fix(BRepTopology): Fixed the inspection of the topology of a BRep in several specific cases

MelchiorSchuh · MelchiorSchuh · commit 2cfbe3749576 · 2022-04-01T10:07:16.000+02:00
diff --git a/bindings/python/src/inspector/topology/brep_topology.h b/bindings/python/src/inspector/topology/brep_topology.h
@@ -31,18 +31,20 @@
         .def( pybind11::init< const BRep& >() )                                  \
         .def( "brep_topology_is_valid",                                          \
             &BRepTopologyInspector::brep_topology_is_valid )                     \
-        .def( "brep_components_are_linked_to_a_unique_vertex",                   \
+        .def( "brep_meshed_components_are_linked_to_a_unique_vertex",            \
             &BRepTopologyInspector::                                             \
-                brep_components_are_linked_to_a_unique_vertex )                  \
+                brep_meshed_components_are_linked_to_a_unique_vertex )           \
         .def( "nb_corners_not_linked_to_a_unique_vertex",                        \
             &BRepTopologyInspector::nb_corners_not_linked_to_a_unique_vertex )   \
-        .def( "nb_lines_not_linked_to_a_unique_vertex",                          \
-            &BRepTopologyInspector::nb_lines_not_linked_to_a_unique_vertex )     \
-        .def( "nb_surfaces_not_linked_to_a_unique_vertex",                       \
+        .def( "nb_lines_meshed_but_not_linked_to_a_unique_vertex",               \
             &BRepTopologyInspector::                                             \
-                nb_surfaces_not_linked_to_a_unique_vertex )                      \
-        .def( "nb_blocks_not_linked_to_a_unique_vertex",                         \
-            &BRepTopologyInspector::nb_blocks_not_linked_to_a_unique_vertex )    \
+                nb_lines_meshed_but_not_linked_to_a_unique_vertex )              \
+        .def( "nb_surfaces_meshed_but_not_linked_to_a_unique_vertex",            \
+            &BRepTopologyInspector::                                             \
+                nb_surfaces_meshed_but_not_linked_to_a_unique_vertex )           \
+        .def( "nb_blocks_meshed_but_not_linked_to_a_unique_vertex",              \
+            &BRepTopologyInspector::                                             \
+                nb_blocks_meshed_but_not_linked_to_a_unique_vertex )             \
         .def( "invalid_components_topology_unique_vertices",                     \
             &BRepTopologyInspector::                                             \
                 invalid_components_topology_unique_vertices )                    \
diff --git a/bindings/python/tests/test-py-brep-topology.py b/bindings/python/tests/test-py-brep-topology.py
@@ -30,12 +30,12 @@
 def check_components_linking( brep_inspector ):
     nb_unlinked_corners = brep_inspector.nb_corners_not_linked_to_a_unique_vertex()
     print( "There are ", nb_unlinked_corners, " corners not linked to a unique vertex." )
-    nb_unlinked_lines = brep_inspector.nb_lines_not_linked_to_a_unique_vertex()
-    print( "There are ", nb_unlinked_lines, " lines not linked to a unique vertex." )
-    nb_unlinked_surfaces = brep_inspector.nb_surfaces_not_linked_to_a_unique_vertex()
-    print( "There are ", nb_unlinked_surfaces, " surfaces not linked to a unique vertex." )
-    nb_unlinked_blocks = brep_inspector.nb_blocks_not_linked_to_a_unique_vertex()
-    print( "There are ", nb_unlinked_blocks, " blocks not linked to a unique vertex." )
+    nb_unlinked_lines = brep_inspector.nb_lines_meshed_but_not_linked_to_a_unique_vertex()
+    print( "There are ", nb_unlinked_lines, " lines meshed but not linked to a unique vertex." )
+    nb_unlinked_surfaces = brep_inspector.nb_surfaces_meshed_but_not_linked_to_a_unique_vertex()
+    print( "There are ", nb_unlinked_surfaces, " surfaces meshed but not linked to a unique vertex." )
+    nb_unlinked_blocks = brep_inspector.nb_blocks_meshed_but_not_linked_to_a_unique_vertex()
+    print( "There are ", nb_unlinked_blocks, " blocks meshed but not linked to a unique vertex." )
 
 def check_invalid_components_topology_unique_vertices( brep_inspector ):
     invalid_components_unique_vertices = brep_inspector.invalid_components_topology_unique_vertices()
diff --git a/include/geode/inspector/topology/brep_topology.h b/include/geode/inspector/topology/brep_topology.h
@@ -51,15 +51,15 @@ namespace geode
          */
         bool brep_topology_is_valid() const;
 
-        bool brep_components_are_linked_to_a_unique_vertex() const;
+        bool brep_meshed_components_are_linked_to_a_unique_vertex() const;
 
         index_t nb_corners_not_linked_to_a_unique_vertex() const;
 
-        index_t nb_lines_not_linked_to_a_unique_vertex() const;
+        index_t nb_lines_meshed_but_not_linked_to_a_unique_vertex() const;
 
-        index_t nb_surfaces_not_linked_to_a_unique_vertex() const;
+        index_t nb_surfaces_meshed_but_not_linked_to_a_unique_vertex() const;
 
-        index_t nb_blocks_not_linked_to_a_unique_vertex() const;
+        index_t nb_blocks_meshed_but_not_linked_to_a_unique_vertex() const;
 
         std::vector< index_t >
             invalid_components_topology_unique_vertices() const;
diff --git a/src/bin/geode-inspector-brep-topology.cpp b/src/bin/geode-inspector-brep-topology.cpp
@@ -55,21 +55,24 @@ void inspect_brep( const geode::BRep& brep )
         } ) );
         tasks.emplace_back( async::spawn( [&brep_inspector] {
             const auto nb_lines =
-                brep_inspector.nb_lines_not_linked_to_a_unique_vertex();
+                brep_inspector
+                    .nb_lines_meshed_but_not_linked_to_a_unique_vertex();
             geode::Logger::info(
-                nb_lines, " corners not linked to a unique vertex" );
+                nb_lines, " lines meshed but not linked to a unique vertex" );
         } ) );
         tasks.emplace_back( async::spawn( [&brep_inspector] {
             const auto nb_surfaces =
-                brep_inspector.nb_surfaces_not_linked_to_a_unique_vertex();
-            geode::Logger::info(
-                nb_surfaces, " surfaces not linked to a unique vertex" );
+                brep_inspector
+                    .nb_surfaces_meshed_but_not_linked_to_a_unique_vertex();
+            geode::Logger::info( nb_surfaces,
+                " surfaces meshed but not linked to a unique vertex" );
         } ) );
         tasks.emplace_back( async::spawn( [&brep_inspector] {
             const auto nb_blocks =
-                brep_inspector.nb_blocks_not_linked_to_a_unique_vertex();
+                brep_inspector
+                    .nb_blocks_meshed_but_not_linked_to_a_unique_vertex();
             geode::Logger::info(
-                nb_blocks, " blocks not linked to a unique vertex" );
+                nb_blocks, " blocks meshed but not linked to a unique vertex" );
         } ) );
     }
     if( absl::GetFlag( FLAGS_corners ) )
diff --git a/src/geode/inspector/topology/brep_topology.cpp b/src/geode/inspector/topology/brep_topology.cpp
@@ -25,6 +25,10 @@
 
 #include <geode/basic/pimpl_impl.h>
 
+#include <geode/mesh/core/edged_curve.h>
+#include <geode/mesh/core/solid_mesh.h>
+#include <geode/mesh/core/surface_mesh.h>
+
 #include <geode/model/mixin/core/block.h>
 #include <geode/model/mixin/core/corner.h>
 #include <geode/model/mixin/core/line.h>
@@ -38,7 +42,25 @@
 
 namespace
 {
-    bool brep_has_unique_vertex_associated_to_component_id(
+    bool brep_line_is_meshed(
+        const geode::BRep& brep, const geode::uuid& line_id )
+    {
+        return brep.line( line_id ).mesh().nb_vertices() != 0;
+    }
+
+    bool brep_surface_is_meshed(
+        const geode::BRep& brep, const geode::uuid& surface_id )
+    {
+        return brep.surface( surface_id ).mesh().nb_vertices() != 0;
+    }
+
+    bool brep_block_is_meshed(
+        const geode::BRep& brep, const geode::uuid& block_id )
+    {
+        return brep.block( block_id ).mesh().nb_vertices() != 0;
+    }
+
+    bool brep_has_unique_vertex_associated_to_component(
         const geode::BRep& brep, const geode::uuid& component_id )
     {
         for( const auto unique_vertex_id :
@@ -77,7 +99,7 @@ namespace geode
             {
                 return false;
             }
-            if( !brep_components_are_linked_to_a_unique_vertex() )
+            if( !brep_meshed_components_are_linked_to_a_unique_vertex() )
             {
                 return false;
             }
@@ -97,27 +119,38 @@ namespace geode
             return true;
         }
 
-        bool brep_components_are_linked_to_a_unique_vertex() const
+        bool brep_meshed_components_are_linked_to_a_unique_vertex() const
         {
             for( const auto& corner : brep_.corners() )
             {
-                if( !brep_has_unique_vertex_associated_to_component_id(
+                if( !brep_has_unique_vertex_associated_to_component(
                         brep_, corner.id() ) )
                 {
                     return false;
                 }
             }
+            for( const auto& line : brep_.lines() )
+            {
+                if( brep_line_is_meshed( brep_, line.id() )
+                    && !brep_has_unique_vertex_associated_to_component(
+                        brep_, line.id() ) )
+                {
+                    return false;
+                }
+            }
             for( const auto& surface : brep_.surfaces() )
             {
-                if( !brep_has_unique_vertex_associated_to_component_id(
+                if( brep_surface_is_meshed( brep_, surface.id() )
+                    && !brep_has_unique_vertex_associated_to_component(
                         brep_, surface.id() ) )
                 {
                     return false;
                 }
             }
             for( const auto& block : brep_.blocks() )
             {
-                if( !brep_has_unique_vertex_associated_to_component_id(
+                if( brep_block_is_meshed( brep_, block.id() )
+                    && !brep_has_unique_vertex_associated_to_component(
                         brep_, block.id() ) )
                 {
                     return false;
@@ -131,7 +164,7 @@ namespace geode
             index_t counter{ 0 };
             for( const auto& corner : brep_.corners() )
             {
-                if( !brep_has_unique_vertex_associated_to_component_id(
+                if( !brep_has_unique_vertex_associated_to_component(
                         brep_, corner.id() ) )
                 {
                     counter++;
@@ -140,12 +173,13 @@ namespace geode
             return counter;
         }
 
-        index_t nb_lines_not_linked_to_a_unique_vertex() const
+        index_t nb_lines_meshed_but_not_linked_to_a_unique_vertex() const
         {
             index_t counter{ 0 };
             for( const auto& line : brep_.lines() )
             {
-                if( !brep_has_unique_vertex_associated_to_component_id(
+                if( brep_line_is_meshed( brep_, line.id() )
+                    && !brep_has_unique_vertex_associated_to_component(
                         brep_, line.id() ) )
                 {
                     counter++;
@@ -154,12 +188,13 @@ namespace geode
             return counter;
         }
 
-        index_t nb_surfaces_not_linked_to_a_unique_vertex() const
+        index_t nb_surfaces_meshed_but_not_linked_to_a_unique_vertex() const
         {
             index_t counter{ 0 };
             for( const auto& surface : brep_.surfaces() )
             {
-                if( !brep_has_unique_vertex_associated_to_component_id(
+                if( brep_surface_is_meshed( brep_, surface.id() )
+                    && !brep_has_unique_vertex_associated_to_component(
                         brep_, surface.id() ) )
                 {
                     counter++;
@@ -168,12 +203,13 @@ namespace geode
             return counter;
         }
 
-        index_t nb_blocks_not_linked_to_a_unique_vertex() const
+        index_t nb_blocks_meshed_but_not_linked_to_a_unique_vertex() const
         {
             index_t counter{ 0 };
             for( const auto& block : brep_.blocks() )
             {
-                if( !brep_has_unique_vertex_associated_to_component_id(
+                if( brep_block_is_meshed( brep_, block.id() )
+                    && !brep_has_unique_vertex_associated_to_component(
                         brep_, block.id() ) )
                 {
                     counter++;
@@ -416,10 +452,10 @@ namespace geode
         return impl_->brep_topology_is_valid();
     }
 
-    bool BRepTopologyInspector::brep_components_are_linked_to_a_unique_vertex()
-        const
+    bool BRepTopologyInspector::
+        brep_meshed_components_are_linked_to_a_unique_vertex() const
     {
-        return impl_->brep_components_are_linked_to_a_unique_vertex();
+        return impl_->brep_meshed_components_are_linked_to_a_unique_vertex();
     }
 
     index_t
@@ -428,22 +464,22 @@ namespace geode
         return impl_->nb_corners_not_linked_to_a_unique_vertex();
     }
 
-    index_t
-        BRepTopologyInspector::nb_lines_not_linked_to_a_unique_vertex() const
+    index_t BRepTopologyInspector::
+        nb_lines_meshed_but_not_linked_to_a_unique_vertex() const
     {
-        return impl_->nb_lines_not_linked_to_a_unique_vertex();
+        return impl_->nb_lines_meshed_but_not_linked_to_a_unique_vertex();
     }
 
-    index_t
-        BRepTopologyInspector::nb_surfaces_not_linked_to_a_unique_vertex() const
+    index_t BRepTopologyInspector::
+        nb_surfaces_meshed_but_not_linked_to_a_unique_vertex() const
     {
-        return impl_->nb_surfaces_not_linked_to_a_unique_vertex();
+        return impl_->nb_surfaces_meshed_but_not_linked_to_a_unique_vertex();
     }
 
-    index_t
-        BRepTopologyInspector::nb_blocks_not_linked_to_a_unique_vertex() const
+    index_t BRepTopologyInspector::
+        nb_blocks_meshed_but_not_linked_to_a_unique_vertex() const
     {
-        return impl_->nb_blocks_not_linked_to_a_unique_vertex();
+        return impl_->nb_blocks_meshed_but_not_linked_to_a_unique_vertex();
     }
 
     std::vector< index_t >
diff --git a/src/geode/inspector/topology/private/brep_lines_topology_impl.cpp b/src/geode/inspector/topology/private/brep_lines_topology_impl.cpp
@@ -83,14 +83,16 @@ namespace geode
             for( const auto line : brep_.mesh_component_vertices(
                      unique_vertex_index, Line3D::component_type_static() ) )
             {
-                if( brep_.nb_embeddings( line.component_id.id() ) < 1 )
-                {
-                    return false;
-                }
-                else if( brep_.nb_embeddings( line.component_id.id() ) > 1
-                         || brep_.nb_incidences( line.component_id.id() ) > 0 )
+                const auto embeddings =
+                    brep_.embeddings( line.component_id.id() );
+
+                for( const auto embedding : embeddings )
                 {
-                    return true;
+                    if( brep_.Relationships::is_boundary(
+                            line.component_id.id(), embedding.id() ) )
+                    {
+                        return true;
+                    }
                 }
             }
             return false;
@@ -113,7 +115,12 @@ namespace geode
             {
                 if( !brep_.Relationships::is_internal(
                         lines[0].component_id.id(),
-                        surfaces[0].component_id.id() ) )
+                        surfaces[0].component_id.id() )
+                    && !( brep_.Relationships::nb_embeddings(
+                              surfaces[0].component_id.id() )
+                          && brep_.Relationships::is_boundary(
+                              lines[0].component_id.id(),
+                              surfaces[0].component_id.id() ) ) )
                 {
                     return true;
                 }
@@ -133,6 +140,9 @@ namespace geode
                 for( const auto& surface : surfaces )
                 {
                     if( !brep_.Relationships::is_boundary(
+                            lines[0].component_id.id(),
+                            surface.component_id.id() )
+                        && !brep_.Relationships::is_internal(
                             lines[0].component_id.id(),
                             surface.component_id.id() ) )
                     {
diff --git a/src/geode/inspector/topology/private/brep_surfaces_topology_impl.cpp b/src/geode/inspector/topology/private/brep_surfaces_topology_impl.cpp
diff --git a/tests/inspector/test-brep-topology.cpp b/tests/inspector/test-brep-topology.cpp

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,10 @@`
`25`	`25`
`26`	`26`	`#include <geode/basic/pimpl_impl.h>`
`27`	`27`
	`28`	`+#include <geode/mesh/core/edged_curve.h>`
	`29`	`+#include <geode/mesh/core/solid_mesh.h>`
	`30`	`+#include <geode/mesh/core/surface_mesh.h>`
	`31`	`+`
`28`	`32`	`#include <geode/model/mixin/core/block.h>`
`29`	`33`	`#include <geode/model/mixin/core/corner.h>`
`30`	`34`	`#include <geode/model/mixin/core/line.h>`
`@@ -38,7 +42,25 @@`
`38`	`42`
`39`	`43`	`namespace`
`40`	`44`	`{`
`41`		`- bool brep_has_unique_vertex_associated_to_component_id(`
	`45`	`+ bool brep_line_is_meshed(`
	`46`	`+ const geode::BRep& brep, const geode::uuid& line_id )`
	`47`	`+ {`
	`48`	`+ return brep.line( line_id ).mesh().nb_vertices() != 0;`
	`49`	`+ }`
	`50`	`+`
	`51`	`+ bool brep_surface_is_meshed(`
	`52`	`+ const geode::BRep& brep, const geode::uuid& surface_id )`
	`53`	`+ {`
	`54`	`+ return brep.surface( surface_id ).mesh().nb_vertices() != 0;`
	`55`	`+ }`
	`56`	`+`
	`57`	`+ bool brep_block_is_meshed(`
	`58`	`+ const geode::BRep& brep, const geode::uuid& block_id )`
	`59`	`+ {`
	`60`	`+ return brep.block( block_id ).mesh().nb_vertices() != 0;`
	`61`	`+ }`
	`62`	`+`
	`63`	`+ bool brep_has_unique_vertex_associated_to_component(`
`42`	`64`	`const geode::BRep& brep, const geode::uuid& component_id )`
`43`	`65`	`{`
`44`	`66`	`for( const auto unique_vertex_id :`
`@@ -77,7 +99,7 @@ namespace geode`
`77`	`99`	`{`
`78`	`100`	`return false;`
`79`	`101`	`}`
`80`		`- if( !brep_components_are_linked_to_a_unique_vertex() )`
	`102`	`+ if( !brep_meshed_components_are_linked_to_a_unique_vertex() )`
`81`	`103`	`{`
`82`	`104`	`return false;`
`83`	`105`	`}`
`@@ -97,27 +119,38 @@ namespace geode`
`97`	`119`	`return true;`
`98`	`120`	`}`
`99`	`121`
`100`		`- bool brep_components_are_linked_to_a_unique_vertex() const`
	`122`	`+ bool brep_meshed_components_are_linked_to_a_unique_vertex() const`
`101`	`123`	`{`
`102`	`124`	`for( const auto& corner : brep_.corners() )`
`103`	`125`	`{`
`104`		`- if( !brep_has_unique_vertex_associated_to_component_id(`
	`126`	`+ if( !brep_has_unique_vertex_associated_to_component(`
`105`	`127`	`brep_, corner.id() ) )`
`106`	`128`	`{`
`107`	`129`	`return false;`
`108`	`130`	`}`
`109`	`131`	`}`
	`132`	`+ for( const auto& line : brep_.lines() )`
	`133`	`+ {`
	`134`	`+ if( brep_line_is_meshed( brep_, line.id() )`
	`135`	`+ && !brep_has_unique_vertex_associated_to_component(`
	`136`	`+ brep_, line.id() ) )`
	`137`	`+ {`
	`138`	`+ return false;`
	`139`	`+ }`
	`140`	`+ }`
`110`	`141`	`for( const auto& surface : brep_.surfaces() )`
`111`	`142`	`{`
`112`		`- if( !brep_has_unique_vertex_associated_to_component_id(`
	`143`	`+ if( brep_surface_is_meshed( brep_, surface.id() )`
	`144`	`+ && !brep_has_unique_vertex_associated_to_component(`
`113`	`145`	`brep_, surface.id() ) )`
`114`	`146`	`{`
`115`	`147`	`return false;`
`116`	`148`	`}`
`117`	`149`	`}`
`118`	`150`	`for( const auto& block : brep_.blocks() )`
`119`	`151`	`{`
`120`		`- if( !brep_has_unique_vertex_associated_to_component_id(`
	`152`	`+ if( brep_block_is_meshed( brep_, block.id() )`
	`153`	`+ && !brep_has_unique_vertex_associated_to_component(`
`121`	`154`	`brep_, block.id() ) )`
`122`	`155`	`{`
`123`	`156`	`return false;`
`@@ -131,7 +164,7 @@ namespace geode`
`131`	`164`	`index_t counter{ 0 };`
`132`	`165`	`for( const auto& corner : brep_.corners() )`
`133`	`166`	`{`
`134`		`- if( !brep_has_unique_vertex_associated_to_component_id(`
	`167`	`+ if( !brep_has_unique_vertex_associated_to_component(`
`135`	`168`	`brep_, corner.id() ) )`
`136`	`169`	`{`
`137`	`170`	`counter++;`
`@@ -140,12 +173,13 @@ namespace geode`
`140`	`173`	`return counter;`
`141`	`174`	`}`
`142`	`175`
`143`		`- index_t nb_lines_not_linked_to_a_unique_vertex() const`
	`176`	`+ index_t nb_lines_meshed_but_not_linked_to_a_unique_vertex() const`
`144`	`177`	`{`
`145`	`178`	`index_t counter{ 0 };`
`146`	`179`	`for( const auto& line : brep_.lines() )`
`147`	`180`	`{`
`148`		`- if( !brep_has_unique_vertex_associated_to_component_id(`
	`181`	`+ if( brep_line_is_meshed( brep_, line.id() )`
	`182`	`+ && !brep_has_unique_vertex_associated_to_component(`
`149`	`183`	`brep_, line.id() ) )`
`150`	`184`	`{`
`151`	`185`	`counter++;`
`@@ -154,12 +188,13 @@ namespace geode`
`154`	`188`	`return counter;`
`155`	`189`	`}`
`156`	`190`
`157`		`- index_t nb_surfaces_not_linked_to_a_unique_vertex() const`
	`191`	`+ index_t nb_surfaces_meshed_but_not_linked_to_a_unique_vertex() const`
`158`	`192`	`{`
`159`	`193`	`index_t counter{ 0 };`
`160`	`194`	`for( const auto& surface : brep_.surfaces() )`
`161`	`195`	`{`
`162`		`- if( !brep_has_unique_vertex_associated_to_component_id(`
	`196`	`+ if( brep_surface_is_meshed( brep_, surface.id() )`
	`197`	`+ && !brep_has_unique_vertex_associated_to_component(`
`163`	`198`	`brep_, surface.id() ) )`
`164`	`199`	`{`
`165`	`200`	`counter++;`
`@@ -168,12 +203,13 @@ namespace geode`
`168`	`203`	`return counter;`
`169`	`204`	`}`
`170`	`205`
`171`		`- index_t nb_blocks_not_linked_to_a_unique_vertex() const`
	`206`	`+ index_t nb_blocks_meshed_but_not_linked_to_a_unique_vertex() const`
`172`	`207`	`{`
`173`	`208`	`index_t counter{ 0 };`
`174`	`209`	`for( const auto& block : brep_.blocks() )`
`175`	`210`	`{`
`176`		`- if( !brep_has_unique_vertex_associated_to_component_id(`
	`211`	`+ if( brep_block_is_meshed( brep_, block.id() )`
	`212`	`+ && !brep_has_unique_vertex_associated_to_component(`
`177`	`213`	`brep_, block.id() ) )`
`178`	`214`	`{`
`179`	`215`	`counter++;`
`@@ -416,10 +452,10 @@ namespace geode`
`416`	`452`	`return impl_->brep_topology_is_valid();`
`417`	`453`	`}`
`418`	`454`
`419`		`- bool BRepTopologyInspector::brep_components_are_linked_to_a_unique_vertex()`
`420`		`- const`
	`455`	`+ bool BRepTopologyInspector::`
	`456`	`+ brep_meshed_components_are_linked_to_a_unique_vertex() const`
`421`	`457`	`{`
`422`		`- return impl_->brep_components_are_linked_to_a_unique_vertex();`
	`458`	`+ return impl_->brep_meshed_components_are_linked_to_a_unique_vertex();`
`423`	`459`	`}`
`424`	`460`
`425`	`461`	`index_t`
`@@ -428,22 +464,22 @@ namespace geode`
`428`	`464`	`return impl_->nb_corners_not_linked_to_a_unique_vertex();`
`429`	`465`	`}`
`430`	`466`
`431`		`- index_t`
`432`		`- BRepTopologyInspector::nb_lines_not_linked_to_a_unique_vertex() const`
	`467`	`+ index_t BRepTopologyInspector::`
	`468`	`+ nb_lines_meshed_but_not_linked_to_a_unique_vertex() const`
`433`	`469`	`{`
`434`		`- return impl_->nb_lines_not_linked_to_a_unique_vertex();`
	`470`	`+ return impl_->nb_lines_meshed_but_not_linked_to_a_unique_vertex();`
`435`	`471`	`}`
`436`	`472`
`437`		`- index_t`
`438`		`- BRepTopologyInspector::nb_surfaces_not_linked_to_a_unique_vertex() const`
	`473`	`+ index_t BRepTopologyInspector::`
	`474`	`+ nb_surfaces_meshed_but_not_linked_to_a_unique_vertex() const`
`439`	`475`	`{`
`440`		`- return impl_->nb_surfaces_not_linked_to_a_unique_vertex();`
	`476`	`+ return impl_->nb_surfaces_meshed_but_not_linked_to_a_unique_vertex();`
`441`	`477`	`}`
`442`	`478`
`443`		`- index_t`
`444`		`- BRepTopologyInspector::nb_blocks_not_linked_to_a_unique_vertex() const`
	`479`	`+ index_t BRepTopologyInspector::`
	`480`	`+ nb_blocks_meshed_but_not_linked_to_a_unique_vertex() const`
`445`	`481`	`{`
`446`		`- return impl_->nb_blocks_not_linked_to_a_unique_vertex();`
	`482`	`+ return impl_->nb_blocks_meshed_but_not_linked_to_a_unique_vertex();`
`447`	`483`	`}`
`448`	`484`
`449`	`485`	`std::vector< index_t >`
Original file line number	Diff line number	Diff line change
`@@ -83,14 +83,16 @@ namespace geode`
`83`	`83`	`for( const auto line : brep_.mesh_component_vertices(`
`84`	`84`	`unique_vertex_index, Line3D::component_type_static() ) )`
`85`	`85`	`{`
`86`		`- if( brep_.nb_embeddings( line.component_id.id() ) < 1 )`
`87`		`- {`
`88`		`- return false;`
`89`		`- }`
`90`		`- else if( brep_.nb_embeddings( line.component_id.id() ) > 1`
`91`		`- \|\| brep_.nb_incidences( line.component_id.id() ) > 0 )`
	`86`	`+ const auto embeddings =`
	`87`	`+ brep_.embeddings( line.component_id.id() );`
	`88`	`+`
	`89`	`+ for( const auto embedding : embeddings )`
`92`	`90`	`{`
`93`		`- return true;`
	`91`	`+ if( brep_.Relationships::is_boundary(`
	`92`	`+ line.component_id.id(), embedding.id() ) )`
	`93`	`+ {`
	`94`	`+ return true;`
	`95`	`+ }`
`94`	`96`	`}`
`95`	`97`	`}`
`96`	`98`	`return false;`
`@@ -113,7 +115,12 @@ namespace geode`
`113`	`115`	`{`
`114`	`116`	`if( !brep_.Relationships::is_internal(`
`115`	`117`	`lines[0].component_id.id(),`
`116`		`- surfaces[0].component_id.id() ) )`
	`118`	`+ surfaces[0].component_id.id() )`
	`119`	`+ && !( brep_.Relationships::nb_embeddings(`
	`120`	`+ surfaces[0].component_id.id() )`
	`121`	`+ && brep_.Relationships::is_boundary(`
	`122`	`+ lines[0].component_id.id(),`
	`123`	`+ surfaces[0].component_id.id() ) ) )`
`117`	`124`	`{`
`118`	`125`	`return true;`
`119`	`126`	`}`
`@@ -133,6 +140,9 @@ namespace geode`
`133`	`140`	`for( const auto& surface : surfaces )`
`134`	`141`	`{`
`135`	`142`	`if( !brep_.Relationships::is_boundary(`
	`143`	`+ lines[0].component_id.id(),`
	`144`	`+ surface.component_id.id() )`
	`145`	`+ && !brep_.Relationships::is_internal(`
`136`	`146`	`lines[0].component_id.id(),`
`137`	`147`	`surface.component_id.id() ) )`
`138`	`148`	`{`