@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/Core/Cutter.js

@@ -1,187 +1,170 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { newInstance as newInstance$1, obj, algo, setGet, vtkErrorMacro as vtkErrorMacro$1, newTypedArrayFrom } from '../../macros.js';
+import { n as newInstance$1, o as obj, d as algo, e as setGet, c as macro, b as newTypedArrayFrom } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.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 = vtkErrorMacro$1;
-
+const {
+  vtkErrorMacro
+} = macro;
 function initPolyIterator(pd) {
-  var polys = pd.getPolys().getData();
-  var strips = pd.getStrips().getData();
-  var it = {
+  const polys = pd.getPolys().getData();
+  const strips = pd.getStrips().getData();
+  const it = {
     done: false,
     polyIdx: 0,
     stripIdx: 0,
     remainingStripLength: 0,
     // returns a single poly cell
-    next: function next() {
-      var ret = null;
-
+    next() {
+      let ret = null;
       if (it.polyIdx < polys.length) {
-        var cellSize = polys[it.polyIdx];
-        var start = it.polyIdx + 1;
-        var end = start + cellSize;
+        const cellSize = polys[it.polyIdx];
+        const start = it.polyIdx + 1;
+        const end = start + cellSize;
         it.polyIdx = end;
         ret = polys.subarray(start, end);
       } else if (it.stripIdx < strips.length) {
         if (it.remainingStripLength === 0) {
           it.remainingStripLength = strips[it.stripIdx] - 2; // sliding window of 3 points
           // stripIdx points to the last point in a triangle 3-tuple
-
           it.stripIdx += 3;
         }
-
-        var _start = it.stripIdx - 2;
-
-        var _end = it.stripIdx + 1;
-
+        const start = it.stripIdx - 2;
+        const end = it.stripIdx + 1;
         it.stripIdx++;
         it.remainingStripLength--;
-        ret = strips.subarray(_start, _end);
+        ret = strips.subarray(start, end);
       } else if (it.done) {
         throw new Error('Iterator is done');
       }
-
       it.done = it.polyIdx >= polys.length && it.stripIdx >= strips.length;
       return ret;
     }
   };
   return it;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkCutter methods
 // ----------------------------------------------------------------------------
 
-
 function vtkCutter(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkCutter'); // Capture "parentClass" api for internal use
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.getMTime = function () {
-    var mTime = superClass.getMTime();
+  model.classHierarchy.push('vtkCutter');
 
+  // Capture "parentClass" api for internal use
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.getMTime = () => {
+    let mTime = superClass.getMTime();
     if (!model.cutFunction) {
       return mTime;
     }
-
     mTime = Math.max(mTime, model.cutFunction.getMTime());
     return mTime;
   };
-
   function dataSetCutter(input, output) {
-    var points = input.getPoints();
-    var pointsData = points.getData();
-    var numPts = points.getNumberOfPoints();
-    var newPointsData = [];
-    var newLinesData = [];
-    var newPolysData = [];
-
+    const points = input.getPoints();
+    const pointsData = points.getData();
+    const numPts = points.getNumberOfPoints();
+    const newPointsData = [];
+    const newLinesData = [];
+    const newPolysData = [];
     if (!model.cutScalars || model.cutScalars.length < numPts) {
       model.cutScalars = new Float32Array(numPts);
-    } // Loop over all points evaluating scalar function at each point
-
-
-    var inOffset = 0;
-    var outOffset = 0;
+    }
 
+    // Loop over all points evaluating scalar function at each point
+    let inOffset = 0;
+    let outOffset = 0;
     while (inOffset < pointsData.length) {
       model.cutScalars[outOffset++] = model.cutFunction.evaluateFunction(pointsData[inOffset++], pointsData[inOffset++], pointsData[inOffset++]);
     }
-
-    var crossedEdges = [];
-    var x1 = new Array(3);
-    var x2 = new Array(3); // Loop over all cells; get scalar values for all cell points
+    const crossedEdges = [];
+    const x1 = new Array(3);
+    const x2 = new Array(3);
+    // Loop over all cells; get scalar values for all cell points
     // and process each cell.
-
     /* eslint-disable no-continue */
-
-    var it = initPolyIterator(input);
-
+    const it = initPolyIterator(input);
     while (!it.done) {
       // cell contains the point IDs/indices
-      var cell = it.next(); // Check that cells have at least 3 points
+      const cell = it.next();
 
+      // Check that cells have at least 3 points
       if (cell.length <= 2) {
         continue;
-      } // Get associated scalar of points that constitute the current cell
-
-
-      var cellPointsScalars = [];
-      var pointIndex = void 0;
+      }
 
-      for (var i = 0; i < cell.length; i++) {
+      // Get associated scalar of points that constitute the current cell
+      const cellPointsScalars = [];
+      let pointIndex;
+      for (let i = 0; i < cell.length; i++) {
         pointIndex = cell[i];
         cellPointsScalars.push(model.cutScalars[pointIndex]);
-      } // Check if all cell points are on same side (same side == cell not crossed by cut function)
-      // TODO: won't work if one point scalar is = 0 ?
-
-
-      var sideFirstPoint = cellPointsScalars[0] > 0;
-      var allPointsSameSide = true;
-
-      for (var _i = 1; _i < cellPointsScalars.length; _i++) {
-        var sideCurrentPoint = cellPointsScalars[_i] > 0;
+      }
 
+      // Check if all cell points are on same side (same side == cell not crossed by cut function)
+      // TODO: won't work if one point scalar is = 0 ?
+      const sideFirstPoint = cellPointsScalars[0] > 0;
+      let allPointsSameSide = true;
+      for (let i = 1; i < cellPointsScalars.length; i++) {
+        const sideCurrentPoint = cellPointsScalars[i] > 0;
         if (sideCurrentPoint !== sideFirstPoint) {
           allPointsSameSide = false;
           break;
         }
-      } // Go to next cell if cell is not crossed by cut function
-
+      }
 
+      // Go to next cell if cell is not crossed by cut function
       if (allPointsSameSide) {
         continue;
-      } // Find and compute edges which intersect cells
-
+      }
 
-      var intersectedEdgesList = [];
+      // Find and compute edges which intersect cells
+      const intersectedEdgesList = [];
+      for (let i = 0; i < cell.length; i++) {
+        const idNext = i + 1 === cell.length ? 0 : i + 1;
 
-      for (var _i2 = 0; _i2 < cell.length; _i2++) {
-        var idNext = _i2 + 1 === cell.length ? 0 : _i2 + 1; // Go to next edge if edge is not crossed
+        // Go to next edge if edge is not crossed
         // TODO: in most come cases, (numberOfPointsInCell - 1) or 0 edges of the cell
         // will be crossed, but if it crosses right at a point, it could be intersecting
         // with (numberOfPoints) or 1 edge(s). Do we account for that?
-
-        var signPoint0 = cellPointsScalars[_i2] > 0;
-        var signPoint1 = cellPointsScalars[idNext] > 0;
-
+        const signPoint0 = cellPointsScalars[i] > 0;
+        const signPoint1 = cellPointsScalars[idNext] > 0;
         if (signPoint1 === signPoint0) {
           continue;
-        } // Compute preferred interpolation direction
-
-
-        var e1 = _i2;
-        var e2 = idNext;
-        var deltaScalar = cellPointsScalars[e2] - cellPointsScalars[e1];
+        }
 
+        // Compute preferred interpolation direction
+        let e1 = i;
+        let e2 = idNext;
+        let deltaScalar = cellPointsScalars[e2] - cellPointsScalars[e1];
         if (deltaScalar <= 0) {
           e1 = idNext;
-          e2 = _i2;
+          e2 = i;
           deltaScalar *= -1;
-        } // linear interpolation
-
-
-        var t = 0.0;
+        }
 
+        // linear interpolation
+        let t = 0.0;
         if (deltaScalar !== 0.0) {
           t = (model.cutValue - cellPointsScalars[e1]) / deltaScalar;
-        } // points position
-
+        }
 
-        var pointID1 = cell[e1];
-        var pointID2 = cell[e2];
+        // points position
+        const pointID1 = cell[e1];
+        const pointID2 = cell[e2];
         x1[0] = pointsData[pointID1 * 3];
         x1[1] = pointsData[pointID1 * 3 + 1];
         x1[2] = pointsData[pointID1 * 3 + 2];
         x2[0] = pointsData[pointID2 * 3];
         x2[1] = pointsData[pointID2 * 3 + 1];
-        x2[2] = pointsData[pointID2 * 3 + 2]; // Compute the intersected point on edge
+        x2[2] = pointsData[pointID2 * 3 + 2];
 
-        var computedIntersectedPoint = [x1[0] + t * (x2[0] - x1[0]), x1[1] + t * (x2[1] - x1[1]), x1[2] + t * (x2[2] - x1[2])]; // Keep track of it
+        // Compute the intersected point on edge
+        const computedIntersectedPoint = [x1[0] + t * (x2[0] - x1[0]), x1[1] + t * (x2[1] - x1[1]), x1[2] + t * (x2[2] - x1[2])];
 
+        // Keep track of it
         intersectedEdgesList.push({
           pointEdge1: pointID1,
           // id of one point of the edge
@@ -190,112 +173,117 @@ function vtkCutter(publicAPI, model) {
           intersectedPoint: computedIntersectedPoint,
           // 3D coordinate of points that intersected edge
           newPointID: -1 // id of the intersected point when it will be added into vtkPoints
-
         });
-      } // Add points into newPointList
-
-
-      for (var _i3 = 0; _i3 < intersectedEdgesList.length; _i3++) {
-        var intersectedEdge = intersectedEdgesList[_i3];
-        var alreadyAdded = false; // Check if point/edge already added
-
-        for (var j = 0; j < crossedEdges.length; j++) {
-          var crossedEdge = crossedEdges[j];
-          var sameEdge = intersectedEdge.pointEdge1 === crossedEdge.pointEdge1 && intersectedEdge.pointEdge2 === crossedEdge.pointEdge2;
-          var samePoint = intersectedEdge.intersectedPoint[0] === crossedEdge.intersectedPoint[0] && intersectedEdge.intersectedPoint[1] === crossedEdge.intersectedPoint[1] && intersectedEdge.intersectedPoint[2] === crossedEdge.intersectedPoint[2];
+      }
 
+      // Add points into newPointList
+      for (let i = 0; i < intersectedEdgesList.length; i++) {
+        const intersectedEdge = intersectedEdgesList[i];
+        let alreadyAdded = false;
+        // Check if point/edge already added
+        for (let j = 0; j < crossedEdges.length; j++) {
+          const crossedEdge = crossedEdges[j];
+          const sameEdge = intersectedEdge.pointEdge1 === crossedEdge.pointEdge1 && intersectedEdge.pointEdge2 === crossedEdge.pointEdge2;
+          const samePoint = intersectedEdge.intersectedPoint[0] === crossedEdge.intersectedPoint[0] && intersectedEdge.intersectedPoint[1] === crossedEdge.intersectedPoint[1] && intersectedEdge.intersectedPoint[2] === crossedEdge.intersectedPoint[2];
           if (sameEdge || samePoint) {
             alreadyAdded = true;
-            intersectedEdgesList[_i3].newPointID = crossedEdges[j].newPointID;
+            intersectedEdgesList[i].newPointID = crossedEdges[j].newPointID;
             break;
           }
         }
-
         if (!alreadyAdded) {
           newPointsData.push(intersectedEdge.intersectedPoint[0]);
           newPointsData.push(intersectedEdge.intersectedPoint[1]);
           newPointsData.push(intersectedEdge.intersectedPoint[2]);
-          intersectedEdgesList[_i3].newPointID = newPointsData.length / 3 - 1;
-          crossedEdges.push(intersectedEdgesList[_i3]);
+          intersectedEdgesList[i].newPointID = newPointsData.length / 3 - 1;
+          crossedEdges.push(intersectedEdgesList[i]);
         }
-      } // Store cells
-
-
-      var cellSize = intersectedEdgesList.length;
+      }
 
+      // Store cells
+      const cellSize = intersectedEdgesList.length;
       if (cellSize === 2) {
         newLinesData.push(cellSize, intersectedEdgesList[0].newPointID, intersectedEdgesList[1].newPointID);
       } else if (cellSize > 2) {
         newPolysData.push(cellSize);
-        intersectedEdgesList.forEach(function (edge) {
+        intersectedEdgesList.forEach(edge => {
           newPolysData.push(edge.newPointID);
         });
       }
-    } // Set points
-
+    }
 
-    var outputPoints = output.getPoints();
-    outputPoints.setData(newTypedArrayFrom(points.getDataType(), newPointsData), 3); // Set lines
+    // Set points
+    const outputPoints = output.getPoints();
+    outputPoints.setData(newTypedArrayFrom(points.getDataType(), newPointsData), 3);
 
+    // Set lines
     if (newLinesData.length !== 0) {
       output.getLines().setData(Uint16Array.from(newLinesData));
-    } // Set polys
-
+    }
 
+    // Set polys
     if (newPolysData.length !== 0) {
       output.getPolys().setData(Uint16Array.from(newPolysData));
     }
-  } // expose requestData
-
+  }
 
-  publicAPI.requestData = function (inData, outData) {
+  // expose requestData
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0];
-
+    const input = inData[0];
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-
     if (!model.cutFunction) {
       vtkErrorMacro('Missing cut function');
       return;
     }
-
-    var output = vtkPolyData.newInstance();
+    const output = vtkPolyData.newInstance();
     dataSetCutter(input, output);
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   cutFunction: null,
   // support method with evaluateFunction method
   cutScalars: null,
   cutValue: 0.0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // Make this a VTK object
+  obj(publicAPI, model);
 
-  algo(publicAPI, model, 1, 1); // Set implicit function use to cut the input data (is vtkPlane)
+  // Also make it an algorithm with one input and one output
+  algo(publicAPI, model, 1, 1);
 
-  setGet(publicAPI, model, ['cutFunction', 'cutValue']); // Object specific methods
+  // Set implicit function use to cut the input data (is vtkPlane)
+  setGet(publicAPI, model, ['cutFunction', 'cutValue']);
 
+  // Object specific methods
   vtkCutter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend, 'vtkCutter'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend, 'vtkCutter');
+
+// ----------------------------------------------------------------------------
 
 var vtkCutter$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCutter$1 as default, extend, newInstance };

package/Filters/Core/PolyDataNormals.js

@@ -1,81 +1,66 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { f as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.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; }
+// ----------------------------------------------------------------------------
 // vtkPolyDataNormals methods
 // ----------------------------------------------------------------------------
 
 function vtkPolyDataNormals(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPolyDataNormals');
-
-  publicAPI.vtkPolyDataNormalsExecute = function (pointsData, polysData) {
+  publicAPI.vtkPolyDataNormalsExecute = (pointsData, polysData) => {
     if (!pointsData) {
       return null;
     }
-
-    var normalsData = new Float32Array(pointsData.length);
-    var numberOfPoints = 0;
-    var polysDataLength = polysData.length;
-    var cellPointIds = [0, 0, 0];
-
-    for (var c = 0; c < polysDataLength; c += numberOfPoints + 1) {
+    const normalsData = new Float32Array(pointsData.length);
+    let numberOfPoints = 0;
+    const polysDataLength = polysData.length;
+    const cellPointIds = [0, 0, 0];
+    for (let c = 0; c < polysDataLength; c += numberOfPoints + 1) {
       numberOfPoints = polysData[c];
-
       if (numberOfPoints < 3) {
         continue; // eslint-disable-line
       }
 
-      for (var i = 1; i <= 3; ++i) {
+      for (let i = 1; i <= 3; ++i) {
         cellPointIds[i - 1] = 3 * polysData[c + i];
       }
-
-      var cellNormal = [];
+      const cellNormal = [];
       vtkTriangle.computeNormal(pointsData.slice(cellPointIds[0], cellPointIds[0] + 3), pointsData.slice(cellPointIds[1], cellPointIds[1] + 3), pointsData.slice(cellPointIds[2], cellPointIds[2] + 3), cellNormal);
-
-      for (var _i = 1; _i <= numberOfPoints; ++_i) {
-        var pointId = 3 * polysData[c + _i];
+      for (let i = 1; i <= numberOfPoints; ++i) {
+        let pointId = 3 * polysData[c + i];
         normalsData[pointId] += cellNormal[0];
         normalsData[++pointId] += cellNormal[1];
         normalsData[++pointId] += cellNormal[2];
       }
     }
-    /* Normalize normals */
 
+    /* Normalize normals */
 
-    for (var _i2 = 0; _i2 < pointsData.length;) {
-      var pointNormal = normalsData.slice(_i2, _i2 + 3);
+    for (let i = 0; i < pointsData.length;) {
+      const pointNormal = normalsData.slice(i, i + 3);
       vtkMath.normalize(pointNormal);
-      normalsData[_i2++] = pointNormal[0];
-      normalsData[_i2++] = pointNormal[1];
-      normalsData[_i2++] = pointNormal[2];
+      normalsData[i++] = pointNormal[0];
+      normalsData[i++] = pointNormal[1];
+      normalsData[i++] = pointNormal[2];
     }
-
     return normalsData;
   };
-
-  publicAPI.requestData = function (inData, outData) {
-    var numberOfInputs = publicAPI.getNumberOfInputPorts();
-
+  publicAPI.requestData = (inData, outData) => {
+    const numberOfInputs = publicAPI.getNumberOfInputPorts();
     if (!numberOfInputs) {
       return;
     }
-
-    var input = inData[0];
-
+    const input = inData[0];
     if (!input) {
       return;
     }
-
-    var outputNormalsData = publicAPI.vtkPolyDataNormalsExecute(input.getPoints().getData(), input.getPolys().getData());
-    var output = vtkPolyData.newInstance();
-    var outputNormals = vtkDataArray.newInstance({
+    const outputNormalsData = publicAPI.vtkPolyDataNormalsExecute(input.getPoints().getData(), input.getPolys().getData());
+    const output = vtkPolyData.newInstance();
+    const outputNormals = vtkDataArray.newInstance({
       numberOfComponents: 3,
       values: outputNormalsData
     });
@@ -90,35 +75,44 @@ function vtkPolyDataNormals(publicAPI, model) {
     output.getPointData().setNormals(outputNormals);
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
 function defaultValues(initialValues) {
-  return _objectSpread({}, initialValues);
-} // ----------------------------------------------------------------------------
-
+  return {
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 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, defaultValues(initialValues));
+
   /* Make this a VTK object */
 
   macro.obj(publicAPI, model);
+
   /* Also make it an algorithm with one input and one output */
 
   macro.algo(publicAPI, model, 1, 1);
+
   /* Object specific methods */
 
   vtkPolyDataNormals(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkPolyDataNormals'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPolyDataNormals');
+
+// ----------------------------------------------------------------------------
 
 var vtkPolyDataNormals$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPolyDataNormals$1 as default, extend, newInstance };

package/Filters/Core.js

@@ -2,8 +2,8 @@ import vtkCutter from './Core/Cutter.js';
 import vtkPolyDataNormals from './Core/PolyDataNormals.js';
 
 var Core = {
-  vtkCutter: vtkCutter,
-  vtkPolyDataNormals: vtkPolyDataNormals
+  vtkCutter,
+  vtkPolyDataNormals
 };
 
 export { Core as default };