MeshUtilities.hpp

Go to the documentation of this file.

// _LICENSE_HEADER_
//
// Copyright (C) 2019 - 2025.
// Terms register on the GPL-3.0 license.
//
// This file can be redistributed and/or modified under the license terms.
//
// See top level LICENSE file for more details.
//
// This file can be used citing references in CITATION.cff file.
 
#ifndef __MeshUtilities_H
#define __MeshUtilities_H
 
#include "GeometryUtilities.hpp"
#include "IMeshDAO.hpp"
 
namespace Gedim
{
class MeshUtilities final
{
  public:
    struct CheckMesh2DConfiguration final
    {
        bool Cell0D_CheckCoordinates2D = true;
        bool Cell0D_CheckDuplications = true;
        bool Cell1D_CheckDuplications = true;
        bool Cell1D_CheckNeighbours = true;
        bool Cell1D_CheckMeasure = true;
        bool Cell2D_CheckEdges = true;
        bool Cell2D_CheckDuplications = true;
        bool Cell2D_CheckConvexity = true;
        bool Cell2D_CheckMeasure = true;
    };
 
    struct CheckMesh3DConfiguration final
    {
        bool Cell0D_CheckDuplications = true;
        bool Cell1D_CheckDuplications = true;
        bool Cell1D_CheckMeasure = true;
        bool Cell2D_CheckEdges = true;
        bool Cell2D_CheckDuplications = true;
        bool Cell2D_CheckConvexity = true;
        bool Cell2D_CheckMeasure = true;
        bool Cell3D_CheckDuplications = true;
        bool Cell3D_CheckEdges = true;
        bool Cell3D_CheckEdgesAreActive = true;
        bool Cell3D_CheckConvexity = true;
        bool Cell3D_CheckMeasure = true;
        bool Cell3D_CheckFaces = true;
    };
 
    struct CheckMeshGeometricData2DConfiguration final
    {
        bool Cell1D_CheckMeasure = true;
        bool Cell1D_CheckNormals = true;
        bool Cell2D_CheckMeasure = true;
        bool Cell2D_CheckTriangles = true;
        unsigned int Cell1D_QuadratureOrder = 0;
        unsigned int Cell2D_QuadratureOrder = 0;
    };
 
    struct CheckMeshGeometricData3DConfiguration final
    {
        bool Cell1D_CheckMeasure = true;
        bool Cell1D_CheckNormals = true;
        bool Cell2D_CheckMeasure = true;
        bool Cell2D_CheckTriangles = true;
        bool Cell2D_CheckNormals = true;
        bool Cell3D_CheckMeasure = true;
        bool Cell3D_CheckTetrahedra = true;
        unsigned int Cell1D_QuadratureOrder = 0;
        unsigned int Cell2D_QuadratureOrder = 0;
        unsigned int Cell3D_QuadratureOrder = 0;
    };
 
    struct ExtractActiveMeshData final
    {
        std::unordered_map<unsigned int, unsigned int> OldCell0DToNewCell0D; 
        std::unordered_map<unsigned int, unsigned int> OldCell1DToNewCell1D; 
        std::unordered_map<unsigned int, unsigned int> OldCell2DToNewCell2D; 
        std::unordered_map<unsigned int, unsigned int> OldCell3DToNewCell3D; 
        std::unordered_map<unsigned int, unsigned int> NewCell0DToOldCell0D; 
        std::unordered_map<unsigned int, unsigned int> NewCell1DToOldCell1D; 
        std::unordered_map<unsigned int, unsigned int> NewCell2DToOldCell2D; 
        std::unordered_map<unsigned int, unsigned int> NewCell3DToOldCell3D; 
    };
 
    struct FilterMeshData final
    {
        std::vector<unsigned int> Cell0Ds;
        std::vector<unsigned int> Cell1Ds;
        std::vector<unsigned int> Cell2Ds;
        std::vector<unsigned int> Cell3Ds;
    };
 
    struct ExtractMeshData final
    {
        std::vector<unsigned int> OldCell0DToNewCell0D = {}; 
        std::vector<unsigned int> OldCell1DToNewCell1D = {}; 
        std::vector<unsigned int> OldCell2DToNewCell2D = {}; 
        std::vector<unsigned int> OldCell3DToNewCell3D = {}; 
        std::vector<unsigned int> NewCell0DToOldCell0D = {}; 
        std::vector<unsigned int> NewCell1DToOldCell1D = {}; 
        std::vector<unsigned int> NewCell2DToOldCell2D = {}; 
        std::vector<unsigned int> NewCell3DToOldCell3D = {}; 
    };
 
    struct ComputeMesh2DCell1DsResult final
    {
        Eigen::MatrixXi Cell1Ds;              
        std::vector<Eigen::MatrixXi> Cell2Ds; 
    };
 
    struct ComputeMesh3DAlignedCell1DsResult final
    {
 
        Eigen::MatrixXi AlignedCell1Ds;
        std::vector<Eigen::MatrixXi> Cell0DsAlignedCell1DsIndex;
        std::vector<Eigen::MatrixXi> Cell1DsAlignedCell1DsIndex;
        std::vector<Eigen::MatrixXi> Cell3DsAlignedCell1DsIndex;
        std::vector<std::vector<unsigned int>> AlignedCell1Ds_SubCell0Ds;
        std::vector<std::vector<unsigned int>> AlignedCell1Ds_SubCell1Ds;
        std::vector<std::vector<unsigned int>> AlignedCell1Ds_Cell3Ds;
    };
 
    struct MeshGeometricData1D final
    {
        std::vector<Eigen::MatrixXd> Cell1DsBoundingBox;
        std::vector<Eigen::MatrixXd> Cell1DsVertices;  
        std::vector<Eigen::Vector3d> Cell1DsTangents;  
        std::vector<double> Cell1DsLengths;            
        std::vector<double> Cell1DsSquaredLengths;     
        std::vector<Eigen::Vector3d> Cell1DsCentroids; 
    };
 
    struct MeshGeometricData2D final
    {
        std::vector<Eigen::MatrixXd> Cell2DsBoundingBox;
        std::vector<Eigen::MatrixXd> Cell2DsVertices;                    
        std::vector<std::vector<Eigen::Matrix3d>> Cell2DsTriangulations; 
        std::vector<double> Cell2DsAreas;                                
        std::vector<Eigen::Vector3d> Cell2DsCentroids;                   
        std::vector<double> Cell2DsDiameters;                            
        std::vector<std::vector<bool>> Cell2DsEdgeDirections;            
        std::vector<Eigen::MatrixXd> Cell2DsEdgesCentroid;               
        std::vector<Eigen::VectorXd> Cell2DsEdgeLengths;                 
        std::vector<Eigen::MatrixXd> Cell2DsEdgeTangents;                
        std::vector<Eigen::MatrixXd> Cell2DsEdgeNormals;                 
        std::vector<Eigen::Vector3d> Cell2DsChebyshevCenter;             
        std::vector<std::vector<Eigen::Matrix3d>> Cell2DsTriangulationsByChebyshevCenter; 
        std::vector<double> Cell2DsInRadius;                                              
    };
 
    struct MeshGeometricData2DConfig final
    {
        bool Cell2DsBoundingBox = true;
        bool Cell2DsTriangulations = true; 
        bool Cell2DsAreas = true;          
        bool Cell2DsCentroids = true;      
        bool Cell2DsDiameters = true;      
        bool Cell2DsEdgeDirections = true; 
        bool Cell2DsEdgesCentroid = true;  
        bool Cell2DsEdgeLengths = true;    
        bool Cell2DsEdgeTangents = true;   
        bool Cell2DsEdgeNormals = true;    
        bool Cell2DsChebyshevCenter = false;
        bool Cell2DsTriangulationsByChebyshevCenter = false; 
        bool Cell2DsInRadius = false;                        
 
        MeshGeometricData2DConfig()
        {
            Cell2DsBoundingBox = true;
            Cell2DsTriangulations = true;
            Cell2DsAreas = true;
            Cell2DsCentroids = true;
            Cell2DsDiameters = true;
            Cell2DsEdgeDirections = true;
            Cell2DsEdgesCentroid = true;
            Cell2DsEdgeLengths = true;
            Cell2DsEdgeTangents = true;
            Cell2DsEdgeNormals = true;
            Cell2DsChebyshevCenter = false;
            Cell2DsTriangulationsByChebyshevCenter = false;
            Cell2DsInRadius = false;
        }
 
        MeshGeometricData2DConfig(bool Cell2DsBoundingBox,
                                  bool Cell2DsTriangulations,
                                  bool Cell2DsAreas,
                                  bool Cell2DsCentroids,
                                  bool Cell2DsDiameters,
                                  bool Cell2DsEdgeDirections,
                                  bool Cell2DsEdgesCentroid,
                                  bool Cell2DsEdgeLengths,
                                  bool Cell2DsEdgeTangents,
                                  bool Cell2DsEdgeNormals,
                                  bool Cell2DsChebyshevCenter,
                                  bool Cell2DsTriangulationsByChebyshevCenter,
                                  bool Cell2DsInRadius);
    };
 
    struct MeshGeometricData3D final
    {
        std::vector<Eigen::MatrixXd> Cell3DsVertices;
        std::vector<Eigen::MatrixXi> Cell3DsEdges;
        std::vector<std::vector<Eigen::MatrixXi>> Cell3DsFaces;
        std::vector<Eigen::MatrixXd> Cell3DsBoundingBox;
        std::vector<double> Cell3DsVolumes;
        std::vector<double> Cell3DsDiameters;
        std::vector<Eigen::Vector3d> Cell3DsCentroids;
        std::vector<Eigen::MatrixXd> Cell3DsEdgesCentroid;
        std::vector<Eigen::VectorXd> Cell3DsEdgeLengths;
        std::vector<Eigen::MatrixXd> Cell3DsEdgeTangents;
        std::vector<std::vector<bool>> Cell3DsEdgeDirections;
        std::vector<std::vector<Eigen::MatrixXd>> Cell3DsTetrahedronPoints;
        std::vector<std::vector<Eigen::Vector3d>> Cell3DsFacesTranslations;
        std::vector<std::vector<Eigen::Matrix3d>> Cell3DsFacesRotationMatrices;
        std::vector<std::vector<Eigen::Vector3d>> Cell3DsFacesNormals;
        std::vector<std::vector<std::array<Eigen::Vector3d, 2>>> Cell3DsFacesTangents;
        std::vector<std::vector<bool>> Cell3DsFacesNormalDirections;
        std::vector<std::vector<bool>> Cell3DsFacesNormalGlobalDirection;
        std::vector<std::vector<std::array<bool, 2>>> Cell3DsFacesTangentsGlobalDirection;
        std::vector<std::vector<std::vector<bool>>> Cell3DsFacesEdgeDirections;
        std::vector<std::vector<Eigen::MatrixXd>> Cell3DsFaces3DVertices; 
        std::vector<std::vector<Eigen::MatrixXd>> Cell3DsFaces2DVertices; 
        std::vector<std::vector<std::vector<Eigen::Matrix3d>>> Cell3DsFaces3DTriangulations; 
        std::vector<std::vector<std::vector<Eigen::Matrix3d>>> Cell3DsFaces2DTriangulations; 
        std::vector<std::vector<double>> Cell3DsFacesAreas;                   
        std::vector<std::vector<Eigen::Vector3d>> Cell3DsFaces2DCentroids;    
        std::vector<std::vector<double>> Cell3DsFacesDiameters;               
        std::vector<std::vector<Eigen::VectorXd>> Cell3DsFacesEdgeLengths;    
        std::vector<std::vector<Eigen::MatrixXd>> Cell3DsFacesEdge3DTangents; 
        std::vector<std::vector<Eigen::MatrixXd>> Cell3DsFacesEdges3DCentroid;
        std::vector<std::vector<Eigen::MatrixXd>> Cell3DsFacesEdge2DTangents; 
        std::vector<std::vector<Eigen::MatrixXd>> Cell3DsFacesEdges2DCentroid;
        std::vector<std::vector<Eigen::MatrixXd>> Cell3DsFacesEdge2DNormals; 
    };
 
    struct VTPPolyhedron final
    {
        Eigen::MatrixXd Vertices;                               
        std::vector<std::vector<unsigned int>> PolyhedronFaces; 
    };
 
    struct AgglomerateTrianglesResult final
    {
        std::vector<unsigned int> RemovedEdges;
        std::vector<unsigned int> VerticesIndex;
        std::vector<unsigned int> EdgesIndex;
    };
 
    struct AgglomerateMeshFromTriangularMeshResult final
    {
        struct ConcaveCell2D
        {
            unsigned int Cell2DIndex;
            std::vector<unsigned int> ConvexCell2DsIndex;
        };
 
        std::vector<Gedim::MeshUtilities::AgglomerateMeshFromTriangularMeshResult::ConcaveCell2D> ConcaveCell2Ds;
        std::vector<unsigned int> RemovedCell1Ds;
        std::vector<unsigned int> RemovedCell2Ds;
    };
 
    struct AgglomerationInformation final
    {
        std::vector<unsigned int> OriginalCell0DToAgglomeratedCell0Ds = {};
        std::vector<unsigned int> OriginalCell1DToAgglomeratedCell1Ds = {};
        std::vector<unsigned int> OriginalCell2DToAgglomeratedCell2Ds = {};
        std::vector<unsigned int> AgglomeratedCell0DToOriginalCell0Ds = {};
        std::vector<std::vector<unsigned int>> AgglomeratedCell1DToOriginalCell1Ds = {};
        std::vector<std::vector<unsigned int>> AgglomeratedCell2DToOriginalCell2Ds = {};
    };
 
    struct AgglomerateCell1DInformation final
    {
        std::vector<unsigned int> AgglomerateCell1DVertices;
        std::vector<unsigned int> SubCell1DsRemovedVertices;
    };
 
    struct AgglomerateCell2DInformation final
    {
        std::vector<unsigned int> AgglomerateCell2DVertices;
        std::vector<unsigned int> AgglomerateCell2DEdges;
        std::vector<unsigned int> SubCell2DsRemovedVertices;
        std::vector<unsigned int> SubCell2DsRemovedEdges;
    };
 
    struct AgglomerateCell3DInformation final
    {
        std::vector<unsigned int> AgglomerateCell3DVertices;
        std::vector<unsigned int> AgglomerateCell3DEdges;
        std::vector<unsigned int> AgglomerateCell3DFaces;
        std::vector<unsigned int> SubCell3DsRemovedVertices;
        std::vector<unsigned int> SubCell3DsRemovedEdges;
        std::vector<unsigned int> SubCell3DsRemovedFaces;
    };
 
    struct FindConcaveCell3DFacesConvexCell2DResult final
    {
        struct ConvexCell2D final
        {
            unsigned int ConvexCell3DIndex = 0;
            unsigned int ConvexCell3DFaceIndex = 0;
        };
 
        std::vector<Gedim::MeshUtilities::FindConcaveCell3DFacesConvexCell2DResult::ConvexCell2D> ConcaveCell3DFacesConvexCell2D = {};
    };
 
    struct Mesh3DPolyhedron final
    {
        std::vector<unsigned int> VerticesIndex;
        std::vector<unsigned int> EdgesIndex;
        std::vector<unsigned int> FacesIndex;
    };
 
    struct FindPointMeshPositionResult final
    {
        struct PointMeshPosition final
        {
            enum struct Types
            {
                Unknown = 0,
                Outside = 1,
                Cell0D = 2,
                Cell1D = 3,
                Cell2D = 4,
                Cell3D = 5
            };
 
            Gedim::MeshUtilities::FindPointMeshPositionResult::PointMeshPosition::Types Type;
            unsigned int Cell_index;
        };
 
        std::vector<Gedim::MeshUtilities::FindPointMeshPositionResult::PointMeshPosition> MeshPositions;
    };
 
    struct FindPointCell2DResult final
    {
        struct PointCell2DFound final
        {
            unsigned int Cell2D_index;
            Gedim::GeometryUtilities::PointPolygonPositionResult Cell2D_Position;
        };
 
        std::vector<Gedim::MeshUtilities::FindPointCell2DResult::PointCell2DFound> Cell2Ds_found;
    };
 
    struct FindPointCell3DResult final
    {
        struct PointCell3DFound final
        {
            unsigned int Cell3D_index;
            Gedim::GeometryUtilities::PointPolyhedronPositionResult Cell3D_Position;
        };
 
        std::vector<Gedim::MeshUtilities::FindPointCell3DResult::PointCell3DFound> Cell3Ds_found;
    };
 
    struct Intersect_mesh_polyhedron_result final
    {
        enum struct Types
        {
            None = 1,     
            Vertices = 2, 
        };
 
        struct Polyhedron_Intersection final
        {
            enum struct Types
            {
                Vertex = 1,
                Edge = 2,
                Face = 3,
                Polyhedron = 4
            };
 
            Gedim::MeshUtilities::Intersect_mesh_polyhedron_result::Polyhedron_Intersection::Types Type;
            unsigned int Geometry_index;
            std::vector<unsigned int> Cell0Ds_index;
            std::vector<unsigned int> Cell1Ds_index;
            std::vector<unsigned int> Cell2Ds_index;
            std::vector<unsigned int> Cell3Ds_index;
        };
 
        struct Mesh_Intersections final
        {
            std::map<unsigned int, unsigned int> Cell0Ds_intersections;
            std::map<unsigned int, std::vector<unsigned int>> Cell1Ds_intersections;
            std::map<unsigned int, std::vector<unsigned int>> Cell2Ds_intersections;
            std::map<unsigned int, std::vector<unsigned int>> Cell3Ds_intersections;
        };
 
        Gedim::MeshUtilities::Intersect_mesh_polyhedron_result::Types Type;
        Eigen::MatrixXd Intersections_Coordinates;
        std::vector<Gedim::MeshUtilities::Intersect_mesh_polyhedron_result::Polyhedron_Intersection> Polyhedron_intersections;
        Gedim::MeshUtilities::Intersect_mesh_polyhedron_result::Mesh_Intersections Mesh_intersections;
    };
 
  public:
    MeshUtilities(){};
    ~MeshUtilities(){};
 
    void ExtractActiveMesh(Gedim::IMeshDAO &mesh, Gedim::MeshUtilities::ExtractActiveMeshData &extractionData) const;
 
    Gedim::MeshUtilities::FilterMeshData FilterActiveMesh(const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::FilterMeshData FilterMesh1D(const std::vector<unsigned int> &cell1DsFilter,
                                                      const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::FilterMeshData FilterMesh2D(const std::vector<unsigned int> &cell2DsFilter,
                                                      const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::FilterMeshData FilterMesh3D(const std::vector<unsigned int> &cell3DsFilter,
                                                      const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::ExtractMeshData ExtractMesh1D(const std::vector<unsigned int> &cell0DsFilter,
                                                        const std::vector<unsigned int> &cell1DsFilter,
                                                        const Gedim::IMeshDAO &originalMesh,
                                                        Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::ExtractMeshData ExtractMesh2D(const std::vector<unsigned int> &cell0DsFilter,
                                                        const std::vector<unsigned int> &cell1DsFilter,
                                                        const std::vector<unsigned int> &cell2DsFilter,
                                                        const Gedim::IMeshDAO &originalMesh,
                                                        Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::ExtractMeshData ExtractMesh3D(const std::vector<unsigned int> &cell0DsFilter,
                                                        const std::vector<unsigned int> &cell1DsFilter,
                                                        const std::vector<unsigned int> &cell2DsFilter,
                                                        const std::vector<unsigned int> &cell3DsFilter,
                                                        const Gedim::IMeshDAO &originalMesh,
                                                        Gedim::IMeshDAO &mesh) const;
 
    void FillMesh1D(const Gedim::GeometryUtilities &geometryUtilities,
                    const Eigen::Vector3d &segmentOrigin,
                    const Eigen::Vector3d &segmentTangent,
                    const std::vector<double> &coordinates,
                    Gedim::IMeshDAO &mesh) const;
 
    void FillMesh2D(const Eigen::MatrixXd &cell0Ds,
                    const Eigen::MatrixXi &cell1Ds,
                    const std::vector<Eigen::MatrixXi> &cell2Ds,
                    Gedim::IMeshDAO &mesh) const;
 
    void FillMesh3D(const Eigen::MatrixXd &cell0Ds,
                    const Eigen::MatrixXi &cell1Ds,
                    const std::vector<Eigen::MatrixXi> &cell2Ds,
                    const std::vector<Mesh3DPolyhedron> &cell3Ds,
                    Gedim::IMeshDAO &mesh) const;
 
    void FillMesh3D(const Eigen::MatrixXd &cell0Ds,
                    const std::vector<std::pair<unsigned int, unsigned int>> &cell1Ds_vertices,
                    const std::vector<std::vector<unsigned int>> &cell2Ds_vertices,
                    const std::vector<std::vector<unsigned int>> &cell2Ds_edges,
                    const std::vector<std::vector<unsigned int>> &cell3Ds_vertices,
                    const std::vector<std::vector<unsigned int>> &cell3Ds_edges,
                    const std::vector<std::vector<unsigned int>> &cell3Ds_faces,
                    Gedim::IMeshDAO &mesh) const;
 
    void FillMesh3D(const Eigen::MatrixXd &cell0Ds,
                    const std::vector<std::vector<std::vector<unsigned int>>> &cell3Ds_faces_vertices,
                    Gedim::IMeshDAO &mesh) const;
 
    void FixCell2DsOrientation(const Gedim::GeometryUtilities &geometryUtilities, IMeshDAO &mesh) const;
 
    void SetMesh3DMarker(const unsigned int marker, Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::ComputeMesh2DCell1DsResult ComputeMesh2DCell1Ds(const Eigen::MatrixXd &cell0Ds,
                                                                          const std::vector<Eigen::VectorXi> &cell2Ds) const;
 
    void CheckMesh2D(const Gedim::MeshUtilities::CheckMesh2DConfiguration &configuration,
                     const Gedim::GeometryUtilities &geometryUtilities,
                     const Gedim::IMeshDAO &convexMesh) const;
 
    void CheckMesh3D(const Gedim::MeshUtilities::CheckMesh3DConfiguration &configuration,
                     const Gedim::GeometryUtilities &geometryUtilities,
                     const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::ComputeMesh3DAlignedCell1DsResult ComputeMesh3DAlignedCell1Ds(
        const std::vector<std::vector<std::vector<unsigned int>>> &cell3DsAlignedEdgesVertices,
        const std::vector<std::vector<std::vector<unsigned int>>> &cell3DsAlignedEdgesEdges,
        const Gedim::IMeshDAO &mesh) const;
 
    void CheckMeshGeometricData3D(const Gedim::MeshUtilities::CheckMeshGeometricData3DConfiguration &configuration,
                                  const Gedim::GeometryUtilities &geometryUtilities,
                                  const Gedim::IMeshDAO &mesh,
                                  const Gedim::MeshUtilities::MeshGeometricData3D &geometricData) const;
 
    void Mesh1DFromSegment(const Gedim::GeometryUtilities &geometryUtilities,
                           const Eigen::MatrixXd &segmentVertices,
                           const std::vector<unsigned int> vertexMarkers,
                           Gedim::IMeshDAO &mesh) const;
 
    void Mesh2DFromPolygon(const Eigen::MatrixXd &polygonVertices,
                           const std::vector<unsigned int> vertexMarkers,
                           const std::vector<unsigned int> edgeMarkers,
                           Gedim::IMeshDAO &mesh) const;
 
    void SetMeshMarkersOnLine(const Gedim::GeometryUtilities &geometryUtilities,
                              const Eigen::Vector3d &lineOrigin,
                              const Eigen::Vector3d &lineTangent,
                              const double &lineTangentSquaredLength,
                              const unsigned int &marker,
                              Gedim::IMeshDAO &mesh) const;
 
    void SetMeshMarkersOnSegment(const Gedim::GeometryUtilities &geometryUtilities,
                                 const Eigen::Vector3d &segment_origin,
                                 const Eigen::Vector3d &segment_tangent,
                                 const double &segment_tangent_squared_length,
                                 const unsigned int &marker,
                                 Gedim::IMeshDAO &mesh) const;
 
    void Mesh3DFromPolyhedron(const Eigen::MatrixXd &polyhedronVertices,
                              const Eigen::MatrixXi &polyhedronEdges,
                              const std::vector<Eigen::MatrixXi> &polyhedronFaces,
                              const std::vector<unsigned int> vertexMarkers,
                              const std::vector<unsigned int> edgeMarkers,
                              const std::vector<unsigned int> faceMarkers,
                              Gedim::IMeshDAO &mesh) const;
 
    void SetMeshMarkersOnPlane(const Gedim::GeometryUtilities &geometryUtilities,
                               const Eigen::Vector3d &planeNormal,
                               const Eigen::Vector3d &planeOrigin,
                               const unsigned int &marker,
                               Gedim::IMeshDAO &mesh) const;
 
    void SetMeshMarkersByFaceNormal(const Gedim::GeometryUtilities &geometryUtilities,
                                    const Eigen::Vector3d &normal,
                                    const std::vector<Eigen::Vector3d> &cell2Ds_normal,
                                    const unsigned int &marker,
                                    Gedim::IMeshDAO &mesh) const;
 
    void SetMeshMarkersOnPolygon(const Gedim::GeometryUtilities &geometryUtilities,
                                 const Eigen::Vector3d &polygon_plane_normal,
                                 const Eigen::Vector3d &polygon_plane_origin,
                                 const Eigen::MatrixXd &polygon_vertices_2D,
                                 const Eigen::Vector3d &polygon_translation,
                                 const Eigen::Matrix3d &polygon_rotation_matrix,
                                 const unsigned int &marker,
                                 Gedim::IMeshDAO &mesh) const;
 
    void SetMeshMarkersOnPolygon(const Gedim::GeometryUtilities &geometryUtilities,
                                 const Eigen::Vector3d &polygon_plane_normal,
                                 const Eigen::Vector3d &polygon_plane_origin,
                                 const Eigen::MatrixXd &polygon_vertices_2D,
                                 const Eigen::Vector3d &polygon_translation,
                                 const Eigen::Matrix3d &polygon_rotation_matrix,
                                 const std::vector<Eigen::Vector3d> &cell1Ds_centroid,
                                 const std::vector<Eigen::Vector3d> &cell2Ds_centroid,
                                 const unsigned int &marker,
                                 Gedim::IMeshDAO &mesh) const;
 
    std::vector<unsigned int> MeshCell2DRoots(const Gedim::IMeshDAO &mesh) const;
 
    MeshGeometricData1D FillMesh1DGeometricData(const Gedim::GeometryUtilities &geometryUtilities,
                                                const Gedim::IMeshDAO &convexMesh) const;
 
    MeshGeometricData1D ImportMeshGeometricData1DFromTxt(const std::string &file_path);
    void ExportMeshGeometricData1DToTxt(const MeshGeometricData1D &mesh_geometric_data, const std::string &file_path);
 
    MeshGeometricData2D FillMesh2DGeometricData(const Gedim::GeometryUtilities &geometryUtilities,
                                                const Gedim::IMeshDAO &convexMesh) const;
 
    MeshUtilities::MeshGeometricData2D FillMesh2DGeometricData(const Gedim::GeometryUtilities &geometryUtilities,
                                                               const Gedim::IMeshDAO &mesh,
                                                               const std::vector<Gedim::GeometryUtilities::PolygonTypes> &meshCell2DsPolygonType,
                                                               const MeshGeometricData2DConfig &config = MeshGeometricData2DConfig()) const;
 
    MeshGeometricData2D FillMesh2DGeometricData(const Gedim::GeometryUtilities &geometryUtilities,
                                                const Gedim::IMeshDAO &mesh,
                                                const Gedim::IMeshDAO &convexMesh,
                                                const std::vector<std::vector<unsigned int>> &meshCell2DToConvexCell2DIndices) const;
 
    MeshGeometricData2D ImportMeshGeometricData2DFromTxt(const std::string &file_path);
    void ExportMeshGeometricData2DToTxt(const MeshGeometricData2D &mesh_geometric_data, const std::string &file_path);
 
    MeshGeometricData3D FillMesh3DGeometricData(const Gedim::GeometryUtilities &geometryUtilities,
                                                const Gedim::IMeshDAO &convexMesh) const;
 
    MeshGeometricData3D FillMesh3DGeometricData(const Gedim::GeometryUtilities &geometryUtilities,
                                                const Gedim::IMeshDAO &mesh,
                                                const Gedim::IMeshDAO &convexMesh,
                                                const std::vector<std::vector<unsigned int>> &meshCell3DToConvexCell3DIndices) const;
 
    MeshGeometricData3D FillMesh3DGeometricData(const Gedim::GeometryUtilities &geometryUtilities,
                                                const Gedim::IMeshDAO &mesh,
                                                const std::vector<std::vector<Eigen::MatrixXd>> &cell3Ds_tetra_vertices,
                                                const std::vector<std::vector<Eigen::Matrix3d>> &cell2Ds_triangles_3D_vertices) const;
 
    MeshGeometricData3D ImportMeshGeometricData3DFromTxt(const std::string &file_path);
    void ExportMeshGeometricData3DToTxt(const MeshGeometricData3D &mesh_geometric_data, const std::string &file_path);
 
    void ComputeCell0DCell1DNeighbours(Gedim::IMeshDAO &mesh) const;
    void ComputeCell0DCell2DNeighbours(Gedim::IMeshDAO &mesh) const;
    void ComputeCell0DCell3DNeighbours(Gedim::IMeshDAO &mesh) const;
 
    void ComputeCell1DCell2DNeighbours(Gedim::IMeshDAO &mesh) const;
 
    void ComputeCell1DCell3DNeighbours(Gedim::IMeshDAO &mesh) const;
 
    void ComputeCell2DCell3DNeighbours(Gedim::IMeshDAO &mesh) const;
 
    void CreateRectangleMesh(const Eigen::Vector3d &rectangleOrigin,
                             const Eigen::Vector3d &rectangleBaseTangent,
                             const Eigen::Vector3d &rectangleHeightTangent,
                             const std::vector<double> &baseMeshCurvilinearCoordinates,
                             const std::vector<double> &heightMeshCurvilinearCoordinates,
                             Gedim::IMeshDAO &mesh) const;
 
    void CreateStructuredTriangularMesh(const Eigen::Vector3d &rectangleOrigin,
                                        const Eigen::Vector3d &rectangleBaseTangent,
                                        const Eigen::Vector3d &rectangleHeightTangent,
                                        const std::vector<double> &baseMeshCurvilinearCoordinates,
                                        const std::vector<double> &heightMeshCurvilinearCoordinates,
                                        Gedim::IMeshDAO &mesh) const;
 
    void CreateParallelepipedMesh(const Eigen::Vector3d &rectangleOrigin,
                                  const Eigen::Vector3d &rectangleLengthTangent,
                                  const Eigen::Vector3d &rectangleHeightTangent,
                                  const Eigen::Vector3d &rectangleWidthTangent,
                                  const std::vector<double> &lengthMeshCurvilinearCoordinates,
                                  const std::vector<double> &heightMeshCurvilinearCoordinates,
                                  const std::vector<double> &widthMeshCurvilinearCoordinates,
                                  Gedim::IMeshDAO &mesh) const;
 
    void CreateTrianglePlusHangingNodesMesh(const Eigen::Vector3d &rectangleOrigin,
                                            const Eigen::Vector3d &rectangleBaseTangent,
                                            const Eigen::Vector3d &rectangleHeightTangent,
                                            const std::vector<double> &baseMeshCurvilinearCoordinates,
                                            const std::vector<double> &heightMeshCurvilinearCoordinates,
                                            const std::vector<unsigned int> &numberOfAddedVerticesForEachRectangle,
                                            const Gedim::GeometryUtilities &geometryUtilities,
                                            Gedim::IMeshDAO &mesh) const;
 
    void CreateRectanglePlusHangingNodesMesh(const Eigen::Vector3d &rectangleOrigin,
                                             const Eigen::Vector3d &rectangleBaseTangent,
                                             const Eigen::Vector3d &rectangleHeightTangent,
                                             const std::vector<double> &baseMeshCurvilinearCoordinates,
                                             const std::vector<double> &heightMeshCurvilinearCoordinates,
                                             const std::vector<unsigned int> &numberOfAddedVerticesForEachRectangle,
                                             const Gedim::GeometryUtilities &geometryUtilities,
                                             Gedim::IMeshDAO &mesh) const;
 
    void CreateQuadrilateralMeshFromTriangularMesh(const Gedim::GeometryUtilities &geometryUtilities,
                                                   const Gedim::IMeshDAO &triangular_mesh,
                                                   Gedim::IMeshDAO &mesh) const;
 
    void CreateQuadrilateralMeshFromTriangularMesh(const Gedim::GeometryUtilities &geometryUtilities,
                                                   const Eigen::MatrixXd &polygonVertices,
                                                   const double &maxTriangleArea,
                                                   Gedim::IMeshDAO &mesh) const;
 
    void CreateTriangularMesh(const Eigen::MatrixXd &polygonVertices,
                              const double &maxTriangleArea,
                              Gedim::IMeshDAO &mesh,
                              const std::string &options = "-QDzpqnea") const;
 
    void CreatePolygonalMesh(const Gedim::GeometryUtilities &geometryUtilities,
                             const Eigen::MatrixXd &polygonVertices,
                             const unsigned int numPoints,
                             const unsigned int numIterations,
                             Gedim::IMeshDAO &mesh,
                             const unsigned int random_seed = 0) const;
 
    void CreateTetrahedralMesh(const Eigen::MatrixXd &polyhedronVertices,
                               const Eigen::MatrixXi &polyhedronEdges,
                               const std::vector<Eigen::MatrixXi> &polyhedronFaces,
                               const double &maxTetrahedronVolume,
                               Gedim::IMeshDAO &mesh,
                               const std::string &options = "Qpqfezna") const;
    void CreateTetrahedralMesh(const Eigen::MatrixXd &points,
                               const std::vector<std::vector<unsigned int>> &facets,
                               const double &maxTetrahedronVolume,
                               Gedim::IMeshDAO &mesh,
                               const std::string &options = "Qpqfezna") const;
 
    void CreateDelaunayMesh3D(const Eigen::MatrixXd &points, const std::vector<unsigned int> &points_marker, Gedim::IMeshDAO &mesh) const;
 
    void CreatePolyhedralMesh(const Gedim::GeometryUtilities &geometryUtilities,
                              const Eigen::MatrixXd &polyhedronVertices,
                              const Eigen::MatrixXi &polyhedronEdges,
                              const std::vector<Eigen::MatrixXi> &polyhedronFaces,
                              const unsigned int numPoints,
                              const unsigned int numIterations,
                              Gedim::IMeshDAO &mesh,
                              const unsigned int random_seed = 0) const;
 
    void MakeMeshTriangularFaces(const std::vector<std::vector<unsigned int>> &faces_triangulation, Gedim::IMeshDAO &mesh) const;
 
    void ImportTriangularMesh(const Gedim::GeometryUtilities &geometry_utilities,
                              const std::string &cell0Ds_file_path,
                              const std::string &cell2Ds_file_path,
                              const std::string &marker_file_path,
                              const char separator,
                              Gedim::IMeshDAO &mesh) const;
 
    void ImportRegnFaceMesh(const Gedim::GeometryUtilities &geometry_utilities,
                            const std::string &node_file_path,
                            const std::string &ele_file_path,
                            IMeshDAO &mesh) const;
 
    void ImportOpenVolumeMesh(const std::string &ovmFilePath,
                              Gedim::IMeshDAO &mesh,
                              std::vector<std::vector<bool>> &meshCell3DsFacesOrientation) const;
 
    void ExportMeshToOpenVolume(const Gedim::IMeshDAO &mesh,
                                const std::vector<std::vector<bool>> &meshCell3DsFacesOrientation,
                                const std::string &ovmFilePath) const;
 
    void ImportVtkMesh3D(const std::string &vtkFilePath, Gedim::IMeshDAO &mesh) const;
 
    void ImportObjectFileFormat(const std::string &offFilePath, Gedim::IMeshDAO &mesh) const;
 
    void ExportMeshToObjectFileFormat(const Gedim::IMeshDAO &mesh, const std::string &offFilePath) const;
 
    void ImportWavefrontOBJ(const std::string &offFilePath, Gedim::IMeshDAO &mesh) const;
 
    void ExportMeshToWavefrontOBJ(const Gedim::IMeshDAO &mesh, const std::string &offFilePath) const;
 
    void ChangePolygonMeshMarkers(const Eigen::MatrixXd &polygonVertices,
                                  const std::vector<unsigned int> &cell0DMarkers,
                                  const std::vector<unsigned int> &cell1DMarkers,
                                  Gedim::IMeshDAO &mesh) const;
 
    void ChangePolyhedronMeshMarkers(const Gedim::GeometryUtilities &geometryUtilities,
                                     const Eigen::MatrixXd &polyhedron_vertices,
                                     const Eigen::MatrixXi &polyhedron_edges,
                                     const std::vector<Eigen::MatrixXi> &polyhedron_faces,
                                     const Eigen::MatrixXd &polyhedron_edges_tangent,
                                     const Eigen::VectorXd &polyhedron_edges_length,
                                     const std::vector<Eigen::Vector3d> &polyhedron_faces_normal,
                                     const std::vector<Eigen::MatrixXd> &polyhedron_faces_vertices,
                                     const std::vector<Eigen::MatrixXd> &polyhedron_faces_vertices_2D,
                                     const std::vector<Eigen::Vector3d> &polyhedron_faces_translation,
                                     const std::vector<Eigen::Matrix3d> &polyhedron_faces_rotation_matrix,
                                     const std::vector<unsigned int> &polyhedron_vertices_marker,
                                     const std::vector<unsigned int> &polyhedron_edges_marker,
                                     const std::vector<unsigned int> &polyhedron_faces_marker,
                                     const std::vector<Eigen::Vector3d> &cell1Ds_centroid,
                                     const std::vector<Eigen::Vector3d> &cell2Ds_centroid,
                                     Gedim::IMeshDAO &mesh) const;
 
    void ExportMeshToVTU(const Gedim::IMeshDAO &mesh,
                         const std::string &exportFolder,
                         const std::string &fileName,
                         const bool &separateFile = false) const;
 
    void ExportMeshToUCD(const Gedim::IMeshDAO &mesh,
                         const std::string &exportFolder,
                         const std::string &fileName,
                         const bool &separateFile = false) const;
 
    void ExportMeshToMEDIT(const Gedim::IMeshDAO &mesh,
                           const std::string &exportFolder,
                           const std::string &fileName,
                           const bool &separateFile = false,
                           const unsigned int &order = 1) const;
 
    void ExportCell2DToVTU(const Gedim::IMeshDAO &mesh,
                           const unsigned int &cell2DIndex,
                           const Eigen::MatrixXd &cell2DVertices,
                           const std::vector<Eigen::Matrix3d> &cell2DTriangulations,
                           const double &cell2DArea,
                           const Eigen::Vector3d &cell2DCentroid,
                           const std::string &exportFolder) const;
 
    void ExportCell3DToVTU(const Gedim::GeometryUtilities &geometryUtilities,
                           const Gedim::IMeshDAO &mesh,
                           const unsigned int &cell3DIndex,
                           const Eigen::MatrixXd &cell3DVertices,
                           const std::vector<Eigen::MatrixXd> &cell3DTetrahedrons,
                           const std::vector<std::vector<Eigen::Matrix3d>> &cell3DFaces3DTriangulations,
                           const double &cell3DVolume,
                           const Eigen::Vector3d &cell3DCentroid,
                           const std::vector<Eigen::Vector3d> &cell3DFacesTranslation,
                           const std::vector<Eigen::Matrix3d> &cell3DFacesRotationMatrix,
                           const std::vector<double> &cell3DFacesArea,
                           const std::vector<Eigen::MatrixXd> &cell3DFaces2DVertices,
                           const std::vector<Eigen::MatrixXd> &cell3DFaces3DVertices,
                           const std::vector<Eigen::VectorXd> &cell3DFacesEdgeLengths,
                           const std::vector<std::vector<bool>> &cell3DFacesEdgeDirections,
                           const std::vector<Eigen::MatrixXd> &cell3DFacesEdges2DTangent,
                           const std::vector<Eigen::MatrixXd> &cell3DFacesEdges2DNormal,
                           const std::vector<Eigen::Vector3d> &cell3DFacesNormals,
                           const std::vector<bool> &cell3DFacesNormalDirections,
                           const std::vector<Eigen::Vector3d> &cell3DFaces2DCentroids,
                           const std::string &exportFolder) const;
 
    Gedim::GeometryUtilities::Polyhedron MeshCell3DToPolyhedron(const Gedim::IMeshDAO &mesh, const unsigned int &cell3DIndex) const;
 
    MeshUtilities::VTPPolyhedron MeshCell3DToVTPPolyhedron(const Gedim::IMeshDAO &mesh, const unsigned int &cell3DIndex) const;
 
    std::vector<unsigned int> SplitCell1D(const unsigned int &cell1DIndex, const Eigen::MatrixXi subCell1Ds, Gedim::IMeshDAO &mesh) const;
 
    std::vector<unsigned int> SplitCell2D(const unsigned int &cell2DIndex,
                                          const std::vector<Eigen::MatrixXi> &subCell2Ds,
                                          Gedim::IMeshDAO &mesh) const;
 
    std::vector<unsigned int> SplitCell3D(const unsigned int &cell3DIndex,
                                          const std::vector<std::vector<unsigned int>> &subCell3DsVertices,
                                          const std::vector<std::vector<unsigned int>> &subCell3DsEdges,
                                          const std::vector<std::vector<unsigned int>> &subCell3DsFaces,
                                          Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::AgglomerateCell1DInformation AgglomerateCell1Ds(const std::unordered_set<unsigned int> &cell1DsIndex,
                                                                          const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::AgglomerateCell2DInformation AgglomerateCell2Ds(const Gedim::GeometryUtilities &geometryUtilities,
                                                                          const std::unordered_set<unsigned int> &cell2DsIndex,
                                                                          const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::AgglomerateCell3DInformation AgglomerateCell3Ds(const std::unordered_set<unsigned int> &cell3DsIndex,
                                                                          const Gedim::IMeshDAO &mesh) const;
 
    unsigned int AgglomerateCell1Ds(const std::unordered_set<unsigned int> &subCell1DsIndex,
                                    const std::vector<unsigned int> &agglomerateCell1DVertices,
                                    const std::vector<unsigned int> &subCell1DsRemovedCell0Ds,
                                    Gedim::IMeshDAO &mesh,
                                    std::vector<std::vector<unsigned int>> &meshCell1DsOriginalCell1Ds,
                                    const bool mantain_neigh2D_order = false) const;
 
    unsigned int AgglomerateCell2Ds(const std::unordered_set<unsigned int> &subCell2DsIndex,
                                    const std::vector<unsigned int> &agglomerateCell2DVertices,
                                    const std::vector<unsigned int> &agglomerateCell2DEdges,
                                    const std::vector<unsigned int> &subCell2DsRemovedCell0Ds,
                                    const std::vector<unsigned int> &subCell2DsRemovedCell1Ds,
                                    Gedim::IMeshDAO &mesh,
                                    std::vector<std::vector<unsigned int>> &meshCell2DsOriginalCell2Ds) const;
 
    unsigned int AgglomerateCell3Ds(const std::unordered_set<unsigned int> &subCell3DsIndex,
                                    const std::vector<unsigned int> &agglomerateCell3DVertices,
                                    const std::vector<unsigned int> &agglomerateCell3DEdges,
                                    const std::vector<unsigned int> &agglomerateCell3DFaces,
                                    const std::vector<unsigned int> &subCell3DsRemovedCell0Ds,
                                    const std::vector<unsigned int> &subCell3DsRemovedCell1Ds,
                                    const std::vector<unsigned int> &subCell3DsRemovedCell2Ds,
                                    Gedim::IMeshDAO &mesh,
                                    std::vector<std::vector<unsigned int>> &meshCell3DsOriginalCell3Ds) const;
 
    void CreateRandomlyDeformedQuadrilaterals(const Gedim::GeometryUtilities &geometryUtilities,
                                              const Eigen::Vector3d &rectangleOrigin,
                                              const Eigen::Vector3d &rectangleBaseTangent,
                                              const Eigen::Vector3d &rectangleHeightTangent,
                                              const unsigned int &numQuadrilateralsBaseTangent,
                                              const unsigned int &numQuadrilateralsHeightTangent,
                                              const double &maxDeformingPercentageBase,
                                              const double &maxDeformingPercentageHeight,
                                              Gedim::IMeshDAO &mesh) const;
 
    void CreateDistortedQuadrilaterals(const Gedim::GeometryUtilities &geometryUtilities,
                                       const Eigen::Vector3d &rectangleOrigin,
                                       const Eigen::Vector3d &rectangleBaseTangent,
                                       const Eigen::Vector3d &rectangleHeightTangent,
                                       const unsigned int &numQuadrilateralsBaseTangent,
                                       const unsigned int &numQuadrilateralsHeightTangent,
                                       Gedim::IMeshDAO &mesh) const;
    std::vector<unsigned int> FindCell2DsCommonVertices(const std::vector<unsigned int> &cell2DsIndex,
                                                        const Gedim::IMeshDAO &mesh) const;
 
    std::vector<unsigned int> FindCell2DsCommonEdges(const std::vector<unsigned int> &cell2DsIndex, const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::FindConcaveCell3DFacesConvexCell2DResult FindConcaveCell3DFacesConvexCell2D(
        const Gedim::GeometryUtilities &geometryUtilities,
        const unsigned int &concaveCell3DIndex,
        const Gedim::IMeshDAO &mesh,
        const Gedim::IMeshDAO &convexMesh,
        const std::vector<unsigned int> &convexCell3DIndices,
        const std::vector<Eigen::MatrixXd> &concaveCell3DFaces3DVertices,
        const std::vector<Eigen::MatrixXd> &concaveCell3DFaces2DVertices,
        const std::vector<Eigen::Vector3d> &concaveCell3DFacesTranslation,
        const std::vector<Eigen::Matrix3d> &concaveCell3DFacesRotationMatrix,
        const std::vector<Eigen::Vector3d> &concaveCell3DFacesNormal,
        const std::vector<std::vector<Eigen::MatrixXd>> &convexCell3DsFaces3DVertices,
        const std::vector<std::vector<std::vector<unsigned int>>> &convexCell3DsFacesUnalignedVertices) const;
 
    Gedim::MeshUtilities::FindConcaveCell3DFacesConvexCell2DResult FindConcaveCell3DFacesConvexCell2D(
        const Gedim::GeometryUtilities &geometryUtilities,
        const unsigned int &concaveCell3DIndex,
        const Gedim::IMeshDAO &mesh,
        const std::vector<Eigen::MatrixXd> &concaveCell3DTetra,
        const std::vector<std::vector<Eigen::Matrix3d>> &concaveCell3D_faces_2D_triangles,
        const std::vector<Eigen::MatrixXd> &concaveCell3DFaces3DVertices,
        const std::vector<Eigen::Vector3d> &concaveCell3DFacesTranslation,
        const std::vector<Eigen::Matrix3d> &concaveCell3DFacesRotationMatrix,
        const std::vector<Eigen::Vector3d> &concaveCell3DFacesNormal,
        const std::vector<std::vector<Eigen::MatrixXd>> &convexCell3DsFaces3DVertices,
        const std::vector<std::vector<std::vector<unsigned int>>> &convexCell3DsFacesUnalignedVertices) const;
 
    Gedim::MeshUtilities::FindPointMeshPositionResult FindPointMeshPosition(const MeshUtilities::FindPointCell2DResult &find_cell2D_result,
                                                                            const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::FindPointMeshPositionResult FindPointMeshPosition(const MeshUtilities::FindPointCell3DResult &find_cell3D_result,
                                                                            const Gedim::IMeshDAO &mesh) const;
 
    Gedim::MeshUtilities::FindPointCell2DResult FindPointCell2D(const Gedim::GeometryUtilities &geometryUtilities,
                                                                const Eigen::Vector3d &point,
                                                                const Gedim::IMeshDAO &mesh,
                                                                const std::vector<Eigen::MatrixXd> &cell2DsVertices,
                                                                const std::vector<Eigen::MatrixXd> &cell2DsBoundingBox,
                                                                const bool find_only_first_cell2D = true,
                                                                const unsigned int starting_cell2D_index = 0) const;
 
    Gedim::MeshUtilities::FindPointCell3DResult FindPointCell3D(
        const Gedim::GeometryUtilities &geometryUtilities,
        const Eigen::Vector3d &point,
        const Gedim::IMeshDAO &mesh,
        const std::vector<std::vector<Eigen::MatrixXi>> &cell3DsFaces,
        const std::vector<std::vector<Eigen::MatrixXd>> &cell3DsFaceVertices,
        const std::vector<std::vector<Eigen::MatrixXd>> &cell3DsFaceRotatedVertices,
        const std::vector<std::vector<Eigen::Vector3d>> &cell3DsFaceNormals,
        const std::vector<std::vector<bool>> &cell3DsFaceNormalDirections,
        const std::vector<std::vector<Eigen::Vector3d>> &cell3DsFaceTranslations,
        const std::vector<std::vector<Eigen::Matrix3d>> &cell3DsFaceRotationMatrices,
        const std::vector<Eigen::MatrixXd> &cell3DsBoundingBox,
        const bool find_only_first_cell3D = true,
        const unsigned int starting_cell3D_index = 0) const;
 
    Gedim::MeshUtilities::FindPointCell3DResult FindPointCell3D(
        const Gedim::GeometryUtilities &geometryUtilities,
        const Eigen::Vector3d &point,
        const Gedim::IMeshDAO &mesh,
        const std::vector<std::vector<Eigen::MatrixXi>> &cell3DsFaces,
        const std::vector<std::vector<Eigen::MatrixXd>> &cell3DsFaceVertices,
        const std::vector<std::vector<Eigen::MatrixXd>> &cell3DsFaceRotatedVertices,
        const std::vector<std::vector<Eigen::Vector3d>> &cell3DsFaceNormals,
        const std::vector<std::vector<bool>> &cell3DsFaceNormalDirections,
        const std::vector<std::vector<Eigen::Vector3d>> &cell3DsFaceTranslations,
        const std::vector<std::vector<Eigen::Matrix3d>> &cell3DsFaceRotationMatrices,
        const std::vector<Eigen::MatrixXd> &cell3DsBoundingBox,
        const std::vector<std::vector<Eigen::MatrixXd>> &cell3DsTetrahedra,
        const bool find_only_first_cell3D,
        const unsigned int starting_cell3D_index) const;
 
    Gedim::MeshUtilities::AgglomerateTrianglesResult AgglomerateTriangles(const std::vector<unsigned int> &trianglesIndexToAgglomerate,
                                                                          Gedim::IMeshDAO &triangularMesh) const;
 
    Gedim::MeshUtilities::AgglomerateMeshFromTriangularMeshResult AgglomerateMeshFromTriangularMesh(
        const std::vector<std::vector<unsigned int>> &trianglesIndicesToAgglomerate,
        Gedim::IMeshDAO &triangularMesh) const;
 
    Gedim::MeshUtilities::AgglomerationInformation ImportAgglomerationInformationFromCsv(const Gedim::GeometryUtilities &geometryUtilities,
                                                                                         const Gedim::IMeshDAO &originalMesh,
                                                                                         const Gedim::IMeshDAO &agglomeratedMesh,
                                                                                         const std::string &fileName,
                                                                                         const char &separator) const;
 
    Gedim::MeshUtilities::AgglomerationInformation ImportAgglomerationInformationFromOFF(const Gedim::GeometryUtilities &geometryUtilities,
                                                                                         const Gedim::IMeshDAO &originalMesh,
                                                                                         const Gedim::IMeshDAO &agglomeratedMesh,
                                                                                         const std::string &fileName,
                                                                                         const char &separator) const;
 
    void ExportMeshToCsv(const Gedim::IMeshDAO &mesh, const char &separator, const std::string &exportFolderPath) const;
 
    void ExportConcaveMesh2DToCsv(const Gedim::IMeshDAO &mesh,
                                  const std::vector<std::vector<unsigned int>> &convexCell2DsIndex,
                                  const char &separator,
                                  const std::string &exportFolderPath) const;
 
    std::vector<unsigned int> MarkCells(const std::function<Eigen::VectorXi(const Eigen::MatrixXd &)> &marking_function,
                                        const std::vector<Eigen::MatrixXd> &cells_points,
                                        const unsigned int default_mark) const;
 
    Gedim::MeshUtilities::Intersect_mesh_polyhedron_result Intersect_mesh_polyhedron(
        const Gedim::GeometryUtilities &geometry_utilities,
        const Eigen::MatrixXd &polyhedron_vertices,
        const Eigen::MatrixXi &polyhedron_edges,
        const std::vector<Eigen::MatrixXd> &polyhedron_edges_vertices,
        const Eigen::MatrixXd &polyhedron_edges_tangent,
        const std::vector<Eigen::MatrixXd> &polyhedron_edges_boudingBox,
        const std::vector<Eigen::MatrixXi> &polyhedron_faces,
        const std::vector<Eigen::MatrixXd> &polyhedron_faces_vertices,
        const std::vector<Eigen::MatrixXd> &polyhedron_faces_rotated_vertices,
        const std::vector<Eigen::Vector3d> &polyhedron_faces_normals,
        const std::vector<bool> &polyhedron_faces_normal_direction,
        const std::vector<Eigen::Vector3d> &polyhedron_faces_translation,
        const std::vector<Eigen::Matrix3d> &polyhedron_faces_rotation_matrix,
        const std::vector<Eigen::MatrixXd> &polyhedron_faces_boudingBox,
        const Eigen::MatrixXd &polyhedron_boudingBox,
        const Gedim::IMeshDAO &mesh,
        const std::vector<Eigen::MatrixXd> &mesh_cell1Ds_boudingBox,
        const std::vector<Eigen::MatrixXd> &mesh_cell1Ds_vertices,
        const std::vector<Eigen::Vector3d> &mesh_cell1Ds_tangent,
        const std::vector<Eigen::MatrixXd> &mesh_cell2Ds_vertices,
        const std::vector<Eigen::Vector3d> &mesh_cell2Ds_normal,
        const std::vector<Eigen::MatrixXd> &mesh_cell2Ds_2D_vertices,
        const std::vector<Eigen::Vector3d> &mesh_cell2Ds_translation,
        const std::vector<Eigen::Matrix3d> &mesh_cell2Ds_rotation_matrix,
        const std::vector<Eigen::MatrixXd> &mesh_cell2Ds_boudingBox,
        const std::vector<Eigen::MatrixXd> &mesh_cell3Ds_boudingBox,
        const std::vector<std::vector<Eigen::MatrixXi>> &mesh_cell3Ds_faces,
        const std::vector<std::vector<Eigen::MatrixXd>> &mesh_cell3Ds_faces_vertices,
        const std::vector<std::vector<Eigen::MatrixXd>> &mesh_cell3Ds_faces_2D_vertices,
        const std::vector<std::vector<Eigen::Vector3d>> &mesh_cell3Ds_faces_normal,
        const std::vector<std::vector<bool>> &mesh_cell3Ds_faces_normal_directions,
        const std::vector<std::vector<Eigen::Vector3d>> &mesh_cell3Ds_faces_translation,
        const std::vector<std::vector<Eigen::Matrix3d>> &mesh_cell3Ds_faces_rotation_matrix) const;
 
    void SetPolygonMeshMarkers(const Gedim::GeometryUtilities &geometryUtilities,
                               const Eigen::MatrixXd &polygonVertices,
                               const std::vector<unsigned int> &cell0DMarkers,
                               const std::vector<unsigned int> &cell1DMarkers,
                               Gedim::IMeshDAO &mesh) const;
 
    void CheckMeshGeometricData2D(const Gedim::MeshUtilities::CheckMeshGeometricData2DConfiguration &configuration,
                                  const Gedim::GeometryUtilities &geometryUtilities,
                                  const Gedim::IMeshDAO &mesh,
                                  const MeshGeometricData2D &geometricData) const;
 
    void CreatePolygonIntersectionMesh(const Gedim::GeometryUtilities &geometry_utilities,
                                       const Eigen::MatrixXd &interface_vertices,
                                       Gedim::IMeshDAO &mesh) const;
 
    bool CollapseCell1D(const unsigned int cell1D_index, Gedim::IMeshDAO &mesh) const;
 
    void Mesh3DFromPolyhedra(const Gedim::GeometryUtilities &geometry_utilities,
                             const std::vector<Gedim::GeometryUtilities::Polyhedron> &polyhedra,
                             Gedim::IMeshDAO &mesh) const;
};
 
} // namespace Gedim
 
#endif // __MeshUtilities_H