@kitware/vtk.js 23.4.2 → 24.0.0-beta.1

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 };