Merge branch 'next' into fix/serialize-attribute

Author: BotellaA

include/geode/basic/detail/geode_input_impl.h

@@ -68,7 +68,8 @@ namespace geode
                 absl::AsciiStrToLower( extension_from_filename( filename ) );
             OPENGEODE_EXCEPTION( Factory::has_creator( extension ),
                 "Unknown extension: ", extension );
-            return Factory::create( extension, filename );
+            return Factory::create(
+                extension, expand_predefined_folders( filename ) );
         }
 
         template < typename Factory, typename... Args >

include/geode/basic/detail/geode_output_impl.h

@@ -49,7 +49,8 @@ namespace geode
                 absl::AsciiStrToLower( extension_from_filename( filename ) );
             OPENGEODE_EXCEPTION( Factory::has_creator( extension ),
                 "Unknown extension: ", extension );
-            return Factory::create( extension, filename );
+            return Factory::create(
+                extension, expand_predefined_folders( filename ) );
         }
 
         template < typename Factory, typename Object >

include/geode/basic/filename.h

@@ -41,4 +41,7 @@ namespace geode
 
     absl::string_view opengeode_basic_api extension_from_filename(
         absl::string_view filename );
+
+    std::string opengeode_basic_api expand_predefined_folders(
+        absl::string_view path );
 } // namespace geode

include/geode/basic/io.h

@@ -27,6 +27,7 @@
 #include <absl/strings/string_view.h>
 
 #include <geode/basic/common.h>
+#include <geode/basic/filename.h>
 #include <geode/basic/logger.h>
 
 namespace geode
@@ -42,10 +43,13 @@ namespace geode
         }
 
     protected:
-        IOFile( absl::string_view filename ) : filename_( filename ) {}
+        IOFile( absl::string_view filename )
+            : filename_( expand_predefined_folders( filename ) )
+        {
+        }
 
     private:
-        absl::string_view filename_;
+        std::string filename_;
     };
 
     template < typename Factory >

src/geode/basic/filename.cpp

@@ -23,6 +23,8 @@
 
 #include <geode/basic/filename.h>
 
+#include <absl/strings/string_view.h>
+
 #include <ghc/filesystem.hpp>
 
 namespace geode
@@ -55,4 +57,17 @@ namespace geode
     {
         return filename.substr( filename.find_last_of( '.' ) + 1 );
     }
+
+    std::string expand_predefined_folders( absl::string_view path )
+    {
+        if( path.empty() )
+        {
+            return to_string( path );
+        }
+        if( path[0] == '~' )
+        {
+            return absl::StrCat( std::getenv( "HOME" ), path.substr( 1 ) );
+        }
+        return to_string( path );
+    }
 } // namespace geode

src/geode/mesh/helpers/convert_solid_mesh.cpp

@@ -161,8 +161,148 @@ namespace
         }
         return true;
     }
+
+    std::array< geode::index_t, 8 > order_hexahedron_vertices(
+        const geode::index_t hexahedron_id, const geode::SolidMesh3D& solid )
+    {
+        std::array< geode::index_t, 8 > ordered_vertices;
+        const auto first_polyhedron_facet_vertices =
+            solid.polyhedron_facet_vertices( { hexahedron_id, 0 } );
+        ordered_vertices[0] = first_polyhedron_facet_vertices[0];
+        ordered_vertices[1] = first_polyhedron_facet_vertices[3];
+        ordered_vertices[2] = first_polyhedron_facet_vertices[2];
+        ordered_vertices[3] = first_polyhedron_facet_vertices[1];
+        for( const auto f : geode::LRange( 1, 6 ) )
+        {
+            const auto polyhedron_facet_vertices =
+                solid.polyhedron_facet_vertices( { hexahedron_id, f } );
+            const auto v_id_0 =
+                absl::c_find( polyhedron_facet_vertices, ordered_vertices[0] );
+            if( v_id_0 != polyhedron_facet_vertices.end()
+                && absl::c_find(
+                       polyhedron_facet_vertices, ordered_vertices[1] )
+                       != polyhedron_facet_vertices.end() )
+            {
+                const auto index_v_id_0 =
+                    std::distance( polyhedron_facet_vertices.begin(), v_id_0 );
+                ordered_vertices[4] =
+                    polyhedron_facet_vertices[( index_v_id_0 + 1 ) % 4];
+                ordered_vertices[5] =
+                    polyhedron_facet_vertices[( index_v_id_0 + 2 ) % 4];
+                continue;
+            }
+            const auto v_id_2 =
+                absl::c_find( polyhedron_facet_vertices, ordered_vertices[2] );
+            if( v_id_2 != polyhedron_facet_vertices.end()
+                && absl::c_find(
+                       polyhedron_facet_vertices, ordered_vertices[3] )
+                       != polyhedron_facet_vertices.end() )
+            {
+                const auto index_v_id_2 =
+                    std::distance( polyhedron_facet_vertices.begin(), v_id_2 );
+                ordered_vertices[6] =
+                    polyhedron_facet_vertices[( index_v_id_2 + 1 ) % 4];
+                ordered_vertices[7] =
+                    polyhedron_facet_vertices[( index_v_id_2 + 2 ) % 4];
+                continue;
+            }
+        }
+        return ordered_vertices;
+    }
+
+    std::array< geode::index_t, 6 > order_prism_vertices(
+        const geode::index_t prism_id, const geode::SolidMesh3D& solid )
+    {
+        std::array< geode::index_t, 6 > ordered_vertices;
+        geode::index_t already_used_facet{ 0 };
+        for( const auto f : geode::LRange{ 5 } )
+        {
+            if( solid.nb_polyhedron_facet_vertices( { prism_id, f } ) == 3 )
+            {
+                const auto vertices =
+                    solid.polyhedron_facet_vertices( { prism_id, f } );
+                ordered_vertices[0] = vertices[0];
+                ordered_vertices[1] = vertices[2];
+                ordered_vertices[2] = vertices[1];
+                already_used_facet = f;
+                break;
+            }
+        }
+        for( const auto f : geode::LRange{ 5 } )
+        {
+            if( f == already_used_facet )
+            {
+                continue;
+            }
+            const auto facet_vertices =
+                solid.polyhedron_facet_vertices( { prism_id, f } );
+            const auto v_id =
+                absl::c_find( facet_vertices, ordered_vertices[0] );
+            if( v_id == facet_vertices.end()
+                || absl::c_find( facet_vertices, ordered_vertices[2] )
+                       == facet_vertices.end() )
+            {
+                continue;
+            }
+            const auto index_v_id =
+                std::distance( facet_vertices.begin(), v_id );
+            ordered_vertices[3] = facet_vertices[( index_v_id + 1 ) % 4];
+            ordered_vertices[5] = facet_vertices[( index_v_id + 2 ) % 4];
+            break;
+        }
+        for( const auto v : geode::LRange{ 6 } )
+        {
+            const auto solid_vertex =
+                solid.polyhedron_vertex( { prism_id, v } );
+            if( ordered_vertices[1] == solid_vertex
+                || ordered_vertices[2] == solid_vertex
+                || ordered_vertices[3] == solid_vertex
+                || ordered_vertices[5] == solid_vertex
+                || ordered_vertices[0] == solid_vertex )
+            {
+                continue;
+            }
+            ordered_vertices[4] = solid_vertex;
+            break;
+        }
+        return ordered_vertices;
+    }
 } // namespace
 
+std::array< geode::index_t, 5 > order_pyramid_vertices(
+    const geode::index_t pyramid_id, const geode::SolidMesh3D& solid )
+{
+    std::array< geode::index_t, 5 > ordered_vertices;
+
+    for( const auto f : geode::LRange{ 5 } )
+    {
+        if( solid.nb_polyhedron_facet_vertices( { pyramid_id, f } ) == 4 )
+        {
+            const auto vertices =
+                solid.polyhedron_facet_vertices( { pyramid_id, f } );
+            ordered_vertices[0] = vertices[0];
+            ordered_vertices[1] = vertices[3];
+            ordered_vertices[2] = vertices[2];
+            ordered_vertices[3] = vertices[1];
+            break;
+        }
+    }
+    for( const auto v : geode::LRange{ 5 } )
+    {
+        const auto solid_vertex = solid.polyhedron_vertex( { pyramid_id, v } );
+        if( ordered_vertices[1] == solid_vertex
+            || ordered_vertices[2] == solid_vertex
+            || ordered_vertices[3] == solid_vertex
+            || ordered_vertices[0] == solid_vertex )
+        {
+            continue;
+        }
+        ordered_vertices[4] = solid_vertex;
+        break;
+    }
+    return ordered_vertices;
+}
+
 namespace geode
 {
     absl::optional< std::unique_ptr< TetrahedralSolid3D > >
@@ -253,19 +393,20 @@ namespace geode
             }
             else if( vertices.size() == 8 )
             {
-                builder->create_hexahedron(
-                    { vertices[0], vertices[1], vertices[2], vertices[3],
-                        vertices[4], vertices[5], vertices[6], vertices[7] } );
+                const auto ordered_vertices =
+                    order_hexahedron_vertices( p, solid );
+                builder->create_hexahedron( { ordered_vertices } );
             }
             else if( vertices.size() == 5 )
             {
-                builder->create_pyramid( { vertices[0], vertices[1],
-                    vertices[2], vertices[3], vertices[4] } );
+                const auto ordered_vertices =
+                    order_pyramid_vertices( p, solid );
+                builder->create_pyramid( ordered_vertices );
             }
             else if( vertices.size() == 6 )
             {
-                builder->create_prism( { vertices[0], vertices[1], vertices[2],
-                    vertices[3], vertices[4], vertices[5] } );
+                const auto ordered_vertices = order_prism_vertices( p, solid );
+                builder->create_prism( { ordered_vertices } );
             }
         }
         for( const auto p : Range{ solid.nb_polyhedra() } )

src/geode/mesh/helpers/detail/element_identifier.cpp

@@ -81,13 +81,13 @@ namespace geode
             }
             const auto facets_vertices =
                 solid.polyhedron_facets_vertices( polyhedron_id );
-            if( facets_vertices.size() != 8 )
+            if( facets_vertices.size() != 5 )
             {
                 return false;
             }
             for( const auto &facet_vertices : facets_vertices )
             {
-                if( facet_vertices.size() != 3 )
+                if( facet_vertices.size() != 3 && facet_vertices.size() != 4 )
                 {
                     return false;
                 }

tests/mesh/test-convert-solid.cpp

@@ -30,15 +30,19 @@
 
 #include <geode/mesh/builder/regular_grid_solid_builder.h>
 #include <geode/mesh/builder/tetrahedral_solid_builder.h>
+#include <geode/mesh/core/hybrid_solid.h>
 #include <geode/mesh/core/light_regular_grid.h>
 #include <geode/mesh/core/regular_grid_solid.h>
 #include <geode/mesh/core/tetrahedral_solid.h>
 #include <geode/mesh/helpers/detail/split_along_solid_facets.h>
+#include <geode/mesh/io/hybrid_solid_output.h>
 #include <geode/mesh/io/tetrahedral_solid_output.h>
 
 #include <geode/mesh/helpers/convert_solid_mesh.h>
 
-void test()
+// NOLINTBEGIN(*-magic-numbers)
+
+void test_tetrahedral_solid()
 {
     geode::OpenGeodeMeshLibrary::initialize();
     auto mesh_grid = geode::RegularGrid3D::create();
@@ -86,4 +90,75 @@ void test()
     splitter.split_solid_along_facets( {} );
 }
 
-OPENGEODE_TEST( "convert-solid" )
+void test_hybrid_solid()
+{
+    geode::OpenGeodeMeshLibrary::initialize();
+    std::vector< geode::Point3D > hex_points{
+        { { 0, 0, 0 } },
+        { { 1, 0, 0 } },
+        { { 0, 1, 0 } },
+        { { 1, 1, 0 } },
+        { { 0, 0, 1 } },
+        { { 1, 0, 1 } },
+        { { 0, 1, 1 } },
+        { { 1, 1, 1 } },
+    };
+    auto hex = geode::SolidMesh3D::create();
+    auto builder_hex = geode::SolidMeshBuilder3D::create( *hex );
+    for( const auto& point : hex_points )
+    {
+        builder_hex->create_point( point );
+    }
+    builder_hex->create_polyhedron( { 0, 1, 2, 3, 4, 5, 6, 7 },
+        { { 0, 2, 3, 1 }, { 0, 4, 5, 1 }, { 3, 1, 5, 7 }, { 4, 6, 7, 5 },
+            { 2, 3, 7, 6 }, { 0, 2, 6, 4 } } );
+    auto hybrid_solid_hex = geode::convert_solid_mesh_into_hybrid_solid( *hex );
+    geode::save_hybrid_solid(
+        *hybrid_solid_hex.value(), "hybrid_solid_hex.og_hso3d" );
+    std::vector< geode::Point3D > prism_points{
+        { { 0, 0, 0 } },
+        { { 1, 0, 0 } },
+        { { 0, 1, 0 } },
+        { { 0, 0, 1 } },
+        { { 1, 0, 1 } },
+        { { 0, 1, 1 } },
+    };
+    auto prism = geode::SolidMesh3D::create();
+    auto builder_prism = geode::SolidMeshBuilder3D::create( *prism );
+    for( const auto& point : prism_points )
+    {
+        builder_prism->create_point( point );
+    }
+    builder_prism->create_polyhedron(
+        { 0, 1, 2, 3, 4, 5 }, { { 0, 2, 1 }, { 3, 5, 4 }, { 0, 3, 4, 1 },
+                                  { 0, 3, 5, 2 }, { 1, 4, 5, 2 } } );
+    auto hybrid_solid_prism =
+        geode::convert_solid_mesh_into_hybrid_solid( *prism );
+    geode::save_hybrid_solid(
+        *hybrid_solid_prism.value(), "hybrid_solid_prism.og_hso3d" );
+    std::vector< geode::Point3D > pyramid_points{ { { 0, 0, 0 } },
+        { { 1, 0, 0 } }, { { 1, 1, 0 } }, { { 0, 1, 0 } },
+        { { 0.5, 0.5, 1 } } };
+    auto pyramid = geode::SolidMesh3D::create();
+    auto builder_pyramid = geode::SolidMeshBuilder3D::create( *pyramid );
+    for( const auto& point : pyramid_points )
+    {
+        builder_pyramid->create_point( point );
+    }
+    builder_pyramid->create_polyhedron(
+        { 0, 1, 2, 3, 4 }, { { 0, 4, 1 }, { 0, 4, 3 }, { 1, 4, 2 }, { 4, 3, 2 },
+                               { 0, 3, 2, 1 } } );
+    auto hybrid_solid_pyramid =
+        geode::convert_solid_mesh_into_hybrid_solid( *pyramid );
+    geode::save_hybrid_solid(
+        *hybrid_solid_pyramid.value(), "hybrid_solid_pyramid.og_hso3d" );
+}
+
+void test()
+{
+    test_tetrahedral_solid();
+    test_hybrid_solid();
+}
+
+OPENGEODE_TEST( "convert-solid" )
+// NOLINTEND(*-magic-numbers)