@kitware/vtk.js 34.17.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/CONTRIBUTING.md

@@ -128,7 +128,7 @@ The vtk.js documentation is part of the code repository and is entirely written
 
 If you create an example, please list it in the [examples landing page](Documentation/content/examples/index.md).
 
-Images and GIF videos added to the [gallery](Documentation/public/gallery) must be compressed as much as possible (e.g. 432px by 300px with 50% JPEG compression). You may want to use [ezgif.com](https://ezgif.com/).
+Images and GIF videos added to the [gallery](Documentation/public/gallery) must be compressed as much as possible (e.g. 500px by 280px with 50% JPEG compression). You may want to use [ezgif.com](https://ezgif.com/).
 
 ## Reporting Issues
 

package/Common/Core/Math/index.js

@@ -1928,6 +1928,18 @@ function getMajorAxisIndex(vector) {
   }
   return axisIndex;
 }
+function getMinorAxisIndex(vector) {
+  let minValue = Infinity;
+  let axisIndex = -1;
+  for (let i = 0; i < vector.length; i++) {
+    const value = Math.abs(vector[i]);
+    if (value < minValue) {
+      axisIndex = i;
+      minValue = value;
+    }
+  }
+  return axisIndex;
+}
 
 // Return the closest orthogonal matrix of 1, -1 and 0
 // It works for both column major and row major matrices
@@ -2110,6 +2122,7 @@ var vtkMath = {
   // JS add-on
   createUninitializedBounds,
   getMajorAxisIndex,
+  getMinorAxisIndex,
   getSparseOrthogonalMatrix,
   floatToHex2,
   floatRGB2HexCode,
@@ -2232,6 +2245,7 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   isNan: isNan,
   createUninitializedBounds: createUninitializedBounds,
   getMajorAxisIndex: getMajorAxisIndex,
+  getMinorAxisIndex: getMinorAxisIndex,
   getSparseOrthogonalMatrix: getSparseOrthogonalMatrix,
   floatToHex2: floatToHex2,
   floatRGB2HexCode: floatRGB2HexCode,
@@ -2239,4 +2253,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { createArray as $, rowsToMat3 as A, degreesFromRadians as B, ldexp as C, xyz2rgb as D, areEquals as E, clampValue as F, arrayRange as G, getMajorAxisIndex as H, createUninitializedBounds as I, normalize4D as J, identity as K, multiplyMatrix as L, floor as M, isInf as N, rgb2hsv as O, rgb2lab as P, lab2rgb as Q, round as R, normalize2D as S, nearestPowerOfTwo as T, multiply3x3_vect3 as U, getSparseOrthogonalMatrix as V, areBoundsInitialized as W, floatRGB2HexCode as X, isPowerOfTwo as Y, angleBetweenVectors as Z, signedAngleBetweenVectors as _, areMatricesEqual as a, isNaN as a$, Pi as a0, ceil as a1, min as a2, max as a3, arrayMin as a4, arrayMax as a5, ceilLog2 as a6, factorial as a7, binomial as a8, beginCombination as a9, quaternionToMatrix3x3 as aA, roundNumber as aB, matrix3x3ToQuaternion as aC, multiplyQuaternion as aD, orthogonalize3x3 as aE, diagonalize3x3 as aF, singularValueDecomposition3x3 as aG, luFactorLinearSystem as aH, luSolveLinearSystem as aI, estimateMatrixCondition as aJ, solveHomogeneousLeastSquares as aK, solveLeastSquares as aL, hex2float as aM, lab2xyz as aN, xyz2lab as aO, rgb2xyz as aP, computeBoundsFromPoints as aQ, clampAndNormalizeValue as aR, getScalarTypeFittingRange as aS, getAdjustedScalarRange as aT, extentIsWithinOtherExtent as aU, boundsIsWithinOtherBounds as aV, pointIsWithinBounds as aW, solve3PointCircle as aX, inf as aY, negInf as aZ, isFinite as a_, nextCombination as aa, randomSeed as ab, getSeed as ac, gaussian as ad, multiplyScalar2D as ae, multiplyAccumulate2D as af, outer as ag, projectVector as ah, dot2D as ai, projectVector2D as aj, gaussianAmplitude as ak, gaussianWeight as al, outer2D as am, norm2D as an, rowsToMat4 as ao, columnsToMat4 as ap, columnsToMat3 as aq, LUFactor3x3 as ar, LUSolve3x3 as as, linearSolve3x3 as at, multiply3x3_mat3 as au, transpose3x3 as av, invert3x3 as aw, identity3x3 as ax, isIdentity as ay, isIdentity3x3 as az, vtkMath as b, floatToHex2 as b0, float2CssRGBA as b1, roundVector as c, dot as d, clampVector as e, distance2BetweenPoints as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, invertMatrix as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };
+export { createArray as $, rowsToMat3 as A, degreesFromRadians as B, ldexp as C, xyz2rgb as D, areEquals as E, clampValue as F, arrayRange as G, getMajorAxisIndex as H, createUninitializedBounds as I, normalize4D as J, identity as K, multiplyMatrix as L, floor as M, isInf as N, rgb2hsv as O, rgb2lab as P, lab2rgb as Q, round as R, normalize2D as S, nearestPowerOfTwo as T, multiply3x3_vect3 as U, getSparseOrthogonalMatrix as V, areBoundsInitialized as W, floatRGB2HexCode as X, isPowerOfTwo as Y, angleBetweenVectors as Z, signedAngleBetweenVectors as _, areMatricesEqual as a, isNaN as a$, Pi as a0, ceil as a1, min as a2, max as a3, arrayMin as a4, arrayMax as a5, ceilLog2 as a6, factorial as a7, binomial as a8, beginCombination as a9, quaternionToMatrix3x3 as aA, roundNumber as aB, matrix3x3ToQuaternion as aC, multiplyQuaternion as aD, orthogonalize3x3 as aE, diagonalize3x3 as aF, singularValueDecomposition3x3 as aG, luFactorLinearSystem as aH, luSolveLinearSystem as aI, estimateMatrixCondition as aJ, solveHomogeneousLeastSquares as aK, solveLeastSquares as aL, hex2float as aM, lab2xyz as aN, xyz2lab as aO, rgb2xyz as aP, computeBoundsFromPoints as aQ, clampAndNormalizeValue as aR, getScalarTypeFittingRange as aS, getAdjustedScalarRange as aT, extentIsWithinOtherExtent as aU, boundsIsWithinOtherBounds as aV, pointIsWithinBounds as aW, solve3PointCircle as aX, inf as aY, negInf as aZ, isFinite as a_, nextCombination as aa, randomSeed as ab, getSeed as ac, gaussian as ad, multiplyScalar2D as ae, multiplyAccumulate2D as af, outer as ag, projectVector as ah, dot2D as ai, projectVector2D as aj, gaussianAmplitude as ak, gaussianWeight as al, outer2D as am, norm2D as an, rowsToMat4 as ao, columnsToMat4 as ap, columnsToMat3 as aq, LUFactor3x3 as ar, LUSolve3x3 as as, linearSolve3x3 as at, multiply3x3_mat3 as au, transpose3x3 as av, invert3x3 as aw, identity3x3 as ax, isIdentity as ay, isIdentity3x3 as az, vtkMath as b, getMinorAxisIndex as b0, floatToHex2 as b1, float2CssRGBA as b2, roundVector as c, dot as d, clampVector as e, distance2BetweenPoints as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, invertMatrix as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };

package/Common/Core/Math.d.ts

@@ -1074,6 +1074,13 @@ export function createUninitializedBounds(): Bounds;
  */
 export function getMajorAxisIndex(vector: number[]): number;
 
+/**
+ * Return the index of the component with the smallest absolute value.
+ * Returns -1 for empty arrays.
+ * @param {Number[]} vector
+ */
+export function getMinorAxisIndex(vector: number[]): number;
+
 /**
  * Return the closest orthogonal matrix of 1, -1 and 0
  * It works for both column major and row major matrices
@@ -1244,6 +1251,7 @@ export declare const vtkMath: {
   isInf: typeof isInf;
   createUninitializedBounds: typeof createUninitializedBounds;
   getMajorAxisIndex: typeof getMajorAxisIndex;
+  getMinorAxisIndex: typeof getMinorAxisIndex;
   getSparseOrthogonalMatrix: typeof getSparseOrthogonalMatrix;
   floatToHex2: typeof floatToHex2;
   floatRGB2HexCode: typeof floatRGB2HexCode;

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import 'seedrandom';
 import '../../macros2.js';
 import './Math/Constants.js';
-export { ar as LUFactor3x3, as as LUSolve3x3, a0 as Pi, k as add, Z as angleBetweenVectors, W as areBoundsInitialized, E as areEquals, a as areMatricesEqual, a5 as arrayMax, a4 as arrayMin, G as arrayRange, a9 as beginCombination, a8 as binomial, aV as boundsIsWithinOtherBounds, a1 as ceil, a6 as ceilLog2, aR as clampAndNormalizeValue, F as clampValue, e as clampVector, aq as columnsToMat3, ap as columnsToMat4, aQ as computeBoundsFromPoints, $ as createArray, I as createUninitializedBounds, j as cross, b as default, B as degreesFromRadians, o as determinant2x2, z as determinant3x3, aF as diagonalize3x3, f as distance2BetweenPoints, d as dot, ai as dot2D, aJ as estimateMatrixCondition, aU as extentIsWithinOtherExtent, a7 as factorial, b1 as float2CssRGBA, X as floatRGB2HexCode, b0 as floatToHex2, M as floor, ad as gaussian, ak as gaussianAmplitude, al as gaussianWeight, aT as getAdjustedScalarRange, H as getMajorAxisIndex, aS as getScalarTypeFittingRange, ac as getSeed, V as getSparseOrthogonalMatrix, aM as hex2float, h as hsv2rgb, K as identity, ax as identity3x3, aY as inf, aw as invert3x3, p as invertMatrix, a_ as isFinite, ay as isIdentity, az as isIdentity3x3, N as isInf, a$ as isNaN, i as isNan, Y as isPowerOfTwo, w as jacobi, q as jacobiN, Q as lab2rgb, aN as lab2xyz, C as ldexp, at as linearSolve3x3, aH as luFactorLinearSystem, aI as luSolveLinearSystem, aC as matrix3x3ToQuaternion, a3 as max, a2 as min, au as multiply3x3_mat3, U as multiply3x3_vect3, m as multiplyAccumulate, af as multiplyAccumulate2D, L as multiplyMatrix, aD as multiplyQuaternion, x as multiplyScalar, ae as multiplyScalar2D, T as nearestPowerOfTwo, aZ as negInf, aa as nextCombination, n as norm, an as norm2D, l as normalize, S as normalize2D, J as normalize4D, aE as orthogonalize3x3, ag as outer, am as outer2D, t as perpendiculars, aW as pointIsWithinBounds, ah as projectVector, aj as projectVector2D, aA as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, ab as randomSeed, O as rgb2hsv, P as rgb2lab, aP as rgb2xyz, R as round, aB as roundNumber, c as roundVector, A as rowsToMat3, ao as rowsToMat4, _ as signedAngleBetweenVectors, aG as singularValueDecomposition3x3, aX as solve3PointCircle, aK as solveHomogeneousLeastSquares, aL as solveLeastSquares, g as solveLinearSystem, s as subtract, av as transpose3x3, u as uninitializeBounds, aO as xyz2lab, D as xyz2rgb } from './Math/index.js';
+export { ar as LUFactor3x3, as as LUSolve3x3, a0 as Pi, k as add, Z as angleBetweenVectors, W as areBoundsInitialized, E as areEquals, a as areMatricesEqual, a5 as arrayMax, a4 as arrayMin, G as arrayRange, a9 as beginCombination, a8 as binomial, aV as boundsIsWithinOtherBounds, a1 as ceil, a6 as ceilLog2, aR as clampAndNormalizeValue, F as clampValue, e as clampVector, aq as columnsToMat3, ap as columnsToMat4, aQ as computeBoundsFromPoints, $ as createArray, I as createUninitializedBounds, j as cross, b as default, B as degreesFromRadians, o as determinant2x2, z as determinant3x3, aF as diagonalize3x3, f as distance2BetweenPoints, d as dot, ai as dot2D, aJ as estimateMatrixCondition, aU as extentIsWithinOtherExtent, a7 as factorial, b2 as float2CssRGBA, X as floatRGB2HexCode, b1 as floatToHex2, M as floor, ad as gaussian, ak as gaussianAmplitude, al as gaussianWeight, aT as getAdjustedScalarRange, H as getMajorAxisIndex, b0 as getMinorAxisIndex, aS as getScalarTypeFittingRange, ac as getSeed, V as getSparseOrthogonalMatrix, aM as hex2float, h as hsv2rgb, K as identity, ax as identity3x3, aY as inf, aw as invert3x3, p as invertMatrix, a_ as isFinite, ay as isIdentity, az as isIdentity3x3, N as isInf, a$ as isNaN, i as isNan, Y as isPowerOfTwo, w as jacobi, q as jacobiN, Q as lab2rgb, aN as lab2xyz, C as ldexp, at as linearSolve3x3, aH as luFactorLinearSystem, aI as luSolveLinearSystem, aC as matrix3x3ToQuaternion, a3 as max, a2 as min, au as multiply3x3_mat3, U as multiply3x3_vect3, m as multiplyAccumulate, af as multiplyAccumulate2D, L as multiplyMatrix, aD as multiplyQuaternion, x as multiplyScalar, ae as multiplyScalar2D, T as nearestPowerOfTwo, aZ as negInf, aa as nextCombination, n as norm, an as norm2D, l as normalize, S as normalize2D, J as normalize4D, aE as orthogonalize3x3, ag as outer, am as outer2D, t as perpendiculars, aW as pointIsWithinBounds, ah as projectVector, aj as projectVector2D, aA as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, ab as randomSeed, O as rgb2hsv, P as rgb2lab, aP as rgb2xyz, R as round, aB as roundNumber, c as roundVector, A as rowsToMat3, ao as rowsToMat4, _ as signedAngleBetweenVectors, aG as singularValueDecomposition3x3, aX as solve3PointCircle, aK as solveHomogeneousLeastSquares, aL as solveLeastSquares, g as solveLinearSystem, s as subtract, av as transpose3x3, u as uninitializeBounds, aO as xyz2lab, D as xyz2rgb } from './Math/index.js';

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/Filters/General/WindowedSincPolyDataFilter.js

@@ -2,7 +2,6 @@ import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { b as vtkMath } from '../../Common/Core/Math/index.js';
-import { AttributeTypes } from '../../Common/DataModel/DataSetAttributes/Constants.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
@@ -484,8 +483,7 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
         numberOfComponents: 1,
         values: newScalars
       });
-      const idx = output.getPointData().addArray(newScalarsArray);
-      output.getPointData().setActiveAttribute(idx, AttributeTypes.SCALARS);
+      output.getPointData().setScalars(newScalarsArray);
     }
     if (model.generateErrorVectors) {
       const newVectors = new Float32Array(3 * numPts);
@@ -513,7 +511,7 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
     if (!input) {
       return;
     }
-    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
+    const output = outData[0] || vtkPolyData.newInstance();
     const outputPoints = publicAPI.vtkWindowedSincPolyDataFilterExecute(input.getPoints(), input, output);
     output.setPointData(input.getPointData());
     output.setCellData(input.getCellData());

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/AbstractImageMapper.d.ts

@@ -10,6 +10,10 @@ export interface IAbstractImageMapperInitialValues
   customDisplayExtent?: number[];
   useCustomExtents?: boolean;
   slice?: number;
+  backgroundColor?: RGBAColor;
+  colorTextureWidth?: number;
+  opacityTextureWidth?: number;
+  labelOutlineTextureWidth?: number;
 }
 
 export interface vtkAbstractImageMapper extends vtkAbstractMapper3D {

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/ImageProperty.d.ts

@@ -21,6 +21,7 @@ export interface IImagePropertyInitialValues {
   useLookupTableScalarRange?: boolean;
   useLabelOutline?: boolean;
   labelOutlineThickness?: number | number[];
+  labelOutlineOpacity?: number | number[];
 }
 
 export interface vtkImageProperty extends vtkObject {
@@ -127,6 +128,12 @@ export interface vtkImageProperty extends vtkObject {
    */
   getLabelOutlineThickness(): number;
 
+  /**
+   * Get the label outline thickness array by reference.
+   * This returns the actual internal array, not a copy.
+   */
+  getLabelOutlineThicknessByReference(): number[];
+
   /**
    * It will set the label outline thickness for the labelmaps. It can accept
    * a single number or an array of numbers. If a single number is provided,

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;