@kitware/vtk.js 26.0.0-beta.1 → 26.0.0-beta.3

package/Common/Core/ClassHierarchy.js

@@ -1,4 +1,3 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
 import _createClass from '@babel/runtime/helpers/createClass';
 import _get from '@babel/runtime/helpers/get';
@@ -11,6 +10,7 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
+/* eslint-disable prefer-rest-params */
 var ClassHierarchy = /*#__PURE__*/function (_Array) {
   _inherits(ClassHierarchy, _Array);
 
@@ -25,18 +25,13 @@ var ClassHierarchy = /*#__PURE__*/function (_Array) {
   _createClass(ClassHierarchy, [{
     key: "push",
     value: function push() {
-      var _this = this,
-          _get2;
-
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
+      for (var i = 0; i < arguments.length; i++) {
+        if (!this.includes(arguments[i])) {
+          _get(_getPrototypeOf(ClassHierarchy.prototype), "push", this).call(this, arguments[i]);
+        }
       }
 
-      // no perf issue since args.length should be small
-      var newArgs = args.filter(function (arg) {
-        return !_this.includes(arg);
-      });
-      return (_get2 = _get(_getPrototypeOf(ClassHierarchy.prototype), "push", this)).call.apply(_get2, [this].concat(_toConsumableArray(newArgs)));
+      return this.length;
     }
   }]);
 

package/Common/Core/Math/Constants.js

@@ -0,0 +1,12 @@
+var IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+var IDENTITY_3X3 = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+var EPSILON = 1e-6;
+var VTK_SMALL_NUMBER = 1.0e-12;
+var Constants = {
+  IDENTITY: IDENTITY,
+  IDENTITY_3X3: IDENTITY_3X3,
+  EPSILON: EPSILON,
+  VTK_SMALL_NUMBER: VTK_SMALL_NUMBER
+};
+
+export { EPSILON, IDENTITY, IDENTITY_3X3, VTK_SMALL_NUMBER, Constants as default };

package/Common/Core/Math/index.js

@@ -2,6 +2,7 @@ import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import seedrandom from 'seedrandom';
 import macro from '../../../macros.js';
+import { IDENTITY, IDENTITY_3X3, VTK_SMALL_NUMBER, EPSILON } from './Constants.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro,
     vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
@@ -17,7 +18,6 @@ var vtkErrorMacro = macro.vtkErrorMacro,
 
 var randomSeedValue = 0;
 var VTK_MAX_ROTATIONS = 20;
-var VTK_SMALL_NUMBER = 1.0e-12;
 
 function notImplemented(method) {
   return function () {
@@ -53,7 +53,13 @@ function swapColumnsMatrix_nxn(matrix, n, column1, column2) {
 function createArray() {
   var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;
   // faster than Array.from and/or while loop
-  return Array(size).fill(0);
+  var res = Array(size);
+
+  for (var i = 0; i < size; ++i) {
+    res[i] = 0;
+  }
+
+  return res;
 }
 var Pi = function Pi() {
   return Math.PI;
@@ -676,6 +682,27 @@ function invert3x3(in_3x3, outI_3x3) {
 function determinant3x3(mat_3x3) {
   return mat_3x3[0] * mat_3x3[4] * mat_3x3[8] + mat_3x3[3] * mat_3x3[7] * mat_3x3[2] + mat_3x3[6] * mat_3x3[1] * mat_3x3[5] - mat_3x3[0] * mat_3x3[7] * mat_3x3[5] - mat_3x3[3] * mat_3x3[1] * mat_3x3[8] - mat_3x3[6] * mat_3x3[4] * mat_3x3[2];
 }
+/**
+ * Returns true if elements of both arrays are equals.
+ * @param {Array} a an array of numbers (vector, point, matrix...)
+ * @param {Array} b an array of numbers (vector, point, matrix...)
+ * @param {Number} eps tolerance
+ */
+
+function areEquals(a, b) {
+  var eps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EPSILON;
+
+  if (a.length !== b.length) {
+    return false;
+  }
+
+  function isEqual(element, index) {
+    return Math.abs(element - b[index]) <= eps;
+  }
+
+  return a.every(isEqual);
+}
+var areMatricesEqual = areEquals;
 function identity3x3(mat_3x3) {
   for (var i = 0; i < 3; i++) {
     /* eslint-disable-next-line no-multi-assign */
@@ -694,6 +721,14 @@ function identity(n, mat) {
 
   return mat;
 }
+function isIdentity(mat) {
+  var eps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;
+  return areMatricesEqual(mat, IDENTITY, eps);
+}
+function isIdentity3x3(mat) {
+  var eps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;
+  return areMatricesEqual(mat, IDENTITY_3X3, eps);
+}
 function quaternionToMatrix3x3(quat_4, mat_3x3) {
   var ww = quat_4[0] * quat_4[0];
   var wx = quat_4[0] * quat_4[1];
@@ -720,27 +755,6 @@ function quaternionToMatrix3x3(quat_4, mat_3x3) {
   mat_3x3[5] = (yz - wx) * f;
   mat_3x3[8] = zz * f + s;
 }
-/**
- * Returns true if elements of both arrays are equals.
- * @param {Array} a an array of numbers (vector, point, matrix...)
- * @param {Array} b an array of numbers (vector, point, matrix...)
- * @param {Number} eps tolerance
- */
-
-function areEquals(a, b) {
-  var eps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1e-6;
-
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  function isEqual(element, index) {
-    return Math.abs(element - b[index]) <= eps;
-  }
-
-  return a.every(isEqual);
-}
-var areMatricesEqual = areEquals;
 function roundNumber(num) {
   var digits = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
 
@@ -1406,7 +1420,8 @@ function solveLinearSystem(A, x, size) {
 
   luSolveLinearSystem(A, index, x, size);
   return 1;
-}
+} // Note that A is modified during the inversion !
+
 function invertMatrix(A, AI, size) {
   var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
   var column = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
@@ -1416,7 +1431,7 @@ function invertMatrix(A, AI, size) {
   // memory whose values are not used in LUSolveLinearSystem
 
   if (luFactorLinearSystem(A, tmp1Size, size) === 0) {
-    return 0;
+    return null;
   }
 
   for (var j = 0; j < size; j++) {
@@ -1432,7 +1447,7 @@ function invertMatrix(A, AI, size) {
     }
   }
 
-  return 1;
+  return AI;
 }
 function estimateMatrixCondition(A, size) {
   var minValue = +Number.MAX_VALUE;
@@ -2174,6 +2189,8 @@ var vtkMath = {
   invert3x3: invert3x3,
   identity3x3: identity3x3,
   identity: identity,
+  isIdentity: isIdentity,
+  isIdentity3x3: isIdentity3x3,
   determinant3x3: determinant3x3,
   quaternionToMatrix3x3: quaternionToMatrix3x3,
   areEquals: areEquals,
@@ -2291,11 +2308,13 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   transpose3x3: transpose3x3,
   invert3x3: invert3x3,
   determinant3x3: determinant3x3,
+  areEquals: areEquals,
+  areMatricesEqual: areMatricesEqual,
   identity3x3: identity3x3,
   identity: identity,
+  isIdentity: isIdentity,
+  isIdentity3x3: isIdentity3x3,
   quaternionToMatrix3x3: quaternionToMatrix3x3,
-  areEquals: areEquals,
-  areMatricesEqual: areMatricesEqual,
   roundNumber: roundNumber,
   roundVector: roundVector,
   jacobiN: jacobiN,
@@ -2347,4 +2366,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { ceilLog2 as $, rowsToMat3 as A, degreesFromRadians as B, areEquals as C, clampValue as D, arrayRange as E, getMajorAxisIndex 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, createUninitializedBounds as O, multiply3x3_vect3 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, 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, luFactorLinearSystem as aA, luSolveLinearSystem as aB, invertMatrix as aC, estimateMatrixCondition as aD, solveHomogeneousLeastSquares as aE, solveLeastSquares as aF, hex2float as aG, lab2xyz as aH, xyz2lab as aI, xyz2rgb as aJ, rgb2xyz as aK, clampAndNormalizeValue as aL, getScalarTypeFittingRange as aM, getAdjustedScalarRange as aN, extentIsWithinOtherExtent as aO, boundsIsWithinOtherBounds as aP, pointIsWithinBounds as aQ, solve3PointCircle as aR, inf as aS, negInf as aT, isFinite as aU, isNaN as aV, floatToHex2 as aW, floatRGB2HexCode as aX, float2CssRGBA as aY, 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, quaternionToMatrix3x3 as at, roundNumber as au, matrix3x3ToQuaternion as av, multiplyQuaternion as aw, orthogonalize3x3 as ax, diagonalize3x3 as ay, singularValueDecomposition3x3 as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, vtkMath as g, hsv2rgb as h, isNan as i, solveLinearSystem as j, cross as k, add as l, normalize as m, norm as n, multiplyAccumulate as o, determinant2x2 as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };
+export { ceilLog2 as $, rowsToMat3 as A, degreesFromRadians as B, areEquals as C, clampValue as D, arrayRange as E, getMajorAxisIndex 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, createUninitializedBounds as O, multiply3x3_vect3 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, 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, 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_, 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, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, vtkMath as g, hsv2rgb as h, isNan as i, solveLinearSystem as j, cross as k, add as l, normalize as m, norm as n, multiplyAccumulate as o, determinant2x2 as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };

package/Common/Core/Math.d.ts

@@ -489,12 +489,41 @@ export function transpose3x3(in_3x3: Matrix3x3, outT_3x3: Matrix3x3): void;
  */
 export function invert3x3(in_3x3: Matrix3x3, outI_3x3: Matrix3x3): void;
 
+/**
+ * Set mat to the identity matrix.
+ * @param {Number} n The size of the matrix.
+ * @param {Number[]} mat The output matrix.
+ * @see isIdentity()
+ * @see identity3x3()
+ */
+export function identity(n: number, mat: number[]): void;
+
 /**
  * Set mat_3x3 to the identity matrix.
  * @param {Matrix3x3} mat_3x3 The input 3x3 matrix.
+ * @see isIdentity3x3()
+ * @see identity()
  */
 export function identity3x3(mat_3x3: Matrix3x3): void;
 
+/**
+ * Returns true if provided matrix is the identity matrix.
+ * @param {Number[]} mat The 3x3 matrix to check
+ * @param {Number} [eps] The tolerance value.
+ * @see isIdentity()
+ * @see identity()
+ */
+export function isIdentity(mat: Matrix3x3, eps?: number): boolean;
+
+/**
+ * Returns true if provided 3x3 matrix is the identity matrix.
+ * @param {Matrix3x3} mat The 3x3 matrix to check
+ * @param {Number} [eps] The tolerance value.
+ * @see isIdentity()
+ * @see identity3x3()
+ */
+export function isIdentity3x3(mat: Matrix3x3, eps?: number): boolean;
+
 /**
  * Calculate the determinant of a 3x3 matrix.
  * @param {Matrix3x3} mat_3x3 The input 3x3 matrix.
@@ -606,13 +635,14 @@ export function solveLinearSystem(A: Matrix, x: number[], size: number): number;
 
 /**
  *
- * @param {Matrix} A 
- * @param {Matrix} AI 
- * @param {Number} [size] 
+ * @param {Matrix} A The input matrix. It is modified during the inversion.
+ * @param {Matrix} AI The output inverse matrix. Can be the same as input matrix.
+ * @param {Number} [size] The square size of the matrix to invert : 4 for a 4x4
  * @param {Number[]} [index] 
  * @param {Number[]} [column] 
+ * @return AI on success, null otherwise
  */
-export function invertMatrix(A: Matrix, AI: Matrix, size?: number, index?: number[], column?: number[]): number;
+export function invertMatrix(A: Matrix, AI: Matrix, size?: number, index?: number[], column?: number[]): Matrix|null;
 
 /**
  *

package/Common/Core/Math.js

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

package/Common/Core/MatrixBuilder.d.ts

@@ -1,4 +1,4 @@
-import { mat4 } from 'gl-matrix';
+import { mat3, mat4 } from 'gl-matrix';
 import { TypedArray, Vector3 } from './../../types';
 
 declare interface Transform {
@@ -66,11 +66,22 @@ declare interface Transform {
 	 */
 	multiply(mat4x4: mat4): Transform
 
+	/**
+	 * Multiply the current matrix with the provided 3x3 matrix.
+	 * @param {mat3} mat3x3 column-first matrix
+	 */
+	 multiply3x3(mat3x3: mat3): Transform
+	
 	/**
 	 * Resets the MatrixBuilder to the Identity matrix.
-	 */	
+	 */
 	identity(): Transform
 
+	/**
+	 * Inverts the MatrixBuilder matrix.
+	 */
+	invert(): Transform
+
 	/**
 	 * Multiplies the array by the MatrixBuilder's internal matrix, in sets of
 	 * 3. Updates the array in place. If specified, `offset` starts at a given

package/Common/Core/MatrixBuilder.js

@@ -1,14 +1,14 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
 import _createClass from '@babel/runtime/helpers/createClass';
-import { mat4, vec3, glMatrix } from 'gl-matrix';
+import { vec3, mat4, glMatrix } from 'gl-matrix';
 import { a as areMatricesEqual } from './Math/index.js';
+import { IDENTITY } from './Math/Constants.js';
 
 var NoOp = function NoOp(v) {
   return v;
 };
 
-var IDENTITY = mat4.identity(new Float64Array(16));
 var EPSILON = 1e-6;
 
 var Transform = /*#__PURE__*/function () {
@@ -100,6 +100,18 @@ var Transform = /*#__PURE__*/function () {
       mat4.multiply(this.matrix, this.matrix, mat4x4);
       return this;
     }
+  }, {
+    key: "multiply3x3",
+    value: function multiply3x3(mat3x3) {
+      mat4.multiply(this.matrix, this.matrix, [mat3x3[0], mat3x3[1], mat3x3[2], 0, mat3x3[3], mat3x3[4], mat3x3[5], 0, mat3x3[6], mat3x3[7], mat3x3[8], 0, 0, 0, 0, 1]);
+      return this;
+    }
+  }, {
+    key: "invert",
+    value: function invert() {
+      mat4.invert(this.matrix, this.matrix);
+      return this;
+    }
   }, {
     key: "identity",
     value: function identity() {

package/Common/Core/ScalarsToColors.d.ts

@@ -105,10 +105,8 @@ export interface vtkScalarsToColors extends vtkObject {
 
 	/**
 	 * 
-	 * @param {Number} min 
-	 * @param {Number} max 
 	 */
-	getRange(min: number, max: number): Range;
+	getRange(): Range;
 
 	/**
 	 * Get which component of a vector to map to colors.

package/Common/Core/ScalarsToColors.js

@@ -501,7 +501,7 @@ function vtkScalarsToColors(publicAPI, model) {
     return publicAPI.setMappingRange(min, max);
   };
 
-  publicAPI.getRange = function (min, max) {
+  publicAPI.getRange = function () {
     return publicAPI.getMappingRange();
   };
 } // ----------------------------------------------------------------------------

package/Common/DataModel/BoundingBox.js

@@ -38,7 +38,7 @@ function _reset(bounds) {
   return _setBounds(bounds, INIT_BOUNDS);
 }
 
-function _addPoint(bounds) {
+function _addPoint(bounds, x, y, z) {
   var _bounds = _slicedToArray(bounds, 6),
       xMin = _bounds[0],
       xMax = _bounds[1],
@@ -47,12 +47,12 @@ function _addPoint(bounds) {
       zMin = _bounds[4],
       zMax = _bounds[5];
 
-  bounds[0] = xMin < (arguments.length <= 1 ? undefined : arguments[1]) ? xMin : arguments.length <= 1 ? undefined : arguments[1];
-  bounds[1] = xMax > (arguments.length <= 1 ? undefined : arguments[1]) ? xMax : arguments.length <= 1 ? undefined : arguments[1];
-  bounds[2] = yMin < (arguments.length <= 2 ? undefined : arguments[2]) ? yMin : arguments.length <= 2 ? undefined : arguments[2];
-  bounds[3] = yMax > (arguments.length <= 2 ? undefined : arguments[2]) ? yMax : arguments.length <= 2 ? undefined : arguments[2];
-  bounds[4] = zMin < (arguments.length <= 3 ? undefined : arguments[3]) ? zMin : arguments.length <= 3 ? undefined : arguments[3];
-  bounds[5] = zMax > (arguments.length <= 3 ? undefined : arguments[3]) ? zMax : arguments.length <= 3 ? undefined : arguments[3];
+  bounds[0] = xMin < x ? xMin : x;
+  bounds[1] = xMax > x ? xMax : x;
+  bounds[2] = yMin < y ? yMin : y;
+  bounds[3] = yMax > y ? yMax : y;
+  bounds[4] = zMin < z ? zMin : z;
+  bounds[5] = zMax > z ? zMax : z;
   return bounds;
 }
 

package/Common/DataModel/EdgeLocator.d.ts

@@ -0,0 +1,79 @@
+import { Nullable } from './../../types';
+
+/**
+ *
+ */
+export interface IEdgeLocatorInitialValues {
+	oriented?: boolean;
+}
+
+export interface IEdge<T = unknown> {
+	key: number;
+	edgeId: number;
+	value?: T;
+}
+
+export interface vtkEdgeLocator {
+	/**
+	 * Remove all the edges previously added.
+	 */
+	 initialize(): void;
+
+	/**
+	 * Returns the inserted edge or null if no edge was inserted.
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @return {IEdge|null} an edge object ({ key, edgeId, value }) or null
+	 */
+	isInsertedEdge<T = unknown>(pointId0: number, pointId1: number): Nullable<IEdge<T>>;
+
+	/**
+	 * Insert edge if it does not already exist.
+	 * Returns the existing or newly inserted edge.
+	 *
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @param {unknown} value Optional value option
+	 * @return {IEdge|null} an edge object ({ key, edgeId, value }) or null
+	 * @see insertEdge()
+	 * @see isInsertedEdge()
+	 */
+	insertUniqueEdge<T>(pointId0: number, pointId1: number, value?: T): IEdge<T>;
+
+	/**
+	 * Insert edge. If the edge already exists, it is overwritten by this
+	 * new edge. You may verify that the edge did not previously exist with
+	 * `isInsertedEdge()`.
+	 * Returns the newly inserted edge.
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @param {unknown} value Optional value option
+	 * @return {Edge|null} an edge object ({ key, edgeId, value }) or null
+	 * @see isInsertedEdge
+	 * @see insertUniqueEdge
+	 */
+	insertEdge<T>(pointId0: number, pointId1: number, value?: T): IEdge<T>;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to create a new instance of vtkEdgeLocator
+ * @param {IEdgeLocatorInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+	initialValues?: IEdgeLocatorInitialValues
+): vtkEdgeLocator;
+
+/**
+ * vtkEdgeLocator
+ */
+export declare const vtkEdgeLocator: {
+	newInstance: typeof newInstance;
+};
+
+export default vtkEdgeLocator;

package/Common/DataModel/EdgeLocator.js

@@ -0,0 +1,85 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+
+var EdgeLocator = /*#__PURE__*/function () {
+  function EdgeLocator() {
+    var oriented = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+    _classCallCheck(this, EdgeLocator);
+
+    this.oriented = oriented;
+    this.edgeMap = new Map();
+  }
+
+  _createClass(EdgeLocator, [{
+    key: "initialize",
+    value: function initialize() {
+      this.edgeMap.clear();
+    }
+  }, {
+    key: "computeEdgeKey",
+    value: function computeEdgeKey(pointId0, pointId1) {
+      return this.oriented || pointId0 < pointId1 ? // Cantor pairing function:
+      0.5 * (pointId0 * pointId1) * (pointId0 * pointId1 + 1) + pointId1 : 0.5 * (pointId1 * pointId0) * (pointId1 * pointId0 + 1) + pointId0;
+    }
+  }, {
+    key: "insertUniqueEdge",
+    value: function insertUniqueEdge(pointId0, pointId1, newEdgeValue) {
+      // Generate a unique key
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      var node = this.edgeMap.get(key);
+
+      if (!node) {
+        // Didn't find key, so add a new edge entry
+        node = {
+          key: key,
+          edgeId: this.edgeMap.size,
+          value: newEdgeValue
+        };
+        this.edgeMap.set(key, node);
+      }
+
+      return node;
+    }
+  }, {
+    key: "insertEdge",
+    value: function insertEdge(pointId0, pointId1, newEdgeValue) {
+      // Generate a unique key
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      var node = {
+        key: key,
+        edgeId: this.edgeMap.size,
+        value: newEdgeValue
+      };
+      this.edgeMap.set(key, node);
+      return node;
+    }
+  }, {
+    key: "isInsertedEdge",
+    value: function isInsertedEdge(pointId0, pointId1) {
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      return this.edgeMap.get(key);
+    }
+  }], [{
+    key: "getEdgePointIds",
+    value: function getEdgePointIds(node) {
+      var n = 0.5 * (-1 + Math.sqrt(8 * node.key + 1));
+      var pointId0 = node.key - 0.5 * (n + 1) * n;
+      var pointId1 = n - pointId0;
+      return [pointId0, pointId1];
+    }
+  }]);
+
+  return EdgeLocator;
+}();
+
+function newInstance() {
+  var initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new EdgeLocator(initialValues.oriented);
+}
+
+var vtkEdgeLocator = {
+  newInstance: newInstance
+};
+
+export { vtkEdgeLocator as default };

package/Common/DataModel/ImageData.js

@@ -222,55 +222,6 @@ function vtkImageData(publicAPI, model) {
     model.indexToWorld[10] = model.direction[8];
     mat4.scale(model.indexToWorld, model.indexToWorld, model.spacing);
     mat4.invert(model.worldToIndex, model.indexToWorld);
-  }; //
-  // The direction matrix is a 3x3 basis for the I, J, K axes
-  // of the image. The rows of the matrix correspond to the
-  // axes directions in world coordinates. Direction must
-  // form an orthonormal basis, results are undefined if
-  // it is not.
-  //
-
-
-  publicAPI.setDirection = function () {
-    if (model.deleted) {
-      vtkErrorMacro('instance deleted - cannot call any method');
-      return false;
-    }
-
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
-    }
-
-    var array = args; // allow an array passed as a single arg.
-
-    if (array.length === 1 && (Array.isArray(array[0]) || array[0].constructor === Float32Array || array[0].constructor === Float64Array)) {
-      array = array[0];
-    }
-
-    if (array.length !== 9) {
-      throw new RangeError('Invalid number of values for array setter');
-    }
-
-    var changeDetected = false;
-    model.direction.forEach(function (item, index) {
-      if (item !== array[index]) {
-        if (changeDetected) {
-          return;
-        }
-
-        changeDetected = true;
-      }
-    });
-
-    if (changeDetected) {
-      for (var i = 0; i < 9; ++i) {
-        model.direction[i] = array[i];
-      }
-
-      publicAPI.modified();
-    }
-
-    return true;
   };
 
   publicAPI.indexToWorld = function (ain) {
@@ -487,8 +438,9 @@ function extend(publicAPI, model) {
   model.indexToWorld = new Float64Array(16);
   model.worldToIndex = new Float64Array(16); // Set/Get methods
 
-  macro.get(publicAPI, model, ['direction', 'indexToWorld', 'worldToIndex']);
+  macro.get(publicAPI, model, ['indexToWorld', 'worldToIndex']);
   macro.setGetArray(publicAPI, model, ['origin', 'spacing'], 3);
+  macro.setGetArray(publicAPI, model, ['direction'], 9);
   macro.getArray(publicAPI, model, ['extent'], 6); // Object specific methods
 
   vtkImageData(publicAPI, model);

package/Common/DataModel/IncrementalOctreeNode.d.ts

@@ -48,6 +48,21 @@ export interface vtkIncrementalOctreeNode extends vtkObject {
 	 */
 	getBounds(bounds: Bounds): void;
 
+	/**
+	 * @param {Vector3} point
+	 */
+	getChildIndex(point: Vector3): number;
+	
+	/**
+	 * @param {Vector3} point
+	 */
+	containsPoint(point: Vector3): boolean;
+	
+	/**
+	 * @param {Vector3} point
+	 */
+	containsPointByData(point: Vector3): boolean;
+
 	/**
 	 * Given a point inserted to either this node (a leaf node) or a descendant
 	 * leaf (of this node --- when this node is a non-leaf node), update the