ecv2DLabel.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 "ecvGenericDisplayTools.h"
#include "ecvHObject.h"
#include "ecvInteractor.h"
 
// Qt
#include <QRect>
 
class ccGenericMesh;
class ccGenericPointCloud;
 
class CV_DB_LIB_API cc2DLabel : public ccHObject, public ccInteractor {
public:
    cc2DLabel(QString name = QString("label"));
 
    // inherited from ccObject
    virtual QString getName() const override;
    // inherited from ccHObject
    inline virtual CV_CLASS_ENUM getClassID() const override {
        return CV_TYPES::LABEL_2D;
    }
    inline virtual bool isSerializable() const override { return true; }
 
    inline QString getRawName() const { return m_name; }
 
 
    QStringList getLabelContent(int precision) const;
 
 
    QString getTitle(int precision) const;
 
    // inherited from ccInteractor
    virtual bool acceptClick(int x, int y, Qt::MouseButton button) override;
    virtual bool move2D(int x,
                        int y,
                        int dx,
                        int dy,
                        int screenWidth,
                        int screenHeight) override;
 
    void setPosition(float x, float y);
 
    inline const float* getPosition() const { return m_screenPos; }
 
    void clear(bool ignoreDependencies = false, bool ignoreCaption = true);
 
    void clearLabel(bool ignoreCaption = true);
    void updateLabel();
    void update3DLabelView(CC_DRAW_CONTEXT& context, bool updateScreen = true);
    void update2DLabelView(CC_DRAW_CONTEXT& context, bool updateScreen = true);
 
    inline unsigned size() const {
        return static_cast<unsigned>(m_pickedPoints.size());
    }
 
 
    bool addPickedPoint(ccGenericPointCloud* cloud,
                        unsigned pointIndex,
                        bool entityCenter = false);
 
 
    bool addPickedPoint(ccGenericMesh* mesh,
                        unsigned triangleIndex,
                        const CCVector2d& uv,
                        bool entityCenter = false);
 
    inline void setCollapsed(bool state) { m_showFullBody = !state; }
 
    inline bool isCollapsed() const { return !m_showFullBody; }
 
    inline void displayPointLegend(bool state) { m_dispPointsLegend = state; }
 
    inline bool isPointLegendDisplayed() const { return m_dispPointsLegend; }
 
    inline void setDisplayedIn2D(bool state) { m_dispIn2D = state; }
 
    inline bool isDisplayedIn2D() const { return m_dispIn2D; }
 
 
    struct CV_DB_LIB_API PickedPoint {
        ccGenericPointCloud* cloud;
        ccGenericMesh* mesh;
        unsigned index;
 
        CCVector3d pos2D;
        float markerScale;
        CCVector2d uv;
        bool entityCenterPoint;
 
        CCVector3 getPointPosition() const;
        ccGenericPointCloud* cloudOrVertices() const;
        unsigned getUniqueID() const;
        ccHObject* entity() const;
        QString itemTitle() const;
        QString prefix(const char* pointTag) const;
 
        PickedPoint()
            : cloud(nullptr),
              mesh(nullptr),
              index(0),
              pos2D(0, 0, 0),
              markerScale(0),
              uv(0, 0),
              entityCenterPoint(false) {}
 
        PickedPoint(ccGenericPointCloud* _cloud,
                    unsigned pointIndex,
                    bool centerPoint = false)
            : cloud(_cloud),
              mesh(nullptr),
              index(pointIndex),
              pos2D(0, 0, 0),
              markerScale(0),
              uv(0, 0),
              entityCenterPoint(centerPoint) {}
 
        PickedPoint(ccGenericMesh* _mesh,
                    unsigned triIindex,
                    const CCVector2d& _uv,
                    bool centerPoint = false)
            : cloud(nullptr),
              mesh(_mesh),
              index(triIindex),
              pos2D(0, 0, 0),
              markerScale(0),
              uv(_uv),
              entityCenterPoint(centerPoint) {}
    };
 
    bool addPickedPoint(const PickedPoint& pp);
 
    inline const PickedPoint& getPickedPoint(unsigned index) const {
        return m_pickedPoints[index];
    }
    inline PickedPoint& getPickedPoint(unsigned index) {
        return m_pickedPoints[index];
    }
 
 
    inline void setRelativeMarkerScale(float scale) {
        m_relMarkerScale = scale;
    }
 
    bool pointPicking(const CCVector2d& clickPos,
                      const ccGLCameraParameters& camera,
                      int& nearestPointIndex,
                      double& nearestSquareDist) const;
 
protected:
    struct LabelInfo1 {
        unsigned pointIndex;
        ccGenericPointCloud* cloud;
        bool hasNormal;
        CCVector3 normal;
        bool hasRGB;
        ecvColor::Rgb rgb;
        bool hasSF;
        ScalarType sfValue;
        double sfShiftedValue;
        bool sfValueIsShifted;
        QString sfName;
        LabelInfo1()
            : pointIndex(0),
              cloud(0),
              hasNormal(false),
              normal(0, 0, 0),
              hasRGB(false),
              rgb(0, 0, 0),
              hasSF(false),
              sfValue(0),
              sfShiftedValue(0),
              sfValueIsShifted(false) {}
    };
 
    void getLabelInfo1(LabelInfo1& info) const;
 
 
    static QString GetSFValueAsString(const LabelInfo1& info, int precision);
 
    struct LabelInfo2 {
        unsigned point1Index;
        ccGenericPointCloud* cloud1;
        unsigned point2Index;
        ccGenericPointCloud* cloud2;
        CCVector3 diff;
        LabelInfo2()
            : point1Index(0),
              cloud1(0),
              point2Index(0),
              cloud2(0),
              diff(0, 0, 0) {}
    };
    void getLabelInfo2(LabelInfo2& info) const;
 
    struct LabelInfo3 {
        unsigned point1Index;
        ccGenericPointCloud* cloud1;
        unsigned point2Index;
        ccGenericPointCloud* cloud2;
        unsigned point3Index;
        ccGenericPointCloud* cloud3;
        CCVector3 normal;
        PointCoordinateType area;
        CCVector3d angles;
        CCVector3d edges;
        LabelInfo3()
            : point1Index(0),
              cloud1(0),
              point2Index(0),
              cloud2(0),
              point3Index(0),
              cloud3(0),
              normal(0, 0, 0),
              area(0),
              angles(0, 0, 0),
              edges(0, 0, 0) {}
    };
    void getLabelInfo3(LabelInfo3& info) const;
 
    // inherited from ccHObject
    bool toFile_MeOnly(QFile& out, short dataVersion) const override;
    short minimumFileVersion_MeOnly() const override;
    bool fromFile_MeOnly(QFile& in,
                         short dataVersion,
                         int flags,
                         LoadedIDMap& oldToNewIDMap) override;
    virtual void drawMeOnly(CC_DRAW_CONTEXT& context) override;
    virtual void onDeletionOf(const ccHObject* obj) override;
 
    void drawMeOnly2D(CC_DRAW_CONTEXT& context);
    void clear2Dviews();
    void drawMeOnly3D(CC_DRAW_CONTEXT& context);
 
    void clear3Dviews();
 
    std::vector<PickedPoint> m_pickedPoints;
 
    void updateName();
 
    bool m_showFullBody;
 
 
    QRect m_labelROI;
 
    QStringList m_historyMessage;
 
    // int m_closeButtonROI[4];
 
    float m_screenPos[2];
 
    int m_lastScreenPos[2];
 
    bool m_dispPointsLegend;
 
    bool m_dispIn2D;
 
    float m_relMarkerScale;
 
    QString m_sphereIdfix;
    QString m_surfaceIdfix;
    QString m_contourIdfix;
    QString m_lineID;
};