C bindings: Hide FloatGrid implementation (#4914)

oitel · web-flow · commit ab8e4ca42dd7 · 2025-08-04T14:53:03.000+02:00
* C bindings: Hide FloatGrid implementation

* Fix Python bindings

* Update comment
diff --git a/scripts/mrbind/extra_headers/instantiate_templates.h b/scripts/mrbind/extra_headers/instantiate_templates.h
@@ -8,6 +8,7 @@
 #include "MRMesh/MRPointCloud.h"
 #include "MRMesh/MRVector2.h"
 #include "MRMesh/MRVector3.h"
+#include "MRVoxels/MRFloatGrid.h"
 #include "MRVoxels/MRObjectVoxels.h"
 
 #define INST_IF(cond) MR_CONCAT(INST_IF_, cond)
@@ -88,7 +89,7 @@ FORCE_REGISTER_TYPE( std::vector<MR::PointCloud> );
 FORCE_REGISTER_TYPE( std::vector<MR::Polyline3> );
 // Those are needed directly for mrmeshpy:
 FORCE_REGISTER_TYPE( std::monostate );
-FORCE_REGISTER_TYPE( Expected<MR::VoxelsLoad::DicomVolumeT<MR::VoxelsVolumeMinMax<std::shared_ptr<MR::OpenVdbFloatGrid>>>> );
+FORCE_REGISTER_TYPE( Expected<MR::VoxelsLoad::DicomVolumeT<MR::VoxelsVolumeMinMax<FloatGrid>>> );
 FORCE_REGISTER_TYPE( Expected<MR::VoxelsLoad::DicomVolumeT<MR::VoxelsVolumeMinMax<Vector<float, MR::VoxelId>>>> );
 FORCE_REGISTER_PARAM_TYPE( double * );
 // ---
diff --git a/source/MRTestC2/MRVDBConversions.c b/source/MRTestC2/MRVDBConversions.c
@@ -44,8 +44,8 @@ void testVDBConversions( void )
     const MR_Box1f* box = MR_VdbVolume_UpcastTo_MR_Box1f( volume );
     TEST_ASSERT( box->min > -0.001f && box->min < 0.001f );
     TEST_ASSERT( box->max > 2.999f && box->max < 3.001f );
-    const MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid* baseVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume );
-    const MR_Vector3i* dims = MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_Get_dims( baseVolume );
+    const MR_VoxelsVolume_MR_FloatGrid* baseVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume );
+    const MR_Vector3i* dims = MR_VoxelsVolume_MR_FloatGrid_Get_dims( baseVolume );
     TEST_ASSERT( dims->x == 26 );
     TEST_ASSERT( dims->y == 26 );
     TEST_ASSERT( dims->z == 26 );
@@ -54,7 +54,7 @@ void testVDBConversions( void )
     MR_GridToMeshSettings_Set_voxelSize( gridToMeshSettings, MR_Vector3f_diagonal( 0.1f ) );
     MR_GridToMeshSettings_Set_isoValue( gridToMeshSettings, 1 );
 
-    MR_expected_MR_Mesh_std_string* restoredEx = MR_gridToMesh_const_std_shared_ptr_MR_OpenVdbFloatGrid_ref( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_Get_data( baseVolume ), gridToMeshSettings );
+    MR_expected_MR_Mesh_std_string* restoredEx = MR_gridToMesh_const_MR_FloatGrid_ref( MR_VoxelsVolume_MR_FloatGrid_Get_data( baseVolume ), gridToMeshSettings );
     const MR_Mesh* restored = MR_expected_MR_Mesh_std_string_GetValue( restoredEx );
     MR_Box3f bbox = MR_Mesh_computeBoundingBox_1( restored, NULL );
     TEST_ASSERT( bbox.min.x > 0.199f && bbox.min.x < 0.201f );
@@ -75,12 +75,12 @@ void testVDBConversions( void )
 void testUniformResampling( void )
 {
     MR_VdbVolume* volume = createVolume();
-    MR_std_shared_ptr_MR_OpenVdbFloatGrid* resampledGrid = MR_resampled_float( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume ) ), 2.0f, MR_PassBy_DefaultArgument, NULL );
+    MR_FloatGrid* resampledGrid = MR_resampled_float( MR_VoxelsVolume_MR_FloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume ) ), 2.0f, MR_PassBy_DefaultArgument, NULL );
     MR_VdbVolume* resampledVolume = MR_floatGridToVdbVolume( MR_PassBy_Move, resampledGrid );
-    MR_std_shared_ptr_MR_OpenVdbFloatGrid_Destroy( resampledGrid );
+    MR_FloatGrid_Destroy( resampledGrid );
 
-    const MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid* baseResampledVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( resampledVolume );
-    const MR_Vector3i* dims = MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_Get_dims( baseResampledVolume );
+    const MR_VoxelsVolume_MR_FloatGrid* baseResampledVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_MR_FloatGrid( resampledVolume );
+    const MR_Vector3i* dims = MR_VoxelsVolume_MR_FloatGrid_Get_dims( baseResampledVolume );
 
     TEST_ASSERT( dims->x == 13 );
     TEST_ASSERT( dims->y == 13 );
@@ -98,12 +98,12 @@ void testResampling( void )
     voxelScale.y = 1.0f;
     voxelScale.z = 0.5f;
 
-    MR_std_shared_ptr_MR_OpenVdbFloatGrid* resampledGrid = MR_resampled_MR_Vector3f( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume ) ), &voxelScale, MR_PassBy_DefaultArgument, NULL );
+    MR_FloatGrid* resampledGrid = MR_resampled_MR_Vector3f( MR_VoxelsVolume_MR_FloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume ) ), &voxelScale, MR_PassBy_DefaultArgument, NULL );
     MR_VdbVolume* resampledVolume = MR_floatGridToVdbVolume( MR_PassBy_Move, resampledGrid );
-    MR_std_shared_ptr_MR_OpenVdbFloatGrid_Destroy( resampledGrid );
+    MR_FloatGrid_Destroy( resampledGrid );
 
-    const MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid* baseResampledVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( resampledVolume );
-    const MR_Vector3i* dims = MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_Get_dims( baseResampledVolume );
+    const MR_VoxelsVolume_MR_FloatGrid* baseResampledVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_MR_FloatGrid( resampledVolume );
+    const MR_Vector3i* dims = MR_VoxelsVolume_MR_FloatGrid_Get_dims( baseResampledVolume );
 
     TEST_ASSERT( dims->x == 13 );
     TEST_ASSERT( dims->y == 27 );
@@ -124,13 +124,13 @@ void testCropping( void )
     box.max.y = 13;
     box.max.z = 23;
 
-    MR_std_shared_ptr_MR_OpenVdbFloatGrid* croppedGrid = MR_cropped( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume ) ), &box, MR_PassBy_DefaultArgument, NULL );
+    MR_FloatGrid* croppedGrid = MR_cropped( MR_VoxelsVolume_MR_FloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume ) ), &box, MR_PassBy_DefaultArgument, NULL );
 
     MR_VdbVolume* croppedVolume = MR_floatGridToVdbVolume( MR_PassBy_Move, croppedGrid );
-    MR_std_shared_ptr_MR_OpenVdbFloatGrid_Destroy( croppedGrid );
+    MR_FloatGrid_Destroy( croppedGrid );
 
-    const MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid* baseCroppedVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( croppedVolume );
-    const MR_Vector3i* dims = MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_Get_dims( baseCroppedVolume );
+    const MR_VoxelsVolume_MR_FloatGrid* baseCroppedVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_MR_FloatGrid( croppedVolume );
+    const MR_Vector3i* dims = MR_VoxelsVolume_MR_FloatGrid_Get_dims( baseCroppedVolume );
 
     TEST_ASSERT( dims->x == 16 );
     TEST_ASSERT( dims->y == 8 );
@@ -145,25 +145,25 @@ void testAccessors( void )
     MR_VdbVolume* volume = createVolume();
     MR_Vector3i p;
     p.x = 0; p.y = 0; p.z = 0;
-    float value = MR_getValue( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume ) ), &p );
+    float value = MR_getValue( MR_VoxelsVolume_MR_FloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume ) ), &p );
     TEST_ASSERT( value == 3.0f );
 
-    const MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid* baseVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume );
-    const MR_Vector3i* dims = MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_Get_dims( baseVolume );
+    const MR_VoxelsVolume_MR_FloatGrid* baseVolume = MR_VdbVolume_UpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume );
+    const MR_Vector3i* dims = MR_VoxelsVolume_MR_FloatGrid_Get_dims( baseVolume );
 
     MR_VoxelBitSet* region = MR_VoxelBitSet_DefaultConstruct();
     MR_BitSet_resize( MR_VoxelBitSet_MutableUpcastTo_MR_BitSet( region ), dims->x * dims->y * dims->z, NULL );
 
     MR_BitSet_set_2( MR_VoxelBitSet_MutableUpcastTo_MR_BitSet( region ), 0, true );
 
-    MR_setValue_MR_VoxelBitSet( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume ) ), region, 1.0f );
+    MR_setValue_MR_VoxelBitSet( MR_VoxelsVolume_MR_FloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume ) ), region, 1.0f );
     MR_VoxelBitSet_Destroy( region );
 
-    value = MR_getValue( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume ) ), &p );
+    value = MR_getValue( MR_VoxelsVolume_MR_FloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume ) ), &p );
     TEST_ASSERT( value == 1.0f );
 
-    MR_setValue_MR_Vector3i( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume ) ), &p, 2.0f );
-    value = MR_getValue( MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_std_shared_ptr_MR_OpenVdbFloatGrid( volume ) ), &p );
+    MR_setValue_MR_Vector3i( MR_VoxelsVolume_MR_FloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume ) ), &p, 2.0f );
+    value = MR_getValue( MR_VoxelsVolume_MR_FloatGrid_GetMutable_data( MR_VdbVolume_MutableUpcastTo_MR_VoxelsVolume_MR_FloatGrid( volume ) ), &p );
     TEST_ASSERT( value == 2.0f );
 
     MR_VdbVolume_Destroy( volume );
diff --git a/source/MRViewer/MRMarkedVoxelSlice.h b/source/MRViewer/MRMarkedVoxelSlice.h
@@ -8,6 +8,7 @@
 #include <MRMesh/MRVector3.h>
 #include <MRMesh/MRBitSet.h>
 #include <MRMesh/MRBox.h>
+#include <MRVoxels/MRFloatGrid.h>
 #include <MRVoxels/MRVoxelPath.h>
 
 namespace MR
diff --git a/source/MRVoxels/MRFloatGrid.cpp b/source/MRVoxels/MRFloatGrid.cpp
@@ -13,6 +13,48 @@
 namespace MR
 {
 
+FloatGrid::FloatGrid() = default;
+
+FloatGrid::FloatGrid( std::shared_ptr<OpenVdbFloatGrid> ptr )
+    : ptr_( std::move( ptr ) )
+{
+}
+
+void FloatGrid::reset() noexcept
+{
+    ptr_.reset();
+}
+
+void FloatGrid::swap( FloatGrid& other ) noexcept
+{
+    ptr_.swap( other.ptr_ );
+}
+
+OpenVdbFloatGrid* FloatGrid::get() const noexcept
+{
+    return ptr_.get();
+}
+
+OpenVdbFloatGrid& FloatGrid::operator*() const noexcept
+{
+    return *ptr_;
+}
+
+OpenVdbFloatGrid* FloatGrid::operator->() const noexcept
+{
+    return ptr_.get();
+}
+
+FloatGrid::operator bool() const noexcept
+{
+    return (bool)ptr_;
+}
+
+std::shared_ptr<OpenVdbFloatGrid> FloatGrid::toVdb() const noexcept
+{
+    return ptr_;
+}
+
 size_t heapBytes( const FloatGrid& grid )
 {
     return grid ? grid->memUsage() : 0;
diff --git a/source/MRVoxels/MRFloatGrid.h b/source/MRVoxels/MRFloatGrid.h
@@ -14,6 +14,30 @@ namespace MR
  * \{
  */
 
+struct MRVOXELS_CLASS OpenVdbFloatGrid;
+
+/// wrapper class that helps mrbind to avoid excess MRVDBFloatGrid.h includes
+class MRVOXELS_CLASS FloatGrid
+{
+public:
+    MRVOXELS_API FloatGrid();
+    MRVOXELS_API FloatGrid( std::shared_ptr<OpenVdbFloatGrid> ptr );
+
+    MRVOXELS_API void reset() noexcept;
+    MRVOXELS_API void swap( FloatGrid& other ) noexcept;
+
+    MRVOXELS_API OpenVdbFloatGrid* get() const noexcept;
+    MRVOXELS_API OpenVdbFloatGrid& operator *() const noexcept;
+    MRVOXELS_API OpenVdbFloatGrid* operator ->() const noexcept;
+
+    MRVOXELS_API explicit operator bool() const noexcept;
+
+    MRVOXELS_API std::shared_ptr<OpenVdbFloatGrid> toVdb() const noexcept;
+
+private:
+    std::shared_ptr<OpenVdbFloatGrid> ptr_;
+};
+
 /// returns the amount of heap memory occupied by grid
 [[nodiscard]] MRVOXELS_API size_t heapBytes( const FloatGrid& grid );
 
diff --git a/source/MRVoxels/MRVDBFloatGrid.h b/source/MRVoxels/MRVDBFloatGrid.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "MRVoxelsFwd.h"
+#include "MRFloatGrid.h"
 // this header includes the whole OpenVDB, so please include it from .cpp files only
 #include "MRMesh/MRVector3.h"
 #include "MRMesh/MRBox.h"
diff --git a/source/MRVoxels/MRVoxelsFwd.h b/source/MRVoxels/MRVoxelsFwd.h
@@ -21,8 +21,7 @@ namespace MR
 
 class ObjectVoxels;
 
-struct MRVOXELS_CLASS OpenVdbFloatGrid;
-using FloatGrid = std::shared_ptr<OpenVdbFloatGrid>;
+class FloatGrid;
 
 MR_CANONICAL_TYPEDEFS( (template <typename T> struct), MRVOXELS_CLASS VoxelsVolumeMinMax,
     ( SimpleVolumeMinMax, VoxelsVolumeMinMax<Vector<float, VoxelId>> )
diff --git a/source/MRVoxels/MRVoxelsSave.cpp b/source/MRVoxels/MRVoxelsSave.cpp
@@ -276,7 +276,7 @@ Expected<void> gridToVdb( const FloatGrid& grid, const std::filesystem::path& fi
 Expected<void> gridToVdb( const FloatGrid& vdbVolume, std::ostream& out, ProgressCallback /*callback*/ /*= {} */ )
 {
     openvdb::io::Stream stream( out );
-    stream.write( openvdb::GridCPtrVec{ vdbVolume } );
+    stream.write( openvdb::GridCPtrVec{ vdbVolume.toVdb() } );
     if ( !out )
         return unexpected( "error writing in stream" );
     return {};
diff --git a/source/MRVoxels/MRVoxelsVolume.h b/source/MRVoxels/MRVoxelsVolume.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "MRVoxelsFwd.h"
+#include "MRFloatGrid.h"
 
 #include "MRMesh/MRVector3.h"
 #include "MRMesh/MRBox.h"
diff --git a/source/mrviewerpy/MRPythonScene.cpp b/source/mrviewerpy/MRPythonScene.cpp
@@ -15,7 +15,6 @@
 
 #ifndef MRVIEWER_NO_VOXELS
 #include "MRVoxels/MRObjectVoxels.h"
-#include "MRVoxels/MRVDBFloatGrid.h"
 #endif
 
 // NOTE: see the disclaimer in the header file

Original file line number	Diff line number	Diff line change
`@@ -276,7 +276,7 @@ Expected<void> gridToVdb( const FloatGrid& grid, const std::filesystem::path& fi`
`276`	`276`	`Expected<void> gridToVdb( const FloatGrid& vdbVolume, std::ostream& out, ProgressCallback /callback/ /= {} / )`
`277`	`277`	`{`
`278`	`278`	`openvdb::io::Stream stream( out );`
`279`		`- stream.write( openvdb::GridCPtrVec{ vdbVolume } );`
	`279`	`+ stream.write( openvdb::GridCPtrVec{ vdbVolume.toVdb() } );`
`280`	`280`	`if ( !out )`
`281`	`281`	`return unexpected( "error writing in stream" );`
`282`	`282`	`return {};`