ecvPolyline.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 <Polyline.h>
 
// Local
#include "CV_db.h"
#include "ecvShiftedObject.h"
 
class ccPointCloud;
class ccGenericPointCloud;
 
 
class CV_DB_LIB_API ccPolyline : public cloudViewer::Polyline,
                                 public ccShiftedObject {
public:
 
    explicit ccPolyline(GenericIndexedCloudPersist* associatedCloud);
    explicit ccPolyline(ccPointCloud& associatedCloud);
 
 
    ccPolyline(const ccPolyline& poly);
 
    virtual ~ccPolyline() override = default;
 
    virtual CV_CLASS_ENUM getClassID() const override {
        return CV_TYPES::POLY_LINE;
    }
 
    // inherited methods (ccHObject)
    virtual bool isSerializable() const override { return true; }
    virtual void applyGLTransformation(const ccGLMatrix& trans) override;
    virtual unsigned getUniqueIDForDisplay() const override;
 
    // inherited methods (ccDrawableObject)
    virtual bool hasColors() const override;
 
    // inherited methods (ccShiftedObject)
    virtual void setGlobalShift(const CCVector3d& shift) override;
    virtual void setGlobalScale(double scale) override;
 
 
    void set2DMode(bool state);
 
    inline bool is2DMode() const { return m_mode2D; }
 
 
    void setTransformFlag(bool state) { m_needTransform = state; };
 
    inline bool needTransform() const { return m_needTransform; }
 
 
    void setForeground(bool state);
 
 
    inline void setColor(const ecvColor::Rgb& col) {
        enableTempColor(false);
        m_rgbColor = col;
    }
 
 
    void setWidth(PointCoordinateType width);
 
 
    inline PointCoordinateType getWidth() const { return m_width; }
 
 
    inline const ecvColor::Rgb& getColor() const { return m_rgbColor; }
 
    // inherited methods (ccHObject)
    virtual ccBBox getOwnBB(bool withGLFeatures = false) override;
    inline virtual void drawBB(CC_DRAW_CONTEXT& context,
                               const ecvColor::Rgb& col) override {
        // DGM: only for 3D polylines!
        if (!is2DMode()) ccShiftedObject::drawBB(context, col);
    }
 
 
    bool split(PointCoordinateType maxEdgeLength,
               std::vector<ccPolyline*>& parts);
 
 
    bool add(const ccPointCloud& cloud);
 
    PointCoordinateType computeLength() const;
 
    void showVertices(bool state) { m_showVertices = state; }
    bool verticesShown() const { return m_showVertices; }
    bool arrowShown() const { return m_showArrow; }
    unsigned getArrowIndex() const { return m_arrowIndex; }
    PointCoordinateType getArrowLength() const { return m_arrowLength; }
 
    void setVertexMarkerWidth(int width) { m_vertMarkWidth = width; }
    int getVertexMarkerWidth() const { return m_vertMarkWidth; }
 
 
    bool initWith(ccPointCloud* vertices, const ccPolyline& poly);
 
    void importParametersFrom(const ccPolyline& poly);
 
    void showArrow(bool state, unsigned vertIndex, PointCoordinateType length);
 
    unsigned segmentCount() const;
 
    ccPointCloud* samplePoints(bool densityBased,
                               double samplingParameter,
                               bool withRGB);
 
 
    ccPolyline* smoothChaikin(PointCoordinateType ratio,
                              unsigned iterationCount) const;
 
 
    bool createNewPolylinesFromSelection(std::vector<ccPolyline*>& output);
 
    static bool IsCloudVerticesOfPolyline(ccGenericPointCloud* cloud,
                                          ccPolyline** polyline = nullptr);
 
    static ccPolyline* Circle(const CCVector3& center,
                              PointCoordinateType radius,
                              unsigned resolution = 48);
 
    inline virtual bool IsEmpty() const override { return !hasPoints(); }
    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 ccPolyline& Transform(
            const Eigen::Matrix4d& transformation) override;
    virtual ccPolyline& Translate(const Eigen::Vector3d& translation,
                                  bool relative = true) override;
    virtual ccPolyline& Scale(const double s,
                              const Eigen::Vector3d& center) override;
    virtual ccPolyline& Rotate(const Eigen::Matrix3d& R,
                               const Eigen::Vector3d& center) override;
 
    ccPolyline& operator+=(const ccPolyline& polyline);
    ccPolyline& operator=(const ccPolyline& polyline);
    ccPolyline operator+(const ccPolyline& polyline) const;
 
    ccPolyline& PaintUniformColor(const Eigen::Vector3d& color) {
        setColor(ecvColor::Rgb::FromEigen(color));
        return *this;
    }
 
public:  // meta-data keys
 
    static QString MetaKeyUpDir() { return "up.dir"; }
 
    static QString MetaKeyConstAltitude() { return "contour.altitude"; }
    static QString MetaKeyAbscissa() { return "profile.abscissa"; }
 
    static QString MetaKeyPrefixCenter() { return "profile.center"; }
 
    static QString MetaKeyPrefixDirection() { return "profile.direction"; }
 
protected:
    // 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;
 
    // inherited methods (ccHObject)
    virtual void drawMeOnly(CC_DRAW_CONTEXT& context) override;
 
    ecvColor::Rgb m_rgbColor;
 
    PointCoordinateType m_width;
 
    bool m_mode2D;
 
    bool m_needTransform;
 
    bool m_foreground;
 
    bool m_showVertices;
 
    int m_vertMarkWidth;
 
    bool m_showArrow;
    PointCoordinateType m_arrowLength;
    unsigned m_arrowIndex;
};