ecvMesh.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
 
// cloudViewer
#include <Helper.h>
#include <PointProjectionTools.h>
#include <SimpleTriangle.h>
 
#include <Eigen/Core>
 
// Local
#include <unordered_map>
#include <unordered_set>
 
#include "Image.h"
#include "ecvGenericMesh.h"
 
namespace cloudViewer {
namespace geometry {
class TetraMesh;
}
}  // namespace cloudViewer
 
class ccPolyline;
class ecvOrientedBBox;
class ecvProgressDialog;
 
class CV_DB_LIB_API ccMesh : public ccGenericMesh {
public:
 
    explicit ccMesh(ccGenericPointCloud* vertices = nullptr);
 
    ccMesh(const ccMesh& mesh);
 
    explicit ccMesh(const std::vector<Eigen::Vector3d>& vertices,
                    const std::vector<Eigen::Vector3i>& triangles);
 
 
    explicit ccMesh(cloudViewer::GenericIndexedMesh* giMesh,
                    ccGenericPointCloud* giVertices);
 
    ~ccMesh() override;
 
    CV_CLASS_ENUM getClassID() const override { return CV_TYPES::MESH; }
 
    void setAssociatedCloud(ccGenericPointCloud* cloud);
 
    // Creates associated vertices cloud internally.
    bool CreateInternalCloud();
 
 
    ccMesh* cloneMesh(ccGenericPointCloud* vertices = nullptr,
                      ccMaterialSet* clonedMaterials = nullptr,
                      NormsIndexesTableType* clonedNormsTable = nullptr,
                      TextureCoordsContainer* cloneTexCoords = nullptr);
 
 
    ccMesh* partialClone(const std::vector<unsigned>& triangleIndices,
                         int* warnings = nullptr) const;
 
    static inline cloudViewer::VerticesIndexes GetOrderedTriangle(int vidx0,
                                                                  int vidx1,
                                                                  int vidx2) {
        if (vidx0 > vidx2) {
            std::swap(vidx0, vidx2);
        }
        if (vidx0 > vidx1) {
            std::swap(vidx0, vidx1);
        }
        if (vidx1 > vidx2) {
            std::swap(vidx1, vidx2);
        }
        return cloudViewer::VerticesIndexes(static_cast<unsigned int>(vidx0),
                                            static_cast<unsigned int>(vidx1),
                                            static_cast<unsigned int>(vidx2));
    }
 
 
    static ccMesh* Triangulate(ccGenericPointCloud* cloud,
                               cloudViewer::TRIANGULATION_TYPES type,
                               bool updateNormals = false,
                               PointCoordinateType maxEdgeLength = 0,
                               unsigned char dim = 2);
 
    static ccMesh* TriangulateTwoPolylines(ccPolyline* p1,
                                           ccPolyline* p2,
                                           CCVector3* projectionDir = nullptr);
 
 
    bool merge(const ccMesh* mesh, bool createSubMesh);
 
    ccMesh& operator=(const ccMesh& mesh);
    ccMesh& operator+=(const ccMesh& mesh);
    ccMesh operator+(const ccMesh& mesh) const;
 
    void clear();
 
    // inherited methods (ccHObject)
    unsigned getUniqueIDForDisplay() const override;
    ccBBox getOwnBB(bool withGLFeatures = false) override;
    bool isSerializable() const override { return true; }
    const ccGLMatrix& getGLTransformationHistory() const override;
 
    // inherited methods (ccGenericMesh)
    inline ccGenericPointCloud* getAssociatedCloud() const override {
        return m_associatedCloud;
    }
    void refreshBB() override;
    bool interpolateNormalsBC(unsigned triIndex,
                              const CCVector3d& w,
                              CCVector3& N) override;
    bool interpolateColors(unsigned triIndex,
                           const CCVector3& P,
                           ecvColor::Rgb& C) override;
    void computeInterpolationWeights(unsigned triIndex,
                                     const CCVector3& P,
                                     CCVector3d& weights) const override;
    bool getColorFromMaterial(unsigned triIndex,
                              const CCVector3& P,
                              ecvColor::Rgb& C,
                              bool interpolateColorIfNoTexture) override;
    bool getVertexColorFromMaterial(unsigned triIndex,
                                    unsigned char vertIndex,
                                    ecvColor::Rgb& C,
                                    bool returnColorIfNoTexture) override;
    unsigned capacity() const override;
 
    // inherited methods (GenericIndexedMesh)
    void forEach(genericTriangleAction action) override;
    void placeIteratorAtBeginning() override;
    cloudViewer::GenericTriangle* _getNextTriangle() override;  // temporary
    cloudViewer::GenericTriangle* _getTriangle(
            unsigned triangleIndex) override;  // temporary
    cloudViewer::VerticesIndexes* getNextTriangleVertIndexes() override;
    cloudViewer::VerticesIndexes* getTriangleVertIndexes(
            unsigned triangleIndex) override;
    virtual void getTriangleVertices(unsigned triangleIndex,
                                     CCVector3& A,
                                     CCVector3& B,
                                     CCVector3& C) const override;
    virtual void getTriangleVertices(unsigned triangleIndex,
                                     double A[3],
                                     double B[3],
                                     double C[3]) const override;
 
    unsigned int getVerticeSize() const;
 
    Eigen::Vector3d getVertice(size_t index) const;
    void setVertice(size_t index, const Eigen::Vector3d& vertice);
    void addVertice(const Eigen::Vector3d& vertice);
    std::vector<Eigen::Vector3d> getEigenVertices() const;
    void addEigenVertices(const std::vector<Eigen::Vector3d>& vertices);
    void setEigenVertices(const std::vector<Eigen::Vector3d>& vertices);
 
    Eigen::Vector3d getVertexNormal(size_t index) const;
    void setVertexNormal(size_t index, const Eigen::Vector3d& normal);
    void addVertexNormal(const Eigen::Vector3d& normal);
    std::vector<Eigen::Vector3d> getVertexNormals() const;
    void addVertexNormals(const std::vector<Eigen::Vector3d>& normals);
    void setVertexNormals(const std::vector<Eigen::Vector3d>& normals);
 
    Eigen::Vector3d getVertexColor(size_t index) const;
    void setVertexColor(size_t index, const Eigen::Vector3d& color);
    void addVertexColor(const Eigen::Vector3d& color);
    std::vector<Eigen::Vector3d> getVertexColors() const;
    ColorsTableType* getVertexColorsPtr();
    void addVertexColors(const std::vector<Eigen::Vector3d>& colors);
    void setVertexColors(const std::vector<Eigen::Vector3d>& colors);
 
    inline bool HasVertices() const { return getVerticeSize() != 0; }
 
    std::vector<CCVector3>& getVerticesPtr();
    const std::vector<CCVector3>& getVertices() const;
 
    virtual unsigned size() const override;
    void getBoundingBox(CCVector3& bbMin, CCVector3& bbMax) override;
    bool normalsAvailable() const override { return hasNormals(); }
    bool interpolateNormals(unsigned triIndex,
                            const CCVector3& P,
                            CCVector3& N) override;
 
    // const version of getTriangleVertIndexes
    void getTriangleVertIndexes(size_t triangleIndex,
                                Eigen::Vector3i& vertIndx) const;
    const virtual cloudViewer::VerticesIndexes* getTriangleVertIndexes(
            unsigned triangleIndex) const;
 
    // inherited methods (ccDrawableObject)
    bool hasColors() const override;
    bool hasNormals() const override;
    bool HasVertexNormals() const;
    bool hasScalarFields() const override;
    bool hasDisplayedScalarField() const override;
    bool normalsShown() const override;
    void toggleMaterials() override { showMaterials(!materialsShown()); }
 
 
    void invertNormals();
 
 
    void shiftTriangleIndexes(unsigned shift);
 
 
    void flipTriangles();
 
 
    void addTriangle(unsigned i1, unsigned i2, unsigned i3);
    void addTriangle(const cloudViewer::VerticesIndexes& triangle);
    inline void addTriangle(const Eigen::Vector3i& index) {
        addTriangle(static_cast<unsigned>(index[0]),
                    static_cast<unsigned>(index[1]),
                    static_cast<unsigned>(index[2]));
    }
    inline void addTriangles(const std::vector<Eigen::Vector3i>& triangles) {
        for (auto& tri : triangles) {
            addTriangle(tri);
        }
    }
 
    void setTriangle(size_t index, const Eigen::Vector3i& triangle);
    void setTriangles(const std::vector<Eigen::Vector3i>& triangles);
    Eigen::Vector3i getTriangle(size_t index) const;
    std::vector<Eigen::Vector3i> getTriangles() const;
 
    using triangleIndexesContainer =
            ccArray<cloudViewer::VerticesIndexes, 3, unsigned>;
    inline triangleIndexesContainer* getTrianglesPtr() const {
        return m_triVertIndexes;
    }
 
 
    bool reserve(std::size_t n);
    bool reserveAssociatedCloud(std::size_t n,
                                bool init_color = false,
                                bool init_normal = false);
 
 
    bool resize(size_t n);
    bool resizeAssociatedCloud(std::size_t n);
 
    inline void shrinkToFit() {
        if (size() < capacity()) resize(size());
    }
    void shrinkVertexToFit();
 
    /*********************************************************/
    /**************    PER-TRIANGLE NORMALS    ***************/
    /*********************************************************/
 
    // inherited from ccGenericMesh
    bool hasTriNormals() const override;
    // for compatibility
    inline bool HasTriangleNormals() const { return hasTriNormals(); }
    void getTriangleNormalIndexes(unsigned triangleIndex,
                                  int& i1,
                                  int& i2,
                                  int& i3) const override;
    bool getTriangleNormals(unsigned triangleIndex,
                            CCVector3& Na,
                            CCVector3& Nb,
                            CCVector3& Nc) const override;
    bool getTriangleNormals(unsigned triangleIndex,
                            double Na[3],
                            double Nb[3],
                            double Nc[3]) const override;
    bool getTriangleNormals(unsigned triangleIndex,
                            Eigen::Vector3d& Na,
                            Eigen::Vector3d& Nb,
                            Eigen::Vector3d& Nc) const override;
    std::vector<Eigen::Vector3d> getTriangleNormals() const;
    std::vector<CCVector3*> getTriangleNormalsPtr() const;
    Eigen::Vector3d getTriangleNorm(size_t index) const;
    bool setTriangleNorm(size_t index, const Eigen::Vector3d& triangle_normal);
    bool setTriangleNormalIndexes(size_t triangleIndex,
                                  CompressedNormType value);
    CompressedNormType getTriangleNormalIndexes(size_t triangleIndex);
    bool addTriangleNorm(const CCVector3& N);
    bool addTriangleNorm(const Eigen::Vector3d& N);
    std::vector<Eigen::Vector3d> getTriangleNorms() const;
    bool setTriangleNorms(const std::vector<Eigen::Vector3d>& triangle_normals);
    bool addTriangleNorms(const std::vector<Eigen::Vector3d>& triangle_normals);
 
    NormsIndexesTableType* getTriNormsTable() const override {
        return m_triNormals;
    }
 
    void setTriNormsTable(NormsIndexesTableType* triNormsTable,
                          bool autoReleaseOldTable = true);
 
    void clearTriNormals() { setTriNormsTable(nullptr); }
 
 
    bool arePerTriangleNormalsEnabled() const;
 
 
    bool reservePerTriangleNormalIndexes();
 
 
    void addTriangleNormalIndexes(int i1, int i2, int i3);
 
 
    void setTriangleNormalIndexes(unsigned triangleIndex,
                                  int i1,
                                  int i2,
                                  int i3);
 
    void removePerTriangleNormalIndexes();
 
    void invertPerTriangleNormals();
 
    /********************************************************/
    /************    PER-TRIANGLE MATERIAL    ***************/
    /********************************************************/
 
    // inherited from ccGenericMesh
    bool hasMaterials() const override;
    const ccMaterialSet* getMaterialSet() const override { return m_materials; }
    int getTriangleMtlIndex(unsigned triangleIndex) const override;
 
 
    bool convertMaterialsToVertexColors();
 
    bool hasPerTriangleMtlIndexes() const {
        return m_triMtlIndexes && m_triMtlIndexes->isAllocated();
    }
 
 
    bool reservePerTriangleMtlIndexes();
 
    void removePerTriangleMtlIndexes();
 
 
    void addTriangleMtlIndex(int mtlIndex);
 
    using triangleMaterialIndexesSet = ccArray<int, 1, int>;
 
    void setTriangleMtlIndexesTable(triangleMaterialIndexesSet* matIndexesTable,
                                    bool autoReleaseOldTable = true);
 
    inline const triangleMaterialIndexesSet* getTriangleMtlIndexesTable()
            const {
        return m_triMtlIndexes;
    }
 
 
    void setTriangleMtlIndex(unsigned triangleIndex, int mtlIndex);
 
    void setMaterialSet(ccMaterialSet* materialSet,
                        bool autoReleaseOldMaterialSet = true);
 
    /******************************************************************/
    /************    PER-TRIANGLE TEXTURE COORDINATE    ***************/
    /******************************************************************/
 
    // inherited from ccGenericMesh
    bool hasTextures() const override;
    TextureCoordsContainer* getTexCoordinatesTable() const override {
        return m_texCoords;
    }
    void getTriangleTexCoordinates(unsigned triIndex,
                                   TexCoords2D*& tx1,
                                   TexCoords2D*& tx2,
                                   TexCoords2D*& tx3) const override;
    void getTexCoordinates(unsigned index, TexCoords2D*& tx) const override;
    bool hasPerTriangleTexCoordIndexes() const override {
        return m_texCoordIndexes && m_texCoordIndexes->isAllocated();
    }
    void getTriangleTexCoordinatesIndexes(unsigned triangleIndex,
                                          int& i1,
                                          int& i2,
                                          int& i3) const override;
 
    void setTexCoordinatesTable(TextureCoordsContainer* texCoordsTable,
                                bool autoReleaseOldTable = true);
 
 
    bool reservePerTriangleTexCoordIndexes();
 
    void removePerTriangleTexCoordIndexes();
 
 
    void addTriangleTexCoordIndexes(int i1, int i2, int i3);
 
 
    void setTriangleTexCoordIndexes(unsigned triangleIndex,
                                    int i1,
                                    int i2,
                                    int i3);
 
 
    bool computeNormals(bool perVertex);
 
    bool computePerVertexNormals();
 
    bool computePerTriangleNormals();
 
 
    bool laplacianSmooth(
            unsigned nbIteration = 100,
            PointCoordinateType factor = static_cast<PointCoordinateType>(0.01),
            ecvProgressDialog* progressCb = nullptr);
 
    enum MESH_SCALAR_FIELD_PROCESS {
        SMOOTH_MESH_SF,  
        ENHANCE_MESH_SF, 
    };
 
 
    bool processScalarField(MESH_SCALAR_FIELD_PROCESS process);
 
 
    ccMesh* subdivide(PointCoordinateType maxArea) const;
 
 
    ccMesh* createNewMeshFromSelection(
            bool removeSelectedTriangles,
            std::vector<int>* newIndexesOfRemainingTriangles = nullptr,
            bool withChildEntities = false);
 
 
    void swapTriangles(unsigned index1, unsigned index2);
 
    void removeTriangles(size_t index);
 
    void transformTriNormals(const ccGLMatrix& trans);
 
    static const unsigned char DefaultMergeDulicateVerticesLevel = 10;
 
    bool mergeDuplicatedVertices(
            unsigned char octreeLevel = DefaultMergeDulicateVerticesLevel,
            QWidget* parentWidget = nullptr);
 
public:  // some cloudViewer interface
    std::vector<std::unordered_set<int>> adjacency_list_;
 
    std::vector<Eigen::Vector2d> triangle_uvs_;
 
    struct Material {
        struct MaterialParameter {
            float f4[4] = {0};
 
            MaterialParameter() {
                f4[0] = 0;
                f4[1] = 0;
                f4[2] = 0;
                f4[3] = 0;
            }
 
            MaterialParameter(const float v1,
                              const float v2,
                              const float v3,
                              const float v4) {
                f4[0] = v1;
                f4[1] = v2;
                f4[2] = v3;
                f4[3] = v4;
            }
 
            MaterialParameter(const float v1, const float v2, const float v3) {
                f4[0] = v1;
                f4[1] = v2;
                f4[2] = v3;
                f4[3] = 1;
            }
 
            MaterialParameter(const float v1, const float v2) {
                f4[0] = v1;
                f4[1] = v2;
                f4[2] = 0;
                f4[3] = 0;
            }
 
            explicit MaterialParameter(const float v1) {
                f4[0] = v1;
                f4[1] = 0;
                f4[2] = 0;
                f4[3] = 0;
            }
 
            static MaterialParameter CreateRGB(const float r,
                                               const float g,
                                               const float b) {
                return {r, g, b, 1.f};
            }
 
            float r() const { return f4[0]; }
            float g() const { return f4[1]; }
            float b() const { return f4[2]; }
            float a() const { return f4[3]; }
        };
 
        MaterialParameter baseColor;
        float baseMetallic = 0.f;
        float baseRoughness = 1.f;
        float baseReflectance = 0.5f;
        float baseClearCoat = 0.f;
        float baseClearCoatRoughness = 0.f;
        float baseAnisotropy = 0.f;
 
        std::shared_ptr<cloudViewer::geometry::Image> albedo;
        std::shared_ptr<cloudViewer::geometry::Image> normalMap;
        std::shared_ptr<cloudViewer::geometry::Image> ambientOcclusion;
        std::shared_ptr<cloudViewer::geometry::Image> metallic;
        std::shared_ptr<cloudViewer::geometry::Image> roughness;
        std::shared_ptr<cloudViewer::geometry::Image> reflectance;
        std::shared_ptr<cloudViewer::geometry::Image> clearCoat;
        std::shared_ptr<cloudViewer::geometry::Image> clearCoatRoughness;
        std::shared_ptr<cloudViewer::geometry::Image> anisotropy;
 
        std::unordered_map<std::string, MaterialParameter> floatParameters;
        std::unordered_map<std::string, cloudViewer::geometry::Image>
                additionalMaps;
    };
 
    std::vector<std::pair<std::string, Material>> materials_;
 
    std::vector<int> triangle_material_ids_;
    std::vector<cloudViewer::geometry::Image> textures_;
 
    bool hasAdjacencyList() const {
        return getVerticeSize() > 0 &&
               adjacency_list_.size() == getVerticeSize();
    }
 
    inline bool hasTriangleUvs() const {
        return hasTriangles() && triangle_uvs_.size() == 3 * size();
    }
 
    bool hasTriangleMaterialIds() const {
        return hasTriangles() && triangle_material_ids_.size() == size();
    }
 
    bool hasEigenTextures() const {
        bool is_all_texture_valid = std::accumulate(
                textures_.begin(), textures_.end(), true,
                [](bool a, const cloudViewer::geometry::Image& b) {
                    return a && !b.IsEmpty();
                });
        return !textures_.empty() && is_all_texture_valid;
    }
 
    inline virtual bool IsEmpty() const override {
        return !HasVertices() || !hasTriangles();
    }
 
    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 ccMesh& Transform(const Eigen::Matrix4d& transformation) override;
    virtual ccMesh& Translate(const Eigen::Vector3d& translation,
                              bool relative = true) override;
    virtual ccMesh& Scale(const double s,
                          const Eigen::Vector3d& center) override;
    virtual ccMesh& Rotate(const Eigen::Matrix3d& R,
                           const Eigen::Vector3d& center) override;
 
    ccMesh& PaintUniformColor(const Eigen::Vector3d& color);
 
    std::tuple<std::shared_ptr<ccMesh>, std::vector<size_t>> ComputeConvexHull()
            const;
 
    std::unordered_map<Eigen::Vector2i,
                       double,
                       cloudViewer::utility::hash_eigen<Eigen::Vector2i>>
    ComputeEdgeWeightsCot(
            const std::unordered_map<
                    Eigen::Vector2i,
                    std::vector<int>,
                    cloudViewer::utility::hash_eigen<Eigen::Vector2i>>&
                    edges_to_vertices,
            double min_weight = std::numeric_limits<double>::lowest()) const;
 
    ccMesh& ComputeTriangleNormals(bool normalized = true);
 
    ccMesh& ComputeVertexNormals(bool normalized = true);
 
    ccMesh& NormalizeNormals();
 
    ccMesh& ComputeAdjacencyList();
 
    ccMesh& RemoveDuplicatedVertices();
 
    ccMesh& RemoveDuplicatedTriangles();
 
    ccMesh& RemoveUnreferencedVertices();
 
    ccMesh& RemoveDegenerateTriangles();
 
    ccMesh& RemoveNonManifoldEdges();
 
    ccMesh& MergeCloseVertices(double eps);
 
    std::shared_ptr<ccMesh> FilterSharpen(
            int number_of_iterations,
            double strength,
            FilterScope scope = FilterScope::All) const;
 
    std::shared_ptr<ccMesh> FilterSmoothSimple(
            int number_of_iterations,
            FilterScope scope = FilterScope::All) const;
 
    std::shared_ptr<ccMesh> FilterSmoothLaplacian(
            int number_of_iterations,
            double lambda,
            FilterScope scope = FilterScope::All) const;
 
    std::shared_ptr<ccMesh> FilterSmoothTaubin(
            int number_of_iterations,
            double lambda = 0.5,
            double mu = -0.53,
            FilterScope scope = FilterScope::All) const;
 
    int EulerPoincareCharacteristic() const;
 
    std::vector<Eigen::Vector2i> GetNonManifoldEdges(
            bool allow_boundary_edges = true) const;
 
    bool IsEdgeManifold(bool allow_boundary_edges = true) const;
 
    std::vector<int> GetNonManifoldVertices() const;
 
    bool IsVertexManifold() const;
 
    std::vector<Eigen::Vector2i> GetSelfIntersectingTriangles() const;
 
    bool IsSelfIntersecting() const;
 
    bool IsBoundingBoxIntersecting(const ccMesh& other) const;
 
    bool IsIntersecting(const ccMesh& other) const;
 
    bool IsOrientable() const;
 
    bool IsWatertight() const;
 
    bool OrientTriangles();
 
    std::unordered_map<Eigen::Vector2i,
                       std::vector<int>,
                       cloudViewer::utility::hash_eigen<Eigen::Vector2i>>
    GetEdgeToTrianglesMap() const;
 
    std::unordered_map<Eigen::Vector2i,
                       std::vector<int>,
                       cloudViewer::utility::hash_eigen<Eigen::Vector2i>>
    GetEdgeToVerticesMap() const;
 
    double GetTriangleArea(size_t triangle_idx) const;
 
    static double ComputeTriangleArea(const Eigen::Vector3d& p0,
                                      const Eigen::Vector3d& p1,
                                      const Eigen::Vector3d& p2);
 
    static inline Eigen::Vector3i GetEigneOrderedTriangle(int vidx0,
                                                          int vidx1,
                                                          int vidx2) {
        if (vidx0 > vidx2) {
            std::swap(vidx0, vidx2);
        }
        if (vidx0 > vidx1) {
            std::swap(vidx0, vidx1);
        }
        if (vidx1 > vidx2) {
            std::swap(vidx1, vidx2);
        }
        return Eigen::Vector3i(vidx0, vidx1, vidx2);
    }
 
    double GetSurfaceArea() const;
 
    double GetSurfaceArea(std::vector<double>& triangle_areas) const;
 
    double GetVolume() const;
 
    static Eigen::Vector4d ComputeTrianglePlane(const Eigen::Vector3d& p0,
                                                const Eigen::Vector3d& p1,
                                                const Eigen::Vector3d& p2);
 
    Eigen::Vector4d GetTrianglePlane(size_t triangle_idx) const;
 
    static inline Eigen::Vector2i GetOrderedEdge(int vidx0, int vidx1) {
        return Eigen::Vector2i(std::min(vidx0, vidx1), std::max(vidx0, vidx1));
    }
 
    std::shared_ptr<ccPointCloud> SamplePointsUniformlyImpl(
            size_t number_of_points,
            std::vector<double>& triangle_areas,
            double surface_area,
            bool use_triangle_normal,
            int seed);
 
    std::shared_ptr<ccPointCloud> SamplePointsUniformly(
            size_t number_of_points,
            bool use_triangle_normal = false,
            int seed = -1);
 
    std::shared_ptr<ccPointCloud> SamplePointsPoissonDisk(
            size_t number_of_points,
            double init_factor = 5,
            const std::shared_ptr<ccPointCloud> pcl_init = nullptr,
            bool use_triangle_normal = false,
            int seed = -1);
 
    std::shared_ptr<ccMesh> SubdivideMidpoint(int number_of_iterations) const;
 
    std::shared_ptr<ccMesh> SubdivideLoop(int number_of_iterations) const;
 
    std::shared_ptr<ccMesh> SimplifyVertexClustering(
            double voxel_size,
            SimplificationContraction contraction =
                    SimplificationContraction::Average) const;
 
    std::shared_ptr<ccMesh> SimplifyQuadricDecimation(
            int target_number_of_triangles,
            double maximum_error = std::numeric_limits<double>::infinity(),
            double boundary_weight = 1.0) const;
 
    std::shared_ptr<ccMesh> SelectByIndex(const std::vector<size_t>& indices,
                                          bool cleanup = true) const;
 
    std::shared_ptr<ccMesh> Crop(const ccBBox& bbox) const;
 
    std::shared_ptr<ccMesh> Crop(const ecvOrientedBBox& bbox) const;
 
    std::tuple<std::vector<int>, std::vector<size_t>, std::vector<double>>
    ClusterConnectedTriangles() const;
 
    void RemoveTrianglesByIndex(const std::vector<size_t>& triangle_indices);
 
    void RemoveTrianglesByMask(const std::vector<bool>& triangle_mask);
 
    void RemoveVerticesByIndex(const std::vector<size_t>& vertex_indices);
 
    void RemoveVerticesByMask(const std::vector<bool>& vertex_mask);
 
    std::shared_ptr<ccMesh> DeformAsRigidAsPossible(
            const std::vector<int>& constraint_vertex_indices,
            const std::vector<Eigen::Vector3d>& constraint_vertex_positions,
            size_t max_iter,
            DeformAsRigidAsPossibleEnergy energy =
                    DeformAsRigidAsPossibleEnergy::Spokes,
            double smoothed_alpha = 0.01) const;
 
    static std::shared_ptr<ccMesh> CreateFromPointCloudAlphaShape(
            const ccPointCloud& pcd,
            double alpha,
            std::shared_ptr<cloudViewer::geometry::TetraMesh> tetra_mesh =
                    nullptr,
            std::vector<size_t>* pt_map = nullptr);
 
    static std::shared_ptr<ccMesh> CreateFromPointCloudBallPivoting(
            const ccPointCloud& pcd, const std::vector<double>& radii);
 
    static std::tuple<std::shared_ptr<ccMesh>, std::vector<double>>
    CreateFromPointCloudPoisson(const ccPointCloud& pcd,
                                size_t depth = 8,
                                size_t width = 0,
                                float scale = 1.1f,
                                bool linear_fit = false,
                                float point_weight = 2.f,
                                float samples_per_node = 1.5f,
                                int boundary_type = 2 /*BOUNDARY_NEUMANN*/,
                                int n_threads = -1);
 
    static std::shared_ptr<ccMesh> CreateTetrahedron(
            double radius = 1.0, bool create_uv_map = false);
 
    static std::shared_ptr<ccMesh> CreateOctahedron(double radius = 1.0,
                                                    bool create_uv_map = false);
 
    static std::shared_ptr<ccMesh> CreateIcosahedron(
            double radius = 1.0, bool create_uv_map = false);
 
    static std::shared_ptr<ccMesh> CreatePlane(double width = 1.0,
                                               double height = 1.0,
                                               bool create_uv_map = false);
 
    static std::shared_ptr<ccMesh> CreateBox(
            double width = 1.0,
            double height = 1.0,
            double depth = 1.0,
            bool create_uv_map = false,
            bool map_texture_to_each_face = false);
 
    static std::shared_ptr<ccMesh> CreateSphere(double radius = 1.0,
                                                int resolution = 20,
                                                bool create_uv_map = false);
 
    static std::shared_ptr<ccMesh> CreateCylinder(double radius = 1.0,
                                                  double height = 2.0,
                                                  int resolution = 20,
                                                  int split = 4,
                                                  bool create_uv_map = false);
 
    static std::shared_ptr<ccMesh> CreateCone(double radius = 1.0,
                                              double height = 2.0,
                                              int resolution = 20,
                                              int split = 1,
                                              bool create_uv_map = false);
 
    static std::shared_ptr<ccMesh> CreateTorus(double torus_radius = 1.0,
                                               double tube_radius = 0.5,
                                               int radial_resolution = 30,
                                               int tubular_resolution = 20);
 
    static std::shared_ptr<ccMesh> CreateArrow(double cylinder_radius = 1.0,
                                               double cone_radius = 1.5,
                                               double cylinder_height = 5.0,
                                               double cone_height = 4.0,
                                               int resolution = 20,
                                               int cylinder_split = 4,
                                               int cone_split = 1);
 
    static std::shared_ptr<ccMesh> CreateCoordinateFrame(
            double size = 1.0,
            const Eigen::Vector3d& origin = Eigen::Vector3d(0.0, 0.0, 0.0));
 
    static std::shared_ptr<ccMesh> CreateMobius(int length_split = 70,
                                                int width_split = 15,
                                                int twists = 1,
                                                double radius = 1,
                                                double flatness = 1,
                                                double width = 1,
                                                double scale = 1);
 
protected:
    void FilterSmoothLaplacianHelper(
            std::shared_ptr<ccMesh>& mesh,
            const std::vector<CCVector3>& prev_vertices,
            const std::vector<CCVector3>& prev_vertex_normals,
            const ColorsTableType& prev_vertex_colors,
            const std::vector<std::unordered_set<int>>& adjacency_list,
            double lambda,
            bool filter_vertex,
            bool filter_normal,
            bool filter_color) const;
 
protected:
    // inherited from ccHObject
    void drawMeOnly(CC_DRAW_CONTEXT& context) 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 applyGLTransformation(const ccGLMatrix& trans) override;
    void onUpdateOf(ccHObject* obj) override;
    void onDeletionOf(const ccHObject* obj) override;
 
    void computeInterpolationWeights(
            const cloudViewer::VerticesIndexes& vertIndexes,
            const CCVector3& P,
            CCVector3d& weights) const;
    bool interpolateNormals(const cloudViewer::VerticesIndexes& vertIndexes,
                            const CCVector3d& w,
                            CCVector3& N,
                            const Tuple3i* triNormIndexes = nullptr);
    bool interpolateColors(const cloudViewer::VerticesIndexes& vertIndexes,
                           const CCVector3& P,
                           ecvColor::Rgb& C);
 
    bool pushSubdivide(/*PointCoordinateType maxArea, */ unsigned indexA,
                       unsigned indexB,
                       unsigned indexC);
 
    /*** EXTENDED CALL SCRIPTS (FOR CC_SUB_MESHES) ***/
 
    // 0 parameter
#define ccMesh_extended_call0(baseName, recursiveName)        \
    inline virtual void recursiveName() {                     \
        baseName();                                           \
        for (Container::iterator it = m_children.begin();     \
             it != m_children.end(); ++it)                    \
            if ((*it)->isA(CV_TYPES::SUB_MESH))               \
                static_cast<ccGenericMesh*>(*it)->baseName(); \
    }
 
    // 1 parameter
#define ccMesh_extended_call1(baseName, param1Type, recursiveName) \
    inline virtual void recursiveName(param1Type p) {              \
        baseName(p);                                               \
        for (Container::iterator it = m_children.begin();          \
             it != m_children.end(); ++it)                         \
            if ((*it)->isA(CV_TYPES::SUB_MESH))                    \
                static_cast<ccGenericMesh*>(*it)->baseName(p);     \
    }
 
    // recursive equivalents of some of ccGenericMesh methods (applied to
    // sub-meshes as well)
    ccMesh_extended_call1(showNormals, bool, showNormals_extended)
 
            
            ccGenericPointCloud* m_associatedCloud;
 
    NormsIndexesTableType* m_triNormals;
 
    TextureCoordsContainer* m_texCoords;
 
    ccMaterialSet* m_materials;
 
    triangleIndexesContainer* m_triVertIndexes;
 
    unsigned m_globalIterator;
    cloudViewer::SimpleRefTriangle m_currentTriangle;
 
    ccBBox m_bBox;
 
    triangleMaterialIndexesSet* m_triMtlIndexes;
 
    using triangleTexCoordIndexesSet = ccArray<Tuple3i, 3, int>;
    triangleTexCoordIndexesSet* m_texCoordIndexes;
 
    using triangleNormalsIndexesSet = ccArray<Tuple3i, 3, int>;
    triangleNormalsIndexesSet* m_triNormalIndexes;
};