Merge pull request #1176 from Geode-solutions/fix/unsegmentation

Fix/unsegmentation

Author: BotellaA

commitlint.config.js

@@ -0,0 +1,16 @@
+export default {
+  extends: ["@commitlint/config-angular"],
+  rules: {
+    "scope-empty": [2, "never"],
+    "subject-empty": [2, "never"],
+    "subject-max-length": [0],
+    "body-leading-blank": [0],
+    "footer-leading-blank": [0],
+    "header-max-length": [0],
+    "scope-case": [0],
+    "subject-case": [0],
+    "subject-full-stop": [0],
+    "type-case": [0],
+    "type-empty": [0],
+  },
+}

include/geode/mesh/core/solid_mesh.hpp

@@ -210,9 +210,15 @@ namespace geode
 
     using PolyhedronFacetVertices = absl::InlinedVector< index_t, 3 >;
 
+    using PolyhedronFacetLocalVertices =
+        absl::InlinedVector< local_index_t, 3 >;
+
     using PolyhedronFacetsVertices =
         absl::InlinedVector< PolyhedronFacetVertices, 4 >;
 
+    using PolyhedronFacetsLocalVertices =
+        absl::InlinedVector< PolyhedronFacetLocalVertices, 4 >;
+
     using PolyhedronVertices = absl::InlinedVector< index_t, 4 >;
 
     using PolyhedronFacets = absl::InlinedVector< PolyhedronFacet, 4 >;
@@ -349,6 +355,9 @@ namespace geode
         [[nodiscard]] virtual PolyhedronFacetsVertices
             polyhedron_facets_vertices( index_t polyhedron ) const;
 
+        [[nodiscard]] virtual PolyhedronFacetsLocalVertices
+            polyhedron_facets_local_vertices( index_t polyhedron ) const;
+
         [[nodiscard]] virtual PolyhedronFacets polyhedron_vertex_facets(
             const PolyhedronVertex& polyhedron_vertex ) const;
 

include/geode/mesh/core/tetrahedral_solid.hpp

@@ -73,6 +73,9 @@ namespace geode
         [[nodiscard]] PolyhedronFacetsVertices polyhedron_facets_vertices(
             index_t polyhedron ) const final;
 
+        [[nodiscard]] PolyhedronFacetsLocalVertices
+            polyhedron_facets_local_vertices( index_t polyhedron ) const final;
+
         [[nodiscard]] typename SolidMesh< dimension >::VerticesAroundVertex
             vertices_around_vertex( index_t vertex_id ) const final;
 

include/geode/model/helpers/component_mesh_polygons.hpp

@@ -213,5 +213,10 @@ namespace geode
             opengeode_model_api
             block_component_mesh_polygons( const BRep& brep,
                 const PolygonVertices& polygon_unique_vertices );
+
+        [[nodiscard]] std::vector< PolyhedronFacet >
+            opengeode_model_api block_component_mesh_polygons( const BRep& brep,
+                const PolygonVertices& polygon_unique_vertices,
+                const Block3D& block );
     } // namespace detail
 } // namespace geode

src/geode/mesh/core/solid_mesh.cpp

@@ -1341,6 +1341,27 @@ namespace geode
         return facets_vertices;
     }
 
+    template < index_t dimension >
+    PolyhedronFacetsLocalVertices
+        SolidMesh< dimension >::polyhedron_facets_local_vertices(
+            index_t polyhedron ) const
+    {
+        PolyhedronFacetsLocalVertices facets_vertices;
+        facets_vertices.reserve( nb_polyhedron_facets( polyhedron ) );
+        for( const auto f : LRange{ nb_polyhedron_facets( polyhedron ) } )
+        {
+            const PolyhedronFacet facet{ polyhedron, f };
+            auto& facet_vertices = facets_vertices.emplace_back();
+            for( const auto v :
+                LRange{ nb_polyhedron_facet_vertices( facet ) } )
+            {
+                facet_vertices.push_back(
+                    polyhedron_facet_vertex_id( { facet, v } ).vertex_id );
+            }
+        }
+        return facets_vertices;
+    }
+
     template < index_t dimension >
     PolyhedronFacets SolidMesh< dimension >::polyhedron_vertex_facets(
         const PolyhedronVertex& polyhedron_vertex ) const

src/geode/mesh/core/tetrahedral_solid.cpp

@@ -449,6 +449,20 @@ namespace geode
         return result;
     }
 
+    template < index_t dimension >
+    PolyhedronFacetsLocalVertices
+        TetrahedralSolid< dimension >::polyhedron_facets_local_vertices(
+            index_t /*unused*/ ) const
+    {
+        PolyhedronFacetsLocalVertices result;
+        for( const auto& facet : detail::TETRAHEDRON_FACET_VERTICES )
+        {
+            result.emplace_back(
+                PolyhedronFacetLocalVertices{ facet[0], facet[1], facet[2] } );
+        }
+        return result;
+    }
+
     template < index_t dimension >
     std::optional< PolyhedronFacet >
         TetrahedralSolid< dimension >::polyhedron_adjacent_facet(

src/geode/model/helpers/component_mesh_polygons.cpp

@@ -560,6 +560,24 @@ namespace
             unique_vertices, type );
     }
 
+    template < typename Model >
+    geode::ComponentMeshVertexGeneric< 3 > model_polygon_pairs(
+        const Model& model,
+        const geode::PolygonVertices& polygon_unique_vertices,
+        const geode::ComponentID& component )
+    {
+        std::vector< absl::Span< const geode::ComponentMeshVertex > >
+            unique_vertices;
+        unique_vertices.reserve( polygon_unique_vertices.size() );
+        for( const auto polygon_unique_vertex : polygon_unique_vertices )
+        {
+            unique_vertices.emplace_back(
+                model.component_mesh_vertices( polygon_unique_vertex ) );
+        }
+        return geode::component_mesh_vertex_generic< 3 >(
+            unique_vertices, component );
+    }
+
     template < typename Model >
     void model_component_mesh_polygons(
         geode::ModelComponentMeshPolygons& polygons,
@@ -673,6 +691,34 @@ namespace geode
             return polygons;
         }
 
+        std::vector< PolyhedronFacet > block_component_mesh_polygons(
+            const BRep& model,
+            const PolygonVertices& polygon_unique_vertices,
+            const Block3D& block )
+        {
+            const auto block_pairs = model_polygon_pairs(
+                model, polygon_unique_vertices, block.component_id() );
+            if( !block_pairs.contains( block.component_id() ) )
+            {
+                return {};
+            }
+            std::vector< PolyhedronFacet > facets;
+            const auto& mesh = block.mesh();
+            for( const auto& pair : block_pairs.at( block.component_id() ) )
+            {
+                if( auto facet = mesh.polyhedron_facet_from_vertices( pair ) )
+                {
+                    facets.emplace_back( std::move( facet.value() ) );
+                    if( auto adj =
+                            mesh.polyhedron_adjacent_facet( facet.value() ) )
+                    {
+                        facets.emplace_back( std::move( adj.value() ) );
+                    }
+                }
+            }
+            geode::sort_unique( facets );
+            return facets;
+        }
     } // namespace detail
 
     PolygonVertices polygon_unique_vertices(