@kitware/vtk.js 28.10.2 → 28.11.0

package/Common/DataModel/Cell.js

@@ -1,38 +1,34 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { u as uninitializeBounds } from '../Core/Math/index.js';
 import vtkPoints from '../Core/Points.js';
 
+// ----------------------------------------------------------------------------
 // vtkCell methods
 // ----------------------------------------------------------------------------
 
 function vtkCell(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCell');
-
   publicAPI.initialize = function (points) {
-    var pointIdsList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
+    let pointIdsList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     if (!pointIdsList) {
       model.points = points;
       model.pointsIds = new Array(points.getNumberOfPoints());
-
-      for (var i = points.getNumberOfPoints() - 1; i >= 0; --i) {
+      for (let i = points.getNumberOfPoints() - 1; i >= 0; --i) {
         model.pointsIds[i] = i;
       }
     } else {
       model.pointsIds = pointIdsList;
-      var triangleData = model.points.getData();
-
+      let triangleData = model.points.getData();
       if (triangleData.length !== 3 * model.pointsIds.length) {
         triangleData = macro.newTypedArray(points.getDataType(), 3 * model.pointsIds.length);
       }
-
-      var pointsData = points.getData();
-      model.pointsIds.forEach(function (pointId, index) {
+      const pointsData = points.getData();
+      model.pointsIds.forEach((pointId, index) => {
         // const start = 3 * pointId;
         // pointsData.set(p.subarray(start, start + 3), 3 * index);
-        var pointOffset = 3 * pointId;
-        var trianglePointOffset = 3 * index;
+        let pointOffset = 3 * pointId;
+        let trianglePointOffset = 3 * index;
         triangleData[trianglePointOffset] = pointsData[pointOffset];
         triangleData[++trianglePointOffset] = pointsData[++pointOffset];
         triangleData[++trianglePointOffset] = pointsData[++pointOffset];
@@ -40,11 +36,9 @@ function vtkCell(publicAPI, model) {
       model.points.setData(triangleData);
     }
   };
-
-  publicAPI.getBounds = function () {
-    var nbPoints = model.points.getNumberOfPoints();
-    var x = [];
-
+  publicAPI.getBounds = () => {
+    const nbPoints = model.points.getNumberOfPoints();
+    const x = [];
     if (nbPoints) {
       model.points.getPoint(0, x);
       model.bounds[0] = x[0];
@@ -53,8 +47,7 @@ function vtkCell(publicAPI, model) {
       model.bounds[3] = x[1];
       model.bounds[4] = x[2];
       model.bounds[5] = x[2];
-
-      for (var i = 1; i < nbPoints; i++) {
+      for (let i = 1; i < nbPoints; i++) {
         model.points.getPoint(i, x);
         model.bounds[0] = x[0] < model.bounds[0] ? x[0] : model.bounds[0];
         model.bounds[1] = x[0] > model.bounds[1] ? x[0] : model.bounds[1];
@@ -66,28 +59,22 @@ function vtkCell(publicAPI, model) {
     } else {
       uninitializeBounds(model.bounds);
     }
-
     return model.bounds;
   };
-
-  publicAPI.getLength2 = function () {
+  publicAPI.getLength2 = () => {
     publicAPI.getBounds();
-    var length = 0.0;
-    var diff = 0;
-
-    for (var i = 0; i < 3; i++) {
+    let length = 0.0;
+    let diff = 0;
+    for (let i = 0; i < 3; i++) {
       diff = model.bounds[2 * i + 1] - model.bounds[2 * i];
       length += diff * diff;
     }
-
     return length;
   };
-
-  publicAPI.getParametricDistance = function (pcoords) {
-    var pDist;
-    var pDistMax = 0.0;
-
-    for (var i = 0; i < 3; i++) {
+  publicAPI.getParametricDistance = pcoords => {
+    let pDist;
+    let pDistMax = 0.0;
+    for (let i = 0; i < 3; i++) {
       if (pcoords[i] < 0.0) {
         pDist = -pcoords[i];
       } else if (pcoords[i] > 1.0) {
@@ -96,61 +83,54 @@ function vtkCell(publicAPI, model) {
         // inside the cell in the parametric direction
         pDist = 0.0;
       }
-
       if (pDist > pDistMax) {
         pDistMax = pDist;
       }
     }
-
     return pDistMax;
   };
-
-  publicAPI.getNumberOfPoints = function () {
-    return model.points.getNumberOfPoints();
-  };
-
-  publicAPI.deepCopy = function (cell) {
+  publicAPI.getNumberOfPoints = () => model.points.getNumberOfPoints();
+  publicAPI.deepCopy = cell => {
     cell.initialize(model.points, model.pointsIds);
   };
-
-  publicAPI.getCellDimension = function () {}; // virtual
-
-
-  publicAPI.intersectWithLine = function (p1, p2, tol, t, x, pcoords, subId) {}; // virtual
-
-
-  publicAPI.evaluatePosition = function (x, closestPoint, subId, pcoords, dist2, weights) {
+  publicAPI.getCellDimension = () => {}; // virtual
+  publicAPI.intersectWithLine = (p1, p2, tol, t, x, pcoords, subId) => {}; // virtual
+  publicAPI.evaluatePosition = (x, closestPoint, subId, pcoords, dist2, weights) => {
     macro.vtkErrorMacro('vtkCell.evaluatePosition is not implemented.');
   }; // virtual
+}
 
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   bounds: [-1, -1, -1, -1, -1, -1],
   pointsIds: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   macro.obj(publicAPI, model);
-
   if (!model.points) {
     model.points = vtkPoints.newInstance();
   }
-
   macro.get(publicAPI, model, ['points', 'pointsIds']);
   vtkCell(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCell'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCell');
+
+// ----------------------------------------------------------------------------
 
 var vtkCell$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCell$1 as default, extend, newInstance };

package/Common/DataModel/CellLinks.js

@@ -1,105 +1,91 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCell from './Cell.js';
 
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
-
-var InitLink = {
+const InitLink = {
   ncells: 0,
   cells: null
 };
-
 function resize(model, sz) {
-  var newSize = sz;
-
+  let newSize = sz;
   if (sz >= model.array.length) {
     newSize += model.array.length;
   }
-
-  while (newSize > model.array.length) {
-    model.array.push({
-      ncells: 0,
-      cells: null
-    });
-  }
-
+  while (newSize > model.array.length) model.array.push({
+    ncells: 0,
+    cells: null
+  });
   model.array.length = newSize;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkCellLinks methods
 // ----------------------------------------------------------------------------
 
-
 function vtkCellLinks(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCellLinks');
+
   /**
    * Build the link list array. All subclasses of vtkAbstractCellLinks
    * must support this method.
    */
+  publicAPI.buildLinks = data => {
+    const numPts = data.getPoints().getNumberOfPoints();
+    const numCells = data.getNumberOfCells();
 
-  publicAPI.buildLinks = function (data) {
-    var numPts = data.getPoints().getNumberOfPoints();
-    var numCells = data.getNumberOfCells(); // fill out lists with number of references to cells
-
-    var linkLoc = new Uint32Array(numPts); // Use fast path if polydata
+    // fill out lists with number of references to cells
+    const linkLoc = new Uint32Array(numPts);
 
+    // Use fast path if polydata
     if (data.isA('vtkPolyData')) {
       // traverse data to determine number of uses of each point
-      for (var cellId = 0; cellId < numCells; ++cellId) {
-        var _data$getCellPoints = data.getCellPoints(cellId),
-            cellPointIds = _data$getCellPoints.cellPointIds;
-
-        cellPointIds.forEach(function (cellPointId) {
+      for (let cellId = 0; cellId < numCells; ++cellId) {
+        const {
+          cellPointIds
+        } = data.getCellPoints(cellId);
+        cellPointIds.forEach(cellPointId => {
           publicAPI.incrementLinkCount(cellPointId);
         });
-      } // now allocate storage for the links
-
+      }
 
+      // now allocate storage for the links
       publicAPI.allocateLinks(numPts);
       model.maxId = numPts - 1;
-
-      var _loop = function _loop(_cellId) {
-        var _data$getCellPoints2 = data.getCellPoints(_cellId),
-            cellPointIds = _data$getCellPoints2.cellPointIds;
-
-        cellPointIds.forEach(function (cellPointId) {
-          publicAPI.insertCellReference(cellPointId, linkLoc[cellPointId]++, _cellId);
+      for (let cellId = 0; cellId < numCells; ++cellId) {
+        const {
+          cellPointIds
+        } = data.getCellPoints(cellId);
+        cellPointIds.forEach(cellPointId => {
+          publicAPI.insertCellReference(cellPointId, linkLoc[cellPointId]++, cellId);
         });
-      };
-
-      for (var _cellId = 0; _cellId < numCells; ++_cellId) {
-        _loop(_cellId);
       }
     } // any other type of dataset
     else {
       // traverse data to determine number of uses of each point
-      for (var _cellId2 = 0; _cellId2 < numCells; _cellId2++) {
+      for (let cellId = 0; cellId < numCells; cellId++) {
         // TODO: Currently not supported: const cell = data.getCell(cellId);
-        var cell = vtkCell.newInstance();
-        cell.getPointsIds().forEach(function (cellPointId) {
+        const cell = vtkCell.newInstance();
+        cell.getPointsIds().forEach(cellPointId => {
           publicAPI.incrementLinkCount(cellPointId);
         });
-      } // now allocate storage for the links
-
+      }
 
+      // now allocate storage for the links
       publicAPI.allocateLinks(numPts);
       model.maxId = numPts - 1;
-
-      var _loop2 = function _loop2(_cellId3) {
+      for (let cellId = 0; cellId < numCells; ++cellId) {
         // TODO: Currently not supported: const cell = data.getCell(cellId);
-        var cell = vtkCell.newInstance();
-        cell.getPointsIds().forEach(function (cellPointId) {
-          publicAPI.insertCellReference(cellPointId, linkLoc[cellPointId]++, _cellId3);
+        const cell = vtkCell.newInstance();
+        cell.getPointsIds().forEach(cellPointId => {
+          publicAPI.insertCellReference(cellPointId, linkLoc[cellPointId]++, cellId);
         });
-      };
-
-      for (var _cellId3 = 0; _cellId3 < numCells; ++_cellId3) {
-        _loop2(_cellId3);
       }
     } // end else
-
   };
+
   /**
    * Build the link list array with a provided connectivity array.
    */
@@ -109,186 +95,164 @@ function vtkCellLinks(publicAPI, model) {
    * Allocate the specified number of links (i.e., number of points) that
    * will be built.
    */
-
-
   publicAPI.allocate = function (numLinks) {
-    var ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
-    model.array = Array(numLinks).fill().map(function () {
-      return {
-        ncells: 0,
-        cells: null
-      };
-    });
+    let ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+    model.array = Array(numLinks).fill().map(() => ({
+      ncells: 0,
+      cells: null
+    }));
     model.extend = ext;
     model.maxId = -1;
   };
-
-  publicAPI.initialize = function () {
+  publicAPI.initialize = () => {
     model.array = null;
   };
+
   /**
    * Get a link structure given a point id.
    */
+  publicAPI.getLink = ptId => model.array[ptId];
 
-
-  publicAPI.getLink = function (ptId) {
-    return model.array[ptId];
-  };
   /**
    * Get the number of cells using the point specified by ptId.
    */
+  publicAPI.getNcells = ptId => model.array[ptId].ncells;
 
-
-  publicAPI.getNcells = function (ptId) {
-    return model.array[ptId].ncells;
-  };
   /**
    * Return a list of cell ids using the point.
    */
+  publicAPI.getCells = ptId => model.array[ptId].cells;
 
-
-  publicAPI.getCells = function (ptId) {
-    return model.array[ptId].cells;
-  };
   /**
    * Insert a new point into the cell-links data structure. The size parameter
    * is the initial size of the list.
    */
-
-
-  publicAPI.insertNextPoint = function (numLinks) {
+  publicAPI.insertNextPoint = numLinks => {
     model.array.push({
       ncells: numLinks,
       cells: Array(numLinks)
     });
     ++model.maxId;
   };
+
   /**
    * Insert a cell id into the list of cells (at the end) using the cell id
    * provided. (Make sure to extend the link list (if necessary) using the
    * method resizeCellList().)
    */
-
-
-  publicAPI.insertNextCellReference = function (ptId, cellId) {
+  publicAPI.insertNextCellReference = (ptId, cellId) => {
     model.array[ptId].cells[model.array[ptId].ncells++] = cellId;
   };
+
   /**
    * Delete point (and storage) by destroying links to using cells.
    */
-
-
-  publicAPI.deletePoint = function (ptId) {
+  publicAPI.deletePoint = ptId => {
     model.array[ptId].ncells = 0;
     model.array[ptId].cells = null;
   };
+
   /**
    * Delete the reference to the cell (cellId) from the point (ptId). This
    * removes the reference to the cellId from the cell list, but does not
    * resize the list (recover memory with resizeCellList(), if necessary).
    */
-
-
-  publicAPI.removeCellReference = function (cellId, ptId) {
-    model.array[ptId].cells = model.array[ptId].cells.filter(function (cell) {
-      return cell !== cellId;
-    });
+  publicAPI.removeCellReference = (cellId, ptId) => {
+    model.array[ptId].cells = model.array[ptId].cells.filter(cell => cell !== cellId);
     model.array[ptId].ncells = model.array[ptId].cells.length;
   };
+
   /**
    * Add the reference to the cell (cellId) from the point (ptId). This
    * adds a reference to the cellId from the cell list, but does not resize
    * the list (extend memory with resizeCellList(), if necessary).
    */
-
-
-  publicAPI.addCellReference = function (cellId, ptId) {
+  publicAPI.addCellReference = (cellId, ptId) => {
     model.array[ptId].cells[model.array[ptId].ncells++] = cellId;
   };
+
   /**
    * Change the length of a point's link list (i.e., list of cells using a
    * point) by the size specified.
    */
-
-
-  publicAPI.resizeCellList = function (ptId, size) {
+  publicAPI.resizeCellList = (ptId, size) => {
     model.array[ptId].cells.length = size;
   };
+
   /**
    * Reclaim any unused memory.
    */
-
-
-  publicAPI.squeeze = function () {
+  publicAPI.squeeze = () => {
     resize(model, model.maxId + 1);
   };
+
   /**
    * Reset to a state of no entries without freeing the memory.
    */
-
-
-  publicAPI.reset = function () {
+  publicAPI.reset = () => {
     model.maxId = -1;
   };
+
   /**
    * Standard DeepCopy method.  Since this object contains no reference
    * to other objects, there is no ShallowCopy.
    */
-
-
-  publicAPI.deepCopy = function (src) {
-    model.array = _toConsumableArray(src.array);
+  publicAPI.deepCopy = src => {
+    model.array = [...src.array];
     model.extend = src.extend;
     model.maxId = src.maxId;
   };
+
   /**
    * Increment the count of the number of cells using the point.
    */
-
-
-  publicAPI.incrementLinkCount = function (ptId) {
+  publicAPI.incrementLinkCount = ptId => {
     ++model.array[ptId].ncells;
   };
-
-  publicAPI.allocateLinks = function (n) {
-    for (var i = 0; i < n; ++i) {
+  publicAPI.allocateLinks = n => {
+    for (let i = 0; i < n; ++i) {
       model.array[i].cells = new Array(model.array[i].ncells);
     }
   };
+
   /**
    * Insert a cell id into the list of cells using the point.
    */
-
-
-  publicAPI.insertCellReference = function (ptId, pos, cellId) {
+  publicAPI.insertCellReference = (ptId, pos, cellId) => {
     model.array[ptId].cells[pos] = cellId;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   array: null,
   // pointer to data
   maxId: 0,
   // maximum index inserted thus far
   extend: 0 // grow array by this point
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 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);
   macro.obj(publicAPI, model);
   vtkCellLinks(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkCellLinks'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkCellLinks');
+
+// ----------------------------------------------------------------------------
 
 var vtkCellLinks$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { InitLink, vtkCellLinks$1 as default, extend, newInstance };

package/Common/DataModel/CellTypes/Constants.js

@@ -1,4 +1,4 @@
-var CellType = {
+const CellType = {
   // Linear cells
   VTK_EMPTY_CELL: 0,
   VTK_VERTEX: 1,
@@ -64,13 +64,14 @@ var CellType = {
   VTK_LAGRANGE_WEDGE: 73,
   VTK_LAGRANGE_PYRAMID: 74,
   VTK_NUMBER_OF_CELL_TYPES: 75
-}; // This list should contain the cell class names in
-// the same order as in CellType.
+};
 
-var CellTypesStrings = ['vtkEmptyCell', 'vtkVertex', 'vtkPolyVertex', 'vtkLine', 'vtkPolyLine', 'vtkTriangle', 'vtkTriangleStrip', 'vtkPolygon', 'vtkPixel', 'vtkQuad', 'vtkTetra', 'vtkVoxel', 'vtkHexahedron', 'vtkWedge', 'vtkPyramid', 'vtkPentagonalPrism', 'vtkHexagonalPrism', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkQuadraticEdge', 'vtkQuadraticTriangle', 'vtkQuadraticQuad', 'vtkQuadraticTetra', 'vtkQuadraticHexahedron', 'vtkQuadraticWedge', 'vtkQuadraticPyramid', 'vtkBiQuadraticQuad', 'vtkTriQuadraticHexahedron', 'vtkQuadraticLinearQuad', 'vtkQuadraticLinearWedge', 'vtkBiQuadraticQuadraticWedge', 'vtkBiQuadraticQuadraticHexahedron', 'vtkBiQuadraticTriangle', 'vtkCubicLine', 'vtkQuadraticPolygon', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkConvexPointSet', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkParametricCurve', 'vtkParametricSurface', 'vtkParametricTriSurface', 'vtkParametricQuadSurface', 'vtkParametricTetraRegion', 'vtkParametricHexRegion', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkHigherOrderEdge', 'vtkHigherOrderTriangle', 'vtkHigherOrderQuad', 'vtkHigherOrderPolygon', 'vtkHigherOrderTetrahedron', 'vtkHigherOrderWedge', 'vtkHigherOrderPyramid', 'vtkHigherOrderHexahedron'];
+// This list should contain the cell class names in
+// the same order as in CellType.
+const CellTypesStrings = ['vtkEmptyCell', 'vtkVertex', 'vtkPolyVertex', 'vtkLine', 'vtkPolyLine', 'vtkTriangle', 'vtkTriangleStrip', 'vtkPolygon', 'vtkPixel', 'vtkQuad', 'vtkTetra', 'vtkVoxel', 'vtkHexahedron', 'vtkWedge', 'vtkPyramid', 'vtkPentagonalPrism', 'vtkHexagonalPrism', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkQuadraticEdge', 'vtkQuadraticTriangle', 'vtkQuadraticQuad', 'vtkQuadraticTetra', 'vtkQuadraticHexahedron', 'vtkQuadraticWedge', 'vtkQuadraticPyramid', 'vtkBiQuadraticQuad', 'vtkTriQuadraticHexahedron', 'vtkQuadraticLinearQuad', 'vtkQuadraticLinearWedge', 'vtkBiQuadraticQuadraticWedge', 'vtkBiQuadraticQuadraticHexahedron', 'vtkBiQuadraticTriangle', 'vtkCubicLine', 'vtkQuadraticPolygon', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkConvexPointSet', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkParametricCurve', 'vtkParametricSurface', 'vtkParametricTriSurface', 'vtkParametricQuadSurface', 'vtkParametricTetraRegion', 'vtkParametricHexRegion', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkHigherOrderEdge', 'vtkHigherOrderTriangle', 'vtkHigherOrderQuad', 'vtkHigherOrderPolygon', 'vtkHigherOrderTetrahedron', 'vtkHigherOrderWedge', 'vtkHigherOrderPyramid', 'vtkHigherOrderHexahedron'];
 var Constants = {
-  CellType: CellType,
-  CellTypesStrings: CellTypesStrings
+  CellType,
+  CellTypesStrings
 };
 
 export { CellType, CellTypesStrings, Constants as default };