@kitware/vtk.js 25.4.0 → 25.7.0

package/Common/DataModel/Polygon.js

@@ -1,15 +1,219 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
-import { l as normalize, s as subtract, j as cross, k as add, d as dot, n as norm } from '../Core/Math/index.js';
+import { d as dot, s as subtract, k as cross, l as add, m as normalize, f as distance2BetweenPoints, n as norm } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 import vtkPriorityQueue from '../Core/PriorityQueue.js';
+import vtkBoundingBox from './BoundingBox.js';
 import { IntersectionState } from './Line/Constants.js';
+import { PolygonWithPointIntersectionState, FLOAT_EPSILON, TOLERANCE, EPSILON } from './Polygon/Constants.js';
 
-// vtkPolygon methods
+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; }
+// Global methods
 // ----------------------------------------------------------------------------
+// Given the line (p0,p1), determine if the given point is located to the left
+// of, on, or to the right of a line (with the function returning >0, ==0, or
+// <0 respectively). The points are assumed 3D points, but projected into
+// one of x-y-z planes; hence the indices axis0 and axis1 specify which plane
+// the computation is to be performed on.
+
+function pointLocation(axis0, axis1, p0, p1, point) {
+  return (p1[axis0] - p0[axis0]) * (point[axis1] - p0[axis1]) - (point[axis0] - p0[axis0]) * (p1[axis1] - p0[axis1]);
+} //------------------------------------------------------------------------------
+
+
+function pointInPolygon(point, vertices, bounds, normal) {
+  // Do a quick bounds check to throw out trivial cases.
+  // winding plane.
+  if (point[0] < bounds[0] || point[0] > bounds[1] || point[1] < bounds[2] || point[1] > bounds[3] || point[2] < bounds[4] || point[2] > bounds[5]) {
+    return PolygonWithPointIntersectionState.OUTSIDE;
+  } //  Check that the normal is non-zero.
+
+
+  if (normalize(normal) <= FLOAT_EPSILON) {
+    return PolygonWithPointIntersectionState.FAILURE;
+  } // Assess whether the point lies on the boundary of the polygon. Points on
+  // the boundary are considered inside the polygon. Need to define a small
+  // tolerance relative to the bounding box diagonal length of the polygon.
+
 
-var EPSILON = 1e-6;
+  var tol2 = TOLERANCE * ((bounds[1] - bounds[0]) * (bounds[1] - bounds[0]) + (bounds[3] - bounds[2]) * (bounds[3] - bounds[2]) + (bounds[5] - bounds[4]) * (bounds[5] - bounds[4]));
+  tol2 *= tol2;
+  tol2 = tol2 === 0.0 ? FLOAT_EPSILON : tol2;
+  var p0 = [];
+  var p1 = [];
+
+  for (var i = 0; i < vertices.length;) {
+    // Check coincidence to polygon vertices
+    p0[0] = vertices[i++];
+    p0[1] = vertices[i++];
+    p0[2] = vertices[i++];
+
+    if (distance2BetweenPoints(point, p0) <= tol2) {
+      return PolygonWithPointIntersectionState.INSIDE;
+    } // Check coincidence to polygon edges
+
+
+    var _vtkLine$distanceToLi = vtkLine.distanceToLine(point, p0, p1),
+        distance = _vtkLine$distanceToLi.distance,
+        t = _vtkLine$distanceToLi.t;
+
+    if (distance <= tol2 && t > 0.0 && t < 1.0) {
+      return PolygonWithPointIntersectionState.INSIDE;
+    }
+  } // If here, begin computation of the winding number. This method works for
+  // points/polygons arbitrarily oriented in 3D space.  Hence a projection
+  // onto one of the x-y-z coordinate planes using the maximum normal
+  // component. The computation will be performed in the (axis0, axis1) plane.
+
+
+  var axis0;
+  var axis1;
+
+  if (Math.abs(normal[0]) > Math.abs(normal[1])) {
+    if (Math.abs(normal[0]) > Math.abs(normal[2])) {
+      axis0 = 1;
+      axis1 = 2;
+    } else {
+      axis0 = 0;
+      axis1 = 1;
+    }
+  } else if (Math.abs(normal[1]) > Math.abs(normal[2])) {
+    axis0 = 0;
+    axis1 = 2;
+  } else {
+    axis0 = 0;
+    axis1 = 1;
+  } // Compute the winding number wn. If after processing all polygon edges
+  // wn == 0, then the point is outside.  Otherwise, the point is inside the
+  // polygon. Process all polygon edges determining if there are ascending or
+  // descending crossings of the line axis1=constant.
+
+
+  var wn = 0;
+
+  for (var _i = 0; _i < vertices.length;) {
+    p0[0] = vertices[_i++];
+    p0[1] = vertices[_i++];
+    p0[2] = vertices[_i++];
+
+    if (_i < vertices.length) {
+      p1[0] = vertices[_i];
+      p1[1] = vertices[_i + 1];
+      p1[2] = vertices[_i + 2];
+    } else {
+      p1[0] = vertices[0];
+      p1[1] = vertices[1];
+      p1[2] = vertices[2];
+    }
+
+    if (p0[axis1] <= point[axis1]) {
+      if (p1[axis1] > point[axis1]) {
+        // if an upward crossing
+        if (pointLocation(axis0, axis1, p0, p1, point) > 0) {
+          // if x left of edge
+          ++wn; // a valid up intersect, increment the winding number
+        }
+      }
+    } else if (p1[axis1] <= point[axis1]) {
+      // if a downward crossing
+      if (pointLocation(axis0, axis1, p0, p1, point) < 0) {
+        // if x right of edge
+        --wn; // a valid down intersect, decrement the winding number
+      }
+    }
+  } // Over all polygon edges
+  // A winding number == 0 is outside the polygon
+
+
+  return wn === 0 ? PolygonWithPointIntersectionState.OUTSIDE : PolygonWithPointIntersectionState.INSIDE;
+} // ---------------------------------------------------
+
+/**
+ * Simple utility method for computing polygon bounds.
+ * Returns the sum of the squares of the dimensions.
+ * Requires a poly with at least one point.
+ *
+ * @param {Array<Number>|TypedArray<Number>} poly
+ * @param {vtkPoints} points
+ * @param {Bound} bounds
+ */
+
+
+function getBounds(poly, points, bounds) {
+  var n = poly.length;
+  var p = [];
+  points.getPoint(poly[0], p);
+  bounds[0] = p[0];
+  bounds[1] = p[0];
+  bounds[2] = p[1];
+  bounds[3] = p[1];
+  bounds[4] = p[2];
+  bounds[5] = p[2];
+
+  for (var j = 1; j < n; j++) {
+    points.getPoint(poly[j], p);
+    vtkBoundingBox.addPoint(bounds, p);
+  }
+
+  var length = vtkBoundingBox.getLength(bounds);
+  return dot(length, length);
+} // ---------------------------------------------------
+
+/**
+ * Compute the normal of a polygon and return its norm.
+ *
+ * TBD: This does the same thing as vtkPolygon.computeNormal,
+ * but in a more generic way. Maybe we can keep the public
+ * static method somehow and have the private method use it instead.
+ *
+ * @param {Array<Number>|TypedArray<Number>} poly
+ * @param {vtkPoints} points
+ * @param {Vector3} normal
+ * @returns {Number}
+ */
+
+function getNormal(poly, points, normal) {
+  normal.length = 3;
+  normal[0] = 0.0;
+  normal[1] = 0.0;
+  normal[2] = 0.0;
+  var p0 = [];
+  var p1 = [];
+  var p2 = [];
+  var v1 = [];
+  var v2 = [];
+  points.getPoint(poly[0], p0);
+  points.getPoint(poly[1], p1);
+
+  for (var j = 2; j < poly.length; j++) {
+    points.getPoint(poly[j], p2);
+    subtract(p2, p1, v1);
+    subtract(p0, p1, v2);
+    var n = [0, 0, 0];
+    cross(v1, v2, n);
+    add(normal, n, normal);
+    var _ref = [p2, p1];
+    p1 = _ref[0];
+    p2 = _ref[1];
+  }
+
+  return normalize(normal);
+} // ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+var STATIC = {
+  PolygonWithPointIntersectionState: PolygonWithPointIntersectionState,
+  pointInPolygon: pointInPolygon,
+  getBounds: getBounds,
+  getNormal: getNormal
+}; // ----------------------------------------------------------------------------
+// vtkPolygon methods
+// ----------------------------------------------------------------------------
 
 function vtkPolygon(publicAPI, model) {
   // Set our classname
@@ -216,9 +420,9 @@ function extend(publicAPI, model) {
 
 var newInstance = macro.newInstance(extend, 'vtkPolygon'); // ----------------------------------------------------------------------------
 
-var vtkPolygon$1 = {
+var vtkPolygon$1 = _objectSpread({
   newInstance: newInstance,
   extend: extend
-};
+}, STATIC);
 
-export { vtkPolygon$1 as default, extend, newInstance };
+export { vtkPolygon$1 as default, extend, getBounds, getNormal, newInstance };

package/Common/DataModel/Quad/Constants.js

@@ -0,0 +1,9 @@
+var QuadWithLineIntersectionState = {
+  NO_INTERSECTION: 0,
+  YES_INTERSECTION: 1
+};
+var Constants = {
+  QuadWithLineIntersectionState: QuadWithLineIntersectionState
+};
+
+export { QuadWithLineIntersectionState, Constants as default };

package/Common/DataModel/Quad.d.ts

@@ -0,0 +1,91 @@
+import { Vector3, Vector4 } from './../../types';
+import vtkCell, { ICellInitialValues } from './Cell';
+import { IIntersectWithLine } from './Triangle';
+
+export interface IQuadInitialValues extends ICellInitialValues {}
+
+export interface vtkQuad extends vtkCell {
+  getCellType(): number;
+  /**
+   * Get the topological dimensional of the cell (0, 1, 2 or 3).
+   */
+  getCellDimension(): number;
+  getNumberOfEdges(): number;
+  getNumberOfFaces(): number;
+
+  /**
+   * Compute the intersection point of the intersection between quad and
+   * line defined by p1 and p2. tol Tolerance use for the position evaluation
+   * x is the point which intersect triangle (computed in function) pcoords
+   * parametric coordinates (computed in function) A javascript object is
+   * returned :
+   *
+   * ```js
+   * {
+   *    evaluation: define if the triangle has been intersected or not
+   *    subId: always set to 0
+   *    t: parametric coordinate along the line.
+   *    betweenPoints: Define if the intersection is between input points
+   * }
+   * ```
+   *
+   * @param {Vector3} p1 The first point coordinate.
+   * @param {Vector3} p2 The second point coordinate.
+   * @param {Number} tol The tolerance to use.
+   * @param {Vector3} x The point which intersect triangle.
+   * @param {Vector3} pcoords The parametric coordinates.
+   */
+  intersectWithLine(
+    p1: Vector3,
+    p2: Vector3,
+    tol: number,
+    x: Vector3,
+    pcoords: Vector3
+  ): IIntersectWithLine;
+
+  /**
+   * Determine global coordinate (x]) from subId and parametric coordinates.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector3} x The x point coordinate.
+   * @param {Number[]} weights The number of weights.
+   */
+  evaluateLocation(pcoords: Vector3, x: Vector3, weights: number[]): void;
+
+  /*
+   *  Compute iso-parametric interpolation functions
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector4} sf out weights.
+   */
+  interpolationFunctions(pcoords: Vector3, sf: Vector4);
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkQuad characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IQuadInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IQuadInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkQuad.
+ * @param {IQuadInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IQuadInitialValues): vtkQuad;
+
+/**
+ * vtkQuad is a cell which represents a quadrilateral. It may contain static
+ * methods to make some computations directly link to quads.
+ *
+ * @see vtkCell
+ */
+export declare const vtkQuad: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkQuad;

package/Common/DataModel/Quad.js

@@ -0,0 +1,235 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../macros.js';
+import vtkCell from './Cell.js';
+import { f as distance2BetweenPoints } from '../Core/Math/index.js';
+import { CellType } from './CellTypes/Constants.js';
+import vtkTriangle from './Triangle.js';
+import vtkPoints from '../Core/Points.js';
+
+function intersectionStruct() {
+  return {
+    intersected: false,
+    subId: -1,
+    x: [0.0, 0.0, 0.0],
+    pCoords: [0.0, 0.0, 0.0],
+    t: -1
+  };
+}
+
+function vtkQuad(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkQuad');
+
+  publicAPI.getCellDimension = function () {
+    return 2;
+  };
+
+  publicAPI.getCellType = function () {
+    return CellType.VTK_QUAD;
+  };
+
+  publicAPI.getNumberOfEdges = function () {
+    return 4;
+  };
+
+  publicAPI.getNumberOfFaces = function () {
+    return 0;
+  };
+
+  publicAPI.intersectWithLine = function (p1, p2, tol, x, pcoords) {
+    var _points, _points2, _points3, _points4, _points5, _points6, _points7, _points8, _points9, _points10, _points11, _points12;
+
+    var outObj = {
+      subId: 0,
+      t: Number.MAX_VALUE,
+      intersect: 0,
+      betweenPoints: false
+    };
+    var diagonalCase;
+    var point0 = model.points.getPoint(0, []);
+    var point1 = model.points.getPoint(1, []);
+    var point2 = model.points.getPoint(2, []);
+    var point3 = model.points.getPoint(3, []);
+    var d1 = distance2BetweenPoints(point0, point2);
+    var d2 = distance2BetweenPoints(point1, point3);
+    /* Figure out how to uniquely tessellate the quad. Watch out for
+     * equivalent triangulations (i.e., the triangulation is equivalent
+     * no matter where the diagonal). In this case use the point ids as
+     * a tie breaker to ensure unique triangulation across the quad.
+     */
+    // rare case; discriminate based on point id
+
+    if (d1 === d2) {
+      // find the maximum id
+      var id;
+      var maxId = 0;
+      var maxIdx = 0;
+
+      for (var i = 0; i < 4; i++) {
+        id = model.pointsIds[i];
+
+        if (id > maxId) {
+          maxId = id;
+          maxIdx = i;
+        }
+      }
+
+      if (maxIdx === 0 || maxIdx === 2) {
+        diagonalCase = 0;
+      } else {
+        diagonalCase = 1;
+      }
+    } else if (d1 < d2) {
+      diagonalCase = 0;
+    } else {
+      diagonalCase = 1;
+    }
+
+    var points = null;
+
+    if (!model.triangle) {
+      model.triangle = vtkTriangle.newInstance();
+      points = vtkPoints.newInstance();
+      points.setNumberOfPoints(3);
+      model.triangle.initialize(points);
+    } else {
+      points = model.triangle.getPoints();
+    }
+
+    var firstIntersect;
+    var firstIntersectTmpObj = intersectionStruct();
+    var secondIntersect;
+    var secondIntersectTmpObj = intersectionStruct();
+    var useFirstIntersection;
+    var useSecondIntersection;
+
+    switch (diagonalCase) {
+      case 0:
+        (_points = points).setPoint.apply(_points, [0].concat(_toConsumableArray(point0)));
+
+        (_points2 = points).setPoint.apply(_points2, [1].concat(_toConsumableArray(point1)));
+
+        (_points3 = points).setPoint.apply(_points3, [2].concat(_toConsumableArray(point2)));
+
+        firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
+
+        (_points4 = points).setPoint.apply(_points4, [0].concat(_toConsumableArray(point2)));
+
+        (_points5 = points).setPoint.apply(_points5, [1].concat(_toConsumableArray(point3)));
+
+        (_points6 = points).setPoint.apply(_points6, [2].concat(_toConsumableArray(point0)));
+
+        secondIntersect = model.triangle.intersectWithLine(p1, p2, tol, secondIntersectTmpObj.x, secondIntersectTmpObj.pCoords);
+        useFirstIntersection = firstIntersect.intersect && secondIntersect.intersect ? firstIntersect.t <= secondIntersect.t : firstIntersect.intersect;
+        useSecondIntersection = firstIntersect.intersect && secondIntersect.intersect ? secondIntersect.t < firstIntersect.t : secondIntersect.intersect;
+
+        if (useFirstIntersection) {
+          outObj = firstIntersect;
+          x[0] = firstIntersectTmpObj.x[0];
+          x[1] = firstIntersectTmpObj.x[1];
+          x[2] = firstIntersectTmpObj.x[2];
+          pcoords[0] = firstIntersectTmpObj.pCoords[0] + firstIntersectTmpObj.pCoords[1];
+          pcoords[1] = firstIntersectTmpObj.pCoords[1];
+          pcoords[2] = firstIntersectTmpObj.pCoords[2];
+        } else if (useSecondIntersection) {
+          outObj = secondIntersect;
+          x[0] = secondIntersectTmpObj.x[0];
+          x[1] = secondIntersectTmpObj.x[1];
+          x[2] = secondIntersectTmpObj.x[2];
+          pcoords[0] = 1.0 - (secondIntersectTmpObj.pCoords[0] + secondIntersectTmpObj.pCoords[1]);
+          pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
+          pcoords[2] = secondIntersectTmpObj.pCoords[2];
+        }
+
+        break;
+
+      case 1:
+        (_points7 = points).setPoint.apply(_points7, [0].concat(_toConsumableArray(point0)));
+
+        (_points8 = points).setPoint.apply(_points8, [1].concat(_toConsumableArray(point1)));
+
+        (_points9 = points).setPoint.apply(_points9, [2].concat(_toConsumableArray(point3)));
+
+        firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
+
+        (_points10 = points).setPoint.apply(_points10, [0].concat(_toConsumableArray(point2)));
+
+        (_points11 = points).setPoint.apply(_points11, [1].concat(_toConsumableArray(point3)));
+
+        (_points12 = points).setPoint.apply(_points12, [2].concat(_toConsumableArray(point1)));
+
+        secondIntersect = model.triangle.intersectWithLine(p1, p2, tol, secondIntersectTmpObj.x, secondIntersectTmpObj.pCoords);
+        useFirstIntersection = firstIntersect.intersect && secondIntersect.intersect ? firstIntersect.t <= secondIntersect.t : firstIntersect.intersect;
+        useSecondIntersection = firstIntersect.intersect && secondIntersect.intersect ? secondIntersect.t < firstIntersect.t : secondIntersect.intersect;
+
+        if (useFirstIntersection) {
+          outObj = firstIntersect;
+          x[0] = firstIntersectTmpObj.x[0];
+          x[1] = firstIntersectTmpObj.x[1];
+          x[2] = firstIntersectTmpObj.x[2];
+          pcoords[0] = firstIntersectTmpObj.pCoords[0];
+          pcoords[1] = firstIntersectTmpObj.pCoords[1];
+          pcoords[2] = firstIntersectTmpObj.pCoords[2];
+        } else if (useSecondIntersection) {
+          outObj = secondIntersect;
+          x[0] = secondIntersectTmpObj.x[0];
+          x[1] = secondIntersectTmpObj.x[1];
+          x[2] = secondIntersectTmpObj.x[2];
+          pcoords[0] = 1 - secondIntersectTmpObj.pCoords[0];
+          pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
+          pcoords[2] = secondIntersectTmpObj.pCoords[2];
+        }
+
+        break;
+    }
+
+    return outObj;
+  };
+
+  publicAPI.interpolationFunctions = function (pcoords, weights) {
+    var rm = 1 - pcoords[0];
+    var sm = 1 - pcoords[1];
+    weights[0] = rm * sm;
+    weights[1] = pcoords[0] * sm;
+    weights[2] = pcoords[0] * pcoords[1];
+    weights[3] = rm * pcoords[1];
+  };
+
+  publicAPI.evaluateLocation = function (pcoords, x, weights) {
+    var point = []; // Calculate the weights
+
+    publicAPI.interpolationFunctions(pcoords, weights);
+    x[0] = 0.0;
+    x[1] = 0.0;
+    x[2] = 0.0;
+
+    for (var i = 0; i < 4; i++) {
+      model.points.getPoint(i, point);
+
+      for (var j = 0; j < 3; j++) {
+        x[j] += point[j] * weights[i];
+      }
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkCell.extend(publicAPI, model, initialValues);
+  vtkQuad(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkQuad'); // ----------------------------------------------------------------------------
+
+var vtkQuad$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkQuad$1 as default, extend, newInstance };