feat(Degeneration): adding degeneration inspection function with tolerance argument.

benoit2776 · benoit2776 · commit 09131c066af2 · 2025-05-28T11:56:30.000+02:00
diff --git a/bindings/python/src/inspector/criterion/degeneration/edgedcurve_degeneration.hpp b/bindings/python/src/inspector/criterion/degeneration/edgedcurve_degeneration.hpp
@@ -40,7 +40,13 @@ namespace geode
             .def( "is_mesh_degenerated",
                 &EdgedCurveDegeneration::is_mesh_degenerated )
             .def( "degenerated_edges",
-                &EdgedCurveDegeneration::degenerated_edges );
+                []( EdgedCurveDegeneration& self ) {
+                    return self.degenerated_edges();
+                } )
+            .def( "degenerated_edges",
+                []( EdgedCurveDegeneration& self, double tolerance ) {
+                    return self.degenerated_edges( tolerance );
+                } );
     }
     void define_edged_curve_degeneration( pybind11::module& module )
     {
diff --git a/bindings/python/src/inspector/criterion/degeneration/surface_degeneration.hpp b/bindings/python/src/inspector/criterion/degeneration/surface_degeneration.hpp
@@ -40,9 +40,21 @@ namespace geode
             .def( "is_mesh_degenerated",
                 &SurfaceMeshDegeneration::is_mesh_degenerated )
             .def( "degenerated_edges",
-                &SurfaceMeshDegeneration::degenerated_edges )
+                []( SurfaceMeshDegeneration& self ) {
+                    return self.degenerated_edges();
+                } )
+            .def( "degenerated_edges",
+                []( SurfaceMeshDegeneration& self, double tolerance ) {
+                    return self.degenerated_edges( tolerance );
+                } )
+            .def( "degenerated_polygons",
+                []( SurfaceMeshDegeneration& self ) {
+                    return self.degenerated_polygons();
+                } )
             .def( "degenerated_polygons",
-                &SurfaceMeshDegeneration::degenerated_polygons );
+                []( SurfaceMeshDegeneration& self, double tolerance ) {
+                    return self.degenerated_polygons( tolerance );
+                } );
     }
     void define_surface_degeneration( pybind11::module& module )
     {
diff --git a/include/geode/inspector/criterion/degeneration/brep_meshes_degeneration.hpp b/include/geode/inspector/criterion/degeneration/brep_meshes_degeneration.hpp
@@ -74,6 +74,15 @@ namespace geode
         [[nodiscard]] BRepMeshesDegenerationInspectionResult
             inspect_elements_degeneration() const;
 
+        [[nodiscard]] BRepMeshesDegenerationInspectionResult
+            inspect_polygons_degeneration( double tolerance ) const;
+
+        [[nodiscard]] BRepMeshesDegenerationInspectionResult
+            inspect_edges_degeneration( double tolerance ) const;
+
+        [[nodiscard]] BRepMeshesDegenerationInspectionResult
+            inspect_polyhedra_degeneration() const;
+
     private:
         IMPLEMENTATION_MEMBER( impl_ );
     };
diff --git a/include/geode/inspector/criterion/degeneration/edgedcurve_degeneration.hpp b/include/geode/inspector/criterion/degeneration/edgedcurve_degeneration.hpp
@@ -52,6 +52,9 @@ namespace geode
 
         [[nodiscard]] InspectionIssues< index_t > degenerated_edges() const;
 
+        [[nodiscard]] InspectionIssues< index_t > degenerated_edges(
+            double tolerance ) const;
+
     private:
         IMPLEMENTATION_MEMBER( impl_ );
     };
diff --git a/include/geode/inspector/criterion/degeneration/surface_degeneration.hpp b/include/geode/inspector/criterion/degeneration/surface_degeneration.hpp
@@ -51,8 +51,14 @@ namespace geode
 
         [[nodiscard]] bool is_mesh_degenerated() const;
 
+        [[nodiscard]] InspectionIssues< index_t > degenerated_edges(
+            double tolerance ) const;
+
         [[nodiscard]] InspectionIssues< index_t > degenerated_edges() const;
 
+        [[nodiscard]] InspectionIssues< index_t > degenerated_polygons(
+            double tolerance ) const;
+
         [[nodiscard]] InspectionIssues< index_t > degenerated_polygons() const;
 
     private:
diff --git a/include/geode/inspector/criterion/internal/component_meshes_degeneration.hpp b/include/geode/inspector/criterion/internal/component_meshes_degeneration.hpp
@@ -51,9 +51,17 @@ namespace geode
             void add_degenerated_edges(
                 InspectionIssuesMap< index_t >& issues_map ) const;
 
+            void add_degenerated_edges(
+                InspectionIssuesMap< index_t >& issues_map,
+                double tolerance ) const;
+
             void add_degenerated_polygons(
                 InspectionIssuesMap< index_t >& issues_map ) const;
 
+            void add_degenerated_polygons(
+                InspectionIssuesMap< index_t >& issues_map,
+                double tolerance ) const;
+
         protected:
             explicit ComponentMeshesDegeneration( const Model& model );
 
diff --git a/include/geode/inspector/criterion/internal/degeneration_impl.hpp b/include/geode/inspector/criterion/internal/degeneration_impl.hpp
@@ -41,9 +41,15 @@ namespace geode
 
             [[nodiscard]] virtual bool is_mesh_degenerated() const;
 
+            [[nodiscard]] InspectionIssues< index_t > degenerated_edges(
+                double tolerance ) const;
+
             [[nodiscard]] InspectionIssues< index_t > degenerated_edges() const;
 
         private:
+            [[nodiscard]] bool edge_is_degenerated(
+                index_t edge_index, double tolerance ) const;
+
             [[nodiscard]] bool edge_is_degenerated( index_t edge_index ) const;
 
         protected:
diff --git a/src/geode/inspector/criterion/degeneration/brep_meshes_degeneration.cpp b/src/geode/inspector/criterion/degeneration/brep_meshes_degeneration.cpp
@@ -76,7 +76,7 @@ namespace geode
         {
         }
 
-        void add_solid_degenerations(
+        void add_degenerated_polyhedra(
             InspectionIssuesMap< index_t >& degenerated_edges_map,
             InspectionIssuesMap< index_t >& degenerated_polyhedra_map ) const
         {
@@ -112,8 +112,37 @@ namespace geode
         BRepMeshesDegenerationInspectionResult result;
         impl_->add_degenerated_edges( result.degenerated_edges );
         impl_->add_degenerated_polygons( result.degenerated_polygons );
-        impl_->add_solid_degenerations(
+        impl_->add_degenerated_polyhedra(
             result.degenerated_edges, result.degenerated_polyhedra );
         return result;
     }
+
+    BRepMeshesDegenerationInspectionResult
+        BRepComponentMeshesDegeneration::inspect_edges_degeneration(
+            double tolerance ) const
+    {
+        BRepMeshesDegenerationInspectionResult result;
+        impl_->add_degenerated_edges( result.degenerated_edges, tolerance );
+        return result;
+    }
+
+    BRepMeshesDegenerationInspectionResult
+        BRepComponentMeshesDegeneration::inspect_polygons_degeneration(
+            double tolerance ) const
+    {
+        BRepMeshesDegenerationInspectionResult result;
+        impl_->add_degenerated_polygons(
+            result.degenerated_polygons, tolerance );
+        return result;
+    }
+
+    BRepMeshesDegenerationInspectionResult
+        BRepComponentMeshesDegeneration::inspect_polyhedra_degeneration() const
+    {
+        BRepMeshesDegenerationInspectionResult result;
+        impl_->add_degenerated_polyhedra(
+            result.degenerated_edges, result.degenerated_polyhedra );
+        return result;
+    }
+
 } // namespace geode
diff --git a/src/geode/inspector/criterion/degeneration/edgedcurve_degeneration.cpp b/src/geode/inspector/criterion/degeneration/edgedcurve_degeneration.cpp
@@ -51,14 +51,14 @@ namespace geode
             return false;
         }
 
-        InspectionIssues< index_t > degenerated_edges() const
+        InspectionIssues< index_t > degenerated_edges( double tolerance ) const
         {
             InspectionIssues< index_t > degenerated_edges_index{
                 "Degenerated Edges of EdgeCurve " + mesh_.id().string() + "."
             };
             for( const auto edge_id : Range{ mesh_.nb_edges() } )
             {
-                if( mesh_.is_edge_degenerated( edge_id ) )
+                if( mesh_.is_edge_degenerated( edge_id, tolerance ) )
                 {
                     degenerated_edges_index.add_issue(
                         edge_id, absl::StrCat( "Edge with index ", edge_id,
@@ -70,6 +70,11 @@ namespace geode
             return degenerated_edges_index;
         }
 
+        InspectionIssues< index_t > degenerated_edges() const
+        {
+            return degenerated_edges( GLOBAL_EPSILON );
+        }
+
     private:
         const EdgedCurve< dimension >& mesh_;
     };
@@ -90,6 +95,14 @@ namespace geode
         return impl_->is_mesh_degenerated();
     }
 
+    template < index_t dimension >
+    InspectionIssues< index_t >
+        EdgedCurveDegeneration< dimension >::degenerated_edges(
+            double tolerance ) const
+    {
+        return impl_->degenerated_edges( tolerance );
+    }
+
     template < index_t dimension >
     InspectionIssues< index_t >
         EdgedCurveDegeneration< dimension >::degenerated_edges() const
diff --git a/src/geode/inspector/criterion/degeneration/surface_degeneration.cpp b/src/geode/inspector/criterion/degeneration/surface_degeneration.cpp
@@ -63,14 +63,16 @@ namespace geode
             return false;
         }
 
-        InspectionIssues< index_t > degenerated_polygons() const
+        InspectionIssues< index_t > degenerated_polygons(
+            double tolerance ) const
         {
             InspectionIssues< index_t > wrong_polygons{
                 "Degenerated Polygons."
             };
             for( const auto polygon_id : Range{ this->mesh().nb_polygons() } )
             {
-                if( this->mesh().is_polygon_degenerated( polygon_id ) )
+                if( this->mesh().is_polygon_degenerated(
+                        polygon_id, tolerance ) )
                 {
                     wrong_polygons.add_issue( polygon_id,
                         absl::StrCat( "Polygon ", polygon_id, " of Surface ",
@@ -79,6 +81,11 @@ namespace geode
             }
             return wrong_polygons;
         }
+
+        InspectionIssues< index_t > degenerated_polygons() const
+        {
+            return degenerated_polygons( GLOBAL_EPSILON );
+        }
     };
 
     template < index_t dimension >
@@ -97,6 +104,14 @@ namespace geode
         return impl_->is_mesh_degenerated();
     }
 
+    template < index_t dimension >
+    InspectionIssues< index_t >
+        SurfaceMeshDegeneration< dimension >::degenerated_edges(
+            double tolerance ) const
+    {
+        return impl_->degenerated_edges( tolerance );
+    }
+
     template < index_t dimension >
     InspectionIssues< index_t >
         SurfaceMeshDegeneration< dimension >::degenerated_edges() const
@@ -111,6 +126,14 @@ namespace geode
         return impl_->degenerated_polygons();
     }
 
+    template < index_t dimension >
+    InspectionIssues< index_t >
+        SurfaceMeshDegeneration< dimension >::degenerated_polygons(
+            double tolerance ) const
+    {
+        return impl_->degenerated_polygons( tolerance );
+    }
+
     template class opengeode_inspector_inspector_api
         SurfaceMeshDegeneration< 2 >;
     template class opengeode_inspector_inspector_api
diff --git a/src/geode/inspector/criterion/internal/component_meshes_degeneration.cpp b/src/geode/inspector/criterion/internal/component_meshes_degeneration.cpp
@@ -48,14 +48,15 @@ namespace geode
 
         template < typename Model >
         void ComponentMeshesDegeneration< Model >::add_degenerated_edges(
-            InspectionIssuesMap< index_t >& components_degenerated_edges ) const
+            InspectionIssuesMap< index_t >& components_degenerated_edges,
+            double tolerance ) const
         {
             for( const auto& line : model_.lines() )
             {
                 const EdgedCurveDegeneration< Model::dim > inspector{
                     line.mesh()
                 };
-                auto issues = inspector.degenerated_edges();
+                auto issues = inspector.degenerated_edges( tolerance );
                 issues.set_description( absl::StrCat(
                     "Line ", line.id().string(), " degenerated edges" ) );
                 components_degenerated_edges.add_issues_to_map(
@@ -66,14 +67,22 @@ namespace geode
                 const geode::SurfaceMeshDegeneration< Model::dim > inspector{
                     surface.mesh()
                 };
-                auto issues = inspector.degenerated_edges();
+                auto issues = inspector.degenerated_edges( tolerance );
                 issues.set_description( absl::StrCat(
                     "Surface ", surface.id().string(), " degenerated edges" ) );
                 components_degenerated_edges.add_issues_to_map(
                     surface.id(), std::move( issues ) );
             }
         }
 
+        template < typename Model >
+        void ComponentMeshesDegeneration< Model >::add_degenerated_edges(
+            InspectionIssuesMap< index_t >& components_degenerated_edges ) const
+        {
+            add_degenerated_edges(
+                components_degenerated_edges, GLOBAL_EPSILON );
+        }
+
         template < typename Model >
         void ComponentMeshesDegeneration< Model >::add_degenerated_polygons(
             InspectionIssuesMap< index_t >& components_degenerated_polygons )
@@ -92,6 +101,24 @@ namespace geode
             }
         }
 
+        template < typename Model >
+        void ComponentMeshesDegeneration< Model >::add_degenerated_polygons(
+            InspectionIssuesMap< index_t >& components_degenerated_polygons,
+            double tolerance ) const
+        {
+            for( const auto& surface : model_.surfaces() )
+            {
+                const geode::SurfaceMeshDegeneration< Model::dim > inspector{
+                    surface.mesh()
+                };
+                auto issues = inspector.degenerated_polygons( tolerance );
+                issues.set_description( absl::StrCat( "Surface ",
+                    surface.id().string(), " degenerated polygons" ) );
+                components_degenerated_polygons.add_issues_to_map(
+                    surface.id(), std::move( issues ) );
+            }
+        }
+
         template < typename Model >
         const Model& ComponentMeshesDegeneration< Model >::model() const
         {
diff --git a/src/geode/inspector/criterion/internal/degeneration_impl.cpp b/src/geode/inspector/criterion/internal/degeneration_impl.cpp
@@ -72,14 +72,15 @@ namespace geode
 
         template < class MeshType >
         InspectionIssues< index_t >
-            DegenerationImpl< MeshType >::degenerated_edges() const
+            DegenerationImpl< MeshType >::degenerated_edges(
+                double tolerance ) const
         {
             InspectionIssues< index_t > degenerated_edges_index{
                 "Degenerated Edges."
             };
             for( const auto edge_index : Range{ mesh_.edges().nb_edges() } )
             {
-                if( edge_is_degenerated( edge_index ) )
+                if( edge_is_degenerated( edge_index, tolerance ) )
                 {
                     const auto edge_vertices =
                         mesh_.edges().edge_vertices( edge_index );
@@ -94,15 +95,29 @@ namespace geode
             return degenerated_edges_index;
         }
 
+        template < class MeshType >
+        InspectionIssues< index_t >
+            DegenerationImpl< MeshType >::degenerated_edges() const
+        {
+            return degenerated_edges( GLOBAL_EPSILON );
+        }
+
         template < class MeshType >
         bool DegenerationImpl< MeshType >::edge_is_degenerated(
-            index_t edge_index ) const
+            index_t edge_index, double tolerance ) const
         {
             const auto edge_vertices =
                 mesh_.edges().edge_vertices( edge_index );
             const auto p1 = mesh_.point( edge_vertices[0] );
             const auto p2 = mesh_.point( edge_vertices[1] );
-            return point_point_distance( p1, p2 ) < GLOBAL_EPSILON;
+            return point_point_distance( p1, p2 ) < tolerance;
+        }
+
+        template < class MeshType >
+        bool DegenerationImpl< MeshType >::edge_is_degenerated(
+            index_t edge_index ) const
+        {
+            return edge_is_degenerated( edge_index, GLOBAL_EPSILON );
         }
 
         template < class MeshType >
