perf(Intersections): use the parallel AABB self intersections

.clang-tidy

@@ -14,6 +14,7 @@ Checks: >
   -misc-no-recursion,
   -misc-include-cleaner,
   -misc-const-correctness,
+  -modernize-use-scoped-lock,
   -modernize-use-trailing-return-type,
   -portability-avoid-pragma-once,
   -readability-use-anyofallof,

src/geode/inspector/inspection/criterion/intersections/model_intersections.cpp

@@ -51,15 +51,11 @@
 {
     struct ComponentOverlap
     {
-        bool operator()(
-            geode::index_t first_component, geode::index_t second_component )
+        [[nodiscard]] bool operator()( geode::index_t /*first_component*/,
+            geode::index_t /*second_component*/ ) const
         {
-            component_pairs.emplace_back( first_component, second_component );
-            return false;
+            return true;
         }
-
-        std::vector< std::pair< geode::index_t, geode::index_t > >
-            component_pairs;
     };
 
     [[nodiscard]] absl::InlinedVector< geode::PolygonVertices, 1 >
@@ -82,7 +78,7 @@
     {
     public:
         BRepLineSurfacesIntersection( const geode::BRep& model,
             const geode::uuid& surface_id,
             const geode::uuid& line_id )
             : surface_( model.surface( surface_id ) ),
               line_( model.line( line_id ) ),
@@ -164,7 +160,7 @@
     class ModelIntersectionBase
     {
     public:
         ModelIntersectionBase( const Model& model ) : model_( model ) {}
 
         [[nodiscard]] std::vector< std::pair< geode::index_t, geode::index_t > >
             intersecting_elements()
@@ -205,9 +201,15 @@
         {
         }
 
+        [[nodiscard]] bool self_intersect(
+            geode::index_t p1_id, geode::index_t p2_id ) const
+        {
+            return p1_id != p2_id && polygons_intersect( p1_id, p2_id );
+        }
+
     protected:
         [[nodiscard]] bool polygons_intersect(
             geode::index_t p1_id, geode::index_t p2_id ) const
         {
             const auto p1_vertices = this->mesh1().polygon_vertices( p1_id );
             const auto p2_vertices = this->mesh2().polygon_vertices( p2_id );
@@ -249,7 +251,7 @@
 
         [[nodiscard]] absl::InlinedVector< std::array< geode::index_t, 2 >, 3 >
             triangles_common_vertices(
                 const geode::PolygonVertices& t1_vertices,
                 const geode::PolygonVertices& t2_vertices ) const
         {
             absl::InlinedVector< std::array< geode::index_t, 2 >, 3 >
@@ -425,7 +427,7 @@
 
     template <>
     [[nodiscard]] bool
         ModelSurfacesIntersectionBase< geode::Section >::triangles_intersect(
             const geode::PolygonVertices& t1_vertices,
             const geode::PolygonVertices& t2_vertices,
             absl::Span< const std::array< geode::index_t, 2 > >
@@ -505,7 +507,7 @@
         return false;
     }
 
     [[nodiscard]] bool triangle_intersects_other(
         const geode::Triangle3D& triangle1,
         const geode::Triangle3D& triangle2,
         const geode::PolygonVertices& t1_vertices,
@@ -574,7 +576,7 @@
         const auto triangle1 = mesh_triangle( mesh1_, t1_vertices );
         return triangle_intersects_other( triangle1, triangle2, t1_vertices,
                    t2_vertices, common_vertices, 1 )
                || triangle_intersects_other( triangle2, triangle1, t2_vertices,
                    t1_vertices, common_vertices, 0 );
     }
 
@@ -609,8 +611,14 @@
             return false;
         }
 
+        [[nodiscard]] bool self_intersect(
+            geode::index_t e1_id, geode::index_t e2_id ) const
+        {
+            return e1_id != e2_id && lines_intersect( e1_id, e2_id );
+        }
+
     private:
         bool lines_intersect( geode::index_t p1_id, geode::index_t p2_id ) const
         {
             const auto [position1, position2] =
                 geode::segment_segment_intersection_detection(
@@ -626,6 +634,25 @@
         const geode::EdgedCurve< dimension >& mesh2_;
         const bool same_line_{ false };
     };
+
+    template < typename Action >
+    class SelfIntersectionTest
+    {
+    public:
+        explicit SelfIntersectionTest( const Action& action )
+            : action_( action )
+        {
+        }
+
+        [[nodiscard]] bool operator()(
+            geode::index_t element1, geode::index_t element2 ) const
+        {
+            return action_.self_intersect( element1, element2 );
+        }
+
+    private:
+        const Action& action_;
+    };
 } // namespace
 
 namespace geode
@@ -785,17 +812,19 @@
             for( const auto& surface : model_.active_surfaces() )
             {
                 tasks.emplace_back( async::spawn( [this, &surface] {
-                    Action surfaces_intersection_action{ model_, surface.id(),
-                        surface.id() };
-                    surfaces_model_tree_
-                        .mesh_trees_[surfaces_model_tree_.mesh_tree_ids_.at(
-                            surface.id() )]
-                        .compute_self_element_bbox_intersections(
-                            surfaces_intersection_action );
+                    const Action surfaces_intersection_action{ model_,
+                        surface.id(), surface.id() };
+                    const auto intersecting_elements =
+                        surfaces_model_tree_
+                            .mesh_trees_[surfaces_model_tree_.mesh_tree_ids_.at(
+                                surface.id() )]
+                            .compute_self_element_bbox_intersections(
+                                SelfIntersectionTest< Action >{
+                                    surfaces_intersection_action } );
                     IntersectionsResult result;
                     const auto surface_id = surface.component_id();
                     for( const auto& [polygon1, polygon2] :
-                        surfaces_intersection_action.intersecting_elements() )
+                        intersecting_elements )
                     {
                         result.emplace_back(
                             ComponentMeshElement{ surface_id, polygon1 },
@@ -804,10 +833,11 @@
                     return result;
                 } ) );
             }
-            ComponentOverlap surfaces_overlap;
-            surfaces_model_tree_.components_tree_
-                .compute_self_element_bbox_intersections( surfaces_overlap );
-            for( const auto& components : surfaces_overlap.component_pairs )
+            const auto surfaces_overlap =
+                surfaces_model_tree_.components_tree_
+                    .compute_self_element_bbox_intersections(
+                        ComponentOverlap{} );
+            for( const auto& components : surfaces_overlap )
             {
                 tasks.emplace_back( async::spawn( [this, &components] {
                     const auto surface_uuid1 =
@@ -865,17 +895,20 @@
             for( const auto& line : model_.active_lines() )
             {
                 tasks.emplace_back( async::spawn( [this, &line] {
-                    LineLineIntersection lines_intersection_action{ model_,
-                        line.id(), line.id() };
-                    lines_model_tree_
-                        .mesh_trees_[lines_model_tree_.mesh_tree_ids_.at(
-                            line.id() )]
-                        .compute_self_element_bbox_intersections(
-                            lines_intersection_action );
+                    const LineLineIntersection lines_intersection_action{
+                        model_, line.id(), line.id()
+                    };
+                    const auto intersecting_elements =
+                        lines_model_tree_
+                            .mesh_trees_[lines_model_tree_.mesh_tree_ids_.at(
+                                line.id() )]
+                            .compute_self_element_bbox_intersections(
+                                SelfIntersectionTest<
+                                    LineLineIntersection< Model > >{
+                                    lines_intersection_action } );
                     IntersectionsResult result;
                     const auto line_id = line.component_id();
-                    for( const auto& [edge1, edge2] :
-                        lines_intersection_action.intersecting_elements() )
+                    for( const auto& [edge1, edge2] : intersecting_elements )
                     {
                         result.emplace_back(
                             ComponentMeshElement{ line_id, edge1 },
@@ -884,10 +917,11 @@
                     return result;
                 } ) );
             }
-            ComponentOverlap lines_overlap;
-            lines_model_tree_.components_tree_
-                .compute_self_element_bbox_intersections( lines_overlap );
-            for( const auto& components : lines_overlap.component_pairs )
+            const auto lines_overlap =
+                lines_model_tree_.components_tree_
+                    .compute_self_element_bbox_intersections(
+                        ComponentOverlap{} );
+            for( const auto& components : lines_overlap )
             {
                 tasks.emplace_back( async::spawn( [this, &components] {
                     const auto line_uuid1 =

src/geode/inspector/inspection/criterion/intersections/surface_intersections.cpp

@@ -41,55 +41,28 @@
     class PolygonPolygonIntersection
     {
     public:
-        PolygonPolygonIntersection( const geode::SurfaceMesh< dimension >& mesh,
-            bool stop_at_first_intersection )
-            : mesh_( mesh ),
-              stop_at_first_intersection_{ stop_at_first_intersection }
+        explicit PolygonPolygonIntersection(
+            const geode::SurfaceMesh< dimension >& mesh )
+            : mesh_( mesh )
         {
         }
 
-        std::vector< std::pair< geode::index_t, geode::index_t > >
-            intersecting_polygons()
-        {
-            return std::move( intersecting_polygons_ );
-        }
-
-        bool operator()( geode::index_t p1_id, geode::index_t p2_id )
+        [[nodiscard]] bool operator()(
+            geode::index_t p1_id, geode::index_t p2_id ) const
         {
             if( p1_id == p2_id )
             {
                 return false;
             }
-            const auto p1_vertices = this->mesh().polygon_vertices( p1_id );
-            const auto p2_vertices = this->mesh().polygon_vertices( p2_id );
-            if( geode::detail::polygons_intersection_detection<
-                    geode::SurfaceMesh< dimension > >(
-                    mesh_, p1_vertices, p2_vertices ) )
-            {
-                this->emplace( p1_id, p2_id );
-                return stop_at_first_intersection_;
-            }
-            return false;
-        }
-
-    protected:
-        void emplace( geode::index_t p1_id, geode::index_t p2_id )
-        {
-            std::lock_guard< std::mutex > lock( mutex_ );
-            intersecting_polygons_.emplace_back( p1_id, p2_id );
-        }
-
-        const geode::SurfaceMesh< dimension >& mesh() const
-        {
-            return mesh_;
+            const auto p1_vertices = mesh_.polygon_vertices( p1_id );
+            const auto p2_vertices = mesh_.polygon_vertices( p2_id );
+            return geode::detail::polygons_intersection_detection<
+                geode::SurfaceMesh< dimension > >(
+                mesh_, p1_vertices, p2_vertices );
         }
 
     private:
         const geode::SurfaceMesh< dimension >& mesh_;
-        bool stop_at_first_intersection_;
-        std::vector< std::pair< geode::index_t, geode::index_t > >
-            intersecting_polygons_;
-        std::mutex mutex_;
     };
 } // namespace
 
@@ -106,7 +79,7 @@
 
         bool mesh_has_self_intersections() const
         {
-            const auto intersections = intersecting_polygons( true );
+            const auto intersections = intersecting_polygons();
             if( intersections.empty() )
             {
                 return false;
@@ -117,7 +90,7 @@
         InspectionIssues< std::pair< index_t, index_t > >
             intersecting_elements() const
         {
-            const auto intersections = intersecting_polygons( false );
+            const auto intersections = intersecting_polygons();
             InspectionIssues< std::pair< index_t, index_t > > issues{
                 "intersections between polygons"
             };
@@ -132,14 +105,13 @@
         }
 
     private:
-        std::vector< std::pair< index_t, index_t > > intersecting_polygons(
-            bool stop_at_first_intersection ) const
+        std::vector< std::pair< index_t, index_t > >
+            intersecting_polygons() const
         {
             const auto surface_aabb = create_aabb_tree( mesh_ );
-            PolygonPolygonIntersection< dimension > action{ mesh_,
-                stop_at_first_intersection };
-            surface_aabb.compute_self_element_bbox_intersections( action );
-            return action.intersecting_polygons();
+            const PolygonPolygonIntersection< dimension > action{ mesh_ };
+            return surface_aabb.compute_self_element_bbox_intersections(
+                action );
         }
 
     private: