fix(RegularGrid): Fixed issue on grid origin initialization on old grids.

MelchiorSchuh · MelchiorSchuh · commit bb6cfad23fa0 · 2025-03-11T11:51:45.000+01:00
diff --git a/include/geode/basic/mapping.hpp b/include/geode/basic/mapping.hpp
@@ -32,8 +32,7 @@ namespace geode
 {
     template < typename T1,
         typename T2,
-        template < typename >
-        class StorageType >
+        template < typename > class StorageType >
     class MappingBase
     {
     public:
@@ -200,7 +199,7 @@ namespace geode
         {
             if( this->has_mapping_input( in ) )
             {
-                if( absl::c_contains( this->in2out_mapping().at( in ), out ) )
+                if( absl::c_contains( this->in2out( in ), out ) )
                 {
                     return;
                 }
diff --git a/src/geode/mesh/core/grid.cpp b/src/geode/mesh/core/grid.cpp
@@ -26,6 +26,7 @@
 #include <absl/container/inlined_vector.h>
 
 #include <geode/basic/bitsery_archive.hpp>
+#include <geode/basic/logger.hpp>
 #include <geode/basic/pimpl_impl.hpp>
 
 #include <geode/geometry/bounding_box.hpp>
@@ -53,6 +54,7 @@ namespace geode
         Impl()
         {
             cells_length_.fill( 1 );
+            set_base_origin();
             set_base_grid_directions();
         }
 
@@ -429,10 +431,12 @@ namespace geode
                            { []( Archive& a, Impl& impl ) {
                                 a.container4b( impl.deprecated_cells_number_ );
                                 a.container8b( impl.cells_length_ );
+                                impl.set_base_origin();
                                 impl.set_base_grid_directions();
                             },
                                []( Archive& a, Impl& impl ) {
                                    a.container8b( impl.cells_length_ );
+                                   impl.set_base_origin();
                                    impl.set_base_grid_directions();
                                },
                                []( Archive& a, Impl& impl ) {
@@ -441,6 +445,11 @@ namespace geode
                                } } } );
         }
 
+        void set_base_origin()
+        {
+            set_grid_origin( Point< dimension >{} );
+        }
+
         void set_base_grid_directions()
         {
             std::array< Vector< dimension >, dimension > directions;
@@ -524,8 +533,8 @@ namespace geode
     }
 
     template < index_t dimension >
-    auto Grid< dimension >::cell_vertices(
-        const CellIndices& cell_id ) const -> CellVertices
+    auto Grid< dimension >::cell_vertices( const CellIndices& cell_id ) const
+        -> CellVertices
     {
         return impl_->cell_vertices( cell_id );
     }
@@ -572,15 +581,15 @@ namespace geode
     }
 
     template < index_t dimension >
-    auto Grid< dimension >::cells(
-        const Point< dimension >& query ) const -> CellsAroundVertex
+    auto Grid< dimension >::cells( const Point< dimension >& query ) const
+        -> CellsAroundVertex
     {
         return impl_->cells( *this, query );
     }
 
     template < index_t dimension >
-    auto Grid< dimension >::cells_around(
-        VertexIndices vertex_indices ) const -> CellsAroundVertex
+    auto Grid< dimension >::cells_around( VertexIndices vertex_indices ) const
+        -> CellsAroundVertex
     {
         return impl_->cells_around( *this, vertex_indices );
     }
diff --git a/src/geode/mesh/core/regular_grid_solid.cpp b/src/geode/mesh/core/regular_grid_solid.cpp
@@ -94,7 +94,7 @@ namespace geode
                      a.ext( grid, bitsery::ext::BaseClass< SolidMesh< 3 > >{} );
                      a.ext( grid, bitsery::ext::BaseClass< Grid< 3 > >{} );
                      GridBuilder3D builder{ grid };
-                     builder.set_grid_origin( grid.point( 0 ) );
+                     builder.set_grid_origin( grid.grid_point( { 0, 0, 0 } ) );
                  },
                     []( Archive& a, RegularGrid< 3 >& grid ) {
                         a.ext(
diff --git a/src/geode/mesh/core/regular_grid_surface.cpp b/src/geode/mesh/core/regular_grid_surface.cpp
@@ -95,7 +95,7 @@ namespace geode
                          grid, bitsery::ext::BaseClass< SurfaceMesh< 2 > >{} );
                      a.ext( grid, bitsery::ext::BaseClass< Grid< 2 > >{} );
                      GridBuilder2D builder{ grid };
-                     builder.set_grid_origin( grid.point( 0 ) );
+                     builder.set_grid_origin( grid.grid_point( { 0, 0 } ) );
                  },
                     []( Archive& a, RegularGrid< 2 >& grid ) {
                         a.ext( grid,
diff --git a/src/geode/mesh/helpers/convert_solid_mesh.cpp b/src/geode/mesh/helpers/convert_solid_mesh.cpp
@@ -310,14 +310,17 @@ namespace
             std::vector< double > lambdas;
             cell_vertices.reserve( 8 );
             lambdas.reserve( 8 );
+            geode::Point3D position{ { 0., 0., 0. } };
             for( const auto& vertex_indices :
                 grid.cell_vertices( cell_indices ) )
             {
                 cell_vertices.push_back( grid.vertex_index( vertex_indices ) );
                 lambdas.push_back( 0.125 );
+                position += grid.grid_point( vertex_indices ) * 0.125;
             }
             solid_attribute_manager.interpolate_attribute_value(
                 { cell_vertices, lambdas }, counter );
+            builder.set_point( counter, position );
             counter++;
         }
     }
diff --git a/src/geode/mesh/helpers/convert_surface_mesh.cpp b/src/geode/mesh/helpers/convert_surface_mesh.cpp
@@ -149,7 +149,7 @@ namespace
             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],
+        created_triangles[3] = builder.create_triangle( { cell_mesh_vertices[2],
             cell_mesh_vertices[0], additional_vertex_id } );
         return created_triangles;
     }
@@ -210,14 +210,14 @@ namespace
         for( const auto cell_index : geode::Indices{ cells_to_densify } )
         {
             const auto cell_indices =
-                grid.cell_indices( cells_to_densify[cell_index] );
+                grid.cell_indices( cells_to_densify.at( 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 );
+                    cells_to_densify.at( cell_index ), triangle_id );
             }
         }
         builder.compute_polygon_adjacencies();
@@ -232,14 +232,14 @@ namespace
     {
         builder.create_vertices(
             grid.nb_grid_vertices() + cells_to_densify.size() );
+        auto& surface_attribute_manager = surface.vertex_attribute_manager();
+        geode::internal::copy_attributes(
+            grid.grid_vertex_attribute_manager(), surface_attribute_manager );
         for( const auto vertex_id : geode::Range{ grid.nb_grid_vertices() } )
         {
             builder.set_point( vertex_id,
                 grid.grid_point( grid.vertex_indices( vertex_id ) ) );
         }
-        auto& surface_attribute_manager = surface.vertex_attribute_manager();
-        geode::internal::copy_attributes(
-            grid.grid_vertex_attribute_manager(), surface_attribute_manager );
         geode::index_t counter{ grid.nb_grid_vertices() };
         for( const auto cell_id : cells_to_densify )
         {
@@ -249,14 +249,17 @@ namespace
             std::vector< double > lambdas;
             cell_vertices.reserve( 4 );
             lambdas.reserve( 4 );
+            geode::Point2D position{ { 0., 0. } };
             for( const auto& vertex_indices :
                 grid.cell_vertices( cell_indices ) )
             {
                 cell_vertices.push_back( grid.vertex_index( vertex_indices ) );
                 lambdas.push_back( 0.25 );
+                position += grid.grid_point( vertex_indices ) * 0.25;
             }
             surface_attribute_manager.interpolate_attribute_value(
                 { cell_vertices, lambdas }, counter );
+            builder.set_point( counter, position );
             counter++;
         }
     }
diff --git a/tests/data/old_regular_grid.og_rgd2d b/tests/data/old_regular_grid.og_rgd2d
diff --git a/tests/data/old_regular_grid.og_rgd3d b/tests/data/old_regular_grid.og_rgd3d
diff --git a/tests/mesh/test-convert-surface.cpp b/tests/mesh/test-convert-surface.cpp
@@ -24,16 +24,20 @@
 #include <geode/tests/common.hpp>
 
 #include <geode/basic/assert.hpp>
+#include <geode/basic/attribute_manager.hpp>
 #include <geode/basic/logger.hpp>
 
 #include <geode/geometry/point.hpp>
 #include <geode/geometry/vector.hpp>
 
+#include <geode/mesh/builder/regular_grid_surface_builder.hpp>
 #include <geode/mesh/builder/surface_mesh_builder.hpp>
 #include <geode/mesh/core/light_regular_grid.hpp>
 #include <geode/mesh/core/polygonal_surface.hpp>
+#include <geode/mesh/core/regular_grid_surface.hpp>
 #include <geode/mesh/core/triangulated_surface.hpp>
 #include <geode/mesh/io/polygonal_surface_output.hpp>
+#include <geode/mesh/io/regular_grid_input.hpp>
 #include <geode/mesh/io/triangulated_surface_input.hpp>
 
 #include <geode/mesh/helpers/convert_surface_mesh.hpp>
@@ -78,9 +82,9 @@ void convert_grid_to_surface()
 {
     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 );
+    const std::array< geode::index_t, 4 > cells_to_densify{ 5, 11, 12, 13 };
     const auto converted_grid2d_densified =
         geode::convert_grid_into_densified_triangulated_surface(
             grid, cells_to_densify );
@@ -92,6 +96,37 @@ void convert_grid_to_surface()
             == grid.nb_cells() * 2 + 2 * cells_to_densify.size(),
         "[Test] Number of polygons in TriangulatedSurface2D from grid is not "
         "correct." );
+
+    geode::Logger::debug( "Triangulated surface from created RegularGrid" );
+    auto mesh_grid = geode::RegularGrid2D::create();
+    auto builder = geode::RegularGridBuilder2D::create( *mesh_grid );
+    builder->initialize_grid( geode::Point2D{ { 1, 1.5 } }, { 5, 5 }, 5 );
+    const auto tri_surf_from_mesh_grid_1 =
+        geode::convert_surface_mesh_into_triangulated_surface( *mesh_grid );
+    const auto tri_surf_from_mesh_grid_2 =
+        geode::convert_grid_into_triangulated_surface( *mesh_grid );
+
+    geode::Logger::debug( "Triangulated surface from old RegularGrid" );
+    const auto old_regular_grid = geode::load_regular_grid< 2 >(
+        absl::StrCat( geode::DATA_PATH, "old_regular_grid.og_rgd2d" ) );
+    const auto old_regular_grid_surface =
+        geode::convert_grid_into_triangulated_surface( *old_regular_grid );
+    auto test_attribute =
+        old_regular_grid_surface->vertex_attribute_manager()
+            .find_or_create_attribute< geode::VariableAttribute,
+                geode::Point2D >( "test", geode::Point2D{ { 0., 0. } } );
+    auto pt_attribute = old_regular_grid_surface->vertex_attribute_manager()
+                            .find_attribute< geode::Point2D >( "points" );
+    const auto old_regular_grid_surface2 =
+        geode::convert_surface_mesh_into_triangulated_surface(
+            *old_regular_grid )
+            .value();
+    auto test_attribute2 =
+        old_regular_grid_surface2->vertex_attribute_manager()
+            .find_or_create_attribute< geode::VariableAttribute,
+                geode::Point2D >( "test", geode::Point2D{ { 0., 0. } } );
+    auto pt_attribute2 = old_regular_grid_surface2->vertex_attribute_manager()
+                             .find_attribute< geode::Point2D >( "points" );
 }
 
 void triangulate_surface()
@@ -118,6 +153,7 @@ void triangulate_surface()
 void test()
 {
     geode::OpenGeodeMeshLibrary::initialize();
+    geode::Logger::set_level( geode::Logger::LEVEL::debug );
     convert_surface_dimension();
     convert_grid_to_surface();
     triangulate_surface();

Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,7 @@ namespace geode`
`32`	`32`	`{`
`33`	`33`	`template < typename T1,`
`34`	`34`	`typename T2,`
`35`		`- template < typename >`
`36`		`- class StorageType >`
	`35`	`+ template < typename > class StorageType >`
`37`	`36`	`class MappingBase`
`38`	`37`	`{`
`39`	`38`	`public:`
`@@ -200,7 +199,7 @@ namespace geode`
`200`	`199`	`{`
`201`	`200`	`if( this->has_mapping_input( in ) )`
`202`	`201`	`{`
`203`		`- if( absl::c_contains( this->in2out_mapping().at( in ), out ) )`
	`202`	`+ if( absl::c_contains( this->in2out( in ), out ) )`
`204`	`203`	`{`
`205`	`204`	`return;`
`206`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@`
`26`	`26`	`#include <absl/container/inlined_vector.h>`
`27`	`27`
`28`	`28`	`#include <geode/basic/bitsery_archive.hpp>`
	`29`	`+#include <geode/basic/logger.hpp>`
`29`	`30`	`#include <geode/basic/pimpl_impl.hpp>`
`30`	`31`
`31`	`32`	`#include <geode/geometry/bounding_box.hpp>`
`@@ -53,6 +54,7 @@ namespace geode`
`53`	`54`	`Impl()`
`54`	`55`	`{`
`55`	`56`	`cells_length_.fill( 1 );`
	`57`	`+ set_base_origin();`
`56`	`58`	`set_base_grid_directions();`
`57`	`59`	`}`
`58`	`60`
`@@ -429,10 +431,12 @@ namespace geode`
`429`	`431`	`{ []( Archive& a, Impl& impl ) {`
`430`	`432`	`a.container4b( impl.deprecated_cells_number_ );`
`431`	`433`	`a.container8b( impl.cells_length_ );`
	`434`	`+ impl.set_base_origin();`
`432`	`435`	`impl.set_base_grid_directions();`
`433`	`436`	`},`
`434`	`437`	`[]( Archive& a, Impl& impl ) {`
`435`	`438`	`a.container8b( impl.cells_length_ );`
	`439`	`+ impl.set_base_origin();`
`436`	`440`	`impl.set_base_grid_directions();`
`437`	`441`	`},`
`438`	`442`	`[]( Archive& a, Impl& impl ) {`
`@@ -441,6 +445,11 @@ namespace geode`
`441`	`445`	`} } } );`
`442`	`446`	`}`
`443`	`447`
	`448`	`+ void set_base_origin()`
	`449`	`+ {`
	`450`	`+ set_grid_origin( Point< dimension >{} );`
	`451`	`+ }`
	`452`	`+`
`444`	`453`	`void set_base_grid_directions()`
`445`	`454`	`{`
`446`	`455`	`std::array< Vector< dimension >, dimension > directions;`
`@@ -524,8 +533,8 @@ namespace geode`
`524`	`533`	`}`
`525`	`534`
`526`	`535`	`template < index_t dimension >`
`527`		`- auto Grid< dimension >::cell_vertices(`
`528`		`- const CellIndices& cell_id ) const -> CellVertices`
	`536`	`+ auto Grid< dimension >::cell_vertices( const CellIndices& cell_id ) const`
	`537`	`+ -> CellVertices`
`529`	`538`	`{`
`530`	`539`	`return impl_->cell_vertices( cell_id );`
`531`	`540`	`}`
`@@ -572,15 +581,15 @@ namespace geode`
`572`	`581`	`}`
`573`	`582`
`574`	`583`	`template < index_t dimension >`
`575`		`- auto Grid< dimension >::cells(`
`576`		`- const Point< dimension >& query ) const -> CellsAroundVertex`
	`584`	`+ auto Grid< dimension >::cells( const Point< dimension >& query ) const`
	`585`	`+ -> CellsAroundVertex`
`577`	`586`	`{`
`578`	`587`	`return impl_->cells( *this, query );`
`579`	`588`	`}`
`580`	`589`
`581`	`590`	`template < index_t dimension >`
`582`		`- auto Grid< dimension >::cells_around(`
`583`		`- VertexIndices vertex_indices ) const -> CellsAroundVertex`
	`591`	`+ auto Grid< dimension >::cells_around( VertexIndices vertex_indices ) const`
	`592`	`+ -> CellsAroundVertex`
`584`	`593`	`{`
`585`	`594`	`return impl_->cells_around( *this, vertex_indices );`
`586`	`595`	`}`
Original file line number	Diff line number	Diff line change
`@@ -310,14 +310,17 @@ namespace`
`310`	`310`	`std::vector< double > lambdas;`
`311`	`311`	`cell_vertices.reserve( 8 );`
`312`	`312`	`lambdas.reserve( 8 );`
	`313`	`+ geode::Point3D position{ { 0., 0., 0. } };`
`313`	`314`	`for( const auto& vertex_indices :`
`314`	`315`	`grid.cell_vertices( cell_indices ) )`
`315`	`316`	`{`
`316`	`317`	`cell_vertices.push_back( grid.vertex_index( vertex_indices ) );`
`317`	`318`	`lambdas.push_back( 0.125 );`
	`319`	`+ position += grid.grid_point( vertex_indices ) * 0.125;`
`318`	`320`	`}`
`319`	`321`	`solid_attribute_manager.interpolate_attribute_value(`
`320`	`322`	`{ cell_vertices, lambdas }, counter );`
	`323`	`+ builder.set_point( counter, position );`
`321`	`324`	`counter++;`
`322`	`325`	`}`
`323`	`326`	`}`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ namespace`
`149`	`149`	`cell_mesh_vertices[3], additional_vertex_id } );`
`150`	`150`	`created_triangles[2] = builder.create_triangle( { cell_mesh_vertices[3],`
`151`	`151`	`cell_mesh_vertices[2], additional_vertex_id } );`
`152`		`- created_triangles[4] = builder.create_triangle( { cell_mesh_vertices[2],`
	`152`	`+ created_triangles[3] = builder.create_triangle( { cell_mesh_vertices[2],`
`153`	`153`	`cell_mesh_vertices[0], additional_vertex_id } );`
`154`	`154`	`return created_triangles;`
`155`	`155`	`}`
`@@ -210,14 +210,14 @@ namespace`
`210`	`210`	`for( const auto cell_index : geode::Indices{ cells_to_densify } )`
`211`	`211`	`{`
`212`	`212`	`const auto cell_indices =`
`213`		`- grid.cell_indices( cells_to_densify[cell_index] );`
	`213`	`+ grid.cell_indices( cells_to_densify.at( cell_index ) );`
`214`	`214`	`const auto additional_vertex_id =`
`215`	`215`	`grid.nb_grid_vertices() + cell_index;`
`216`	`216`	`for( const auto triangle_id : create_triangles_from_cross_pattern(`
`217`	`217`	`builder, grid, cell_indices, additional_vertex_id ) )`
`218`	`218`	`{`
`219`	`219`	`old2new_mapping.map(`
`220`		`- cells_to_densify[cell_index], triangle_id );`
	`220`	`+ cells_to_densify.at( cell_index ), triangle_id );`
`221`	`221`	`}`
`222`	`222`	`}`
`223`	`223`	`builder.compute_polygon_adjacencies();`
`@@ -232,14 +232,14 @@ namespace`
`232`	`232`	`{`
`233`	`233`	`builder.create_vertices(`
`234`	`234`	`grid.nb_grid_vertices() + cells_to_densify.size() );`
	`235`	`+ auto& surface_attribute_manager = surface.vertex_attribute_manager();`
	`236`	`+ geode::internal::copy_attributes(`
	`237`	`+ grid.grid_vertex_attribute_manager(), surface_attribute_manager );`
`235`	`238`	`for( const auto vertex_id : geode::Range{ grid.nb_grid_vertices() } )`
`236`	`239`	`{`
`237`	`240`	`builder.set_point( vertex_id,`
`238`	`241`	`grid.grid_point( grid.vertex_indices( vertex_id ) ) );`
`239`	`242`	`}`
`240`		`- auto& surface_attribute_manager = surface.vertex_attribute_manager();`
`241`		`- geode::internal::copy_attributes(`
`242`		`- grid.grid_vertex_attribute_manager(), surface_attribute_manager );`
`243`	`243`	`geode::index_t counter{ grid.nb_grid_vertices() };`
`244`	`244`	`for( const auto cell_id : cells_to_densify )`
`245`	`245`	`{`
`@@ -249,14 +249,17 @@ namespace`
`249`	`249`	`std::vector< double > lambdas;`
`250`	`250`	`cell_vertices.reserve( 4 );`
`251`	`251`	`lambdas.reserve( 4 );`
	`252`	`+ geode::Point2D position{ { 0., 0. } };`
`252`	`253`	`for( const auto& vertex_indices :`
`253`	`254`	`grid.cell_vertices( cell_indices ) )`
`254`	`255`	`{`
`255`	`256`	`cell_vertices.push_back( grid.vertex_index( vertex_indices ) );`
`256`	`257`	`lambdas.push_back( 0.25 );`
	`258`	`+ position += grid.grid_point( vertex_indices ) * 0.25;`
`257`	`259`	`}`
`258`	`260`	`surface_attribute_manager.interpolate_attribute_value(`
`259`	`261`	`{ cell_vertices, lambdas }, counter );`
	`262`	`+ builder.set_point( counter, position );`
`260`	`263`	`counter++;`
`261`	`264`	`}`
`262`	`265`	`}`