added densified pattern for surfaces

Author: MelchiorSchuh

include/geode/mesh/helpers/convert_surface_mesh.hpp

@@ -58,6 +58,10 @@ namespace geode
     [[nodiscard]] std::unique_ptr< TriangulatedSurface2D > opengeode_mesh_api
         convert_grid_into_triangulated_surface( const Grid2D& grid );
 
+    [[nodiscard]] std::unique_ptr< TriangulatedSurface2D > opengeode_mesh_api
+        convert_grid_into_densified_triangulated_surface( const Grid2D& grid,
+            absl::Span< const geode::index_t > cells_to_densify );
+
     template < index_t dimension >
     void triangulate_surface_mesh( SurfaceMesh< dimension >& surface );
 

src/geode/mesh/helpers/convert_solid_mesh.cpp

@@ -144,7 +144,8 @@ namespace
         const geode::Grid3D& grid,
         absl::Span< const geode::index_t > cells_to_densify )
     {
-        builder.reserve_tetrahedra( 6 * grid.nb_cells() );
+        builder.reserve_tetrahedra(
+            6 * grid.nb_cells() + 6 * cells_to_densify.size() );
         geode::GenericMapping< geode::index_t > old2new_mapping;
         for( const auto k : geode::Range{ grid.nb_cells_in_direction( 2 ) } )
         {
@@ -175,7 +176,6 @@ namespace
                 grid.cell_indices( cells_to_densify[cell_index] );
             const auto additional_vertex_id =
                 grid.nb_grid_vertices() + cell_index;
-            geode::index_t counter{ 0 };
             for( const auto tetra_id : create_tetrahedra_from_pyramid_pattern(
                      builder, grid, cell_indices, additional_vertex_id ) )
             {

src/geode/mesh/helpers/convert_surface_mesh.cpp

@@ -117,67 +117,141 @@ namespace
     template < geode::index_t dimension >
     std::unique_ptr< geode::TriangulatedSurface< dimension > >
         create_triangulated_surface_from_grid(
-            const geode::Grid< dimension >& /*unused*/ )
+            const geode::Grid< dimension >& /*unused*/,
+            absl::Span< const geode::index_t > /*unused*/ )
     {
         throw geode::OpenGeodeException{
             "[create_triangulated_surface_from_grid] Cannot convert "
             "SurfaceMesh from RegularGrid3D"
         };
     }
 
+    std::array< geode::index_t, 4 > create_triangles_from_cross_pattern(
+        geode::TriangulatedSurfaceBuilder2D& builder,
+        const geode::Grid2D& grid,
+        const geode::Grid2D::CellIndices& cell_indices,
+        geode::index_t additional_vertex_id )
+    {
+        const auto cell_vertices = grid.cell_vertices( cell_indices );
+        std::array< geode::index_t, 4 > cell_mesh_vertices;
+        for( const auto vertex_id : geode::LIndices{ cell_mesh_vertices } )
+        {
+            const auto cell_vertex_id =
+                grid.vertex_index( cell_vertices[vertex_id] );
+            cell_mesh_vertices[vertex_id] = cell_vertex_id;
+        }
+        std::array< geode::index_t, 4 > created_triangles;
+        created_triangles[0] = builder.create_triangle( { cell_mesh_vertices[0],
+            cell_mesh_vertices[1], additional_vertex_id } );
+        created_triangles[1] = builder.create_triangle( { cell_mesh_vertices[1],
+            cell_mesh_vertices[3], additional_vertex_id } );
+        created_triangles[2] = builder.create_triangle( { cell_mesh_vertices[3],
+            cell_mesh_vertices[2], additional_vertex_id } );
+        created_triangles[4] = builder.create_triangle( { cell_mesh_vertices[2],
+            cell_mesh_vertices[0], additional_vertex_id } );
+        return created_triangles;
+    }
+
+    std::array< geode::index_t, 2 > create_triangles_from_diagonal_pattern(
+        geode::TriangulatedSurfaceBuilder2D& builder,
+        const geode::Grid2D& grid,
+        const geode::Grid2D::CellIndices& cell_indices )
+    {
+        const auto cell_vertices = grid.cell_vertices( cell_indices );
+        std::array< geode::index_t, 4 > cell_mesh_vertices;
+        for( const auto vertex_id : geode::LIndices{ cell_mesh_vertices } )
+        {
+            const auto cell_vertex_id =
+                grid.vertex_index( cell_vertices[vertex_id] );
+            cell_mesh_vertices[vertex_id] = cell_vertex_id;
+        }
+        std::array< geode::index_t, 2 > created_triangles;
+        created_triangles[0] = builder.create_triangle( { cell_mesh_vertices[0],
+            cell_mesh_vertices[1], cell_mesh_vertices[3] } );
+        created_triangles[1] = builder.create_triangle( { cell_mesh_vertices[0],
+            cell_mesh_vertices[3], cell_mesh_vertices[2] } );
+        return created_triangles;
+    }
+
     void create_triangles_from_grid_cells(
         const geode::TriangulatedSurface2D& surface,
         geode::TriangulatedSurfaceBuilder2D& builder,
-        const geode::Grid2D& grid )
+        const geode::Grid2D& grid,
+        absl::Span< const geode::index_t > cells_to_densify )
     {
-        builder.reserve_triangles( 2 * grid.nb_cells() );
+        builder.reserve_triangles(
+            2 * grid.nb_cells() + 2 * cells_to_densify.size() );
         geode::GenericMapping< geode::index_t > old2new_mapping;
         for( const auto j : geode::Range{ grid.nb_cells_in_direction( 1 ) } )
         {
             for( const auto i :
                 geode::Range{ grid.nb_cells_in_direction( 0 ) } )
             {
-                const auto cell_vertices = grid.cell_vertices( { i, j } );
                 const auto cell = grid.cell_index( { i, j } );
-                std::array< geode::index_t, 4 > cell_mesh_vertices;
-                for( const auto v : geode::LIndices{ cell_mesh_vertices } )
+                if( absl::c_find( cells_to_densify, cell )
+                    != cells_to_densify.end() )
+                {
+                    continue;
+                }
+                for( const auto triangle_id :
+                    create_triangles_from_diagonal_pattern(
+                        builder, grid, { i, j } ) )
                 {
-                    const auto cell_vertex_id =
-                        grid.vertex_index( cell_vertices[v] );
-                    cell_mesh_vertices[v] = cell_vertex_id;
+                    old2new_mapping.map( cell, triangle_id );
                 }
-                const auto triangle0 =
-                    builder.create_triangle( { cell_mesh_vertices[0],
-                        cell_mesh_vertices[1], cell_mesh_vertices[3] } );
-                const auto triangle1 =
-                    builder.create_triangle( { cell_mesh_vertices[0],
-                        cell_mesh_vertices[3], cell_mesh_vertices[2] } );
-                builder.set_polygon_adjacent( { triangle0, 2 }, triangle1 );
-                builder.set_polygon_adjacent( { triangle1, 0 }, triangle0 );
-                old2new_mapping.map( cell, triangle0 );
-                old2new_mapping.map( cell, triangle1 );
+            }
+        }
+        for( const auto cell_index : geode::Indices{ cells_to_densify } )
+        {
+            const auto cell_indices =
+                grid.cell_indices( cells_to_densify[cell_index] );
+            const auto additional_vertex_id =
+                grid.nb_grid_vertices() + cell_index;
+            for( const auto triangle_id : create_triangles_from_cross_pattern(
+                     builder, grid, cell_indices, additional_vertex_id ) )
+            {
+                old2new_mapping.map(
+                    cells_to_densify[cell_index], triangle_id );
             }
         }
         builder.compute_polygon_adjacencies();
         surface.polygon_attribute_manager().import(
             grid.cell_attribute_manager(), old2new_mapping );
     }
 
+    void create_vertices_from_grid( const geode::TriangulatedSurface2D& surface,
+        geode::TriangulatedSurfaceBuilder2D& builder,
+        const geode::Grid2D& grid,
+        absl::Span< const geode::index_t > cells_to_densify )
+    {
+        builder.create_vertices(
+            grid.nb_grid_vertices() + cells_to_densify.size() );
+        for( const auto vertex_id : geode::Range{ grid.nb_grid_vertices() } )
+        {
+            builder.set_point( vertex_id,
+                grid.grid_point( grid.vertex_indices( vertex_id ) ) );
+        }
+        geode::index_t counter{ grid.nb_grid_vertices() };
+        for( const auto cell_id : cells_to_densify )
+        {
+            builder.set_point(
+                counter, grid.cell_barycenter( grid.cell_indices( cell_id ) ) );
+            counter++;
+        }
+        geode::internal::copy_attributes( grid.grid_vertex_attribute_manager(),
+            surface.vertex_attribute_manager() );
+    }
+
     template <>
     std::unique_ptr< geode::TriangulatedSurface2D >
-        create_triangulated_surface_from_grid( const geode::Grid2D& grid )
+        create_triangulated_surface_from_grid( const geode::Grid2D& grid,
+            absl::Span< const geode::index_t > cells_to_densify )
     {
         auto surface = geode::TriangulatedSurface2D::create();
         auto builder = geode::TriangulatedSurfaceBuilder2D::create( *surface );
-        builder->create_vertices( grid.nb_grid_vertices() );
-        for( const auto v : geode::Range{ grid.nb_grid_vertices() } )
-        {
-            builder->set_point(
-                v, grid.grid_point( grid.vertex_indices( v ) ) );
-        }
-        geode::internal::copy_attributes( grid.grid_vertex_attribute_manager(),
-            surface->vertex_attribute_manager() );
-        create_triangles_from_grid_cells( *surface, *builder, grid );
+        create_vertices_from_grid( *surface, *builder, grid, cells_to_densify );
+        create_triangles_from_grid_cells(
+            *surface, *builder, grid, cells_to_densify );
         return surface;
     }
 } // namespace
@@ -211,8 +285,8 @@ namespace geode
         {
             std::optional< std::unique_ptr< TriangulatedSurface< dimension > > >
                 result{ create_triangulated_surface_from_grid(
-                    dynamic_cast< const RegularGrid< dimension >& >(
-                        surface ) ) };
+                    dynamic_cast< const RegularGrid< dimension >& >( surface ),
+                    {} ) };
             auto builder = TriangulatedSurfaceBuilder< dimension >::create(
                 *result->get() );
             internal::copy_meta_info( surface, *builder );
@@ -233,7 +307,14 @@ namespace geode
     std::unique_ptr< TriangulatedSurface2D >
         convert_grid_into_triangulated_surface( const Grid2D& grid )
     {
-        return create_triangulated_surface_from_grid( grid );
+        return create_triangulated_surface_from_grid( grid, {} );
+    }
+
+    std::unique_ptr< TriangulatedSurface2D >
+        convert_grid_into_densified_triangulated_surface( const Grid2D& grid,
+            absl::Span< const geode::index_t > cells_to_densify )
+    {
+        return create_triangulated_surface_from_grid( grid, cells_to_densify );
     }
 
     template < index_t dimension >

tests/mesh/test-convert-surface.cpp

@@ -73,9 +73,18 @@ void test()
 
     geode::LightRegularGrid2D grid{ geode::Point2D{ { 1, 2 } }, { 5, 6 },
         { 1, 1 } };
+    const std::array< geode::index_t, 4 > cells_to_densify{ 5, 11, 12, 13 };
     const auto converted_grid2d =
         geode::convert_grid_into_triangulated_surface( grid );
-    OPENGEODE_EXCEPTION( converted_grid2d->nb_polygons() == 5 * 6 * 2,
+    const auto converted_grid2d_densified =
+        geode::convert_grid_into_densified_triangulated_surface(
+            grid, cells_to_densify );
+    OPENGEODE_EXCEPTION( converted_grid2d->nb_polygons() == grid.nb_cells() * 2,
+        "[Test] Number of polygons in TriangulatedSurface2D from grid is not "
+        "correct." );
+    OPENGEODE_EXCEPTION(
+        converted_grid2d_densified->nb_polygons()
+            == grid.nb_cells() * 2 + 2 * cells_to_densify.size(),
         "[Test] Number of polygons in TriangulatedSurface2D from grid is not "
         "correct." );
 }