@kitware/vtk.js 28.10.2 → 28.11.1

package/Common/DataModel/PolyData.js

@@ -1,5 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtk from '../../vtk.js';
 import vtkCellArray from '../Core/CellArray.js';
 import vtkCellLinks from './CellLinks.js';
@@ -10,191 +9,165 @@ import vtkTriangle from './Triangle.js';
 import { CellType } from './CellTypes/Constants.js';
 import { POLYDATA_FIELDS } from './PolyData/Constants.js';
 
-var _CELL_FACTORY;
-var vtkWarningMacro = macro.vtkWarningMacro;
-var CELL_FACTORY = (_CELL_FACTORY = {}, _defineProperty(_CELL_FACTORY, CellType.VTK_LINE, vtkLine), _defineProperty(_CELL_FACTORY, CellType.VTK_POLY_LINE, vtkLine), _defineProperty(_CELL_FACTORY, CellType.VTK_TRIANGLE, vtkTriangle), _CELL_FACTORY); // ----------------------------------------------------------------------------
+const {
+  vtkWarningMacro
+} = macro;
+const CELL_FACTORY = {
+  [CellType.VTK_LINE]: vtkLine,
+  [CellType.VTK_POLY_LINE]: vtkLine,
+  [CellType.VTK_TRIANGLE]: vtkTriangle
+};
+
+// ----------------------------------------------------------------------------
 // vtkPolyData methods
 // ----------------------------------------------------------------------------
 
 function vtkPolyData(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPolyData');
-
   function camelize(str) {
-    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function (letter) {
-      return letter.toUpperCase();
-    }).replace(/\s+/g, '');
-  } // build empty cell arrays and set methods
-
-
-  POLYDATA_FIELDS.forEach(function (type) {
-    publicAPI["getNumberOf".concat(camelize(type))] = function () {
-      return model[type].getNumberOfCells();
-    };
+    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, letter => letter.toUpperCase()).replace(/\s+/g, '');
+  }
 
+  // build empty cell arrays and set methods
+  POLYDATA_FIELDS.forEach(type => {
+    publicAPI[`getNumberOf${camelize(type)}`] = () => model[type].getNumberOfCells();
     if (!model[type]) {
       model[type] = vtkCellArray.newInstance();
     } else {
       model[type] = vtk(model[type]);
     }
   });
-
-  publicAPI.getNumberOfCells = function () {
-    return POLYDATA_FIELDS.reduce(function (num, cellType) {
-      return num + model[cellType].getNumberOfCells();
-    }, 0);
-  };
-
-  var superShallowCopy = publicAPI.shallowCopy;
-
+  publicAPI.getNumberOfCells = () => POLYDATA_FIELDS.reduce((num, cellType) => num + model[cellType].getNumberOfCells(), 0);
+  const superShallowCopy = publicAPI.shallowCopy;
   publicAPI.shallowCopy = function (other) {
-    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     superShallowCopy(other, debug);
-    POLYDATA_FIELDS.forEach(function (type) {
+    POLYDATA_FIELDS.forEach(type => {
       model[type] = vtkCellArray.newInstance();
       model[type].shallowCopy(other.getReferenceByName(type));
     });
   };
-
-  publicAPI.buildCells = function () {
+  publicAPI.buildCells = () => {
     // here are the number of cells we have
-    var nVerts = publicAPI.getNumberOfVerts();
-    var nLines = publicAPI.getNumberOfLines();
-    var nPolys = publicAPI.getNumberOfPolys();
-    var nStrips = publicAPI.getNumberOfStrips(); // pre-allocate the space we need
-
-    var nCells = nVerts + nLines + nPolys + nStrips;
-    var types = new Uint8Array(nCells);
-    var pTypes = types;
-    var locs = new Uint32Array(nCells);
-    var pLocs = locs; // record locations and type of each cell.
+    const nVerts = publicAPI.getNumberOfVerts();
+    const nLines = publicAPI.getNumberOfLines();
+    const nPolys = publicAPI.getNumberOfPolys();
+    const nStrips = publicAPI.getNumberOfStrips();
+
+    // pre-allocate the space we need
+    const nCells = nVerts + nLines + nPolys + nStrips;
+    const types = new Uint8Array(nCells);
+    let pTypes = types;
+    const locs = new Uint32Array(nCells);
+    let pLocs = locs;
+
+    // record locations and type of each cell.
     // verts
-
     if (nVerts) {
-      var nextCellPts = 0;
-      model.verts.getCellSizes().forEach(function (numCellPts, index) {
+      let nextCellPts = 0;
+      model.verts.getCellSizes().forEach((numCellPts, index) => {
         pLocs[index] = nextCellPts;
         pTypes[index] = numCellPts > 1 ? CellType.VTK_POLY_VERTEX : CellType.VTK_VERTEX;
         nextCellPts += numCellPts + 1;
       });
       pLocs = pLocs.subarray(nVerts);
       pTypes = pTypes.subarray(nVerts);
-    } // lines
-
+    }
 
+    // lines
     if (nLines) {
-      var _nextCellPts = 0;
-      model.lines.getCellSizes().forEach(function (numCellPts, index) {
-        pLocs[index] = _nextCellPts;
+      let nextCellPts = 0;
+      model.lines.getCellSizes().forEach((numCellPts, index) => {
+        pLocs[index] = nextCellPts;
         pTypes[index] = numCellPts > 2 ? CellType.VTK_POLY_LINE : CellType.VTK_LINE;
-
         if (numCellPts === 1) {
           vtkWarningMacro('Building VTK_LINE ', index, ' with only one point, but VTK_LINE needs at least two points. Check the input.');
         }
-
-        _nextCellPts += numCellPts + 1;
+        nextCellPts += numCellPts + 1;
       });
       pLocs = pLocs.subarray(nLines);
       pTypes = pTypes.subarray(nLines);
-    } // polys
-
+    }
 
+    // polys
     if (nPolys) {
-      var _nextCellPts2 = 0;
-      model.polys.getCellSizes().forEach(function (numCellPts, index) {
-        pLocs[index] = _nextCellPts2;
-
+      let nextCellPts = 0;
+      model.polys.getCellSizes().forEach((numCellPts, index) => {
+        pLocs[index] = nextCellPts;
         switch (numCellPts) {
           case 3:
             pTypes[index] = CellType.VTK_TRIANGLE;
             break;
-
           case 4:
             pTypes[index] = CellType.VTK_QUAD;
             break;
-
           default:
             pTypes[index] = CellType.VTK_POLYGON;
             break;
         }
-
         if (numCellPts < 3) {
           vtkWarningMacro('Building VTK_TRIANGLE ', index, ' with less than three points, but VTK_TRIANGLE needs at least three points. Check the input.');
         }
-
-        _nextCellPts2 += numCellPts + 1;
+        nextCellPts += numCellPts + 1;
       });
       pLocs += pLocs.subarray(nPolys);
       pTypes += pTypes.subarray(nPolys);
-    } // strips
-
+    }
 
+    // strips
     if (nStrips) {
-      var _nextCellPts3 = 0;
+      let nextCellPts = 0;
       pTypes.fill(CellType.VTK_TRIANGLE_STRIP, 0, nStrips);
-      model.strips.getCellSizes().forEach(function (numCellPts, index) {
-        pLocs[index] = _nextCellPts3;
-        _nextCellPts3 += numCellPts + 1;
+      model.strips.getCellSizes().forEach((numCellPts, index) => {
+        pLocs[index] = nextCellPts;
+        nextCellPts += numCellPts + 1;
       });
-    } // set up the cell types data structure
-
+    }
 
+    // set up the cell types data structure
     model.cells = vtkCellTypes.newInstance();
     model.cells.setCellTypes(nCells, types, locs);
   };
+
   /**
    * Create upward links from points to cells that use each point. Enables
    * topologically complex queries.
    */
-
-
   publicAPI.buildLinks = function () {
-    var initialSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-
+    let initialSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (model.cells === undefined) {
       publicAPI.buildCells();
     }
-
     model.links = vtkCellLinks.newInstance();
-
     if (initialSize > 0) {
       model.links.allocate(initialSize);
     } else {
       model.links.allocate(publicAPI.getPoints().getNumberOfPoints());
     }
-
     model.links.buildLinks(publicAPI);
   };
-
-  publicAPI.getCellType = function (cellId) {
-    return model.cells.getCellType(cellId);
-  };
-
-  publicAPI.getCellPoints = function (cellId) {
-    var cellType = publicAPI.getCellType(cellId);
-    var cells = null;
-
+  publicAPI.getCellType = cellId => model.cells.getCellType(cellId);
+  publicAPI.getCellPoints = cellId => {
+    const cellType = publicAPI.getCellType(cellId);
+    let cells = null;
     switch (cellType) {
       case CellType.VTK_VERTEX:
       case CellType.VTK_POLY_VERTEX:
         cells = model.verts;
         break;
-
       case CellType.VTK_LINE:
       case CellType.VTK_POLY_LINE:
         cells = model.lines;
         break;
-
       case CellType.VTK_TRIANGLE:
       case CellType.VTK_QUAD:
       case CellType.VTK_POLYGON:
         cells = model.polys;
         break;
-
       case CellType.VTK_TRIANGLE_STRIP:
         cells = model.strips;
         break;
-
       default:
         cells = null;
         return {
@@ -202,67 +175,69 @@ function vtkPolyData(publicAPI, model) {
           cellPointIds: null
         };
     }
-
-    var loc = model.cells.getCellLocation(cellId);
-    var cellPointIds = cells.getCell(loc);
+    const loc = model.cells.getCellLocation(cellId);
+    const cellPointIds = cells.getCell(loc);
     return {
-      cellType: cellType,
-      cellPointIds: cellPointIds
+      cellType,
+      cellPointIds
     };
   };
-
-  publicAPI.getPointCells = function (ptId) {
-    return model.links.getCells(ptId);
+  publicAPI.getPointCells = ptId => model.links.getCells(ptId);
+  publicAPI.getCellEdgeNeighbors = (cellId, point1, point2) => {
+    const link1 = model.links.getLink(point1);
+    const link2 = model.links.getLink(point2);
+    return link1.cells.filter(cell => cell !== cellId && link2.cells.indexOf(cell) !== -1);
   };
 
-  publicAPI.getCellEdgeNeighbors = function (cellId, point1, point2) {
-    var link1 = model.links.getLink(point1);
-    var link2 = model.links.getLink(point2);
-    return link1.cells.filter(function (cell) {
-      return cell !== cellId && link2.cells.indexOf(cell) !== -1;
-    });
-  };
   /**
    * If you know the type of cell, you may provide it to improve performances.
    */
-
-
   publicAPI.getCell = function (cellId) {
-    var cellHint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    var cellInfo = publicAPI.getCellPoints(cellId);
-    var cell = cellHint || CELL_FACTORY[cellInfo.cellType].newInstance();
+    let cellHint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    const cellInfo = publicAPI.getCellPoints(cellId);
+    const cell = cellHint || CELL_FACTORY[cellInfo.cellType].newInstance();
     cell.initialize(publicAPI.getPoints(), cellInfo.cellPointIds);
     return cell;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {// verts: null,
+const DEFAULT_VALUES = {
+  // verts: null,
   // lines: null,
   // polys: null,
   // strips: null,
   // cells: null,
   // links: null,
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   vtkPointSet.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['cells', 'links']);
-  macro.setGet(publicAPI, model, ['verts', 'lines', 'polys', 'strips']); // Object specific methods
+  macro.setGet(publicAPI, model, ['verts', 'lines', 'polys', 'strips']);
 
+  // Object specific methods
   vtkPolyData(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkPolyData'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPolyData');
+
+// ----------------------------------------------------------------------------
 
 var vtkPolyData$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { CELL_FACTORY, vtkPolyData$1 as default, extend, newInstance };

package/Common/DataModel/PolyLine.js

@@ -1,36 +1,29 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCell from './Cell.js';
 import vtkLine from './Line.js';
 import { vec3 } from 'gl-matrix';
 
 function vtkPolyLine(publicAPI, model) {
   model.classHierarchy.push('vtkPolyLine');
-  var line = vtkLine.newInstance();
+  const line = vtkLine.newInstance();
   line.getPoints().setNumberOfPoints(2);
-
-  publicAPI.getCellDimension = function () {
-    return 1;
-  };
-
-  publicAPI.intersectWithLine = function (t1, t2, p1, p2, tol, x, pcoords) {
-    var outObj = {
+  publicAPI.getCellDimension = () => 1;
+  publicAPI.intersectWithLine = (t1, t2, p1, p2, tol, x, pcoords) => {
+    const outObj = {
       intersect: 0,
       t: Number.MAX_VALUE,
       subId: 0,
       betweenPoints: null
     };
-    var numLines = publicAPI.getNumberOfPoints() - 1;
-    var pDistMin = Number.MAX_VALUE;
-
-    for (var subId = 0; subId < numLines; subId++) {
-      var pCoords = [0, 0, 0];
+    const numLines = publicAPI.getNumberOfPoints() - 1;
+    let pDistMin = Number.MAX_VALUE;
+    for (let subId = 0; subId < numLines; subId++) {
+      const 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);
-
+      const 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);
-
+        const pDist = line.getParametricDistance(pCoords);
         if (pDist < pDistMin || pDist === pDistMin && lineIntersected.t < outObj.t) {
           outObj.subId = subId;
           outObj.t = lineIntersected.t;
@@ -38,98 +31,84 @@ function vtkPolyLine(publicAPI, model) {
         }
       }
     }
-
     return outObj;
   };
-
-  publicAPI.evaluateLocation = function (subId, pcoords, x, weights) {
+  publicAPI.evaluateLocation = (subId, pcoords, x, weights) => {
     line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
     return line.evaluateLocation(pcoords, x, weights);
   };
-
-  publicAPI.evaluateOrientation = function (subId, pcoords, q, weights) {
+  publicAPI.evaluateOrientation = (subId, pcoords, q, weights) => {
     if (model.orientations) {
       line.setOrientations([model.orientations[subId], model.orientations[subId + 1]]);
     } else {
       line.setOrientations(null);
     }
-
     return line.evaluateOrientation(pcoords, q, weights);
   };
-
-  publicAPI.getDistancesToFirstPoint = function () {
-    var dTime = model.distancesTime.getMTime();
-
+  publicAPI.getDistancesToFirstPoint = () => {
+    const dTime = model.distancesTime.getMTime();
     if (dTime < model.points.getMTime() || dTime < publicAPI.getMTime()) {
-      var numPoints = publicAPI.getNumberOfPoints();
-
+      const numPoints = publicAPI.getNumberOfPoints();
       if (!model.distances) {
         model.distances = new Array(numPoints);
       } else {
         model.distances.length = numPoints;
       }
-
       if (numPoints > 0) {
-        var previousPoint = new Array(3);
-        var currentPoint = new Array(3);
-        var totalDistance = 0;
+        const previousPoint = new Array(3);
+        const currentPoint = new Array(3);
+        let totalDistance = 0;
         model.distances[0] = totalDistance;
         model.points.getPoint(0, previousPoint);
-
-        for (var i = 1; i < numPoints; ++i) {
+        for (let i = 1; i < numPoints; ++i) {
           model.points.getPoint(i, currentPoint);
           totalDistance += model.distanceFunction(previousPoint, currentPoint);
           model.distances[i] = totalDistance;
           vec3.copy(previousPoint, currentPoint);
         }
       }
-
       model.distancesTime.modified();
     }
-
     return model.distances;
   };
-
-  publicAPI.findPointIdAtDistanceFromFirstPoint = function (distance) {
-    var distances = publicAPI.getDistancesToFirstPoint(); // At least two points to return an ID
-
+  publicAPI.findPointIdAtDistanceFromFirstPoint = distance => {
+    const distances = publicAPI.getDistancesToFirstPoint();
+    // At least two points to return an ID
     if (distances.length < 2) {
       return -1;
-    } // Binary search in the distance array
-
-
-    var minId = 0;
-    var maxId = distances.length - 1;
-
+    }
+    // Binary search in the distance array
+    let minId = 0;
+    let maxId = distances.length - 1;
     if (distance < distances[minId] || distance > distances[maxId] || distances[maxId] === 0) {
       return -1;
     }
-
     while (maxId - minId > 1) {
-      var midId = Math.floor((minId + maxId) / 2);
-
+      const midId = Math.floor((minId + maxId) / 2);
       if (distances[midId] <= distance) {
         minId = midId;
       } else {
         maxId = midId;
       }
     }
-
     return minId;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   orientations: null,
   // an array of quat or null
   distanceFunction: vec3.dist
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkCell.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['orientations', 'distanceFunction']);
@@ -138,13 +117,17 @@ function extend(publicAPI, model) {
     mtime: 0
   });
   vtkPolyLine(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkPolyLine'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPolyLine');
+
+// ----------------------------------------------------------------------------
 
 var vtkPolyLine$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPolyLine$1 as default, extend, newInstance };

package/Common/DataModel/Polygon/Constants.js

@@ -1,7 +1,7 @@
-var EPSILON = 1e-6;
-var FLOAT_EPSILON = 1.1920929e-7;
-var TOLERANCE = 1e-8;
-var PolygonWithPointIntersectionState = {
+const EPSILON = 1e-6;
+const FLOAT_EPSILON = 1.1920929e-7;
+const TOLERANCE = 1e-8;
+const PolygonWithPointIntersectionState = {
   FAILURE: -1,
   OUTSIDE: 0,
   INSIDE: 1,