@kitware/vtk.js 28.10.1 → 28.10.2

package/Common/Core/Math/index.js

@@ -2108,6 +2108,67 @@ function getMajorAxisIndex(vector) {
   }
 
   return axisIndex;
+} // Return the closest orthogonal matrix of 1, -1 and 0
+// It works for both column major and row major matrices
+// This function iteratively associate a column with a row by choosing
+// the greatest absolute value from the remaining row and columns
+// For each association, a -1 or a 1 is set in the output, depending on
+// the sign of the value in the original matrix
+
+function getSparseOrthogonalMatrix(matrix) {
+  var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
+  // Initialize rows and columns to available indices
+  var rows = new Array(n);
+  var cols = new Array(n);
+
+  for (var i = 0; i < n; ++i) {
+    rows[i] = i;
+    cols[i] = i;
+  } // No need for the last iteration: i = 0
+
+
+  for (var _i7 = n - 1; _i7 > 0; _i7--) {
+    // Loop invariant:
+    // rows[0:i] and cols[0:i] contain the remaining rows and columns
+    // rows]i:n[ and cols]i:n[ contain the associations found (rows[k] is associated with cols[k])
+    var bestValue = -Infinity;
+    var bestRowI = 0;
+    var bestColI = 0;
+
+    for (var rowI = 0; rowI <= _i7; ++rowI) {
+      var row = rows[rowI];
+
+      for (var colI = 0; colI <= _i7; ++colI) {
+        var col = cols[colI];
+        var absVal = Math.abs(matrix[row + n * col]);
+
+        if (absVal > bestValue) {
+          bestValue = absVal;
+          bestRowI = rowI;
+          bestColI = colI;
+        }
+      }
+    } // Found an association between rows[bestRowI] and cols[bestColI]
+    // Put both at the end of their array by swapping with i
+
+
+    var _ref = [rows[bestRowI], rows[_i7]];
+    rows[_i7] = _ref[0];
+    rows[bestRowI] = _ref[1];
+    var _ref2 = [cols[bestColI], cols[_i7]];
+    cols[_i7] = _ref2[0];
+    cols[bestColI] = _ref2[1];
+  } // Convert row/column association to a matrix
+
+
+  var output = new Array(n * n).fill(0);
+
+  for (var _i8 = 0; _i8 < n; ++_i8) {
+    var matIdx = rows[_i8] + n * cols[_i8];
+    output[matIdx] = matrix[matIdx] < 0 ? -1 : 1;
+  }
+
+  return output;
 }
 function floatToHex2(value) {
   var integer = Math.floor(value * 255);
@@ -2245,6 +2306,7 @@ var vtkMath = {
   // JS add-on
   createUninitializedBounds: createUninitializedBounds,
   getMajorAxisIndex: getMajorAxisIndex,
+  getSparseOrthogonalMatrix: getSparseOrthogonalMatrix,
   floatToHex2: floatToHex2,
   floatRGB2HexCode: floatRGB2HexCode,
   float2CssRGBA: float2CssRGBA
@@ -2364,10 +2426,11 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   isNan: isNan,
   createUninitializedBounds: createUninitializedBounds,
   getMajorAxisIndex: getMajorAxisIndex,
+  getSparseOrthogonalMatrix: getSparseOrthogonalMatrix,
   floatToHex2: floatToHex2,
   floatRGB2HexCode: floatRGB2HexCode,
   float2CssRGBA: float2CssRGBA,
   'default': vtkMath
 });
 
-export { factorial as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, isInf as G, rgb2hsv as H, rgb2lab as I, lab2rgb as J, floor as K, round as L, normalize2D as M, nearestPowerOfTwo as N, multiply3x3_vect3 as O, areBoundsInitialized as P, isPowerOfTwo as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, createArray as T, Pi as U, ceil as V, min as W, max as X, arrayMin as Y, arrayMax as Z, ceilLog2 as _, areMatricesEqual as a, binomial as a0, beginCombination as a1, nextCombination as a2, randomSeed as a3, getSeed as a4, gaussian as a5, multiplyScalar2D as a6, multiplyAccumulate2D as a7, outer as a8, projectVector as a9, singularValueDecomposition3x3 as aA, luFactorLinearSystem as aB, luSolveLinearSystem as aC, invertMatrix as aD, estimateMatrixCondition as aE, solveHomogeneousLeastSquares as aF, solveLeastSquares as aG, hex2float as aH, lab2xyz as aI, xyz2lab as aJ, xyz2rgb as aK, rgb2xyz as aL, computeBoundsFromPoints as aM, clampAndNormalizeValue as aN, getScalarTypeFittingRange as aO, getAdjustedScalarRange as aP, extentIsWithinOtherExtent as aQ, boundsIsWithinOtherBounds as aR, pointIsWithinBounds as aS, solve3PointCircle as aT, inf as aU, negInf as aV, isFinite as aW, isNaN as aX, floatToHex2 as aY, floatRGB2HexCode as aZ, float2CssRGBA as a_, dot2D as aa, projectVector2D as ab, gaussianAmplitude as ac, gaussianWeight as ad, outer2D as ae, norm2D as af, rowsToMat4 as ag, columnsToMat4 as ah, columnsToMat3 as ai, LUFactor3x3 as aj, LUSolve3x3 as ak, linearSolve3x3 as al, multiply3x3_mat3 as am, multiplyMatrix as an, transpose3x3 as ao, invert3x3 as ap, identity3x3 as aq, identity as ar, isIdentity as as, isIdentity3x3 as at, quaternionToMatrix3x3 as au, roundNumber as av, matrix3x3ToQuaternion as aw, multiplyQuaternion as ax, orthogonalize3x3 as ay, diagonalize3x3 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 { ceilLog2 as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, isInf as G, rgb2hsv as H, rgb2lab as I, lab2rgb as J, floor 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 };

package/Common/Core/Math.d.ts

@@ -878,6 +878,19 @@ export function createUninitializedBounds(): Bounds;
  */
 export function getMajorAxisIndex(vector: number[]): number;
 
+/**
+ * Return the closest orthogonal matrix of 1, -1 and 0
+ * It works for both column major and row major matrices
+ * This function iteratively associate a column with a row by choosing
+ * the greatest absolute value from the remaining row and columns
+ * For each association, a -1 or a 1 is set in the output, depending on
+ * the sign of the value in the original matrix
+ * 
+ * @param {Number[]} matrix The matrix of size nxn
+ * @param {Number[]} n The size of the square matrix, defaults to 3
+ */
+export function getSparseOrthogonalMatrix(matrix: number[], n: number): number[];
+
 /**
  *
  * @param {Number} value The value to convert.
@@ -1028,6 +1041,7 @@ export declare const vtkMath: {
 	isInf: typeof isInf;
 	createUninitializedBounds: typeof createUninitializedBounds;
 	getMajorAxisIndex: typeof getMajorAxisIndex;
+	getSparseOrthogonalMatrix: typeof getSparseOrthogonalMatrix;
 	floatToHex2: typeof floatToHex2;
 	floatRGB2HexCode: typeof floatRGB2HexCode;
 	float2CssRGBA: typeof float2CssRGBA;

package/Common/Core/Math.js

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

package/Rendering/Core/ImageMapper.js

@@ -3,7 +3,7 @@ import Constants from './ImageMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
-import { C as clampValue, O as multiply3x3_vect3, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { C as clampValue, O as multiply3x3_vect3, F as createUninitializedBounds, P as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
@@ -11,7 +11,6 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
     otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods;
-var vtkWarningMacro = macro.vtkWarningMacro;
 var SlicingMode = Constants.SlicingMode; // ----------------------------------------------------------------------------
 // vtkImageMapper methods
 // ----------------------------------------------------------------------------
@@ -164,19 +163,19 @@ function vtkImageMapper(publicAPI, model) {
   };
 
   function computeClosestIJKAxis() {
-    var inVec3;
+    var xyzMode;
 
     switch (model.slicingMode) {
       case SlicingMode.X:
-        inVec3 = [1, 0, 0];
+        xyzMode = 0;
         break;
 
       case SlicingMode.Y:
-        inVec3 = [0, 1, 0];
+        xyzMode = 1;
         break;
 
       case SlicingMode.Z:
-        inVec3 = [0, 0, 1];
+        xyzMode = 2;
         break;
 
       default:
@@ -185,41 +184,23 @@ function vtkImageMapper(publicAPI, model) {
           flip: false
         };
         return;
-    } // Project vec3 onto direction cosines
+    } // The direction matrix in vtkImageData is the indexToWorld rotation matrix
+    // with a column-major data layout since it is stored as a WebGL matrix.
 
 
-    var out = [0, 0, 0]; // The direction matrix in vtkImageData is the indexToWorld rotation matrix
-    // with a column-major data layout since it is stored as a WebGL matrix.
-    // We need the worldToIndex rotation matrix for the projection, and it needs
-    // to be in a row-major data layout to use vtkMath for operations.
-    // To go from the indexToWorld column-major matrix to the worldToIndex
-    // row-major matrix, we need to transpose it (column -> row) then inverse it.
-    // However, that 3x3 matrix is a rotation matrix which is orthonormal, meaning
-    // that its inverse is equal to its transpose. We therefore need to apply two
-    // transpositions resulting in a no-op.
-
-    var a = publicAPI.getCurrentImage().getDirection();
-    multiply3x3_vect3(a, inVec3, out);
-    var maxAbs = 0.0;
-    var ijkMode = -1;
-    var flip = false;
-
-    for (var axis = 0; axis < out.length; ++axis) {
-      var absValue = Math.abs(out[axis]);
-
-      if (absValue > maxAbs) {
-        maxAbs = absValue;
-        flip = out[axis] < 0.0;
-        ijkMode = axis;
-      }
-    }
+    var direction = publicAPI.getCurrentImage().getDirection();
+    var newMatrix = getSparseOrthogonalMatrix(direction); // With {foo}Vector filled with 0s except at {foo}Mode position where it is 1
+    // We have xyzVector = (+/-) newMatrix * ijkVector
 
-    if (maxAbs !== 1.0) {
-      var xyzLabel = 'IJKXYZ'[model.slicingMode];
-      var ijkLabel = 'IJKXYZ'[ijkMode];
-      vtkWarningMacro("Unaccurate slicing along ".concat(xyzLabel, " axis which ") + "is not aligned with any IJK axis of the image data. " + "Using ".concat(ijkLabel, " axis  as a fallback (").concat(maxAbs, "% aligned). ") + "Necessitates slice reformat that is not yet implemented.  " + "You can switch the slicing mode on your mapper to do IJK slicing instead.");
+    var ijkMode = 0;
+
+    for (; ijkMode < 3; ++ijkMode) {
+      if (newMatrix[xyzMode + 3 * ijkMode] !== 0) {
+        break;
+      }
     }
 
+    var flip = newMatrix[xyzMode + 3 * ijkMode] < 0;
     model.closestIJKAxis = {
       ijkMode: ijkMode,
       flip: flip

package/Rendering/Core/Renderer.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, get, setGet, getArray, setGetArray, moveToProtected, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
-import { P as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { Q 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/OpenGL/Texture.js

@@ -4,7 +4,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { newInstance as newInstance$1, obj, set, setGet, get, moveToProtected, newTypedArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { Q as isPowerOfTwo, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { R as isPowerOfTwo, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Widgets/Widgets3D/AngleWidget.js

@@ -4,7 +4,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, R as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { s as subtract, S 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

@@ -3,7 +3,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../../macros.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, S 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, T 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

@@ -3,7 +3,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, S as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.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 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": "28.10.1",
+  "version": "28.10.2",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",