Merge remote-tracking branch 'origin/next' into fix/modify-component-mesh-edges-method

Author: BenPinet

cmake/CppTargets.cmake

@@ -58,11 +58,12 @@ function(add_geode_library)
         )
     endforeach()
     set(PROJECT_LIB_NAME ${PROJECT_NAME}::${GEODE_LIB_NAME})
-    set(VERSION_RC_FILE ${PROJECT_BINARY_DIR}/${GEODE_LIB_FOLDER}/version.rc)
-    if(EXISTS ${VERSION_RC_FILE})
+    set(VERSION_RC_FILE_IN ${PROJECT_SOURCE_DIR}/cmake/version.rc.in)
+    if(EXISTS ${VERSION_RC_FILE_IN})
         message(STATUS "Configuring version.rc")
+        set(VERSION_RC_FILE ${PROJECT_BINARY_DIR}/${GEODE_LIB_FOLDER}/version.rc)
         configure_file(
-            ${PROJECT_SOURCE_DIR}/cmake/version.rc.in
+            ${VERSION_RC_FILE_IN}
             ${VERSION_RC_FILE}
             @ONLY
         )

include/geode/mesh/core/detail/facet_storage.h

@@ -115,7 +115,7 @@ namespace geode
                 for( const auto e :
                     Range{ facet_attribute_manager_.nb_elements() } )
                 {
-                    to_delete[e] = !counter_->value( e );
+                    to_delete[e] = counter_->value( e ) == 0;
                 }
                 return delete_facets( to_delete );
             }

include/geode/mesh/core/grid.h

@@ -170,4 +170,27 @@ namespace geode
         IMPLEMENTATION_MEMBER( impl_ );
     };
     ALIAS_2D_AND_3D( Grid );
+
+    namespace detail
+    {
+        static constexpr std::array< std::array< geode::local_index_t, 2 >, 12 >
+            CELL_EDGE_VERTICES_3D{ { { 0, 1 }, { 0, 2 }, { 2, 3 }, { 1, 3 },
+                { 4, 5 }, { 4, 6 }, { 6, 7 }, { 5, 7 }, { 0, 4 }, { 1, 5 },
+                { 2, 6 }, { 3, 7 } } };
+
+        static constexpr std::array< std::array< geode::local_index_t, 4 >, 6 >
+            CELL_FACET_VERTICES_3D{ { { 0, 4, 6, 2 }, { 1, 5, 7, 3 },
+                { 0, 4, 5, 1 }, { 2, 3, 7, 6 }, { 0, 1, 3, 2 },
+                { 4, 6, 7, 5 } } };
+
+        static constexpr std::array< std::array< geode::local_index_t, 3 >, 8 >
+            CELL_EDGES_AROUND_VERTEX_3D{ { { 0, 1, 8 }, { 0, 3, 9 },
+                { 1, 2, 10 }, { 2, 3, 11 }, { 4, 5, 8 }, { 4, 7, 9 },
+                { 5, 6, 10 }, { 6, 7, 11 } } };
+
+        static constexpr std::array< std::array< geode::local_index_t, 3 >, 8 >
+            CELL_FACETS_AROUND_VERTEX_3D{ { { 0, 2, 4 }, { 1, 2, 4 },
+                { 0, 3, 4 }, { 1, 3, 4 }, { 0, 2, 5 }, { 1, 2, 5 }, { 0, 3, 5 },
+                { 1, 3, 5 } } };
+    } // namespace detail
 } // namespace geode

include/geode/mesh/core/meshes_mapping.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2019 - 2024 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 <geode/basic/mapping.h>
+
+#include <geode/mesh/common.h>
+
+namespace geode
+{
+    using ElementsMapping = GenericMapping< index_t, index_t >;
+
+    struct MeshesElementsMapping
+    {
+        ElementsMapping vertices;
+        ElementsMapping edges;
+        ElementsMapping polygons;
+        ElementsMapping polyhedra;
+    };
+} // namespace geode

include/geode/mesh/helpers/detail/split_along_solid_facets.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2019 - 2024 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 <absl/types/span.h>
+
+#include <geode/basic/pimpl.h>
+
+#include <geode/mesh/common.h>
+#include <geode/mesh/core/meshes_mapping.h>
+
+namespace geode
+{
+    FORWARD_DECLARATION_DIMENSION_CLASS( SolidMesh );
+    FORWARD_DECLARATION_DIMENSION_CLASS( SolidMeshBuilder );
+    ALIAS_3D( SolidMesh );
+    ALIAS_3D( SolidMeshBuilder );
+} // namespace geode
+
+namespace geode
+{
+    namespace detail
+    {
+        class opengeode_mesh_api SplitAlongSolidFacets
+        {
+        public:
+            SplitAlongSolidFacets(
+                const SolidMesh3D& mesh, SolidMeshBuilder3D& builder );
+            ~SplitAlongSolidFacets();
+
+            /*
+             * Splits the solid along given facets, and returns the mapping on
+             * vertices and facets.
+             */
+            MeshesElementsMapping split_solid_along_facets(
+                absl::Span< const PolyhedronFacet > facets_list );
+
+        private:
+            IMPLEMENTATION_MEMBER( impl_ );
+        };
+    } // namespace detail
+} // namespace geode

include/geode/model/helpers/detail/cut_along_internal_surfaces.h renamed to include/geode/model/helpers/detail/split_along_block_mesh_borders.h

@@ -40,28 +40,30 @@ namespace geode
 {
     namespace detail
     {
-        class opengeode_model_api CutAlongInternalSurfaces
+        class opengeode_model_api SplitAlongBlockMeshBorders
         {
         public:
-            CutAlongInternalSurfaces( BRep& model );
-            CutAlongInternalSurfaces( const BRep& model, BRepBuilder& builder );
-            ~CutAlongInternalSurfaces();
+            SplitAlongBlockMeshBorders(
+                const BRep& model, BRepBuilder& builder );
+            ~SplitAlongBlockMeshBorders();
 
-            /* Cuts the blocks along internal surfaces, and returns pairs of
+            /* Splits the blocks along internal surfaces, facets without
+             * adjacencies and non manifold vertices, and returns pairs of
              * component mesh vertices where the blocks vertices were split
              * (first the initial cmv of the vertices, second the cmv of the
              * newly created vertex)
              */
             std::vector< std::pair< ComponentMeshVertex, ComponentMeshVertex > >
-                cut_all_blocks();
+                split_all_blocks();
 
-            /* Cuts the block along internal surfaces, and returns pairs of
+            /* Splits the block along internal surfaces, facets without
+             * adjacencies and non manifold vertices, and returns pairs of
              * component mesh vertices where the block vertices were split
              * (first the initial id of the vertices, second the id of the newly
              * created vertex)
              */
             std::vector< std::pair< ComponentMeshVertex, ComponentMeshVertex > >
-                cut_block( const Block3D& block );
+                split_block( const Block3D& block );
 
         private:
             IMPLEMENTATION_MEMBER( impl_ );

include/geode/model/helpers/detail/cut_along_internal_lines.h renamed to include/geode/model/helpers/detail/split_along_surface_mesh_borders.h

@@ -38,29 +38,29 @@ namespace geode
     namespace detail
     {
         template < typename Model >
-        class CutAlongInternalLines
+        class SplitAlongSurfaceMeshBorders
         {
         public:
-            CutAlongInternalLines( Model& model );
-            CutAlongInternalLines(
+            SplitAlongSurfaceMeshBorders( Model& model );
+            SplitAlongSurfaceMeshBorders(
                 const Model& model, typename Model::Builder& builder );
-            ~CutAlongInternalLines();
+            ~SplitAlongSurfaceMeshBorders();
 
-            /* Cuts the surfaces along internal lines, and returns pairs of
+            /* Splits the surfaces along internal lines, and returns pairs of
              * component mesh vertices where the surfaces vertices were split
              * (first the initial cmv of the vertices, second the cmv of the
              * newly created vertex)
              */
             std::vector< std::pair< ComponentMeshVertex, ComponentMeshVertex > >
-                cut_all_surfaces();
+                split_all_surfaces();
 
-            /* Cuts the surface along internal lines, and returns pairs of
+            /* Splits the surface along internal lines, and returns pairs of
              * component mesh vertices where the surface vertices were split
              * (first the initial id of the vertices, second the id of the newly
              * created vertex)
              */
             std::vector< std::pair< ComponentMeshVertex, ComponentMeshVertex > >
-                cut_surface( const Surface< Model::dim >& surface );
+                split_surface( const Surface< Model::dim >& surface );
 
         private:
             IMPLEMENTATION_MEMBER( impl_ );

src/geode/mesh/CMakeLists.txt

@@ -117,6 +117,7 @@ add_geode_library(
         "helpers/detail/component_identifier.cpp"
         "helpers/detail/create_mesh.cpp"
         "helpers/detail/curve_merger.cpp"
+        "helpers/detail/split_along_solid_facets.cpp"
         "helpers/detail/debug.cpp"
         "helpers/detail/element_identifier.cpp"
         "helpers/detail/solid_merger.cpp"
@@ -298,6 +299,7 @@ add_geode_library(
         "core/detail/geode_elements.h"
         "core/detail/vertex_cycle.h"
         "helpers/detail/curve_merger.h"
+        "helpers/detail/split_along_solid_facets.h"
         "helpers/detail/component_identifier.h"
         "helpers/detail/create_mesh.h"
         "helpers/detail/debug.h"

src/geode/mesh/builder/solid_mesh_builder.cpp

@@ -293,49 +293,49 @@ namespace
             }
             const auto position_it =
                 absl::c_find( facet_vertices, polyhedron_vertex );
-            if( position_it != facet_vertices.end() )
+            if( position_it == facet_vertices.end() )
             {
-                geode::PolyhedronFacetVertices facet_vertices_id;
-                facet_vertices_id.reserve( nb_facet_vertices );
-                for( const auto& v : facet_vertices )
-                {
-                    facet_vertices_id.emplace_back(
-                        solid.polyhedron_vertex( v ) );
-                }
+                continue;
+            }
+            geode::PolyhedronFacetVertices facet_vertices_id;
+            facet_vertices_id.reserve( nb_facet_vertices );
+            for( const auto& v : facet_vertices )
+            {
+                facet_vertices_id.emplace_back( solid.polyhedron_vertex( v ) );
+            }
 
-                const auto position = static_cast< geode::index_t >(
-                    std::distance( facet_vertices.begin(), position_it ) );
+            const auto position = static_cast< geode::index_t >(
+                std::distance( facet_vertices.begin(), position_it ) );
 
-                if( solid.are_facets_enabled() )
+            if( solid.are_facets_enabled() )
+            {
+                auto facets = builder.facets_builder();
+                facets.update_facet_vertex(
+                    facet_vertices_id, position, new_vertex_id );
+            }
+
+            if( solid.are_edges_enabled() )
+            {
+                auto edges = builder.edges_builder();
+                const auto next =
+                    position + 1 == nb_facet_vertices ? 0 : position + 1;
+                std::array< geode::index_t, 2 > next_edge_vertices{
+                    facet_vertices_id[position], facet_vertices_id[next]
+                };
+                if( next_edge_vertices[0] < next_edge_vertices[1] )
                 {
-                    auto facets = builder.facets_builder();
-                    facets.update_facet_vertex(
-                        facet_vertices_id, position, new_vertex_id );
+                    edges.update_edge_vertex(
+                        next_edge_vertices, 0, new_vertex_id );
                 }
-
-                if( solid.are_edges_enabled() )
+                const auto prev =
+                    position == 0 ? nb_facet_vertices - 1 : position - 1;
+                std::array< geode::index_t, 2 > previous_edge_vertices{
+                    facet_vertices_id[prev], facet_vertices_id[position]
+                };
+                if( previous_edge_vertices[0] < previous_edge_vertices[1] )
                 {
-                    auto edges = builder.edges_builder();
-                    const auto next =
-                        position + 1 == nb_facet_vertices ? 0 : position + 1;
-                    std::array< geode::index_t, 2 > next_edge_vertices{
-                        facet_vertices_id[position], facet_vertices_id[next]
-                    };
-                    if( next_edge_vertices[0] < next_edge_vertices[1] )
-                    {
-                        edges.update_edge_vertex(
-                            next_edge_vertices, 0, new_vertex_id );
-                    }
-                    const auto prev =
-                        position == 0 ? nb_facet_vertices - 1 : position - 1;
-                    std::array< geode::index_t, 2 > previous_edge_vertices{
-                        facet_vertices_id[prev], facet_vertices_id[position]
-                    };
-                    if( previous_edge_vertices[0] < previous_edge_vertices[1] )
-                    {
-                        edges.update_edge_vertex(
-                            previous_edge_vertices, 1, new_vertex_id );
-                    }
+                    edges.update_edge_vertex(
+                        previous_edge_vertices, 1, new_vertex_id );
                 }
             }
         }

src/geode/mesh/core/solid_mesh.cpp

@@ -191,17 +191,21 @@ namespace
         const geode::SolidMesh< dimension >& solid,
         const std::array< geode::index_t, 2 >& vertices )
     {
-        for( const auto& polyhedron :
-            solid.polyhedra_around_vertex( vertices[0] ) )
+        for( const auto vertex : vertices )
         {
-            for( const auto& edge_vertices :
-                solid.polyhedron_edges_vertices( polyhedron.polyhedron_id ) )
+            for( const auto& polyhedron :
+                solid.polyhedra_around_vertex( vertex ) )
             {
-                if( vertices == edge_vertices
-                    || ( vertices[0] == edge_vertices[1]
-                         && vertices[1] == edge_vertices[0] ) )
+                for( const auto& edge_vertices :
+                    solid.polyhedron_edges_vertices(
+                        polyhedron.polyhedron_id ) )
                 {
-                    return polyhedron.polyhedron_id;
+                    if( vertices == edge_vertices
+                        || ( vertices[0] == edge_vertices[1]
+                             && vertices[1] == edge_vertices[0] ) )
+                    {
+                        return polyhedron.polyhedron_id;
+                    }
                 }
             }
         }
@@ -1142,6 +1146,7 @@ namespace geode
         }
         return result;
     }
+
     template < index_t dimension >
     absl::optional< index_t > SolidMesh< dimension >::polyhedron_around_edge(
         const std::array< index_t, 2 >& vertices ) const