@kitware/vtk.js 23.4.1 → 24.0.0-beta.2

package/BREAKING_CHANGES.md

@@ -1,3 +1,36 @@
+## From 23.x to 24
+
+All old-style widgets except OrientationMarkerWidget and PiecewiseGaussianWidget have been removed.
+
+| **Old-style/deprecated widget**   | **New-style widget**            |
+|-----------------------------------|---------------------------------|
+| `Sources/Interaction/Widgets/...` | `Sources/Widgets/Widgets3D/...` |
+| DistanceWidget			              | DistanceWidget                  |
+| HandleWidget				              | PolyLineWidget                  |
+| ImageCroppingRegionsWidget        | ImageCroppingWidget             |
+| LabelWidget                       | LabelWidget                     |
+| LineWidget                        | LineWidget                      |
+| OrientationMarkerWidget (kept)    | *not implemented*               |
+| PiecewiseGaussianWidget (kept)    | *not implemented*               |
+| ResliceCursor                     | ResliceCursorWidget             |
+
+- In SVGLandmarkRepresentation: `model.showCircle` is replaced by `model.circleProps.visible`
+
+## From 22.x to 23
+
+- **imagemapper**: The original behavior of the image mapper was that if a lookup table is provided,
+it mapped the lookup table's scalar range by default. The new behavior disables using the lookup
+table scalar range by default. Instead, the window/level values are used.
+
+## From 21.x to 22
+
+- `config/rules-linter.js` is now gone.
+- **AbstractMapper**: Changed removeClippingPlane to use instance instead of index.
+
+## From 20.x to 21
+
+SplineWidget's handles now scale up automatically.
+
 ## From 19.x to 20
 
 In ShapeWidget: 

package/Common/Core/DataArray.js

@@ -337,6 +337,10 @@ function vtkDataArray(publicAPI, model) {
 
 
   publicAPI.getState = function () {
+    if (model.deleted) {
+      return null;
+    }
+
     var jsonArchive = _objectSpread(_objectSpread({}, model), {}, {
       vtkClass: publicAPI.getClassName()
     }); // Convert typed array to regular array

package/Common/Core/Math/index.js

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

package/Common/Core/Math.js

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

package/Common/DataModel/DataSetAttributes/FieldData.js

@@ -242,11 +242,15 @@ function vtkFieldData(publicAPI, model) {
 
   publicAPI.getState = function () {
     var result = superGetState();
-    result.arrays = model.arrays.map(function (item) {
-      return {
-        data: item.data.getState()
-      };
-    });
+
+    if (result) {
+      result.arrays = model.arrays.map(function (item) {
+        return {
+          data: item.data.getState()
+        };
+      });
+    }
+
     return result;
   };
 }

package/Common/DataModel/ImageData.d.ts

@@ -69,18 +69,31 @@ export interface vtkImageData extends vtkDataSet {
 	extentToBounds(ex: Extent): Bounds;
 
 	/**
-	 * The Bounds of a vtkImage are returned as pairs of world coordinates
+	 * Get image extents without translation (i.e. with origin set to [0,0,0]) and under unit spacing
+	 * (i.e. spacing = [1, 1, 1]).
+	 * This includes a padding of 0.5 pixel/voxel in each principal direction.
+	 * The padding is necessary for conventional images (textures, png, bmp)
+	 * as well as medical images and volumes, since each pixel/voxel has a pre-defined width
+	 * (based on specified spacing) including the ones on the boundary of the image.
+	 * @internal
+	 */
+	getSpatialExtent(): Extent;
+
+	/**
+	 * Returns the axis-aligned bounds of vtkImageData in world coordinates.
+	 * The axis-aligned Bounds of a vtkImage are returned as pairs of world coordinates
 	 * ```[x_min, x_max, y_min, y_max, z_min, z_max]``` these are calculated
 	 * from the Extent, Origin, and Spacing, defined
 	 * through
 	 * ```js
-	 * bounds[6] =
 	 * [
-	 *   i_min*Spacing[0] + Origin[0], i_max*Spacing[0] + Origin[0],
-	 *   j_min*Spacing[1] + Origin[1], j_max*Spacing[1] + Origin[1],
-	 *   k_min*Spacing[2] + Origin[2], k_max*Spacing[2] + Origin[2]
+	 *   (i_min - 0.5)*Spacing[0] + Origin[0], (i_max + 0.5)*Spacing[0] + Origin[0],
+	 *   (j_min - 0.5)*Spacing[1] + Origin[1], (j_max + 0.5)*Spacing[1] + Origin[1],
+	 *   (k_min - 0.5)*Spacing[2] + Origin[2], (k_max + 0.5)*Spacing[2] + Origin[2]
 	 * ];
 	 *  ```
+	 * Note that this includes a padding of 0.5 voxel spacing in each principal direction,
+	 * as well as any orientation of the image.
 	 * You can't directly set the bounds. First you need to decide how many
 	 * pixels across your image will be (i.e. what the extent should be), and
 	 * then you must find the origin and spacing that will produce the bounds
@@ -89,6 +102,8 @@ export interface vtkImageData extends vtkDataSet {
 	 * 9]` for a 10x10x10 image. Calling `setDimensions(10,10,10)` does exactly
 	 * the same thing as `setExtent(0,9,0,9,0,9)` but you should always do the
 	 * latter to be explicit about where your extent starts.
+	 * Such an image of dimensions [10, 10, 10], origin [0, 0, 0] and voxel-spacing of 1.0,
+	 * will result in bounds equal to [-0.5, 9.5, -0.5, 9.5, -0.5, 9.5].
 	 * @return {Bounds} The bounds for the mapper.
 	 */
 	getBounds(): Bounds;
@@ -217,7 +232,9 @@ export interface vtkImageData extends vtkDataSet {
 	/**
 	 * Calculate the corresponding world bounds for the given index bounds
 	 * `[i_min, i_max, j_min, j_max, k_min, k_max]`. Modifies `out` in place if
-	 * provided, or returns a new array.
+	 * provided, or returns a new array. Returned bounds are NOT padded based
+	 * on voxel spacing (see getBounds). The output is merely a bounding box
+	 * calculated considering voxels as grid points.
 	 * @param {Bounds} bin 
 	 * @param {Bounds} [bout] 
 	 */

package/Common/DataModel/ImageData.js

@@ -191,7 +191,7 @@ function vtkImageData(publicAPI, model) {
 
 
   publicAPI.getBounds = function () {
-    return publicAPI.extentToBounds(model.extent);
+    return publicAPI.extentToBounds(publicAPI.getSpatialExtent());
   };
 
   publicAPI.extentToBounds = function (ex) {
@@ -232,6 +232,13 @@ function vtkImageData(publicAPI, model) {
     }
 
     return bounds;
+  };
+
+  publicAPI.getSpatialExtent = function () {
+    var boundingBox = vtkBoundingBox.newInstance();
+    boundingBox.setBounds(model.extent);
+    boundingBox.inflate(0.5);
+    return boundingBox.getBounds();
   }; // Internal, shouldn't need to call this manually.
 
 

package/Common/DataModel/PolyData.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from '../../types';
+import { CellType, Vector3 } from '../../types';
 import vtkCellArray from '../Core/CellArray';
 import vtkPointSet, { IPointSetInitialValues } from './PointSet';
 
@@ -45,6 +45,13 @@ export interface vtkPolyData extends vtkPointSet {
 	 */
 	getCellPoints(cellId: number): object;
 
+	/**
+	 * Get the type of the cell
+	 * @param {Number} cellId The Id of the cell.
+	 * @return CellType The type of the cell.
+	 */
+	 getCellType(cellId: number): CellType;
+
 	/**
 	 * Get the cell array defining cells.
 	 */

package/Common/DataModel/PolyData.js

@@ -164,12 +164,14 @@ function vtkPolyData(publicAPI, model) {
     }
 
     model.links.buildLinks(publicAPI);
-  }; // Returns an object made of the cellType and a subarray `cellPointIds` of
-  // the cell points.
+  };
 
+  publicAPI.getCellType = function (cellId) {
+    return model.cells.getCellType(cellId);
+  };
 
   publicAPI.getCellPoints = function (cellId) {
-    var cellType = model.cells.getCellType(cellId);
+    var cellType = publicAPI.getCellType(cellId);
     var cells = null;
 
     switch (cellType) {

package/Common/DataModel/Triangle.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkCell from './Cell.js';
-import { f as distance2BetweenPoints, d as dot, m as determinant2x2 } from '../Core/Math/index.js';
+import { d as dot, j as cross, l as normalize, m as multiplyAccumulate, f as distance2BetweenPoints, o as determinant2x2 } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 
@@ -33,6 +33,220 @@ function computeNormal(v1, v2, v3, n) {
     n[1] /= length;
     n[2] /= length;
   }
+}
+
+function intersectWithTriangle(p1, q1, r1, p2, q2, r2) {
+  var tolerance = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 1e-6;
+  var coplanar = false;
+  var pt1 = [];
+  var pt2 = [];
+  var surfaceId = [];
+  var n1 = [];
+  var n2 = []; // Compute supporting plane normals.
+
+  computeNormal(p1, q1, r1, n1);
+  computeNormal(p2, q2, r2, n2);
+  var s1 = -dot(n1, p1);
+  var s2 = -dot(n2, p2); // Compute signed distances of points p1, q1, r1 from supporting
+  // plane of second triangle.
+
+  var dist1 = [dot(n2, p1) + s2, dot(n2, q1) + s2, dot(n2, r1) + s2]; // If signs of all points are the same, all the points lie on the
+  // same side of the supporting plane, and we can exit early.
+
+  if (dist1[0] * dist1[1] > tolerance && dist1[0] * dist1[2] > tolerance) {
+    // vtkDebugMacro(<<"Same side supporting plane 1!");
+    return {
+      intersect: false,
+      coplanar: coplanar,
+      pt1: pt1,
+      pt2: pt2,
+      surfaceId: surfaceId
+    };
+  } // Do the same for p2, q2, r2 and supporting plane of first
+  // triangle.
+
+
+  var dist2 = [dot(n1, p2) + s1, dot(n1, q2) + s1, dot(n1, r2) + s1]; // If signs of all points are the same, all the points lie on the
+  // same side of the supporting plane, and we can exit early.
+
+  if (dist2[0] * dist2[1] > tolerance && dist2[0] * dist2[2] > tolerance) {
+    // vtkDebugMacro(<<"Same side supporting plane 2!");
+    return {
+      intersect: false,
+      coplanar: coplanar,
+      pt1: pt1,
+      pt2: pt2,
+      surfaceId: surfaceId
+    };
+  } // Check for coplanarity of the supporting planes.
+
+
+  if (Math.abs(n1[0] - n2[0]) < 1e-9 && Math.abs(n1[1] - n2[1]) < 1e-9 && Math.abs(n1[2] - n2[2]) < 1e-9 && Math.abs(s1 - s2) < 1e-9) {
+    coplanar = true; // vtkDebugMacro(<<"Coplanar!");
+
+    return {
+      intersect: false,
+      coplanar: coplanar,
+      pt1: pt1,
+      pt2: pt2,
+      surfaceId: surfaceId
+    };
+  } // There are more efficient ways to find the intersection line (if
+  // it exists), but this is clear enough.
+
+
+  var pts1 = [p1, q1, r1];
+  var pts2 = [p2, q2, r2]; // Find line of intersection (L = p + t*v) between two planes.
+
+  var n1n2 = dot(n1, n2);
+  var a = (s1 - s2 * n1n2) / (n1n2 * n1n2 - 1.0);
+  var b = (s2 - s1 * n1n2) / (n1n2 * n1n2 - 1.0);
+  var p = [a * n1[0] + b * n2[0], a * n1[1] + b * n2[1], a * n1[2] + b * n2[2]];
+  var v = cross(n1, n2, []);
+  normalize(v);
+  var index1 = 0;
+  var index2 = 0;
+  var t1 = [];
+  var t2 = [];
+  var ts1 = 50;
+  var ts2 = 50;
+
+  for (var i = 0; i < 3; i++) {
+    var id1 = i;
+    var id2 = (i + 1) % 3; // Find t coordinate on line of intersection between two planes.
+
+    var val1 = vtkPlane.intersectWithLine(pts1[id1], pts1[id2], p2, n2);
+
+    if (val1.intersection && val1.t > 0 - tolerance && val1.t < 1 + tolerance) {
+      if (val1.t < 1 + tolerance && val1.t > 1 - tolerance) {
+        ts1 = index1;
+      }
+
+      t1[index1++] = dot(val1.x, v) - dot(p, v);
+    }
+
+    var val2 = vtkPlane.intersectWithLine(pts2[id1], pts2[id2], p1, n1);
+
+    if (val2.intersection && val2.t > 0 - tolerance && val2.t < 1 + tolerance) {
+      if (val2.t < 1 + tolerance && val2.t > 1 - tolerance) {
+        ts2 = index2;
+      }
+
+      t2[index2++] = dot(val2.x, v) - dot(p, v);
+    }
+  } // If the value of the index is greater than 2, the intersecting point
+  // actually is intersected by all three edges. In this case, set the two
+  // edges to the two edges where the intersecting point is not the end point
+
+
+  if (index1 > 2) {
+    index1--; // swap
+
+    var t12 = t1[2];
+    t1[2] = t1[ts1];
+    t1[ts1] = t12;
+  }
+
+  if (index2 > 2) {
+    index2--;
+    var t22 = t2[2];
+    t2[2] = t2[ts2];
+    t2[ts2] = t22;
+  } // Check if only one edge or all edges intersect the supporting
+  // planes intersection.
+
+
+  if (index1 !== 2 || index2 !== 2) {
+    // vtkDebugMacro(<<"Only one edge intersecting!");
+    return {
+      intersect: false,
+      coplanar: coplanar,
+      pt1: pt1,
+      pt2: pt2,
+      surfaceId: surfaceId
+    };
+  } // Check for NaNs
+
+
+  if (Number.isNaN(t1[0]) || Number.isNaN(t1[1]) || Number.isNaN(t2[0]) || Number.isNaN(t2[1])) {
+    // vtkWarningMacro(<<"NaNs!");
+    return {
+      intersect: false,
+      coplanar: coplanar,
+      pt1: pt1,
+      pt2: pt2,
+      surfaceId: surfaceId
+    };
+  }
+
+  if (t1[0] > t1[1]) {
+    // swap
+    var t11 = t1[1];
+    t1[1] = t1[0];
+    t1[0] = t11;
+  }
+
+  if (t2[0] > t2[1]) {
+    // swap
+    var t21 = t2[1];
+    t2[1] = t2[0];
+    t2[0] = t21;
+  } // Handle the different interval configuration cases.
+
+
+  var tt1;
+  var tt2;
+
+  if (t1[1] < t2[0] || t2[1] < t1[0]) {
+    // vtkDebugMacro(<<"No Overlap!");
+    return {
+      intersect: false,
+      coplanar: coplanar,
+      pt1: pt1,
+      pt2: pt2,
+      surfaceId: surfaceId
+    }; // No overlap
+  }
+
+  if (t1[0] < t2[0]) {
+    if (t1[1] < t2[1]) {
+      // First point on surface 2, second point on surface 1
+      surfaceId[0] = 2;
+      surfaceId[1] = 1;
+      tt1 = t2[0];
+      tt2 = t1[1];
+    } else {
+      // Both points belong to lines on surface 2
+      surfaceId[0] = 2;
+      surfaceId[1] = 2;
+      tt1 = t2[0];
+      tt2 = t2[1];
+    }
+  } // t1[0] >= t2[0]
+  else if (t1[1] < t2[1]) {
+    // Both points belong to lines on surface 1
+    surfaceId[0] = 1;
+    surfaceId[1] = 1;
+    tt1 = t1[0];
+    tt2 = t1[1];
+  } else {
+    // First point on surface 1, second point on surface 2
+    surfaceId[0] = 1;
+    surfaceId[1] = 2;
+    tt1 = t1[0];
+    tt2 = t2[1];
+  } // Create actual intersection points.
+
+
+  multiplyAccumulate(p, v, tt1, pt1);
+  multiplyAccumulate(p, v, tt2, pt2);
+  return {
+    intersect: true,
+    coplanar: coplanar,
+    pt1: pt1,
+    pt2: pt2,
+    surfaceId: surfaceId
+  };
 } // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
@@ -40,7 +254,8 @@ function computeNormal(v1, v2, v3, n) {
 
 var STATIC = {
   computeNormalDirection: computeNormalDirection,
-  computeNormal: computeNormal
+  computeNormal: computeNormal,
+  intersectWithTriangle: intersectWithTriangle
 }; // ----------------------------------------------------------------------------
 // vtkTriangle methods
 // ----------------------------------------------------------------------------

package/Common/Transform/LandmarkTransform.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { mat4, mat3 } from 'gl-matrix';
 import Constants from './LandmarkTransform/Constants.js';
 import macro from '../../macros.js';
-import { o as jacobiN, p as perpendiculars } from '../Core/Math/index.js';
+import { p as jacobiN, q as perpendiculars } from '../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/Filters/General/OBBTree/OBBNode.js

@@ -0,0 +1,82 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../../macros.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; }
+
+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; }
+// vtkOBBNode methods
+// ----------------------------------------------------------------------------
+
+function vtkOBBNode(publicAPI, model) {
+  // Set our classname
+  model.classHierarchy.push('vtkOBBNode');
+  /**
+   * Copy a vtkOBBNode into an other one
+   * @param {vtkOBBNode} nodeSource
+   * @param {vtkOBBNode} nodeTarget
+   */
+
+  publicAPI.deepCopy = function (nodeSource) {
+    publicAPI.setCorner(nodeSource.getCorner());
+    var axes = nodeSource.getAxes();
+    publicAPI.setAxes([_toConsumableArray(axes[0]), _toConsumableArray(axes[1]), _toConsumableArray(axes[2])]);
+    publicAPI.setCells(_toConsumableArray(nodeSource.getCells()));
+
+    if (nodeSource.getKids()) {
+      var kids0 = vtkOBBNode.newInstance();
+      kids0.setParent(publicAPI);
+      var kids1 = vtkOBBNode.newInstance();
+      kids1.setParent(publicAPI);
+      kids0.deepCopy(nodeSource.getKids()[0]);
+      kids1.deepCopy(nodeSource.getKids()[1], kids1);
+      publicAPI.setKids(kids0, kids1);
+    }
+  };
+
+  publicAPI.getAxis = function (axis) {
+    return model.axes[axis];
+  };
+} // ----------------------------------------------------------------------------
+
+
+function defaultValues(initialValues) {
+  return _objectSpread({
+    corner: [0, 0, 0],
+    // center point of this node
+    axes: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
+    // the axes defining the OBB - ordered from long->short
+    cells: []
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
+  model.corner = [0, 0, 0];
+  model.axes = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+  model.parent = null; // parent node; null if root
+
+  model.kids = null; // two children of this node; nullptr if leaf
+
+  model.cells = []; // list of cells in node
+  // Build VTK API
+
+  macro.setGet(publicAPI, model, ['parent', 'cells', 'kids']); // macro.setGetArray(publicAPI, model, ['kids'], 2);
+
+  macro.setGetArray(publicAPI, model, ['corner', 'axes'], 3); // Make this a VTK object
+
+  macro.obj(publicAPI, model); // Object specific methods
+
+  vtkOBBNode(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkOBBNode'); // ----------------------------------------------------------------------------
+
+var vtkOBBNode$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkOBBNode$1 as default, extend, newInstance };

package/Filters/General/OBBTree/helper.js

@@ -0,0 +1,92 @@
+import { CellType } from '../../../Common/DataModel/CellTypes/Constants.js';
+import vtkOBJReader from '../../../IO/Misc/OBJReader.js';
+
+/**
+ * Get the correct point ID from a cell id
+ * @param {Array} cellPtsIds
+ * @param {CellType} type
+ * @param {Number} idx
+ * @returns {Object} Contains three point's id of cells as 'ptId0', 'ptId1', 'ptId2'
+ */
+
+function getCellTriangles(cellPtsIds, type, idx) {
+  var ptId0 = -1;
+  var ptId1 = -1;
+  var ptId2 = -1;
+  var cellListLength = cellPtsIds.length;
+
+  switch (type) {
+    case CellType.VTK_TRIANGLE:
+    case CellType.VTK_POLYGON:
+    case CellType.VTK_QUAD:
+      {
+        if (idx > cellListLength) break;
+        ptId0 = cellPtsIds[0];
+        ptId1 = cellPtsIds[idx + 1];
+        ptId2 = cellPtsIds[idx + 2];
+        break;
+      }
+
+    case CellType.VTK_TRIANGLE_STRIP:
+      {
+        // eslint-disable-next-line no-bitwise
+        var idx1 = idx + 1 + (idx & 1); // eslint-disable-next-line no-bitwise
+
+        var idx2 = idx + 2 - (idx & 1);
+        if (idx1 > cellListLength || idx2 > cellListLength) break;
+        ptId0 = cellPtsIds[idx];
+        ptId1 = cellPtsIds[idx1];
+        ptId2 = cellPtsIds[idx2];
+        break;
+      }
+
+    default:
+      ptId0 = -1;
+      ptId1 = -1;
+      ptId2 = -1;
+      break;
+  }
+
+  return {
+    ptId0: ptId0,
+    ptId1: ptId1,
+    ptId2: ptId2
+  };
+}
+/**
+ * Concatenate second typed array to the first typed array.
+ * @param {TypedArray} first
+ * @param {TypedArray} second Must be of the same type as first
+ * @return {TypedArray}
+ */
+
+function pushArray(first, second) {
+  var firstLength = first.length;
+  var result = new first.constructor(firstLength + second.length);
+  result.set(first);
+  result.set(second, firstLength);
+  return result;
+}
+/**
+ * Load an obj with point's colors
+ *
+ * @param {string} url path to the OBJ file
+ * @return Promise
+ * ---> success : Return vtkPolyData
+ * ---> failed : Error message
+ */
+
+function loadOBJ(url) {
+  return new Promise(function (resolve, reject) {
+    var reader = vtkOBJReader.newInstance();
+    reader.setUrl(url).then(function () {
+      var data = reader.getOutputData();
+      resolve(data);
+    }, function () {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      reject('Error when loading ', url);
+    });
+  });
+}
+
+export { getCellTriangles, loadOBJ, pushArray };