@kitware/vtk.js 29.0.0 → 29.1.1

package/Common/Core/Math/index.js

@@ -2245,4 +2245,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { ceilLog2 as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, floor as G, isInf as H, rgb2hsv as I, rgb2lab as J, lab2rgb as K, round as L, normalize2D as M, nearestPowerOfTwo as N, multiply3x3_vect3 as O, getSparseOrthogonalMatrix as P, areBoundsInitialized as Q, isPowerOfTwo as R, angleBetweenVectors as S, signedAngleBetweenVectors as T, createArray as U, Pi as V, ceil as W, min as X, max as Y, arrayMin as Z, arrayMax as _, areMatricesEqual as a, float2CssRGBA as a$, factorial as a0, binomial as a1, beginCombination as a2, nextCombination as a3, randomSeed as a4, getSeed as a5, gaussian as a6, multiplyScalar2D as a7, multiplyAccumulate2D as a8, outer 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_, projectVector as aa, dot2D as ab, projectVector2D as ac, gaussianAmplitude as ad, gaussianWeight as ae, outer2D as af, norm2D as ag, rowsToMat4 as ah, columnsToMat4 as ai, columnsToMat3 as aj, LUFactor3x3 as ak, LUSolve3x3 as al, linearSolve3x3 as am, multiply3x3_mat3 as an, multiplyMatrix as ao, transpose3x3 as ap, invert3x3 as aq, identity3x3 as ar, identity as as, isIdentity as at, isIdentity3x3 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 { 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 };

package/Common/Core/Math.js

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

package/Rendering/Core/CellPicker.d.ts

@@ -13,6 +13,7 @@ export interface ICellPickerInitialValues extends IPickerInitialValues {
 	cellIJK?: number[];
 	pickNormal?: number[];
 	mapperNormal?: number[];
+	opacityThreshold?:number;
 }
 
 export interface vtkCellPicker extends vtkPicker {
@@ -42,6 +43,16 @@ export interface vtkCellPicker extends vtkPicker {
 	 */
 	getMapperNormalByReference(): number[];
 
+	/**
+	 * Get the opacity threshold for volume picking
+	 */
+	getOpacityThreshold(): number;
+
+	/**
+	 * Get the opacity threshold for volume picking
+	 */
+	setOpacityThreshold(value: number);
+
 	/**
 	 * Get the parametric coordinates of the picked cell.
 	 */

package/Rendering/Core/CellPicker.js

@@ -5,9 +5,10 @@ import vtkPicker from './Picker.js';
 import vtkPolyLine from '../../Common/DataModel/PolyLine.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
 import vtkQuad from '../../Common/DataModel/Quad.js';
-import { l as normalize } from '../../Common/Core/Math/index.js';
+import { l as normalize, G as isIdentity3x3 } from '../../Common/Core/Math/index.js';
 import { CellType } from '../../Common/DataModel/CellTypes/Constants.js';
-import { vec3 } from 'gl-matrix';
+import { vec3, vec4 } from 'gl-matrix';
+import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
 // ----------------------------------------------------------------------------
 // Global methods
@@ -156,7 +157,7 @@ function vtkCellPicker(publicAPI, model) {
     }
     return pickResult;
   };
-  publicAPI.intersectWithLine = (p1, p2, tol, mapper) => {
+  publicAPI.intersectWithLine = (p1, p2, tol, actor, mapper) => {
     let tMin = Number.MAX_VALUE;
     const t1 = 0.0;
     const t2 = 1.0;
@@ -172,6 +173,8 @@ function vtkCellPicker(publicAPI, model) {
         model.cellIJK = pickData.ijk;
         model.pCoords = pickData.pCoords;
       }
+    } else if (mapper.isA('vtkVolumeMapper')) {
+      tMin = publicAPI.intersectVolumeWithLine(p1, p2, clipLine.t1, clipLine.t2, tol, actor);
     } else if (mapper.isA('vtkMapper')) {
       tMin = publicAPI.intersectActorWithLine(p1, p2, t1, t2, tol, mapper);
     }
@@ -198,6 +201,109 @@ function vtkCellPicker(publicAPI, model) {
     }
     return tMin;
   };
+  publicAPI.intersectVolumeWithLine = (p1, p2, t1, t2, tol, volume) => {
+    let tMin = Number.MAX_VALUE;
+    const mapper = volume.getMapper();
+    const imageData = mapper.getInputData();
+    const origin = imageData.getOrigin();
+    const spacing = imageData.getSpacing();
+    const dims = imageData.getDimensions();
+    const scalars = imageData.getPointData().getScalars().getData();
+    const extent = imageData.getExtent();
+    const direction = imageData.getDirection();
+    let imageTransform;
+    if (!isIdentity3x3(direction)) {
+      imageTransform = vtkMatrixBuilder.buildFromRadian().translate(origin[0], origin[1], origin[2]).multiply3x3(direction).translate(-origin[0], -origin[1], -origin[2]).invert().getMatrix();
+    }
+
+    // calculate opacity table
+    const numIComps = 1;
+    const oWidth = 1024;
+    const tmpTable = new Float32Array(oWidth);
+    const opacityArray = new Float32Array(oWidth);
+    let ofun;
+    let oRange;
+    const sampleDist = volume.getMapper().getSampleDistance();
+    for (let c = 0; c < numIComps; ++c) {
+      ofun = volume.getProperty().getScalarOpacity(c);
+      oRange = ofun.getRange();
+      ofun.getTable(oRange[0], oRange[1], oWidth, tmpTable, 1);
+      const opacityFactor = sampleDist / volume.getProperty().getScalarOpacityUnitDistance(c);
+
+      // adjust for sample distance etc
+      for (let i = 0; i < oWidth; ++i) {
+        opacityArray[i] = 1.0 - (1.0 - tmpTable[i]) ** opacityFactor;
+      }
+    }
+    const scale = oWidth / (oRange[1] - oRange[0] + 1);
+
+    // Make a new p1 and p2 using the clipped t1 and t2
+    const q1 = [0, 0, 0];
+    const q2 = [0, 0, 0];
+    q1[0] = p1[0];
+    q1[1] = p1[1];
+    q1[2] = p1[2];
+    q2[0] = p2[0];
+    q2[1] = p2[1];
+    q2[2] = p2[2];
+    if (t1 !== 0.0 || t2 !== 1.0) {
+      for (let j = 0; j < 3; j++) {
+        q1[j] = p1[j] * (1.0 - t1) + p2[j] * t1;
+        q2[j] = p1[j] * (1.0 - t2) + p2[j] * t2;
+      }
+    }
+    const x1 = [0, 0, 0];
+    const x2 = [0, 0, 0];
+    for (let i = 0; i < 3; i++) {
+      x1[i] = (p1[i] - origin[i]) / spacing[i];
+      x2[i] = (p2[i] - origin[i]) / spacing[i];
+    }
+    const x = [0, 0, 0, 0];
+    const xi = [0, 0, 0];
+    const sliceSize = dims[1] * dims[0];
+    const rowSize = dims[0];
+    const nSteps = 100;
+    let insideVolume;
+    for (let t = t1; t < t2; t += 1 / nSteps) {
+      // calculate the location of the point
+      insideVolume = true;
+      for (let j = 0; j < 3; j++) {
+        // "t" is the fractional distance between endpoints x1 and x2
+        x[j] = x1[j] * (1.0 - t) + x2[j] * t;
+      }
+      x[3] = 1.0;
+      if (imageTransform) {
+        vec4.transformMat4(x, x, imageTransform);
+      }
+      for (let j = 0; j < 3; j++) {
+        // Bounds check
+        if (x[j] < extent[2 * j]) {
+          x[j] = extent[2 * j];
+          insideVolume = false;
+        } else if (x[j] > extent[2 * j + 1]) {
+          x[j] = extent[2 * j + 1];
+          insideVolume = false;
+        }
+        xi[j] = Math.round(x[j]);
+      }
+      if (insideVolume) {
+        const index = xi[2] * sliceSize + xi[1] * rowSize + xi[0];
+        let value = scalars[index];
+        if (value < oRange[0]) {
+          value = oRange[0];
+        } else if (value > oRange[1]) {
+          value = oRange[1];
+        }
+        value = Math.floor((value - oRange[0]) * scale);
+        const opacity = tmpTable[value];
+        if (opacity > model.opacityThreshold) {
+          tMin = t;
+          break;
+        }
+      }
+    }
+    return tMin;
+  };
   publicAPI.intersectActorWithLine = (p1, p2, t1, t2, tol, mapper) => {
     let tMin = Number.MAX_VALUE;
     const minXYZ = [0, 0, 0];
@@ -337,7 +443,8 @@ const DEFAULT_VALUES = {
   pCoords: [],
   cellIJK: [],
   pickNormal: [],
-  mapperNormal: []
+  mapperNormal: [],
+  opacityThreshold: 0.2
 };
 
 // ----------------------------------------------------------------------------
@@ -349,6 +456,7 @@ function extend(publicAPI, model) {
   // Inheritance
   vtkPicker.extend(publicAPI, model, initialValues);
   macro.getArray(publicAPI, model, ['pickNormal', 'mapperNormal', 'pCoords', 'cellIJK']);
+  macro.setGet(publicAPI, model, ['opacityThreshold']);
   macro.get(publicAPI, model, ['cellId']);
 
   // Object methods

package/Rendering/Core/ColorTransferFunction.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { h as hsv2rgb, i as isNan, G as floor, H as isInf, I as rgb2hsv, J as rgb2lab, K as lab2rgb } from '../../Common/Core/Math/index.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 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 { L as round, G as floor } from '../../Common/Core/Math/index.js';
+import { M as round, H 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 { M as normalize2D, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { N as normalize2D, O 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, O as multiply3x3_vect3, F as createUninitializedBounds, P as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
+import { C as clampValue, P as multiply3x3_vect3, F as createUninitializedBounds, Q as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 
 const {

package/Rendering/Core/Picker.js

@@ -180,7 +180,7 @@ function vtkPicker(publicAPI, model) {
     props.forEach(prop => {
       const mapper = prop.getMapper();
       pickable = prop.getNestedPickable() && prop.getNestedVisibility();
-      if (prop.getProperty().getOpacity() <= 0.0) {
+      if (prop.getProperty().getOpacity?.() <= 0.0) {
         pickable = false;
       }
       if (pickable) {
@@ -214,7 +214,7 @@ function vtkPicker(publicAPI, model) {
           bbox.reset();
         }
         if (bbox.intersectBox(p1Mapper, ray, hitPosition, t)) {
-          t[0] = publicAPI.intersectWithLine(p1Mapper, p2Mapper, tol * 0.333 * (scale[0] + scale[1] + scale[2]), mapper);
+          t[0] = publicAPI.intersectWithLine(p1Mapper, p2Mapper, tol * 0.333 * (scale[0] + scale[1] + scale[2]), prop, mapper);
           if (t[0] < Number.MAX_VALUE) {
             const p = [];
             p[0] = (1.0 - t[0]) * p1World[0] + t[0] * p2World[0];
@@ -246,6 +246,30 @@ function vtkPicker(publicAPI, model) {
       publicAPI.invokePickChange(model.pickedPositions);
       return 1;
     });
+    // sort array by distance
+    const tempArray = [];
+    for (let i = 0; i < model.pickedPositions.length; i++) {
+      tempArray.push({
+        actor: model.actors[i],
+        pickedPosition: model.pickedPositions[i],
+        distance2: distance2BetweenPoints(p1World, model.pickedPositions[i])
+      });
+    }
+    tempArray.sort((a, b) => {
+      const keyA = a.distance2;
+      const keyB = b.distance2;
+      // order the actors based on the distance2 attribute, so the near actors comes
+      // first in the list
+      if (keyA < keyB) return -1;
+      if (keyA > keyB) return 1;
+      return 0;
+    });
+    model.pickedPositions = [];
+    model.actors = [];
+    tempArray.forEach(obj => {
+      model.pickedPositions.push(obj.pickedPosition);
+      model.actors.push(obj.actor);
+    });
   };
 }
 

package/Rendering/Core/PointPicker.js

@@ -13,7 +13,7 @@ const {
 function vtkPointPicker(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPointPicker');
-  publicAPI.intersectWithLine = (p1, p2, tol, mapper) => {
+  publicAPI.intersectWithLine = (p1, p2, tol, actor, mapper) => {
     let tMin = Number.MAX_VALUE;
     if (mapper.isA('vtkImageMapper') || mapper.isA('vtkImageArrayMapper')) {
       const pickData = mapper.intersectWithLineForPointPicking(p1, p2);

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 { Q as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { R 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 { N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { O 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, G as floor } from '../../Common/Core/Math/index.js';
+import { F as createUninitializedBounds, C as clampValue, H 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/Misc/GenericRenderWindow.js

@@ -9,6 +9,8 @@ import '../../Common/Core/DataArray.js';
 import '../../Common/DataModel/PolyData.js';
 import '../Core/Actor.js';
 import '../Core/Mapper.js';
+import '../OpenGL/RenderWindow.js';
+import '../WebGPU/RenderWindow.js';
 
 // Process arguments from URL
 const userParams = vtkURLExtract.extractURLParameters();

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 { L as round } from '../../Common/Core/Math/index.js';
+import { M as round } from '../../Common/Core/Math/index.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

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 { R as isPowerOfTwo, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { S as isPowerOfTwo, O as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL/Volume.js

@@ -60,6 +60,7 @@ function vtkOpenGLVolume(publicAPI, model) {
       } else {
         mat3.fromMat4(model.normalMatrix, model.MCWCMatrix);
         mat3.invert(model.normalMatrix, model.normalMatrix);
+        mat3.transpose(model.normalMatrix, model.normalMatrix);
       }
       model.keyMatrixTime.modified();
     }

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, S as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { s as subtract, T 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, T 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, U 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, T as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.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 vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 

package/package.json

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