Merge pull request #934 from Geode-solutions/fix/is-degenerated

fix(Mesh): add methos in mesh classes to ask if an element is degener…

Author: panquez

include/geode/mesh/core/edged_curve.h

@@ -65,6 +65,12 @@ namespace geode
 
         Point< dimension > edge_barycenter( index_t edge_id ) const;
 
+        /*!
+         * Return if an edge is degenerated (means stands into an
+         * epsilon-large ball)
+         */
+        bool is_edge_degenerated( index_t edge_id ) const;
+
         Segment< dimension > segment( index_t edge_id ) const;
 
         TextureManager1D texture_manager() const;

include/geode/mesh/core/solid_mesh.h

@@ -439,6 +439,12 @@ namespace geode
         absl::optional< Vector3D > new_polyhedron_facet_normal(
             const PolyhedronFacet& polyhedron_facet ) const;
 
+        /*!
+         * Return if a polyhedron is degenerated (means stands into an
+         * epsilon-large plane)
+         */
+        bool is_polyhedron_degenerated( index_t polyhedron_id ) const;
+
         /*!
          * Returns the vertices linked by an edge to the given mesh vertex.
          */

include/geode/mesh/core/surface_mesh.h

@@ -348,6 +348,12 @@ namespace geode
         typename std::enable_if< T == 3, absl::optional< Vector3D > >::type
             polygon_vertex_normal( index_t vertex_id ) const;
 
+        /*!
+         * Return if a polygon is degenerated (means stands into an
+         * epsilon-large segment)
+         */
+        bool is_polygon_degenerated( index_t polygon_id ) const;
+
         /*!
          * Returns the vertices linked by an edge to the given mesh vertex.
          */

src/geode/mesh/core/edged_curve.cpp

@@ -113,6 +113,12 @@ namespace geode
         return ( e0 + e1 ) / 2.;
     }
 
+    template < index_t dimension >
+    bool EdgedCurve< dimension >::is_edge_degenerated( index_t edge_id ) const
+    {
+        return edge_length( edge_id ) <= global_epsilon;
+    }
+
     template < index_t dimension >
     template < typename Archive >
     void EdgedCurve< dimension >::serialize( Archive& archive )

src/geode/mesh/core/solid_mesh.cpp

@@ -33,9 +33,11 @@
 #include <geode/basic/detail/mapping_after_deletion.h>
 #include <geode/basic/pimpl_impl.h>
 
+#include <geode/geometry/basic_objects/plane.h>
 #include <geode/geometry/basic_objects/tetrahedron.h>
 #include <geode/geometry/basic_objects/triangle.h>
 #include <geode/geometry/bounding_box.h>
+#include <geode/geometry/distance.h>
 #include <geode/geometry/mensuration.h>
 #include <geode/geometry/vector.h>
 
@@ -874,6 +876,52 @@ namespace geode
         }
     }
 
+    template < index_t dimension >
+    bool SolidMesh< dimension >::is_polyhedron_degenerated(
+        index_t polyhedron_id ) const
+    {
+        double max_area{ 0. };
+        local_index_t max_area_facet{ 0 };
+        for( const auto f : LRange{ nb_polyhedron_facets( polyhedron_id ) } )
+        {
+            const auto cur_area = polyhedron_facet_area( { polyhedron_id, f } );
+            if( cur_area > max_area )
+            {
+                max_area = cur_area;
+                max_area_facet = f;
+            }
+        }
+        if( max_area < global_epsilon )
+        {
+            return true;
+        }
+        const auto vertices = polyhedron_vertices( polyhedron_id );
+        const auto normal =
+            new_polyhedron_facet_normal( { polyhedron_id, max_area_facet } );
+        if( !normal )
+        {
+            return true;
+        }
+        const auto facet_vertices =
+            polyhedron_facet_vertices( { polyhedron_id, max_area_facet } );
+        Plane plane{ normal.value(), this->point( facet_vertices[0] ) };
+        for( const auto vertex_id : vertices )
+        {
+            if( absl::c_find( facet_vertices, vertex_id )
+                != facet_vertices.end() )
+            {
+                continue;
+            }
+            if( std::get< 0 >(
+                    point_plane_distance( this->point( vertex_id ), plane ) )
+                > global_epsilon )
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
     template < index_t dimension >
     index_t SolidMesh< dimension >::nb_polyhedra() const
     {

src/geode/mesh/core/surface_mesh.cpp

@@ -28,26 +28,32 @@
 
 #include <bitsery/brief_syntax/array.h>
 
+#include <geode/basic/attribute.h>
 #include <geode/basic/attribute_manager.h>
 #include <geode/basic/bitsery_archive.h>
 #include <geode/basic/cached_value.h>
 #include <geode/basic/detail/mapping_after_deletion.h>
 #include <geode/basic/pimpl_impl.h>
 
+#include <geode/geometry/basic_objects/infinite_line.h>
+#include <geode/geometry/basic_objects/segment.h>
 #include <geode/geometry/basic_objects/triangle.h>
 #include <geode/geometry/bounding_box.h>
 #include <geode/geometry/distance.h>
 #include <geode/geometry/mensuration.h>
 
 #include <geode/mesh/builder/surface_edges_builder.h>
 #include <geode/mesh/builder/surface_mesh_builder.h>
+#include <geode/mesh/builder/triangulated_surface_builder.h>
 #include <geode/mesh/core/detail/facet_storage.h>
 #include <geode/mesh/core/mesh_factory.h>
 #include <geode/mesh/core/polygonal_surface.h>
 #include <geode/mesh/core/private/surface_mesh_impl.h>
 #include <geode/mesh/core/surface_edges.h>
 #include <geode/mesh/core/texture2d.h>
 #include <geode/mesh/core/texture_storage.h>
+#include <geode/mesh/core/triangulated_surface.h>
+#include <geode/mesh/io/triangulated_surface_output.h>
 
 namespace
 {
@@ -98,6 +104,25 @@ namespace
             "edge" );
     }
 
+    template < geode::index_t dimension >
+    void output( const geode::SurfaceMesh< dimension >& mesh )
+    {
+        auto surf = geode::TriangulatedSurface< dimension >::create();
+        auto bui =
+            geode::TriangulatedSurfaceBuilder< dimension >::create( *surf );
+        for( const auto v : geode::Range{ mesh.nb_vertices() } )
+        {
+            bui->create_point( mesh.point( v ) );
+        }
+        for( const auto p : geode::Range{ mesh.nb_polygons() } )
+        {
+            const auto vertices = mesh.polygon_vertices( p );
+            bui->create_triangle( { vertices[0], vertices[1], vertices[2] } );
+        }
+        bui->delete_isolated_vertices();
+        geode::save_triangulated_surface( *surf, "output.og_tsf3d" );
+    }
+
     template < geode::index_t dimension >
     geode::detail::PolygonsAroundVertexImpl compute_polygons_around_vertex(
         const geode::SurfaceMesh< dimension >& mesh,
@@ -147,6 +172,10 @@ namespace
                 safety_count++;
             }
         }
+        if( safety_count >= MAX_SAFETY_COUNT )
+        {
+            output( mesh );
+        }
         OPENGEODE_EXCEPTION( safety_count < MAX_SAFETY_COUNT,
             "[SurfaceMesh::polygons_around_vertex] Too many polygons "
             "around vertex ",
@@ -1051,6 +1080,48 @@ namespace geode
         }
     }
 
+    template < index_t dimension >
+    bool SurfaceMesh< dimension >::is_polygon_degenerated(
+        index_t polygon_id ) const
+    {
+        double max_length{ 0. };
+        local_index_t max_length_edge{ 0 };
+        for( const auto e : LRange{ nb_polygon_edges( polygon_id ) } )
+        {
+            const auto cur_length = edge_length( PolygonEdge{ polygon_id, e } );
+            if( cur_length > max_length )
+            {
+                max_length = cur_length;
+                max_length_edge = e;
+            }
+        }
+        if( max_length < global_epsilon )
+        {
+            return true;
+        }
+        const auto vertices = polygon_vertices( polygon_id );
+        const auto next =
+            max_length_edge + 1 == nb_polygon_vertices( polygon_id )
+                ? 0
+                : max_length_edge + 1;
+        InfiniteLine< dimension > line{ Segment< dimension >{
+            this->point( vertices[max_length_edge] ),
+            this->point( vertices[next] ) } };
+        for( const auto v : LIndices{ vertices } )
+        {
+            if( v == max_length_edge || v == next )
+            {
+                continue;
+            }
+            if( point_line_distance( this->point( vertices[v] ), line )
+                > global_epsilon )
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
     template < index_t dimension >
     std::unique_ptr< SurfaceMesh< dimension > >
         SurfaceMesh< dimension >::clone() const