@kitware/vtk.js 28.10.2 → 28.11.0

package/Common/DataModel/Polygon.js

@@ -1,6 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { d as dot, s as subtract, j as cross, k as add, l as normalize, e as distance2BetweenPoints, n as norm } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
@@ -9,70 +7,66 @@ import vtkBoundingBox from './BoundingBox.js';
 import { IntersectionState } from './Line/Constants.js';
 import { PolygonWithPointIntersectionState, FLOAT_EPSILON, TOLERANCE, EPSILON } from './Polygon/Constants.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; }
+// ----------------------------------------------------------------------------
 // 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.
-
+  }
 
+  //  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
+  }
+
+  // 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 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]));
+  let 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;) {
+  const p0 = [];
+  const p1 = [];
+  for (let 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;
+    }
 
+    // Check coincidence to polygon edges
+    const {
+      distance,
+      t
+    } = vtkLine.distanceToLine(point, p0, p1);
     if (distance <= tol2 && t > 0.0 && t < 1.0) {
       return PolygonWithPointIntersectionState.INSIDE;
     }
-  } // If here, begin computation of the winding number. This method works for
+  }
+
+  // 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;
-
+  let axis0;
+  let axis1;
   if (Math.abs(normal[0]) > Math.abs(normal[1])) {
     if (Math.abs(normal[0]) > Math.abs(normal[2])) {
       axis0 = 1;
@@ -87,29 +81,26 @@ function pointInPolygon(point, vertices, bounds, normal) {
   } else {
     axis0 = 0;
     axis1 = 1;
-  } // Compute the winding number wn. If after processing all polygon edges
+  }
+
+  // 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];
+  let wn = 0;
+  for (let 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
@@ -126,12 +117,12 @@ function pointInPolygon(point, vertices, bounds, normal) {
       }
     }
   } // Over all polygon edges
-  // A winding number == 0 is outside the polygon
-
 
+  // 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.
@@ -141,11 +132,9 @@ function pointInPolygon(point, vertices, bounds, normal) {
  * @param {vtkPoints} points
  * @param {Bound} bounds
  */
-
-
 function getBounds(poly, points, bounds) {
-  var n = poly.length;
-  var p = [];
+  const n = poly.length;
+  const p = [];
   points.getPoint(poly[0], p);
   bounds[0] = p[0];
   bounds[1] = p[0];
@@ -153,16 +142,15 @@ function getBounds(poly, points, bounds) {
   bounds[3] = p[1];
   bounds[4] = p[2];
   bounds[5] = p[2];
-
-  for (var j = 1; j < n; j++) {
+  for (let j = 1; j < n; j++) {
     points.getPoint(poly[j], p);
-    vtkBoundingBox.addPoint.apply(vtkBoundingBox, [bounds].concat(p));
+    vtkBoundingBox.addPoint(bounds, ...p);
   }
-
-  var length = vtkBoundingBox.getLengths(bounds);
+  const length = vtkBoundingBox.getLengths(bounds);
   return dot(length, length);
-} // ---------------------------------------------------
+}
 
+// ---------------------------------------------------
 /**
  * Compute the normal of a polygon and return its norm.
  *
@@ -175,138 +163,119 @@ function getBounds(poly, points, bounds) {
  * @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 = [];
+  const p0 = [];
+  let p1 = [];
+  let p2 = [];
+  const v1 = [];
+  const v2 = [];
   points.getPoint(poly[0], p0);
   points.getPoint(poly[1], p1);
-
-  for (var j = 2; j < poly.length; j++) {
+  for (let j = 2; j < poly.length; j++) {
     points.getPoint(poly[j], p2);
     subtract(p2, p1, v1);
     subtract(p0, p1, v2);
-    var n = [0, 0, 0];
+    const n = [0, 0, 0];
     cross(v1, v2, n);
     add(normal, n, normal);
-    var _ref = [p2, p1];
-    p1 = _ref[0];
-    p2 = _ref[1];
+    [p1, p2] = [p2, p1];
   }
-
   return normalize(normal);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
-var STATIC = {
-  PolygonWithPointIntersectionState: PolygonWithPointIntersectionState,
-  pointInPolygon: pointInPolygon,
-  getBounds: getBounds,
-  getNormal: getNormal
-}; // ----------------------------------------------------------------------------
+const STATIC = {
+  PolygonWithPointIntersectionState,
+  pointInPolygon,
+  getBounds,
+  getNormal
+};
+
+// ----------------------------------------------------------------------------
 // vtkPolygon methods
 // ----------------------------------------------------------------------------
 
 function vtkPolygon(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkPolygon');
-
   function computeNormal() {
-    var v1 = [0, 0, 0];
-    var v2 = [0, 0, 0];
+    const v1 = [0, 0, 0];
+    const v2 = [0, 0, 0];
     model.normal = [0, 0, 0];
-
-    var anchor = _toConsumableArray(model.firstPoint.point);
-
-    var point = model.firstPoint;
-
-    for (var i = 0; i < model.pointCount; i++) {
+    const anchor = [...model.firstPoint.point];
+    let point = model.firstPoint;
+    for (let i = 0; i < model.pointCount; i++) {
       subtract(point.point, anchor, v1);
       subtract(point.next.point, anchor, v2);
-      var n = [0, 0, 0];
+      const n = [0, 0, 0];
       cross(v1, v2, n);
       add(model.normal, n, model.normal);
       point = point.next;
     }
-
     return normalize(model.normal);
   }
-
   function computeMeasure(point) {
-    var v1 = [0, 0, 0];
-    var v2 = [0, 0, 0];
-    var v3 = [0, 0, 0];
-    var v4 = [0, 0, 0];
+    const v1 = [0, 0, 0];
+    const v2 = [0, 0, 0];
+    const v3 = [0, 0, 0];
+    const v4 = [0, 0, 0];
     subtract(point.point, point.previous.point, v1);
     subtract(point.next.point, point.point, v2);
     subtract(point.previous.point, point.next.point, v3);
     cross(v1, v2, v4);
-    var area = dot(v4, model.normal);
-
+    const area = dot(v4, model.normal);
     if (area <= 0) {
       return -1;
     }
-
-    var perimeter = norm(v1) + norm(v2) + norm(v3);
+    const perimeter = norm(v1) + norm(v2) + norm(v3);
     return perimeter * perimeter / area;
   }
-
   function canRemoveVertex(point) {
     if (model.pointCount <= 3) {
       return true;
     }
-
-    var previous = point.previous;
-    var next = point.next;
-    var v = [0, 0, 0];
+    const previous = point.previous;
+    const next = point.next;
+    const v = [0, 0, 0];
     subtract(next.point, previous.point, v);
-    var sN = [0, 0, 0];
+    const sN = [0, 0, 0];
     cross(v, model.normal, sN);
     normalize(sN);
-
     if (norm(sN) === 0) {
       return false;
     }
-
-    var val = vtkPlane.evaluate(sN, previous.point, next.next.point); // eslint-disable-next-line no-nested-ternary
-
-    var currentSign = val > EPSILON ? 1 : val < -EPSILON ? -1 : 0;
-    var oneNegative = currentSign < 0 ? 1 : 0;
-
-    for (var vertex = next.next.next; vertex.id !== previous.id; vertex = vertex.next) {
-      var previousVertex = vertex.previous;
-      val = vtkPlane.evaluate(sN, previous.point, vertex.point); // eslint-disable-next-line no-nested-ternary
-
-      var sign = val > EPSILON ? 1 : val < -EPSILON ? -1 : 0;
-
+    let val = vtkPlane.evaluate(sN, previous.point, next.next.point);
+    // eslint-disable-next-line no-nested-ternary
+    let currentSign = val > EPSILON ? 1 : val < -EPSILON ? -1 : 0;
+    let oneNegative = currentSign < 0 ? 1 : 0;
+    for (let vertex = next.next.next; vertex.id !== previous.id; vertex = vertex.next) {
+      const previousVertex = vertex.previous;
+      val = vtkPlane.evaluate(sN, previous.point, vertex.point);
+      // eslint-disable-next-line no-nested-ternary
+      const sign = val > EPSILON ? 1 : val < -EPSILON ? -1 : 0;
       if (sign !== currentSign) {
         if (!oneNegative) {
           oneNegative = sign <= 0 ? 1 : 0;
         }
-
         if (vtkLine.intersection(previous.point, next.point, vertex.point, previousVertex.point, [0], [0]) === IntersectionState.YES_INTERSECTION) {
           return false;
         }
-
         currentSign = sign;
       }
     }
-
     return oneNegative === 1;
   }
-
   function removePoint(point, queue) {
     model.pointCount -= 1;
-    var previous = point.previous;
-    var next = point.next;
+    const previous = point.previous;
+    const next = point.next;
     model.tris = model.tris.concat(point.point);
     model.tris = model.tris.concat(next.point);
     model.tris = model.tris.concat(previous.point);
@@ -314,65 +283,51 @@ function vtkPolygon(publicAPI, model) {
     next.previous = previous;
     queue.deleteById(previous.id);
     queue.deleteById(next.id);
-    var previousMeasure = computeMeasure(previous);
-
+    const previousMeasure = computeMeasure(previous);
     if (previousMeasure > 0) {
       queue.push(previousMeasure, previous);
     }
-
-    var nextMeasure = computeMeasure(next);
-
+    const nextMeasure = computeMeasure(next);
     if (nextMeasure > 0) {
       queue.push(nextMeasure, next);
     }
-
     if (point.id === model.firstPoint.id) {
       model.firstPoint = next;
     }
   }
-
   function earCutTriangulation() {
     computeNormal();
-    var vertexQueue = vtkPriorityQueue.newInstance();
-    var point = model.firstPoint;
-
-    for (var i = 0; i < model.pointCount; i++) {
-      var measure = computeMeasure(point);
-
+    const vertexQueue = vtkPriorityQueue.newInstance();
+    let point = model.firstPoint;
+    for (let i = 0; i < model.pointCount; i++) {
+      const measure = computeMeasure(point);
       if (measure > 0) {
         vertexQueue.push(measure, point);
       }
-
       point = point.next;
     }
-
     while (model.pointCount > 2 && vertexQueue.length() > 0) {
       if (model.pointCount === vertexQueue.length()) {
         // convex
-        var pointToRemove = vertexQueue.pop();
+        const pointToRemove = vertexQueue.pop();
         removePoint(pointToRemove, vertexQueue);
       } else {
         // concave
-        var _pointToRemove = vertexQueue.pop();
-
-        if (canRemoveVertex(_pointToRemove)) {
-          removePoint(_pointToRemove, vertexQueue);
+        const pointToRemove = vertexQueue.pop();
+        if (canRemoveVertex(pointToRemove)) {
+          removePoint(pointToRemove, vertexQueue);
         }
       }
     }
-
     return model.pointCount <= 2;
   }
-
-  publicAPI.triangulate = function () {
+  publicAPI.triangulate = () => {
     if (!model.firstPoint) {
       return null;
     }
-
     return earCutTriangulation();
   };
-
-  publicAPI.setPoints = function (points) {
+  publicAPI.setPoints = points => {
     model.pointCount = points.length;
     model.firstPoint = {
       id: 0,
@@ -380,9 +335,8 @@ function vtkPolygon(publicAPI, model) {
       next: null,
       previous: null
     };
-    var currentPoint = model.firstPoint;
-
-    for (var i = 1; i < model.pointCount; i++) {
+    let currentPoint = model.firstPoint;
+    for (let i = 1; i < model.pointCount; i++) {
       currentPoint.next = {
         id: i,
         point: points[i],
@@ -391,38 +345,43 @@ function vtkPolygon(publicAPI, model) {
       };
       currentPoint = currentPoint.next;
     }
-
     model.firstPoint.previous = currentPoint;
     currentPoint.next = model.firstPoint;
   };
+  publicAPI.getPointArray = () => model.tris;
+}
 
-  publicAPI.getPointArray = function () {
-    return model.tris;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   firstPoint: null,
   pointCount: 0,
   tris: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   vtkPolygon(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkPolygon'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkPolygon');
+
+// ----------------------------------------------------------------------------
 
-var vtkPolygon$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+var vtkPolygon$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { vtkPolygon$1 as default, extend, getBounds, getNormal, newInstance };

package/Common/DataModel/Quad/Constants.js

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