@kitware/vtk.js 29.5.1 → 29.7.0

package/Common/Core/Math/index.js

@@ -544,7 +544,7 @@ function multiply3x3_mat3(a_3x3, b_3x3, out_3x3) {
     out_3x3[i + 6] = copyA[6] * copyB[i] + copyA[7] * copyB[i + 3] + copyA[8] * copyB[i + 6];
   }
 }
-function multiplyMatrix(a, b, rowA, colA, rowB, colB, out_rowXcol) {
+function multiplyMatrix(a, b, rowA, colA, rowB, colB, outRowAColB) {
   // we need colA == rowB
   if (colA !== rowB) {
     vtkErrorMacro('Number of columns of A must match number of rows of B.');
@@ -558,10 +558,10 @@ function multiplyMatrix(a, b, rowA, colA, rowB, colB, out_rowXcol) {
   for (let i = 0; i < rowA; i++) {
     // output col
     for (let j = 0; j < colB; j++) {
-      out_rowXcol[i * colB + j] = 0;
+      outRowAColB[i * colB + j] = 0;
       // sum for this point
       for (let k = 0; k < colA; k++) {
-        out_rowXcol[i * colB + j] += copyA[i * colA + k] * copyB[j + colB * k];
+        outRowAColB[i * colB + j] += copyA[i * colA + k] * copyB[j + colB * k];
       }
     }
   }
@@ -2245,4 +2245,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { arrayMax as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, isIdentity3x3 as G, floor as H, isInf as I, rgb2hsv as J, rgb2lab as K, lab2rgb as L, round as M, normalize2D as N, nearestPowerOfTwo as O, multiply3x3_vect3 as P, getSparseOrthogonalMatrix as Q, areBoundsInitialized as R, isPowerOfTwo as S, angleBetweenVectors as T, signedAngleBetweenVectors as U, createArray as V, Pi as W, ceil as X, min as Y, max as Z, arrayMin as _, areMatricesEqual as a, float2CssRGBA as a$, ceilLog2 as a0, factorial as a1, binomial as a2, beginCombination as a3, nextCombination as a4, randomSeed as a5, getSeed as a6, gaussian as a7, multiplyScalar2D as a8, multiplyAccumulate2D as a9, diagonalize3x3 as aA, singularValueDecomposition3x3 as aB, luFactorLinearSystem as aC, luSolveLinearSystem as aD, invertMatrix as aE, estimateMatrixCondition as aF, solveHomogeneousLeastSquares as aG, solveLeastSquares as aH, hex2float as aI, lab2xyz as aJ, xyz2lab as aK, xyz2rgb as aL, rgb2xyz as aM, computeBoundsFromPoints as aN, clampAndNormalizeValue as aO, getScalarTypeFittingRange as aP, getAdjustedScalarRange as aQ, extentIsWithinOtherExtent as aR, boundsIsWithinOtherBounds as aS, pointIsWithinBounds as aT, solve3PointCircle as aU, inf as aV, negInf as aW, isFinite as aX, isNaN as aY, floatToHex2 as aZ, floatRGB2HexCode as a_, outer as aa, projectVector as ab, dot2D as ac, projectVector2D as ad, gaussianAmplitude as ae, gaussianWeight as af, outer2D as ag, norm2D as ah, rowsToMat4 as ai, columnsToMat4 as aj, columnsToMat3 as ak, LUFactor3x3 as al, LUSolve3x3 as am, linearSolve3x3 as an, multiply3x3_mat3 as ao, multiplyMatrix as ap, transpose3x3 as aq, invert3x3 as ar, identity3x3 as as, identity as at, isIdentity as au, quaternionToMatrix3x3 as av, roundNumber as aw, matrix3x3ToQuaternion as ax, multiplyQuaternion as ay, orthogonalize3x3 as az, roundVector as b, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath 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, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };
+export { max as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, isIdentity3x3 as G, identity as H, multiplyMatrix as I, floor as J, isInf as K, rgb2hsv as L, rgb2lab as M, lab2rgb as N, round as O, normalize2D as P, nearestPowerOfTwo as Q, multiply3x3_vect3 as R, getSparseOrthogonalMatrix as S, areBoundsInitialized as T, isPowerOfTwo as U, angleBetweenVectors as V, signedAngleBetweenVectors as W, createArray as X, Pi as Y, ceil as Z, min as _, areMatricesEqual as a, float2CssRGBA as a$, arrayMin as a0, arrayMax as a1, ceilLog2 as a2, factorial as a3, binomial as a4, beginCombination as a5, nextCombination as a6, randomSeed as a7, getSeed as a8, gaussian as a9, diagonalize3x3 as aA, singularValueDecomposition3x3 as aB, luFactorLinearSystem as aC, luSolveLinearSystem as aD, invertMatrix as aE, estimateMatrixCondition as aF, solveHomogeneousLeastSquares as aG, solveLeastSquares as aH, hex2float as aI, lab2xyz as aJ, xyz2lab as aK, xyz2rgb as aL, rgb2xyz as aM, computeBoundsFromPoints as aN, clampAndNormalizeValue as aO, getScalarTypeFittingRange as aP, getAdjustedScalarRange as aQ, extentIsWithinOtherExtent as aR, boundsIsWithinOtherBounds as aS, pointIsWithinBounds as aT, solve3PointCircle as aU, inf as aV, negInf as aW, isFinite as aX, isNaN as aY, floatToHex2 as aZ, floatRGB2HexCode as a_, multiplyScalar2D as aa, multiplyAccumulate2D as ab, outer as ac, projectVector as ad, dot2D as ae, projectVector2D as af, gaussianAmplitude as ag, gaussianWeight as ah, outer2D as ai, norm2D as aj, rowsToMat4 as ak, columnsToMat4 as al, columnsToMat3 as am, LUFactor3x3 as an, LUSolve3x3 as ao, linearSolve3x3 as ap, multiply3x3_mat3 as aq, transpose3x3 as ar, invert3x3 as as, identity3x3 as at, isIdentity as au, quaternionToMatrix3x3 as av, roundNumber as aw, matrix3x3ToQuaternion as ax, multiplyQuaternion as ay, orthogonalize3x3 as az, roundVector as b, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath 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, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };

package/Common/Core/Math.d.ts

@@ -471,9 +471,9 @@ export function multiply3x3_mat3(a_3x3: Matrix3x3, b_3x3: Matrix3x3, out_3x3: Ma
  * @param {Number} colA 
  * @param {Number} rowB 
  * @param {Number} colB 
- * @param {Matrix} out_rowXcol 
+ * @param {Matrix} outRowAColB 
  */
-export function multiplyMatrix(a: Matrix, b: Matrix, rowA: number, colA: number, rowB: number, colB: number, out_rowXcol: Matrix): void;
+export function multiplyMatrix(a: Matrix, b: Matrix, rowA: number, colA: number, rowB: number, colB: number, outRowAColB: Matrix): void;
 
 /**
  * Transpose a 3x3 matrix.

package/Common/Core/Math.js

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

package/Filters/General/ContourLoopExtraction.d.ts

@@ -0,0 +1,79 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import vtkPolyData from './../../Common/DataModel/PolyData';
+/**
+ * Initial configuration values for vtkContourLoopExtraction instances.
+ */
+export interface IContourLoopExtractionInitialValues {}
+
+type vtkContourLoopExtractionBase = vtkObject & vtkAlgorithm;
+
+export interface vtkContourLoopExtraction extends vtkContourLoopExtractionBase {
+  /**
+   * Runs the contour extraction algorithm with the given input and output data.
+   * @param inData - The input data for the contour extraction.
+   * @param outData - The output data where the extracted contours will be stored.
+   */
+  requestData(inData: vtkPolyData[], outData: vtkPolyData[]): void;
+
+  /**
+   * Extracts contour loops from the given polydata input and populates the given output.
+   * @param input - The input polydata
+   * @param output - The output polydata
+   */
+  extractContours(input: vtkPolyData, output: vtkPolyData): void;
+
+  /**
+   * Traverses a loop starting from a given line and point, in a specified direction.
+   * @param pd - The polydata which to traverse.
+   * @param dir - The direction of traversal.
+   * @param startLineId - The ID of the starting line.
+   * @param startPtId - The ID of the starting point.
+   * @param loopPoints - The array to store the traversed points of the loop.
+   * @returns The last point ID after traversal.
+   */
+  traverseLoop(
+    pd: vtkPolyData,
+    dir: number,
+    startLineId: number,
+    startPtId: number,
+    loopPoints: Array<{ t: number; ptId: number }>
+  ): number;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkContourLoopExtraction characteristics.
+ *
+ * @param publicAPI - Object on which methods will be bound (public).
+ * @param model - Object on which data structure will be bound (protected).
+ * @param initialValues - (Optional) Initial values to assign to the model.
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IContourLoopExtractionInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkContourLoopExtraction.
+ *
+ * @param initialValues - (Optional) Initial values for the instance.
+ */
+export function newInstance(
+  initialValues?: IContourLoopExtractionInitialValues
+): vtkContourLoopExtraction;
+
+// ----------------------------------------------------------------------------
+
+/**
+ * vtkContourLoopExtraction specific static methods.
+ */
+export declare const vtkContourLoopExtraction: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkContourLoopExtraction;

package/Filters/General/ContourLoopExtraction.js

@@ -0,0 +1,137 @@
+import { m as macro } from '../../macros2.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+
+const Dir = {
+  Forward: 1,
+  Backward: -1
+};
+const visited = new Set();
+function vtkContourLoopExtraction(publicAPI, model) {
+  publicAPI.requestData = (inData, outData) => {
+    const [input] = inData;
+    if (!outData[0]) {
+      outData[0] = vtkPolyData.newInstance();
+    }
+    const [output] = outData;
+    publicAPI.extractContours(input, output);
+    output.modified();
+  };
+  publicAPI.traverseLoop = (pd, dir, startLineId, startPtId, loopPoints) => {
+    let lineId = startLineId;
+    let lastPtId = startPtId;
+    let terminated = false;
+    let numInserted = 0;
+    while (!terminated) {
+      const {
+        cellPointIds
+      } = pd.getCellPoints(lineId);
+      if (!cellPointIds) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      lastPtId = cellPointIds[0] !== lastPtId ? cellPointIds[0] : cellPointIds[1];
+      numInserted++;
+
+      // parametric point value
+      const t = dir * numInserted;
+      loopPoints.push({
+        t,
+        ptId: lastPtId
+      });
+      const lineCell = pd.getPointCells(lastPtId);
+      if (lineCell.length !== 2 || lastPtId === startPtId) {
+        // looped
+        return lastPtId;
+      }
+      if (lineCell.length === 2) {
+        // continue along loop
+        lineId = lineCell[0] !== lineId ? lineCell[0] : lineCell[1];
+        visited.add(lineId);
+      } else {
+        // empty or invalid cell
+        terminated = true;
+      }
+    }
+    return lastPtId;
+  };
+  publicAPI.extractContours = (input, output) => {
+    const loops = [];
+    visited.clear();
+    const inLines = input.getLines();
+    output.getPoints().setData(Float32Array.from(input.getPoints().getData()));
+
+    // TODO skip if cached input mtime hasn't changed.
+    // iterate over input lines
+    for (let li = 0; li < inLines.getNumberOfCells(); li++) {
+      if (visited.has(li)) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      const {
+        cellPointIds
+      } = input.getCellPoints(li);
+      if (!cellPointIds) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      visited.add(li);
+      const startPtId = cellPointIds[0];
+      const loopPoints = [];
+      loopPoints.push({
+        t: 0,
+        ptId: startPtId
+      });
+      const endPtId = publicAPI.traverseLoop(input, Dir.Forward, li, startPtId, loopPoints);
+      if (startPtId !== endPtId) {
+        // didn't find a loop. Go other direction to see where we end up
+        publicAPI.traverseLoop(input, Dir.Backward, li, startPtId, loopPoints);
+        loopPoints.sort((a, b) => a.t < b.t ? -1 : 1);
+        // make closed contour
+        if (loopPoints.length && loopPoints[0].ptId !== loopPoints[loopPoints.length - 1]?.ptId) {
+          loopPoints.push({
+            ...loopPoints[loopPoints.length - 1]
+          });
+        }
+      }
+      if (loopPoints.length) {
+        loops.push(loopPoints);
+      }
+    }
+
+    // clear output lines
+    const outLines = output.getLines();
+    outLines.resize(0);
+    loops.forEach(loop => {
+      outLines.insertNextCell(loop.map(pt => pt.ptId));
+    });
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 1, 1);
+  vtkContourLoopExtraction(publicAPI);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkContourLoopExtraction');
+
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend
+};
+
+export { index as default, extend, newInstance };

package/Filters/General/ScalarToRGBA.js

@@ -35,7 +35,7 @@ function vtkScalarToRGBA(publicAPI, model) {
     }
     const rgba = [0, 0, 0, 0];
     const data = scalars.getData();
-    const rgbaArray = new Uint8Array(data.length * 4);
+    const rgbaArray = new Uint8ClampedArray(data.length * 4);
     let offset = 0;
     for (let idx = 0; idx < data.length; idx++) {
       const x = data[idx];

package/Interaction/Manipulators/MouseRangeManipulator.d.ts

@@ -1,11 +1,14 @@
 import vtkCompositeMouseManipulator, {
   ICompositeMouseManipulatorInitialValues,
 } from './CompositeMouseManipulator';
+import { vtkObject } from './../../interfaces';
 
 export interface IMouseRangeManipulatorInitialValues
   extends ICompositeMouseManipulatorInitialValues {}
 
-export interface vtkMouseRangeManipulator extends vtkCompositeMouseManipulator {
+export interface vtkMouseRangeManipulator
+  extends vtkCompositeMouseManipulator,
+    vtkObject {
   setHorizontalListener(
     min: number,
     max: number,

package/Interaction/Widgets/OrientationMarkerWidget/Constants.js

@@ -8,4 +8,4 @@ var Constants = {
   Corners
 };
 
-export { Constants as default };
+export { Corners, Constants as default };

package/Interaction/Widgets/OrientationMarkerWidget.d.ts

@@ -1,6 +1,5 @@
 import { vtkObject } from './../../interfaces';
-import vtkAnnotatedCubeActor from './../../Rendering/Core/AnnotatedCubeActor';
-import vtkAxesActor from './../../Rendering/Core/AxesActor';
+import vtkActor from './../../Rendering/Core/Actor';
 import vtkRenderer from './../../Rendering/Core/Renderer';
 import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
 import { Nullable } from './../../types';
@@ -11,7 +10,7 @@ import { Corners } from './OrientationMarkerWidget/Constants';
  * 
  */
 export interface IOrientationMarkerWidgetInitialValues {
-	actor?: vtkAnnotatedCubeActor | vtkAxesActor,
+	actor?: vtkActor,
 	interactor?: vtkRenderWindowInteractor,
 	parentRenderer?: vtkRenderer,
 	viewportCorner?: Corners,
@@ -39,7 +38,7 @@ export interface vtkOrientationMarkerWidget extends vtkObject {
 	/**
 	 * 
 	 */
-	getActor(): vtkAnnotatedCubeActor | vtkAxesActor;
+	getActor(): vtkActor;
 
 	/**
 	 * Gets the parent renderer, if any.
@@ -85,9 +84,9 @@ export interface vtkOrientationMarkerWidget extends vtkObject {
 	
 	/**
 	 * Get the actor associated with the widget.
-	 * @param {vtkAnnotatedCubeActor | vtkAxesActor} actor The actor instance.
+	 * @param {vtkActor} actor The actor instance.
 	 */
-	setActor(actor: vtkAnnotatedCubeActor | vtkAxesActor): void;
+	setActor(actor: vtkActor): void;
 
 	/**
 	 * Sets the parent renderer

package/Rendering/Core/AxesActor.js

@@ -24,7 +24,7 @@ function shiftDataset(ds, axis) {
 
 function addColor(ds, r, g, b) {
   const size = ds.getPoints().getData().length;
-  const rgbArray = new Uint8Array(size);
+  const rgbArray = new Uint8ClampedArray(size);
   let offset = 0;
   while (offset < size) {
     rgbArray[offset++] = r;

package/Rendering/Core/ColorTransferFunction/CssFilters.d.ts

@@ -0,0 +1,109 @@
+/**
+ * A helper file to transform RGBA points using CSS filters equivalent
+ * The equivalents of CSS filters using SVG filters can be found here:
+ * https://www.w3.org/TR/filter-effects-1/#ShorthandEquivalents
+ * For each SVG filter, you can look for the maths behind it on the same page:
+ * https://www.w3.org/TR/filter-effects-1/#FilterPrimitivesOverview
+ *
+ * For example, the saturate filter equivalent is here:
+ * https://www.w3.org/TR/filter-effects-1/#saturateEquivalent
+ * And the maths behind the feColorMatrix of type saturate is here:
+ * https://www.w3.org/TR/filter-effects-1/#ref-for-attr-valuedef-type-saturate
+ *
+ * The transforms are done using matrices of size 5 by 5. They are row major
+ * as in vtkMath. The vectors representing the RGBA points uses
+ * [R, G, B, A, 1] vectors, with each channel between 0 and 1.
+ */
+
+import { Matrix, Vector3 } from '../../../types';
+
+export const luminanceWeights: Vector3;
+export type FilterMatrix = Matrix;
+
+/**
+ * Create a new filter matrix
+ * This is a 5x5 row major array
+ * Use applyFilter() function to use it
+ * It is NOT the identity
+ */
+export function createCSSFilter(): FilterMatrix;
+
+/**
+ * Convert a filter to an identity matrix or create a new identity filter
+ * @param outFilter If specified, the outFilter is converted to identity filter
+ */
+export function createIdentityFilter(outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * Combine two filters into a single filter
+ * Warning: it is NOT an operation inspired by CSS filters
+ * For this, apply filters one by one using applyFilter
+ * The clamping step is not applied between each filter when the filters are combined
+ * The order of the filters matters
+ * @param baseFilter The first filter that will be applied
+ * @param newFilter The second filter that will be applied
+ * @param outFilter An optional filter that will contain the combined filter
+ */
+export function combineFilters(baseFilter: FilterMatrix, newFilter: FilterMatrix, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * Apply a filter to a rgb(a) point
+ * It is a multiplication by the matrix and a clamping
+ * @param filter The filter
+ * @param r The red channel (between 0 and 1)
+ * @param g The green channel (between 0 and 1)
+ * @param b The blue channel (between 0 and 1)
+ * @param a The optional alpha channel (between 0 and 1), defaults to 1
+ * @returns A vector of size 4 [r, g, b, a]
+ */
+export function applyFilter(filter: FilterMatrix, r: number, g: number, b: number, a?: number): [number, number, number, number];
+
+/**
+ * A generic linear filter
+ * See svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+ * @param slope 
+ * @param intercept 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createLinearFilter(slope: number, intercept: number, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * A contrast filter
+ * See css/svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#contrastEquivalent
+ * https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+ * @param contrast 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createContrastFilter(contrast: number, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * A saturate filter
+ * See css/svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#saturateEquivalent
+ * https://www.w3.org/TR/filter-effects-1/#ref-for-attr-valuedef-type-saturate
+ * @param saturate 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createSaturateFilter(saturate: number, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * A brightness filter
+ * See css/svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#brightnessEquivalent
+ * https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+ * @param brightness 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createBrightnessFilter(brightness: number, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * An invert filter
+ * See css/svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#invertEquivalent
+ * https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-table
+ * @param invert 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createInvertFilter(invert: number, outFilter?: FilterMatrix): FilterMatrix;

package/Rendering/Core/ColorTransferFunction/CssFilters.js

@@ -0,0 +1,103 @@
+import { H as identity, I as multiplyMatrix } from '../../../Common/Core/Math/index.js';
+
+/**
+ * A helper file to transform RGBA points using CSS filters equivalent
+ * The equivalents of CSS filters using SVG filters can be found here:
+ * https://www.w3.org/TR/filter-effects-1/#ShorthandEquivalents
+ * For each SVG filter, you can look for the maths behind it on the same page:
+ * https://www.w3.org/TR/filter-effects-1/#FilterPrimitivesOverview
+ *
+ * For example, the saturate filter equivalent is here:
+ * https://www.w3.org/TR/filter-effects-1/#saturateEquivalent
+ * And the maths behind the feColorMatrix of type saturate is here:
+ * https://www.w3.org/TR/filter-effects-1/#ref-for-attr-valuedef-type-saturate
+ *
+ * The transforms are done using matrices of size 5 by 5. They are row major
+ * as in vtkMath. The vectors representing the RGBA points uses
+ * [R, G, B, A, 1] vectors, with each channel between 0 and 1.
+ */
+const luminanceWeights = [0.213, 0.715, 0.072];
+function createCSSFilter() {
+  return new Array(25);
+}
+function createIdentityFilter() {
+  let outFilter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : createCSSFilter();
+  return identity(5, outFilter);
+}
+function combineFilters(baseFilter, newFilter) {
+  let outFilter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : createCSSFilter();
+  multiplyMatrix(newFilter, baseFilter, 5, 5, 5, 5, outFilter);
+  return outFilter;
+}
+function applyFilter(filter, r, g, b) {
+  let a = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+  const vec = [r, g, b, a, 1];
+  multiplyMatrix(filter, vec, 5, 5, 5, 1, vec);
+  // Clamp R, G, B, A
+  const output = new Array(4);
+  for (let i = 0; i < 4; ++i) {
+    const value = vec[i];
+    if (value < 0) {
+      output[i] = 0;
+    } else if (value > 1) {
+      output[i] = 1;
+    } else {
+      output[i] = value;
+    }
+  }
+  return output;
+}
+function createLinearFilter(slope, intercept) {
+  let outFilter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : createCSSFilter();
+  createIdentityFilter(outFilter);
+  for (let row = 0; row < 3; ++row) {
+    outFilter[row * 5 + row] = slope;
+    outFilter[row * 5 + 4] = intercept;
+  }
+  return outFilter;
+}
+
+// https://www.w3.org/TR/filter-effects-1/#contrastEquivalent
+// https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+function createContrastFilter(contrast) {
+  let outFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createCSSFilter();
+  const slope = contrast;
+  const intercept = -(0.5 * contrast) + 0.5;
+  return createLinearFilter(slope, intercept, outFilter);
+}
+
+// https://www.w3.org/TR/filter-effects-1/#saturateEquivalent
+// https://www.w3.org/TR/filter-effects-1/#ref-for-attr-valuedef-type-saturate
+function createSaturateFilter(saturate) {
+  let outFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createCSSFilter();
+  createIdentityFilter(outFilter);
+  for (let col = 0; col < 3; ++col) {
+    const columnLuminance = luminanceWeights[col];
+    const diagonalValue = columnLuminance + (1 - columnLuminance) * saturate;
+    const nonDiagonalValue = columnLuminance - columnLuminance * saturate;
+    for (let row = 0; row < 3; ++row) {
+      outFilter[row * 5 + col] = row === col ? diagonalValue : nonDiagonalValue;
+    }
+  }
+  return outFilter;
+}
+
+// https://www.w3.org/TR/filter-effects-1/#brightnessEquivalent
+// https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+function createBrightnessFilter(brightness) {
+  let outFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createCSSFilter();
+  const slope = brightness;
+  const intercept = 0;
+  return createLinearFilter(slope, intercept, outFilter);
+}
+
+// https://www.w3.org/TR/filter-effects-1/#invertEquivalent
+// https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-table
+function createInvertFilter(invert) {
+  let outFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createCSSFilter();
+  const slope = 1 - 2 * invert;
+  const intercept = invert;
+  return createLinearFilter(slope, intercept, outFilter);
+}
+
+export { applyFilter, combineFilters, createBrightnessFilter, createCSSFilter, createContrastFilter, createIdentityFilter, createInvertFilter, createLinearFilter, createSaturateFilter, luminanceWeights };

package/Rendering/Core/ColorTransferFunction.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { h as hsv2rgb, i as isNan, H as floor, I as isInf, J as rgb2hsv, K as rgb2lab, L as lab2rgb } from '../../Common/Core/Math/index.js';
+import { h as hsv2rgb, i as isNan, J as floor, K as isInf, L as rgb2hsv, M as rgb2lab, N as lab2rgb } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import Constants from './ColorTransferFunction/Constants.js';
 

package/Rendering/Core/Coordinate.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import Constants from './Coordinate/Constants.js';
-import { M as round, H as floor } from '../../Common/Core/Math/index.js';
+import { O as round, J as floor } from '../../Common/Core/Math/index.js';
 
 const {
   Coordinate

package/Rendering/Core/CubeAxesActor.js

@@ -1,6 +1,6 @@
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { N as normalize2D, O as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { P as normalize2D, Q as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';

package/Rendering/Core/ImageMapper.js

@@ -2,7 +2,7 @@ import Constants from './ImageMapper/Constants.js';
 import { m as macro } from '../../macros2.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
-import { C as clampValue, P as multiply3x3_vect3, F as createUninitializedBounds, Q as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
+import { C as clampValue, R as multiply3x3_vect3, F as createUninitializedBounds, S as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 
 const {

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -396,6 +396,11 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 */
 	invokeEndInteractionEvent(callData: IRenderWindowInteractorEvent): void;
 
+	/**
+	 *
+	 */
+	invokeRenderEvent(): void;
+
 	/**
 	 *
 	 * @param cb The callback to be called
@@ -659,6 +664,13 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 */
 	onEndInteractionEvent(cb: InteractorEventCallback, priority?: number): Readonly<vtkSubscription>;
 
+	/**
+	 *
+	 * @param {Function} cb The callback to be called.
+	 * @param {Number} [priority] The priority of the event.
+	 */
+	onRenderEvent(cb: () => void, priority?: number): Readonly<vtkSubscription>;
+
 	/**
 	 *
 	 * @param args

package/Rendering/Core/Renderer.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { n as newInstance$1, g as get, e as setGet, k as getArray, l as setGetArray, i as moveToProtected, c as macro } from '../../macros2.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
-import { R as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { T as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 

package/Rendering/Core/ScalarBarActor.js

@@ -1,5 +1,5 @@
 import * as d3 from 'd3-scale';
-import { O as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { Q as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';

package/Rendering/Core/VolumeMapper.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { F as createUninitializedBounds, C as clampValue, H as floor } from '../../Common/Core/Math/index.js';
+import { F as createUninitializedBounds, C as clampValue, J as floor } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';

package/Rendering/Core/VolumeProperty.d.ts

@@ -1,5 +1,6 @@
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { vtkObject } from './../../interfaces';
+import { Nullable } from './../../types';
 import vtkColorTransferFunction from './ColorTransferFunction';
 import { InterpolationType, OpacityMode } from './VolumeProperty/Constants';
 
@@ -279,14 +280,14 @@ export interface vtkVolumeProperty extends vtkObject {
 	 * @param {Number} index 
 	 * @param {vtkColorTransferFunction} func 
 	 */
-	setRGBTransferFunction(index: number, func: vtkColorTransferFunction): boolean;
+	setRGBTransferFunction(index: number, func?: Nullable<vtkColorTransferFunction>): boolean;
 
 	/**
 	 * Set the scalar opacity of a volume to a transfer function
 	 * @param {Number} index 
 	 * @param {vtkPiecewiseFunction} func 
 	 */
-	setScalarOpacity(index: number, func: vtkPiecewiseFunction): boolean;
+	setScalarOpacity(index: number, func?: Nullable<vtkPiecewiseFunction>): boolean;
 
 	/**
 	 * Set the scalar component weights.

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -188,7 +188,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (model.colorTextureString !== cfunToString) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
-      const cTable = new Uint8Array(cSize);
+      const cTable = new Uint8ClampedArray(cSize);
       let cfun = ppty.getRGBTransferFunction();
       if (cfun) {
         const tmpTable = new Float32Array(cWidth * 3);
@@ -228,7 +228,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (model.pwfTextureString !== pwfunToString) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
-      const pwfTable = new Uint8Array(pwfSize);
+      const pwfTable = new Uint8ClampedArray(pwfSize);
       let pwfun = ppty.getPiecewiseFunction();
       // support case where pwfun is added/removed
       model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);

package/Rendering/OpenGL/ImageMapper.js

@@ -582,7 +582,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
-      const cTable = new Uint8Array(cSize);
+      const cTable = new Uint8ClampedArray(cSize);
       if (!model.colorTexture) {
         model.colorTexture = vtkOpenGLTexture.newInstance({
           resizable: true
@@ -645,7 +645,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
-      const pwfTable = new Uint8Array(pwfSize);
+      const pwfTable = new Uint8ClampedArray(pwfSize);
       if (!model.pwfTexture) {
         model.pwfTexture = vtkOpenGLTexture.newInstance({
           resizable: true

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -213,7 +213,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
-      const cTable = new Uint8Array(cSize);
+      const cTable = new Uint8ClampedArray(cSize);
       if (!model.colorTexture) {
         model.colorTexture = vtkOpenGLTexture.newInstance();
         model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
@@ -268,7 +268,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
-      const pwfTable = new Uint8Array(pwfSize);
+      const pwfTable = new Uint8ClampedArray(pwfSize);
       if (!model.pwfTexture) {
         model.pwfTexture = vtkOpenGLTexture.newInstance();
         model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -8,7 +8,7 @@ import { v as vtkPolyData2DVS } from './glsl/vtkPolyData2DVS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
-import { M as round } from '../../Common/Core/Math/index.js';
+import { O as round } from '../../Common/Core/Math/index.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -80,7 +80,7 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 *
 	 * @param {HTMLElement} el The container element.
 	 */
-	setContainer(el: HTMLElement): void;
+	setContainer(el: Nullable<HTMLElement>): void;
 
 	/**
 	 * Get the container element.

package/Rendering/OpenGL/Texture.js

@@ -2,7 +2,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { n as newInstance$1, o as obj, s as set, e as setGet, g as get, i as moveToProtected, a as newTypedArray, c as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { S as isPowerOfTwo, O as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { U as isPowerOfTwo, Q as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL/VolumeMapper.js

@@ -1006,7 +1006,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       if (model._openGLRenderWindow.getWebgl2() || model.context.getExtension('OES_texture_float') && model.context.getExtension('OES_texture_float_linear')) {
         model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.FLOAT, ofTable);
       } else {
-        const oTable = new Uint8Array(oSize);
+        const oTable = new Uint8ClampedArray(oSize);
         for (let i = 0; i < oSize; ++i) {
           oTable[i] = 255.0 * ofTable[i];
         }
@@ -1029,7 +1029,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * 2 * numIComps * 3;
-      const cTable = new Uint8Array(cSize);
+      const cTable = new Uint8ClampedArray(cSize);
       const tmpTable = new Float32Array(cWidth * 3);
       for (let c = 0; c < numIComps; ++c) {
         const cfun = vprop.getRGBTransferFunction(c);

package/Rendering/WebGPU/ImageMapper.js

@@ -230,7 +230,7 @@ function vtkWebGPUImageMapper(publicAPI, model) {
     const cfunToString = computeFnToString(actorProperty, actorProperty.getRGBTransferFunction, numIComps);
     if (model.colorTextureString !== cfunToString) {
       model.numRows = numIComps;
-      const colorArray = new Uint8Array(model.numRows * 2 * model.rowLength * 4);
+      const colorArray = new Uint8ClampedArray(model.numRows * 2 * model.rowLength * 4);
       let cfun = actorProperty.getRGBTransferFunction();
       if (cfun) {
         const tmpTable = new Float32Array(model.rowLength * 3);

package/Rendering/WebGPU/SphereMapper.js

@@ -245,7 +245,7 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
           if (colorComponents !== 4) {
             vtkErrorMacro('this should be 4');
           }
-          const tmpVBO = new Uint8Array(3 * numPoints * 4);
+          const tmpVBO = new Uint8ClampedArray(3 * numPoints * 4);
           let vboIdx = 0;
           const colorData = c.getData();
           for (let id = 0; id < numPoints; ++id) {

package/Rendering/WebGPU/StickMapper.js

@@ -362,7 +362,7 @@ function vtkWebGPUStickMapper(publicAPI, model) {
           if (colorComponents !== 4) {
             vtkErrorMacro('this should be 4');
           }
-          const tmpVBO = new Uint8Array(numPoints * 4);
+          const tmpVBO = new Uint8ClampedArray(numPoints * 4);
           let vboIdx = 0;
           const colorData = c.getData();
           for (let id = 0; id < numPoints; ++id) {

package/Rendering/WebGPU/VolumePassFSQ.js

@@ -484,7 +484,7 @@ function vtkWebGPUVolumePassFSQ(publicAPI, model) {
     }
 
     // allocate the image array
-    const colorArray = new Uint8Array(model.numRows * 2 * model.rowLength * 4);
+    const colorArray = new Uint8ClampedArray(model.numRows * 2 * model.rowLength * 4);
     const opacityArray = new Float32Array(model.numRows * 2 * model.rowLength);
     let imgRow = 0;
     const tmpTable = new Float32Array(model.rowLength * 3);

package/Widgets/Widgets3D/AngleWidget.js

@@ -3,7 +3,7 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { s as subtract, T as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { s as subtract, V as angleBetweenVectors } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './AngleWidget/behavior.js';
 import generateState from './AngleWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../../macros2.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkLine from '../../../Common/DataModel/Line.js';
-import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, U as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, W as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import { getLineNames, getOtherLineName, updateState, boundPointOnPlane, getLinePlaneName, getLineInPlaneName, rotateVector } from './helpers.js';
 import { InteractionMethodsName, ScrollingMethods, planeNameToViewType } from './Constants.js';
 

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -2,7 +2,7 @@ import vtkBoundingBox, { STATIC } from '../../../Common/DataModel/BoundingBox.js
 import vtkCubeSource from '../../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../../Filters/Core/Cutter.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
-import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, U as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, W as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 

package/index.d.ts

@@ -55,6 +55,7 @@
 /// <reference path="./Common/Transform/Transform.d.ts" />
 /// <reference path="./Filters/General/AppendPolyData.d.ts" />
 /// <reference path="./Filters/General/ClipClosedSurface.d.ts" />
+/// <reference path="./Filters/General/ContourLoopExtraction.d.ts" />
 /// <reference path="./Filters/General/ContourTriangulator.d.ts" />
 /// <reference path="./Filters/General/ImageCropFilter.d.ts" />
 /// <reference path="./Filters/General/ImageDataOutlineFilter.d.ts" />
@@ -150,6 +151,7 @@
 /// <reference path="./Rendering/Core/CellPicker.d.ts" />
 /// <reference path="./Rendering/Core/ColorTransferFunction/ColorMaps.d.ts" />
 /// <reference path="./Rendering/Core/ColorTransferFunction/Constants.d.ts" />
+/// <reference path="./Rendering/Core/ColorTransferFunction/CssFilters.d.ts" />
 /// <reference path="./Rendering/Core/ColorTransferFunction.d.ts" />
 /// <reference path="./Rendering/Core/Coordinate/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Coordinate.d.ts" />

package/package.json

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