ecvFacet.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 "ecvHObject.h"
#include "ecvPlanarEntityInterface.h"
 
namespace cloudViewer {
class GenericIndexedCloudPersist;
}
 
class ccMesh;
class ccPolyline;
class ccPointCloud;
 
 
class CV_DB_LIB_API ccFacet : public ccHObject, public ccPlanarEntityInterface {
public:
 
    ccFacet(PointCoordinateType maxEdgeLength = 0,
            QString name = QString("Facet"));
 
    virtual ~ccFacet() override;
 
 
    static ccFacet* Create(cloudViewer::GenericIndexedCloudPersist* cloud,
                           PointCoordinateType maxEdgeLength = 0,
                           bool transferOwnership = false,
                           const PointCoordinateType* planeEquation = nullptr);
 
    virtual CV_CLASS_ENUM getClassID() const override {
        return CV_TYPES::FACET;
    }
    virtual bool isSerializable() const override { return true; }
 
 
    void setColor(const ecvColor::Rgb& rgb);
 
    // inherited from ccPlanarEntityInterface
    inline CCVector3 getNormal() const override {
        return CCVector3(m_planeEquation);
    }
 
    inline double getRMS() const { return m_rms; }
    inline double getSurface() const { return m_surface; }
    inline const PointCoordinateType* getPlaneEquation() const {
        return m_planeEquation;
    }
    void invertNormal();
    inline const CCVector3& getCenter() const { return m_center; }
 
    inline ccMesh* getPolygon() { return m_polygonMesh; }
    inline const ccMesh* getPolygon() const { return m_polygonMesh; }
 
    inline ccPolyline* getContour() { return m_contourPolyline; }
    inline const ccPolyline* getContour() const { return m_contourPolyline; }
 
    inline ccPointCloud* getContourVertices() { return m_contourVertices; }
    inline const ccPointCloud* getContourVertices() const {
        return m_contourVertices;
    }
 
    inline ccPointCloud* getOriginPoints() { return m_originPoints; }
    inline const ccPointCloud* getOriginPoints() const {
        return m_originPoints;
    }
 
    inline void setPolygon(ccMesh* mesh) { m_polygonMesh = mesh; }
    inline void setContour(ccPolyline* poly) { m_contourPolyline = poly; }
    inline void setContourVertices(ccPointCloud* cloud) {
        m_contourVertices = cloud;
    }
    inline void setOriginPoints(ccPointCloud* cloud) { m_originPoints = cloud; }
 
    std::shared_ptr<ccMesh> getNormalVectorMesh(bool update = false);
 
    ccFacet* clone() const;
    bool clone(ccFacet* facet) const;
 
    virtual bool IsEmpty() const override;
    virtual Eigen::Vector3d GetMinBound() const override;
    virtual Eigen::Vector3d GetMaxBound() const override;
    virtual Eigen::Vector3d GetCenter() const override;
    virtual ccBBox GetAxisAlignedBoundingBox() const override;
    virtual ecvOrientedBBox GetOrientedBoundingBox() const override;
    virtual ccFacet& Transform(const Eigen::Matrix4d& transformation) override;
    virtual ccFacet& Translate(const Eigen::Vector3d& translation,
                               bool relative = true) override;
    virtual ccFacet& Scale(const double s,
                           const Eigen::Vector3d& center) override;
    virtual ccFacet& Rotate(const Eigen::Matrix3d& R,
                            const Eigen::Vector3d& center) override;
 
 
    ccFacet(const ccFacet& poly);
 
    ccFacet& operator+=(const ccFacet& polyline);
    ccFacet& operator=(const ccFacet& polyline);
    ccFacet operator+(const ccFacet& polyline) const;
 
    ccFacet& PaintUniformColor(const Eigen::Vector3d& color) {
        setColor(ecvColor::Rgb::FromEigen(color));
        return (*this);
    }
 
protected:
    // inherited from ccDrawable
    virtual void drawMeOnly(CC_DRAW_CONTEXT& context) override;
 
    bool createInternalRepresentation(
            cloudViewer::GenericIndexedCloudPersist* points,
            const PointCoordinateType* planeEquation = nullptr);
 
    std::shared_ptr<ccMesh> m_arrow;
 
    ccMesh* m_polygonMesh;
    ccPolyline* m_contourPolyline;
    ccPointCloud* m_contourVertices;
    ccPointCloud* m_originPoints;
 
    PointCoordinateType m_planeEquation[4];
 
    CCVector3 m_center;
 
    double m_rms;
 
    double m_surface;
 
    PointCoordinateType m_maxEdgeLength;
 
    // 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;
 
    // ccHObject interface
    virtual void applyGLTransformation(const ccGLMatrix& trans) override;
};