Merge branch 'next' of https://github.com/Geode-solutions/OpenGeode into fix_removing_apex_refine_in_remesh

Author: benoit2776

include/geode/mesh/helpers/convert_edged_curve.hpp

@@ -47,8 +47,7 @@ namespace geode
             double axis_coordinate );
 
     template < index_t dimension >
-    [[nodiscard]] std::unique_ptr< EdgedCurve< dimension > > merge_edged_curves(
-        absl::Span<
-            const std::reference_wrapper< const EdgedCurve< dimension > > >
-            curves );
+    [[deprecated, nodiscard]] std::unique_ptr< EdgedCurve< dimension > >
+        merge_edged_curves( absl::Span< const std::reference_wrapper<
+                const EdgedCurve< dimension > > > curves );
 } // namespace geode

include/geode/mesh/helpers/convert_solid_mesh.hpp

@@ -61,7 +61,7 @@ namespace geode
         opengeode_mesh_api convert_solid_mesh_into_hybrid_solid(
             const SolidMesh3D& solid );
 
-    [[nodiscard]] std::unique_ptr< SolidMesh3D >
+    [[deprecated, nodiscard]] std::unique_ptr< SolidMesh3D >
         opengeode_mesh_api merge_solid_meshes(
             absl::Span< const std::reference_wrapper< const SolidMesh3D > >
                 solids );

include/geode/mesh/helpers/convert_surface_mesh.hpp

@@ -103,7 +103,7 @@ namespace geode
             local_index_t axis_to_remove );
 
     template < index_t dimension >
-    [[nodiscard]] std::unique_ptr< SurfaceMesh< dimension > >
+    [[deprecated, nodiscard]] std::unique_ptr< SurfaceMesh< dimension > >
         merge_surface_meshes( absl::Span< const std::reference_wrapper<
                 const SurfaceMesh< dimension > > > surfaces );
 } // namespace geode

include/geode/mesh/helpers/remove_vertex_duplication.hpp

@@ -42,17 +42,20 @@ namespace geode
 namespace geode
 {
     template < index_t dimension >
-    void remove_vertex_duplication( const PointSet< dimension >& mesh,
+    [[deprecated]] void remove_vertex_duplication(
+        const PointSet< dimension >& mesh,
         PointSetBuilder< dimension >& builder );
 
     template < index_t dimension >
-    void remove_vertex_duplication( const EdgedCurve< dimension >& mesh,
+    [[deprecated]] void remove_vertex_duplication(
+        const EdgedCurve< dimension >& mesh,
         EdgedCurveBuilder< dimension >& builder );
 
     template < index_t dimension >
-    void remove_vertex_duplication( const SurfaceMesh< dimension >& mesh,
+    [[deprecated]] void remove_vertex_duplication(
+        const SurfaceMesh< dimension >& mesh,
         SurfaceMeshBuilder< dimension >& builder );
 
-    void opengeode_mesh_api remove_vertex_duplication(
+    [[deprecated]] void opengeode_mesh_api remove_vertex_duplication(
         const SolidMesh3D& mesh, SolidMeshBuilder3D& builder );
 } // namespace geode

src/geode/mesh/helpers/rasterize.cpp

@@ -84,7 +84,10 @@ namespace
             index[axis0] += increments[axis0];
             painted_cells.push_back( index );
         }
-        painted_cells.push_back( end );
+        if( painted_cells.back() != end )
+        {
+            painted_cells.push_back( end );
+        }
         return painted_cells;
     }
 
@@ -98,12 +101,17 @@ namespace
         std::array< int, dimension > increments;
         for( const auto i : geode::LRange{ dimension } )
         {
-            if( end[i] > start[i] )
+            if( end[i] == start[i] )
+            {
+                deltas[i] = 0;
+                increments[i] = 0;
+            }
+            else if( end[i] > start[i] )
             {
                 deltas[i] = end[i] - start[i];
                 increments[i] = 1;
             }
-            else
+            else if( end[i] < start[i] )
             {
                 deltas[i] = start[i] - end[i];
                 increments[i] = -1;
@@ -176,9 +184,9 @@ namespace
         std::array< int, dimension > increments;
         std::tie( deltas, increments ) =
             compute_deltas< dimension >( start, end );
-        const auto i = get_major_axis< dimension >( deltas );
+        const auto major_axis = get_major_axis< dimension >( deltas );
         return paint_segment_axis< dimension >(
-            i, deltas, increments, start, end );
+            major_axis, deltas, increments, start, end );
     }
 
     std::vector< CellIndices< 2 > > conservative_voxelization_triangle(
@@ -446,39 +454,56 @@ namespace
         return cells;
     }
 
-    absl::InlinedVector< CellIndices< 3 >, 6 > neighbors(
-        const geode::Grid3D& grid, const CellIndices< 3 >& cell )
+    void add_neighbors_to_queue( const geode::Grid3D& grid,
+        const CellIndices< 3 >& cell,
+        std::queue< CellIndices< 3 > >& cells_queue,
+        const CellIndices< 3 >& min,
+        const CellIndices< 3 >& max )
     {
-        absl::InlinedVector< CellIndices< 3 >, 6 > neighbors;
-        for( const auto d : geode::LRange{ 3 } )
+        for( const auto axis : geode::LRange{ 3 } )
         {
-            if( const auto prev = grid.previous_cell( cell, d ) )
+            if( const auto prev = grid.previous_cell( cell, axis ) )
             {
-                neighbors.push_back( prev.value() );
+                if( prev.value()[axis] >= min[axis] )
+                {
+                    cells_queue.emplace( prev.value() );
+                }
             }
-            if( const auto next = grid.next_cell( cell, d ) )
+            if( const auto next = grid.next_cell( cell, axis ) )
             {
-                neighbors.push_back( next.value() );
+                if( next.value()[axis] <= max[axis] )
+                {
+                    cells_queue.emplace( next.value() );
+                }
             }
         }
-        return neighbors;
     }
 
     std::vector< CellIndices< 3 > > conservative_voxelization_segment(
         const geode::Grid3D& grid,
         const geode::Segment3D& segment,
-        const std::array< geode::Grid3D::CellsAroundVertex, 2 > /*unused*/ )
+        const std::array< geode::Grid3D::CellsAroundVertex, 2 > vertex_cells )
     {
         auto cells = geode::rasterize_segment( grid, segment );
         std::vector< bool > tested_cells( grid.nb_cells(), false );
+        auto min = grid.cell_indices( grid.nb_cells() - 1 );
+        auto max = grid.cell_indices( 0 );
+        for( const auto vertex_id : geode::LRange{ 2 } )
+        {
+            for( const auto& cell_indices : vertex_cells[vertex_id] )
+            {
+                for( const auto axis : geode::LRange{ 3 } )
+                {
+                    max[axis] = std::max( max[axis], cell_indices[axis] );
+                    min[axis] = std::min( min[axis], cell_indices[axis] );
+                }
+            }
+        }
         std::queue< CellIndices< 3 > > to_test;
         for( const auto& cell : cells )
         {
             tested_cells[grid.cell_index( cell )] = true;
-            for( auto&& neighbor : neighbors( grid, cell ) )
-            {
-                to_test.emplace( std::move( neighbor ) );
-            }
+            add_neighbors_to_queue( grid, cell, to_test, min, max );
         }
         const auto half_cell_size =
             std::sqrt( grid.cell_length_in_direction( 0 )
@@ -502,10 +527,7 @@ namespace
             if( geode::point_segment_distance( center, segment )
                 <= half_cell_size )
             {
-                for( auto&& neighbor : neighbors( grid, cell ) )
-                {
-                    to_test.emplace( std::move( neighbor ) );
-                }
+                add_neighbors_to_queue( grid, cell, to_test, min, max );
                 cells.emplace_back( std::move( cell ) );
             }
         }

tests/mesh/CMakeLists.txt

@@ -233,13 +233,6 @@ add_geode_test(
         ${PROJECT_NAME}::geometry
         ${PROJECT_NAME}::mesh
 )
-add_geode_test(
-    SOURCE "test-remove-vertex-duplication.cpp"
-    DEPENDENCIES
-        ${PROJECT_NAME}::basic
-        ${PROJECT_NAME}::geometry
-        ${PROJECT_NAME}::mesh
-)
 add_geode_test(
     SOURCE "test-tetrahedral-solid.cpp"
     DEPENDENCIES

tests/mesh/test-merge-curve.cpp

@@ -30,7 +30,7 @@
 
 #include <geode/mesh/builder/edged_curve_builder.hpp>
 #include <geode/mesh/core/edged_curve.hpp>
-#include <geode/mesh/helpers/convert_edged_curve.hpp>
+#include <geode/mesh/helpers/detail/curve_merger.hpp>
 
 std::vector< std::unique_ptr< geode::EdgedCurve2D > > create_curves()
 {
@@ -81,8 +81,9 @@ void test()
     geode::OpenGeodeMeshLibrary::initialize();
 
     const auto curves = create_curves();
-    const auto merged = geode::merge_edged_curves< 2 >(
-        { *curves[0], *curves[1], *curves[2] } );
+    geode::detail::EdgedCurveMerger2D merger{ { *curves[0], *curves[1],
+        *curves[2] } };
+    const auto merged = merger.merge( geode::GLOBAL_EPSILON );
     OPENGEODE_EXCEPTION(
         merged->nb_vertices() == 8, "[Test] Wrong number of vertices" );
     OPENGEODE_EXCEPTION(

tests/mesh/test-merge-solid.cpp

@@ -30,7 +30,7 @@
 
 #include <geode/mesh/builder/solid_mesh_builder.hpp>
 #include <geode/mesh/core/solid_mesh.hpp>
-#include <geode/mesh/helpers/convert_solid_mesh.hpp>
+#include <geode/mesh/helpers/detail/solid_merger.hpp>
 
 void test()
 {
@@ -87,7 +87,8 @@ void test()
     std::vector< std::reference_wrapper< const geode::SolidMesh3D > > meshes{
         *mesh0, *mesh1
     };
-    const auto merged = geode::merge_solid_meshes( meshes );
+    geode::detail::SolidMeshMerger3D merger{ meshes };
+    const auto merged = merger.merge( geode::GLOBAL_EPSILON );
     OPENGEODE_EXCEPTION(
         merged->nb_vertices() == 10, "[Test] Wrong number of vertices" );
     OPENGEODE_EXCEPTION(

tests/mesh/test-merge-surface.cpp

@@ -34,7 +34,7 @@
 #include <geode/mesh/builder/surface_mesh_builder.hpp>
 #include <geode/mesh/core/surface_mesh.hpp>
 #include <geode/mesh/core/triangulated_surface.hpp>
-#include <geode/mesh/helpers/convert_surface_mesh.hpp>
+#include <geode/mesh/helpers/detail/surface_merger.hpp>
 #include <geode/mesh/io/triangulated_surface_input.hpp>
 #include <geode/mesh/io/triangulated_surface_output.hpp>
 
@@ -74,7 +74,8 @@ void test_create()
     std::vector< std::reference_wrapper< const geode::SurfaceMesh2D > > meshes{
         *mesh0, *mesh1
     };
-    const auto merged = geode::merge_surface_meshes< 2 >( meshes );
+    geode::detail::SurfaceMeshMerger2D merger{ meshes };
+    const auto merged = merger.merge( geode::GLOBAL_EPSILON );
     OPENGEODE_EXCEPTION(
         merged->nb_vertices() == 6, "[Test] Wrong number of vertices" );
     OPENGEODE_EXCEPTION(
@@ -124,7 +125,8 @@ void test_import()
     std::vector< std::reference_wrapper< const geode::SurfaceMesh3D > > meshes{
         *surface
     };
-    const auto merged = geode::merge_surface_meshes< 3 >( meshes );
+    geode::detail::SurfaceMeshMerger3D merger{ meshes };
+    const auto merged = merger.merge( geode::GLOBAL_EPSILON );
     geode::save_triangulated_surface(
         *dynamic_cast< geode::TriangulatedSurface3D* >( merged.get() ),
         "output.og_tsf3d" );