V18

include/geode/io/image/detail/vtk_output.hpp

@@ -31,12 +31,12 @@
 
 #include <geode/basic/attribute_manager.hpp>
 
 namespace geode
 {
     namespace detail
     {
         template < typename Mesh >
         class VTKOutputImpl
         {
         public:
             void write_file()
@@ -59,7 +59,7 @@
                     "[VTKOutput] Error while writing file: ", filename );
             }
 
             virtual ~VTKOutputImpl() {}
 
             const Mesh& mesh() const
             {
@@ -79,27 +79,32 @@
                 write_attributes( attribute_node, manager, elements );
             }
 
             void write_attributes( pugi::xml_node& attribute_node,
                 const AttributeManager& manager,
                 absl::Span< const index_t > elements ) const
             {
-                for( const auto& name : manager.attribute_names() )
+                for( const auto& id : manager.attribute_ids() )
                 {
-                    const auto attribute =
-                        manager.find_generic_attribute( name );
+                    const auto attribute = manager.find_generic_attribute( id );
                     if( !attribute || !attribute->is_genericable() )
                     {
                         continue;
                     }
-                    auto data_array = write_attribute_header(
-                        attribute_node, name, attribute->nb_items() );
+                    auto data_array = write_attribute_header( attribute_node,
+                        attribute->name().value(), attribute->nb_items() );
                     auto min = std::numeric_limits< float >::max();
                     auto max = std::numeric_limits< float >::lowest();
                     std::string values;
                     for( const auto e : elements )
                     {
                         for( const auto i : LRange{ attribute->nb_items() } )
                         {
+                            if( !attribute->has_value( e ) )
+                            {
+                                absl::StrAppend(
+                                    &values, std::nanf( " " ), " " );
+                                continue;
+                            }
                             const auto value =
                                 attribute->generic_item_value( e, i );
                             absl::StrAppend( &values, value, " " );

include/geode/io/mesh/detail/vtk_input.hpp

@@ -39,12 +39,12 @@
 
 #include <geode/geometry/point.hpp>
 
 namespace geode
 {
     namespace detail
     {
         template < typename Mesh >
         class VTKInputImpl
         {
         public:
             virtual ~VTKInputImpl() = default;
@@ -59,17 +59,17 @@
                 return std::move( mesh_ );
             }
 
             Percentage is_loadable()
             {
                 read_common_data();
                 std::vector< Percentage > percentages;
                 for( const auto& vtk_object : root_.children( type_ ) )
                 {
                     is_vtk_object_loadable( vtk_object, percentages );
                 }
                 if( percentages.empty() )
                 {
                     return Percentage{ 0 };
                 }
                 const auto nb_percentages = percentages.size();
                 double value{ 0 };
@@ -77,7 +77,7 @@
                 {
                     value += percentage.value();
                 }
                 return Percentage{ value / nb_percentages };
             }
 
         protected:
@@ -97,7 +97,7 @@
 
             virtual void is_vtk_object_loadable(
                 const pugi::xml_node& vtk_object,
                 std::vector< Percentage >& percentages ) const = 0;
 
             void read_common_data()
             {
@@ -124,20 +124,20 @@
             index_t read_attribute(
                 const pugi::xml_node& piece, std::string_view attribute ) const
             {
                 return string_to_index(
                     piece.attribute( attribute.data() ).value() );
             }
 
             template < typename T >
             std::vector< T > read_integer_data_array(
                 const pugi::xml_node& data ) const
             {
                 const auto format = data.attribute( "format" ).value();
                 if( match( format, "appended" ) )
                 {
                     return decode< T >( read_appended_data( data ) );
                 }
                 else
                 {
                     const auto data_string =
                         absl::StripAsciiWhitespace( data.child_value() );
@@ -220,16 +220,21 @@
                     OpenGeodeException::TYPE::data,
                     "[VTKInput::build_attribute] Number of attribute "
                     "values is not a multiple of number of components" );
-                if( manager.find_generic_attribute( name ) )
-                {
-                    return;
-                }
                 if( nb_components == 1 )
                 {
+                    AttributeValues< T > default_values;
+                    default_values.default_value = T{};
+                    default_values.no_value = T{};
+                    AttributeProperties properties;
+                    properties.assignable = false;
+                    properties.interpolable = false;
+                    properties.transferable = true;
+                    auto attribute_id =
+                        manager.create_attribute< VariableAttribute, T >(
+                            name, default_values, properties );
                     auto attribute =
-                        manager
-                            .find_or_create_attribute< VariableAttribute, T >(
-                                name, T{} );
+                        manager.find_attribute< VariableAttribute, T >(
+                            attribute_id );
                     for( const auto i : Indices{ values } )
                     {
                         attribute->set_value( i + offset, values[i] );
@@ -374,9 +379,19 @@
                 std::string_view name,
                 index_t offset )
             {
+                AttributeValues< Container > default_values;
+                default_values.default_value = default_value;
+                default_values.no_value = default_value;
+                AttributeProperties properties;
+                properties.assignable = false;
+                properties.interpolable = false;
+                properties.transferable = true;
+                const auto attribute_id =
+                    manager.create_attribute< VariableAttribute, Container >(
+                        name, default_values, properties );
                 auto attribute =
-                    manager.find_or_create_attribute< VariableAttribute,
-                        Container >( name, default_value );
+                    manager.find_attribute< VariableAttribute, Container >(
+                        attribute_id );
                 for( const auto i : Range{ values.size() / nb_components } )
                 {
                     for( const auto c : Range{ nb_components } )

include/geode/io/model/detail/vtm_output.hpp

@@ -129,7 +129,7 @@ namespace geode
             {
                 index_t counter{ 0 };
                 const auto level = Logger::level();
-                Logger::set_level( Logger::LEVEL::warn );
+                Logger::set_level( Logger::LEVEL::warning );
                 absl::FixedArray< async::task< void > > tasks(
                     this->mesh().nb_corners() );
                 absl::FixedArray< uuid > corner_ids(
@@ -187,7 +187,7 @@ namespace geode
             {
                 index_t counter{ 0 };
                 const auto level = Logger::level();
-                Logger::set_level( Logger::LEVEL::warn );
+                Logger::set_level( Logger::LEVEL::warning );
                 absl::FixedArray< async::task< void > > tasks(
                     this->mesh().nb_lines() );
                 absl::FixedArray< uuid > line_ids( this->mesh().nb_lines() );
@@ -243,7 +243,7 @@ namespace geode
             {
                 index_t counter{ 0 };
                 const auto level = Logger::level();
-                Logger::set_level( Logger::LEVEL::warn );
+                Logger::set_level( Logger::LEVEL::warning );
                 absl::FixedArray< async::task< void > > tasks(
                     this->mesh().nb_surfaces() );
                 absl::FixedArray< uuid > surface_ids(

include/geode/io/model/internal/msh_common.hpp

@@ -115,8 +115,8 @@
             {
                 return physical_ids.find( physical_id ) != physical_ids.end();
             }
-            absl::flat_hash_map< GmshElementID, geode::uuid > elementary_ids;
-            absl::flat_hash_map< GmshElementID, geode::uuid > physical_ids;
+            absl::flat_hash_map< GmshElementID, uuid > elementary_ids;
+            absl::flat_hash_map< GmshElementID, uuid > physical_ids;
         };
 
         class GMSHElement
@@ -131,7 +131,7 @@
                   nb_vertices_( nb_vertices ),
                   vertex_ids_str_( vertex_ids )
             {
                 OpenGeodeIOModelException::check_exception(
                     elementary_entity_id > 0, nullptr,
                     OpenGeodeException::TYPE::data,
                     "[GMSHElement] GMSH tag for elementary entity "
@@ -215,7 +215,7 @@
                 };
                 const auto existing_id =
                     id_map.contains_elementary_id( cur_gmsh_id );
-                geode::uuid corner_uuid;
+                uuid corner_uuid;
                 geode::BRepBuilder builder{ brep };
                 if( existing_id )
                 {
@@ -229,7 +229,8 @@
                 }
 
                 const auto v_id =
-                    builder.corner_mesh_builder( corner_uuid )->create_vertex();
+                    builder.corner_mesh_builder( brep.corner( corner_uuid ) )
+                        ->create_vertex();
                 builder.set_unique_vertex(
                     { brep.corner( corner_uuid ).component_id(), v_id },
                     vertex_ids()[0] - GMSH_OFFSET_START );
@@ -255,7 +256,7 @@
                 const auto existing_id =
                     id_map.contains_elementary_id( cur_gmsh_id );
                 geode::BRepBuilder builder{ brep };
-                geode::uuid line_uuid;
+                uuid line_uuid;
                 if( existing_id )
                 {
                     line_uuid = id_map.elementary_ids.at( cur_gmsh_id );
@@ -265,14 +266,13 @@
                     line_uuid = builder.add_line();
                     id_map.elementary_ids.insert( { cur_gmsh_id, line_uuid } );
                 }
+                const auto& line = brep.line( line_uuid );
                 const auto first_v_id =
-                    builder.line_mesh_builder( line_uuid )
-                        ->create_vertices( vertex_ids().size() );
+                    builder.line_mesh_builder( line )->create_vertices(
+                        vertex_ids().size() );
                 const auto edge_id =
-                    builder.line_mesh_builder( line_uuid )
-                        ->create_edge( first_v_id, first_v_id + 1 );
-
-                const auto& line = brep.line( line_uuid );
+                    builder.line_mesh_builder( line )->create_edge(
+                        first_v_id, first_v_id + 1 );
                 for( const auto v_id : geode::LIndices{ vertex_ids() } )
                 {
                     builder.set_unique_vertex(
@@ -303,7 +303,7 @@
                 const auto existing_id =
                     id_map.contains_elementary_id( cur_gmsh_id );
                 geode::BRepBuilder builder{ brep };
-                geode::uuid surface_uuid;
+                uuid surface_uuid;
                 if( existing_id )
                 {
                     surface_uuid = id_map.elementary_ids.at( cur_gmsh_id );
@@ -314,16 +314,16 @@
                     id_map.elementary_ids.insert(
                         { cur_gmsh_id, surface_uuid } );
                 }
+                const auto& surface = brep.surface( surface_uuid );
                 const auto first_v_id =
-                    builder.surface_mesh_builder( surface_uuid )
-                        ->create_vertices( vertex_ids().size() );
+                    builder.surface_mesh_builder( surface )->create_vertices(
+                        vertex_ids().size() );
                 std::vector< geode::index_t > v_ids( vertex_ids().size() );
                 std::iota( v_ids.begin(), v_ids.end(), first_v_id );
                 const auto polygon_id =
-                    builder.surface_mesh_builder( surface_uuid )
-                        ->create_polygon( v_ids );
+                    builder.surface_mesh_builder( surface )->create_polygon(
+                        v_ids );
 
-                const auto& surface = brep.surface( surface_uuid );
                 for( const auto v_id : geode::LIndices{ vertex_ids() } )
                 {
                     builder.set_unique_vertex(
@@ -372,7 +372,7 @@
 
             virtual geode::index_t create_gmsh_polyhedron(
                 geode::BRepBuilder& builder,
-                const geode::uuid& block_uuid,
+                const Block3D& block,
                 const std::vector< geode::index_t >& v_ids ) = 0;
 
             void add_element( geode::BRep& brep, GmshId2Uuids& id_map ) final
@@ -383,7 +383,7 @@
                 const auto existing_id =
                     id_map.contains_elementary_id( cur_gmsh_id );
                 geode::BRepBuilder builder{ brep };
-                geode::uuid block_uuid;
+                uuid block_uuid;
                 if( existing_id )
                 {
                     block_uuid = id_map.elementary_ids.at( cur_gmsh_id );
@@ -395,16 +395,16 @@
                             geode::HybridSolid3D::type_name_static() ) );
                     id_map.elementary_ids.insert( { cur_gmsh_id, block_uuid } );
                 }
+                const auto& block = brep.block( block_uuid );
 
                 const auto first_v_id =
-                    builder.block_mesh_builder( block_uuid )
-                        ->create_vertices( vertex_ids().size() );
+                    builder.block_mesh_builder( block )->create_vertices(
+                        vertex_ids().size() );
                 std::vector< geode::index_t > v_ids( vertex_ids().size() );
                 std::iota( v_ids.begin(), v_ids.end(), first_v_id );
                 const auto polyhedron_id =
-                    create_gmsh_polyhedron( builder, block_uuid, v_ids );
+                    create_gmsh_polyhedron( builder, block, v_ids );
 
-                const auto& block = brep.block( block_uuid );
                 for( const auto v_id : geode::LIndices{ vertex_ids() } )
                 {
                     builder.set_unique_vertex(
@@ -427,15 +427,15 @@
             }
 
             geode::index_t create_gmsh_polyhedron( geode::BRepBuilder& builder,
-                const geode::uuid& block_uuid,
+                const Block3D& block,
                 const std::vector< geode::index_t >& v_ids ) override final
             {
                 static const std::array< std::vector< geode::local_index_t >,
                     4 >
                     gmsh_tetrahedron_faces{ { { 0, 1, 2 }, { 0, 2, 3 },
                         { 1, 3, 2 }, { 0, 3, 1 } } };
-                return builder.block_mesh_builder( block_uuid )
-                    ->create_polyhedron( v_ids, gmsh_tetrahedron_faces );
+                return builder.block_mesh_builder( block )->create_polyhedron(
+                    v_ids, gmsh_tetrahedron_faces );
             }
         };
 
@@ -451,16 +451,16 @@
             }
 
             geode::index_t create_gmsh_polyhedron( geode::BRepBuilder& builder,
-                const geode::uuid& block_uuid,
+                const Block3D& block,
                 const std::vector< geode::index_t >& v_ids ) override final
             {
                 static const std::array< std::vector< geode::local_index_t >,
                     6 >
                     gmsh_hexahedron_faces{ { { 0, 1, 2, 3 }, { 7, 6, 5, 4 },
                         { 0, 3, 7, 4 }, { 1, 5, 6, 2 }, { 2, 6, 7, 3 },
                         { 0, 4, 5, 1 } } };
-                return builder.block_mesh_builder( block_uuid )
-                    ->create_polyhedron( v_ids, gmsh_hexahedron_faces );
+                return builder.block_mesh_builder( block )->create_polyhedron(
+                    v_ids, gmsh_hexahedron_faces );
             }
         };
 
@@ -476,15 +476,15 @@
             }
 
             geode::index_t create_gmsh_polyhedron( geode::BRepBuilder& builder,
-                const geode::uuid& block_uuid,
+                const Block3D& block,
                 const std::vector< geode::index_t >& v_ids ) override final
             {
                 static const std::array< std::vector< geode::local_index_t >,
                     5 >
                     gmsh_prism_faces{ { { 0, 1, 2 }, { 5, 4, 3 },
                         { 0, 2, 5, 3 }, { 0, 3, 4, 1 }, { 1, 4, 5, 2 } } };
-                return builder.block_mesh_builder( block_uuid )
-                    ->create_polyhedron( v_ids, gmsh_prism_faces );
+                return builder.block_mesh_builder( block )->create_polyhedron(
+                    v_ids, gmsh_prism_faces );
             }
         };
 
@@ -500,15 +500,15 @@
             }
 
             geode::index_t create_gmsh_polyhedron( geode::BRepBuilder& builder,
-                const geode::uuid& block_uuid,
+                const Block3D& block,
                 const std::vector< geode::index_t >& v_ids ) override final
             {
                 static const std::array< std::vector< geode::local_index_t >,
                     5 >
                     gmsh_pyramid_faces{ { { 0, 3, 4 }, { 0, 4, 1 }, { 4, 3, 2 },
                         { 1, 4, 2 }, { 0, 1, 2, 3 } } };
-                return builder.block_mesh_builder( block_uuid )
-                    ->create_polyhedron( v_ids, gmsh_pyramid_faces );
+                return builder.block_mesh_builder( block )->create_polyhedron(
+                    v_ids, gmsh_pyramid_faces );
             }
         };
 

src/geode/io/mesh/assimp_input.cpp

@@ -140,7 +140,7 @@ namespace geode
                     }
                     catch( const OpenGeodeException& e )
                     {
-                        Logger::warn( e.what() );
+                        Logger::warning( e.what() );
                     }
                 }
             }

src/geode/io/mesh/csv_input_helpers.cpp

@@ -154,9 +154,21 @@ namespace geode
                     {
                         continue;
                     }
+                    AttributeValues< double > default_values;
+                    default_values.default_value = value;
+                    default_values.no_value = value;
+                    AttributeProperties properties;
+                    properties.assignable = false;
+                    properties.interpolable = false;
+                    properties.transferable = true;
+                    const auto attribute_id =
+                        attribute_manager
+                            .create_attribute< VariableAttribute, double >(
+                                attribute_name, default_values, properties );
                     double_attrs[col] =
-                        attribute_manager.find_or_create_attribute<
-                            VariableAttribute, double >( attribute_name, 0.0 );
+                        attribute_manager
+                            .find_attribute< VariableAttribute, double >(
+                                attribute_id );
                 }
             }
             for( const auto col : geode::Range{ line_values.size() } )