keep cleaning

Author: BenPinet

src/geode/inspector/topology/brep_blocks_topology.cpp

@@ -31,20 +31,14 @@
 #include <geode/basic/attribute_manager.hpp>
 #include <geode/basic/logger.hpp>
 
-#include <geode/geometry/aabb.hpp>
 #include <geode/geometry/point.hpp>
 
 #include <geode/mesh/builder/graph_builder.hpp>
 #include <geode/mesh/builder/polygonal_surface_builder.hpp>
-#include <geode/mesh/builder/vertex_set_builder.hpp>
-#include <geode/mesh/core/edged_curve.hpp>
 #include <geode/mesh/core/graph.hpp>
-#include <geode/mesh/core/point_set.hpp>
 #include <geode/mesh/core/polygonal_surface.hpp>
 #include <geode/mesh/core/solid_mesh.hpp>
 #include <geode/mesh/core/surface_edges.hpp>
-#include <geode/mesh/core/triangulated_surface.hpp>
-#include <geode/mesh/helpers/aabb_surface_helpers.hpp>
 
 #include <geode/model/helpers/component_mesh_edges.hpp>
 #include <geode/model/helpers/ray_tracing.hpp>
@@ -162,51 +156,10 @@ namespace
             line_uuids_to_graph_vertices;
         auto graph = geode::Graph::create();
         auto graph_builder = geode::GraphBuilder::create( *graph );
-        build_surface_line_graph( brep, *graph, *graph_builder,
-            surface_uuids_to_graph_edges, line_uuids_to_graph_vertices );
-        bool found_not_boundary_surface{ true };
-        while( found_not_boundary_surface )
-        {
-            const auto to_delete = find_graph_surfaces_to_delete(
-                *graph, surface_uuids_to_graph_edges, not_boundaries_surfaces );
-            if( !absl::c_contains( to_delete, true ) )
-            {
-                found_not_boundary_surface = false;
-                continue;
-            }
-            const auto old2new = graph_builder->delete_edges( to_delete );
-            geode::GenericMapping< geode::uuid, geode::index_t >
-                new_surface_uuids_to_graph_edges;
-            for( const auto& [surface_id, graph_edges] :
-                surface_uuids_to_graph_edges.in2out_map() )
-            {
-                for( const auto graph_edge : graph_edges )
-                {
-                    if( old2new.at( graph_edge ) != geode::NO_ID )
-                    {
-                        new_surface_uuids_to_graph_edges.map(
-                            surface_id, old2new.at( graph_edge ) );
-                    }
-                }
-            }
-            surface_uuids_to_graph_edges = new_surface_uuids_to_graph_edges;
-            graph_builder->delete_isolated_vertices();
-        }
-        return not_boundaries_surfaces;
-    }
-
-    void build_surface_line_graph( const geode::BRep& brep,
-        geode::Graph& graph,
-        geode::GraphBuilder& graph_builder,
-        geode::GenericMapping< geode::uuid, geode::index_t >&
-            surface_uuids_to_graph_edges,
-        geode::BijectiveMapping< geode::uuid, geode::index_t >&
-            line_uuids_to_graph_vertices )
-    {
         for( const auto& line : brep.lines() )
         {
             line_uuids_to_graph_vertices.map(
-                line.id(), graph_builder.create_vertex() );
+                line.id(), graph_builder->create_vertex() );
         }
         for( const auto& line : brep.lines() )
         {
@@ -220,7 +173,7 @@ namespace
                     const auto boundary_line_vertex =
                         line_uuids_to_graph_vertices.in2out(
                             boundary_line.id() );
-                    if( const auto existing_edge = graph.edge_from_vertices(
+                    if( const auto existing_edge = graph->edge_from_vertices(
                             boundary_line_vertex, line_vertex ) )
                     {
                         if( surface_uuids_to_graph_edges
@@ -232,60 +185,80 @@ namespace
                         }
                     }
                     surface_uuids_to_graph_edges.map( incident_surface.id(),
-                        graph_builder.create_edge(
+                        graph_builder->create_edge(
                             boundary_line_vertex, line_vertex ) );
                 }
             }
         }
-    }
-
-    std::vector< bool > find_graph_surfaces_to_delete(
-        const geode::Graph& graph,
-        const geode::GenericMapping< geode::uuid, geode::index_t >&
-            surface_uuids_to_graph_edges,
-        std::vector< geode::uuid > not_boundaries_surfaces )
-    {
-        std::vector< bool > to_delete( graph.nb_edges(), false );
-        for( const auto graph_vertex : geode::Range{ graph.nb_vertices() } )
+        bool found_not_boundary_surface{ true };
+        while( found_not_boundary_surface )
         {
-            if( graph.edges_around_vertex( graph_vertex ).empty() )
+            std::vector< bool > to_delete( graph->nb_edges(), false );
+            for( const auto graph_vertex :
+                geode::Range{ graph->nb_vertices() } )
             {
-                continue;
-            }
-            const auto surface_id =
-                surface_uuids_to_graph_edges
-                    .out2in( graph.edges_around_vertex( graph_vertex )
+                if( graph->edges_around_vertex( graph_vertex ).empty() )
+                {
+                    continue;
+                }
+                const auto surface_id =
+                    surface_uuids_to_graph_edges
+                        .out2in( graph->edges_around_vertex( graph_vertex )
+                                .at( 0 )
+                                .edge_id )
+                        .at( 0 );
+                bool should_delete{ true };
+                for( const auto& edge_around :
+                    graph->edges_around_vertex( graph_vertex ) )
+                {
+                    if( surface_uuids_to_graph_edges
+                            .out2in( edge_around.edge_id )
                             .at( 0 )
-                            .edge_id )
-                    .at( 0 );
-            bool should_delete{ true };
-            for( const auto& edge_around :
-                graph.edges_around_vertex( graph_vertex ) )
-            {
-                if( surface_uuids_to_graph_edges.out2in( edge_around.edge_id )
-                        .at( 0 )
-                    != surface_id )
+                        != surface_id )
+                    {
+                        should_delete = false;
+                        break;
+                    }
+                }
+                if( !should_delete )
                 {
-                    should_delete = false;
-                    break;
+                    continue;
                 }
+                if( absl::c_contains( not_boundaries_surfaces, surface_id ) )
+                {
+                    continue;
+                }
+                for( const auto& edge :
+                    surface_uuids_to_graph_edges.in2out( surface_id ) )
+                {
+                    to_delete[edge] = true;
+                }
+                not_boundaries_surfaces.push_back( surface_id );
             }
-            if( !should_delete )
-            {
-                continue;
-            }
-            if( absl::c_contains( not_boundaries_surfaces, surface_id ) )
+            if( !absl::c_contains( to_delete, true ) )
             {
+                found_not_boundary_surface = false;
                 continue;
             }
-            for( const auto& edge :
-                surface_uuids_to_graph_edges.in2out( surface_id ) )
+            const auto old2new = graph_builder->delete_edges( to_delete );
+            geode::GenericMapping< geode::uuid, geode::index_t >
+                new_surface_uuids_to_graph_edges;
+            for( const auto& [surface_id, graph_edges] :
+                surface_uuids_to_graph_edges.in2out_map() )
             {
-                to_delete[edge] = true;
+                for( const auto graph_edge : graph_edges )
+                {
+                    if( old2new.at( graph_edge ) != geode::NO_ID )
+                    {
+                        new_surface_uuids_to_graph_edges.map(
+                            surface_id, old2new.at( graph_edge ) );
+                    }
+                }
             }
-            not_boundaries_surfaces.push_back( surface_id );
+            surface_uuids_to_graph_edges = new_surface_uuids_to_graph_edges;
+            graph_builder->delete_isolated_vertices();
         }
-        return to_delete;
+        return not_boundaries_surfaces;
     }
 
     bool verify_blocks_boundaries(