@kitware/vtk.js 23.4.2 → 23.4.4

package/Filters/General/ClipClosedSurface.js

@@ -0,0 +1,972 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../macros.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';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkDataSetAttributes from '../../Common/DataModel/DataSetAttributes.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+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;
+
+function vtkClipClosedSurface(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkClipClosedSurface');
+
+  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.
+   *
+   * @param {Number} color1
+   * @param {Number} color2
+   * @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++) {
+        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
+   * function guarantees perfect consistency in the results.
+   *
+   * @param {vtkPoints} points
+   * @param {vtkDataArray} pointData
+   * @param {CCSEdgeLocator} locator
+   * @param {Number} tol
+   * @param {Number} i0
+   * @param {Number} i1
+   * @param {Number} v0
+   * @param {Number} v1
+   * @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);
+
+    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
+
+    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.
+   *
+   * @param {vtkPoints} points
+   * @param {vtkDataArray} pointScalars
+   * @param {vtkDataSetAttributesk} pointData
+   * @param {vtkEdgeLocator} edgeLocator
+   * @param {vtkCellArray} inputLines
+   * @param {vtkCellArray} outputLines
+   * @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++) {
+      numPts = values[i];
+      i1 = values[i + 1];
+      v1 = pointScalars.getData()[i1];
+      c1 = v1 > 0;
+
+      for (var 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
+
+        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 (i0 !== i1) {
+            linePts[0] = i0;
+            linePts[1] = i1;
+            var 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,
+   * then scalars will be set to color.  If scalars is zero, then no
+   * scalars will be generated.
+   *
+   * @param {vtkCellArray} inputLines
+   * @param {vtkCellArray} outputLines
+   * @param {vtkDataArray} inputScalars
+   * @param {Number} firstLineScalar
+   * @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) {
+      numPts = values[i];
+
+      if (inputScalars) {
+        inputScalars.getTuple(firstLineScalar + cellId++, cellColor);
+      }
+
+      for (var 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.
+   * If polyScalars is set to zero, don't generate scalars.
+   *
+   * @param {vtkCellArray} inputPolys
+   * @param {vtkCellArray} outputPolys
+   * @param {vtkDataArray} inputScalars
+   * @param {Number} firstPolyScalar
+   * @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();
+      polyScalars.insertTuple(n - 1, scalarValue);
+
+      if (inputScalars) {
+        for (var 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);
+        }
+      }
+    }
+  }
+
+  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];
+
+        if (j % 2) {
+          polys.insertNextCell([p2, p1, p3]);
+        } else {
+          polys.insertNextCell([p1, p2, p3]);
+        }
+
+        p1 = p2;
+        p2 = p3;
+      }
+
+      if (polyScalars) {
+        var scalarValue = _toConsumableArray(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();
+
+        if (n >= 0) {
+          // First insert is just to allocate space
+          polyScalars.insertTuple(m + n, scalarValue);
+
+          for (var 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,
+   * not polylines.  The input lines do not have to be in order.
+   * Only lines from firstLine to will be used.  Specify the normal
+   * of the clip plane, which will be opposite the normals
+   * of the polys that will be produced.  If outCD has scalars, then color
+   * scalars will be added for each poly that is created.
+   *
+   * @param {vtkPolyData} polyData
+   * @param {Number} firstLine
+   * @param {Number} numLines
+   * @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]]);
+
+    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,
+   * then scalars will be set to color. If scalars is zero, then no
+   * scalars will be generated.
+   *
+   * @param {Number[]} polygon
+   * @param {vtkPoints} points
+   * @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
+   * the clipped polygons.  This exact correspondence is necessary
+   * in order to guarantee that the surface remains closed.
+   *
+   * @param {vtkPoints} points
+   * @param {vtkDataArray} pointScalars
+   * @param {vtkDataSetAttributes} pointData
+   * @param {vtkEdgeLocator} edgeLocator
+   * @param {Number} triangulate
+   * @param {vtkCellArray} inputPolys
+   * @param {vtkCellArray} outputPolys
+   * @param {vtkCellArray} outputLines
+   * @param {vtkDataSetAttributes} inCellData
+   * @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;
+
+    if (triangulate) {
+      if (triangulate < 4) {
+        // triangles only
+        polyMax = 3;
+      } else if (triangulate === 4) {
+        // 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;
+
+    for (var 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
+
+      var j0 = c1 ? i1 : -1;
+      var 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++) {
+        // Save previous point info
+        var i0 = i1;
+        var v0 = v1;
+        var 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
+
+        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
+
+
+            linePts[c0 ? 1 : 0] = j1;
+          }
+
+          if (c1) {
+            j1 = i1;
+
+            if (j1 !== j0) {
+              idList[idListIdx++] = j1;
+              j0 = j1;
+            }
+          }
+        }
+      } // Insert the clipped poly
+
+
+      var 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);
+
+        if (!success) {
+          triangulationFailure = true;
+        } // Copy the attribute data to the triangle cells
+
+
+        var 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
+
+
+      if (linePts[0] !== linePts[1]) {
+        var _newCellId2 = outputLines.insertNextCell(linePts);
+
+        outLineData.passData(inCellData, cellId, _newCellId2);
+      }
+    }
+
+    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
+   * be modified.
+   *
+   * @param {vtkPolyData} output
+   * @param {vtkPoints} points
+   * @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 = [];
+    pointMap.length = n;
+    var cellArrays = [output.getVerts(), output.getLines(), output.getPolys(), output.getStrips()]; // Find all the newPoints that are used by cells
+
+    cellArrays.forEach(function (cellArray) {
+      if (!cellArray) {
+        return;
+      }
+
+      var values = cellArray.getData();
+      var numPts;
+      var pointId;
+
+      for (var i = 0; i < values.length; i += numPts + 1) {
+        numPts = values[i];
+
+        for (var 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({
+      size: numNewPoints * 3,
+      dataType: outputPointDataType
+    }); // outPointData.copyAllocate(pointData, numNewPoints, 0);
+
+    var p = [];
+    var newPointId;
+
+    for (var 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);
+      }
+    } // Change the cell pointIds to reflect the new point array
+
+
+    cellArrays.forEach(function (cellArray) {
+      if (!cellArray) {
+        return;
+      }
+
+      var values = cellArray.getData();
+      var numPts;
+      var pointId;
+
+      for (var i = 0; i < values.length; i += numPts + 1) {
+        numPts = values[i];
+
+        for (var j = 1; j <= numPts; j++) {
+          pointId = values[i + j];
+          values[i + j] = pointMap[pointId];
+        }
+      }
+    });
+    output.setPoints(newPoints);
+  }
+
+  publicAPI.requestData = function (inData, outData) {
+    var _input$getVerts, _input$getStrips;
+
+    // implement requestData
+    var input = inData[0];
+    var 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;
+
+    if (inputPoints) {
+      numPts = inputPoints.getNumberOfPoints();
+      inputPointsType = inputPoints.getDataType();
+    } // Force points to double precision, copy the point attributes
+
+
+    var points = vtkPoints.newInstance({
+      size: numPts * 3,
+      dataType: VtkDataTypes.DOUBLE
+    });
+    var pointData = vtkDataSetAttributes.newInstance();
+    var inPointData = null;
+
+    if (model.passPointData) {
+      inPointData = input.getPointData(); // pointData.interpolateAllocate(inPointData, numPts, 0);
+    }
+
+    var point = [];
+
+    for (var 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
+
+    var lineScalars;
+    var polyScalars;
+    var inputScalars; // For input scalars: the offsets to the various cell types
+
+    var firstLineScalar = 0;
+    var firstPolyScalar = 0;
+    var firstStripScalar = 0; // Make the colors to be used on the data
+
+    var numberOfScalarComponents = 1;
+    var 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);
+    } else if (model.scalarMode === ScalarMode.LABELS) {
+      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
+    // 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;
+
+    if (model.scalarMode !== ScalarMode.NONE) {
+      lineScalars = vtkDataArray.newInstance({
+        dataType: VtkDataTypes.UNSIGNED_CHAR,
+        empty: true,
+        // size: 0,
+        // values: new Uint8Array(numLines * 3),
+        numberOfComponents: numberOfScalarComponents
+      });
+      var 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;
+
+    if (numLines > 0) {
+      lines = vtkCellArray.newInstance({
+        dataType: inputLines.getDataType(),
+        values: new Uint8Array(numLines * 3),
+        // we will have at least that amount of lines
+        size: 0
+      });
+      breakPolylines(inputLines, lines, inputScalars, firstLineScalar, lineScalars, colors[0]);
+    } else {
+      lines = vtkCellArray.newInstance({
+        empty: true
+      });
+    }
+
+    var polys = null;
+    var polyMax = 3;
+
+    if (numPolys > 0 || numStrips > 0) {
+      // If there are line scalars, then poly scalars are needed too
+      if (lineScalars) {
+        polyScalars = vtkDataArray.newInstance({
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          empty: true,
+          // size: 0,
+          // values: new Uint8Array(inputPolys.getNumberOfCells(false) * 3),
+          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
+
+
+    var newLines = vtkCellArray.newInstance({
+      dataType: lines.getDataType(),
+      empty: true
+    });
+    var newPolys = null;
+
+    if (polys) {
+      newPolys = vtkCellArray.newInstance({
+        dataType: polys.getDataType(),
+        empty: true
+      });
+    } // The line scalars, for coloring the outline
+
+
+    var inLineData = vtkDataSetAttributes.newInstance();
+    inLineData.copyScalarsOn();
+    inLineData.setScalars(lineScalars); // The poly scalars, for coloring the faces
+
+    var inPolyData = vtkDataSetAttributes.newInstance();
+    inPolyData.copyScalarsOn();
+    inPolyData.setScalars(polyScalars); // Also create output attribute data
+
+    var outLineData = vtkDataSetAttributes.newInstance();
+    outLineData.copyScalarsOn();
+    var 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;
+
+      if (planeId === planes.length - 1) {
+        triangulate = polyMax;
+      }
+
+      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
+
+      pc[3] = -dot(pc, plane.getOrigin()); // Create the clip scalars by evaluating the plane at each point
+
+      var numPoints = points.getNumberOfPoints(); // The point scalars, needed for clipping (not for the output!)
+
+      var 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) {
+        pointScalarsData[pointId++] = pointsData[i++] * pc[0] + pointsData[i++] * pc[1] + pointsData[i++] * pc[2] + pc[3];
+      } // Prepare the output scalars
+      // outLineData.copyAllocate(inLineData, 0, 0);
+      // outPolyData.copyAllocate(inPolyData, 0, 0);
+      // Reset the locator
+
+
+      edgeLocator.initialize(); // 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
+
+        var _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);
+
+            if (numberOfScalarComponents !== 3 || oldColor[0] !== activeColor[0] || oldColor[1] !== activeColor[1] || oldColor[2] !== activeColor[2]) {
+              _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
+
+        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();
+
+          if (numCells > cellId) {
+            // The insert allocates space up to numCells - 1
+            _scalars.insertTuple(numCells - 1, _color);
+
+            for (; cellId < numCells; cellId++) {
+              _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) {
+            // The insert allocates space up to numCells - 1
+            _scalars.insertTuple(_numCells - 1, _color2);
+
+            for (var lineCellId = numClipAndContourLines; lineCellId < _numCells; lineCellId++) {
+              _scalars.setTuple(lineCellId, _color2);
+            }
+          }
+        }
+      } // Swap the lines, points, etcetera: old output becomes new input
+
+
+      var _ref3 = [newLines, lines];
+      lines = _ref3[0];
+      newLines = _ref3[1];
+      newLines.initialize();
+
+      if (polys) {
+        var _ref4 = [newPolys, polys];
+        polys = _ref4[0];
+        newPolys = _ref4[1];
+        newPolys.initialize();
+      }
+
+      var _ref5 = [outLineData, inLineData];
+      inLineData = _ref5[0];
+      outLineData = _ref5[1];
+      outLineData.initialize();
+      var _ref6 = [outPolyData, inPolyData];
+      inPolyData = _ref6[0];
+      outPolyData = _ref6[1];
+      outPolyData.initialize();
+    } // Get the line scalars
+
+
+    var 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();
+
+        if (n > 0) {
+          var _color3 = [0, 0, 0]; // This is just to expand the array
+
+          scalars.insertTuple(n + m - 1, _color3); // Fill in the poly scalars
+
+          for (var _i2 = 0; _i2 < n; _i2++) {
+            pScalars.getTuple(_i2, _color3);
+            scalars.setTuple(_i2 + m, _color3);
+          }
+        }
+      }
+    }
+
+    if (scalars && model.scalarMode === ScalarMode.COLORS) {
+      scalars.setName('Colors');
+      output.getCellData().setScalars(scalars);
+    } else if (model.scalarMode === ScalarMode.LABELS) {
+      // Don't use VTK_UNSIGNED_CHAR or they will look like color scalars
+      // const categories = vtkSignedCharArray.newInstance();
+      // categories.deepCopy(scalars);
+      // categories.setName("Labels");
+      // output.getCellData().setScalars(categories);
+      // categories.delete();
+      // TODO: Check
+      var 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
+    // output.squeeze();
+
+    outData[0] = output;
+  };
+
+  Object.keys(ScalarMode).forEach(function (key) {
+    var name = capitalize(key.toLowerCase());
+
+    publicAPI["setScalarModeTo".concat(name)] = function () {
+      model.scalarMode = ScalarMode[key];
+    };
+  });
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  clippingPlanes: null,
+  tolerance: 1e-6,
+  passPointData: false,
+  triangulatePolys: false,
+  scalarMode: ScalarMode.NONE,
+  generateOutline: false,
+  generateFaces: true,
+  activePlaneId: -1,
+  baseColor: [255 / 255, 99 / 255, 71 / 255],
+  // Tomato
+  clipColor: [244 / 255, 164 / 255, 96 / 255],
+  // Sandy brown
+  activePlaneColor: [227 / 255, 207 / 255, 87 / 255],
+  // Banana
+  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
+
+  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
+
+  vtkClipClosedSurface(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkClipClosedSurface'); // ----------------------------------------------------------------------------
+
+var vtkClipClosedSurface$1 = _objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, Constants);
+
+export { vtkClipClosedSurface$1 as default, extend, newInstance };