Merge pull request #157 from Geode-solutions/fix/externalize_functions_to_compute_expected_nb_cmvs

BotellaA · web-flow · commit d724d46df2b0 · 2025-10-17T15:26:21.000+02:00
fix(BlocksTopology): Externalized function to compute the expected nu…
diff --git a/include/geode/inspector/topology/internal/expected_nb_cmvs.hpp b/include/geode/inspector/topology/internal/expected_nb_cmvs.hpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2019 - 2025 Geode-solutions
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#pragma once
+
+#include <optional>
+
+#include <geode/model/mixin/core/vertex_identifier.hpp>
+
+#include <geode/inspector/common.hpp>
+
+namespace geode
+{
+    class BRep;
+} // namespace geode
+
+namespace geode
+{
+    namespace internal
+    {
+        struct VertexCMVsByComponent
+        {
+            std::vector< ComponentMeshVertex > block_cmvs;
+            std::vector< ComponentMeshVertex > surface_cmvs;
+            std::vector< ComponentMeshVertex > line_cmvs;
+            std::vector< ComponentMeshVertex > corner_cmvs;
+        };
+
+        VertexCMVsByComponent vertex_cmvs_by_component(
+            const BRep& brep, index_t unique_vertex_id );
+
+        index_t nb_expected_block_cmvs( const BRep& brep,
+            index_t unique_vertex_id,
+            const geode::uuid& block_uuid,
+            const VertexCMVsByComponent& unique_vertex_cmvs );
+
+        std::optional< std::string > wrong_nb_expected_block_cmvs(
+            const BRep& brep,
+            index_t unique_vertex_id,
+            const geode::uuid& block_uuid,
+            const VertexCMVsByComponent& unique_vertex_cmvs );
+    } // namespace internal
+} // namespace geode
diff --git a/src/geode/inspector/CMakeLists.txt b/src/geode/inspector/CMakeLists.txt
@@ -68,6 +68,7 @@ add_geode_library(
         "topology/section_corners_topology.cpp"
         "topology/section_lines_topology.cpp"
         "topology/section_surfaces_topology.cpp"
+        "topology/internal/expected_nb_cmvs.cpp"
         "topology/internal/topology_helpers.cpp"
         "section_inspector.cpp"
         "brep_inspector.cpp"
@@ -131,6 +132,7 @@ add_geode_library(
         "topology/section_corners_topology.hpp"
         "topology/section_lines_topology.hpp"
         "topology/section_surfaces_topology.hpp"
+        "topology/internal/expected_nb_cmvs.hpp"
         "topology/internal/topology_helpers.hpp"
     PUBLIC_DEPENDENCIES
         OpenGeode::basic
diff --git a/src/geode/inspector/topology/brep_blocks_topology.cpp b/src/geode/inspector/topology/brep_blocks_topology.cpp
@@ -50,6 +50,7 @@
 #include <geode/model/mixin/core/surface.hpp>
 #include <geode/model/representation/core/brep.hpp>
 
+#include <geode/inspector/topology/internal/expected_nb_cmvs.hpp>
 #include <geode/inspector/topology/internal/topology_helpers.hpp>
 
 namespace
@@ -128,22 +129,6 @@ namespace
         return false;
     }
 
-    template < typename Condition >
-    geode::index_t count_cmvs(
-        absl::Span< const geode::ComponentMeshVertex > cmvs,
-        const Condition& condition )
-    {
-        geode::index_t counter{ 0 };
-        for( const auto& cmv : cmvs )
-        {
-            if( condition( cmv ) )
-            {
-                counter++;
-            }
-        }
-        return counter;
-    }
-
     void create_graph( const geode::BRep& brep,
         geode::GenericMapping< geode::uuid, geode::index_t >&
             surface_uuids_to_graph_edges,
@@ -566,8 +551,7 @@ namespace geode
         }
         return absl::StrCat( "Unique vertex with index ", unique_vertex_index,
             " is part of two blocks, but not of a surface boundary to the "
-            "two "
-            "blocks, nor of a line boundary to one of the blocks incident "
+            "two blocks, nor of a line boundary to one of the blocks incident "
             "surfaces." );
     }
 
@@ -577,159 +561,14 @@ namespace geode
     {
         const auto block_uuids = internal::components_uuids(
             brep_, unique_vertex_index, Block3D::component_type_static() );
-
-        std::vector< ComponentMeshVertex > block_cmvs;
-        std::vector< ComponentMeshVertex > surface_cmvs;
-        std::vector< ComponentMeshVertex > line_cmvs;
-        std::vector< ComponentMeshVertex > corner_cmvs;
-        for( const auto& cmv :
-            brep_.component_mesh_vertices( unique_vertex_index ) )
-        {
-            if( cmv.component_id.type() == Block3D::component_type_static() )
-            {
-                block_cmvs.push_back( cmv );
-            }
-            if( cmv.component_id.type() == Surface3D::component_type_static() )
-            {
-                surface_cmvs.push_back( cmv );
-            }
-            if( cmv.component_id.type() == Line3D::component_type_static() )
-            {
-                line_cmvs.push_back( cmv );
-            }
-            if( cmv.component_id.type() == Corner3D::component_type_static() )
-            {
-                corner_cmvs.push_back( cmv );
-            }
-        }
+        const auto component_cmvs =
+            internal::vertex_cmvs_by_component( brep_, unique_vertex_index );
         for( const auto& block_uuid : block_uuids )
         {
-            const auto nb_block_cmvs =
-                count_cmvs( block_cmvs, [&block_uuid]( const auto& cmv ) {
-                    return cmv.component_id.id() == block_uuid;
-                } );
-
-            const auto nb_internal_surface_cmvs = count_cmvs(
-                surface_cmvs, [&block_uuid, this]( const auto& cmv ) {
-                    return this->brep_.is_internal(
-                        brep_.surface( cmv.component_id.id() ),
-                        brep_.block( block_uuid ) );
-                } );
-
-            const auto nb_boundary_surface_cmvs = count_cmvs(
-                surface_cmvs, [&block_uuid, this]( const auto& cmv ) {
-                    return this->brep_.is_boundary(
-                        brep_.surface( cmv.component_id.id() ),
-                        brep_.block( block_uuid ) );
-                } );
-            const auto nb_boundary_line_cmvs =
-                count_cmvs( line_cmvs, [&block_uuid, this]( const auto& cmv ) {
-                    for( const auto& block_boundary :
-                        this->brep_.boundaries( brep_.block( block_uuid ) ) )
-                    {
-                        for( const auto& surface_boundary :
-                            this->brep_.boundaries( block_boundary ) )
-                        {
-                            if( surface_boundary.id() == cmv.component_id.id() )
-                            {
-                                return true;
-                            }
-                        }
-                        for( const auto& surface_internal :
-                            this->brep_.internal_lines( block_boundary ) )
-                        {
-                            if( surface_internal.id() == cmv.component_id.id() )
-                            {
-                                return true;
-                            }
-                        }
-                    }
-                    return false;
-                } );
-            const auto nb_free_line_cmvs =
-                count_cmvs( line_cmvs, [this]( const auto& cmv ) {
-                    return this->brep_.nb_incidences( cmv.component_id.id() )
-                               == 1
-                           && this->brep_.nb_embedding_surfaces(
-                                  brep_.line( cmv.component_id.id() ) )
-                                  == 0;
-                } );
-            if( corner_cmvs.size() == 1 && nb_internal_surface_cmvs == 0 )
-            {
-                if( nb_boundary_line_cmvs == 1 )
-                {
-                    if( nb_block_cmvs != 1 )
-                    {
-                        return absl::StrCat( "Unique vertex with index ",
-                            unique_vertex_index, " is part of block ",
-                            block_uuid.string(),
-                            " and exactly one corner and one line but "
-                            "has ",
-                            nb_block_cmvs,
-                            " block component mesh vertices (should be "
-                            "1)." );
-                    }
-                    continue;
-                }
-
-                const auto predicted_nb_block_cmvs = nb_boundary_surface_cmvs
-                                                     + corner_cmvs.size()
-                                                     - nb_boundary_line_cmvs;
-                if( nb_block_cmvs != predicted_nb_block_cmvs )
-                {
-                    return absl::StrCat( "Unique vertex with index ",
-                        unique_vertex_index, " is part of the block ",
-                        block_uuid.string(),
-                        ", and of a corner, and of no internal line, ",
-                        "and of ", nb_boundary_surface_cmvs,
-                        " boundary surface(s), and of ", nb_boundary_line_cmvs,
-                        " line(s) on block boundaries, with ", nb_block_cmvs,
-                        " block component mesh vertices (should be ",
-                        predicted_nb_block_cmvs, ")." );
-                }
-                continue;
-            }
-
-            if( nb_internal_surface_cmvs == 0 )
+            if( auto error_message = internal::wrong_nb_expected_block_cmvs(
+                    brep_, unique_vertex_index, block_uuid, component_cmvs ) )
             {
-                const auto predicted_nb_block_cmvs =
-                    nb_boundary_line_cmvs == 0 ? 1
-                                               : nb_boundary_surface_cmvs / 2;
-                if( nb_block_cmvs != predicted_nb_block_cmvs )
-                {
-                    return absl::StrCat( "Unique vertex with index ",
-                        unique_vertex_index, " is part of the block ",
-                        block_uuid.string(),
-                        " and none of its internal surfaces but has ",
-                        nb_block_cmvs,
-                        " block component mesh vertices (should be ",
-                        predicted_nb_block_cmvs, ")." );
-                }
-                continue;
-            }
-            auto predicted_nb_block_cmvs =
-                nb_internal_surface_cmvs < nb_free_line_cmvs + 1
-                    ? static_cast< index_t >( 1 )
-                    : nb_internal_surface_cmvs - nb_free_line_cmvs;
-            if( nb_internal_surface_cmvs - nb_free_line_cmvs == 1 )
-            {
-                predicted_nb_block_cmvs++;
-            }
-            if( nb_boundary_surface_cmvs > 1 && corner_cmvs.empty() )
-            {
-                predicted_nb_block_cmvs += ( nb_boundary_surface_cmvs - 2 ) / 2;
-            }
-            if( nb_block_cmvs != predicted_nb_block_cmvs )
-            {
-                return absl::StrCat( "Unique vertex with index ",
-                    unique_vertex_index, " is part of the block ",
-                    block_uuid.string(), ", has ", nb_internal_surface_cmvs,
-                    " internal surface(s) component mesh vertices (CMVs), "
-                    "has ",
-                    nb_boundary_surface_cmvs,
-                    " boundary surface(s) CMVs, and has ", nb_free_line_cmvs,
-                    " free line(s) CMVs, with ", nb_block_cmvs,
-                    " block CMVs (should be ", predicted_nb_block_cmvs, ")." );
+                return error_message;
             }
         }
         return std::nullopt;
diff --git a/src/geode/inspector/topology/internal/expected_nb_cmvs.cpp b/src/geode/inspector/topology/internal/expected_nb_cmvs.cpp
