@kitware/vtk.js 23.4.2 → 23.4.4

package/Common/DataModel/IncrementalOctreePointLocator.js

@@ -0,0 +1,398 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import macro from '../../macros.js';
+import { f as vtkMath } from '../Core/Math/index.js';
+import vtkBoundingBox from './BoundingBox.js';
+import vtkIncrementalOctreeNode from './IncrementalOctreeNode.js';
+import vtkAbstractPointLocator from './AbstractPointLocator.js';
+import { VtkDataTypes } from '../Core/DataArray/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; }
+var vtkErrorMacro = macro.vtkErrorMacro;
+
+function vtkIncrementalOctreePointLocator(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkIncrementalOctreePointLocator');
+
+  function getLeafContainer(node, pnt) {
+    return node.isLeaf() ? node : getLeafContainer(node.getChild(node.getChildIndex(pnt)), pnt);
+  } //------------------------------------------------------------------------------
+
+
+  publicAPI.freeSearchStructure = function () {
+    model.octreeRootNode = null;
+    model.numberOfNodes = 0;
+    model.locatorPoints = null;
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.findClosestPointInLeafNode = function (leafNode, point) {
+    // NOTE: dist2 MUST be initiated with a very huge value below, but instead of
+    // model.octreeMaxDimSize * model.octreeMaxDimSize * 4.0, because the point
+    // under check may be outside the octree and hence the squared distance can
+    // be greater than the latter or other similar octree-based specific values.
+    var dist2 = Number.MAX_VALUE;
+
+    if (leafNode.getPointIdSet() == null) {
+      return [-1, dist2];
+    }
+
+    var numPts = 0;
+    var tmpDst = 0.0;
+    var tmpPnt = [];
+    var tmpIdx = -1;
+    var pntIdx = -1;
+    var idList = leafNode.getPointIdSet();
+    numPts = idList.length;
+
+    for (var i = 0; i < numPts; i++) {
+      tmpIdx = idList[i];
+      model.locatorPoints.getPoint(tmpIdx, tmpPnt);
+      tmpDst = vtkMath.distance2BetweenPoints(tmpPnt, point);
+
+      if (tmpDst < dist2) {
+        dist2 = tmpDst;
+        pntIdx = tmpIdx;
+      }
+
+      if (dist2 === 0.0) {
+        break;
+      }
+    }
+
+    idList = null;
+    return [pntIdx, dist2];
+  };
+
+  publicAPI.findClosestPointInSphere = function (point, radius2, maskNode, refDist2) {
+    var pointIndx = -1;
+    var minDist2 = Number.MAX_VALUE;
+    var nodesBase = [];
+    nodesBase.push(model.octreeRootNode);
+    var checkNode;
+    var childNode;
+    var distToData;
+    var tempDist2;
+    var tempPntId;
+
+    while (!nodesBase.length === 0 && minDist2 > 0.0) {
+      checkNode = nodesBase.top();
+      nodesBase.pop();
+
+      if (!checkNode.isLeaf()) {
+        for (var i = 0; i < 8; i++) {
+          childNode = checkNode.getChild(i); // use ( radius2 + radius2 ) to skip empty nodes
+
+          distToData = childNode.getNumberOfPoints() ? childNode.getDistance2ToBoundary(point, model.octreeRootNode, 1) : radius2 + radius2; // If a child node is not the mask node AND its distance, specifically
+          // the data bounding box (determined by the points inside or under) to
+          // the point, is less than the threshold radius (one exception is the
+          // point's container nodes), it is pushed to the stack as a suspect.
+
+          if (childNode !== maskNode && (distToData <= refDist2 || childNode.containsPoint(point) === 1)) {
+            nodesBase.push(childNode);
+          }
+
+          childNode = null;
+        }
+      } else {
+        // now that the node under check is a leaf, let's find the closest
+        // point therein and the minimum distance
+        var _publicAPI$findCloses = publicAPI.findClosestPointInLeafNode(checkNode, point);
+
+        var _publicAPI$findCloses2 = _slicedToArray(_publicAPI$findCloses, 2);
+
+        tempPntId = _publicAPI$findCloses2[0];
+        tempDist2 = _publicAPI$findCloses2[1];
+
+        if (tempDist2 < minDist2) {
+          minDist2 = tempDist2;
+          pointIndx = tempPntId;
+        }
+      }
+
+      checkNode = null;
+    }
+
+    return [minDist2 <= radius2 ? pointIndx : -1, minDist2];
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.initPointInsertion = function (points, bounds) {
+    var _model$octreeRootNode;
+    var i = 0;
+    var bbIndex = 0;
+
+    if (points == null) {
+      vtkErrorMacro('a valid vtkPoints object required for point insertion');
+      return false;
+    } // destroy the existing octree, if any
+
+
+    publicAPI.freeSearchStructure();
+    model.locatorPoints = points; // obtain the threshold squared distance
+
+    model.insertTolerance2 = model.tolerance * model.tolerance; // Fix bounds
+    // (1) push out a little bit if the original volume is too flat --- a slab
+    // (2) pull back the x, y, and z's lower bounds a little bit such that
+    //     points are clearly "inside" the spatial region.  Point p is taken as
+    //     "inside" range r = [r1, r2] if and only if r1 < p <= r2.
+
+    model.octreeMaxDimSize = 0.0;
+
+    var tmpBbox = _toConsumableArray(bounds);
+
+    var dimDiff = vtkBoundingBox.getLengths(bounds);
+    model.octreeMaxDimSize = Math.max.apply(Math, _toConsumableArray(dimDiff));
+
+    if (model.buildCubicOctree) {
+      // make the bounding box a cube and hence descendant octants cubes too
+      for (i = 0; i < 3; i++) {
+        if (dimDiff[i] !== model.octreeMaxDimSize) {
+          var delta = model.octreeMaxDimSize - dimDiff[i];
+          tmpBbox[2 * i] -= 0.5 * delta;
+          tmpBbox[2 * i + 1] += 0.5 * delta;
+          dimDiff[i] = model.octreeMaxDimSize;
+        }
+      }
+    }
+
+    model.fudgeFactor = model.octreeMaxDimSize * 10e-6;
+    var minSideSize = model.octreeMaxDimSize * 10e-2;
+
+    for (i = 0; i < 3; i++) {
+      if (dimDiff[i] < minSideSize) {
+        // case (1) above
+        bbIndex = 2 * i;
+        var tempVal = tmpBbox[bbIndex];
+        tmpBbox[bbIndex] = tmpBbox[bbIndex + 1] - minSideSize;
+        tmpBbox[bbIndex + 1] = tempVal + minSideSize;
+      } else {
+        // case (2) above
+        tmpBbox[2 * i] -= model.fudgeFactor;
+      }
+    } // init the octree with an empty leaf node
+
+
+    model.octreeRootNode = vtkIncrementalOctreeNode.newInstance();
+    ++model.numberOfNodes; // this call internally inits the middle (center) and data range, too
+
+    (_model$octreeRootNode = model.octreeRootNode).setBounds.apply(_model$octreeRootNode, _toConsumableArray(tmpBbox));
+
+    return true;
+  };
+
+  publicAPI.findClosestPointInSphereWithTolerance = function (point, radius2, maskNode) {
+    return publicAPI.findClosestPointInSphere(point, radius2, maskNode, model.octreeMaxDimSize * model.octreeMaxDimSize * 4.0, radius2);
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.findDuplicateFloatTypePointInVisitedLeafNode = function (leafNode, point) {
+    var tmpPnt;
+    var tmpIdx = -1;
+    var pntIdx = -1; // float thePnt[3]; // TODO
+    // thePnt[0] = static_cast<float>(point[0]);
+    // thePnt[1] = static_cast<float>(point[1]);
+    // thePnt[2] = static_cast<float>(point[2]);
+
+    var idList = leafNode.getPointIdSet(); // float* pFloat = (static_cast<vtkFloatArray*>(model.locatorPoints.getData())).getPointer(0);
+
+    var values = model.locatorPoints.getData();
+
+    for (var i = 0; i < idList.length; i++) {
+      tmpIdx = idList[i]; // eslint-disable-next-line no-bitwise
+
+      tmpPnt = (tmpIdx << 1) + tmpIdx;
+
+      if (point[0] === values[tmpPnt] && point[1] === values[tmpPnt + 1] && point[2] === values[tmpPnt + 2]) {
+        pntIdx = tmpIdx;
+        break;
+      }
+    }
+
+    return pntIdx;
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.findDuplicateDoubleTypePointInVisitedLeafNode = function (leafNode, point) {
+    var tmpPnt;
+    var tmpIdx = -1;
+    var pntIdx = -1;
+    var idList = leafNode.getPointIdSet();
+    var values = model.locatorPoints.getData();
+
+    for (var i = 0; i < idList.length; i++) {
+      tmpIdx = idList[i]; // eslint-disable-next-line no-bitwise
+
+      tmpPnt = (tmpIdx << 1) + tmpIdx;
+
+      if (point[0] === values[tmpPnt] && point[1] === values[tmpPnt + 1] && point[2] === values[tmpPnt + 2]) {
+        pntIdx = tmpIdx;
+        break;
+      }
+    }
+
+    return pntIdx;
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.findDuplicatePointInLeafNode = function (leafNode, point) {
+    if (leafNode.getPointIdSet() == null) {
+      return -1;
+    }
+
+    return model.locatorPoints.getDataType() === VtkDataTypes.FLOAT ? publicAPI.findDuplicateFloatTypePointInVisitedLeafNode(leafNode, point) : publicAPI.findDuplicateDoubleTypePointInVisitedLeafNode(leafNode, point);
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.insertPoint = function (ptId, x) {
+    var leafcontainer = getLeafContainer(model.octreeRootNode, x);
+
+    var _leafcontainer$insert = leafcontainer.insertPoint(model.locatorPoints, x, model.maxPointsPerLeaf, ptId, 1, model.numberOfNodes);
+
+    model.numberOfNodes = _leafcontainer$insert.numberOfNodes;
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.insertUniquePoint = function (point) {
+    // TODO: We have a mix of let and const here.
+    // eslint-disable-next-line prefer-const
+    var _publicAPI$isInserted = publicAPI.isInsertedPoint(point),
+        pointIdx = _publicAPI$isInserted.pointIdx,
+        leafContainer = _publicAPI$isInserted.leafContainer;
+
+    if (pointIdx > -1) {
+      return {
+        success: false,
+        idx: pointIdx
+      };
+    } // TODO: pointIdx
+
+
+    var numberOfNodes; // eslint-disable-next-line prefer-const
+
+    var _leafContainer$insert = leafContainer.insertPoint(model.locatorPoints, point, model.maxPointsPerLeaf, pointIdx, 2, model.numberOfNodes);
+
+    numberOfNodes = _leafContainer$insert.numberOfNodes;
+    pointIdx = _leafContainer$insert.pointIdx;
+    model.numberOfNodes = numberOfNodes;
+    return {
+      success: true,
+      idx: pointIdx
+    };
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.insertNextPoint = function (x) {
+    var leafContainer = getLeafContainer(model.octreeRootNode, x);
+
+    var _leafContainer$insert2 = leafContainer.insertPoint(model.locatorPoints, x, model.maxPointsPerLeaf, -1, 2, model.numberOfNodes),
+        numberOfNodes = _leafContainer$insert2.numberOfNodes,
+        pointIdx = _leafContainer$insert2.pointIdx;
+
+    model.numberOfNodes = numberOfNodes;
+    return pointIdx;
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.isInsertedPointForZeroTolerance = function (x) {
+    // the target leaf node always exists there since the root node of the
+    // octree has been initialized to cover all possible points to be inserted
+    // and therefore we do not need to check it here
+    var leafContainer = getLeafContainer(model.octreeRootNode, x);
+    var pointIdx = publicAPI.findDuplicatePointInLeafNode(leafContainer, x);
+    return {
+      pointIdx: pointIdx,
+      leafContainer: leafContainer
+    };
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.isInsertedPointForNonZeroTolerance = function (x) {
+    // minDist2 // min distance to ALL existing points
+    // elseDst2 // min distance to other nodes (inner boundaries)
+    var dist2Ext; // min distance to an EXTended set of nodes
+
+    var pntIdExt; // the target leaf node always exists there since the root node of the
+    // octree has been initialized to cover all possible points to be inserted
+    // and therefore we do not need to check it here
+
+    var leafContainer = getLeafContainer(model.octreeRootNode, x);
+
+    var _publicAPI$findCloses3 = publicAPI.findClosestPointInLeafNode(leafContainer, x),
+        _publicAPI$findCloses4 = _slicedToArray(_publicAPI$findCloses3, 2),
+        pointIdx = _publicAPI$findCloses4[0],
+        minDist2 = _publicAPI$findCloses4[1];
+
+    if (minDist2 === 0.0) {
+      return {
+        pointIdx: pointIdx,
+        leafContainer: leafContainer
+      };
+    } // As no any 'duplicate' point exists in this leaf node, we need to expand
+    // the search scope to capture possible closer points in other nodes.
+
+
+    var elseDst2 = leafContainer.getDistance2ToInnerBoundary(x, model.octreeRootNode);
+
+    if (elseDst2 < model.insertTolerance2) {
+      // one or multiple closer points might exist in the neighboring nodes
+      // TODO: dist2Ext
+      pntIdExt = publicAPI.findClosestPointInSphereWithTolerance(x, model.insertTolerance2, leafContainer, dist2Ext);
+
+      if (dist2Ext < minDist2) {
+        minDist2 = dist2Ext;
+        pointIdx = pntIdExt;
+      }
+    }
+
+    pointIdx = minDist2 <= model.insertTolerance2 ? pointIdx : -1;
+    return {
+      pointIdx: pointIdx,
+      leafContainer: leafContainer
+    };
+  }; //------------------------------------------------------------------------------
+
+
+  publicAPI.isInsertedPoint = function (x, leafContainer) {
+    return model.insertTolerance2 === 0.0 ? publicAPI.isInsertedPointForZeroTolerance(x, leafContainer) : publicAPI.isInsertedPointForNonZeroTolerance(x, leafContainer);
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+function defaultValues(initialValues) {
+  return _objectSpread({
+    fudgeFactor: 0,
+    octreeMaxDimSize: 0,
+    buildCubicOctree: false,
+    maxPointsPerLeaf: 128,
+    insertTolerance2: 0.000001,
+    locatorPoints: null,
+    octreeRootNode: null,
+    numberOfNodes: 0
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkAbstractPointLocator.extend(publicAPI, model, defaultValues(initialValues)); // Make this a VTK object
+
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['fudgeFactor', 'octreeMaxDimSize', 'buildCubicOctree', 'maxPointsPerLeaf', 'insertTolerance2', 'locatorPoints', 'octreeRootNode', 'numberOfNodes']); // Object specific methods
+
+  vtkIncrementalOctreePointLocator(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkIncrementalOctreePointLocator'); // ----------------------------------------------------------------------------
+
+var vtkIncrementalOctreePointLocator$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkIncrementalOctreePointLocator$1 as default, extend, newInstance };

package/Common/DataModel/Locator.d.ts

@@ -0,0 +1,43 @@
+import { vtkObject } from './../../interfaces';
+
+/**
+ *
+ */
+export interface ILocatorInitialValues {
+	dataSet?: number[];
+	maxLevel?: number;
+	level?: number;
+	automatic?: boolean;
+	tolerance?: number;
+	useExistingSearchStructure?: boolean;
+}
+
+export interface vtkLocator extends vtkObject {}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkLocator characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ILocatorInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+	publicAPI: object,
+	model: object,
+	initialValues?: ILocatorInitialValues
+): void;
+
+// ----------------------------------------------------------------------------
+
+/**
+ * vtkLocator
+ */
+export declare const vtkLocator: {
+	extend: typeof extend;
+};
+
+export default vtkLocator;

package/Common/DataModel/Locator.js

@@ -0,0 +1,37 @@
+import macro from '../../macros.js';
+
+function vtkLocator(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkLocator');
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  dataSet: null,
+  maxLevel: 8,
+  // TODO: clamp 0, Number.MAX_VALUE
+  level: 8,
+  automatic: false,
+  tolerance: 0.0,
+  // TODO: clamp 0.0, Number.MAX_VALUE
+  useExistingSearchStructure: false
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+
+  macro.obj(publicAPI, model);
+  macro.get(publicAPI, model, ['level']);
+  macro.setGet(publicAPI, model, ['dataSet', 'maxLevel', 'automatic', 'tolerance', 'useExistingSearchStructure']); // Object specific methods
+
+  vtkLocator(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var vtkLocator$1 = {
+  extend: extend
+};
+
+export { vtkLocator$1 as default, extend };

package/Common/DataModel/Plane.js

@@ -1,5 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { g as subtract, d as dot, j as cross, k as add } from '../Core/Math/index.js';
+import { j as subtract, d as dot, k as cross, l as add } from '../Core/Math/index.js';
 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; }

package/Common/DataModel/PolyData/Constants.d.ts

@@ -0,0 +1,6 @@
+export declare const POLYDATA_FIELDS : string[];
+
+declare const _default: {
+	POLYDATA_FIELDS: typeof POLYDATA_FIELDS;
+};
+export default _default;

package/Common/DataModel/PolyLine.d.ts

@@ -0,0 +1,63 @@
+import { Vector2, Vector3 } from './../../types';
+import vtkCell, { ICellInitialValues } from './Cell';
+import { IIntersectWithLine } from './Line';
+
+export interface IPolyLineInitialValues extends ICellInitialValues { }
+
+export interface vtkPolyLine extends vtkCell {
+
+	/**
+	 * Get the topological dimensional of the cell (0, 1, 2 or 3).
+	 */
+	getCellDimension(): number;
+
+	/**
+	 * @param {number} t1
+	 * @param {number} t2
+	 * @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 the line.
+	 * @param {Vector3} pcoords The parametric coordinates.
+	 */
+	intersectWithLine(t1: number, t2: number, p1: Vector3, p2: Vector3, tol: number, x: Vector3, pcoords: Vector3): IIntersectWithLine;
+
+  /**
+   * Determine global coordinate (x[3]) from subId and parametric coordinates.
+   * Also returns interpolation weights. (The number of weights is equal to
+   * the number of points in the cell.)
+   * 
+   * @param {number} subId
+   * @param {Vector3} pcoords The parametric coordinates
+   * @param {Vector3} x The global coordinate
+   * @param {Vector2} weights The interpolation weights
+   */
+  evaluateLocation(subId: number, pcoords: Vector3, x: Vector3, weights: Vector2): void
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkPolyLine characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPolyLineInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IPolyLineInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkPolyLine.
+ * @param {IPolyLineInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IPolyLineInitialValues): vtkPolyLine;
+
+/** 
+ * vtkPolyLine is a cell which representant a poly line.
+ * 
+ * @see vtkCell
+ */
+export declare const vtkPolyLine: {
+	newInstance: typeof newInstance,
+	extend: typeof extend;
+};
+
+export default vtkPolyLine;

package/Common/DataModel/PolyLine.js

@@ -0,0 +1,77 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkCell from './Cell.js';
+import vtkLine from './Line.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; }
+
+function vtkPolyLine(publicAPI, model) {
+  model.classHierarchy.push('vtkPolyLine');
+
+  var superClass = _objectSpread({}, publicAPI);
+
+  var line = vtkLine.newInstance();
+  line.getPoints().setNumberOfPoints(2);
+
+  publicAPI.getCellDimension = function () {
+    return 1;
+  };
+
+  publicAPI.intersectWithLine = function (t1, t2, p1, p2, tol, x, pcoords) {
+    var outObj = {
+      intersect: 0,
+      t: Number.MAX_VALUE,
+      subId: 0,
+      betweenPoints: null
+    };
+    var numLines = superClass.getPoints().getNumberOfPoints() - 1;
+    var pDistMin = Number.MAX_VALUE;
+
+    for (var subId = 0; subId < numLines; subId++) {
+      var pCoords = [0, 0, 0];
+      line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
+      var lineIntersected = line.intersectWithLine(p1, p2, tol, x, pcoords);
+
+      if (lineIntersected.intersect === 1 && lineIntersected.t <= outObj.t + tol && lineIntersected.t >= t1 && lineIntersected.t <= t2) {
+        outObj.intersect = 1;
+        var pDist = line.getParametricDistance(pCoords);
+
+        if (pDist < pDistMin || pDist === pDistMin && lineIntersected.t < outObj.t) {
+          outObj.subId = subId;
+          outObj.t = lineIntersected.t;
+          pDistMin = pDist;
+        }
+      }
+    }
+
+    return outObj;
+  };
+
+  publicAPI.evaluateLocation = function (subId, pcoords, x, weights) {
+    line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
+    return line.evaluateLocation(pcoords, x, weights);
+  };
+} // ----------------------------------------------------------------------------
+// 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);
+  vtkPolyLine(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkPolyLine'); // ----------------------------------------------------------------------------
+
+var vtkPolyLine$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkPolyLine$1 as default, extend, newInstance };

package/Common/DataModel/Polygon/Constants.js

@@ -0,0 +1,12 @@
+var EPSILON = 1e-6;
+var FLOAT_EPSILON = 1.1920929e-7;
+var TOLERANCE = 1e-8;
+var PolygonWithPointIntersectionState = {
+  FAILURE: -1,
+  OUTSIDE: 0,
+  INSIDE: 1,
+  INTERSECTION: 2,
+  ON_LINE: 3
+};
+
+export { EPSILON, FLOAT_EPSILON, PolygonWithPointIntersectionState, TOLERANCE };

package/Common/DataModel/Polygon.js

@@ -1,6 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
-import { l as normalize, g as subtract, j as cross, k as add, d as dot, n as norm } from '../Core/Math/index.js';
+import { g as normalize, j as subtract, k as cross, l as add, d as dot, n as norm } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 import vtkPriorityQueue from '../Core/PriorityQueue.js';

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