fix(SplitAlongSurfaceMeshBorders): Fixed issue with wrong adjacencies being computed.

Author: MelchiorSchuh

include/geode/mesh/core/solid_edges.hpp

@@ -71,7 +71,7 @@ namespace geode
 
         /*!
          * Get the index of edge corresponding to given vertices
-         * @param[in] vertices Ordered vertex indices
+         * @param[in] vertices Unordered vertex indices
          */
         [[nodiscard]] std::optional< index_t > edge_from_vertices(
             const std::array< index_t, 2 >& vertices ) const;

src/geode/mesh/core/surface_mesh.cpp

@@ -676,14 +676,15 @@ namespace geode
         const auto adj_vertices = polygon_vertices( polygon_adj_id );
         const auto nb_edges = adj_vertices.size();
         std::vector< PolygonEdge > failed_edges;
-        for( const auto e : LRange{ nb_edges } )
+        for( const auto edge_id : LRange{ nb_edges } )
         {
-            const PolygonEdge polygon_adj_edge{ polygon_adj_id, e };
-            if( v0 == adj_vertices[e] )
+            const PolygonEdge polygon_adj_edge{ polygon_adj_id, edge_id };
+            if( v0 == adj_vertices[edge_id] )
             {
-                const auto enext = e == nb_edges - 1
-                                       ? 0u
-                                       : static_cast< local_index_t >( e + 1 );
+                const auto enext =
+                    edge_id == nb_edges - 1
+                        ? 0u
+                        : static_cast< local_index_t >( edge_id + 1 );
                 if( v1 == adj_vertices[enext] )
                 {
                     if( polygon_adjacent( polygon_adj_edge )
@@ -694,11 +695,12 @@ namespace geode
                     failed_edges.emplace_back( polygon_adj_edge );
                 }
             }
-            else if( v1 == adj_vertices[e] )
+            else if( v1 == adj_vertices[edge_id] )
             {
-                const auto enext = e == nb_edges - 1
-                                       ? 0u
-                                       : static_cast< local_index_t >( e + 1 );
+                const auto enext =
+                    edge_id == nb_edges - 1
+                        ? 0u
+                        : static_cast< local_index_t >( edge_id + 1 );
                 if( v0 == adj_vertices[enext] )
                 {
                     if( polygon_adjacent( polygon_adj_edge )

src/geode/model/helpers/component_mesh_edges.cpp

@@ -163,7 +163,6 @@ namespace geode
                 {
                     if( auto edge = mesh.polygon_edge_from_vertices(
                             pair[0], pair[1] ) )
-
                     {
                         edges[surface.id()].emplace_back(
                             std::move( edge.value() ) );

src/geode/model/helpers/detail/split_along_surface_mesh_borders.cpp

@@ -207,10 +207,10 @@ namespace geode
                 for( const auto& line : model_.internal_lines( surface ) )
                 {
                     const auto& mesh = line.mesh();
-                    for( const auto e : Range{ mesh.nb_edges() } )
+                    for( const auto edge_id : Range{ mesh.nb_edges() } )
                     {
                         const auto model_edges =
-                            component_mesh_edges( model_, line, e );
+                            component_mesh_edges( model_, line, edge_id );
                         const auto& surface_edges = model_edges.surface_edges;
                         const auto it = surface_edges.find( surface.id() );
                         if( it == surface_edges.end() )
@@ -219,24 +219,12 @@ namespace geode
                         }
                         for( auto& edge : it->second )
                         {
-                            const auto& surface_mesh = surface.mesh();
-                            const auto& edge_vertices =
-                                surface_mesh.polygon_edge_vertices( edge );
-                            edges.emplace_back(
-                                surface_mesh
-                                    .polygon_edge_from_vertices(
-                                        edge_vertices[0], edge_vertices[1] )
-                                    .value() );
-                            if( surface_mesh
-                                    .polygon_edge_from_vertices(
-                                        edge_vertices[1], edge_vertices[0] )
-                                    .has_value() )
+                            edges.push_back( edge );
+                            if( const auto adj_edge =
+                                    surface.mesh().polygon_adjacent_edge(
+                                        edge ) )
                             {
-                                edges.emplace_back(
-                                    surface_mesh
-                                        .polygon_edge_from_vertices(
-                                            edge_vertices[1], edge_vertices[0] )
-                                        .value() );
+                                edges.push_back( adj_edge.value() );
                             }
                         }
                     }