[WIP] Fix overlapping triangles problem with conformal mesher

README.md

@@ -102,6 +102,8 @@ This code and its copyright is property of to the University of Granada (UGR), C
 
 testData/cervezas_alhambra logo has been downloaded from https://cults3d.com/es/modelo-3d/arte/celosia-alhambra-logo-cervezas-alhambra where is available with license CC BY-NC-SA.
 
+Third party library CDT has been used as an external library. Its source code can be found in https://github.com/artem-ogre/CDT, licensed under the MPL-2.0 license.
+
 ## Funding
 
 - Spanish Ministry of Science and Innovation (MICIN/AEI) (Grant Number: PID2022-137495OB-C31)

src/cgal/CMakeLists.txt

@@ -1,7 +1,7 @@
 message(STATUS "Creating build system for tessellator-cgal")
 
 add_library(tessellator-cgal
-    "Delaunator.cpp"
+    "DelaunatorCGAL.cpp"
     "HPolygonSet.cpp"
     "Manifolder.cpp"
     "PolyhedronTools.cpp"

src/cgal/Delaunator.cpp → src/cgal/DelaunatorCGAL.cpp

@@ -1,14 +1,14 @@
-#include "Delaunator.h"
+#include "DelaunatorCGAL.h"
 #include "utils/Geometry.h"
 #include "LSFPlane.h"
 
 namespace meshlib::cgal {
 
 using namespace utils;
 
-const double Delaunator::COPLANARITY_ANGLE_TOLERANCE = 0.1;
+const double DelaunatorCGAL::COPLANARITY_ANGLE_TOLERANCE = 0.1;
 
-Delaunator::Delaunator(const Coordinates* global, const ElementsView& elements)
+DelaunatorCGAL::DelaunatorCGAL(const Coordinates* global, const ElementsView& elements)
 {
     if (global == nullptr) {
         throw std::runtime_error("Global list of coordinates must be defined");
@@ -20,18 +20,18 @@ Delaunator::Delaunator(const Coordinates* global, const ElementsView& elements)
     }
 }
 
-std::vector<Element> Delaunator::mesh(
+std::vector<Element> DelaunatorCGAL::mesh(
     const IdSet& inIds,
     const std::vector<Polygon>& constrainingPolygons) const
 {
     auto ids = filterIdsByConstraints(inIds, constrainingPolygons);
     checkIdsAreInRange(ids, constrainingPolygons);
     const IndexPointToId pointToId = buildPointsInIndex(ids, constrainingPolygons);
-    CDT cdt = buildCDT(pointToId, ids, constrainingPolygons);
+    Triangulation cdt = buildCDT(pointToId, ids, constrainingPolygons);
     return convertFromCDT(cdt, pointToId);
 }
 
-void Delaunator::checkIdsAreInRange(
+void DelaunatorCGAL::checkIdsAreInRange(
     const IdSet& inIds,
     const std::vector<Polygon>& constrainingPolygons) const
 {
@@ -53,8 +53,8 @@ void Delaunator::checkIdsAreInRange(
     }
 }
 
-std::vector<Element> Delaunator::convertFromCDT(
-    const CDT& cdt, const IndexPointToId& pointToId) const
+std::vector<Element> DelaunatorCGAL::convertFromCDT(
+    const Triangulation& cdt, const IndexPointToId& pointToId) const
 {
     for (auto v : cdt.finite_vertex_handles()) {
         if (pointToId.left.count(v->point()) == 0) {
@@ -79,12 +79,12 @@ std::vector<Element> Delaunator::convertFromCDT(
     return res;
 }
 
-Delaunator::CDT Delaunator::buildCDT(
+DelaunatorCGAL::Triangulation DelaunatorCGAL::buildCDT(
     const IndexPointToId& pointToId,
     const IdSet& inIds,
     const Polygons& constrainingPolygons)
 {
-    CDT cdt;
+    Triangulation cdt;
     for (auto const& polygon : constrainingPolygons) {
         Polygon_2 cgalPoly;
         for (auto const& id : polygon) {
@@ -101,7 +101,7 @@ Delaunator::CDT Delaunator::buildCDT(
     return cdt;
 }
 
-void Delaunator::mark_domains(CDT& ct, Face_handle start, int index, std::list<CDT::Edge>& border)
+void DelaunatorCGAL::mark_domains(Triangulation& ct, Face_handle start, int index, std::list<Triangulation::Edge>& border)
 {
     if (start->info().nesting_level != -1) {
         return;
@@ -114,7 +114,7 @@ void Delaunator::mark_domains(CDT& ct, Face_handle start, int index, std::list<C
         if (fh->info().nesting_level == -1) {
             fh->info().nesting_level = index;
             for (int i = 0; i < 3; i++) {
-                CDT::Edge e(fh, i);
+                Triangulation::Edge e(fh, i);
                 Face_handle n = fh->neighbor(i);
                 if (n->info().nesting_level == -1) {
                     if (ct.is_constrained(e)) border.push_back(e);
@@ -125,7 +125,7 @@ void Delaunator::mark_domains(CDT& ct, Face_handle start, int index, std::list<C
     }
 }
 
-IdSet Delaunator::filterIdsByConstraints(
+IdSet DelaunatorCGAL::filterIdsByConstraints(
     const IdSet& ids, const Polygons& polys)
 {
     IdSet res = ids;
@@ -138,15 +138,15 @@ IdSet Delaunator::filterIdsByConstraints(
 }
 
 
-void Delaunator::mark_domains(CDT& cdt)
+void DelaunatorCGAL::mark_domains(Triangulation& cdt)
 {
-    for (CDT::Face_handle f : cdt.all_face_handles()) {
+    for (Triangulation::Face_handle f : cdt.all_face_handles()) {
         f->info().nesting_level = -1;
     }
-    std::list<CDT::Edge> border;
+    std::list<Triangulation::Edge> border;
     mark_domains(cdt, cdt.infinite_face(), 0, border);
     while (!border.empty()) {
-        CDT::Edge e = border.front();
+        Triangulation::Edge e = border.front();
         border.pop_front();
         Face_handle n = e.first->neighbor(e.second);
         if (n->info().nesting_level == -1) {
@@ -155,7 +155,7 @@ void Delaunator::mark_domains(CDT& cdt)
     }
 }
 
-Delaunator::IndexPointToId Delaunator::buildPointsInIndex(
+DelaunatorCGAL::IndexPointToId DelaunatorCGAL::buildPointsInIndex(
     const IdSet& inIds,
     const Polygons& constrainingPolygons) const
 {
@@ -189,7 +189,7 @@ Delaunator::IndexPointToId Delaunator::buildPointsInIndex(
     IndexPointToId res;
     for (std::size_t i = 0; i < cs.size(); i++) {
         res.insert( IndexPointToId::value_type(
-            CDT::Point(cs[i](0), cs[i](1)), 
+            Triangulation::Point(cs[i](0), cs[i](1)), 
             originalIds[i]) 
         );
     }

src/cgal/Delaunator.h → src/cgal/DelaunatorCGAL.h

@@ -14,12 +14,12 @@ namespace meshlib {
 namespace cgal {
 
 
-class Delaunator {
+class DelaunatorCGAL {
 public:
 	typedef std::vector<CoordinateId> Polygon;
 	typedef std::vector<Polygon> Polygons;
 
-	Delaunator(const Coordinates* globalCoordinates, const ElementsView& elems = ElementsView());
+	DelaunatorCGAL(const Coordinates* globalCoordinates, const ElementsView& elems = ElementsView());
 
 	std::vector<Element> mesh(
 		const IdSet& vertexIds,
@@ -48,22 +48,22 @@ class Delaunator {
 	typedef CGAL::Constrained_triangulation_face_base_2<K, Fbb>       Fb;
 	typedef CGAL::Triangulation_data_structure_2<Vb, Fb>              TDS;
 	typedef CGAL::Exact_predicates_tag                                Itag;
-	typedef CGAL::Constrained_Delaunay_triangulation_2<K, TDS, Itag>  CDT;
-	typedef CDT::Point                                                Point;
+	typedef CGAL::Constrained_Delaunay_triangulation_2<K, TDS, Itag>  Triangulation;
+	typedef Triangulation::Point                                                Point;
 	typedef CGAL::Polygon_2<K>                                        Polygon_2;
-	typedef CDT::Face_handle                                          Face_handle;
+	typedef Triangulation::Face_handle                                          Face_handle;
 
-	typedef boost::bimap<CDT::Point, CoordinateId> IndexPointToId;
+	typedef boost::bimap<Triangulation::Point, CoordinateId> IndexPointToId;
 
 	IndexPointToId buildPointsInIndex(const IdSet& inIds, const Polygons& constraint) const;
-	static CDT buildCDT(
+	static Triangulation buildCDT(
 		const IndexPointToId& pointToId,
 		const IdSet& inIds,
 		const Polygons& constrainingPolygons);
-	std::vector<Element> convertFromCDT(const CDT& cdt, const IndexPointToId& pointToId) const;
+	std::vector<Element> convertFromCDT(const Triangulation& cdt, const IndexPointToId& pointToId) const;
 
-	static void mark_domains(CDT& cdt);
-	static void mark_domains(CDT& ct, Face_handle start, int index, std::list<CDT::Edge>& border);
+	static void mark_domains(Triangulation& cdt);
+	static void mark_domains(Triangulation& ct, Face_handle start, int index, std::list<Triangulation::Edge>& border);
 	void checkIdsAreInRange(
 		const IdSet& inIds,
 		const std::vector<Polygon>& constrainingPolygons) const;

src/cgal/Manifolder.cpp

@@ -100,7 +100,7 @@ Mesh Manifolder::getSurfacesMesh() const
 {
 	Mesh m = getClosedSurfacesMesh();
 	utils::meshTools::mergeMesh(m, getOpenSurfacesMesh());
-	utils::RedundancyCleaner::cleanCoords(m);
+	utils::redundancyCleaner::cleanCoords(m);
 	return m;
 }
 

src/cgal/Repairer.cpp

@@ -72,9 +72,9 @@ Mesh repair(const Mesh& m)
         repairGroup(r.coordinates, r.groups[gId], m.coordinates, g);
     }
 
-    RedundancyCleaner::fuseCoords(r);
-    RedundancyCleaner::removeDegenerateElements(r);
-    RedundancyCleaner::cleanCoords(r);
+    redundancyCleaner::fuseCoords(r);
+    redundancyCleaner::removeDegenerateElements(r);
+    redundancyCleaner::cleanCoords(r);
 
     return r;
 }

src/core/CMakeLists.txt

@@ -7,6 +7,8 @@ add_library(tessellator-core
     "Smoother.cpp"
     "SmootherTools.cpp"
     "Staircaser.cpp"
+    "Splicer.cpp"
+    "Delaunator.cpp"
 )
 
 target_link_libraries(tessellator-core tessellator-utils)

src/core/Collapser.cpp

@@ -4,15 +4,14 @@
 #include "utils/RedundancyCleaner.h"
 #include "utils/MeshTools.h"
 
-#include "Collapser.h"
-
 namespace meshlib {
 namespace core {
 
 using namespace utils;
 
 Collapser::Collapser(const Mesh& in, int decimalPlaces, const std::vector<Element::Type>& dimensionPolicy)
 {
+
     if (dimensionPolicy.size() == 0) {
         dimensionPolicy_ = std::vector<Element::Type>(in.groups.size(), Element::Type::Surface);
     }
@@ -21,16 +20,19 @@ Collapser::Collapser(const Mesh& in, int decimalPlaces, const std::vector<Elemen
     }
 
     mesh_ = in;
+
     double factor = std::pow(10.0, decimalPlaces);
     for (auto& v : mesh_.coordinates) {
         v = v.round(factor);
     }
 
-    RedundancyCleaner::fuseCoords(mesh_);
-    RedundancyCleaner::cleanCoords(mesh_);
+    redundancyCleaner::fuseCoords(mesh_);
+    redundancyCleaner::cleanCoords(mesh_);
 
     collapseDegenerateElements(mesh_, 0.4 / (factor * factor));
-    RedundancyCleaner::removeOverlappedElementsByDimension(mesh_, dimensionPolicy_);
+
+    redundancyCleaner::removeOverlappedElementsByDimension(mesh_, dimensionPolicy_);
+
     utils::meshTools::checkNoNullAreasExist(mesh_);
 }
 
@@ -54,6 +56,14 @@ void Collapser::collapseDegenerateElements(Mesh& mesh, const double& areaThresho
                 degeneratedTrianglesFound = true;
                 Coordinates& coords = mesh.coordinates;
                 const std::vector<CoordinateId>& v = element.vertices;
+                /*
+                bool relevantTriangleFound = true;
+                for (auto& coordId : v) {
+                    if (coords[v[X]] < 1.0 && coords[v[Y]] > 2.0 && coords[v[Y]] < 3.0) {
+                        relevantTriangleFound = false;
+                    }
+                }
+                */
                 std::pair<std::size_t, CoordinateId> replace;
 
                 std::array<double, 3> sumOfDistances{ 0,0,0 };
@@ -75,11 +85,18 @@ void Collapser::collapseDegenerateElements(Mesh& mesh, const double& areaThresho
                 else {
                     coords[element.vertices[midId]] = coords[element.vertices[(midId + 2) % 3]];
                 }
+                /*
+                for (auto& coordId : v) {
+                    if (coords[v[X]] < 1.0 && coords[v[Y]] > 2.0 && coords[v[Y]] < 3.0) {
+                        bool noop = true;
+                    }
+                }
+                */
             }
         }
 
-        RedundancyCleaner::fuseCoords(mesh);
-        RedundancyCleaner::cleanCoords(mesh);
+        redundancyCleaner::fuseCoords(mesh);
+        redundancyCleaner::cleanCoords(mesh);
 
         for (auto & group : mesh.groups) {
             for (auto& element : group.elements) {