Merge pull request #149 from Geode-solutions/fix/multiple_creation_of_edges

fix(DegenerationInspection): Fixed the multiple calls to enable_edges…

Author: BotellaA

bindings/python/tests/test-py-brep.py

@@ -224,11 +224,7 @@ def check_a1(verbose):
             "[Test] model model_A1_valid should have 13494 component meshes issues (pairs of component meshes triangles intersecting)."
         )
 
-
-def check_a1_valid(verbose):
-    test_dir = os.path.dirname(__file__)
-    data_dir = os.path.abspath(os.path.join(test_dir, "../../../tests/data"))
-    model_brep = opengeode.load_brep(data_dir + "/model_A1_valid.og_brep")
+def inspect_model_A1(model_brep,verbose):
     brep_inspector = inspector.BRepInspector(model_brep)
     result = brep_inspector.inspect_brep()
     if brep_inspector.brep_topology_is_valid():
@@ -248,11 +244,13 @@ def check_a1_valid(verbose):
             "[Test] model model_A1_valid should have 13494 component meshes issues (pairs of component meshes triangles intersecting)."
         )
 
-
-def check_model_mss(verbose):
+def check_a1_valid(verbose):
     test_dir = os.path.dirname(__file__)
     data_dir = os.path.abspath(os.path.join(test_dir, "../../../tests/data"))
-    model_brep = opengeode.load_brep(data_dir + "/mss.og_brep")
+    model_brep = opengeode.load_brep(data_dir + "/model_A1_valid.og_brep")
+    inspect_model_A1(model_brep,verbose)
+
+def inspect_model_mss(model_brep,verbose):
     brep_inspector = inspector.BRepInspector(model_brep)
     result = brep_inspector.inspect_brep()
     if brep_inspector.brep_topology_is_valid():
@@ -270,11 +268,13 @@ def check_model_mss(verbose):
     if nb_component_meshes_issues != 0:
         raise ValueError("[Test] model mss should have no component meshes issues.")
 
-
-def check_model_D(verbose):
+def check_model_mss(verbose):
     test_dir = os.path.dirname(__file__)
     data_dir = os.path.abspath(os.path.join(test_dir, "../../../tests/data"))
-    model_brep = opengeode.load_brep(data_dir + "/model_D.og_brep")
+    model_brep = opengeode.load_brep(data_dir + "/mss.og_brep")
+    inspect_model_mss(model_brep,verbose)
+
+def inspect_model_D(model_brep,verbose):
     brep_inspector = inspector.BRepInspector(model_brep)
     result = brep_inspector.inspect_brep()
 
@@ -292,7 +292,13 @@ def check_model_D(verbose):
     )
     if nb_component_meshes_issues != 0:
         raise ValueError("[Test] model_D should have no component meshes issues.")
+    
 
+def check_model_D(verbose):
+    test_dir = os.path.dirname(__file__)
+    data_dir = os.path.abspath(os.path.join(test_dir, "../../../tests/data"))
+    model_brep = opengeode.load_brep(data_dir + "/model_D.og_brep")
+    inspect_model_D(model_brep,verbose)
 
 if __name__ == "__main__":
     inspector.InspectorInspectorLibrary.initialize()

include/geode/inspector/criterion/internal/component_meshes_degeneration.hpp

@@ -23,13 +23,17 @@
 
 #pragma once
 
-#include <absl/container/flat_hash_map.h>
+#include <absl/container/flat_hash_set.h>
 
 #include <geode/inspector/common.hpp>
 #include <geode/inspector/information.hpp>
 
 namespace geode
 {
+    FORWARD_DECLARATION_DIMENSION_CLASS( Line );
+    FORWARD_DECLARATION_DIMENSION_CLASS( Surface );
+    ALIAS_2D_AND_3D( Line );
+    ALIAS_2D_AND_3D( Surface );
     struct uuid;
     struct PolygonEdge;
 } // namespace geode
@@ -48,6 +52,8 @@ namespace geode
             OPENGEODE_DISABLE_COPY( ComponentMeshesDegeneration );
 
         public:
+            virtual ~ComponentMeshesDegeneration();
+
             void add_small_edges( InspectionIssuesMap< index_t >& issues_map,
                 double threshold ) const;
 
@@ -66,8 +72,12 @@ namespace geode
 
             [[nodiscard]] const Model& model() const;
 
+        private:
+            std::vector< uuid > surfaces_on_which_enable_edges() const;
+
         private:
             const Model& model_;
+            mutable absl::flat_hash_set< uuid > enabled_edges_surfaces_;
         };
     } // namespace internal
 } // namespace geode

include/geode/inspector/criterion/internal/degeneration_impl.hpp

@@ -52,14 +52,16 @@ namespace geode
 
             [[nodiscard]] bool edge_is_degenerated( index_t edge_index ) const;
 
+            void enable_edges_on_mesh() const;
+
         protected:
             explicit DegenerationImpl( const Mesh& mesh );
 
             [[nodiscard]] const Mesh& mesh() const;
 
         private:
             const Mesh& mesh_;
-            bool enabled_edges_;
+            mutable bool enabled_edges_;
         };
     } // namespace internal
 } // namespace geode

src/geode/inspector/brep_inspector.cpp

@@ -63,5 +63,4 @@ namespace geode
             } );
         return result;
     }
-
 } // namespace geode

src/geode/inspector/criterion/degeneration/brep_meshes_degeneration.cpp

@@ -26,6 +26,8 @@
 #include <geode/basic/logger.hpp>
 #include <geode/basic/pimpl_impl.hpp>
 
+#include <geode/mesh/core/solid_mesh.hpp>
+
 #include <geode/model/mixin/core/block.hpp>
 #include <geode/model/representation/core/brep.hpp>
 
@@ -76,14 +78,28 @@ namespace geode
         {
         }
 
+        ~Impl()
+        {
+            for( const auto& block_id : enabled_edges_blocks_ )
+            {
+                model().block( block_id ).mesh().disable_edges();
+            }
+        }
+
         void add_solid_small_elements(
             InspectionIssuesMap< index_t >& small_edges_map,
             InspectionIssuesMap< index_t >& small_polyhedra_map,
             double threshold ) const
         {
             for( const auto& block : model().blocks() )
             {
-                const geode::SolidMeshDegeneration3D inspector{ block.mesh() };
+                const auto& mesh = block.mesh();
+                if( !mesh.are_edges_enabled() )
+                {
+                    mesh.enable_edges();
+                    enabled_edges_blocks_.emplace( block.id() );
+                }
+                const geode::SolidMeshDegeneration3D inspector{ mesh };
                 auto small_edges = inspector.small_edges( threshold );
                 small_edges.set_description( absl::StrCat(
                     "Block ", block.id().string(), " small edges" ) );
@@ -105,6 +121,9 @@ namespace geode
             add_solid_small_elements( degenerated_edges_map,
                 degenerated_polyhedra_map, GLOBAL_EPSILON );
         }
+
+    private:
+        mutable absl::flat_hash_set< uuid > enabled_edges_blocks_;
     };
 
     BRepComponentMeshesDegeneration::BRepComponentMeshesDegeneration(

src/geode/inspector/criterion/internal/component_meshes_degeneration.cpp

@@ -23,6 +23,8 @@
 
 #include <geode/inspector/criterion/internal/component_meshes_degeneration.hpp>
 
+#include <async++.h>
+
 #include <geode/basic/logger.hpp>
 
 #include <geode/mesh/core/surface_mesh.hpp>
@@ -45,33 +47,74 @@ namespace geode
             : model_( model )
         {
         }
+        template < typename Model >
+        ComponentMeshesDegeneration< Model >::~ComponentMeshesDegeneration()
+        {
+            for( const auto& surface_id : enabled_edges_surfaces_ )
+            {
+                model_.surface( surface_id ).mesh().disable_edges();
+            }
+        }
 
         template < typename Model >
         void ComponentMeshesDegeneration< Model >::add_small_edges(
             InspectionIssuesMap< index_t >& components_small_edges,
             double threshold ) const
         {
+            std::vector<
+                async::task< std::pair< uuid, InspectionIssues< index_t > > > >
+                line_tasks;
+            line_tasks.reserve( model_.nb_lines() );
             for( const auto& line : model_.lines() )
             {
-                const EdgedCurveDegeneration< Model::dim > inspector{
-                    line.mesh()
-                };
-                auto issues = inspector.small_edges( threshold );
-                issues.set_description( absl::StrCat(
-                    "Line ", line.id().string(), " small edges" ) );
+                line_tasks.emplace_back( async::spawn( [&threshold, &line] {
+                    const EdgedCurveDegeneration< Model::dim > inspector{
+                        line.mesh()
+                    };
+                    auto issues = inspector.small_edges( threshold );
+                    issues.set_description( absl::StrCat(
+                        "Line ", line.id().string(), " small edges" ) );
+                    return std::make_pair( line.id(), std::move( issues ) );
+                } ) );
+            }
+            for( auto& task :
+                async::when_all( line_tasks.begin(), line_tasks.end() ).get() )
+            {
+                auto [line_id, issues] = task.get();
                 components_small_edges.add_issues_to_map(
-                    line.id(), std::move( issues ) );
+                    line_id, std::move( issues ) );
             }
+            std::vector<
+                async::task< std::pair< uuid, InspectionIssues< index_t > > > >
+                surface_tasks;
+            surface_tasks.reserve( model_.nb_surfaces() );
+            const auto surfaces_to_enable = surfaces_on_which_enable_edges();
             for( const auto& surface : model_.surfaces() )
             {
-                const geode::SurfaceMeshDegeneration< Model::dim > inspector{
-                    surface.mesh()
-                };
-                auto issues = inspector.small_edges( threshold );
-                issues.set_description( absl::StrCat(
-                    "Surface ", surface.id().string(), " small edges" ) );
+                const auto enable_edges =
+                    absl::c_contains( surfaces_to_enable, surface.id() );
+                surface_tasks.emplace_back(
+                    async::spawn( [&enable_edges, &threshold, &surface] {
+                        if( enable_edges )
+                        {
+                            surface.mesh().enable_edges();
+                        }
+                        const geode::SurfaceMeshDegeneration< Model::dim >
+                            inspector{ surface.mesh() };
+                        auto issues = inspector.small_edges( threshold );
+                        issues.set_description( absl::StrCat( "Surface ",
+                            surface.id().string(), " small edges" ) );
+                        return std::make_pair(
+                            surface.id(), std::move( issues ) );
+                    } ) );
+            }
+            for( auto& task :
+                async::when_all( surface_tasks.begin(), surface_tasks.end() )
+                    .get() )
+            {
+                auto [surface_id, issues] = task.get();
                 components_small_edges.add_issues_to_map(
-                    surface.id(), std::move( issues ) );
+                    surface_id, std::move( issues ) );
             }
         }
 
@@ -87,16 +130,27 @@ namespace geode
             InspectionIssuesMap< index_t >& components_small_polygons,
             double threshold ) const
         {
+            std::vector<
+                async::task< std::pair< uuid, InspectionIssues< index_t > > > >
+                tasks;
+            tasks.reserve( model_.nb_surfaces() );
             for( const auto& surface : model_.surfaces() )
             {
-                const geode::SurfaceMeshDegeneration< Model::dim > inspector{
-                    surface.mesh()
-                };
-                auto issues = inspector.small_height_polygons( threshold );
-                issues.set_description( absl::StrCat(
-                    "Surface ", surface.id().string(), " small polygons" ) );
+                tasks.emplace_back( async::spawn( [&threshold, &surface] {
+                    const geode::SurfaceMeshDegeneration< Model::dim >
+                        inspector{ surface.mesh() };
+                    auto issues = inspector.small_height_polygons( threshold );
+                    issues.set_description( absl::StrCat( "Surface ",
+                        surface.id().string(), " small polygons" ) );
+                    return std::make_pair( surface.id(), std::move( issues ) );
+                } ) );
+            }
+            for( auto& task :
+                async::when_all( tasks.begin(), tasks.end() ).get() )
+            {
+                auto [surface_id, issues] = task.get();
                 components_small_polygons.add_issues_to_map(
-                    surface.id(), std::move( issues ) );
+                    surface_id, std::move( issues ) );
             }
         }
 
@@ -115,6 +169,24 @@ namespace geode
             return model_;
         }
 
+        template < typename Model >
+        std::vector< uuid > ComponentMeshesDegeneration<
+            Model >::surfaces_on_which_enable_edges() const
+        {
+            std::vector< uuid > result;
+            for( const auto& surface : model_.surfaces() )
+            {
+                const auto& mesh = surface.mesh();
+                if( !mesh.are_edges_enabled()
+                    && !enabled_edges_surfaces_.contains( surface.id() ) )
+                {
+                    result.emplace_back( surface.id() );
+                    enabled_edges_surfaces_.emplace( surface.id() );
+                }
+            }
+            return result;
+        }
+
         template class opengeode_inspector_inspector_api
             ComponentMeshesDegeneration< Section >;
         template class opengeode_inspector_inspector_api

src/geode/inspector/criterion/internal/degeneration_impl.cpp

@@ -41,11 +41,6 @@ namespace geode
         DegenerationImpl< MeshType >::DegenerationImpl( const MeshType& mesh )
             : mesh_( mesh ), enabled_edges_( false )
         {
-            if( !mesh_.are_edges_enabled() )
-            {
-                mesh_.enable_edges();
-                enabled_edges_ = true;
-            }
         }
 
         template < class MeshType >
@@ -60,6 +55,7 @@ namespace geode
         template < class MeshType >
         bool DegenerationImpl< MeshType >::is_mesh_degenerated() const
         {
+            enable_edges_on_mesh();
             for( const auto edge_index : Range{ mesh_.edges().nb_edges() } )
             {
                 if( edge_is_degenerated( edge_index ) )
@@ -74,6 +70,7 @@ namespace geode
         InspectionIssues< index_t > DegenerationImpl< MeshType >::small_edges(
             double threshold ) const
         {
+            enable_edges_on_mesh();
             InspectionIssues< index_t > degenerated_edges_index{
                 "Degenerated Edges."
             };
@@ -112,6 +109,16 @@ namespace geode
             return point_point_distance( p1, p2 ) < threshold;
         }
 
+        template < class MeshType >
+        void DegenerationImpl< MeshType >::enable_edges_on_mesh() const
+        {
+            if( !mesh_.are_edges_enabled() )
+            {
+                mesh_.enable_edges();
+                enabled_edges_ = true;
+            }
+        }
+
         template < class MeshType >
         bool DegenerationImpl< MeshType >::edge_is_degenerated(
             index_t edge_index ) const