refactoring corners

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

@@ -47,13 +47,13 @@ namespace geode
             .def( "invalid_components_topology_unique_vertices",
                 &BRepTopologyInspector::
                     invalid_components_topology_unique_vertices )
-            .def( "multiple_corners_unique_vertices",
-                &BRepTopologyInspector::multiple_corners_unique_vertices )
-            .def( "multiple_internals_corner_vertices",
-                &BRepTopologyInspector::multiple_internals_corner_vertices )
-            .def( "not_internal_nor_boundary_corner_vertices",
-                &BRepTopologyInspector::
-                    not_internal_nor_boundary_corner_vertices )
+            /*           .def( "multiple_corners_unique_vertices",
+                           &BRepTopologyInspector::multiple_corners_unique_vertices
+               ) .def( "multiple_internals_corner_vertices",
+                           &BRepTopologyInspector::multiple_internals_corner_vertices
+               ) .def( "not_internal_nor_boundary_corner_vertices",
+                           &BRepTopologyInspector::
+                               not_internal_nor_boundary_corner_vertices )*/
             .def( "line_corners_without_boundary_status",
                 &BRepTopologyInspector::line_corners_without_boundary_status )
             .def( "part_of_not_boundary_nor_internal_line_unique_vertices",

include/geode/inspector/topology/brep_corners_topology.h

@@ -24,14 +24,24 @@
 #pragma once
 
 #include <geode/inspector/common.h>
+#include <geode\model\mixin\core\vertex_identifier.h>
 
 namespace geode
 {
+    struct ComponentMeshVertex;
     class BRep;
 } // namespace geode
 
 namespace geode
 {
+    struct opengeode_inspector_inspector_api CornerInspectionResult
+    {
+        std::vector< ComponentMeshVertex > corners_not_linked_to_unique_vertex;
+        std::vector< index_t > multiple_corners_unique_vertices;
+        std::vector< index_t > multiple_internals_corner_vertices;
+        std::vector< index_t > not_internal_nor_boundary_corner_vertices;
+    };
+
     class opengeode_inspector_inspector_api BRepCornersTopology
     {
     public:
@@ -61,6 +71,8 @@ namespace geode
         bool corner_is_part_of_line_but_not_boundary(
             index_t unique_vertex_index ) const;
 
+        CornerInspectionResult inspect_corners() const;
+
     private:
         const BRep& brep_;
         bool verbose_;

include/geode/inspector/topology/brep_topology.h

@@ -39,6 +39,10 @@ namespace geode
 
 namespace geode
 {
+    struct opengeode_inspector_inspector_api BRepInspectionResult
+    {
+        CornerInspectionResult corners;
+    };
     /*!
      * Class for inspecting the topology of a BRep model corners
      */
@@ -67,6 +71,8 @@ namespace geode
 
         bool brep_unique_vertices_are_linked_to_a_component_vertex() const;
 
+        BRepInspectionResult inspect_brep() const;
+
         std::vector< ComponentMeshVertex >
             component_vertices_not_linked_to_a_unique_vertex() const;
 
@@ -76,13 +82,6 @@ namespace geode
         std::vector< index_t >
             invalid_components_topology_unique_vertices() const;
 
-        std::vector< index_t > multiple_corners_unique_vertices() const;
-
-        std::vector< index_t > multiple_internals_corner_vertices() const;
-
-        std::vector< index_t >
-            not_internal_nor_boundary_corner_vertices() const;
-
         std::vector< index_t > line_corners_without_boundary_status() const;
 
         std::vector< index_t >

src/bin/geode-inspector-brep.cpp

@@ -67,6 +67,7 @@ void inspect_brep( const geode::BRep& brep )
 {
     const auto verbose = absl::GetFlag( FLAGS_verbose );
     const geode::BRepInspector brep_inspector{ brep, verbose };
+    auto result = brep_inspector.inspect_brep();
     absl::InlinedVector< async::task< void >, 27 > tasks;
     if( absl::GetFlag( FLAGS_component_linking ) )
     {
@@ -105,22 +106,21 @@ void inspect_brep( const geode::BRep& brep )
     }
     if( absl::GetFlag( FLAGS_corners ) )
     {
-        tasks.emplace_back( async::spawn( [&brep_inspector] {
+        tasks.emplace_back( async::spawn( [&result] {
             const auto nb =
-                brep_inspector.multiple_corners_unique_vertices().size();
+                result.corners.multiple_corners_unique_vertices.size();
             geode::Logger::info(
                 nb, " unique vertices associated to multiple corners." );
         } ) );
-        tasks.emplace_back( async::spawn( [&brep_inspector] {
+        tasks.emplace_back( async::spawn( [&result] {
             const auto nb =
-                brep_inspector.multiple_internals_corner_vertices().size();
+                result.corners.multiple_internals_corner_vertices.size();
             geode::Logger::info( nb, " unique vertices associated to a corner "
                                      "with multiple internals." );
         } ) );
-        tasks.emplace_back( async::spawn( [&brep_inspector] {
+        tasks.emplace_back( async::spawn( [&result] {
             const auto nb =
-                brep_inspector.not_internal_nor_boundary_corner_vertices()
-                    .size();
+                result.corners.not_internal_nor_boundary_corner_vertices.size();
             geode::Logger::info( nb,
                 " unique vertices associated to a corner which is neither "
                 "internal nor boundary." );

src/bin/geode-inspector-structural-model.cpp

@@ -83,6 +83,7 @@ void inspect_model( const geode::StructuralModel& model )
 {
     const auto verbose = absl::GetFlag( FLAGS_verbose );
     const geode::BRepInspector model_inspector{ model, verbose };
+    auto result = model_inspector.inspect_brep();
     absl::InlinedVector< async::task< void >, 27 > tasks;
     if( absl::GetFlag( FLAGS_component_linking ) )
     {
@@ -120,22 +121,21 @@ void inspect_model( const geode::StructuralModel& model )
     }
     if( absl::GetFlag( FLAGS_corners ) )
     {
-        tasks.emplace_back( async::spawn( [&model_inspector] {
+        tasks.emplace_back( async::spawn( [&result] {
             const auto nb =
-                model_inspector.multiple_corners_unique_vertices().size();
+                result.corners.multiple_corners_unique_vertices.size();
             geode::Logger::info(
                 nb, " unique vertices associated to multiple corners." );
         } ) );
-        tasks.emplace_back( async::spawn( [&model_inspector] {
+        tasks.emplace_back( async::spawn( [&result] {
             const auto nb =
-                model_inspector.multiple_internals_corner_vertices().size();
+                result.corners.multiple_internals_corner_vertices.size();
             geode::Logger::info( nb, " unique vertices associated to a corner "
                                      "with multiple internals." );
         } ) );
-        tasks.emplace_back( async::spawn( [&model_inspector] {
+        tasks.emplace_back( async::spawn( [&result] {
             const auto nb =
-                model_inspector.not_internal_nor_boundary_corner_vertices()
-                    .size();
+                result.corners.not_internal_nor_boundary_corner_vertices.size();
             geode::Logger::info( nb,
                 " unique vertices associated to a corner which is neither "
                 "internal nor boundary." );

src/geode/inspector/topology/brep_corners_topology.cpp

@@ -170,4 +170,38 @@ namespace geode
         }
         return false;
     }
+
+    CornerInspectionResult BRepCornersTopology::inspect_corners() const
+    {
+        CornerInspectionResult result;
+        for( const auto& corner : brep_.corners() )
+        {
+            geode::ComponentMeshVertex mesh_vertex{ corner.component_id(), 0 };
+            if( brep_.unique_vertex( mesh_vertex ) == geode::NO_ID )
+            {
+                result.corners_not_linked_to_unique_vertex.push_back(
+                    mesh_vertex );
+            }
+        }
+        for( const auto unique_vertex_id : Range{ brep_.nb_unique_vertices() } )
+        {
+            if( unique_vertex_has_multiple_corners( unique_vertex_id ) )
+            {
+                result.multiple_corners_unique_vertices.push_back(
+                    unique_vertex_id );
+            }
+            if( corner_has_multiple_embeddings( unique_vertex_id ) )
+            {
+                result.multiple_internals_corner_vertices.push_back(
+                    unique_vertex_id );
+            }
+            if( corner_is_not_internal_nor_boundary( unique_vertex_id ) )
+            {
+                result.not_internal_nor_boundary_corner_vertices.push_back(
+                    unique_vertex_id );
+            }
+        }
+        return result;
+    }
+
 } // namespace geode

src/geode/inspector/topology/brep_topology.cpp

@@ -298,6 +298,12 @@ namespace geode
     {
         return impl_->brep_unique_vertices_are_linked_to_a_component_vertex();
     }
+    BRepInspectionResult BRepTopologyInspector::inspect_brep() const
+    {
+        BRepInspectionResult result;
+        result.corners = inspect_corners();
+        return result;
+    }
 
     std::vector< ComponentMeshVertex > BRepTopologyInspector::
         component_vertices_not_linked_to_a_unique_vertex() const
@@ -329,48 +335,6 @@ namespace geode
         return invalid_unique_vertices;
     }
 
-    std::vector< index_t >
-        BRepTopologyInspector::multiple_corners_unique_vertices() const
-    {
-        std::vector< index_t > invalid_unique_vertices;
-        for( const auto unique_vertex_id : Range{ brep_.nb_unique_vertices() } )
-        {
-            if( unique_vertex_has_multiple_corners( unique_vertex_id ) )
-            {
-                invalid_unique_vertices.push_back( unique_vertex_id );
-            }
-        }
-        return invalid_unique_vertices;
-    }
-
-    std::vector< index_t >
-        BRepTopologyInspector::multiple_internals_corner_vertices() const
-    {
-        std::vector< index_t > invalid_unique_vertices;
-        for( const auto unique_vertex_id : Range{ brep_.nb_unique_vertices() } )
-        {
-            if( corner_has_multiple_embeddings( unique_vertex_id ) )
-            {
-                invalid_unique_vertices.push_back( unique_vertex_id );
-            }
-        }
-        return invalid_unique_vertices;
-    }
-
-    std::vector< index_t >
-        BRepTopologyInspector::not_internal_nor_boundary_corner_vertices() const
-    {
-        std::vector< index_t > invalid_unique_vertices;
-        for( const auto unique_vertex_id : Range{ brep_.nb_unique_vertices() } )
-        {
-            if( corner_is_not_internal_nor_boundary( unique_vertex_id ) )
-            {
-                invalid_unique_vertices.push_back( unique_vertex_id );
-            }
-        }
-        return invalid_unique_vertices;
-    }
-
     std::vector< index_t >
         BRepTopologyInspector::line_corners_without_boundary_status() const
     {

tests/inspector/test-brep.cpp

@@ -101,44 +101,6 @@ geode::index_t check_invalid_components_topology_unique_vertices(
     return nb_issues;
 }
 
-geode::index_t check_multiple_corners_unique_vertices(
-    geode::BRepInspector& brep_inspector )
-{
-    geode::index_t nb_issues{ 0 };
-    const auto multiple_corners_unique_vertices =
-        brep_inspector.multiple_corners_unique_vertices();
-    geode::Logger::info( "There are ", multiple_corners_unique_vertices.size(),
-        " vertices with multiple corners." );
-    nb_issues += multiple_corners_unique_vertices.size();
-    return nb_issues;
-}
-
-geode::index_t check_multiple_internals_corner_vertices(
-    geode::BRepInspector& brep_inspector )
-{
-    geode::index_t nb_issues{ 0 };
-    const auto multiple_internals_corner_vertices =
-        brep_inspector.multiple_internals_corner_vertices();
-    geode::Logger::info( "There are ",
-        multiple_internals_corner_vertices.size(),
-        " vertices with multiple internals." );
-    nb_issues += multiple_internals_corner_vertices.size();
-    return nb_issues;
-}
-
-geode::index_t check_not_internal_nor_boundary_corner_vertices(
-    geode::BRepInspector& brep_inspector )
-{
-    geode::index_t nb_issues{ 0 };
-    const auto not_internal_nor_boundary_corner_vertices =
-        brep_inspector.not_internal_nor_boundary_corner_vertices();
-    geode::Logger::info( "There are ",
-        not_internal_nor_boundary_corner_vertices.size(),
-        " corner vertices with no boundary nor internal property." );
-    nb_issues += not_internal_nor_boundary_corner_vertices.size();
-    return nb_issues;
-}
-
 geode::index_t check_line_corners_without_boundary_status(
     geode::BRepInspector& brep_inspector )
 {
@@ -295,10 +257,21 @@ geode::index_t launch_topological_validity_checks(
     geode::BRepInspector& brep_inspector )
 {
     geode::index_t nb_issues{ 0 };
-    nb_issues += check_multiple_corners_unique_vertices( brep_inspector );
-    nb_issues += check_multiple_internals_corner_vertices( brep_inspector );
+    auto result = brep_inspector.inspect_brep();
+
+    nb_issues += result.corners.multiple_corners_unique_vertices.size();
+    geode::Logger::info( "There are ",
+        result.corners.multiple_corners_unique_vertices.size(),
+        " vertices with multiple corners." );
+    nb_issues += result.corners.multiple_internals_corner_vertices.size();
+    geode::Logger::info( "There are ",
+        result.corners.multiple_internals_corner_vertices.size(),
+        " vertices with multiple internals." );
     nb_issues +=
-        check_not_internal_nor_boundary_corner_vertices( brep_inspector );
+        result.corners.not_internal_nor_boundary_corner_vertices.size();
+    geode::Logger::info( "There are ",
+        result.corners.multiple_internals_corner_vertices.size(),
+        " corner vertices with no boundary nor internal property." );
     nb_issues += check_line_corners_without_boundary_status( brep_inspector );
     nb_issues += check_part_of_not_boundary_nor_internal_line_unique_vertices(
         brep_inspector );