ecvPointCloud.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
 
#ifdef _MSC_VER
// To get rid of the warnings about dominant inheritance
#pragma warning(disable : 4250)
#endif
 
// cloudViewer
#include <PointCloudTpl.h>
 
// Local
#include "ecvColorScale.h"
#include "ecvKDTreeSearchParam.h"
#include "ecvNormalVectors.h"
#include "ecvWaveform.h"
 
// Qt
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
#include <QOpenGLBuffer>
#define QGLBuffer QOpenGLBuffer
#else
#include <QGLBuffer>
#endif
 
class ccMesh;
class QGLBuffer;
class ccPolyline;
class ccScalarField;
class ccGenericPrimitive;
class ecvOrientedBBox;
class ccPointCloudLOD;
class ecvProgressDialog;
 
namespace cloudViewer {
namespace geometry {
class Image;
class RGBDImage;
class VoxelGrid;
 
#ifdef CV_RANSAC_SUPPORT
class CV_DB_LIB_API RansacParams {
public:
    enum RANSAC_PRIMITIVE_TYPES {
        RPT_PLANE = 0,
        RPT_SPHERE = 1,
        RPT_CYLINDER = 2,
        RPT_CONE = 3,
        RPT_TORUS = 4,
    };
 
public:
    float epsilon;           // distance threshold
    float bitmapEpsilon;     // bitmap resolution
    unsigned supportPoints;  // this is the minimal numer of points required for
                             // a primitive
    float maxNormalDev_deg;  // maximal normal deviation from ideal shape (in
                             // degrees)
    float probability;  // probability that no better candidate was overlooked
                        // during sampling
    bool randomColor;   // should the resulting detected shapes sub point cloud
                        // be colored randomly
    std::vector<RANSAC_PRIMITIVE_TYPES> primEnabled;  // RANSAC_PRIMITIVE_TYPES
    float minRadius;  // minimum radius threshold
    float maxRadius;  // maximum radius threshold
    RansacParams()
        : epsilon(0.005f),
          bitmapEpsilon(0.01f),
          supportPoints(500),
          maxNormalDev_deg(25.0f),
          probability(0.01f),
          randomColor(true),
          minRadius(0.0000001f),
          maxRadius(1000000.0f) {
        primEnabled.push_back(RPT_PLANE);
        primEnabled.push_back(RPT_SPHERE);
        primEnabled.push_back(RPT_CYLINDER);
    }
 
    RansacParams(float scale)
        : epsilon(0.005f * scale),
          bitmapEpsilon(0.01f * scale),
          supportPoints(500),
          maxNormalDev_deg(25.0f),
          probability(0.01f),
          randomColor(true),
          minRadius(0.0000001f),
          maxRadius(1000000.0f) {
        primEnabled.push_back(RPT_PLANE);
        primEnabled.push_back(RPT_SPHERE);
        primEnabled.push_back(RPT_CYLINDER);
    }
};
 
class CV_DB_LIB_API RansacResult {
public:
    std::string getTypeName() const;
    unsigned getDrawingPrecision() const;
    bool setDrawingPrecision(unsigned steps);
 
public:
    std::vector<size_t> indices;
    std::shared_ptr<ccGenericPrimitive> primitive = nullptr;
};
 
using RansacResults = std::vector<RansacResult>;
#endif
 
}  // namespace geometry
 
namespace camera {
class PinholeCameraIntrinsic;
}
}  // namespace cloudViewer
 
/***************************************************
                                ccPointCloud
***************************************************/
 
#if defined(CV_ENV_32)
const unsigned CC_MAX_NUMBER_OF_POINTS_PER_CLOUD = 128000000;
#else  // CV_ENV_64 (but maybe CC_ENV_128 one day ;)
const unsigned CC_MAX_NUMBER_OF_POINTS_PER_CLOUD =
        2000000000;  // we must keep it below MAX_INT to avoid probable issues
                     // ;)
#endif
 
 
class CV_DB_LIB_API ccPointCloud
    : public cloudViewer::PointCloudTpl<ccGenericPointCloud> {
public:
    using BaseClass = cloudViewer::PointCloudTpl<ccGenericPointCloud>;
 
 
    ccPointCloud(QString name = QString()) throw();
    ccPointCloud(const ccPointCloud& cloud);
    ccPointCloud(const std::vector<Eigen::Vector3d>& points,
                 const std::string& name = "cloud");
 
    ~ccPointCloud() override;
 
    CV_CLASS_ENUM getClassID() const override { return CV_TYPES::POINT_CLOUD; }
 
public:  // clone, copy, etc.
 
    static ccPointCloud* From(const cloudViewer::GenericIndexedCloud* cloud,
                              const ccGenericPointCloud* sourceCloud = nullptr);
 
 
    static ccPointCloud* From(cloudViewer::GenericCloud* cloud,
                              const ccGenericPointCloud* sourceCloud = nullptr);
 
    static ccPointCloud* From(const ccPointCloud* sourceCloud,
                              const std::vector<size_t>& indices,
                              bool invert = false);
 
    enum CLONE_WARNINGS {
        WRN_OUT_OF_MEM_FOR_COLORS = 1,
        WRN_OUT_OF_MEM_FOR_NORMALS = 2,
        WRN_OUT_OF_MEM_FOR_SFS = 4,
        WRN_OUT_OF_MEM_FOR_FWF = 8
    };
 
 
    ccPointCloud* partialClone(const cloudViewer::ReferenceCloud* selection,
                               int* warnings = nullptr,
                               bool withChildEntities = true) const;
 
 
    ccPointCloud* cloneThis(ccPointCloud* destCloud = nullptr,
                            bool ignoreChildren = false);
 
    // inherited from ccGenericPointCloud
    ccGenericPointCloud* clone(ccGenericPointCloud* destCloud = nullptr,
                               bool ignoreChildren = false) override;
 
 
    ccPointCloud& operator=(const ccPointCloud& cloud);
    const ccPointCloud& operator+=(const ccPointCloud& cloud);
    const ccPointCloud& operator+=(ccPointCloud*);
    ccPointCloud operator+(const ccPointCloud& cloud) const {
        return (ccPointCloud(*this) += cloud);
    }
 
public:  // features deletion/clearing
 
    void clear() override;
 
 
    void unalloactePoints();
 
    void unallocateColors();
 
    void unallocateNorms();
 
    inline void colorsHaveChanged() {
        m_vboManager.updateFlags |= vboSet::UPDATE_COLORS;
    }
    inline void normalsHaveChanged() {
        m_vboManager.updateFlags |= vboSet::UPDATE_NORMALS;
    }
    inline void pointsHaveChanged() {
        m_vboManager.updateFlags |= vboSet::UPDATE_POINTS;
    }
 
public:  // features allocation/resize
 
    bool reserve(unsigned numberOfPoints) override;
 
 
    bool reserveThePointsTable(unsigned _numberOfPoints);
 
 
    bool reserveTheRGBTable();
 
 
    bool reserveTheNormsTable();
 
 
    bool resize(unsigned numberOfPoints) override;
 
 
    bool resizeTheRGBTable(bool fillWithWhite = false);
 
 
    bool resizeTheNormsTable();
 
    inline void shrinkToFit() {
        if (size() < capacity()) resize(size());
    }
 
public:  // scalar-fields management
    ccScalarField* getCurrentDisplayedScalarField() const;
    int getCurrentDisplayedScalarFieldIndex() const;
 
    void setCurrentDisplayedScalarField(int index);
 
    // inherited from base class
    void deleteScalarField(int index) override;
    void deleteAllScalarFields() override;
    int addScalarField(const char* uniqueName) override;
 
    bool sfColorScaleShown() const;
    void showSFColorsScale(bool state);
 
public:  // associated (scan) grid structure
    struct CV_DB_LIB_API Grid : public ccSerializableObject {
        using Shared = QSharedPointer<Grid>;
 
        Grid();
 
 
        Grid(const Grid& grid) = default;
 
        bool init(unsigned rowCount, unsigned colCount, bool withRGB = false);
 
        void setIndex(unsigned row, unsigned col, int index);
 
        void setColor(unsigned row, unsigned col, const ecvColor::Rgb& rgb);
 
        void updateMinAndMaxValidIndexes();
 
        QImage toImage() const;
 
        // inherited from ccSerializableObject
        inline bool isSerializable() const override { return true; }
        bool toFile(QFile& out, short dataVersion) const override;
        bool fromFile(QFile& in,
                      short dataVersion,
                      int flags,
                      LoadedIDMap& oldToNewIDMap) override;
        short minimumFileVersion() const override;
 
        unsigned w;
        unsigned h;
 
        unsigned validCount;
        unsigned minValidIndex;
        unsigned maxValidIndex;
 
        std::vector<int> indexes;
        std::vector<ecvColor::Rgb> colors;
 
        ccGLMatrixd sensorPosition;
    };
 
    size_t gridCount() const { return m_grids.size(); }
    inline Grid::Shared& grid(size_t gridIndex) { return m_grids[gridIndex]; }
    inline const Grid::Shared& grid(size_t gridIndex) const {
        return m_grids[gridIndex];
    }
    inline bool addGrid(Grid::Shared grid) {
        try {
            m_grids.push_back(grid);
        } catch (const std::bad_alloc&) {
            return false;
        }
        return true;
    }
    inline void removeGrids() { m_grids.resize(0); }
 
 
    ccMesh* triangulateGrid(const Grid& grid,
                            double minTriangleAngle_deg = 0.0) const;
 
public:  // normals computation/orientation
 
    bool computeNormalsWithGrids(double minTriangleAngle_deg = 1.0,
                                 ecvProgressDialog* pDlg = nullptr);
 
    bool orientNormalsWithGrids(ecvProgressDialog* pDlg = nullptr);
 
    bool orientNormalsTowardViewPoint(CCVector3& VP,
                                      ecvProgressDialog* pDlg = nullptr);
 
    bool computeNormalsWithOctree(
            CV_LOCAL_MODEL_TYPES model,
            ccNormalVectors::Orientation preferredOrientation,
            PointCoordinateType defaultRadius,
            ecvProgressDialog* pDlg = nullptr);
 
    bool orientNormalsWithMST(unsigned kNN = 6,
                              ecvProgressDialog* pDlg = nullptr);
 
    bool orientNormalsWithFM(unsigned char level,
                             ecvProgressDialog* pDlg = nullptr);
 
public:  // waveform (e.g. from airborne scanners)
    bool hasFWF() const;
 
    ccWaveformProxy waveformProxy(unsigned index) const;
 
    using FWFDescriptorSet = QMap<uint8_t, WaveformDescriptor>;
 
    using FWFDataContainer = std::vector<uint8_t>;
    using SharedFWFDataContainer = QSharedPointer<const FWFDataContainer>;
 
    FWFDescriptorSet& fwfDescriptors() { return m_fwfDescriptors; }
    const FWFDescriptorSet& fwfDescriptors() const { return m_fwfDescriptors; }
 
    std::vector<ccWaveform>& waveforms() { return m_fwfWaveforms; }
    const std::vector<ccWaveform>& waveforms() const { return m_fwfWaveforms; }
 
    bool reserveTheFWFTable();
    bool resizeTheFWFTable();
 
    SharedFWFDataContainer& fwfData() { return m_fwfData; }
    const SharedFWFDataContainer& fwfData() const { return m_fwfData; }
 
 
    bool compressFWFData();
 
    bool computeFWFAmplitude(double& minVal,
                             double& maxVal,
                             ecvProgressDialog* pDlg = nullptr) const;
 
    void clearFWFData();
 
public:  // other methods
 
    CCVector3 computeGravityCenter();
 
    // inherited from base class
    void invalidateBoundingBox() override;
 
    // inherited from ccHObject
    void getDrawingParameters(glDrawParams& params) const override;
    unsigned getUniqueIDForDisplay() const override;
 
    // inherited from ccDrawableObject
    bool hasColors() const override;
    bool hasNormals() const override;
    bool hasScalarFields() const override;
    bool hasDisplayedScalarField() const override;
 
    // inherited from cloudViewer::GenericCloud
    unsigned char testVisibility(const CCVector3& P) const override;
 
    // inherited from cloudViewer::GenericIndexedCloud
    bool normalsAvailable() const override { return hasNormals(); }
    const CCVector3* getNormal(unsigned pointIndex) const
            override;  // equivalent to getPointNormal, but for cloudViewer
 
    // inherited from ccGenericPointCloud
    const ecvColor::Rgb* getScalarValueColor(ScalarType d) const override;
    const ecvColor::Rgb* getPointScalarValueColor(
            unsigned pointIndex) const override;
    ScalarType getPointDisplayedDistance(unsigned pointIndex) const override;
 
    const ecvColor::Rgb& getPointColor(unsigned pointIndex) const override;
    const ColorsTableType& getPointColors() const { return *rgbColors(); }
    ecvColor::Rgb& getPointColorPtr(size_t pointIndex);
    Eigen::Vector3d getEigenColor(size_t index) const;
    std::vector<Eigen::Vector3d> getEigenColors() const;
    void setEigenColors(const std::vector<Eigen::Vector3d>& colors);
 
    const CompressedNormType& getPointNormalIndex(
            unsigned pointIndex) const override;
    const CCVector3& getPointNormal(unsigned pointIndex) const override;
    CCVector3& getPointNormalPtr(size_t pointIndex) const;
    std::vector<CCVector3> getPointNormals() const;
    std::vector<CCVector3*> getPointNormalsPtr() const;
    void setPointNormals(const std::vector<CCVector3>& normals);
    Eigen::Vector3d getEigenNormal(size_t index) const;
    std::vector<Eigen::Vector3d> getEigenNormals() const;
    void setEigenNormals(const std::vector<Eigen::Vector3d>& normals);
 
    cloudViewer::ReferenceCloud* crop(const ccBBox& box,
                                      bool inside = true) override;
    cloudViewer::ReferenceCloud* crop(const ecvOrientedBBox& bbox) override;
 
    virtual void applyRigidTransformation(const ccGLMatrix& trans) override;
    virtual void scale(PointCoordinateType fx,
                       PointCoordinateType fy,
                       PointCoordinateType fz,
                       CCVector3 center = CCVector3(0, 0, 0)) override;
    inline void refreshBB() override { invalidateBoundingBox(); }
    ccGenericPointCloud* createNewCloudFromVisibilitySelection(
            bool removeSelectedPoints = false,
            VisibilityTableType* visTable = nullptr,
            std::vector<int>* newIndexesOfRemainingPoints = nullptr,
            bool silent = false,
            cloudViewer::ReferenceCloud* selection = nullptr) override;
    bool removeVisiblePoints(VisibilityTableType* visTable = nullptr,
                             std::vector<int>* newIndexes = nullptr) override;
 
    inline void enableVisibilityCheck(bool state) {
        m_visibilityCheckEnabled = state;
    }
 
    bool hasSensor() const;
 
 
    QSharedPointer<cloudViewer::ReferenceCloud> computeCPSet(
            ccGenericPointCloud& otherCloud,
            cloudViewer::GenericProgressCallback* progressCb = nullptr,
            unsigned char octreeLevel = 0);
 
    bool interpolateColorsFrom(
            ccGenericPointCloud* cloud,
            cloudViewer::GenericProgressCallback* progressCb = nullptr,
            unsigned char octreeLevel = 0);
 
 
    void setPointColor(size_t pointIndex, const ecvColor::Rgb& col);
    void setPointColor(size_t pointIndex, const ecvColor::Rgba& col);
    void setPointColor(size_t pointIndex, const Eigen::Vector3d& col);
    void setEigenColor(size_t index, const Eigen::Vector3d& color);
 
 
    void setPointNormalIndex(size_t pointIndex, CompressedNormType norm);
 
 
    void setPointNormal(size_t pointIndex, const CCVector3& N);
    void setEigenNormal(size_t index, const Eigen::Vector3d& normal);
 
 
    void addNormIndex(CompressedNormType index);
 
 
    void addNorm(const CCVector3& N);
    void addEigenNorm(const Eigen::Vector3d& N);
    void addEigenNorms(const std::vector<Eigen::Vector3d>& normals);
 
    void addNorms(const std::vector<CCVector3>& Ns);
    void addNorms(const std::vector<CompressedNormType>& idxes);
    std::vector<CompressedNormType> getNorms() const;
    void getNorms(std::vector<CompressedNormType>& idxes) const;
 
 
    void addNormAtIndex(const PointCoordinateType* N, unsigned index);
 
    void setNormsTable(NormsIndexesTableType* norms);
 
 
    bool convertNormalToRGB();
 
 
    bool convertNormalToDipDirSFs(ccScalarField* dipSF,
                                  ccScalarField* dipDirSF);
 
 
    void addRGBColor(const ecvColor::Rgb& C);
    void addRGBColors(const std::vector<ecvColor::Rgb>& colors);
    void addEigenColor(const Eigen::Vector3d& color);
    void addEigenColors(const std::vector<Eigen::Vector3d>& colors);
 
 
    inline void addRGBColor(ColorCompType r, ColorCompType g, ColorCompType b) {
        addRGBColor(ecvColor::Rgb(r, g, b));
    }
 
 
    inline void addGreyColor(ColorCompType g) {
        addRGBColor(ecvColor::Rgb(g, g, g));
    }
 
 
    bool convertRGBToGreyScale();
 
 
    bool colorize(float r, float g, float b);
 
 
    bool setRGBColorByHeight(unsigned char heightDim,
                             ccColorScale::Shared colorScale);
 
 
    bool setRGBColorByBanding(unsigned char dim, double freq);
 
 
    bool convertCurrentScalarFieldToColors(bool mixWithExistingColor = false);
 
 
    bool setRGBColorWithCurrentScalarField(bool mixWithExistingColor = false);
 
 
    inline bool setRGBColor(ColorCompType r, ColorCompType g, ColorCompType b) {
        return setRGBColor(ecvColor::Rgb(r, g, b));
    }
 
 
    bool setRGBColor(const ecvColor::Rgb& col);
 
    enum RGB_FILTER_TYPES { NONE, BILATERAL, GAUSSIAN, MEAN, MEDIAN };
 
    struct RgbFilterOptions {
        bool applyToSFduringRGB = false;
        RGB_FILTER_TYPES filterType = RGB_FILTER_TYPES::NONE;
        unsigned char burntOutColorThreshold = 0;
        bool commandLine = false;
        double sigmaSF = -1;
        double spatialSigma = -1;
        bool blendGrayscale = false;
        unsigned char blendGrayscaleThreshold = 0;
        double blendGrayscalePercent = 0.5;
    };
 
 
    bool applyFilterToRGB(
            PointCoordinateType sigma,
            PointCoordinateType sigmaSF,
            RgbFilterOptions filterParams,
            cloudViewer::GenericProgressCallback* progressCb = nullptr);
 
    void invertNormals();
 
 
    ccPointCloud* filterPointsByScalarValue(ScalarType minVal,
                                            ScalarType maxVal,
                                            bool outside = false);
 
 
    ccPointCloud* filterPointsByScalarValue(std::vector<ScalarType> values,
                                            bool outside = false);
 
 
    void hidePointsByScalarValue(ScalarType minVal, ScalarType maxVal);
 
 
    void hidePointsByScalarValue(std::vector<ScalarType> values);
 
    enum UnrollMode {
        CYLINDER = 0,
        CONE = 1,
        STRAIGHTENED_CONE = 2,
        STRAIGHTENED_CONE2 = 3
    };
 
    struct UnrollBaseParams {
        PointCoordinateType
                radius;  
        unsigned char
                axisDim;  
    };
    struct UnrollCylinderParams : public UnrollBaseParams {
        CCVector3 center;  
    };
    struct UnrollConeParams : public UnrollBaseParams {
        CCVector3 apex;        
        double coneAngle_deg;  
    };
 
 
    ccPointCloud* unroll(
            UnrollMode mode,
            UnrollBaseParams* params,
            bool exportDeviationSF = false,
            double startAngle_deg = 0.0,
            double stopAngle_deg = 360.0,
            cloudViewer::GenericProgressCallback* progressCb = nullptr) const;
 
    void addColorRampInfo(CC_DRAW_CONTEXT& context);
 
 
    int addScalarField(ccScalarField* sf);
 
    ColorsTableType* rgbColors() const { return m_rgbColors; }
 
    NormsIndexesTableType* normals() const { return m_normals; }
 
 
    cloudViewer::ReferenceCloud* crop2D(const ccPolyline* poly,
                                        unsigned char orthoDim,
                                        bool inside = true);
 
 
    const ccPointCloud& append(ccPointCloud* cloud,
                               unsigned pointCountBefore,
                               bool ignoreChildren = false);
 
    bool enhanceRGBWithIntensitySF(int sfIdx,
                                   bool useCustomIntensityRange = false,
                                   double minI = 0.0,
                                   double maxI = 1.0);
 
    bool exportCoordToSF(bool exportDims[3]);
 
    bool setCoordFromSF(bool importDims[3],
                        cloudViewer::ScalarField* sf,
                        PointCoordinateType defaultValueForNaN);
 
    bool exportNormalToSF(bool exportDims[3]);
 
public:  // for python interface
    inline virtual bool IsEmpty() const override { return !hasPoints(); }
 
    inline virtual Eigen::Vector3d GetMinBound() const override {
        return ComputeMinBound(CCVector3::fromArrayContainer(m_points));
    }
 
    inline virtual Eigen::Vector3d GetMaxBound() const override {
        return ComputeMaxBound(CCVector3::fromArrayContainer(m_points));
    }
    inline virtual Eigen::Vector3d GetCenter() const override {
        return ComputeCenter(CCVector3::fromArrayContainer(m_points));
    }
 
    virtual ccBBox GetAxisAlignedBoundingBox() const override;
    virtual ecvOrientedBBox GetOrientedBoundingBox() const override;
    virtual ccPointCloud& Transform(const Eigen::Matrix4d& trans) override;
    virtual ccPointCloud& Translate(const Eigen::Vector3d& translation,
                                    bool relative = true) override;
    inline ccPointCloud& Translate(const CCVector3& T) {
        return Translate(CCVector3d::fromArray(T), true);
    }
    virtual ccPointCloud& Scale(const double s,
                                const Eigen::Vector3d& center) override;
    virtual ccPointCloud& Rotate(const Eigen::Matrix3d& R,
                                 const Eigen::Vector3d& center) override;
 
    bool HasCovariances() const {
        return !m_points.empty() && covariances_.size() == m_points.size();
    }
 
    ccPointCloud& NormalizeNormals();
 
    std::shared_ptr<ccPointCloud> SelectByIndex(
            const std::vector<size_t>& indices, bool invert = false) const;
 
    ccPointCloud& RemoveNonFinitePoints(bool remove_nan = true,
                                        bool remove_infinite = true);
 
    std::shared_ptr<ccPointCloud> VoxelDownSample(double voxel_size);
 
    std::tuple<std::shared_ptr<ccPointCloud>,
               Eigen::MatrixXi,
               std::vector<std::vector<int>>>
    VoxelDownSampleAndTrace(double voxel_size,
                            const Eigen::Vector3d& min_bound,
                            const Eigen::Vector3d& max_bound,
                            bool approximate_class = false) const;
 
    std::shared_ptr<ccPointCloud> UniformDownSample(
            size_t every_k_points) const;
 
    std::shared_ptr<ccPointCloud> RandomDownSample(double sampling_ratio) const;
 
    std::shared_ptr<ccPointCloud> FarthestPointDownSample(
            const size_t num_samples, const size_t start_index = 0) const;
 
    std::shared_ptr<ccPointCloud> Crop(const ccBBox& bbox) const;
 
    std::shared_ptr<ccPointCloud> Crop(const ecvOrientedBBox& bbox) const;
 
    std::tuple<std::shared_ptr<ccPointCloud>, std::vector<size_t>>
    RemoveRadiusOutliers(size_t nb_points, double search_radius) const;
 
    std::tuple<std::shared_ptr<ccPointCloud>, std::vector<size_t>>
    RemoveStatisticalOutliers(size_t nb_neighbors, double std_ratio) const;
 
    bool EstimateNormals(
            const cloudViewer::geometry::KDTreeSearchParam& search_param =
                    cloudViewer::geometry::KDTreeSearchParamKNN(),
            bool fast_normal_computation = true);
 
    bool OrientNormalsToAlignWithDirection(
            const Eigen::Vector3d& orientation_reference =
                    Eigen::Vector3d(0.0, 0.0, 1.0));
 
    bool OrientNormalsTowardsCameraLocation(
            const Eigen::Vector3d& camera_location = Eigen::Vector3d::Zero());
 
    void OrientNormalsConsistentTangentPlane(size_t k);
 
    std::vector<double> ComputePointCloudDistance(const ccPointCloud& target);
 
    static std::vector<Eigen::Matrix3d> EstimatePerPointCovariances(
            const ccPointCloud& input,
            const cloudViewer::geometry::KDTreeSearchParam& search_param =
                    cloudViewer::geometry::KDTreeSearchParamKNN());
 
    void EstimateCovariances(
            const cloudViewer::geometry::KDTreeSearchParam& search_param =
                    cloudViewer::geometry::KDTreeSearchParamKNN());
 
    std::vector<double> ComputeMahalanobisDistance() const;
 
    std::vector<double> ComputeNearestNeighborDistance() const;
 
    double ComputeResolution() const;
 
    std::tuple<std::shared_ptr<ccMesh>, std::vector<size_t>> ComputeConvexHull()
            const;
 
    std::tuple<std::shared_ptr<ccMesh>, std::vector<size_t>> HiddenPointRemoval(
            const Eigen::Vector3d& camera_location, const double radius) const;
 
    std::vector<int> ClusterDBSCAN(double eps,
                                   size_t min_points,
                                   bool print_progress = false) const;
 
#ifdef CV_RANSAC_SUPPORT
    cloudViewer::geometry::RansacResults ExecuteRANSAC(
            const cloudViewer::geometry::RansacParams& params =
                    cloudViewer::geometry::RansacParams(),
            bool print_progress = false);
#endif
 
    std::tuple<Eigen::Vector4d, std::vector<size_t>> SegmentPlane(
            const double distance_threshold = 0.01,
            const int ransac_n = 3,
            const int num_iterations = 100) const;
 
    static std::shared_ptr<ccPointCloud> CreateFromDepthImage(
            const cloudViewer::geometry::Image& depth,
            const cloudViewer::camera::PinholeCameraIntrinsic& intrinsic,
            const Eigen::Matrix4d& extrinsic = Eigen::Matrix4d::Identity(),
            double depth_scale = 1000.0,
            double depth_trunc = 1000.0,
            int stride = 1,
            bool project_valid_depth_only = true);
 
    static std::shared_ptr<ccPointCloud> CreateFromRGBDImage(
            const cloudViewer::geometry::RGBDImage& image,
            const cloudViewer::camera::PinholeCameraIntrinsic& intrinsic,
            const Eigen::Matrix4d& extrinsic = Eigen::Matrix4d::Identity(),
            bool project_valid_depth_only = true);
 
    std::shared_ptr<ccPointCloud> CreateFromVoxelGrid(
            const cloudViewer::geometry::VoxelGrid& voxel_grid);
 
    ccPointCloud& PaintUniformColor(const Eigen::Vector3d& color);
 
public:
    std::vector<Eigen::Matrix3d> covariances_;
 
protected:
    // inherited from ccHObject
    void drawMeOnly(CC_DRAW_CONTEXT& context) override;
    void applyGLTransformation(const ccGLMatrix& trans) override;
    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;
    void notifyGeometryUpdate() override;
 
    // inherited from ccPointCloud
    void swapPoints(unsigned firstIndex, unsigned secondIndex) override;
 
    virtual void removePoints(size_t index) override;
 
    ColorsTableType* m_rgbColors;
 
    NormsIndexesTableType* m_normals;
 
    bool m_sfColorScaleDisplayed;
 
    ccScalarField* m_currentDisplayedScalarField;
    int m_currentDisplayedScalarFieldIndex;
 
    std::vector<Grid::Shared> m_grids;
 
 
    bool m_visibilityCheckEnabled;
 
protected:  // VBO
    void releaseVBOs();
 
    class VBO : public QGLBuffer {
    public:
        int rgbShift;
        int normalShift;
 
 
        int init(int count,
                 bool withColors,
                 bool withNormals,
                 bool* reallocated = nullptr);
 
        VBO()
            : QGLBuffer(QGLBuffer::VertexBuffer), rgbShift(0), normalShift(0) {}
    };
 
    struct vboSet {
        enum STATES { NEW, INITIALIZED, FAILED };
 
        enum UPDATE_FLAGS {
            UPDATE_POINTS = 1,
            UPDATE_COLORS = 2,
            UPDATE_NORMALS = 4,
            UPDATE_ALL = UPDATE_POINTS | UPDATE_COLORS | UPDATE_NORMALS
        };
 
        vboSet()
            : hasColors(false),
              colorIsSF(false),
              sourceSF(nullptr),
              hasNormals(false),
              totalMemSizeBytes(0),
              updateFlags(0),
              state(NEW) {}
 
        std::vector<VBO*> vbos;
        bool hasColors;
        bool colorIsSF;
        ccScalarField* sourceSF;
        bool hasNormals;
        int totalMemSizeBytes;
        int updateFlags;
 
        STATES state;
    };
 
    vboSet m_vboManager;
 
public:  // Level of Detail (LOD)
 
    bool initLOD();
 
    void clearLOD();
 
protected:  // Level of Detail (LOD)
    ccPointCloudLOD* m_lod;
 
protected:  // waveform (e.g. from airborne scanners)
    FWFDescriptorSet m_fwfDescriptors;
 
    std::vector<ccWaveform> m_fwfWaveforms;
 
    SharedFWFDataContainer m_fwfData;
};