@kitware/vtk.js 24.19.1 → 25.0.2

package/Common/Core/Math.d.ts

@@ -6,6 +6,24 @@ import { Bounds, Extent, HSVColor, RGBAColor, RGBColor, Matrix, Matrix3x3, Range
  */
 export function createArray(size?: number): number[];
 
+/**
+ * Given two rows indices, swap the two rows of a nxn matrix
+ * @param {Number[]} matrix The n by n matrix in wich we want to swap the vectors.
+ * @param {Number} n size of the matrix.
+ * @param {Number} row1 index of first row to swap with the other.
+ * @param {Number} row2 index of second row to swap with the other.
+ */
+export function swapRowsMatrix_nxn(matrix: number[], n: number, row1: number, row2: number): void;
+
+/**
+ * Given two columns indices, swap the two columns of a nxn matrix
+ * @param {Number[]} matrix The n by n matrix in wich we want to swap the vectors.
+ * @param {Number} n size of the matrix.
+ * @param {Number} column1 index of first col to swap with the other.
+ * @param {Number} column2 index of second col to swap with the other.
+ */
+ export function swapColumnsMatrix_nxn(matrix: number[], n: number, column1: number, column2: number): void;
+
 /**
  * Get the number π.
  */
@@ -364,9 +382,47 @@ export function normalize2D(x: Vector2): number;
 
 /**
  *
- * @param {Number[][]|Number[]} args 
+ * @param {Number[]} args 
+ */
+export function determinant2x2(args: number[]): number;
+
+/**
+ * Fill a 4x4 matrix with the given row vectors
+ * @param {Vector4} row0 
+ * @param {Vector4} row1
+ * @param {Vector4} row2
+ * @param {Vector4} row3
+ * @param {Matrix} mat
+ */
+export function rowsToMat4(row0: Vector4, row1: Vector4, row2: Vector4, row3: Vector4, mat: Matrix): Matrix;
+
+/**
+ * Fill a 4x4 matrix with the given column vectors
+ * @param {Vector4} column0 
+ * @param {Vector4} column1
+ * @param {Vector4} column2
+ * @param {Vector4} column3
+ * @param {Matrix} mat
+ */
+export function columnsToMat4(column0: Vector4, column1: Vector4, column2: Vector4, column3: Vector4, mat: Matrix): Matrix;
+
+ /**
+ * Fill a 3x3 matrix with the given row vectors
+ * @param {Vector3} row0 
+ * @param {Vector3} row1
+ * @param {Vector3} row2
+ * @param {Matrix} mat
  */
-export function determinant2x2(args: number[][]|number[]): number;
+export function rowsToMat3(row0: Vector3, row1: Vector3, row2: Vector3, mat: Matrix): Matrix;
+
+ /**
+ * Fill a 3x3 matrix with the given column vectors
+ * @param {Vector3} column0 
+ * @param {Vector3} column1
+ * @param {Vector3} column2
+ * @param {Matrix} mat
+ */
+export function columnsToMat3(column0: Vector3, column1: Vector3, column2: Vector3, mat: Matrix): Matrix;
 
 /**
  * LU Factorization of a 3x3 matrix.
@@ -476,12 +532,12 @@ export function roundNumber(num: number, digits?: number): number;
 export function roundVector(vector: Vector3, out?: Vector3, digits?: number): Vector3;
 
 /**
- *
- * @param {Matrix} a 
- * @param {Number} n 
- * @param {Number[]} w 
- * @param {Number[]} v 
- */
+* Jacobi iteration for the solution of eigenvectors/eigenvalues. Input matrix a is modified (the upper triangle is filled with zeros)
+* @param {Matrix} a real symetric nxn matrix
+* @param {Number} n matrix size
+* @param {Number[]} w vector of size n to store eigenvalues (stored in decreasing order)
+* @param {Number[]} v matrix of size nxn to store eigenvectors (stored in decreasing order, normalized)
+*/
 export function jacobiN(a: Matrix, n: number, w: number[], v: number[]): number;
 
 /**
@@ -837,6 +893,8 @@ export function isFinite(value: any): boolean;
  */
 export declare const vtkMath: {
 	createArray: typeof createArray;
+	swapRowsMatrix_nxn: typeof swapRowsMatrix_nxn;
+	swapColumnsMatrix_nxn: typeof swapColumnsMatrix_nxn;
 	Pi: typeof Pi;
 	radiansFromDegrees: typeof radiansFromDegrees;
 	degreesFromRadians: typeof degreesFromRadians;
@@ -882,6 +940,10 @@ export declare const vtkMath: {
 	norm2D: typeof norm2D;
 	normalize2D: typeof normalize2D;
 	determinant2x2: typeof determinant2x2;
+	rowsToMat4: typeof rowsToMat4;
+	columnsToMat4: typeof columnsToMat4;
+	rowsToMat3: typeof rowsToMat3;
+	columnsToMat3: typeof columnsToMat3;
 	LUFactor3x3: typeof LUFactor3x3;
 	LUSolve3x3: typeof LUSolve3x3;
 	linearSolve3x3: typeof linearSolve3x3;

package/Common/Core/Math.js

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

package/Common/DataModel/DataSetAttributes/FieldData.d.ts

@@ -98,7 +98,7 @@ export interface vtkFieldData extends vtkObject {
 	 * 
 	 * @param {Number} idx The index of the array.
 	 */
-	getArrayByIndex(idx: number): any | null;
+	getArrayByIndex(idx: number): Nullable<any>;
 
 	/**
 	 * 

package/Common/DataModel/Line.js

@@ -73,9 +73,7 @@ function intersection(a1, a2, b1, b2, u, v) {
   subtract(b2, b1, b21);
   subtract(b1, a1, b1a1); // Compute the system (least squares) matrix.
 
-  var A = [];
-  A[0] = [dot(a21, a21), -dot(a21, b21)];
-  A[1] = [A[0][1], dot(b21, b21)]; // Compute the least squares system constant term.
+  var A = [dot(a21, a21), -dot(a21, b21), -dot(a21, b21), dot(b21, b21)]; // Compute the least squares system constant term.
 
   var c = [];
   c[0] = dot(a21, b1a1);

package/Common/Transform/LandmarkTransform.js

@@ -13,20 +13,7 @@ var Mode = Constants.Mode; // --------------------------------------------------
 
 function vtkLandmarkTransform(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkLandmarkTransform'); // Convert a mat4 matrix to a Matrix 2 dimensions
-
-  function mat4To2DArray(mat) {
-    var output = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]];
-    var cpt = 0;
-
-    for (var c = 0; c < 4; c++) {
-      for (var r = 0; r < 4; r++) {
-        output[r][c] = mat[cpt++];
-      }
-    }
-
-    return output;
-  }
+  model.classHierarchy.push('vtkLandmarkTransform');
 
   function update() {
     mat4.identity(model.matrix);
@@ -62,9 +49,9 @@ function vtkLandmarkTransform(publicAPI, model) {
 
     if (N_PTS === 1) {
       mat4.identity(model.matrix);
-      model.matrix.elem[12] = targetCentroid[0] - sourceCentroid[0];
-      model.matrix.elem[13] = targetCentroid[1] - sourceCentroid[1];
-      model.matrix.elem[14] = targetCentroid[2] - sourceCentroid[2];
+      model.matrix[12] = targetCentroid[0] - sourceCentroid[0];
+      model.matrix[13] = targetCentroid[1] - sourceCentroid[1];
+      model.matrix[14] = targetCentroid[2] - sourceCentroid[2];
       return model.matrix;
     } // -- build the 3x3 matrix M --
 
@@ -137,11 +124,11 @@ function vtkLandmarkTransform(publicAPI, model) {
       N[14] = N[11] = M[7] + M[5];
       /* eslint-enable no-multi-assign */
       // -- eigen-decompose N (is symmetric) --
+      // prettier-ignore
 
-      var eigenVectors = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]];
+      var eigenVectors = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
       var eigenValues = [0.0, 0.0, 0.0, 0.0];
-      var NMatrix = mat4To2DArray(N);
-      jacobiN(NMatrix, 4, eigenValues, eigenVectors); // The eigenvector with the largest eigenvalue is the quaternion we want
+      jacobiN(N, 4, eigenValues, eigenVectors); // The eigenvector with the largest eigenvalue is the quaternion we want
       // (they are sorted in decreasing order for us by JacobiN)
 
       var w;
@@ -207,10 +194,10 @@ function vtkLandmarkTransform(publicAPI, model) {
         }
       } else {
         // points are not collinear
-        w = eigenVectors[0][0];
-        x = eigenVectors[1][0];
-        y = eigenVectors[2][0];
-        z = eigenVectors[3][0];
+        w = eigenVectors[0];
+        x = eigenVectors[4];
+        y = eigenVectors[8];
+        z = eigenVectors[12];
       } // convert quaternion to a rotation matrix
 
 

package/Filters/General/OBBTree.js

@@ -44,7 +44,7 @@ function vtkOBBTree(publicAPI, model) {
     var a0 = [0, 0, 0];
     var a1 = [0, 0, 0];
     var a2 = [0, 0, 0];
-    var a = [a0, a1, a2];
+    var a = [0, 0, 0, 0, 0, 0, 0, 0, 0];
     var dp0 = [0, 0, 0];
     var dp1 = [0, 0, 0];
     var c = [0, 0, 0];
@@ -128,36 +128,34 @@ function vtkOBBTree(publicAPI, model) {
 
     a1[0] = a0[1];
     a2[0] = a0[2];
-    a2[1] = a1[2]; // get covariance from moments
+    a2[1] = a1[2];
+    a = [a0[0], a0[1], a0[2], a1[0], a1[1], a1[2], a2[0], a2[1], a2[2]]; // get covariance from moments
 
     for (var _i2 = 0; _i2 < 3; _i2++) {
       for (var _j2 = 0; _j2 < 3; _j2++) {
-        a[_i2][_j2] = a[_i2][_j2] / totMass - mean[_i2] * mean[_j2];
+        a[_i2 * 3 + _j2] = a[_i2 * 3 + _j2] / totMass - mean[_i2] * mean[_j2];
       }
     } //
     // Extract axes (i.e., eigenvectors) from covariance matrix.
     //
 
 
-    var v0 = [0, 0, 0];
-    var v1 = [0, 0, 0];
-    var v2 = [0, 0, 0];
-    var v = [v0, v1, v2];
+    var v = [0, 0, 0, 0, 0, 0, 0, 0, 0];
     jacobi(a, size, v);
-    max[0] = v[0][0];
-    max[1] = v[1][0];
-    max[2] = v[2][0];
-    mid[0] = v[0][1];
-    mid[1] = v[1][1];
-    mid[2] = v[2][1];
-    min[0] = v[0][2];
-    min[1] = v[1][2];
-    min[2] = v[2][2];
+    max[0] = v[0];
+    max[1] = v[3];
+    max[2] = v[6];
+    mid[0] = v[1];
+    mid[1] = v[4];
+    mid[2] = v[7];
+    min[0] = v[2];
+    min[1] = v[5];
+    min[2] = v[8];
 
     for (var _i3 = 0; _i3 < 3; _i3++) {
-      a[0][_i3] = mean[_i3] + max[_i3];
-      a[1][_i3] = mean[_i3] + mid[_i3];
-      a[2][_i3] = mean[_i3] + min[_i3];
+      a[_i3] = mean[_i3] + max[_i3];
+      a[3 + _i3] = mean[_i3] + mid[_i3];
+      a[6 + _i3] = mean[_i3] + min[_i3];
     } //
     // Create oriented bounding box by projecting points onto eigenvectors.
     //
@@ -171,7 +169,7 @@ function vtkOBBTree(publicAPI, model) {
       var _p = model.pointsList[ptId];
 
       for (var _i4 = 0; _i4 < 3; _i4++) {
-        var out = vtkLine.distanceToLine(_p, mean, a[_i4], []);
+        var out = vtkLine.distanceToLine(_p, mean, a.slice(3 * _i4, 3 * (_i4 + 1)), []);
 
         if (out.t < tMin[_i4]) {
           tMin[_i4] = out.t;
@@ -513,7 +511,7 @@ function vtkOBBTree(publicAPI, model) {
     var eps = model.tolerance;
     var pA = nodeA;
     var pB = vtkOBBNode.newInstance();
-    var dotAB = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+    var dotAB = [0, 0, 0, 0, 0, 0, 0, 0, 0];
 
     if (XformBtoA) {
       // Here we assume that XformBtoA is an orthogonal matrix
@@ -606,7 +604,7 @@ function vtkOBBTree(publicAPI, model) {
       for (var jj = 0; jj < 3; jj++) {
         // (note: we are saving all 9 dotproducts for future use)
         dotA = dot(pB.getAxis(_ii5), pA.getAxis(jj));
-        dotAB[_ii5][jj] = dotA;
+        dotAB[_ii5 * 3 + jj] = dotA;
 
         if (dotA > 0) {
           rangeAmax += dotA;
@@ -633,7 +631,7 @@ function vtkOBBTree(publicAPI, model) {
 
       for (var _jj = 0; _jj < 3; _jj++) {
         // (note: we are using the 9 dotproducts computed earlier)
-        dotB = dotAB[_jj][_ii6];
+        dotB = dotAB[_jj * 3 + _ii6];
 
         if (dotB > 0) {
           rangeBmax += dotB;

package/Filters/Texture/TextureMapToPlane.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { l as normalize, d as dot, j as cross, f as distance2BetweenPoints, z as determinant3x3 } from '../../Common/Core/Math/index.js';
+import { l as normalize, d as dot, j as cross, f as distance2BetweenPoints, z as determinant3x3, A as rowsToMat3 } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
@@ -56,10 +56,6 @@ function vtkTextureMapToPlane(publicAPI, model) {
     v[1] = 0.0;
     v[2] = 0.0;
 
-    for (i = 0; i < 9; i++) {
-      m[i] = 0.0;
-    }
-
     for (var ptId = 0; ptId < nbPoints; ptId++) {
       output.getPoints().getPoint(ptId, x);
       v[0] += x[0] * x[2];
@@ -80,21 +76,16 @@ function vtkTextureMapToPlane(publicAPI, model) {
     var c1 = [m[0], m[1], m[2]];
     var c2 = [m[3], m[4], m[5]];
     var c3 = [m[6], m[7], m[8]];
-    var matrix = [c1, c2, c3];
-    var det = determinant3x3(matrix);
+    var det = determinant3x3(m);
 
     if (det <= VTK_TOLERANCE) {
       return;
     }
 
-    matrix[0] = v;
-    matrix[1] = c2;
-    matrix[2] = c3;
-    model.normal[0] = determinant3x3(matrix) / det;
-    matrix[0] = c1;
-    matrix[1] = v;
-    matrix[2] = c3;
-    model.normal[1] = determinant3x3(matrix) / det; // because of the formulation
+    m = rowsToMat3(v, c2, c3, []);
+    model.normal[0] = determinant3x3(m) / det;
+    m = rowsToMat3(c1, v, c3, []);
+    model.normal[1] = determinant3x3(m) / det; // because of the formulation
 
     model.normal[2] = -1.0;
   }

package/IO/Core/HttpSceneLoader.d.ts

@@ -29,7 +29,7 @@ export interface vtkHttpSceneLoader extends vtkObject {
 
 	/**
 	 * 
-	 * @param fetchGzip 
+	 * @param {Boolean} fetchGzip 
 	 */
 	getFetchGzip(fetchGzip: boolean): boolean;
 
@@ -70,10 +70,19 @@ export interface vtkHttpSceneLoader extends vtkObject {
 
 	/**
 	 * 
-	 * @param renderer 
+	 * @param {vtkRenderer} renderer The vtkRenderer instance. 
 	 */
 	setRenderer(renderer: vtkRenderer): boolean;
+
+	/**
+	 * 
+	 * @param {String} url 
+	 */
 	setUrl(url: string): void;
+
+	/**
+	 * 
+	 */
 	update(): void;
 }
 

package/Interaction/Manipulators/MouseCameraTrackballRollManipulator.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { r as radiansFromDegrees, A as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, B as degreesFromRadians } from '../../Common/Core/Math/index.js';
 
 // vtkMouseCameraTrackballRollManipulator methods
 // ----------------------------------------------------------------------------

package/Interaction/Manipulators/MouseCameraUnicamRotateManipulator.js

@@ -10,7 +10,7 @@ import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
-import { B as areEquals, l as normalize, d as dot, C as clampValue, s as subtract, j as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { C as areEquals, l as normalize, d as dot, D as clampValue, s as subtract, j as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 
 var States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
 // vtkMouseCameraUnicamRotateManipulator methods

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkInteractorStyle from '../../Rendering/Core/InteractorStyle.js';
 import vtkInteractorStyleConstants from '../../Rendering/Core/InteractorStyle/Constants.js';
-import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { B as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 
 var States = vtkInteractorStyleConstants.States;

package/Interaction/Widgets/PiecewiseGaussianWidget.js

@@ -2,7 +2,7 @@ import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
-import { D as arrayRange } from '../../Common/Core/Math/index.js';
+import { E as arrayRange } from '../../Common/Core/Math/index.js';
 import WebworkerPromise from 'webworker-promise';
 import { W as WorkerFactory } from '../../_virtual/rollup-plugin-worker-loader__module_Sources/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js';
 

package/Proxy/Core/View2DProxy.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkMouseRangeManipulator from '../../Interaction/Manipulators/MouseRangeManipulator.js';
 import vtkViewProxy from './ViewProxy.js';
-import { j as cross, E as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
+import { j as cross, F as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
 
 var DEFAULT_STEP_WIDTH = 512;
 

package/Rendering/Core/Camera.d.ts

@@ -55,6 +55,11 @@ export interface vtkCamera extends vtkObject {
 	 */
 	computeDistance(): void;
 
+	/**
+	 * 
+	 */
+	computeCameraLightTransform(): void;
+
 	/**
 	 * the provided matrix should include translation and orientation only mat
 	 * is physical to view
@@ -439,6 +444,12 @@ export interface vtkCamera extends vtkObject {
 	 */
 	setFocalPointFrom(focalPoint: Vector3): boolean;
 
+	/**
+	 * Set the value of the FreezeDolly instance variable.
+	 * @param {Boolean} freezeFocalPoint 
+	 */
+	setFreezeFocalPoint(freezeFocalPoint: boolean): boolean;
+
 	/**
 	 * Not implement yet
 	 * Set the oblique viewing angles.
@@ -633,7 +644,7 @@ export interface vtkCamera extends vtkObject {
 	 * @param {Boolean} useHorizontalViewAngle The value of the useHorizontalViewAngle.
 	 */
 	setUseHorizontalViewAngle(useHorizontalViewAngle: boolean): boolean;
-	
+
 	/**
 	 * Set use offaxis frustum.
 	 * 

package/Rendering/Core/CellPicker.d.ts

@@ -69,7 +69,7 @@ export interface vtkCellPicker extends vtkPicker {
 	/**
 	 * 
 	 * @param selection 
-	 * @param {vtkRenderer} renderer 
+	 * @param {vtkRenderer} renderer The vtkRenderer instance.
 	 */
 	pick(selection: any, renderer: vtkRenderer): void;
 
@@ -78,7 +78,7 @@ export interface vtkCellPicker extends vtkPicker {
 	 * @param {Vector3} p1 
 	 * @param {Vector3} p2 
 	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper 
+	 * @param {vtkMapper} mapper The vtkMapper instance.
 	 */
 	intersectWithLine(p1: Vector3, p2: Vector3, tol: number, mapper: vtkMapper): number;
 
@@ -89,7 +89,7 @@ export interface vtkCellPicker extends vtkPicker {
 	 * @param {Number} t1 
 	 * @param {Number} t2 
 	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper 
+	 * @param {vtkMapper} mapper The vtkMapper instance.
 	 */
 	intersectActorWithLine(p1: Vector3, p2: Vector3, t1: number, t2: number, tol: number, mapper: vtkMapper): number;
 }

package/Rendering/Core/ColorTransferFunction.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { h as hsv2rgb, i as isNan, F as isInf, G as rgb2hsv, H as rgb2lab, I as lab2rgb, J as floor } from '../../Common/Core/Math/index.js';
+import { h as hsv2rgb, i as isNan, G as isInf, H as rgb2hsv, I as rgb2lab, J as lab2rgb, K as floor } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import Constants from './ColorTransferFunction/Constants.js';
 

package/Rendering/Core/Coordinate.d.ts

@@ -20,43 +20,43 @@ export interface vtkCoordinate extends vtkObject {
 
 	/**
 	 *
-	 * @param {vtkRenderer} ren 
+	 * @param {vtkRenderer} ren The vtkRenderer instance.
 	 */
 	getComputedWorldValue(ren: vtkRenderer): number[];
 
 	/**
 	 *
-	 * @param {vtkRenderer} ren 
+	 * @param {vtkRenderer} ren The vtkRenderer instance.
 	 */
 	getComputedViewportValue(ren: vtkRenderer): number[];
 
 	/**
 	 *
-	 * @param {vtkRenderer} ren 
+	 * @param {vtkRenderer} ren The vtkRenderer instance.
 	 */
 	getComputedDisplayValue(ren: vtkRenderer): number[];
 
 	/**
 	 *
-	 * @param {vtkRenderer} ren 
+	 * @param {vtkRenderer} ren The vtkRenderer instance.
 	 */
 	getComputedLocalDisplayValue(ren: vtkRenderer): number[];
 
 	/**
 	 *
-	 * @param {vtkRenderer} ren 
+	 * @param {vtkRenderer} ren The vtkRenderer instance.
 	 */
 	getComputedValue(ren: vtkRenderer): number[];
 
 	/**
 	 *
-	 * @param {vtkRenderer} ren 
+	 * @param {vtkRenderer} ren The vtkRenderer instance.
 	 */
 	getComputedDoubleViewportValue(ren: vtkRenderer): number[];
 
 	/**
 	 *
-	 * @param {vtkRenderer} ren 
+	 * @param {vtkRenderer} ren The vtkRenderer instance.
 	 */
 	getComputedDoubleDisplayValue(ren: vtkRenderer): number[];
 

package/Rendering/Core/Coordinate.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import Constants from './Coordinate/Constants.js';
-import { K as round, J as floor } from '../../Common/Core/Math/index.js';
+import { L as round, K as floor } from '../../Common/Core/Math/index.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; }
 

package/Rendering/Core/CubeAxesActor.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { L as normalize2D, M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { M as normalize2D, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';

package/Rendering/Core/Glyph3DMapper.js

@@ -4,7 +4,7 @@ import { mat4, vec3, mat3 } from 'gl-matrix';
 import Constants from './Glyph3DMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkMapper from './Mapper.js';
-import { N as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
+import { O as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.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; }

package/Rendering/Core/ImageMapper.d.ts

@@ -198,7 +198,7 @@ export interface vtkImageMapper extends vtkAbstractMapper {
 	 * @param {Number} factor 
 	 * @param {Number} offset 
 	 */
-	setResolveCoincidentTopologyPolygonOffsetParameters(factor: number, offset: number)
+	setResolveCoincidentTopologyPolygonOffsetParameters(factor: number, offset: number): boolean;
 
 	/**
 	 *

package/Rendering/Core/ImageMapper.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import Constants from './ImageMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkAbstractMapper from './AbstractMapper.js';
-import { C as clampValue, O as multiply3x3_vect3, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { D as clampValue, P as multiply3x3_vect3, O as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import { vec3 } from 'gl-matrix';
@@ -201,8 +201,7 @@ function vtkImageMapper(publicAPI, model) {
     // transpositions resulting in a no-op.
 
     var a = publicAPI.getInputData().getDirection();
-    var mat3 = [[a[0], a[1], a[2]], [a[3], a[4], a[5]], [a[6], a[7], a[8]]];
-    multiply3x3_vect3(mat3, inVec3, out);
+    multiply3x3_vect3(a, inVec3, out);
     var maxAbs = 0.0;
     var ijkMode = -1;
     var flip = false;

package/Rendering/Core/ImageSlice.d.ts

@@ -1,10 +1,10 @@
 import { Bounds } from './../../types';
 import vtkImageProperty from './ImageProperty';
-import vtkMapper from './Mapper';
+import vtkImageMapper from './ImageMapper';
 import vtkProp3D, { IProp3DInitialValues } from './Prop3D';
 
-interface IImageSliceInitialValues extends IProp3DInitialValues{
-	mapper?: vtkMapper;
+export interface IImageSliceInitialValues extends IProp3DInitialValues{
+	mapper?: vtkImageMapper;
 	property?: vtkImageProperty;
 	bounds?: Bounds;
 }
@@ -49,7 +49,7 @@ export interface vtkImageSlice extends vtkProp3D {
 	/**
 	 * 
 	 */
-	getMapper(): vtkMapper;
+	getMapper(): vtkImageMapper;
 	
 	/**
 	 * Get the minimum X bound