ecvBBox.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// LOCAL
#include "CV_db.h"
#include "ecvColorTypes.h"
#include "ecvDrawableObject.h"
#include "ecvGLMatrix.h"
#include "ecvHObject.h"
 
// CV_CORE_LIB
#include <BoundingBox.h>
#include <SquareMatrix.h>
 
 
class CV_DB_LIB_API ccBBox : public ccHObject, public cloudViewer::BoundingBox {
public:
    ccBBox() : ccHObject("ccBBox"), cloudViewer::BoundingBox() {}
 
    ccBBox(const CCVector3& bbMinCorner,
           const CCVector3& bbMaxCorner,
           const std::string& name = "ccBBox")
        : ccHObject(name.c_str()),
          cloudViewer::BoundingBox(bbMinCorner, bbMaxCorner) {}
 
    ccBBox(const Eigen::Vector3d& min_bound,
           const Eigen::Vector3d& max_bound,
           const std::string& name = "ccBBox")
        : ccHObject(name.c_str()),
          cloudViewer::BoundingBox(min_bound, max_bound) {}
 
    explicit ccBBox(const cloudViewer::BoundingBox& bbox,
                    const std::string& name = "ccBBox")
        : ccHObject(name.c_str()), cloudViewer::BoundingBox(bbox) {}
 
    const ccBBox operator*(const ccGLMatrix& mat);
    const ccBBox operator*(const ccGLMatrixd& mat);
 
    ~ccBBox() override = default;
 
    // inherited methods (ccHObject)
    bool isSerializable() const override { return true; }
    CV_CLASS_ENUM getClassID() const override { return CV_TYPES::BBOX; }
    // Returns the entity's own bounding-box
    virtual inline ccBBox getOwnBB(bool withGLFeatures = false) override {
        return *this;
    }
 
public:  // inherited methods (ccHObject)
    // IsEmpty should check if bbox has zero size in all dimensions, not just
    // volume For 2D objects (Z=0), volume=0 but bbox is still valid if X or Y
    // dimension > 0
    inline virtual bool IsEmpty() const override {
        if (!isValid()) return true;
        // Use getMaxBoxDim() which returns the maximum of X, Y, Z extents
        // This correctly handles 2D objects where Z=0 but X or Y > 0
        // A bbox is empty only if all dimensions are zero (or very close to
        // zero)
        return getMaxBoxDim() <= static_cast<PointCoordinateType>(0);
    }
 
    virtual inline Eigen::Vector3d GetMinBound() const override {
        return CCVector3d::fromArray(m_bbMin);
    }
    virtual inline Eigen::Vector3d GetMaxBound() const override {
        return CCVector3d::fromArray(m_bbMax);
    }
    virtual inline Eigen::Vector3d GetCenter() const override {
        return CCVector3d::fromArray(getCenter());
    }
 
    virtual inline ccBBox GetAxisAlignedBoundingBox() const override {
        return *this;
    }
    virtual ecvOrientedBBox GetOrientedBoundingBox() const override;
 
    virtual ccBBox& Transform(const Eigen::Matrix4d& transformation) override;
    virtual ccBBox& Translate(const Eigen::Vector3d& translation,
                              bool relative = true) override;
    virtual ccBBox& Scale(const double s,
                          const Eigen::Vector3d& center) override;
    virtual ccBBox& Rotate(const Eigen::Matrix3d& R,
                           const Eigen::Vector3d& center) override;
 
    const ccBBox& operator+=(const ccBBox& other);
 
    // CCVector3: must override to fix candidate template ignored:
    // could not match 'QStringBuilder' against 'Vector3Tpl
    const ccBBox& operator+=(const CCVector3& V) override;
    const ccBBox& operator-=(const CCVector3& V) override;
    const ccBBox& operator*=(float scaleFactor) override;
    const ccBBox& operator*=(const cloudViewer::SquareMatrix& mat) override;
 
    // Eigen::Vector3d
    const ccBBox& operator+=(const Eigen::Vector3d& V);
    const ccBBox& operator-=(const Eigen::Vector3d& V);
    const ccBBox& operator*=(double scaleFactor);
    const ccBBox& operator*=(const Eigen::Matrix3d& mat);
 
public:
    // Inherited from ccHObject - override to avoid hiding base class method
    void draw(CC_DRAW_CONTEXT& context) override;
 
 
    void draw(CC_DRAW_CONTEXT& context, const ecvColor::Rgb& col);
 
    std::string GetPrintInfo() const;
 
    inline void SetMinBounds(const Eigen::Vector3d& minBound) {
        m_bbMin = minBound;
    }
    inline void SetMaxBounds(const Eigen::Vector3d& maxBound) {
        m_bbMax = maxBound;
    }
 
    static ccBBox CreateFromPoints(const std::vector<CCVector3>& points);
 
    static ccBBox CreateFromPoints(const std::vector<Eigen::Vector3d>& points);
 
    inline Eigen::Vector3d GetExtent() const {
        return CCVector3d::fromArray(getDiagVec());
    }
 
    Eigen::Vector3d GetHalfExtent() const { return GetExtent() * 0.5; }
 
    inline PointCoordinateType GetMaxExtent() const {
        return (m_bbMax - m_bbMin).maxCoeff();
    }
 
    std::vector<Eigen::Vector3d> GetBoxPoints() const;
};