ecvHObject.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
 
// CV_CORE_LIB
#include "BoundingBox.h"
 
// Local
#include "ecvColorTypes.h"
#include "ecvDrawableObject.h"
#include "ecvGLMatrix.h"
#include "ecvGenericDisplayTools.h"
#include "ecvObject.h"
 
class QIcon;
class ccBBox;
class ecvOrientedBBox;
 
class CV_DB_LIB_API ccHObject : public ccObject, public ccDrawableObject {
public:  // construction
 
    ccHObject(QString name = QString());
    ccHObject(const ccHObject& object);
 
    virtual ~ccHObject() override;
 
 
    static ccHObject* New(CV_CLASS_ENUM objectType, const char* name = nullptr);
 
 
    static ccHObject* New(const QString& pluginId,
                          const QString& classId,
                          const char* name = nullptr);
 
    static Eigen::Vector3d ComputeMinBound(
            const std::vector<Eigen::Vector3d>& points);
    static Eigen::Vector3d ComputeMaxBound(
            const std::vector<Eigen::Vector3d>& points);
    static Eigen::Vector3d ComputeCenter(
            const std::vector<Eigen::Vector3d>& points);
 
    static void ResizeAndPaintUniformColor(std::vector<Eigen::Vector3d>& colors,
                                           std::size_t size,
                                           const Eigen::Vector3d& color);
 
    static void TransformPoints(const Eigen::Matrix4d& transformation,
                                std::vector<Eigen::Vector3d>& points);
    static void TransformNormals(const Eigen::Matrix4d& transformation,
                                 std::vector<Eigen::Vector3d>& normals);
 
    static void TransformCovariances(const Eigen::Matrix4d& transformation,
                                     std::vector<Eigen::Matrix3d>& covariances);
 
    static void TranslatePoints(const Eigen::Vector3d& translation,
                                std::vector<Eigen::Vector3d>& points,
                                bool relative);
    static void ScalePoints(const double scale,
                            std::vector<Eigen::Vector3d>& points,
                            const Eigen::Vector3d& center);
    static void RotatePoints(const Eigen::Matrix3d& R,
                             std::vector<Eigen::Vector3d>& points,
                             const Eigen::Vector3d& center);
    static void RotateNormals(const Eigen::Matrix3d& R,
                              std::vector<Eigen::Vector3d>& normals);
 
    static void RotateCovariances(const Eigen::Matrix3d& R,
                                  std::vector<Eigen::Matrix3d>& covariances);
 
    // for virtual functions with cloudViewer interface
    virtual bool IsEmpty() const { return true; }
    virtual Eigen::Vector3d GetMinBound() const { return Eigen::Vector3d(); }
    virtual Eigen::Vector2d GetMin2DBound() const { return Eigen::Vector2d(); }
    virtual Eigen::Vector3d GetMaxBound() const { return Eigen::Vector3d(); }
    virtual Eigen::Vector2d GetMax2DBound() const { return Eigen::Vector2d(); }
    virtual Eigen::Vector3d GetCenter() const { return Eigen::Vector3d(); }
 
    virtual ccBBox GetAxisAlignedBoundingBox() const;
    virtual ecvOrientedBBox GetOrientedBoundingBox() const;
 
    virtual ccHObject& Transform(const Eigen::Matrix4d& transformation) {
        return *this;
    }
    virtual ccHObject& Translate(const Eigen::Vector3d& translation,
                                 bool relative = true) {
        return *this;
    }
    virtual ccHObject& Scale(const double s, const Eigen::Vector3d& center) {
        return *this;
    }
    virtual ccHObject& Scale(const double s) { return Scale(s, GetCenter()); }
    virtual ccHObject& Rotate(const Eigen::Matrix3d& R,
                              const Eigen::Vector3d& center) {
        return *this;
    }
    virtual ccHObject& Rotate(const Eigen::Matrix3d& R) {
        return Rotate(R, GetCenter());
    }
 
    static Eigen::Matrix3d GetRotationMatrixFromXYZ(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromYZX(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromZXY(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromXZY(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromZYX(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromYXZ(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromAxisAngle(
            const Eigen::Vector3d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromQuaternion(
            const Eigen::Vector4d& rotation);
    static Eigen::Matrix3d GetRotationMatrixFromEulerAngle(
            const Eigen::Vector3d& rotation);
 
public:  // base members access
    inline QString getViewId() const {
        return QString::number(this->getUniqueID(), 10);
    }
 
 
    inline CV_CLASS_ENUM getClassID() const override {
        return CV_TYPES::HIERARCHY_OBJECT;
    }
 
    inline bool isGroup() const {
        return getClassID() ==
               static_cast<CV_CLASS_ENUM>(CV_TYPES::HIERARCHY_OBJECT);
    }
 
 
    inline ccHObject* getParent() const { return m_parent; }
 
 
    virtual QIcon getIcon() const;
 
public:  // dependencies management
    enum DEPENDENCY_FLAGS {
        DP_NONE = 0,                   
        DP_NOTIFY_OTHER_ON_DELETE = 1, 
        DP_NOTIFY_OTHER_ON_UPDATE =
                2, 
        // DP_NOTIFY_XXX                = 4,
        DP_DELETE_OTHER = 8,     
        DP_PARENT_OF_OTHER = 24, 
    };
 
 
    void addDependency(ccHObject* otherObject, int flags, bool additive = true);
 
 
    int getDependencyFlagsWith(const ccHObject* otherObject);
 
 
    void removeDependencyWith(ccHObject* otherObject);
 
 
    void removeDependencyFlag(ccHObject* otherObject, DEPENDENCY_FLAGS flag);
 
public:  // children management
 
    virtual bool addChild(ccHObject* child,
                          int dependencyFlags = DP_PARENT_OF_OTHER,
                          int insertIndex = -1);
 
 
    inline unsigned getChildrenNumber() const {
        return static_cast<unsigned>(m_children.size());
    }
 
 
    unsigned int getChildCountRecursive() const;
 
 
    inline ccHObject* getChild(unsigned childPos) const {
        return (childPos < getChildrenNumber() ? m_children[childPos]
                                               : nullptr);
    }
 
 
    ccHObject* find(unsigned uniqueID);
 
    using Container = std::vector<ccHObject*>;
 
    using Shared = QSharedPointer<ccHObject>;
 
    using SharedContainer = std::vector<Shared>;
 
 
    unsigned filterChildren(Container& filteredChildren,
                            bool recursive = false,
                            CV_CLASS_ENUM filter = CV_TYPES::OBJECT,
                            bool strict = false) const;
 
 
    void detachChild(ccHObject* child);
 
    void detachAllChildren();
 
    void getTypeID_recursive(std::vector<removeInfo>& rmInfos, bool relative);
    void getTypeID_recursive(std::vector<hideInfo>& hdInfos, bool relative);
 
    void removeChild(ccHObject* child);
 
    void removeChild(int pos);
    void removeAllChildren();
    int getChildIndex(const ccHObject* aChild) const;
    void swapChildren(unsigned firstChildIndex, unsigned secondChildIndex);
    int getIndex() const;
 
    void transferChild(ccHObject* child, ccHObject& newParent);
    void transferChildren(ccHObject& newParent,
                          bool forceFatherDependent = false);
 
    ccHObject* getFirstChild() const {
        return (m_children.empty() ? nullptr : m_children.front());
    }
    ccHObject* getLastChild() const {
        return (m_children.empty() ? nullptr : m_children.back());
    }
 
    bool isAncestorOf(const ccHObject* anObject) const;
 
    void removeFromRenderScreen(bool recursive = true);
 
public:  // bounding-box
    void hideObject_recursive(bool recursive);
    void hideBB(CC_DRAW_CONTEXT context);
    void showBB(CC_DRAW_CONTEXT context);
 
 
    virtual ccBBox getOwnBB(bool withGLFeatures = false);
 
    void setRedrawFlagRecursive(bool redraw = false);
    void setForceRedrawRecursive(bool redraw = false);
 
    void setPointSizeRecursive(int pSize);
    void setLineWidthRecursive(PointCoordinateType width);
 
 
    virtual ccBBox getBB_recursive(bool withGLFeatures = false,
                                   bool onlyEnabledChildren = true);
 
    using GlobalBoundingBox = cloudViewer::BoundingBoxTpl<double>;
 
 
    virtual GlobalBoundingBox getOwnGlobalBB(bool withGLFeatures = false);
 
 
    virtual bool getOwnGlobalBB(CCVector3d& minCorner, CCVector3d& maxCorner);
 
 
    virtual GlobalBoundingBox getGlobalBB_recursive(
            bool withGLFeatures = false, bool onlyEnabledChildren = true);
 
 
    virtual ccBBox getDisplayBB_recursive(bool relative);
 
 
    virtual ccBBox getOwnFitBB(ccGLMatrix& trans);
 
    virtual void drawBB(CC_DRAW_CONTEXT& context, const ecvColor::Rgb& col);
 
public:  // display
    // Inherited from ccDrawableObject
    void draw(CC_DRAW_CONTEXT& context) override;
 
    void updateNameIn3DRecursive();
 
    void setHideShowType(CC_DRAW_CONTEXT& context);
    void setRemoveType(CC_DRAW_CONTEXT& context);
    ENTITY_TYPE getEntityType() const;
 
    virtual void redrawDisplay(bool forceRedraw = true, bool only2D = false);
 
 
    bool getAbsoluteGLTransformation(ccGLMatrix& trans) const;
 
    virtual bool isDisplayed() const;
 
    virtual bool isBranchEnabled() const;
 
/*** RECURSIVE CALL SCRIPTS ***/
 
// 0 parameter
#define ccHObject_recursive_call0(baseName, recursiveName) \
    inline virtual void recursiveName() {                  \
        baseName();                                        \
        for (Container::iterator it = m_children.begin();  \
             it != m_children.end(); ++it)                 \
            (*it)->recursiveName();                        \
    }
 
// 1 parameter
#define ccHObject_recursive_call1(baseName, param1Type, recursiveName) \
    inline virtual void recursiveName(param1Type p) {                  \
        baseName(p);                                                   \
        for (Container::iterator it = m_children.begin();              \
             it != m_children.end(); ++it)                             \
            (*it)->recursiveName(p);                                   \
    }
 
    ccHObject_recursive_call1(redrawDisplay, bool, redrawDisplay_recursive) ccHObject_recursive_call1(
            redrawDisplay,
            bool,
            refreshDisplay_recursive) ccHObject_recursive_call1(setSelected,
                                                                bool,
                                                                setSelected_recursive)
            ccHObject_recursive_call0(toggleActivation,
                                      toggleActivation_recursive)
                    ccHObject_recursive_call0(toggleVisibility,
                                              toggleVisibility_recursive)
                            ccHObject_recursive_call0(toggleColors,
                                                      toggleColors_recursive)
                                    ccHObject_recursive_call0(
                                            resetGLTransformationHistory,
                                            resetGLTransformationHistory_recursive)
                                            ccHObject_recursive_call0(
                                                    toggleNormals,
                                                    toggleNormals_recursive)
                                                    ccHObject_recursive_call0(
                                                            toggleSF,
                                                            toggleSF_recursive)
                                                            ccHObject_recursive_call0(
                                                                    toggleShowName,
                                                                    toggleShowName_recursive);
 
    unsigned findMaxUniqueID_recursive() const;
 
 
    void applyGLTransformation_recursive(const ccGLMatrix* trans = nullptr);
 
    virtual void notifyGeometryUpdate();
 
    // inherited from ccSerializableObject
    bool isSerializable() const override;
    bool toFile(QFile& out, short dataVersion) const override;
    bool fromFile(QFile& in,
                  short dataVersion,
                  int flags,
                  LoadedIDMap& oldToNewIDMap) override;
    short minimumFileVersion() const override;
 
 
    bool fromFileNoChildren(QFile& in,
                            short dataVersion,
                            int flags,
                            LoadedIDMap& oldToNewIDMap);
 
 
    virtual inline bool isShareable() const { return false; }
 
    enum SelectionBehavior {
        SELECTION_AA_BBOX,
        SELECTION_FIT_BBOX,
        SELECTION_IGNORED
    };
 
 
    virtual inline void setSelectionBehavior(SelectionBehavior mode) {
        m_selectionBehavior = mode;
    }
 
    virtual inline SelectionBehavior getSelectionBehavior() const {
        return m_selectionBehavior;
    }
 
    virtual inline unsigned getUniqueIDForDisplay() const {
        return getUniqueID();
    }
 
    virtual inline const ccGLMatrix& getGLTransformationHistory() const {
        return m_glTransHistory;
    }
    virtual inline void setGLTransformationHistory(const ccGLMatrix& mat) {
        m_glTransHistory = mat;
    }
    virtual inline void resetGLTransformationHistory() {
        m_glTransHistory.toIdentity();
    }
 
public:
    bool pushDisplayState() override;
 
    void popDisplayState(bool apply = true) override;
 
protected:
    virtual inline void setParent(ccHObject* anObject) { m_parent = anObject; }
 
    virtual void drawMeOnly(
            CC_DRAW_CONTEXT& context) { /*does nothing by default*/ }
 
 
    virtual void applyGLTransformation(const ccGLMatrix& trans);
 
 
    virtual bool toFile_MeOnly(QFile& out, short dataVersion) const;
 
 
    virtual bool fromFile_MeOnly(QFile& in,
                                 short dataVersion,
                                 int flags,
                                 LoadedIDMap& oldToNewIDMap);
 
 
    virtual short minimumFileVersion_MeOnly() const;
 
 
    virtual void drawNameIn3D();
 
 
    virtual void onDeletionOf(const ccHObject* obj);
 
 
    virtual void onUpdateOf(ccHObject* obj) { /*does nothing by default*/ }
 
    ccHObject* m_parent;
 
    Container m_children;
 
    SelectionBehavior m_selectionBehavior;
 
 
    std::map<ccHObject*, int> m_dependencies;
 
 
    ccGLMatrix m_glTransHistory;
 
    bool m_isDeleting;
};
 
/*** Helpers ***/
 
 
inline void ConvertToGroup(const ccHObject::Container& origin,
                           ccHObject& dest,
                           int dependencyFlags = ccHObject::DP_NONE) {
    size_t count = origin.size();
    for (size_t i = 0; i < count; ++i) {
        // we don't take objects that are siblings of others
        bool isSiblingOfAnotherOne = false;
        for (size_t j = 0; j < count; ++j) {
            if (i != j && origin[j]->isAncestorOf(origin[i])) {
                isSiblingOfAnotherOne = true;
                break;
            }
        }
 
        if (!isSiblingOfAnotherOne) {
            dest.addChild(origin[i], dependencyFlags);
        }
    }
}