webvdb 0.5.1 → 0.6.0

package/cli.mjs

@@ -8709,6 +8709,9 @@ class GridSharedContext {
   // NOTE Read only grid headers, metadata and transforms. Trees are not read.
   metadataOnly = false;
 
+  // NOTE Read the tree topology (active voxels), but not the leaf values
+  topologyOnly = false;
+
   // NOTE Grid value settings
   valueType = null;
   useHalf = null;
@@ -9410,6 +9413,38 @@ class ChildNode {
     return values;
   }
 
+  // NOTE Extends min and max with the active voxels and tiles. Origin is the index position of this node.
+  // Child origins are relative to the parent.
+  evalActiveBbox(origin, min, max) {
+    const log2dim = this.log2dim;
+    const childTotal = this.total - log2dim;
+    const tileSize = (1 << childTotal) - 1;
+    const position = new Vector3();
+
+    this.valueMask.forEachOn(({ offset }) => {
+      if (this.isInternalNode() && this.childMask.isOn(offset)) {
+        return;
+      }
+
+      position.set(
+        origin.x + ((offset >> (2 * log2dim)) << childTotal),
+        origin.y + (((offset >> log2dim) & ((1 << log2dim) - 1)) << childTotal),
+        origin.z + ((offset & ((1 << log2dim) - 1)) << childTotal)
+      );
+
+      min.min(position);
+      max.max(position.addScalar(tileSize));
+    });
+
+    if (this.isInternalNode()) {
+      this.childMask.forEachOn(({ offset }) => {
+        const child = this.table[offset];
+
+        child.evalActiveBbox(origin.clone().add(child.origin), min, max);
+      });
+    }
+  }
+
   getLocalBbox() {
     if (this.localBboxCache) {
       return this.localBboxCache;
@@ -9592,6 +9627,16 @@ class RootTile {
     return this.localBboxCache;
   }
 
+  // NOTE Extends min and max with the tile extent when the tile is active
+  evalActiveBbox(origin, min, max) {
+    if (!this.active) {
+      return;
+    }
+
+    min.min(origin);
+    max.max(origin.clone().addScalar(this.dim - 1));
+  }
+
   contains(position) {
     const [min, max] = this.getLocalBbox();
 
@@ -9764,6 +9809,11 @@ class RootNode {
     });
   }
 
+  // NOTE Root children and root tiles save their index origin in the file
+  evalActiveBbox(min, max) {
+    this.table.forEach((node) => node.evalActiveBbox(node.origin, min, max));
+  }
+
   getLocalBbox() {
     // NOTE Ignore bbox for root nodes
     return [new Vector3(0.0, 0.0, 0.0), new Vector3(0.0, 0.0, 0.0)];
@@ -10101,7 +10151,7 @@ class GridDescriptor {
   gridType;
 
   readGrid() {
-    const { bufferIterator, version, hasGridOffsets, metadataOnly } =
+    const { bufferIterator, version, hasGridOffsets, metadataOnly, topologyOnly } =
       GridSharedContext.getContext(this);
 
     this.readGridHeader();
@@ -10124,10 +10174,20 @@ class GridDescriptor {
       return;
     }
 
+    // NOTE With topologyOnly, leaf values are skipped. Without grid offsets, the reader cannot skip them.
+    const readOrSkipBuffers = () => {
+      if (topologyOnly && hasGridOffsets) {
+        bufferIterator.offset = this.endBufferPosition;
+        return;
+      }
+
+      this.readBuffers();
+    };
+
     if (Version.less(version, 216)) {
       this.readTopology();
       this.readGridTransform();
-      this.readBuffers();
+      readOrSkipBuffers();
     } else {
       this.readGridTransform();
 
@@ -10142,7 +10202,7 @@ class GridDescriptor {
       }
 
       this.readTopology();
-      this.readBuffers();
+      readOrSkipBuffers();
     }
   }
 
@@ -10302,11 +10362,29 @@ class GridDescriptor {
     ];
   }
 
+  // NOTE Index box of active voxels and tiles from the tree, same as Tree::evalActiveVoxelBoundingBox. Null when none is active.
+  // Some writers (EmberGen) save wrong file_bbox metadata.
+  evalActiveVoxelBoundingBox() {
+    if (this.activeVoxelBboxCache === undefined) {
+      const min = new Vector3(Infinity, Infinity, Infinity);
+      const max = new Vector3(-Infinity, -Infinity, -Infinity);
+
+      this.root.evalActiveBbox(min, max);
+
+      this.activeVoxelBboxCache = min.x <= max.x ? [min, max] : null;
+    }
+
+    return this.activeVoxelBboxCache;
+  }
+
+  // NOTE Without a tree (metadataOnly) or without active voxels, the box comes from the file metadata
   getPreciseWorldBbox() {
-    return this.transform.applyTransformMapToBbox([
-      this.metadata.file_bbox_min.value,
-      this.metadata.file_bbox_max.value,
-    ]);
+    return this.transform.applyTransformMapToBbox(
+      (this.root && this.evalActiveVoxelBoundingBox()) || [
+        this.metadata.file_bbox_min.value,
+        this.metadata.file_bbox_max.value,
+      ]
+    );
   }
 
   valueCache = {};
@@ -10351,11 +10429,13 @@ class OpenVDBReader {
   }
 
   // NOTE With metadataOnly, grids have metadata and transforms (for example the world box), but no tree.
+  // With topologyOnly, grids also have the tree topology (active voxels, evalActiveVoxelBoundingBox), but no leaf values.
   // Grids of files without grid offsets (before version 2.16) are read in full.
-  async read(source, { metadataOnly = false } = {}) {
+  async read(source, { metadataOnly = false, topologyOnly = false } = {}) {
     await Compression.prepareModules();
     GridSharedContext.getContext(this).bufferIterator = new BufferIterator(source);
     GridSharedContext.getContext(this).metadataOnly = metadataOnly;
+    GridSharedContext.getContext(this).topologyOnly = topologyOnly;
 
     if (this.validateVDBFile()) {
       this.readFileVersion();
@@ -11258,8 +11338,12 @@ const getBackground = (grid) => {
     : [Math.fround(background.x), Math.fround(background.y), Math.fround(background.z)];
 };
 
-// NOTE Empty grids store an inverted box
+// NOTE With a tree, empty grids have no active voxels. Without a tree, empty grids store an inverted box.
 const isEmptyGrid = (grid) => {
+  if (grid.root) {
+    return !grid.evalActiveVoxelBoundingBox();
+  }
+
   const { file_voxel_count: voxelCount, file_bbox_min: min, file_bbox_max: max } =
     grid.metadata || {};
 
@@ -12026,9 +12110,9 @@ const readVDB = async (source, readOptions) => {
   return vdb;
 };
 
-// NOTE The box needs only grid metadata and transforms. The trees are not read.
+// NOTE The box needs the tree topology (active voxels). Leaf values are not read.
 const getSourceBox = async ({ source, options }) =>
-  getWVDBBox(await readVDB(readSource(source), { metadataOnly: true }), options.grids);
+  getWVDBBox(await readVDB(readSource(source), { topologyOnly: true }), options.grids);
 
 const convert = async ({ source, options }) => {
   const sourceBytes = readSource(source);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webvdb",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "CLI that converts .vdb files, folders and ZIP files into streamed .wvdb files.",
   "scripts": {},
   "dependencies": {},
@@ -28,6 +28,11 @@
     }
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mjurczyk/openvdb.git",
+    "directory": "src/wvdb"
+  },
   "bin": {
     "wvdb": "./cli.mjs"
   }