wip

Author: BenPinet

bindings/python/src/inspector/topology/brep_topology.hpp

@@ -92,10 +92,10 @@ namespace geode
             .def_readwrite( "surfaces_not_linked_to_a_unique_vertex",
                 &BRepSurfacesTopologyInspectionResult::
                     surfaces_not_linked_to_a_unique_vertex )
-            .def_readwrite(
-                "unique_vertices_linked_to_not_internal_nor_boundary_surface",
+            .def_readwrite( "unique_vertices_linked_to_surface_with_wrong_"
+                            "relationship_with_blocks",
                 &BRepSurfacesTopologyInspectionResult::
-                    unique_vertices_linked_to_not_internal_nor_boundary_surface )
+                    unique_vertices_linked_to_surface_with_wrong_relationship_with_blocks )
             .def_readwrite(
                 "unique_vertices_linked_to_a_surface_with_invalid_embbedings",
                 &BRepSurfacesTopologyInspectionResult::

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

@@ -81,7 +81,7 @@ def surfaces_topological_validity(result, verbose):
         result.unique_vertices_linked_to_a_single_and_invalid_surface.nb_issues()
     )
     nb_issues += (
-        result.unique_vertices_linked_to_not_internal_nor_boundary_surface.nb_issues()
+        result.unique_vertices_linked_to_surface_with_wrong_relationship_with_blocks.nb_issues()
     )
     nb_issues += (
         result.unique_vertices_linked_to_several_and_invalid_surfaces.nb_issues()

include/geode/inspector/topology/brep_lines_topology.hpp

@@ -48,21 +48,11 @@ namespace geode
         InspectionIssuesMap< index_t > lines_not_linked_to_a_unique_vertex{
             "Lines with mesh vertices not linked to a unique vertex"
         };
-        InspectionIssues< index_t >
-            unique_vertices_linked_to_not_internal_nor_boundary_line{
-                "Indices of unique vertices linked to a Line without boundary "
-                "nor internal status."
-            };
         InspectionIssues< index_t >
             unique_vertices_linked_to_a_line_with_invalid_embeddings{
                 "Indices of unique vertices linked to a Line with invalid "
                 "internal topology."
             };
-        InspectionIssues< index_t >
-            unique_vertices_linked_to_a_single_and_invalid_line{
-                "Indices of unique vertices linked to only one Line and this "
-                "single Line is invalid."
-            };
         InspectionIssues< index_t >
             unique_vertices_linked_to_several_lines_but_not_linked_to_a_corner{
                 "Indices of unique vertices linked to several Lines but not "
@@ -102,18 +92,10 @@ namespace geode
         [[nodiscard]] bool line_vertices_are_associated_to_unique_vertices(
             const Line3D& line ) const;
 
-        [[nodiscard]] std::optional< std::string >
-            vertex_is_part_of_not_internal_nor_boundary_line(
-                index_t unique_vertex_index ) const;
-
         [[nodiscard]] std::optional< std::string >
             vertex_is_part_of_invalid_embedded_line(
                 index_t unique_vertex_index ) const;
 
-        [[nodiscard]] std::optional< std::string >
-            vertex_is_part_of_invalid_single_line(
-                index_t unique_vertex_index ) const;
-
         [[nodiscard]] std::optional< std::string >
             vertex_has_lines_but_is_not_a_corner(
                 index_t unique_vertex_index ) const;

include/geode/inspector/topology/brep_surfaces_topology.hpp

@@ -47,21 +47,11 @@ namespace geode
         InspectionIssuesMap< index_t > surfaces_not_linked_to_a_unique_vertex{
             "Surfaces with mesh vertices not linked to a unique vertex"
         };
-        InspectionIssues< index_t >
-            unique_vertices_linked_to_not_internal_nor_boundary_surface{
-                "Indices of unique vertices linked to Surface without boundary "
-                "nor internal status."
-            };
         InspectionIssues< index_t >
             unique_vertices_linked_to_a_surface_with_invalid_embbedings{
                 "Indices of unique vertices linked to a Surface with invalid "
                 "internal topology."
             };
-        InspectionIssues< index_t >
-            unique_vertices_linked_to_a_single_and_invalid_surface{
-                "Indices of unique vertices linked to only one Surface and "
-                "this single surface is invalid."
-            };
         InspectionIssues< index_t >
             unique_vertices_linked_to_several_and_invalid_surfaces{
                 "Indices of unique vertices linked to several Surfaces in an "
@@ -112,18 +102,10 @@ namespace geode
         [[nodiscard]] bool surface_vertices_are_associated_to_unique_vertices(
             const Surface3D& surface ) const;
 
-        [[nodiscard]] std::optional< std::string >
-            vertex_is_part_of_not_internal_nor_boundary_surface(
-                index_t unique_vertex_index ) const;
-
         [[nodiscard]] std::optional< std::string >
             vertex_is_part_of_invalid_embedded_surface(
                 index_t unique_vertex_index ) const;
 
-        [[nodiscard]] std::optional< std::string >
-            vertex_is_part_of_invalid_single_surface(
-                index_t unique_vertex_index ) const;
-
         [[nodiscard]] std::optional< std::string >
             vertex_is_part_of_invalid_multiple_surfaces(
                 index_t unique_vertex_index ) const;

include/geode/inspector/topology/section_lines_topology.hpp

@@ -103,7 +103,7 @@ namespace geode
             const Line2D& line ) const;
 
         [[nodiscard]] std::optional< std::string >
-            vertex_is_part_of_not_internal_nor_boundary_line(
+            vertex_is_part_of_line_with_wrong_relationships_to_surface(
                 const index_t unique_vertex_index ) const;
 
         [[nodiscard]] std::optional< std::string >

src/geode/inspector/topology/brep_blocks_topology.cpp

@@ -257,7 +257,7 @@ namespace
         std::vector< geode::uuid > not_boundaries;
         auto graph = geode::Graph::create();
         auto graph_builder = geode::GraphBuilder::create( *graph );
-        geode::BijectiveMapping< geode::uuid, geode::index_t >
+        geode::GenericMapping< geode::uuid, geode::index_t >
             line_uuids_to_graph_edges;
         geode::BijectiveMapping< geode::uuid, geode::index_t >
             corner_uuids_to_graph_vertices;
@@ -275,18 +275,29 @@ namespace
                 for( const auto& boundary_corner :
                     brep.boundaries( incident_line ) )
                 {
-                    if( boundary_corner.id() == corner.id() )
-                    {
-                        continue;
-                    }
+                    // if( boundary_corner.id() == corner.id() )
+                    // {
+                    //     continue;
+                    // }
                     SDEBUG( boundary_corner.id() );
                     const auto boundary_corner_vertex =
                         corner_uuids_to_graph_vertices.in2out(
                             boundary_corner.id() );
-                    if( line_uuids_to_graph_edges.has_mapping_input(
-                            incident_line.id() ) )
+                    // if( line_uuids_to_graph_edges.has_mapping_input(
+                    //         incident_line.id() ) )
+                    // {
+                    //     continue;
+                    // }
+                    if( const auto existing_edge = graph->edge_from_vertices(
+                            boundary_corner_vertex, corner_vertex ) )
                     {
-                        continue;
+                        if( line_uuids_to_graph_edges
+                                .out2in( existing_edge.value() )
+                                .at( 0 )
+                            == incident_line.id() )
+                        {
+                            continue;
+                        }
                     }
                     line_uuids_to_graph_edges.map( incident_line.id(),
                         graph_builder->create_edge(
@@ -298,51 +309,65 @@ namespace
         geode::save_graph( *graph, "graph.og_grp" );
         while( found_not_boundary_line )
         {
-            DEBUG( "found_not_boundary_lines" );
             std::vector< bool > to_delete( graph->nb_edges(), false );
             for( const auto graph_vertex :
                 geode::Range{ graph->nb_vertices() } )
             {
-                DEBUG( graph->edges_around_vertex( graph_vertex ).size() );
-                SDEBUG(
-                    brep.corner( corner_uuids_to_graph_vertices.out2in(
-                                     graph_vertex ) )
-                        .mesh()
-                        .point( 0 ) );
-                if( graph->edges_around_vertex( graph_vertex ).size() != 1 )
+                if( graph->edges_around_vertex( graph_vertex ).empty() )
                 {
                     continue;
                 }
-                const auto line_id = line_uuids_to_graph_edges.out2in(
-                    graph->edges_around_vertex( graph_vertex )
-                        .at( 0 )
-                        .edge_id );
-                DEBUG( to_delete.size() );
-                DEBUG( graph->edges_around_vertex( graph_vertex ).size() );
-                DEBUG( graph->edges_around_vertex( graph_vertex )
-                        .at( 0 )
-                        .edge_id );
+                const auto line_id =
+                    line_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( line_uuids_to_graph_edges.out2in( edge_around.edge_id )
+                            .at( 0 )
+                        != line_id )
+                    {
+                        should_delete = false;
+                        break;
+                    }
+                }
+                if( !should_delete )
+                {
+                    continue;
+                }
+                if( absl::c_contains( not_boundaries, line_id ) )
+                {
+                    continue;
+                }
+                for( const auto& edge :
+                    line_uuids_to_graph_edges.in2out( line_id ) )
+                {
+                    to_delete[edge] = true;
+                }
                 not_boundaries.push_back( line_id );
-                SDEBUG( line_id );
-                to_delete[graph->edges_around_vertex( graph_vertex )
-                        .at( 0 )
-                        .edge_id] = true;
             }
             if( !absl::c_contains( to_delete, true ) )
             {
                 found_not_boundary_line = false;
                 continue;
             }
             const auto old2new = graph_builder->delete_edges( to_delete );
-            geode::BijectiveMapping< geode::uuid, geode::index_t >
+            geode::GenericMapping< geode::uuid, geode::index_t >
                 new_line_uuids_to_graph_edges;
-            for( const auto& [line_id, graph_edge] :
+            for( const auto& [line_id, graph_edges] :
                 line_uuids_to_graph_edges.in2out_map() )
             {
-                if( old2new.at( graph_edge ) != geode::NO_ID )
+                for( const auto graph_edge : graph_edges )
                 {
-                    new_line_uuids_to_graph_edges.map(
-                        line_id, old2new.at( graph_edge ) );
+                    if( old2new.at( graph_edge ) != geode::NO_ID )
+                    {
+                        new_line_uuids_to_graph_edges.map(
+                            line_id, old2new.at( graph_edge ) );
+                    }
                 }
             }
             line_uuids_to_graph_edges = new_line_uuids_to_graph_edges;