@kitware/vtk.js 34.18.0 → 35.0.0

package/BREAKING_CHANGES.md

@@ -1,3 +1,8 @@
+## From 34.x to 35
+
+- **vtkMapper**: mappers should overwrite `computeBounds()` instead of `getBounds` that now calls `computeBounds()` before returning a copy of the mapper bounds.
+
+
 ## From 33.x to 34
 
 - **vtkMapper**: many properties have moved to `vtkVolumeProperty`. The full list of changed methods is: `getAnisotropy`, `getComputeNormalFromOpacity`, `getFilterMode`, `getFilterModeAsString`, `getGlobalIlluminationReach`, `getIpScalarRange`, `getIpScalarRangeByReference`, `getLAOKernelRadius`, `getLAOKernelSize`, `getLocalAmbientOcclusion`, `getPreferSizeOverAccuracy`, `getVolumetricScatteringBlending`, `setAnisotropy`, `setAverageIPScalarRange`, `setComputeNormalFromOpacity`, `setFilterMode`, `setFilterModeToNormalized`, `setFilterModeToOff`, `setFilterModeToRaw`, `setGlobalIlluminationReach`, `setIpScalarRange`, `setIpScalarRangeFrom`, `setLAOKernelRadius`, `setLAOKernelSize`, `setLocalAmbientOcclusion`, `setPreferSizeOverAccuracy`, `setVolumetricScatteringBlending`.

package/Common/DataModel/BoundingBox.d.ts

@@ -1,5 +1,5 @@
 import { mat4 } from 'gl-matrix';
-import { Bounds, Vector2, Vector3 } from './../../types';
+import { Bounds, TypedArray, Vector2, Vector3 } from './../../types';
 import vtkPoints from './../Core/Points';
 import { Nullable } from './../../types';
 
@@ -394,11 +394,16 @@ declare class BoundingBox {
   /**
    * Adds points to a bounding box.
    * @param {Bounds} bounds
-   * @param {number} x
+   * @param {number|Number[]|TypedArray} xOrPoint
    * @param {number} y
    * @param {number} z
    */
-  addPoint(bounds: Bounds, x: number, y: number, z: number): Bounds;
+  addPoint(
+    bounds: Bounds,
+    xOrPoint: number | number[] | TypedArray,
+    y?: number,
+    z?: number
+  ): Bounds;
 
   /**
    * Adds points to a bounding box.

package/Common/DataModel/BoundingBox.js

@@ -31,14 +31,23 @@ function setBounds(bounds, otherBounds) {
 function reset(bounds) {
   return setBounds(bounds, INIT_BOUNDS);
 }
-function addPoint(bounds, x, y, z) {
+function addPoint(bounds, xOrPoint, y, z) {
   const [xMin, xMax, yMin, yMax, zMin, zMax] = bounds;
-  bounds[0] = xMin < x ? xMin : x;
-  bounds[1] = xMax > x ? xMax : x;
-  bounds[2] = yMin < y ? yMin : y;
-  bounds[3] = yMax > y ? yMax : y;
-  bounds[4] = zMin < z ? zMin : z;
-  bounds[5] = zMax > z ? zMax : z;
+  if (typeof xOrPoint === 'number') {
+    bounds[0] = xMin < xOrPoint ? xMin : xOrPoint;
+    bounds[1] = xMax > xOrPoint ? xMax : xOrPoint;
+    bounds[2] = yMin < y ? yMin : y;
+    bounds[3] = yMax > y ? yMax : y;
+    bounds[4] = zMin < z ? zMin : z;
+    bounds[5] = zMax > z ? zMax : z;
+  } else {
+    bounds[0] = xMin < xOrPoint[0] ? xMin : xOrPoint[0];
+    bounds[1] = xMax > xOrPoint[0] ? xMax : xOrPoint[0];
+    bounds[2] = yMin < xOrPoint[1] ? yMin : xOrPoint[1];
+    bounds[3] = yMax > xOrPoint[1] ? yMax : xOrPoint[1];
+    bounds[4] = zMin < xOrPoint[2] ? zMin : xOrPoint[2];
+    bounds[5] = zMax > xOrPoint[2] ? zMax : xOrPoint[2];
+  }
   return bounds;
 }
 function addPoints(bounds, points) {

package/Common/DataModel/Box.js

@@ -117,7 +117,7 @@ function vtkBox(publicAPI, model) {
     }
     vtkBoundingBox.setBounds(model.bbox, boundsArray);
   };
-  publicAPI.getBounds = () => model.bbox;
+  publicAPI.getBounds = () => [...model.bbox];
   publicAPI.evaluateFunction = (x, y, z) => {
     const point = Array.isArray(x) ? x : [x, y, z];
     let diff;

package/Common/DataModel/PointSet.js

@@ -22,9 +22,9 @@ function vtkPointSet(publicAPI, model) {
     model.points = vtk(model.points);
   }
   publicAPI.getNumberOfPoints = () => model.points.getNumberOfPoints();
-  publicAPI.getBounds = () => model.points.getBounds();
+  publicAPI.getBounds = () => model.points?.getBounds();
   publicAPI.computeBounds = () => {
-    publicAPI.getBounds();
+    model.points?.computeBounds();
   };
   const superShallowCopy = publicAPI.shallowCopy;
   publicAPI.shallowCopy = (other, debug = false) => {

package/Proxy/Core/ViewProxy.js

@@ -321,7 +321,11 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setBackground = chain(model.renderer.setBackground, updateAnnotationColor);
+  publicAPI.setBackground = (...args) => {
+    const res = model.renderer.setBackground(...args);
+    updateAnnotationColor();
+    return res;
+  };
 
   // --------------------------------------------------------------------------
 

package/Rendering/Core/AbstractMapper3D.d.ts

@@ -15,11 +15,30 @@ export interface IAbstractMapper3DInitialValues
 export interface vtkAbstractMapper3D extends vtkAbstractMapper {
   /**
    * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
-   * @default 0
-   * @return {Bounds} The bounds for the mapper.
+   * Bounds are (re)computed if needed.
+   * @return {Bounds} A copy of the bounds for the mapper.
+   * @see getBoundsByReference
+   * @see computeBounds
    */
   getBounds(): Bounds;
 
+  /**
+   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * Bounds are (re)computed if needed.
+   * @return {Bounds} The bounds array of the mapper.
+   * @see getBounds
+   * @see computeBounds
+   */
+  getBoundsByReference(): Bounds;
+
+  /**
+   * Compute the bounds for this mapper.
+   * Must be implemented by sub-classes. Called by getBounds methods.
+   * @see getBoundsByReference
+   * @see getBounds
+   */
+  computeBounds(): void;
+
   /**
    * Get the center of this mapper’s data.
    * @return {Vector3} The center of the mapper's data.

package/Rendering/Core/AbstractMapper3D.js

@@ -1,24 +1,32 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { I as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkAbstractMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkAbstractMapper3D(publicAPI, model) {
+  publicAPI.computeBounds = () => {
+    macro.vtkErrorMacro(`vtkAbstractMapper3D.computeBounds - NOT IMPLEMENTED`);
+  };
+  const superGetBounds = publicAPI.getBounds;
   publicAPI.getBounds = () => {
-    macro.vtkErrorMacro(`vtkAbstractMapper3D.getBounds - NOT IMPLEMENTED`);
-    return createUninitializedBounds();
+    publicAPI.computeBounds();
+    return superGetBounds();
+  };
+  const superGetBoundsByReference = publicAPI.getBoundsByReference;
+  publicAPI.getBoundsByReference = () => {
+    publicAPI.computeBounds();
+    return superGetBoundsByReference();
   };
   publicAPI.getCenter = () => {
-    const bounds = publicAPI.getBounds();
+    const bounds = publicAPI.getBoundsByReference();
     model.center = vtkBoundingBox.isValid(bounds) ? vtkBoundingBox.getCenter(bounds) : null;
     return model.center?.slice();
   };
   publicAPI.getLength = () => {
-    const bounds = publicAPI.getBounds();
+    const bounds = publicAPI.getBoundsByReference();
     return vtkBoundingBox.getDiagonalLength(bounds);
   };
 }
@@ -41,6 +49,7 @@ function extend(publicAPI, model, initialValues = {}) {
   // Inheritance
   vtkAbstractMapper.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['viewSpecificProperties']);
+  macro.getArray(publicAPI, model, ['bounds'], 6);
   vtkAbstractMapper3D(publicAPI, model);
 }
 

package/Rendering/Core/CubeAxesActor.js

@@ -665,16 +665,19 @@ function vtkCubeAxesActor(publicAPI, model) {
   // as it relies on the pixel size of the window. Every time the camera
   // changes the bounds change. This method simplifies by just expanding
   // the grid bounds by a user specified factor.
-  publicAPI.getBounds = () => {
+  publicAPI.computeBounds = () => {
     publicAPI.update();
     vtkBoundingBox.setBounds(model.bounds, model.gridActor.getBounds());
     vtkBoundingBox.scaleAboutCenter(model.bounds, model.boundsScaleFactor, model.boundsScaleFactor, model.boundsScaleFactor);
-    return model.bounds;
   };
 
   // Make sure the grid share the actor property
-  const _setProp = macro.chain(publicAPI.setProperty, model.gridActor.setProperty);
-  publicAPI.setProperty = p => _setProp(p)[0];
+  const superSetProp = publicAPI.setProperty;
+  publicAPI.setProperty = p => {
+    const res = superSetProp(p);
+    model.gridActor.setProperty(p);
+    return res;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/Core/Glyph3DMapper.js

@@ -2,7 +2,7 @@ import { mat4, vec3, mat3 } from 'gl-matrix';
 import Constants from './Glyph3DMapper/Constants.js';
 import { m as macro } from '../../macros2.js';
 import vtkMapper from './Mapper.js';
-import { I as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
+import { n as norm } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 
 const {
@@ -60,21 +60,15 @@ function vtkGlyph3DMapper(publicAPI, model) {
     }
     return idata.getPointData().getArray(model.scaleArray);
   };
-  publicAPI.getBounds = () => {
-    const idata = publicAPI.getInputData(0);
-    const gdata = publicAPI.getInputData(1);
-    if (!idata || !gdata) {
-      return createUninitializedBounds();
-    }
-
-    // first we build the arrays used for the glyphing
-    publicAPI.buildArrays();
-    return model.bounds;
-  };
+  publicAPI.computeBounds = () => publicAPI.buildArrays();
   publicAPI.buildArrays = () => {
     // if the mtgime requires it, rebuild
     const idata = publicAPI.getInputData(0);
     const gdata = publicAPI.getInputData(1);
+    if (!idata || !gdata) {
+      vtkBoundingBox.reset(model.bounds);
+      return;
+    }
     if (model.buildTime.getMTime() < gdata.getMTime() || model.buildTime.getMTime() < idata.getMTime() || model.buildTime.getMTime() < publicAPI.getMTime()) {
       const pts = idata.getPoints().getData();
       let sArray = publicAPI.getScaleArrayData();
@@ -95,12 +89,7 @@ function vtkGlyph3DMapper(publicAPI, model) {
       // overall bounds while building the arrays
       const corners = [];
       vtkBoundingBox.getCorners(gbounds, corners);
-      model.bounds[0] = vtkBoundingBox.INIT_BOUNDS[0];
-      model.bounds[1] = vtkBoundingBox.INIT_BOUNDS[1];
-      model.bounds[2] = vtkBoundingBox.INIT_BOUNDS[2];
-      model.bounds[3] = vtkBoundingBox.INIT_BOUNDS[3];
-      model.bounds[4] = vtkBoundingBox.INIT_BOUNDS[4];
-      model.bounds[5] = vtkBoundingBox.INIT_BOUNDS[5];
+      vtkBoundingBox.reset(model.bounds);
       const tcorner = new Float64Array(3);
       const oArray = publicAPI.getOrientationArrayData();
       const identity = mat4.identity(new Float64Array(16));
@@ -193,24 +182,7 @@ function vtkGlyph3DMapper(publicAPI, model) {
         // update bounds
         for (let p = 0; p < 8; ++p) {
           vec3.transformMat4(tcorner, corners[p], z);
-          if (tcorner[0] < model.bounds[0]) {
-            model.bounds[0] = tcorner[0];
-          }
-          if (tcorner[1] < model.bounds[2]) {
-            model.bounds[2] = tcorner[1];
-          }
-          if (tcorner[2] < model.bounds[4]) {
-            model.bounds[4] = tcorner[2];
-          }
-          if (tcorner[0] > model.bounds[1]) {
-            model.bounds[1] = tcorner[0];
-          }
-          if (tcorner[1] > model.bounds[3]) {
-            model.bounds[3] = tcorner[1];
-          }
-          if (tcorner[2] > model.bounds[5]) {
-            model.bounds[5] = tcorner[2];
-          }
+          vtkBoundingBox.addPoint(model.bounds, tcorner);
         }
         const n = new Float32Array(nbuff, i * 36, 9);
         mat3.fromMat4(n, z);
@@ -276,10 +248,6 @@ function extend(publicAPI, model, initialValues = {}) {
   macro.obj(model.buildTime, {
     mtime: 0
   });
-  model.boundsTime = {};
-  macro.obj(model.boundsTime, {
-    mtime: 0
-  });
   macro.setGet(publicAPI, model, ['orient', 'orientationMode', 'orientationArray', 'scaleArray', 'scaleFactor', 'scaleMode', 'scaling']);
   macro.get(publicAPI, model, ['colorArray', 'matrixArray', 'normalArray', 'buildTime']);
 

package/Rendering/Core/ImageArrayMapper.js

@@ -1,5 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkImageMapper from './ImageMapper.js';
 import { I as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
@@ -80,13 +81,17 @@ function vtkImageArrayMapper(publicAPI, model) {
     }
     return null;
   };
-  publicAPI.getBounds = () => {
+
+  // reimplemented from AbstractMapper3D
+  publicAPI.computeBounds = () => {
     const image = publicAPI.getCurrentImage();
     if (!image) {
-      return createUninitializedBounds();
+      vtkBoundingBox.reset(model.bounds);
+      return;
     }
     if (!model.useCustomExtents) {
-      return image.getBounds();
+      vtkBoundingBox.setBounds(model.bounds, image.getBounds());
+      return;
     }
     const ex = model.customDisplayExtent.slice();
     // use sub-slice of the current image,
@@ -94,7 +99,7 @@ function vtkImageArrayMapper(publicAPI, model) {
     const nSlice = publicAPI.getSubSlice();
     ex[4] = nSlice;
     ex[5] = nSlice;
-    return image.extentToBounds(ex);
+    vtkBoundingBox.setBounds(model.bounds, image.extentToBounds(ex));
   };
   publicAPI.getBoundsForSlice = (slice = publicAPI.getSlice(), halfThickness = 0) => {
     const image = publicAPI.getImage(slice);

package/Rendering/Core/ImageCPRMapper.js

@@ -1,4 +1,5 @@
 import { quat, vec3, mat4 } from 'gl-matrix';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { m as macro } from '../../macros2.js';
@@ -26,12 +27,12 @@ function vtkImageCPRMapper(publicAPI, model) {
   };
 
   /**
-   * Public methods
+   * Reimplemented from AbstractMapper3D
    */
-  publicAPI.getBounds = () => {
+  publicAPI.computeBounds = () => {
     const imageWidth = publicAPI.getWidth();
     const imageHeight = publicAPI.getHeight();
-    return [0, imageWidth, 0, imageHeight, 0, 0];
+    vtkBoundingBox.setBounds(model.bounds, [0, imageWidth, 0, imageHeight, 0, 0]);
   };
   publicAPI.getOrientationDataArray = () => {
     const pointData = publicAPI.getInputData(1)?.getPointData();

package/Rendering/Core/ImageMapper.js

@@ -1,6 +1,7 @@
 import Constants from './ImageMapper/Constants.js';
 import { m as macro } from '../../macros2.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
 import { F as clampValue, U as multiply3x3_vect3, I as createUninitializedBounds, V as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
@@ -186,13 +187,15 @@ function vtkImageMapper(publicAPI, model) {
     }
     return model.closestIJKAxis;
   };
-  publicAPI.getBounds = () => {
+  publicAPI.computeBounds = () => {
     const image = publicAPI.getCurrentImage();
     if (!image) {
-      return createUninitializedBounds();
+      vtkBoundingBox.reset(model.bounds);
+      return;
     }
     if (!model.useCustomExtents) {
-      return image.getBounds();
+      vtkBoundingBox.setBounds(model.bounds, image.getBounds());
+      return;
     }
     const ex = model.customDisplayExtent.slice();
     const {
@@ -217,7 +220,7 @@ function vtkImageMapper(publicAPI, model) {
         ex[5] = nSlice;
         break;
     }
-    return image.extentToBounds(ex);
+    vtkBoundingBox.setBounds(model.bounds, image.extentToBounds(ex));
   };
   publicAPI.getBoundsForSlice = (slice = model.slice, halfThickness = 0) => {
     const image = publicAPI.getCurrentImage();

package/Rendering/Core/ImageResliceMapper.js

@@ -19,18 +19,18 @@ const {
 function vtkImageResliceMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageResliceMapper');
-  publicAPI.getBounds = () => {
-    let bds = [...vtkBoundingBox.INIT_BOUNDS];
+  publicAPI.computeBounds = () => {
     const image = publicAPI.getInputData();
     if (publicAPI.getSlicePolyData()) {
-      bds = publicAPI.getSlicePolyData().getBounds();
+      vtkBoundingBox.setBounds(model.bounds, publicAPI.getSlicePolyData().getBounds());
     } else if (image) {
-      bds = image.getBounds();
+      vtkBoundingBox.setBounds(model.bounds, image.getBounds());
       if (publicAPI.getSlicePlane()) {
-        vtkBoundingBox.cutWithPlane(bds, publicAPI.getSlicePlane().getOrigin(), publicAPI.getSlicePlane().getNormal());
+        vtkBoundingBox.cutWithPlane(model.bounds, publicAPI.getSlicePlane().getOrigin(), publicAPI.getSlicePlane().getNormal());
       }
+    } else {
+      vtkBoundingBox.reset(model.bounds);
     }
-    return bds;
   };
 }
 

package/Rendering/Core/ImageSlice.js

@@ -55,22 +55,22 @@ function vtkImageSlice(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   // Get the minimum X bound
-  publicAPI.getMinXBound = () => publicAPI.getBounds()[0];
+  publicAPI.getMinXBound = () => publicAPI.getBoundsByReference()[0];
 
   // Get the maximum X bound
-  publicAPI.getMaxXBound = () => publicAPI.getBounds()[1];
+  publicAPI.getMaxXBound = () => publicAPI.getBoundsByReference()[1];
 
   // Get the minimum Y bound
-  publicAPI.getMinYBound = () => publicAPI.getBounds()[2];
+  publicAPI.getMinYBound = () => publicAPI.getBoundsByReference()[2];
 
   // Get the maximum Y bound
-  publicAPI.getMaxYBound = () => publicAPI.getBounds()[3];
+  publicAPI.getMaxYBound = () => publicAPI.getBoundsByReference()[3];
 
   // Get the minimum Z bound
-  publicAPI.getMinZBound = () => publicAPI.getBounds()[4];
+  publicAPI.getMinZBound = () => publicAPI.getBoundsByReference()[4];
 
   // Get the maximum Z bound
-  publicAPI.getMaxZBound = () => publicAPI.getBounds()[5];
+  publicAPI.getMaxZBound = () => publicAPI.getBoundsByReference()[5];
   publicAPI.getRedrawMTime = () => {
     let mt = model.mtime;
     if (model.mapper !== null) {

package/Rendering/Core/Mapper.js

@@ -1,9 +1,10 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractMapper3D from './AbstractMapper3D.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkLookupTable from '../../Common/Core/LookupTable.js';
-import { I as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
+import { i as isNan } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors/Constants.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import Constants from './Mapper/Constants.js';
@@ -268,17 +269,16 @@ function getOrCreateColorTextureCoordinates(input, component, range, useLogScale
 function vtkMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMapper');
-  publicAPI.getBounds = () => {
+  publicAPI.computeBounds = () => {
     const input = publicAPI.getInputData();
     if (!input) {
-      model.bounds = createUninitializedBounds();
+      vtkBoundingBox.reset(model.bounds);
     } else {
       if (!model.static) {
         publicAPI.update();
       }
-      model.bounds = input.getBounds();
+      vtkBoundingBox.setBounds(model.bounds, input.getBounds());
     }
-    return model.bounds;
   };
   publicAPI.setForceCompileOnly = v => {
     model.forceCompileOnly = v;

package/Rendering/Core/Prop3D.js

@@ -128,24 +128,20 @@ function vtkProp3D(publicAPI, model) {
       model.matrixMTime.modified();
     }
   };
-  publicAPI.getBoundsByReference = () => {
+  publicAPI.computeBounds = () => {
     if (model.mapper === null) {
-      return model.bounds;
+      vtkBoundingBox.reset(model.bounds);
+      return;
     }
 
-    // Check for the special case when the mapper's bounds are unknown
+    // Check for the special case when the mapper's bounds are invalid
     const bds = model.mapper.getBounds();
-    if (!bds || bds.length !== 6) {
-      return bds;
-    }
-
-    // Check for the special case when the actor is empty.
-    if (bds[0] > bds[1]) {
+    if (!bds || bds.length !== 6 || !vtkBoundingBox.isValid(bds)) {
       // No need to copy bds, a new array is created when calling getBounds()
       model.mapperBounds = bds;
-      model.bounds = [...vtkBoundingBox.INIT_BOUNDS];
+      vtkBoundingBox.reset(model.bounds);
       model.boundsMTime.modified();
-      return bds;
+      return;
     }
 
     // Check if we have cached values for these bounds - we cache the
@@ -165,22 +161,22 @@ function vtkProp3D(publicAPI, model) {
       vtkBoundingBox.transformBounds(bds, transposedMatrix, model.bounds);
       model.boundsMTime.modified();
     }
-    return model.bounds;
   };
+  const superGetBounds = publicAPI.getBounds;
   publicAPI.getBounds = () => {
-    const bounds = publicAPI.getBoundsByReference();
-    // Handle case when bounds are not iterable (for example null or undefined)
-    try {
-      return [...bounds];
-    } catch {
-      return bounds;
-    }
+    publicAPI.computeBounds();
+    return superGetBounds();
+  };
+  const superGetBoundsByReference = publicAPI.getBoundsByReference;
+  publicAPI.getBoundsByReference = () => {
+    publicAPI.computeBounds();
+    return superGetBoundsByReference();
   };
-  publicAPI.getCenter = () => vtkBoundingBox.getCenter(model.bounds);
-  publicAPI.getLength = () => vtkBoundingBox.getLength(model.bounds);
-  publicAPI.getXRange = () => vtkBoundingBox.getXRange(model.bounds);
-  publicAPI.getYRange = () => vtkBoundingBox.getYRange(model.bounds);
-  publicAPI.getZRange = () => vtkBoundingBox.getZRange(model.bounds);
+  publicAPI.getCenter = () => vtkBoundingBox.getCenter(publicAPI.getBoundsByReference());
+  publicAPI.getLength = () => vtkBoundingBox.getLength(publicAPI.getBoundsByReference());
+  publicAPI.getXRange = () => vtkBoundingBox.getXRange(publicAPI.getBoundsByReference());
+  publicAPI.getYRange = () => vtkBoundingBox.getYRange(publicAPI.getBoundsByReference());
+  publicAPI.getZRange = () => vtkBoundingBox.getZRange(publicAPI.getBoundsByReference());
   publicAPI.getUserMatrix = () => model.userMatrix;
   function updateIdentityFlag() {
     publicAPI.computeMatrix();
@@ -227,12 +223,12 @@ function vtkProp3D(publicAPI, model) {
 // ----------------------------------------------------------------------------
 
 const DEFAULT_VALUES = {
+  bounds: [...vtkBoundingBox.INIT_BOUNDS],
   origin: [0, 0, 0],
   position: [0, 0, 0],
   orientation: [0, 0, 0],
   rotation: null,
   scale: [1, 1, 1],
-  bounds: [...vtkBoundingBox.INIT_BOUNDS],
   properties: [],
   userMatrix: null,
   userMatrixMTime: null,
@@ -256,6 +252,7 @@ function extend(publicAPI, model, initialValues = {}) {
   macro.getArray(publicAPI, model, ['orientation']);
   macro.setGetArray(publicAPI, model, ['origin', 'position', 'scale'], 3);
   macro.setGet(publicAPI, model, ['properties']);
+  macro.getArray(publicAPI, model, ['bounds'], 6);
 
   // Object internal instance
   model.matrix = mat4.identity(new Float64Array(16));

package/Rendering/Core/VolumeMapper.js

@@ -40,12 +40,16 @@ function vtkVolumeMapper(publicAPI, model) {
   const superClass = {
     ...publicAPI
   };
-  publicAPI.getBounds = () => {
+  publicAPI.computeBounds = () => {
+    const input = publicAPI.getInputData();
+    if (!input) {
+      vtkBoundingBox.reset(model.bounds);
+      return;
+    }
     if (!model.static) {
       publicAPI.update();
     }
-    model.bounds = [...publicAPI.getInputData().getBounds()];
-    return model.bounds;
+    vtkBoundingBox.setBounds(model.bounds, input.getBounds());
   };
   publicAPI.setBlendModeToComposite = () => {
     publicAPI.setBlendMode(BlendMode.COMPOSITE_BLEND);

package/Widgets/Representations/ArrowHandleRepresentation.js

@@ -137,7 +137,13 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, r => model._pipeline.glyph.setPhiResolution(r), r => model._pipeline.glyph.setThetaResolution(r));
+  const superSetGlyphResolution = publicAPI.setGlyphResolution;
+  publicAPI.setGlyphResolution = r => {
+    const res = superSetGlyphResolution(r);
+    model._pipeline.glyph.setPhiResolution(r);
+    model._pipeline.glyph.setThetaResolution(r);
+    return res;
+  };
 
   // --------------------------------------------------------------------------
 

package/Widgets/Representations/CircleContextRepresentation.js

@@ -12,6 +12,9 @@ import { Resolve } from '../../Rendering/Core/Mapper/Static.js';
 function vtkCircleContextRepresentation(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCircleContextRepresentation');
+  const superClass = {
+    ...publicAPI
+  };
 
   // --------------------------------------------------------------------------
   // Generic rendering pipeline
@@ -23,15 +26,27 @@ function vtkCircleContextRepresentation(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setResolution);
+  publicAPI.setGlyphResolution = r => {
+    const res = superClass.setGlyphResolution(r);
+    model._pipeline.glyph.setResolution(r);
+    return res;
+  };
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setDrawBorder = macro.chain(publicAPI.setDrawBorder, draw => model._pipeline.glyph.setLines(draw));
+  publicAPI.setDrawBorder = draw => {
+    const res = superClass.setDrawBorder(draw);
+    model._pipeline.glyph.setLines(draw);
+    return res;
+  };
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setDrawFace = macro.chain(publicAPI.setDrawFace, draw => model._pipeline.glyph.setFace(draw));
+  publicAPI.setDrawFace = draw => {
+    const res = superClass.setDrawFace(draw);
+    model._pipeline.glyph.setFace(draw);
+    return res;
+  };
 
   // --------------------------------------------------------------------------
 

package/Widgets/Representations/SplineContextRepresentation.js

@@ -112,11 +112,18 @@ function vtkSplineContextRepresentation(publicAPI, model) {
     model._pipelines.border.actor.getProperty().setColor(...(inPoints.length <= 3 || model._pipelines.area.filter.getErrorCount() === 0 ? model.borderColor : model.errorBorderColor));
   };
   publicAPI.getSelectedState = (prop, compositeID) => model.state;
-  function updateAreaVisibility() {
-    model._pipelines.area.actor.setVisibility(model.fill);
-  }
-  publicAPI.setFill = macro.chain(publicAPI.setFill, updateAreaVisibility);
-  publicAPI.setOutputBorder = macro.chain(publicAPI.setOutputBorder, v => model._pipelines.border.actor.setVisibility(v));
+  const superSetFill = publicAPI.setFill;
+  publicAPI.setFill = fill => {
+    const res = superSetFill(fill);
+    model._pipelines.area.actor.setVisibility(fill);
+    return res;
+  };
+  const superSetOutputBorder = publicAPI.setOutputBorder;
+  publicAPI.setOutputBorder = v => {
+    const res = superSetOutputBorder(v);
+    model._pipelines.border.actor.setVisibility(v);
+    return res;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -401,10 +401,13 @@ function vtkResliceCursorWidget(publicAPI, model) {
     res[viewType] = findRepresentationsForViewType(viewType)[0]?.getDisplayScaleParams?.();
     return res;
   }, {});
-  publicAPI.setScaleInPixels = macro.chain(publicAPI.setScaleInPixels, scale => {
+  const superSetScaleInPixels = publicAPI.setScaleInPixels;
+  publicAPI.setScaleInPixels = scale => {
+    const res = superSetScaleInPixels(scale);
     publicAPI.getViewWidgets().forEach(w => w.setScaleInPixels(scale));
     updateState(model.widgetState, model.scaleInPixels, model.rotationHandlePosition);
-  });
+    return res;
+  };
   publicAPI.getPlaneExtremities = viewType => {
     const dirProj = publicAPI.getWidgetState().getPlanes()[viewType].normal;
     const length = vtkBoundingBox.getDiagonalLength(publicAPI.getWidgetState().getImage().getBounds());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.18.0",
+  "version": "35.0.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",