fix(DegenerationInspection): Fixed the multiple calls to enable_edges/disable_edges when checking for model degenerations.

Author: MelchiorSchuh

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,13 @@ namespace geode
 
             [[nodiscard]] const Model& model() const;
 
+        private:
+            void enable_edges_on_surface(
+                const Surface< Model::dim >& surface ) 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/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,65 @@ 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 > > > >
+                tasks;
+            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" ) );
+                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( tasks.begin(), 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 > > > >
+                tasks;
+            tasks.reserve( model_.nb_surfaces() );
             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" ) );
+                tasks.emplace_back( async::spawn( [&threshold, &surface] {
+                    enable_edges_on_surface( surface );
+                    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( tasks.begin(), 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 +121,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 +160,18 @@ namespace geode
             return model_;
         }
 
+        template < typename Model >
+        void ComponentMeshesDegeneration< Model >::enable_edges_on_surface(
+            const Surface< Model::dim >& surface ) const
+        {
+            const auto& mesh = surface.mesh();
+            if( !mesh.are_edges_enabled() )
+            {
+                mesh.enable_edges();
+                enabled_edges_surfaces_.emplace( surface.id() );
+            }
+        }
+
         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