@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/General/ClipClosedSurface.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, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
@@ -12,22 +10,18 @@ import vtkContourTriangulator from './ContourTriangulator.js';
 import vtkEdgeLocator from '../../Common/DataModel/EdgeLocator.js';
 import Constants from './ClipClosedSurface/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,
-    capitalize = macro.capitalize;
-var ScalarMode = Constants.ScalarMode;
-
+const {
+  vtkErrorMacro,
+  capitalize
+} = macro;
+const {
+  ScalarMode
+} = Constants;
 function vtkClipClosedSurface(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkClipClosedSurface');
+  publicAPI.getMTime = () => model.clippingPlanes.reduce((a, b) => b.getMTime() > a ? b.getMTime() : a, model.mtime);
 
-  publicAPI.getMTime = function () {
-    return model.clippingPlanes.reduce(function (a, b) {
-      return b.getMTime() > a ? b.getMTime() : a;
-    }, model.mtime);
-  };
   /**
    * Take three colors as doubles, and convert to unsigned char.
    *
@@ -36,21 +30,16 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {Number} color3
    * @param {Number[3][3]} colors
    */
-
-
   function createColorValues(color1, color2, color3, colors) {
-    var dcolors = [color1, color2, color3];
-
-    var clamp = function clamp(n, min, max) {
-      return Math.min(Math.max(n, min), max);
-    };
-
-    for (var i = 0; i < 3; i++) {
-      for (var j = 0; j < 3; j++) {
+    const dcolors = [color1, color2, color3];
+    const clamp = (n, min, max) => Math.min(Math.max(n, min), max);
+    for (let i = 0; i < 3; i++) {
+      for (let j = 0; j < 3; j++) {
         colors[i][j] = Math.round(clamp(dcolors[i][j], 0, 1) * 255);
       }
     }
   }
+
   /**
    * Point interpolation for clipping and contouring, given the scalar
    * values (v0, v1) for the two endpoints (p0, p1).  The use of this
@@ -67,52 +56,46 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {Number} i
    * @returns {Number}
    */
-
-
   function interpolateEdge(points, pointData, locator, tol, i0, i1, v0, v1) {
     // This swap guarantees that exactly the same point is computed
     // for both line directions, as long as the endpoints are the same.
     if (v1 > 0) {
       // eslint-disable-next-line no-param-reassign
-      var _ref = [i1, i0];
-      i0 = _ref[0];
-      i1 = _ref[1];
-      var _ref2 = [v1, v0];
-      v0 = _ref2[0];
-      v1 = _ref2[1];
-    } // After the above swap, i0 will be kept, and i1 will be clipped
-    // Check to see if this point has already been computed
-
-
-    var edge = locator.insertUniqueEdge(i0, i1);
+      [i0, i1] = [i1, i0];
+      // eslint-disable-next-line no-param-reassign
+      [v0, v1] = [v1, v0];
+    }
+    // After the above swap, i0 will be kept, and i1 will be clipped
 
+    // Check to see if this point has already been computed
+    const edge = locator.insertUniqueEdge(i0, i1);
     if (edge.value != null) {
       return edge.value;
-    } // Get the edge and interpolate the new point
-
+    }
 
-    var p0 = points.getPoint(i0);
-    var p1 = points.getPoint(i1);
-    var f = v0 / (v0 - v1);
-    var s = 1.0 - f;
-    var t = 1.0 - s;
-    var p = [s * p0[0] + t * p1[0], s * p0[1] + t * p1[1], s * p0[2] + t * p1[2]];
-    var tol2 = tol * tol; // Make sure that new point is far enough from kept point
+    // Get the edge and interpolate the new point
+    const p0 = points.getPoint(i0);
+    const p1 = points.getPoint(i1);
+    const f = v0 / (v0 - v1);
+    const s = 1.0 - f;
+    const t = 1.0 - s;
+    const p = [s * p0[0] + t * p1[0], s * p0[1] + t * p1[1], s * p0[2] + t * p1[2]];
+    const tol2 = tol * tol;
 
+    // Make sure that new point is far enough from kept point
     if (distance2BetweenPoints(p, p0) < tol2) {
       edge.value = i0;
       return i0;
     }
-
     if (distance2BetweenPoints(p, p1) < tol2) {
       edge.value = i1;
       return i1;
     }
-
     edge.value = points.insertNextTuple(p);
     pointData.interpolateData(pointData, i0, i1, edge.value, t);
     return edge.value;
   }
+
   /**
    * Method for clipping lines and copying the scalar data.
    *
@@ -125,52 +108,50 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkDataSetAttributes} inLineData
    * @param {vtkDataSetAttributes} outLineData
    */
-
-
   function clipLines(points, pointScalars, pointData, edgeLocator, inputLines, outputLines, inLineData, outLineData) {
-    var numPts;
-    var i0;
-    var i1;
-    var v0;
-    var v1;
-    var c0;
-    var c1;
-    var linePts = [];
-    var values = inputLines.getData();
-    var cellId = 0;
-
-    for (var i = 0; i < values.length; i += numPts + 1, cellId++) {
+    let numPts;
+    let i0;
+    let i1;
+    let v0;
+    let v1;
+    let c0;
+    let c1;
+    const linePts = [];
+    const values = inputLines.getData();
+    let cellId = 0;
+    for (let i = 0; i < values.length; i += numPts + 1, cellId++) {
       numPts = values[i];
       i1 = values[i + 1];
       v1 = pointScalars.getData()[i1];
       c1 = v1 > 0;
-
-      for (var j = 2; j <= numPts; j++) {
+      for (let j = 2; j <= numPts; j++) {
         i0 = i1;
         v0 = v1;
         c0 = c1;
         i1 = values[i + j];
         v1 = pointScalars.getData()[i1];
-        c1 = v1 > 0; // If at least one point wasn't clipped
+        c1 = v1 > 0;
 
+        // If at least one point wasn't clipped
         if (c0 || c1) {
           // If only one end was clipped, interpolate new point
           if (c0 ? !c1 : c1) {
             linePts[c0 ? 1 : 0] = interpolateEdge(points, pointData, edgeLocator, model.tolerance, i0, i1, v0, v1);
-          } // If endpoints are different, insert the line segment
-
+          }
 
+          // If endpoints are different, insert the line segment
           if (i0 !== i1) {
             linePts[0] = i0;
             linePts[1] = i1;
-            var newCellId = outputLines.insertNextCell(linePts); // outLineData.copyData(inLineData, cellId, newCellId);
-
+            const newCellId = outputLines.insertNextCell(linePts);
+            // outLineData.copyData(inLineData, cellId, newCellId);
             outLineData.passData(inLineData, cellId, newCellId);
           }
         }
       }
     }
   }
+
   /**
    * Break polylines into individual lines, copying scalar values from
    * inputScalars starting at firstLineScalar.  If inputScalars is zero,
@@ -184,31 +165,25 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkDataArray} scalars
    * @param {Vector3} color
    */
-
-
   function breakPolylines(inputLines, outputLines, inputScalars, firstLineScalar, scalars, color) {
-    var cellColor = _toConsumableArray(color);
-
-    var cellId = 0;
-    var values = inputLines.getData();
-    var numPts;
-
-    for (var i = 0; i < values.length; i += numPts + 1) {
+    const cellColor = [...color];
+    let cellId = 0;
+    const values = inputLines.getData();
+    let numPts;
+    for (let i = 0; i < values.length; i += numPts + 1) {
       numPts = values[i];
-
       if (inputScalars) {
         inputScalars.getTuple(firstLineScalar + cellId++, cellColor);
       }
-
-      for (var j = 1; j < numPts; j++) {
+      for (let j = 1; j < numPts; j++) {
         outputLines.insertNextCell([values[i + j], values[i + j + 1]]);
-
         if (scalars) {
           scalars.insertNextTuple(cellColor);
         }
       }
     }
   }
+
   /**
    * Copy polygons and their associated scalars to a new array.
    * If inputScalars is set to zero, set polyScalars to color instead.
@@ -221,84 +196,68 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkDataArray} polyScalars
    * @param {Vector3} color
    */
-
-
   function copyPolygons(inputPolys, outputPolys, inputScalars, firstPolyScalar, polyScalars, color) {
     if (!inputPolys) {
       return;
     }
-
     outputPolys.deepCopy(inputPolys);
-
     if (polyScalars) {
-      var scalarValue = _toConsumableArray(color);
-
-      var n = outputPolys.getNumberOfCells();
+      const scalarValue = [...color];
+      const n = outputPolys.getNumberOfCells();
       polyScalars.insertTuple(n - 1, scalarValue);
-
       if (inputScalars) {
-        for (var i = 0; i < n; i++) {
+        for (let i = 0; i < n; i++) {
           inputScalars.getTuple(i + firstPolyScalar, scalarValue);
           polyScalars.setTuple(i, scalarValue);
         }
       } else {
-        for (var _i = 0; _i < n; _i++) {
-          polyScalars.setTuple(_i, scalarValue);
+        for (let i = 0; i < n; i++) {
+          polyScalars.setTuple(i, scalarValue);
         }
       }
     }
   }
-
   function breakTriangleStrips(inputStrips, polys, inputScalars, firstStripScalar, polyScalars, color) {
     if (inputStrips.getNumberOfCells() === 0) {
       return;
     }
-
-    var values = inputStrips.getData();
-    var cellId = firstStripScalar;
-    var numPts;
-
-    for (var i = 0; i < values.length; i += numPts + 1, cellId++) {
-      numPts = values[i]; // vtkTriangleStrip.decomposeStrip(numPts, values, polys);
-
-      var p1 = values[i + 1];
-      var p2 = values[i + 2];
-
-      for (var j = 0; j < numPts - 2; j++) {
-        var p3 = values[i + j + 3];
-
+    const values = inputStrips.getData();
+    let cellId = firstStripScalar;
+    let numPts;
+    for (let i = 0; i < values.length; i += numPts + 1, cellId++) {
+      numPts = values[i];
+      // vtkTriangleStrip.decomposeStrip(numPts, values, polys);
+      let p1 = values[i + 1];
+      let p2 = values[i + 2];
+      for (let j = 0; j < numPts - 2; j++) {
+        const p3 = values[i + j + 3];
         if (j % 2) {
           polys.insertNextCell([p2, p1, p3]);
         } else {
           polys.insertNextCell([p1, p2, p3]);
         }
-
         p1 = p2;
         p2 = p3;
       }
-
       if (polyScalars) {
-        var scalarValue = _toConsumableArray(color);
-
+        const scalarValue = [...color];
         if (inputScalars) {
           // If there are input scalars, use them instead of "color"
           inputScalars.getTuple(cellId, scalarValue);
         }
-
-        var n = numPts - 3;
-        var m = polyScalars.getNumberOfTuples();
-
+        const n = numPts - 3;
+        const m = polyScalars.getNumberOfTuples();
         if (n >= 0) {
           // First insert is just to allocate space
           polyScalars.insertTuple(m + n, scalarValue);
-
-          for (var k = 0; k < n; k++) {
+          for (let k = 0; k < n; k++) {
             polyScalars.setTuple(m + k, scalarValue);
           }
         }
       }
     }
   }
+
   /**
    * Given some closed contour lines, create a triangle mesh that
    * fills those lines.  The input lines must be single-segment lines,
@@ -314,20 +273,17 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkCellArray} outputPolys
    * @param {Vector3} normal
    */
-
-
   function triangulateContours(polyData, firstLine, numLines, outputPolys, normal) {
     // If no cut lines were generated, there's nothing to do
     if (numLines <= 0) {
       return;
     }
-
-    var triangulationError = !vtkContourTriangulator.triangulateContours(polyData, firstLine, numLines, outputPolys, [-normal[0], -normal[1], -normal[2]]);
-
+    const triangulationError = !vtkContourTriangulator.triangulateContours(polyData, firstLine, numLines, outputPolys, [-normal[0], -normal[1], -normal[2]]);
     if (triangulationError && model.triangulationErrorDisplay) {
       vtkErrorMacro('Triangulation failed, polyData may not be watertight.');
     }
   }
+
   /**
    * Break polylines into individual lines, copying scalar values from
    * inputScalars starting at firstLineScalar. If inputScalars is zero,
@@ -339,11 +295,10 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkCellArray} triangles
    * @returns {Boolean}
    */
-
-
   function triangulatePolygon(polygon, points, triangles) {
     return vtkContourTriangulator.triangulatePolygon(polygon, points, triangles);
   }
+
   /**
    * Clip and contour polys in one step, in order to guarantee
    * that the contour lines exactly match the new free edges of
@@ -362,13 +317,10 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkDataSetAttributes} outPolyData
    * @param {vtkDataSetAttributes} outLineData
    */
-
-
   function clipAndContourPolys(points, pointScalars, pointData, edgeLocator, triangulate, inputPolys, outputPolys, outputLines, inCellData, outPolyData, outLineData) {
-    var idList = model._idList; // How many sides for output polygons?
-
-    var polyMax = Number.MAX_VALUE;
-
+    const idList = model._idList;
+    // How many sides for output polygons?
+    let polyMax = Number.MAX_VALUE;
     if (triangulate) {
       if (triangulate < 4) {
         // triangles only
@@ -377,103 +329,98 @@ function vtkClipClosedSurface(publicAPI, model) {
         // allow triangles and quads
         polyMax = 4;
       }
-    } // eslint-disable-next-line prefer-const
-
-
-    var triangulationFailure = false; // Go through all cells and clip them
+    }
 
-    var values = inputPolys.getData();
-    var linePts = [];
-    var cellId = 0;
-    var numPts;
+    // eslint-disable-next-line prefer-const
+    let triangulationFailure = false;
 
-    for (var i = 0; i < values.length; i += numPts + 1, cellId++) {
+    // Go through all cells and clip them
+    const values = inputPolys.getData();
+    const linePts = [];
+    let cellId = 0;
+    let numPts;
+    for (let i = 0; i < values.length; i += numPts + 1, cellId++) {
       numPts = values[i];
-      var i1 = values[i + numPts];
-      var v1 = pointScalars.getData()[i1];
-      var c1 = v1 > 0; // The ids for the current edge: init j0 to -1 if i1 will be clipped
+      let i1 = values[i + numPts];
+      let v1 = pointScalars.getData()[i1];
+      let c1 = v1 > 0;
 
-      var j0 = c1 ? i1 : -1;
-      var j1 = 0; // To store the ids of the contour line
+      // The ids for the current edge: init j0 to -1 if i1 will be clipped
+      let j0 = c1 ? i1 : -1;
+      let j1 = 0;
 
+      // To store the ids of the contour line
       linePts[0] = 0;
       linePts[1] = 0;
-      var idListIdx = 0;
-
-      for (var j = 1; j <= numPts; j++) {
+      let idListIdx = 0;
+      for (let j = 1; j <= numPts; j++) {
         // Save previous point info
-        var i0 = i1;
-        var v0 = v1;
-        var c0 = c1; // Generate new point info
+        const i0 = i1;
+        const v0 = v1;
+        const c0 = c1;
 
+        // Generate new point info
         i1 = values[i + j];
         v1 = pointScalars.getData()[i1];
-        c1 = v1 > 0; // If at least one edge end point wasn't clipped
+        c1 = v1 > 0;
 
+        // If at least one edge end point wasn't clipped
         if (c0 || c1) {
           // If only one end was clipped, interpolate new point
           if (c0 ? !c1 : c1) {
             j1 = interpolateEdge(points, pointData, edgeLocator, model.tolerance, i0, i1, v0, v1);
-
             if (j1 !== j0) {
               idList[idListIdx++] = j1;
               j0 = j1;
-            } // Save as one end of the contour line
-
+            }
 
+            // Save as one end of the contour line
             linePts[c0 ? 1 : 0] = j1;
           }
-
           if (c1) {
             j1 = i1;
-
             if (j1 !== j0) {
               idList[idListIdx++] = j1;
               j0 = j1;
             }
           }
         }
-      } // Insert the clipped poly
-
+      }
 
-      var numPoints = idListIdx;
+      // Insert the clipped poly
+      const numPoints = idListIdx;
       idList.length = numPoints;
-
       if (model.triangulatePolys && numPoints > polyMax) {
         // TODO: Support triangulatePolygon
-        var newCellId = outputPolys.getNumberOfCells(); // Triangulate the poly and insert triangles into output.
-
-        var success = triangulatePolygon(idList, points, outputPolys);
-
+        let newCellId = outputPolys.getNumberOfCells();
+        // Triangulate the poly and insert triangles into output.
+        const success = triangulatePolygon(idList, points, outputPolys);
         if (!success) {
           triangulationFailure = true;
-        } // Copy the attribute data to the triangle cells
-
-
-        var ncells = outputPolys.getNumberOfCells();
+        }
 
+        // Copy the attribute data to the triangle cells
+        const ncells = outputPolys.getNumberOfCells();
         for (; newCellId < ncells; newCellId++) {
           outPolyData.passData(inCellData, cellId, newCellId);
         }
       } else if (numPoints > 2) {
         // Insert the polygon without triangulating it
-        var _newCellId = outputPolys.insertNextCell(idList);
-
-        outPolyData.passData(inCellData, cellId, _newCellId);
-      } // Insert the contour line if one was created
-
+        const newCellId = outputPolys.insertNextCell(idList);
+        outPolyData.passData(inCellData, cellId, newCellId);
+      }
 
+      // Insert the contour line if one was created
       if (linePts[0] !== linePts[1]) {
-        var _newCellId2 = outputLines.insertNextCell(linePts);
-
-        outLineData.passData(inCellData, cellId, _newCellId2);
+        const newCellId = outputLines.insertNextCell(linePts);
+        outLineData.passData(inCellData, cellId, newCellId);
       }
     }
-
     if (triangulationFailure && model.triangulationErrorDisplay) {
       vtkErrorMacro('Triangulation failed, output may not be watertight');
     }
   }
+
   /**
    * Squeeze the points and store them in the output.  Only the points that
    * are used by the cells will be saved, and the pointIds of the cells will
@@ -484,71 +431,64 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkDataSetAttributes} pointData
    * @param {String} outputPointDataType
    */
-
-
   function squeezeOutputPoints(output, points, pointData, outputPointDataType) {
     // Create a list of points used by cells
-    var n = points.getNumberOfPoints();
-    var numNewPoints = 0;
-    var outPointData = output.getPointData();
-    var pointMap = [];
+    const n = points.getNumberOfPoints();
+    let numNewPoints = 0;
+    const outPointData = output.getPointData();
+    const pointMap = [];
     pointMap.length = n;
-    var cellArrays = [output.getVerts(), output.getLines(), output.getPolys(), output.getStrips()]; // Find all the newPoints that are used by cells
+    const cellArrays = [output.getVerts(), output.getLines(), output.getPolys(), output.getStrips()];
 
-    cellArrays.forEach(function (cellArray) {
+    // Find all the newPoints that are used by cells
+    cellArrays.forEach(cellArray => {
       if (!cellArray) {
         return;
       }
-
-      var values = cellArray.getData();
-      var numPts;
-      var pointId;
-
-      for (var i = 0; i < values.length; i += numPts + 1) {
+      const values = cellArray.getData();
+      let numPts;
+      let pointId;
+      for (let i = 0; i < values.length; i += numPts + 1) {
         numPts = values[i];
-
-        for (var j = 1; j <= numPts; j++) {
+        for (let j = 1; j <= numPts; j++) {
           pointId = values[i + j];
-
           if (pointMap[pointId] === undefined) {
             pointMap[pointId] = numNewPoints++;
           }
         }
       }
-    }); // Create exactly the number of points that are required
+    });
 
-    var newPoints = vtkPoints.newInstance({
+    // Create exactly the number of points that are required
+    const newPoints = vtkPoints.newInstance({
       size: numNewPoints * 3,
       dataType: outputPointDataType
-    }); // outPointData.copyAllocate(pointData, numNewPoints, 0);
-
-    var p = [];
-    var newPointId;
+    });
+    // outPointData.copyAllocate(pointData, numNewPoints, 0);
 
-    for (var pointId = 0; pointId < n; pointId++) {
+    const p = [];
+    let newPointId;
+    for (let pointId = 0; pointId < n; pointId++) {
       newPointId = pointMap[pointId];
-
       if (newPointId !== undefined) {
         points.getPoint(pointId, p);
         newPoints.setTuple(newPointId, p);
-        outPointData.passData(pointData, pointId, newPointId); // outPointData.copyData(pointData, pointId, newPointId);
+        outPointData.passData(pointData, pointId, newPointId);
+        // outPointData.copyData(pointData, pointId, newPointId);
       }
-    } // Change the cell pointIds to reflect the new point array
-
+    }
 
-    cellArrays.forEach(function (cellArray) {
+    // Change the cell pointIds to reflect the new point array
+    cellArrays.forEach(cellArray => {
       if (!cellArray) {
         return;
       }
-
-      var values = cellArray.getData();
-      var numPts;
-      var pointId;
-
-      for (var i = 0; i < values.length; i += numPts + 1) {
+      const values = cellArray.getData();
+      let numPts;
+      let pointId;
+      for (let i = 0; i < values.length; i += numPts + 1) {
         numPts = values[i];
-
-        for (var j = 1; j <= numPts; j++) {
+        for (let j = 1; j <= numPts; j++) {
           pointId = values[i + j];
           values[i + j] = pointMap[pointId];
         }
@@ -556,76 +496,71 @@ function vtkClipClosedSurface(publicAPI, model) {
     });
     output.setPoints(newPoints);
   }
-
-  publicAPI.requestData = function (inData, outData) {
-    var _input$getVerts, _input$getStrips;
-
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0];
-    var output = vtkPolyData.newInstance();
+    const input = inData[0];
+    const output = vtkPolyData.newInstance();
     outData[0] = output;
-
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-
     if (model._idList == null) {
       model._idList = [];
     } else {
       model._idList.length = 0;
-    } // Get the input points
-
-
-    var inputPoints = input.getPoints();
-    var numPts = 0;
-    var inputPointsType = VtkDataTypes.FLOAT;
+    }
 
+    // Get the input points
+    const inputPoints = input.getPoints();
+    let numPts = 0;
+    let inputPointsType = VtkDataTypes.FLOAT;
     if (inputPoints) {
       numPts = inputPoints.getNumberOfPoints();
       inputPointsType = inputPoints.getDataType();
-    } // Force points to double precision, copy the point attributes
-
+    }
 
-    var points = vtkPoints.newInstance({
+    // Force points to double precision, copy the point attributes
+    const points = vtkPoints.newInstance({
       size: numPts * 3,
       dataType: VtkDataTypes.DOUBLE
     });
-    var pointData = vtkDataSetAttributes.newInstance();
-    var inPointData = null;
-
+    const pointData = vtkDataSetAttributes.newInstance();
+    let inPointData = null;
     if (model.passPointData) {
-      inPointData = input.getPointData(); // pointData.interpolateAllocate(inPointData, numPts, 0);
+      inPointData = input.getPointData();
+      // pointData.interpolateAllocate(inPointData, numPts, 0);
     }
 
-    var point = [];
-
-    for (var ptId = 0; ptId < numPts; ptId++) {
+    const point = [];
+    for (let ptId = 0; ptId < numPts; ptId++) {
       inputPoints.getPoint(ptId, point);
       points.setTuple(ptId, point);
-
       if (inPointData) {
         // pointData.copyData(inPointData, ptId, ptId);
         pointData.passData(inPointData, ptId, ptId);
       }
-    } // An edge locator to avoid point duplication while clipping
-
-
-    var edgeLocator = vtkEdgeLocator.newInstance(); // A temporary polydata for the contour lines that are triangulated
+    }
 
-    var tmpContourData = vtkPolyData.newInstance(); // The cell scalars
+    // An edge locator to avoid point duplication while clipping
+    const edgeLocator = vtkEdgeLocator.newInstance();
 
-    var lineScalars;
-    var polyScalars;
-    var inputScalars; // For input scalars: the offsets to the various cell types
+    // A temporary polydata for the contour lines that are triangulated
+    const tmpContourData = vtkPolyData.newInstance();
 
-    var firstLineScalar = 0;
-    var firstPolyScalar = 0;
-    var firstStripScalar = 0; // Make the colors to be used on the data
+    // The cell scalars
+    let lineScalars;
+    let polyScalars;
+    let inputScalars;
 
-    var numberOfScalarComponents = 1;
-    var colors = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+    // For input scalars: the offsets to the various cell types
+    let firstLineScalar = 0;
+    let firstPolyScalar = 0;
+    let firstStripScalar = 0;
 
+    // Make the colors to be used on the data
+    let numberOfScalarComponents = 1;
+    const colors = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
     if (model.scalarMode === ScalarMode.COLORS) {
       numberOfScalarComponents = 3;
       createColorValues(model.baseColor, model.clipColor, model.activePlaneColor, colors);
@@ -633,18 +568,17 @@ function vtkClipClosedSurface(publicAPI, model) {
       colors[0][0] = 0;
       colors[1][0] = 1;
       colors[2][0] = 2;
-    } // This is set if we have to work with scalars. The input scalars
+    }
+
+    // This is set if we have to work with scalars. The input scalars
     // will be copied if they are unsigned char with 3 components, otherwise
     // new scalars will be generated.
-
-
-    var numVerts = ((_input$getVerts = input.getVerts()) === null || _input$getVerts === void 0 ? void 0 : _input$getVerts.getNumberOfCells()) || 0;
-    var inputLines = input.getLines();
-    var numLines = (inputLines === null || inputLines === void 0 ? void 0 : inputLines.getNumberOfCells()) || 0;
-    var inputPolys = input.getPolys();
-    var numPolys = (inputPolys === null || inputPolys === void 0 ? void 0 : inputPolys.getNumberOfCells()) || 0;
-    var numStrips = ((_input$getStrips = input.getStrips()) === null || _input$getStrips === void 0 ? void 0 : _input$getStrips.getNumberOfCells()) || 0;
-
+    const numVerts = input.getVerts()?.getNumberOfCells() || 0;
+    const inputLines = input.getLines();
+    const numLines = inputLines?.getNumberOfCells() || 0;
+    const inputPolys = input.getPolys();
+    const numPolys = inputPolys?.getNumberOfCells() || 0;
+    const numStrips = input.getStrips()?.getNumberOfCells() || 0;
     if (model.scalarMode !== ScalarMode.NONE) {
       lineScalars = vtkDataArray.newInstance({
         dataType: VtkDataTypes.UNSIGNED_CHAR,
@@ -653,19 +587,18 @@ function vtkClipClosedSurface(publicAPI, model) {
         // values: new Uint8Array(numLines * 3),
         numberOfComponents: numberOfScalarComponents
       });
-      var tryInputScalars = input.getCellData().getScalars(); // Get input scalars if they are RGB color scalars
-
+      const tryInputScalars = input.getCellData().getScalars();
+      // Get input scalars if they are RGB color scalars
       if (tryInputScalars && tryInputScalars.getDataType() === VtkDataTypes.UNSIGNED_CHAR && numberOfScalarComponents === 3 && tryInputScalars.getNumberOfComponents() === 3) {
         inputScalars = input.getCellData().getScalars();
         firstLineScalar = numVerts;
         firstPolyScalar = numVerts + numLines;
         firstStripScalar = numVerts + numLines + numPolys;
       }
-    } // Break the input lines into segments, generate scalars for lines
-
-
-    var lines;
+    }
 
+    // Break the input lines into segments, generate scalars for lines
+    let lines;
     if (numLines > 0) {
       lines = vtkCellArray.newInstance({
         dataType: inputLines.getDataType(),
@@ -679,10 +612,8 @@ function vtkClipClosedSurface(publicAPI, model) {
         empty: true
       });
     }
-
-    var polys = null;
-    var polyMax = 3;
-
+    let polys = null;
+    let polyMax = 3;
     if (numPolys > 0 || numStrips > 0) {
       // If there are line scalars, then poly scalars are needed too
       if (lineScalars) {
@@ -694,204 +625,188 @@ function vtkClipClosedSurface(publicAPI, model) {
           numberOfComponents: numberOfScalarComponents
         });
       }
-
       polys = vtkCellArray.newInstance();
-      copyPolygons(inputPolys, polys, inputScalars, firstPolyScalar, polyScalars, colors[0]); // TODO: Support triangle strips
-
-      breakTriangleStrips(input.getStrips(), polys, inputScalars, firstStripScalar, polyScalars, colors[0]); // Check if the input has polys and quads or just triangles
-
-      polyMax = inputPolys.getCellSizes().reduce(function (a, b) {
-        return a > b ? a : b;
-      }, 0);
-    } // Arrays for storing the clipped lines and polys
+      copyPolygons(inputPolys, polys, inputScalars, firstPolyScalar, polyScalars, colors[0]);
+      // TODO: Support triangle strips
+      breakTriangleStrips(input.getStrips(), polys, inputScalars, firstStripScalar, polyScalars, colors[0]);
 
+      // Check if the input has polys and quads or just triangles
+      polyMax = inputPolys.getCellSizes().reduce((a, b) => a > b ? a : b, 0);
+    }
 
-    var newLines = vtkCellArray.newInstance({
+    // Arrays for storing the clipped lines and polys
+    let newLines = vtkCellArray.newInstance({
       dataType: lines.getDataType(),
       empty: true
     });
-    var newPolys = null;
-
+    let newPolys = null;
     if (polys) {
       newPolys = vtkCellArray.newInstance({
         dataType: polys.getDataType(),
         empty: true
       });
-    } // The line scalars, for coloring the outline
-
+    }
 
-    var inLineData = vtkDataSetAttributes.newInstance();
+    // The line scalars, for coloring the outline
+    let inLineData = vtkDataSetAttributes.newInstance();
     inLineData.copyScalarsOn();
-    inLineData.setScalars(lineScalars); // The poly scalars, for coloring the faces
+    inLineData.setScalars(lineScalars);
 
-    var inPolyData = vtkDataSetAttributes.newInstance();
+    // The poly scalars, for coloring the faces
+    let inPolyData = vtkDataSetAttributes.newInstance();
     inPolyData.copyScalarsOn();
-    inPolyData.setScalars(polyScalars); // Also create output attribute data
+    inPolyData.setScalars(polyScalars);
 
-    var outLineData = vtkDataSetAttributes.newInstance();
+    // Also create output attribute data
+    let outLineData = vtkDataSetAttributes.newInstance();
     outLineData.copyScalarsOn();
-    var outPolyData = vtkDataSetAttributes.newInstance();
+    let outPolyData = vtkDataSetAttributes.newInstance();
     outPolyData.copyScalarsOn();
-    var planes = model.clippingPlanes; // Go through the clipping planes and clip the input with each plane
-
-    for (var planeId = 0; planeId < planes.length; planeId++) {
-      var plane = planes[planeId];
-      var triangulate = 5;
+    const planes = model.clippingPlanes;
 
+    // Go through the clipping planes and clip the input with each plane
+    for (let planeId = 0; planeId < planes.length; planeId++) {
+      const plane = planes[planeId];
+      let triangulate = 5;
       if (planeId === planes.length - 1) {
         triangulate = polyMax;
       }
+      const active = planeId === model.activePlaneId;
 
-      var active = planeId === model.activePlaneId; // Convert the plane into an easy-to-evaluate function
-
-      var pc = plane.getNormal(); // OK to modify pc because vtkPlane.getNormal() returns a copy
+      // Convert the plane into an easy-to-evaluate function
+      const pc = plane.getNormal();
+      // OK to modify pc because vtkPlane.getNormal() returns a copy
+      pc[3] = -dot(pc, plane.getOrigin());
 
-      pc[3] = -dot(pc, plane.getOrigin()); // Create the clip scalars by evaluating the plane at each point
+      // Create the clip scalars by evaluating the plane at each point
+      const numPoints = points.getNumberOfPoints();
 
-      var numPoints = points.getNumberOfPoints(); // The point scalars, needed for clipping (not for the output!)
-
-      var pointScalars = vtkDataArray.newInstance({
+      // The point scalars, needed for clipping (not for the output!)
+      const pointScalars = vtkDataArray.newInstance({
         dataType: VtkDataTypes.DOUBLE,
         size: numPoints
       });
-      var pointScalarsData = pointScalars.getData();
-      var pointsData = points.getData();
-      var i = 0;
-
-      for (var pointId = 0; pointId < numPoints; pointId) {
+      const pointScalarsData = pointScalars.getData();
+      const pointsData = points.getData();
+      let i = 0;
+      for (let pointId = 0; pointId < numPoints; pointId) {
         pointScalarsData[pointId++] = pointsData[i++] * pc[0] + pointsData[i++] * pc[1] + pointsData[i++] * pc[2] + pc[3];
-      } // Prepare the output scalars
+      }
+
+      // Prepare the output scalars
       // outLineData.copyAllocate(inLineData, 0, 0);
       // outPolyData.copyAllocate(inPolyData, 0, 0);
-      // Reset the locator
-
 
-      edgeLocator.initialize(); // Clip the lines
+      // Reset the locator
+      edgeLocator.initialize();
 
-      clipLines(points, pointScalars, pointData, edgeLocator, lines, newLines, inLineData, outLineData); // Clip the polys
+      // Clip the lines
+      clipLines(points, pointScalars, pointData, edgeLocator, lines, newLines, inLineData, outLineData);
 
+      // Clip the polys
       if (polys) {
         // Get the number of lines remaining after the clipping
-        var numClipLines = newLines.getNumberOfCells(); // Cut the polys to generate more lines
-
-        clipAndContourPolys(points, pointScalars, pointData, edgeLocator, triangulate, polys, newPolys, newLines, inPolyData, outPolyData, outLineData); // Add scalars for the newly-created contour lines
+        const numClipLines = newLines.getNumberOfCells();
 
-        var _scalars = outLineData.getScalars();
+        // Cut the polys to generate more lines
+        clipAndContourPolys(points, pointScalars, pointData, edgeLocator, triangulate, polys, newPolys, newLines, inPolyData, outPolyData, outLineData);
 
-        if (_scalars) {
+        // Add scalars for the newly-created contour lines
+        let scalars = outLineData.getScalars();
+        if (scalars) {
           // Set the color to the active color if plane is active
-          var color = colors[1 + (active ? 1 : 0)];
-          var activeColor = colors[2];
-          var numNewLines = newLines.getNumberOfCells();
-          var oldColor = [];
-
-          for (var lineId = numClipLines; lineId < numNewLines; lineId++) {
-            _scalars.getTuple(lineId, oldColor);
-
+          const color = colors[1 + (active ? 1 : 0)];
+          const activeColor = colors[2];
+          const numNewLines = newLines.getNumberOfCells();
+          const oldColor = [];
+          for (let lineId = numClipLines; lineId < numNewLines; lineId++) {
+            scalars.getTuple(lineId, oldColor);
             if (numberOfScalarComponents !== 3 || oldColor[0] !== activeColor[0] || oldColor[1] !== activeColor[1] || oldColor[2] !== activeColor[2]) {
-              _scalars.setTuple(lineId, color);
+              scalars.setTuple(lineId, color);
             }
           }
-        } // Generate new polys from the cut lines
-
+        }
 
-        var cellId = newPolys.getNumberOfCells();
-        var numClipAndContourLines = newLines.getNumberOfCells(); // Create a polydata for the lines
+        // Generate new polys from the cut lines
+        let cellId = newPolys.getNumberOfCells();
+        const numClipAndContourLines = newLines.getNumberOfCells();
 
+        // Create a polydata for the lines
         tmpContourData.setPoints(points);
         tmpContourData.setLines(newLines);
         tmpContourData.buildCells();
-        triangulateContours(tmpContourData, numClipLines, numClipAndContourLines - numClipLines, newPolys, pc); // Add scalars for the newly-created polys
-
-        _scalars = outPolyData.getScalars();
-
-        if (_scalars) {
-          var _color = colors[1 + (active ? 1 : 0)];
-          var numCells = newPolys.getNumberOfCells();
+        triangulateContours(tmpContourData, numClipLines, numClipAndContourLines - numClipLines, newPolys, pc);
 
+        // Add scalars for the newly-created polys
+        scalars = outPolyData.getScalars();
+        if (scalars) {
+          const color = colors[1 + (active ? 1 : 0)];
+          const numCells = newPolys.getNumberOfCells();
           if (numCells > cellId) {
             // The insert allocates space up to numCells - 1
-            _scalars.insertTuple(numCells - 1, _color);
-
+            scalars.insertTuple(numCells - 1, color);
             for (; cellId < numCells; cellId++) {
-              _scalars.setTuple(cellId, _color);
+              scalars.setTuple(cellId, color);
             }
           }
-        } // Add scalars to any diagnostic lines that added by
-        // triangulateContours(). In usual operation, no lines are added.
-
-
-        _scalars = outLineData.getScalars();
-
-        if (_scalars) {
-          var _color2 = [0, 255, 255];
-
-          var _numCells = newLines.getNumberOfCells();
+        }
 
-          if (_numCells > numClipAndContourLines) {
+        // Add scalars to any diagnostic lines that added by
+        // triangulateContours(). In usual operation, no lines are added.
+        scalars = outLineData.getScalars();
+        if (scalars) {
+          const color = [0, 255, 255];
+          const numCells = newLines.getNumberOfCells();
+          if (numCells > numClipAndContourLines) {
             // The insert allocates space up to numCells - 1
-            _scalars.insertTuple(_numCells - 1, _color2);
-
-            for (var lineCellId = numClipAndContourLines; lineCellId < _numCells; lineCellId++) {
-              _scalars.setTuple(lineCellId, _color2);
+            scalars.insertTuple(numCells - 1, color);
+            for (let lineCellId = numClipAndContourLines; lineCellId < numCells; lineCellId++) {
+              scalars.setTuple(lineCellId, color);
             }
           }
         }
-      } // Swap the lines, points, etcetera: old output becomes new input
-
+      }
 
-      var _ref3 = [newLines, lines];
-      lines = _ref3[0];
-      newLines = _ref3[1];
+      // Swap the lines, points, etcetera: old output becomes new input
+      [lines, newLines] = [newLines, lines];
       newLines.initialize();
-
       if (polys) {
-        var _ref4 = [newPolys, polys];
-        polys = _ref4[0];
-        newPolys = _ref4[1];
+        [polys, newPolys] = [newPolys, polys];
         newPolys.initialize();
       }
-
-      var _ref5 = [outLineData, inLineData];
-      inLineData = _ref5[0];
-      outLineData = _ref5[1];
+      [inLineData, outLineData] = [outLineData, inLineData];
       outLineData.initialize();
-      var _ref6 = [outPolyData, inPolyData];
-      inPolyData = _ref6[0];
-      outPolyData = _ref6[1];
+      [inPolyData, outPolyData] = [outPolyData, inPolyData];
       outPolyData.initialize();
-    } // Get the line scalars
-
-
-    var scalars = inLineData.getScalars();
+    }
 
+    // Get the line scalars
+    const scalars = inLineData.getScalars();
     if (model.generateOutline) {
       output.setLines(lines);
     } else if (scalars) {
       scalars.initialize();
     }
-
     if (model.generateFaces) {
       output.setPolys(polys);
-
       if (polys && scalars) {
-        var pScalars = inPolyData.getScalars();
-        var m = scalars.getNumberOfTuples();
-        var n = pScalars.getNumberOfTuples();
-
+        const pScalars = inPolyData.getScalars();
+        const m = scalars.getNumberOfTuples();
+        const n = pScalars.getNumberOfTuples();
         if (n > 0) {
-          var _color3 = [0, 0, 0]; // This is just to expand the array
+          const color = [0, 0, 0];
 
-          scalars.insertTuple(n + m - 1, _color3); // Fill in the poly scalars
+          // This is just to expand the array
+          scalars.insertTuple(n + m - 1, color);
 
-          for (var _i2 = 0; _i2 < n; _i2++) {
-            pScalars.getTuple(_i2, _color3);
-            scalars.setTuple(_i2 + m, _color3);
+          // Fill in the poly scalars
+          for (let i = 0; i < n; i++) {
+            pScalars.getTuple(i, color);
+            scalars.setTuple(i + m, color);
           }
         }
       }
     }
-
     if (scalars && model.scalarMode === ScalarMode.COLORS) {
       scalars.setName('Colors');
       output.getCellData().setScalars(scalars);
@@ -903,34 +818,33 @@ function vtkClipClosedSurface(publicAPI, model) {
       // output.getCellData().setScalars(categories);
       // categories.delete();
       // TODO: Check
-      var categories = scalars.newClone();
+      const categories = scalars.newClone();
       categories.setData(scalars.getData().slice());
       categories.setName('Labels');
       output.getCellData().setScalars(categories);
     } else {
       output.getCellData().setScalars(null);
-    } // Finally, store the points in the output
-
+    }
 
-    squeezeOutputPoints(output, points, pointData, inputPointsType); // TODO: Check
+    // Finally, store the points in the output
+    squeezeOutputPoints(output, points, pointData, inputPointsType);
+    // TODO: Check
     // output.squeeze();
-
     outData[0] = output;
   };
-
-  Object.keys(ScalarMode).forEach(function (key) {
-    var name = capitalize(key.toLowerCase());
-
-    publicAPI["setScalarModeTo".concat(name)] = function () {
+  Object.keys(ScalarMode).forEach(key => {
+    const name = capitalize(key.toLowerCase());
+    publicAPI[`setScalarModeTo${name}`] = () => {
       model.scalarMode = ScalarMode[key];
     };
   });
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   clippingPlanes: null,
   tolerance: 1e-6,
   passPointData: false,
@@ -945,28 +859,39 @@ var DEFAULT_VALUES = {
   // Sandy brown
   activePlaneColor: [227 / 255, 207 / 255, 87 / 255],
   // Banana
-  triangulationErrorDisplay: false // _idList: null,
 
-}; // ----------------------------------------------------------------------------
+  triangulationErrorDisplay: false
+  // _idList: null,
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
-  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // 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);
   macro.setGet(publicAPI, model, ['clippingPlanes', 'tolerance', 'passPointData', 'triangulatePolys', 'scalarMode', 'generateOutline', 'generateFaces', 'activePlaneId', 'triangulationErrorDisplay']);
-  macro.setGetArray(publicAPI, model, ['baseColor', 'clipColor', 'activePlaneColor'], 3); // Object specific methods
+  macro.setGetArray(publicAPI, model, ['baseColor', 'clipColor', 'activePlaneColor'], 3);
 
+  // Object specific methods
   vtkClipClosedSurface(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkClipClosedSurface');
 
-var newInstance = macro.newInstance(extend, 'vtkClipClosedSurface'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-var vtkClipClosedSurface$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkClipClosedSurface$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkClipClosedSurface$1 as default, extend, newInstance };