fix(RegularGrid): adapt to unstructured convention

Author: BotellaA

include/geode/mesh/core/private/grid_impl.h

@@ -128,30 +128,6 @@ namespace geode
                 return vertex_id;
             }
 
-            absl::optional< index_t > cell_adjacent(
-                const RegularGrid< dimension >& grid,
-                index_t element,
-                local_index_t facet ) const
-            {
-                const auto cell = cell_indices( grid, element );
-                const index_t direction = static_cast< index_t >( facet / 2 );
-                if( ( facet & 1 ) == 0 /* modulo 2 */ )
-                {
-                    if( const auto adj = grid.previous_cell( cell, direction ) )
-                    {
-                        return grid.cell_index( adj.value() );
-                    }
-                }
-                else
-                {
-                    if( const auto adj = grid.next_cell( cell, direction ) )
-                    {
-                        return grid.cell_index( adj.value() );
-                    }
-                }
-                return absl::nullopt;
-            }
-
         protected:
             void do_update_origin( RegularGrid< dimension >& grid,
                 PointsImpl< dimension >& impl,

include/geode/mesh/helpers/private/regular_grid_shape_function.h

@@ -29,22 +29,17 @@
 namespace geode
 {
     FORWARD_DECLARATION_DIMENSION_CLASS( Point );
-    FORWARD_DECLARATION_DIMENSION_CLASS( RegularGrid );
+    FORWARD_DECLARATION_DIMENSION_CLASS( Grid );
 } // namespace geode
 
 namespace geode
 {
     namespace detail
     {
         template < index_t dimension >
-        double shape_function_value( const RegularGrid< dimension >& grid,
+        double shape_function_value( const Grid< dimension >& grid,
             const GridCellIndices< dimension >& cell_id,
             local_index_t node_id,
             const Point< dimension >& point );
-
-        template < index_t dimension >
-        GridVertexIndices< dimension > cell_node_index(
-            const GridCellIndices< dimension >& cell_id,
-            local_index_t node_id );
     } // namespace detail
 } // namespace geode

src/geode/mesh/core/geode_regular_grid_solid.cpp

@@ -89,6 +89,30 @@ namespace geode
             return { facet.polyhedron_id, vertex };
         }
 
+        absl::optional< index_t > cell_adjacent( const RegularGrid3D& grid,
+            const PolyhedronFacet& polyhedron_facet ) const
+        {
+            const auto cell =
+                cell_indices( grid, polyhedron_facet.polyhedron_id );
+            const index_t direction =
+                static_cast< index_t >( polyhedron_facet.facet_id / 2 );
+            if( ( polyhedron_facet.facet_id & 1 ) == 0 /* modulo 2 */ )
+            {
+                if( const auto adj = grid.previous_cell( cell, direction ) )
+                {
+                    return grid.cell_index( adj.value() );
+                }
+            }
+            else
+            {
+                if( const auto adj = grid.next_cell( cell, direction ) )
+                {
+                    return grid.cell_index( adj.value() );
+                }
+            }
+            return absl::nullopt;
+        }
+
     private:
         Impl() = default;
 
@@ -169,8 +193,7 @@ namespace geode
         OpenGeodeRegularGrid< 3 >::get_polyhedron_adjacent(
             const PolyhedronFacet& polyhedron_facet ) const
     {
-        return impl_->cell_adjacent(
-            *this, polyhedron_facet.polyhedron_id, polyhedron_facet.facet_id );
+        return impl_->cell_adjacent( *this, polyhedron_facet );
     }
 
     void OpenGeodeRegularGrid< 3 >::update_origin(

src/geode/mesh/core/geode_regular_grid_surface.cpp

@@ -38,8 +38,11 @@
 namespace
 {
     static constexpr std::array< std::array< geode::local_index_t, 2 >, 4 >
-        cell_vertices_translations{ { { 0, 0 }, { 1, 0 }, { 0, 1 },
-            { 1, 1 } } };
+        cell_vertices_translations{ { { 0, 0 }, { 1, 0 }, { 1, 1 },
+            { 0, 1 } } };
+    static constexpr std::array< std::pair< bool, geode::index_t >, 4 >
+        cell_adjacent_directions{ { { false, 1 }, { true, 0 }, { true, 1 },
+            { false, 0 } } };
 } // namespace
 
 namespace geode
@@ -72,6 +75,29 @@ namespace geode
             return vertex_index( grid, cell_vertex );
         }
 
+        absl::optional< index_t > cell_adjacent(
+            const RegularGrid2D& grid, const PolygonEdge& edge ) const
+        {
+            const auto cell = cell_indices( grid, edge.polygon_id );
+            const auto& direction = cell_adjacent_directions[edge.edge_id];
+            if( direction.first )
+            {
+                if( const auto adj = grid.next_cell( cell, direction.second ) )
+                {
+                    return grid.cell_index( adj.value() );
+                }
+            }
+            else
+            {
+                if( const auto adj =
+                        grid.previous_cell( cell, direction.second ) )
+                {
+                    return grid.cell_index( adj.value() );
+                }
+            }
+            return absl::nullopt;
+        }
+
     private:
         Impl() = default;
 
@@ -145,7 +171,7 @@ namespace geode
     absl::optional< index_t > OpenGeodeRegularGrid< 2 >::get_polygon_adjacent(
         const PolygonEdge& edge ) const
     {
-        return impl_->cell_adjacent( *this, edge.polygon_id, edge.edge_id );
+        return impl_->cell_adjacent( *this, edge );
     }
 
     void OpenGeodeRegularGrid< 2 >::update_origin(

src/geode/mesh/helpers/private/regular_grid_shape_function.cpp

@@ -25,8 +25,7 @@
 
 #include <geode/geometry/point.h>
 
-#include <geode/mesh/core/regular_grid_solid.h>
-#include <geode/mesh/core/regular_grid_surface.h>
+#include <geode/mesh/core/grid.h>
 
 namespace
 {
@@ -41,7 +40,7 @@ namespace
 
     template < geode::index_t dimension >
     geode::Point< dimension > local_point_coordinates(
-        const geode::RegularGrid< dimension >& grid,
+        const geode::Grid< dimension >& grid,
         const geode::Point< dimension >& point,
         const geode::GridCellIndices< dimension >& cell_id )
     {
@@ -69,7 +68,7 @@ namespace geode
     namespace detail
     {
         template < index_t dimension >
-        double shape_function_value( const RegularGrid< dimension >& grid,
+        double shape_function_value( const Grid< dimension >& grid,
             const GridCellIndices< dimension >& cell_id,
             local_index_t node_id,
             const Point< dimension >& point )
@@ -91,35 +90,16 @@ namespace geode
             return shape_function_value;
         }
 
-        template < index_t dimension >
-        GridVertexIndices< dimension > cell_node_index(
-            const GridCellIndices< dimension >& cell_id, local_index_t node_id )
-        {
-            auto node_index = cell_id;
-            for( const auto d : LRange{ dimension } )
-            {
-                if( !node_is_on_axis_origin< dimension >( node_id, d ) )
-                {
-                    node_index[d] += 1;
-                }
-            }
-            return node_index;
-        }
-
         template double opengeode_mesh_api shape_function_value< 2 >(
-            const RegularGrid< 2 >& grid,
+            const Grid< 2 >& grid,
             const GridCellIndices< 2 >& cell_id,
             local_index_t node_id,
             const Point< 2 >& point );
-        template GridVertexIndices< 2 > opengeode_mesh_api cell_node_index< 2 >(
-            const GridCellIndices< 2 >& cell_id, local_index_t node_id );
 
         template double opengeode_mesh_api shape_function_value< 3 >(
-            const RegularGrid< 3 >& grid,
+            const Grid< 3 >& grid,
             const GridCellIndices< 3 >& cell_id,
             local_index_t node_id,
             const Point< 3 >& point );
-        template GridVertexIndices< 3 > opengeode_mesh_api cell_node_index< 3 >(
-            const GridCellIndices< 3 >& cell_id, local_index_t node_id );
     } // namespace detail
 } // namespace geode

src/geode/mesh/helpers/regular_grid_point_function.cpp

@@ -102,7 +102,7 @@ namespace geode
             for( const auto node_id : LRange{ grid_.nb_cell_vertices() } )
             {
                 point_value += function_attribute_->value( grid_.vertex_index(
-                                   detail::cell_node_index< dimension >(
+                                   grid_.cell_vertex_indices(
                                        grid_cell_indices, node_id ) ) )
                                * detail::shape_function_value< dimension >(
                                    grid_, grid_cell_indices, node_id, point );

src/geode/mesh/helpers/regular_grid_scalar_function.cpp

@@ -101,7 +101,7 @@ namespace geode
                 point_value += detail::shape_function_value< dimension >(
                                    grid_, grid_cell_indices, node_id, point )
                                * function_attribute_->value( grid_.vertex_index(
-                                   detail::cell_node_index< dimension >(
+                                   grid_.cell_vertex_indices(
                                        grid_cell_indices, node_id ) ) );
             }
             return point_value;

tests/mesh/test-regular-grid.cpp

@@ -30,7 +30,9 @@
 #include <geode/geometry/point.h>
 
 #include <geode/mesh/builder/regular_grid_solid_builder.h>
+#include <geode/mesh/builder/regular_grid_surface_builder.h>
 #include <geode/mesh/core/regular_grid_solid.h>
+#include <geode/mesh/core/regular_grid_surface.h>
 #include <geode/mesh/io/regular_grid_input.h>
 #include <geode/mesh/io/regular_grid_output.h>
 
@@ -392,6 +394,20 @@ void test_io( const geode::RegularGrid3D& grid, absl::string_view filename )
     geode::load_regular_grid< 3 >( filename );
 }
 
+void test_adjacencies2D()
+{
+    auto grid = geode::RegularGrid2D::create();
+    auto builder = geode::RegularGridBuilder2D::create( *grid );
+    builder->initialize_grid( { { 0., 0. } }, { 10, 10 }, 1 );
+    for( const auto p : geode::Range{ grid->nb_polygons() } )
+    {
+        for( const auto ee : geode::LRange{ grid->nb_polygon_edges( p ) } )
+        {
+            grid->polygon_adjacent_edge( { p, ee } );
+        }
+    }
+}
+
 void test()
 {
     auto grid = geode::RegularGrid3D::create();
@@ -408,6 +424,7 @@ void test()
     test_closest_vertex( *grid );
     test_clone( *grid );
     test_io( *grid, absl::StrCat( "test.", grid->native_extension() ) );
+    test_adjacencies2D();
 }
 
 OPENGEODE_TEST( "regular-grid" )