fix(VTK): implement is_loadable

BotellaA · BotellaA · commit 781f9ec9f142 · 2025-06-17T09:16:26.000+02:00
diff --git a/include/geode/io/mesh/detail/vti_grid_input.hpp b/include/geode/io/mesh/detail/vti_grid_input.hpp
@@ -67,25 +67,6 @@ namespace geode
                 std::array< Vector< dimension >, dimension > cell_directions;
             };
 
-            static bool is_loadable( std::string_view filename )
-            {
-                std::ifstream file{ to_string( filename ) };
-                OPENGEODE_EXCEPTION( file.good(),
-                    "[VTIGridInput::is_loadable] Error while opening file: ",
-                    filename );
-                pugi::xml_document document;
-                const auto status =
-                    document.load_file( to_string( filename ).c_str() );
-                OPENGEODE_EXCEPTION( status,
-                    "[VTIGridInput::is_loadable] Error ", status.description(),
-                    " while parsing file: ", filename );
-                const auto node =
-                    document.child( "VTKFile" ).child( "ImageData" );
-                const auto grid_attributes = read_grid_attributes( node );
-                const auto nb_cells_3d = grid_attributes.cells_number[2];
-                return dimension == 2 ? nb_cells_3d == 0 : nb_cells_3d > 0;
-            }
-
         protected:
             static GridAttributes read_grid_attributes(
                 const pugi::xml_node& vtk_object )
@@ -158,6 +139,14 @@ namespace geode
                 }
             }
 
+            bool is_vtk_object_loadable(
+                const pugi::xml_node& vtk_object ) const final
+            {
+                const auto grid_attributes = read_grid_attributes( vtk_object );
+                const auto nb_cells_3d = grid_attributes.cells_number[2];
+                return dimension == 2 ? nb_cells_3d == 0 : nb_cells_3d > 0;
+            }
+
         protected:
             virtual void build_grid( const pugi::xml_node& vtk_object ) = 0;
         };
diff --git a/include/geode/io/mesh/detail/vtk_input.hpp b/include/geode/io/mesh/detail/vtk_input.hpp
@@ -51,15 +51,27 @@ namespace geode
 
             std::unique_ptr< Mesh > read_file()
             {
-                read_root_attributes();
-                read_appended_data();
+                read_common_data();
                 for( const auto& vtk_object : root_.children( type_ ) )
                 {
                     read_vtk_object( vtk_object );
                 }
                 return std::move( mesh_ );
             }
 
+            bool is_loadable()
+            {
+                read_common_data();
+                for( const auto& vtk_object : root_.children( type_ ) )
+                {
+                    if( is_vtk_object_loadable( vtk_object ) )
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
         protected:
             VTKInputImpl( std::string_view filename, const char* type )
                 : file_{ to_string( filename ) }, type_{ type }
@@ -73,6 +85,15 @@ namespace geode
                 root_ = document_.child( "VTKFile" );
             }
 
+            virtual bool is_vtk_object_loadable(
+                const pugi::xml_node& vtk_object ) const = 0;
+
+            void read_common_data()
+            {
+                read_root_attributes();
+                read_appended_data();
+            }
+
             void initialize_mesh( std::unique_ptr< Mesh >&& mesh )
             {
                 mesh_ = std::move( mesh );
@@ -103,7 +124,7 @@ namespace geode
 
             template < typename T >
             std::vector< T > read_integer_data_array(
-                const pugi::xml_node& data )
+                const pugi::xml_node& data ) const
             {
                 const auto format = data.attribute( "format" ).value();
                 if( match( format, "appended" ) )
@@ -125,7 +146,8 @@ namespace geode
             }
 
             template < typename T >
-            std::vector< T > read_uint8_data_array( const pugi::xml_node& data )
+            std::vector< T > read_uint8_data_array(
+                const pugi::xml_node& data ) const
             {
                 const auto format = data.attribute( "format" ).value();
                 if( match( format, "appended" ) )
@@ -147,7 +169,8 @@ namespace geode
             }
 
             template < typename T >
-            std::vector< T > read_float_data_array( const pugi::xml_node& data )
+            std::vector< T > read_float_data_array(
+                const pugi::xml_node& data ) const
             {
                 const auto format = data.attribute( "format" ).value();
                 if( match( format, "appended" ) )
@@ -305,14 +328,15 @@ namespace geode
                 }
             }
 
-            std::string_view read_appended_data( const pugi::xml_node& data )
+            std::string_view read_appended_data(
+                const pugi::xml_node& data ) const
             {
                 const auto offset = data.attribute( "offset" ).as_uint();
                 return appended_data_.substr( offset );
             }
 
             template < typename T >
-            std::vector< T > decode( std::string_view input )
+            std::vector< T > decode( std::string_view input ) const
             {
                 if( !compressed_ )
                 {
@@ -410,7 +434,7 @@ namespace geode
 
             template < typename T, typename UInt >
             std::vector< T > templated_decode_uncompressed(
-                std::string_view input )
+                std::string_view input ) const
             {
                 const auto nb_chars = nb_char_needed< UInt >( 1 );
                 const auto nb_bytes_input = input.substr( 0, nb_chars );
@@ -448,7 +472,7 @@ namespace geode
             }
 
             template < typename T, typename UInt >
-            std::vector< T > templated_decode( std::string_view input )
+            std::vector< T > templated_decode( std::string_view input ) const
             {
                 const auto fixed_header_length = nb_char_needed< UInt >( 3 );
                 auto fixed_header = input.substr( 0, fixed_header_length );
@@ -540,7 +564,7 @@ namespace geode
 
             template < typename T >
             std::vector< T > read_ascii_data_array( std::string_view data,
-                bool ( *string_convert )( std::string_view, T* ) )
+                bool ( *string_convert )( std::string_view, T* ) ) const
             {
                 std::vector< T > results;
                 for( auto string : absl::StrSplit( data, ' ' ) )
@@ -556,14 +580,14 @@ namespace geode
 
             template < typename T >
             std::vector< T > read_ascii_integer_data_array(
-                std::string_view data )
+                std::string_view data ) const
             {
                 return read_ascii_data_array< T >( data, absl::SimpleAtoi );
             }
 
             template < typename T >
             std::vector< T > read_ascii_uint8_data_array(
-                std::string_view data )
+                std::string_view data ) const
             {
                 std::vector< T > results;
                 for( auto string : absl::StrSplit( data, ' ' ) )
@@ -576,7 +600,7 @@ namespace geode
 
             template < typename T >
             std::vector< T > read_ascii_float_data_array(
-                std::string_view data )
+                std::string_view data ) const
             {
                 return read_ascii_data_array< T >( data, absl::SimpleAtod );
             }
diff --git a/include/geode/io/mesh/detail/vtk_mesh_input.hpp b/include/geode/io/mesh/detail/vtk_mesh_input.hpp
@@ -66,7 +66,7 @@ namespace geode
 
             absl::FixedArray< std::vector< index_t > > get_cell_vertices(
                 absl::Span< const int64_t > connectivity,
-                absl::Span< const int64_t > offsets )
+                absl::Span< const int64_t > offsets ) const
             {
                 absl::FixedArray< std::vector< index_t > > cell_vertices(
                     offsets.size() );
@@ -96,6 +96,19 @@ namespace geode
                 }
             }
 
+            bool is_vtk_object_loadable(
+                const pugi::xml_node& vtk_object ) const final
+            {
+                for( const auto& piece : vtk_object.children( "Piece" ) )
+                {
+                    if( is_vtk_cells_loadable( piece ) )
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
             void read_vtk_points( const pugi::xml_node& piece )
             {
                 const auto nb_points =
@@ -107,6 +120,9 @@ namespace geode
 
             virtual void read_vtk_cells( const pugi::xml_node& piece ) = 0;
 
+            virtual bool is_vtk_cells_loadable(
+                const pugi::xml_node& piece ) const = 0;
+
             index_t build_points(
                 const pugi::xml_node& piece, index_t nb_points )
             {
diff --git a/include/geode/io/mesh/detail/vtu_hybrid_input.hpp b/include/geode/io/mesh/detail/vtu_hybrid_input.hpp
@@ -50,6 +50,8 @@ namespace geode
             }
 
             std::unique_ptr< HybridSolid3D > read( const MeshImpl& impl ) final;
+
+            bool is_loadable() const final;
         };
     } // namespace detail
 } // namespace geode
diff --git a/include/geode/io/mesh/detail/vtu_input_impl.hpp b/include/geode/io/mesh/detail/vtu_input_impl.hpp
@@ -41,7 +41,8 @@ namespace geode
 
             std::tuple< absl::FixedArray< std::vector< index_t > >,
                 std::vector< uint8_t > >
-                read_cells( const pugi::xml_node& piece, index_t nb_cells )
+                read_cells(
+                    const pugi::xml_node& piece, index_t nb_cells ) const
             {
                 std::vector< int64_t > offsets_values;
                 std::vector< int64_t > connectivity_values;
diff --git a/include/geode/io/mesh/detail/vtu_polygonal_input.hpp b/include/geode/io/mesh/detail/vtu_polygonal_input.hpp
@@ -51,6 +51,8 @@ namespace geode
 
             std::unique_ptr< PolygonalSurface3D > read(
                 const MeshImpl& impl ) final;
+
+            bool is_loadable() const final;
         };
     } // namespace detail
 } // namespace geode
diff --git a/include/geode/io/mesh/detail/vtu_polyhedral_input.hpp b/include/geode/io/mesh/detail/vtu_polyhedral_input.hpp
@@ -51,6 +51,8 @@ namespace geode
 
             std::unique_ptr< PolyhedralSolid3D > read(
                 const MeshImpl& impl ) final;
+
+            bool is_loadable() const final;
         };
     } // namespace detail
 } // namespace geode
diff --git a/include/geode/io/mesh/detail/vtu_solid_input.hpp b/include/geode/io/mesh/detail/vtu_solid_input.hpp
@@ -98,6 +98,22 @@ namespace geode
                     this->mesh().polyhedron_attribute_manager() );
             }
 
+            bool is_vtk_cells_loadable(
+                const pugi::xml_node& piece ) const override
+            {
+                const auto nb_polyhedra =
+                    this->read_attribute( piece, "NumberOfCells" );
+                const auto [_, types] = this->read_cells( piece, nb_polyhedra );
+                for( const auto& type : types )
+                {
+                    if( elements_.contains( type ) )
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
             index_t build_polyhedra(
                 const pugi::xml_node& piece, index_t nb_polyhedra )
             {
diff --git a/include/geode/io/mesh/detail/vtu_surface_input.hpp b/include/geode/io/mesh/detail/vtu_surface_input.hpp
@@ -61,6 +61,22 @@ namespace geode
                     this->mesh().polygon_attribute_manager() );
             }
 
+            bool is_vtk_cells_loadable(
+                const pugi::xml_node& piece ) const override
+            {
+                const auto nb_polygons =
+                    this->read_attribute( piece, "NumberOfCells" );
+                const auto [_, types] = this->read_cells( piece, nb_polygons );
+                for( const auto& type : types )
+                {
+                    if( elements_.contains( type ) )
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
             index_t build_polygons(
                 const pugi::xml_node& piece, index_t nb_polygons )
             {
diff --git a/include/geode/io/mesh/detail/vtu_tetrahedral_input.hpp b/include/geode/io/mesh/detail/vtu_tetrahedral_input.hpp
@@ -51,6 +51,8 @@ namespace geode
 
             std::unique_ptr< TetrahedralSolid3D > read(
                 const MeshImpl& impl ) final;
+
+            bool is_loadable() const final;
         };
     } // namespace detail
 } // namespace geode
diff --git a/include/geode/io/mesh/detail/vtu_triangulated_input.hpp b/include/geode/io/mesh/detail/vtu_triangulated_input.hpp
@@ -51,6 +51,8 @@ namespace geode
 
             std::unique_ptr< TriangulatedSurface3D > read(
                 const MeshImpl& impl ) final;
+
+            bool is_loadable() const final;
         };
     } // namespace detail
 } // namespace geode
diff --git a/src/geode/io/mesh/vti_light_regular_grid_input.cpp b/src/geode/io/mesh/vti_light_regular_grid_input.cpp
@@ -77,8 +77,10 @@ namespace geode
         template < index_t dimension >
         bool VTILightRegularGridInput< dimension >::is_loadable() const
         {
-            return VTIGridInputImpl< LightRegularGrid< dimension > >::
-                is_loadable( this->filename() );
+            VTILightRegularGridInputImpl< dimension > reader{
+                this->filename()
+            };
+            return reader.is_loadable();
         }
 
         template class VTILightRegularGridInput< 2 >;
diff --git a/src/geode/io/mesh/vti_regular_grid_input.cpp b/src/geode/io/mesh/vti_regular_grid_input.cpp
@@ -30,6 +30,7 @@
 
 #include <geode/mesh/builder/regular_grid_solid_builder.hpp>
 #include <geode/mesh/builder/regular_grid_surface_builder.hpp>
+#include <geode/mesh/core/mesh_factory.hpp>
 #include <geode/mesh/core/regular_grid_solid.hpp>
 #include <geode/mesh/core/regular_grid_surface.hpp>
 
@@ -80,8 +81,10 @@ namespace geode
         template < index_t dimension >
         bool VTIRegularGridInput< dimension >::is_loadable() const
         {
-            return VTIGridInputImpl< RegularGrid< dimension > >::is_loadable(
-                this->filename() );
+            VTIRegularGridInputImpl< dimension > reader{ this->filename(),
+                MeshFactory::default_impl(
+                    RegularGrid< dimension >::type_name_static() ) };
+            return reader.is_loadable();
         }
 
         template class VTIRegularGridInput< 2 >;
diff --git a/src/geode/io/mesh/vtp_input.cpp b/src/geode/io/mesh/vtp_input.cpp
@@ -50,8 +50,15 @@ namespace
                 this->mesh().polygon_attribute_manager() );
         }
 
+        bool is_vtk_cells_loadable( const pugi::xml_node& piece ) const override
+        {
+            const auto nb_polygons = read_attribute( piece, "NumberOfPolys" );
+            read_polygons( piece, nb_polygons );
+            return true;
+        }
+
         absl::FixedArray< std::vector< geode::index_t > > read_polygons(
-            const pugi::xml_node& piece, geode::index_t nb_polygons )
+            const pugi::xml_node& piece, geode::index_t nb_polygons ) const
         {
             std::vector< int64_t > offsets_values;
             std::vector< int64_t > connectivity_values;
diff --git a/src/geode/io/mesh/vtu_hybrid_input.cpp b/src/geode/io/mesh/vtu_hybrid_input.cpp
diff --git a/src/geode/io/mesh/vtu_polygonal_input.cpp b/src/geode/io/mesh/vtu_polygonal_input.cpp
diff --git a/src/geode/io/mesh/vtu_polyhedral_input.cpp b/src/geode/io/mesh/vtu_polyhedral_input.cpp
diff --git a/src/geode/io/mesh/vtu_tetrahedral_input.cpp b/src/geode/io/mesh/vtu_tetrahedral_input.cpp
diff --git a/src/geode/io/mesh/vtu_triangulated_input.cpp b/src/geode/io/mesh/vtu_triangulated_input.cpp
diff --git a/tests/mesh/test-vtu.cpp b/tests/mesh/test-vtu.cpp

Original file line number	Diff line number	Diff line change
`@@ -51,15 +51,27 @@ namespace geode`
`51`	`51`
`52`	`52`	`std::unique_ptr< Mesh > read_file()`
`53`	`53`	`{`
`54`		`- read_root_attributes();`
`55`		`- read_appended_data();`
	`54`	`+ read_common_data();`
`56`	`55`	`for( const auto& vtk_object : root_.children( type_ ) )`
`57`	`56`	`{`
`58`	`57`	`read_vtk_object( vtk_object );`
`59`	`58`	`}`
`60`	`59`	`return std::move( mesh_ );`
`61`	`60`	`}`
`62`	`61`
	`62`	`+ bool is_loadable()`
	`63`	`+ {`
	`64`	`+ read_common_data();`
	`65`	`+ for( const auto& vtk_object : root_.children( type_ ) )`
	`66`	`+ {`
	`67`	`+ if( is_vtk_object_loadable( vtk_object ) )`
	`68`	`+ {`
	`69`	`+ return true;`
	`70`	`+ }`
	`71`	`+ }`
	`72`	`+ return false;`
	`73`	`+ }`
	`74`	`+`
`63`	`75`	`protected:`
`64`	`76`	`VTKInputImpl( std::string_view filename, const char* type )`
`65`	`77`	`: file_{ to_string( filename ) }, type_{ type }`
`@@ -73,6 +85,15 @@ namespace geode`
`73`	`85`	`root_ = document_.child( "VTKFile" );`
`74`	`86`	`}`
`75`	`87`
	`88`	`+ virtual bool is_vtk_object_loadable(`
	`89`	`+ const pugi::xml_node& vtk_object ) const = 0;`
	`90`	`+`
	`91`	`+ void read_common_data()`
	`92`	`+ {`
	`93`	`+ read_root_attributes();`
	`94`	`+ read_appended_data();`
	`95`	`+ }`
	`96`	`+`
`76`	`97`	`void initialize_mesh( std::unique_ptr< Mesh >&& mesh )`
`77`	`98`	`{`
`78`	`99`	`mesh_ = std::move( mesh );`
`@@ -103,7 +124,7 @@ namespace geode`
`103`	`124`
`104`	`125`	`template < typename T >`
`105`	`126`	`std::vector< T > read_integer_data_array(`
`106`		`- const pugi::xml_node& data )`
	`127`	`+ const pugi::xml_node& data ) const`
`107`	`128`	`{`
`108`	`129`	`const auto format = data.attribute( "format" ).value();`
`109`	`130`	`if( match( format, "appended" ) )`
`@@ -125,7 +146,8 @@ namespace geode`
`125`	`146`	`}`
`126`	`147`
`127`	`148`	`template < typename T >`
`128`		`- std::vector< T > read_uint8_data_array( const pugi::xml_node& data )`
	`149`	`+ std::vector< T > read_uint8_data_array(`
	`150`	`+ const pugi::xml_node& data ) const`
`129`	`151`	`{`
`130`	`152`	`const auto format = data.attribute( "format" ).value();`
`131`	`153`	`if( match( format, "appended" ) )`
`@@ -147,7 +169,8 @@ namespace geode`
`147`	`169`	`}`
`148`	`170`
`149`	`171`	`template < typename T >`
`150`		`- std::vector< T > read_float_data_array( const pugi::xml_node& data )`
	`172`	`+ std::vector< T > read_float_data_array(`
	`173`	`+ const pugi::xml_node& data ) const`
`151`	`174`	`{`
`152`	`175`	`const auto format = data.attribute( "format" ).value();`
`153`	`176`	`if( match( format, "appended" ) )`
`@@ -305,14 +328,15 @@ namespace geode`
`305`	`328`	`}`
`306`	`329`	`}`
`307`	`330`
`308`		`- std::string_view read_appended_data( const pugi::xml_node& data )`
	`331`	`+ std::string_view read_appended_data(`
	`332`	`+ const pugi::xml_node& data ) const`
`309`	`333`	`{`
`310`	`334`	`const auto offset = data.attribute( "offset" ).as_uint();`
`311`	`335`	`return appended_data_.substr( offset );`
`312`	`336`	`}`
`313`	`337`
`314`	`338`	`template < typename T >`
`315`		`- std::vector< T > decode( std::string_view input )`
	`339`	`+ std::vector< T > decode( std::string_view input ) const`
`316`	`340`	`{`
`317`	`341`	`if( !compressed_ )`
`318`	`342`	`{`
`@@ -410,7 +434,7 @@ namespace geode`
`410`	`434`
`411`	`435`	`template < typename T, typename UInt >`
`412`	`436`	`std::vector< T > templated_decode_uncompressed(`
`413`		`- std::string_view input )`
	`437`	`+ std::string_view input ) const`
`414`	`438`	`{`
`415`	`439`	`const auto nb_chars = nb_char_needed< UInt >( 1 );`
`416`	`440`	`const auto nb_bytes_input = input.substr( 0, nb_chars );`
`@@ -448,7 +472,7 @@ namespace geode`
`448`	`472`	`}`
`449`	`473`
`450`	`474`	`template < typename T, typename UInt >`
`451`		`- std::vector< T > templated_decode( std::string_view input )`
	`475`	`+ std::vector< T > templated_decode( std::string_view input ) const`
`452`	`476`	`{`
`453`	`477`	`const auto fixed_header_length = nb_char_needed< UInt >( 3 );`
`454`	`478`	`auto fixed_header = input.substr( 0, fixed_header_length );`
`@@ -540,7 +564,7 @@ namespace geode`
`540`	`564`
`541`	`565`	`template < typename T >`
`542`	`566`	`std::vector< T > read_ascii_data_array( std::string_view data,`
`543`		`- bool ( string_convert )( std::string_view, T ) )`
	`567`	`+ bool ( string_convert )( std::string_view, T ) ) const`
`544`	`568`	`{`
`545`	`569`	`std::vector< T > results;`
`546`	`570`	`for( auto string : absl::StrSplit( data, ' ' ) )`
`@@ -556,14 +580,14 @@ namespace geode`
`556`	`580`
`557`	`581`	`template < typename T >`
`558`	`582`	`std::vector< T > read_ascii_integer_data_array(`
`559`		`- std::string_view data )`
	`583`	`+ std::string_view data ) const`
`560`	`584`	`{`
`561`	`585`	`return read_ascii_data_array< T >( data, absl::SimpleAtoi );`
`562`	`586`	`}`
`563`	`587`
`564`	`588`	`template < typename T >`
`565`	`589`	`std::vector< T > read_ascii_uint8_data_array(`
`566`		`- std::string_view data )`
	`590`	`+ std::string_view data ) const`
`567`	`591`	`{`
`568`	`592`	`std::vector< T > results;`
`569`	`593`	`for( auto string : absl::StrSplit( data, ' ' ) )`
`@@ -576,7 +600,7 @@ namespace geode`
`576`	`600`
`577`	`601`	`template < typename T >`
`578`	`602`	`std::vector< T > read_ascii_float_data_array(`
`579`		`- std::string_view data )`
	`603`	`+ std::string_view data ) const`
`580`	`604`	`{`
`581`	`605`	`return read_ascii_data_array< T >( data, absl::SimpleAtod );`
`582`	`606`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,8 @@ namespace geode`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`std::unique_ptr< HybridSolid3D > read( const MeshImpl& impl ) final;`
	`53`	`+`
	`54`	`+ bool is_loadable() const final;`
`53`	`55`	`};`
`54`	`56`	`} // namespace detail`
`55`	`57`	`} // namespace geode`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,8 @@ namespace geode`
`41`	`41`
`42`	`42`	`std::tuple< absl::FixedArray< std::vector< index_t > >,`
`43`	`43`	`std::vector< uint8_t > >`
`44`		`- read_cells( const pugi::xml_node& piece, index_t nb_cells )`
	`44`	`+ read_cells(`
	`45`	`+ const pugi::xml_node& piece, index_t nb_cells ) const`
`45`	`46`	`{`
`46`	`47`	`std::vector< int64_t > offsets_values;`
`47`	`48`	`std::vector< int64_t > connectivity_values;`