Creating a Grid from a native object done

Author: spyke7

gridData/OpenVDB.py

@@ -158,8 +158,13 @@ def __init__(
             self.metadata = {}
 
         if grid is not None:
-            self._populate(grid, origin, delta)
-            self.vdb_grid = self._create_openvdb_grid()
+            if isinstance(grid, vdb.GridBase):
+                self.vdb_grid = grid
+                print("hello")
+                self._extract_from_vdb_grid()
+            else:
+                self._populate(grid, origin, delta)
+                self.vdb_grid = self._create_openvdb_grid()
         else:
             self.grid = None
             self.origin = None
@@ -322,6 +327,60 @@ def _create_openvdb_grid(self):
 
         return vdb_grid
 
+    def _extract_from_vdb_grid(self):
+        """Extract numpy array, origin, delta from stored VDB grid.
+
+        This method converts the sparse VDB grid to a dense numpy array
+        and extracts the transform information.
+        """
+        if self.vdb_grid.name:
+            self.name = self.vdb_grid.name
+
+        for key in self.vdb_grid.metadata:
+            try:
+                self.metadata[key] = self.vdb_grid[key]
+            except (TypeError, ValueError):
+                pass
+
+        transformation = self.vdb_grid.transform
+
+        v_origin = numpy.array(transformation.indexToWorld([0, 0, 0]))
+        v_delta = numpy.array(transformation.indexToWorld([1, 1, 1])) - v_origin
+
+        self.origin = v_origin
+        self.delta = v_delta
+
+        vdb_native_dtype = {
+            "BoolGrid": numpy.dtype("bool"),
+            "Int32Grid": numpy.dtype("int32"),
+            "Int64Grid": numpy.dtype("int64"),
+            "FloatGrid": numpy.dtype("float32"),
+            "DoubleGrid": numpy.dtype("float64"),
+            "HalfGrid": numpy.dtype("float16"),
+            "Vec3SGrid": numpy.dtype("float32"),
+            "Vec3DGrid": numpy.dtype("float64"),
+        }
+        dtype = vdb_native_dtype.get(
+            type(self.vdb_grid).__name__, numpy.dtype("float32")
+        )
+
+        bbox = self.vdb_grid.evalActiveVoxelBoundingBox()
+
+        if bbox is None or bbox[0] == bbox[1]:
+            self.grid = numpy.zeros((0, 0, 0), dtype=dtype)
+            return
+
+        shape = tuple(numpy.array(bbox[1]) - numpy.array(bbox[0]) + 1)
+
+        self.grid = numpy.zeros(shape, dtype=dtype)
+        print(dtype)
+        self.vdb_grid.copyToArray(self.grid, ijk=bbox[0])
+
+        if not numpy.all(numpy.array(bbox[0]) == 0):
+            self.origin = numpy.array(
+                transformation.indexToWorld(numpy.array(bbox[0]).tolist())
+            )
+
     def write(self, filename):
         """Write the field to an OpenVDB file.
 

gridData/core.py

@@ -38,6 +38,7 @@
 import pickle
 
 import numpy
+import openvdb as vdb
 
 # For interpolated grids: need scipy.ndimage but we import it only when needed:
 # import scipy
@@ -250,7 +251,10 @@ def __init__(
         self.interpolation_cval = None  # default to using min(grid)
 
         if grid is not None:
-            if isinstance(grid, str):
+            if self._is_native_object(grid):
+                self._load_from_native(grid)
+                filename = None
+            elif isinstance(grid, str):
                 # can probably safely try to load() it...
                 filename = grid
             else:
@@ -273,7 +277,7 @@ def __init__(
                     file_format=file_format,
                     assume_volumetric=assume_volumetric,
                 )
-            else:
+            elif not self._is_native_object(grid):
                 self._load(grid, edges, metadata, origin, delta)
 
     @property
@@ -622,38 +626,76 @@ def _load_plt(self, filename, **kwargs):
         grid, edges = g.histogramdd()
         self._load(grid=grid, edges=edges, metadata=self.metadata)
 
+    def _is_native_object(self, obj):
+        """Check if object is a native format object (OpenVDB grid, MRC object).
+
+        Parameters
+        ----------
+        obj : object
+            Object to check
+
+        Returns
+        -------
+        bool
+            True if obj is a native format object
+        """
+        if isinstance(obj, vdb.GridBase):
+            return True
+
+        return False
+
+    def _load_from_native(self, obj):
+        """Load Grid from a native format object.
+
+        Parameters
+        ----------
+        obj : object
+            Native format object (openvdb.GridBase, mrcfile.mrcfile.MrcFile, etc.)
+
+        """
+        self.vdb_field = OpenVDB.OpenVDBField(grid=obj)
+
+        origin = self.vdb_field.origin
+        delta = self.vdb_field.delta
+        grid = self.vdb_field.grid
+
+        self.metadata = self.vdb_field.metadata
+        self._from_native_vdb = True
+
+        self._load(grid=grid, origin=origin, delta=delta)
+
     def convert_to(self, format_specifier, tolerance=None, **kwargs):
         """generates an instance of the native object for a given format
-        
+
         Implemented formats:
-        
+
         vdb
             :mod:`OpenVDB`
-            
+
         Parameters
         ----------
-        format_specifier : str 
+        format_specifier : str
             vdb, etc
 
         Returns
         -------
         native object
-        
+
         """
         formats = ("mrc", "vdb")
-        if (format_specifier.lower() == formats[1]):
+        if format_specifier.lower() == formats[1]:
             grid_name = self.metadata.get("name", "density")
-            vdb_field  = OpenVDB.OpenVDBField(
+            vdb_field = OpenVDB.OpenVDBField(
                 grid=self.grid,
                 origin=self.origin,
                 delta=self.delta,
                 name=grid_name,
                 tolerance=tolerance,
-                metadata=self.metadata
+                metadata=self.metadata,
             )
-            
+
             return vdb_field.vdb_grid
-        
+
         raise ValueError(f"Unsupported convert_to format : {format_specifier}")
 
     def export(
@@ -773,6 +815,14 @@ def _export_vdb(self, filename, tolerance=None, **kwargs):
 
         For the file format see https://www.openvdb.org
         """
+        if (
+            hasattr(self, "_from_native_vdb")
+            and self._from_native_vdb
+            and tolerance is None
+        ):
+            self.vdb_field.write(filename)
+            return
+
         if self.grid.ndim != 3:
             raise ValueError(
                 f"OpenVDB export requires a 3D grid, got {self.grid.ndim}D"

gridData/tests/test_vdb.py

@@ -1,5 +1,6 @@
 import numpy as np
 from numpy.testing import assert_allclose
+import os
 
 import pytest
 from unittest.mock import patch
@@ -362,6 +363,33 @@ def test_grid_convert_to_vdb(self, grid345):
 
         assert isinstance(native, vdb.GridBase)
 
+    def test_grid_from_native_vdb_preserve_values(self, grid345):
+        data, g = grid345
+        native = g.convert_to("vdb")
+        g2 = Grid(grid=native)
+
+        assert g._is_native_object(native) is True
+
+        assert g2.grid.shape == data.shape
+        assert_allclose(g2.origin, g.origin, rtol=1e-5)
+        assert_allclose(g2.delta, g.delta, rtol=1e-5)
+        assert_allclose(g2.grid, data, rtol=1e-5)
+
+    def test_grid_from_native_vdb_export_with_tolerance(self, tmpdir, grid345):
+        data, g = grid345
+        native = g.convert_to("vdb")
+        g2 = Grid(grid=native)
+
+        out_no_tol = str(tmpdir / "no_tolerance.vdb")
+        out_with_tol = str(tmpdir / "with_tolerance.vdb")
+
+        g2.export(out_no_tol)
+        g2.export(out_with_tol, tolerance=5.0)
+
+        size_no_tol = os.path.getsize(out_no_tol)
+        size_with_tol = os.path.getsize(out_with_tol)
+        assert size_with_tol < size_no_tol
+
 
 @pytest.mark.skipif(
     not HAS_OPENVDB, reason="Need openvdb to test import error handling"