Update repository

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.21)
-project (building-reconstruction VERSION 0.3.2)
+project (building-reconstruction VERSION 0.4.5)
 
 option(GFP_WITH_PDAL "Build parts dependent on PDAL" OFF)
 
@@ -17,7 +17,7 @@ endif(GFP_WITH_PDAL)
 add_library(ptinpoly STATIC thirdparty/ptinpoly/ptinpoly.c)
 set_target_properties(
   ptinpoly PROPERTIES 
-  C_STANDARD 11
+  C_STANDARD 90
   POSITION_INDEPENDENT_CODE ON
 )
 
@@ -81,6 +81,7 @@ geoflow_create_plugin(
   src/MeshSimplify.cpp
   src/MeshGridSimplify.cpp
   src/Mesh2TriangleCollectionNode.cpp
+  src/tinsimp.cpp
 )
 
 target_include_directories(gfp_buildingreconstruction PRIVATE
@@ -109,4 +110,4 @@ if (MSVC)
     FILES_MATCHING 
     PATTERN "*.dll"
     PATTERN "gfp*" EXCLUDE)
-endif()
+endif()

register.hpp

@@ -78,8 +78,11 @@ void register_nodes(geoflow::NodeRegister& node_register) {
     node_register.register_node<MaxInscribedCircleNode>("MaxInscribedCircle");
     node_register.register_node<MeshSimplifyFastQuadNode>("MeshSimplifyFastQuad");
     node_register.register_node<MeshSimplifyNode>("MeshSimplify");
+    node_register.register_node<SurfaceMesh2OFFNode>("SurfaceMesh2OFF");
     node_register.register_node<MeshGridSimplifyNode>("MeshGridSimplify");
     node_register.register_node<MeshClipperNode>("MeshClipper");
     node_register.register_node<Mesh2TriangleCollectionNode>("Mesh2TriangleCollection");
     node_register.register_node<Mesh2CGALSurfaceMeshNode>("Mesh2CGALSurfaceMesh");
+    node_register.register_node<RoofPartition3DBAGRasteriseNode>("RoofPartition3DBAGRasterise");
+    node_register.register_node<MeshSimplify2DNode>("MeshSimplify2D");
 }

src/Mesh2TriangleCollectionNode.cpp

@@ -2,6 +2,12 @@
 
 #include <CGAL/Polygon_mesh_processing/compute_normal.h>
 #include <CGAL/Polygon_mesh_processing/triangulate_faces.h>
+#include <cstddef>
+
+#include <CGAL/Polygon_mesh_processing/manifoldness.h>
+#include <CGAL/Polygon_mesh_processing/repair.h>
+#include <CGAL/Polygon_mesh_processing/repair_polygon_soup.h>
+#include <CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h>
 
 namespace geoflow::nodes::stepedge {
 
@@ -30,7 +36,7 @@ namespace geoflow::nodes::stepedge {
 
     TriangleCollection triangleCollection;
     vec3f normals;
-    for (auto& f : smesh.faces()) {
+    for (auto f : smesh.faces()) {
       Triangle t;
       unsigned i = 0;
 
@@ -61,31 +67,54 @@ namespace geoflow::nodes::stepedge {
 
     SurfaceMesh smesh;
     {
-      std::map<arr3f, VertexIndex> vertex_map;
+      std::map<arr3f, std::size_t> vertex_map;
       std::set<arr3f> vertex_set;
+      std::vector<K::Point_3> points;
       for (const auto &ring : gfmesh.get_polygons())
       {
         for (auto &v : ring)
         {
           auto [it, did_insert] = vertex_set.insert(v);
           if (did_insert)
           {
-            vertex_map[v] = smesh.add_vertex(K::Point_3(v[0],v[1],v[2]));;
+            vertex_map[v] = points.size();
+            points.push_back(K::Point_3(v[0],v[1],v[2]));
           }
         }
       }
-
+
+      // First build a polygon soup
+      std::vector<std::vector<std::size_t> > polygons;
       for (auto& ring : gfmesh.get_polygons()) {
-        std::vector<VertexIndex> rindices;
+        std::vector<std::size_t> rindices;
         rindices.reserve(ring.size());
         for(auto& p : ring) {
           rindices.push_back(vertex_map[p]);
         }
-        smesh.add_face(rindices);
+        polygons.push_back(rindices);
       }
+
+      // Do CGAL mesh repair magic, see https://github.com/CGAL/cgal/issues/7529
+
+      // remove all kinds of typical issues in a polygon soup (degenerate polygons, isolated points, etc.)
+      CGAL::Polygon_mesh_processing::repair_polygon_soup(points, polygons);
+
+      // duplicate non-manifold edges (but does not re-orient faces)
+      CGAL::Polygon_mesh_processing::duplicate_non_manifold_edges_in_polygon_soup(points, polygons);
+
+      CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh(points, polygons, smesh);
+
+      if(!CGAL::is_triangle_mesh(smesh)) PMP::triangulate_faces(smesh);
+
+      // this prevents potentially getting stuck in infinite loop (see https://github.com/CGAL/cgal/issues/7529)
+      CGAL::Polygon_mesh_processing::duplicate_non_manifold_vertices( smesh );
+
+      // this is not needed since PMP::repair_polygon_soup() will perform this repair
+      // CGAL::Polygon_mesh_processing::remove_isolated_vertices( smesh	);
+
     }
 
-    if(!CGAL::is_triangle_mesh(smesh)) PMP::triangulate_faces(smesh);
+
 
     output("cgal_surface_mesh").set(smesh);
   }

src/MeshClipperNode.cpp

@@ -28,6 +28,43 @@ namespace geoflow::nodes::stepedge {
     return t;
   }
 
+  struct MeshBuilder {
+    std::map<K::Point_3, std::size_t> vertex_map;
+    std::set<K::Point_3> vertex_set;
+    std::vector<K::Point_3> points;
+
+    std::vector<std::vector<std::size_t> > polygons;
+
+    void add_point(const K::Point_3& p) {
+      auto [it, did_insert] = vertex_set.insert(p);
+      if (did_insert)
+      {
+        vertex_map[p] = points.size();
+        points.push_back(p);
+      }
+    }
+
+    void add_triangle(const K::Point_3& p0, const K::Point_3& p1, const K::Point_3& p2) {
+      add_point(p0);
+      add_point(p1);
+      add_point(p2);
+
+      // First build a polygon soup
+      std::vector<std::size_t> rindices;
+      rindices.reserve(3);
+      rindices.push_back(vertex_map[p0]);
+      rindices.push_back(vertex_map[p1]);
+      rindices.push_back(vertex_map[p2]);
+      polygons.push_back(rindices);
+    }
+
+    void get_mesh(SurfaceMesh& smesh) {
+      smesh.clear();
+      CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh(points, polygons, smesh);
+    }
+
+  };
+
   void MeshClipperNode::process() { 
 
     typedef SurfaceMesh::Vertex_index       VertexIndex;
@@ -38,32 +75,6 @@ namespace geoflow::nodes::stepedge {
     namespace PMP = CGAL::Polygon_mesh_processing;
 
     auto smesh = input("mesh").get<SurfaceMesh>();
-
-    // SurfaceMesh smesh;
-    // {
-    //   std::map<arr3f, VertexIndex> vertex_map;
-    //   std::set<arr3f> vertex_set;
-    //   for (const auto &ring : gfmesh.get_polygons())
-    //   {
-    //     for (auto &v : ring)
-    //     {
-    //       auto [it, did_insert] = vertex_set.insert(v);
-    //       if (did_insert)
-    //       {
-    //         vertex_map[v] = smesh.add_vertex(Point_3(v[0],v[1],v[2]));;
-    //       }
-    //     }
-    //   }
-
-    //   for (auto& ring : gfmesh.get_polygons()) {
-    //     std::vector<VertexIndex> rindices;
-    //     rindices.reserve(ring.size());
-    //     for(auto& p : ring) {
-    //       rindices.push_back(vertex_map[p]);
-    //     }
-    //     smesh.add_face(rindices);
-    //   }
-    // }
 
     // clip
     if(!CGAL::is_triangle_mesh(smesh)) PMP::triangulate_faces(smesh);
@@ -76,12 +87,6 @@ namespace geoflow::nodes::stepedge {
       Point_3(pmax[0], pmax[1], pmax[2])
     );
 
-    TriangleCollection triangleCollection;
-    vec3f normals;
-
-    auto fnormals = smesh.add_property_map<FaceIndex, K::Vector_3>("f:normals", CGAL::NULL_VECTOR).first;
-    PMP::compute_face_normals(smesh, fnormals);
-
     if (!skip_clip_) {
       if (cgal_clip_) { // use cgal mesh_processing
         if (!PMP::does_self_intersect(smesh)) {
@@ -91,8 +96,9 @@ namespace geoflow::nodes::stepedge {
           );
         }
       } else {
+        MeshBuilder mb;
         CGAL::Vertex_around_face_iterator<SurfaceMesh> vit, vend;
-        for (auto& f : smesh.faces()) {
+        for (auto f : smesh.faces()) {
           boost::tie(vit, vend) = CGAL::vertices_around_face(smesh.halfedge(f), smesh);
           auto end = vit;
           K::Point_3 p1 = smesh.point(*vit); vit++;
@@ -106,61 +112,83 @@ namespace geoflow::nodes::stepedge {
 
           const auto result = CGAL::intersection(triangle, cuboid);
           if (result) {
-            auto& n = fnormals[f];
+            // auto& n = fnormals[f];
             if (const Triangle_3* tri = boost::get<Triangle_3>(&*result)) {
-              triangleCollection.push_back(create_gf_triangle(
+              mb.add_triangle(
                 tri->vertex(0),
                 tri->vertex(1),
                 tri->vertex(2)
-              ));
-              normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
-              normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
-              normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
+              );
             } else if (const Poly_3* poly = boost::get<Poly_3 >(&*result)) {
               // std::cout << "polygon! [" << poly->size() << std::endl;
-
               for(unsigned i=0; i<poly->size()-2; ++i) {
                 // std::cout << i << " ";
-                triangleCollection.push_back(create_gf_triangle(
+                mb.add_triangle(
                   (*poly)[0],
                   (*poly)[i+1],
                   (*poly)[i+2]
-                ));
-                normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
-                normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
-                normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
+                );
               }
 
             }
           }
         }
+        mb.get_mesh(smesh);
       }
     }
 
-    if (skip_clip_ || cgal_clip_) {
-      for (auto& f : smesh.faces()) {
-        Triangle t;
-        unsigned i = 0;
-
-        for(VertexIndex vi : vertices_around_face(smesh.halfedge(f), smesh)) {
-          auto& p = smesh.point(vi);
-          t[i++] = arr3f{ 
+    auto fnormals = smesh.add_property_map<FaceIndex, K::Vector_3>("f:normals", CGAL::NULL_VECTOR).first;
+    auto vnormals = smesh.add_property_map<VertexIndex, K::Vector_3>("v:normals", CGAL::NULL_VECTOR).first;
+
+    if (smooth_normals_) {
+      PMP::compute_vertex_normals(smesh, vnormals);
+    } else {
+      PMP::compute_face_normals(smesh, fnormals);
+    }
+
+    // convert to triangleCollection
+    TriangleCollection triangleCollection;
+    vec3f normals;
+    for (auto f : smesh.faces()) {
+      Triangle t;
+
+      unsigned i = 0;
+      for(VertexIndex vi : vertices_around_face(smesh.halfedge(f), smesh)) {
+        if(i==3) {
+          std::cout << "WARNING: skipping triangulated SurfaceMesh face with more than 3 vertices\n";
+          continue;
+        }
+        auto& p = smesh.point(vi);
+        t[i++] = arr3f{ 
           (float) p.x(),
           (float) p.y(),
           (float) p.z()
-          };
+        };
+        // if (!smesh.is_border(vi)) {
+        if (smooth_normals_) {
+          normals.push_back(arr3f{ 
+            float(vnormals[vi].x()), 
+            float(vnormals[vi].y()), 
+            float(vnormals[vi].z()) });
+        } else {
+          normals.push_back(arr3f{ 
+            float(fnormals[f].x()), 
+            float(fnormals[f].y()), 
+            float(fnormals[f].z()) });
         }
-        auto& n = fnormals[f];
-        normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
-        normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
-        normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
-        triangleCollection.push_back(t);
-      }
+      }	
+      // if (!smooth_normals_) {
+
+
+      //   normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
+      //   normals.push_back(arr3f{ float(n.x()), float(n.y()), float(n.z()) });
+      // }
+      triangleCollection.push_back(t);
     }
 
     output("triangles").set(triangleCollection);
     output("normals").set(normals);
     // output("cgal_surface_mesh").set(smesh);
   }
 
-}
+}

src/MeshGridSimplify.cpp

@@ -144,7 +144,7 @@ namespace geoflow::nodes::stepedge {
     // merge vertices in each grid cell, and create a mapping (old vertex indices -> new vertex indices, std::map<unsigned, unsigned>)
     Grid2D G(box, cell_size_xy_, cell_size_z_);
     std::unordered_map<unsigned, unsigned> vertex_map;
-    for (auto& vi : smesh.vertices()) {
+    for (auto vi : smesh.vertices()) {
       unsigned c = G.getCellCoordinate( smesh.point(vi) );
       vertex_map[vi] = c;
     }
@@ -161,15 +161,15 @@ namespace geoflow::nodes::stepedge {
       //   Cluster(float x, float y) : x(x), y(y) {};
       // };
       std::unordered_map<unsigned, arr3f> new_vertices;
-      for (auto& f : smesh.faces()) {
+      for (auto f : smesh.faces()) {
         for(VertexIndex vi : vertices_around_face(smesh.halfedge(f), smesh)) {
           auto p = G.getCellCenterPoint(vertex_map[vi]);
           new_mesh_vertices[vertex_map[vi]] = smesh_new.add_vertex(K::Point_3(p[0], p[1], p[2]));
         }
       }
     }
     {
-      for (auto& f : smesh.faces()) {
+      for (auto f : smesh.faces()) {
         std::set<unsigned> face_set;
         for(VertexIndex vi : vertices_around_face(smesh.halfedge(f), smesh)) {
           face_set.insert(vertex_map[vi]);