@kitware/vtk.js 25.4.0 → 25.7.0

package/Filters/General/ContourTriangulator/helper.js

@@ -0,0 +1,1951 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../../macros.js';
+import vtkPoints from '../../../Common/Core/Points.js';
+import { s as subtract, k as cross, d as dot, n as norm, f as distance2BetweenPoints, l as add, m as normalize } from '../../../Common/Core/Math/index.js';
+import vtkLine from '../../../Common/DataModel/Line.js';
+import vtkPolygon from '../../../Common/DataModel/Polygon.js';
+import vtkIncrementalOctreePointLocator from '../../../Common/DataModel/IncrementalOctreePointLocator.js';
+import { VtkDataTypes } from '../../../Common/Core/DataArray/Constants.js';
+import { CCS_POLYGON_TOLERANCE } from './Constants.js';
+import { PolygonWithPointIntersectionState } from '../../../Common/DataModel/Polygon/Constants.js';
+
+var vtkErrorMacro = macro.vtkErrorMacro;
+/**
+ * Reverse the elements between the indices firstIdx and lastIdx of the given array arr.
+ *
+ * @param {Array|TypedArray} arr
+ * @param {Number} firstIdx
+ * @param {Number} lastIdx
+ */
+
+function reverseElements(arr) {
+  var firstIdx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  var lastIdx = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  var first = firstIdx !== null && firstIdx !== void 0 ? firstIdx : 0;
+  var last = lastIdx !== null && lastIdx !== void 0 ? lastIdx : arr.length - 1;
+  var mid = first + Math.floor((last - first) / 2);
+
+  for (var i = first; i <= mid; ++i) {
+    var _ref = [arr[last - (i - first)], arr[i]];
+    arr[i] = _ref[0];
+    arr[last - (i - first)] = _ref[1];
+  }
+} // ---------------------------------------------------
+
+/**
+ * Compute the quality of a triangle.
+ *
+ * @param {Vector3} p0
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {Vector3} normal
+ * @returns {Number}
+ */
+
+function vtkCCSTriangleQuality(p0, p1, p2, normal) {
+  var u = [];
+  var v = [];
+  var w = [];
+  subtract(p1, p0, u);
+  subtract(p2, p1, v);
+  subtract(p0, p2, w);
+  var area2 = (u[1] * v[2] - u[2] * v[1]) * normal[0] + (u[2] * v[0] - u[0] * v[2]) * normal[1] + (u[0] * v[1] - u[1] * v[0]) * normal[2];
+  var perim = Math.sqrt(u[0] * u[0] + u[1] * u[1] + u[2] * u[2]) + Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) + Math.sqrt(w[0] * w[0] + w[1] * w[1] + w[2] * w[2]);
+  perim *= perim; // square the perimeter
+
+  perim = perim !== 0 ? perim : 1.0; // use a normalization factor so equilateral quality is 1.0
+
+  return area2 / perim * 10.392304845413264;
+} // ---------------------------------------------------
+
+/**
+ * Insert a triangle, and subdivide that triangle if one of
+ * its edges originally had more than two points before
+ * vtkCCSFindTrueEdges was called. Is called by vtkCCSTriangulate.
+ *
+ * @param {vtkCellArray} polys
+ * @param {Array|TypedArray} poly
+ * @param {Vector3} trids
+ * @param {Array|TypedArray} polyEdges
+ * @param {Array|TypedArray} originalEdges
+ */
+
+function vtkCCSInsertTriangle(polys, poly, trids, polyEdges, originalEdges) {
+  var nextVert = [1, 2, 0]; // To store how many of originalEdges match
+
+  var edgeCount = 0;
+  var edgeLocs = [-1, -1, -1]; // Check for original edge matches
+
+  for (var vert = 0; vert < 3; vert++) {
+    var currId = trids[vert];
+    var edgeLoc = polyEdges[currId];
+
+    if (edgeLoc >= 0) {
+      var nextId = currId + 1;
+
+      if (nextId === poly.length) {
+        nextId = 0;
+      } // Is the triangle edge a polygon edge?
+
+
+      if (nextId === trids[nextVert[vert]]) {
+        edgeLocs[vert] = edgeLoc;
+        edgeCount++;
+      }
+    }
+  }
+
+  if (edgeCount === 0) {
+    // No special edge handling, so just do one triangle
+    polys.insertNextCell([poly[trids[0]], poly[trids[1]], poly[trids[2]]]);
+  } else {
+    // Make triangle fans for edges with extra points
+    var edgePts = [[poly[trids[0]], poly[trids[1]]], [poly[trids[1]], poly[trids[2]]], [poly[trids[2]], poly[trids[0]]]]; // Find out which edge has the most extra points
+
+    var maxPoints = 0;
+    var currSide = 0;
+
+    for (var i = 0; i < 3; i++) {
+      if (edgeLocs[i] >= 0) {
+        var _edgeLoc = edgeLocs[i];
+        var npts = originalEdges[_edgeLoc];
+        var pts = originalEdges.slice(_edgeLoc + 1, _edgeLoc + 1 + npts);
+
+        if (!(edgePts[i][0] === pts[0] || edgePts[i][1] === pts[npts - 1])) {
+          vtkErrorMacro('assertion error in vtkCCSInsertTriangle');
+        }
+
+        if (npts > maxPoints) {
+          maxPoints = npts;
+          currSide = i;
+        }
+
+        edgePts[i] = pts;
+      }
+    } // Find the edges before/after the edge with most points
+
+
+    var prevSide = (currSide + 2) % 3;
+    var nextSide = (currSide + 1) % 3; // If other edges have only 2 points, nothing to do with them
+
+    var prevNeeded = edgePts[prevSide].length > 2;
+    var nextNeeded = edgePts[nextSide].length > 2; // The tail is the common point in the triangle fan
+
+    var tailPtIds = [];
+    tailPtIds[prevSide] = edgePts[currSide][1];
+    tailPtIds[currSide] = edgePts[prevSide][0];
+    tailPtIds[nextSide] = edgePts[currSide][edgePts[currSide].length - 2]; // Go through the sides and make the fans
+
+    for (var side = 0; side < 3; side++) {
+      if ((side !== prevSide || prevNeeded) && (side !== nextSide || nextNeeded)) {
+        var m = 0;
+        var n = edgePts[side].length - 1;
+
+        if (side === currSide) {
+          m += prevNeeded;
+          n -= nextNeeded;
+        }
+
+        for (var k = m; k < n; k++) {
+          polys.insertNextCell([edgePts[side][k], edgePts[side][k + 1], tailPtIds[side]]);
+        }
+      }
+    }
+  }
+} // ---------------------------------------------------
+
+/**
+ * Triangulate a polygon that has been simplified by FindTrueEdges.
+ * This will re-insert the original edges.  The output triangles are
+ * appended to "polys" and, for each stored triangle, "color" will
+ * be added to "scalars".  The final two arguments (polygon and
+ * triangles) are only for temporary storage.
+ * The return value is true if triangulation was successful.
+ *
+ * @param {Array} poly
+ * @param {vtkPoints} points
+ * @param {Array} polyEdges
+ * @param {Array} originalEdges
+ * @param {vtkCellArray} polys
+ * @param {Vector3} normal
+ * @returns {boolean}
+ */
+
+function vtkCCSTriangulate(poly, points, polyEdges, originalEdges, polys, normal) {
+  var n = poly.length; // If the poly is a line, then skip it
+
+  if (n < 3) {
+    return true;
+  } // If the poly is a triangle, then pass it
+
+
+  if (n === 3) {
+    var trids = [0, 1, 2];
+    vtkCCSInsertTriangle(polys, poly, trids, polyEdges, originalEdges);
+    return true;
+  } // If the poly has 4 or more points, triangulate it
+
+
+  var triangulationFailure = false;
+  var ppoint = [];
+  var point = [];
+  var npoint = [];
+  var i = 0;
+  var j = 0;
+  var k = 0;
+  var verts = [];
+  verts.length = n;
+
+  for (i = 0; i < n; i++) {
+    verts[i] = [i, 0];
+  } // compute the triangle quality for each vert
+
+
+  k = n - 2;
+  points.getPoint(poly[verts[k][0]], point);
+  i = n - 1;
+  points.getPoint(poly[verts[i][0]], npoint);
+  var concave = 0;
+  var maxq = 0;
+  var maxi = 0;
+
+  for (j = 0; j < n; j++) {
+    var _ref2 = [point, npoint, ppoint];
+    ppoint = _ref2[0];
+    point = _ref2[1];
+    npoint = _ref2[2];
+    points.getPoint(poly[verts[j][0]], npoint);
+    var q = vtkCCSTriangleQuality(ppoint, point, npoint, normal);
+
+    if (q > maxq) {
+      maxi = i;
+      maxq = q;
+    }
+
+    concave += q < 0;
+    verts[i][1] = q;
+    i = j;
+  }
+
+  var foundEar; // perform the ear-cut triangulation
+
+  for (;;) {
+    // if no potential ears were found, then fail
+    if (maxq <= Number.MIN_VALUE) {
+      triangulationFailure = true;
+      break;
+    }
+
+    i = maxi;
+    j = i + 1 !== n ? i + 1 : 0;
+    k = i !== 0 ? i - 1 : n - 1;
+
+    if (verts[i][1] > 0) {
+      foundEar = true;
+      points.getPoint(poly[verts[j][0]], npoint);
+      points.getPoint(poly[verts[k][0]], ppoint); // only do ear check if there are concave vertices
+
+      if (concave) {
+        // get the normal of the split plane
+        var v = [];
+        var u = [];
+        subtract(npoint, ppoint, v);
+        cross(v, normal, u);
+        var d = dot(ppoint, u);
+        var jj = j + 1 !== n ? j + 1 : 0;
+        var x = [];
+        points.getPoint(poly[verts[jj][0]], x);
+        var side = dot(x, u) < d;
+        var foundNegative = side; // check for crossings of the split plane
+
+        jj = jj + 1 !== n ? jj + 1 : 0;
+        var y = [];
+        var s = [];
+        var t = [];
+
+        for (; foundEar && jj !== k; jj = jj + 1 !== n ? jj + 1 : 0) {
+          var _ref3 = [y, x];
+          x = _ref3[0];
+          y = _ref3[1];
+          points.getPoint(poly[verts[jj][0]], x);
+          var sside = dot(x, u) < d; // XOR
+
+          if (side ? !sside : sside) {
+            side = !side;
+            foundNegative = true;
+            foundEar = vtkLine.intersection(ppoint, npoint, x, y, s, t) === vtkLine.IntersectionState.NO_INTERSECTION;
+          }
+        }
+
+        foundEar && (foundEar = foundNegative);
+      }
+
+      if (!foundEar) {
+        // don't try again until it is split
+        verts[i][1] = Number.MIN_VALUE;
+      } else {
+        // create a triangle from vertex and neighbors
+        var _trids = [verts[i][0], verts[j][0], verts[k][0]];
+        vtkCCSInsertTriangle(polys, poly, _trids, polyEdges, originalEdges); // remove the vertex i
+
+        verts.splice(i, 1);
+        k -= i === 0;
+        j -= j !== 0; // break if this was final triangle
+
+        if (--n < 3) {
+          break;
+        } // re-compute quality of previous point
+
+
+        var kk = k !== 0 ? k - 1 : n - 1;
+        points.getPoint(poly[verts[kk][0]], point);
+        var kq = vtkCCSTriangleQuality(point, ppoint, npoint, normal);
+        concave -= verts[k][1] < 0 && kq >= 0;
+        verts[k][1] = kq; // re-compute quality of next point
+
+        var _jj = j + 1 !== n ? j + 1 : 0;
+
+        points.getPoint(poly[verts[_jj][0]], point);
+        var jq = vtkCCSTriangleQuality(ppoint, npoint, point, normal);
+        concave -= verts[j][1] < 0 && jq >= 0;
+        verts[j][1] = jq;
+      }
+    } // find the highest-quality ear candidate
+
+
+    maxi = 0;
+    maxq = verts[0][1];
+
+    for (i = 1; i < n; i++) {
+      var _q = verts[i][1];
+
+      if (_q > maxq) {
+        maxi = i;
+        maxq = _q;
+      }
+    }
+  }
+
+  return !triangulationFailure;
+} // ---------------------------------------------------
+
+/**
+ * Create polygons from line segments.
+ *
+ * @param {vtkPolyData} polyData
+ * @param {Number} firstLine
+ * @param {Number} endLine
+ * @param {Boolean} oriented
+ * @param {Array} newPolys
+ * @param {Array} incompletePolys
+ */
+
+function vtkCCSMakePolysFromLines(polyData, firstLine, endLine, oriented, newPolys, incompletePolys) {
+  var npts = 0;
+  var pts = []; // Bitfield for marking lines as used
+
+  var usedLines = new Uint8Array(endLine - firstLine); // defaults to 0
+  // Require cell links to get lines from pointIds
+
+  polyData.buildLinks(polyData.getPoints().getNumberOfPoints());
+  var numNewPolys = 0;
+  var remainingLines = endLine - firstLine;
+
+  while (remainingLines > 0) {
+    // Create a new poly
+    var polyId = numNewPolys++;
+    var poly = [];
+    newPolys.push(poly);
+    var lineId = 0;
+    var completePoly = false; // start the poly
+
+    for (lineId = firstLine; lineId < endLine; lineId++) {
+      if (!usedLines[lineId - firstLine]) {
+        pts = polyData.getCellPoints(lineId).cellPointIds;
+        npts = pts.length;
+        var n = npts;
+
+        if (npts > 2 && pts[0] === pts[npts - 1]) {
+          n = npts - 1;
+          completePoly = true;
+        }
+
+        poly.length = n;
+
+        for (var i = 0; i < n; i++) {
+          poly[i] = pts[i];
+        }
+
+        break;
+      }
+    }
+
+    usedLines[lineId - firstLine] = 1;
+    remainingLines--;
+    var noLinesMatch = remainingLines === 0 && !completePoly;
+
+    while (!completePoly && !noLinesMatch && remainingLines > 0) {
+      // This is cleared if a match is found
+      noLinesMatch = true; // Number of points in the poly
+
+      var npoly = poly.length;
+      var lineEndPts = [];
+      var endPts = [poly[npoly - 1], poly[0]]; // For both open ends of the polygon
+
+      for (var endIdx = 0; endIdx < 2; endIdx++) {
+        var matches = [];
+        var cells = polyData.getPointCells(endPts[endIdx]); // Go through all lines that contain this endpoint
+
+        for (var icell = 0; icell < cells.length; icell++) {
+          lineId = cells[icell];
+
+          if (lineId >= firstLine && lineId < endLine && !usedLines[lineId - firstLine]) {
+            pts = polyData.getCellPoints(lineId).cellPointIds;
+            npts = pts.length;
+            lineEndPts[0] = pts[0];
+            lineEndPts[1] = pts[npts - 1]; // Check that poly end matches line end
+
+            if (endPts[endIdx] === lineEndPts[endIdx] || !oriented && endPts[endIdx] === lineEndPts[1 - endIdx]) {
+              matches.push(lineId);
+            }
+          }
+        }
+
+        if (!matches.length === 0) {
+          // Multiple matches mean we need to decide which path to take
+          if (matches.length > 1) {
+            // Remove double-backs
+            var k = matches.length;
+
+            do {
+              lineId = matches[--k];
+              pts = polyData.getCellPoints(lineId).cellPointIds;
+              npts = pts.length;
+              lineEndPts[0] = pts[0];
+              lineEndPts[1] = pts[npts - 1]; // check if line is reversed
+
+              var r = endPts[endIdx] !== lineEndPts[endIdx];
+
+              if (!r && (endIdx === 0 && poly[npoly - 2] === pts[1] || endIdx === 1 && poly[1] === pts[npts - 2]) || r && (endIdx === 0 && poly[npoly - 2] === pts[npts - 2] || endIdx === 1 && poly[1] === pts[1])) {
+                matches.splice(k, 1);
+              }
+            } while (k > 0 && matches.length > 1); // If there are multiple matches due to intersections,
+            // they should be dealt with here.
+
+          }
+
+          lineId = matches[0];
+          pts = polyData.getCellPoints(lineId).cellPointIds;
+          npts = pts.length;
+          lineEndPts[0] = pts[0];
+          lineEndPts[1] = pts[npts - 1]; // Do both ends match?
+
+          if (endPts[endIdx] === lineEndPts[endIdx]) {
+            completePoly = endPts[1 - endIdx] === lineEndPts[1 - endIdx];
+          } else {
+            completePoly = endPts[1 - endIdx] === lineEndPts[endIdx];
+          }
+
+          if (endIdx === 0) {
+            for (var _i = 1; _i < npts - (completePoly ? 1 : 0); _i++) {
+              poly.push(pts[_i]);
+            }
+          } else {
+            for (var _i2 = completePoly ? 1 : 0; _i2 < npts - 1; _i2++) {
+              poly.unshift(pts[_i2]);
+            }
+          }
+
+          if (endPts[endIdx] !== lineEndPts[endIdx]) {
+            // reverse the ids in the added line
+            var pit = poly.length;
+            var ptsIt = completePoly ? 1 : 0;
+            var ptsEnd = npts - 1;
+
+            if (endIdx === 1) {
+              pit = npts - 1 - (completePoly ? 1 : 0);
+              ptsIt = pts + 1;
+              ptsEnd = pts + npts - (completePoly ? 1 : 0);
+            }
+
+            while (ptsIt !== ptsEnd) {
+              poly[--pit] = poly[ptsIt++];
+            }
+          }
+
+          usedLines[lineId - firstLine] = 1;
+          remainingLines--;
+          noLinesMatch = false;
+        }
+      }
+    } // Check for incomplete polygons
+
+
+    if (noLinesMatch) {
+      incompletePolys.push(polyId);
+    }
+  }
+} // ---------------------------------------------------
+
+/**
+ * Join polys that have loose ends, as indicated by incompletePolys.
+ * Any polys created will have a normal opposite to the supplied normal,
+ * and any new edges that are created will be on the hull of the point set.
+ * Shorter edges will be preferred over long edges.
+ *
+ * @param {Array[]} polys
+ * @param {Array} incompletePolys
+ * @param {vtkPoints} points
+ * @param {Vector3} normal
+ */
+
+function vtkCCSJoinLooseEnds(polys, incompletePolys, points, normal) {
+  // Relative tolerance for checking whether an edge is on the hull
+  var tol = CCS_POLYGON_TOLERANCE; // A list of polys to remove when everything is done
+
+  var removePolys = [];
+  var p1 = [];
+  var p2 = [];
+  var poly1;
+  var poly2;
+  var pt1;
+  var pt2;
+  var dMin;
+  var iMin;
+  var v;
+  var d;
+  var n = incompletePolys.length;
+
+  while (n !== 0) {
+    poly1 = polys[incompletePolys[n - 1]];
+    pt1 = poly1[poly1.length - 1];
+    points.getPoint(pt1, p1);
+    dMin = Number.MAX_VALUE;
+    iMin = 0;
+
+    for (var _i3 = 0; _i3 < n; _i3++) {
+      poly2 = polys[incompletePolys[_i3]];
+      pt2 = poly2[0];
+      points.getPoint(pt2, p2); // The next few steps verify that edge [p1, p2] is on the hull
+
+      v = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+      d = norm(v);
+
+      if (d !== 0) {
+        v[0] /= d;
+        v[1] /= d;
+        v[2] /= d;
+      } // Compute the midpoint of the edge
+
+
+      var pm = [0.5 * (p1[0] + p2[0]), 0.5 * (p1[1] + p2[1]), 0.5 * (p1[2] + p2[2])]; // Create a plane equation
+
+      var pc = [];
+      cross(normal, v, pc);
+      pc[3] = -dot(pc, pm); // Check that all points are inside the plane.  If they aren't, then
+      // the edge is not on the hull of the pointset.
+
+      var badPoint = false;
+      var m = polys.length;
+      var p = [];
+
+      for (var j = 0; j < m && !badPoint; j++) {
+        var poly = polys[j];
+        var npts = poly.length;
+
+        for (var k = 0; k < npts; k++) {
+          var ptId = poly[k];
+
+          if (ptId !== pt1 && ptId !== pt2) {
+            points.getPoint(ptId, p);
+            var val = p[0] * pc[0] + p[1] * pc[1] + p[2] * pc[2] + pc[3];
+            var r2 = distance2BetweenPoints(p, pm); // Check distance from plane against the tolerance
+
+            if (val < 0 && val * val > tol * tol * r2) {
+              badPoint = true;
+              break;
+            }
+          }
+        } // If no bad points, then this edge is a candidate
+
+
+        if (!badPoint && d < dMin) {
+          dMin = d;
+          iMin = _i3;
+        }
+      }
+    } // If a match was found, append the polys
+
+
+    if (dMin < Number.MAX_VALUE) {
+      // Did the poly match with itself?
+      if (iMin === n - 1) {
+        // Mark the poly as closed
+        incompletePolys.pop();
+      } else {
+        var _poly;
+
+        var id2 = incompletePolys[iMin]; // Combine the polys
+        // for (let i = 1; i < polys[id2].length; i++) {
+        //   poly1.push(polys[id2][i]);
+        // }
+
+        (_poly = poly1).push.apply(_poly, _toConsumableArray(polys[id2])); // Erase the second poly
+
+
+        removePolys.push(id2);
+        incompletePolys.splice(iMin, 1);
+      }
+    } else {
+      // If no match, erase this poly from consideration
+      removePolys.push(incompletePolys[n - 1]);
+      incompletePolys.pop();
+    }
+
+    n = incompletePolys.length;
+  } // Remove polys that couldn't be completed
+
+
+  removePolys.sort(function (a, b) {
+    return a - b;
+  });
+  var i = removePolys.length;
+
+  while (i > 0) {
+    // Remove items in reverse order
+    polys.splice(removePolys[--i], 1);
+  } // Clear the incompletePolys vector, it's indices are no longer valid
+
+
+  incompletePolys.length = 0;
+} // ---------------------------------------------------
+
+/**
+ * Given three vectors p.p1, p.p2, and p.p3, this routine
+ * checks to see if progressing from p1 to p2 to p3 is a clockwise
+ * or counterclockwise progression with respect to the normal.
+ * The return value is -1 for clockwise, +1 for counterclockwise,
+ * and 0 if any two of the vectors are coincident.
+ *
+ * @param {Vector3} p
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {Vector3} p3
+ * @param {Vector3} normal
+ * @returns {Number}
+ */
+
+function vtkCCSVectorProgression(p, p1, p2, p3, normal) {
+  var v1 = [p1[0] - p[0], p1[1] - p[1], p1[2] - p[2]];
+  var v2 = [p2[0] - p[0], p2[1] - p[1], p2[2] - p[2]];
+  var v3 = [p3[0] - p[0], p3[1] - p[1], p3[2] - p[2]];
+  var w1 = [];
+  var w2 = [];
+  cross(v2, v1, w1);
+  cross(v2, v3, w2);
+  var s1 = dot(w1, normal);
+  var s2 = dot(w2, normal);
+
+  if (s1 !== 0 && s2 !== 0) {
+    var sb1 = s1 < 0;
+    var sb2 = s2 < 0; // if sines have different signs
+    // XOR
+
+    if (sb1 ? !sb2 : sb2) {
+      // return -1 if s2 is -ve
+      return 1 - 2 * sb2;
+    }
+
+    var c1 = dot(v2, v1);
+    var l1 = norm(v1);
+    var c2 = dot(v2, v3);
+    var l2 = norm(v3); // ck is the difference of the cosines, flipped in sign if sines are +ve
+
+    var ck = (c2 * l2 - c1 * l1) * (1 - sb1 * 2);
+
+    if (ck !== 0) {
+      // return the sign of ck
+      return 1 - 2 * (ck < 0);
+    }
+  }
+
+  return 0;
+} // ---------------------------------------------------
+
+/**
+ * Check for self-intersection. Split the figure-eights.
+ * This assumes that all intersections occur at existing
+ * vertices, i.e. no new vertices will be created. Returns
+ * the number of splits made.
+ *
+ * @param {Array[]} polys
+ * @param {vtkPoints} points
+ * @param {Array} polyGroups
+ * @param {Array} polyEdges
+ * @param {Vector3} normal
+ * @param {Boolean} oriented
+ */
+
+function vtkCCSSplitAtPinchPoints(polys, points, polyGroups, polyEdges, normal, oriented) {
+  var tryPoints = vtkPoints.newInstance({
+    dataType: VtkDataTypes.DOUBLE,
+    empty: true
+  });
+  var locator = vtkIncrementalOctreePointLocator.newInstance();
+  var splitCount = 0;
+  var poly;
+  var n;
+  var bounds;
+  var tol;
+
+  for (var i = 0; i < polys.length; i++) {
+    poly = polys[i];
+    n = poly.length;
+    bounds = [];
+    tol = CCS_POLYGON_TOLERANCE * Math.sqrt(vtkPolygon.getBounds(poly, points, bounds));
+
+    if (tol === 0) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    tryPoints.initialize();
+    locator.setTolerance(tol);
+    locator.initPointInsertion(tryPoints, bounds);
+    var foundMatch = false;
+    var idx1 = 0;
+    var idx2 = 0;
+    var unique = 0;
+    var point = [];
+    var p1 = [];
+    var p2 = [];
+    var p3 = [];
+
+    for (idx2 = 0; idx2 < n; idx2++) {
+      points.getPoint(poly[idx2], point);
+
+      var _locator$insertUnique = locator.insertUniquePoint(point, 0),
+          success = _locator$insertUnique.success,
+          pointIdx = _locator$insertUnique.pointIdx;
+
+      if (!success) {
+        // Need vertIdx to match poly indices, so force point insertion
+        locator.insertNextPoint(point); // Do the points have different pointIds?
+
+        idx1 = pointIdx;
+        unique = poly[idx2] !== poly[idx1];
+
+        if (idx2 > idx1 + 2 - unique && n + idx1 > idx2 + 2 - unique) {
+          if (oriented) {
+            // Make sure that splitting this poly won't create a hole poly
+            var prevIdx = n + idx1 - 1;
+            var midIdx = idx1 + 1;
+            var nextIdx = idx2 + 1;
+
+            if (prevIdx >= n) {
+              prevIdx -= n;
+            }
+
+            if (midIdx >= n) {
+              midIdx -= n;
+            }
+
+            if (nextIdx >= n) {
+              nextIdx -= n;
+            }
+
+            points.getPoint(poly[prevIdx], p1);
+            points.getPoint(poly[midIdx], p2);
+            points.getPoint(poly[nextIdx], p3);
+
+            if (vtkCCSVectorProgression(point, p1, p2, p3, normal) > 0) {
+              foundMatch = true;
+              break;
+            }
+          } else {
+            foundMatch = true;
+            break;
+          }
+        }
+      }
+    }
+
+    if (foundMatch) {
+      splitCount++; // Split off a new poly
+
+      var m = idx2 - idx1;
+      var oldPoly = polys[i];
+      var oldEdges = polyEdges[i];
+      var newPoly1 = oldPoly.slice(idx1, idx1 + m + unique);
+      var newEdges1 = oldEdges.slice(idx1, idx1 + m + unique);
+      var newPoly2 = new Array(n - m + unique);
+      var newEdges2 = new Array(n - m + unique);
+
+      if (unique) {
+        newEdges1[m] = -1;
+      } // The poly that is split off, which might have more intersections
+
+
+      for (var j = 0; j < idx1 + unique; j++) {
+        newPoly2[j] = oldPoly[j];
+        newEdges2[j] = oldEdges[j];
+      }
+
+      if (unique) {
+        newEdges2[idx1] = -1;
+      }
+
+      for (var k = idx2; k < n; k++) {
+        newPoly2[k - m + unique] = oldPoly[k];
+        newEdges2[k - m + unique] = oldEdges[k];
+      }
+
+      polys[i] = newPoly1;
+      polyEdges[i] = newEdges1;
+      polys.push(newPoly2);
+      polyEdges.push(newEdges2); // Unless polygroup was clear (because poly was reversed),
+      // make a group with one entry for the new poly
+
+      polyGroups.length = polys.length;
+
+      if (polyGroups[i].length > 0) {
+        polyGroups[polys.length - 1].push(polys.length - 1);
+      }
+    }
+  }
+
+  return splitCount;
+} // ---------------------------------------------------
+
+/**
+ * The polygons might have a lot of extra points, i.e. points
+ * in the middle of the edges.  Remove those points, but keep
+ * the original edges as polylines in the originalEdges array.
+ * Only original edges with more than two points will be kept.
+ *
+ * @param {Array[]} polys
+ * @param {vtkPoints} points
+ * @param {Array} polyEdges
+ * @param {Array} originalEdges
+ */
+
+function vtkCCSFindTrueEdges(polys, points, polyEdges, originalEdges) {
+  // Tolerance^2 for angle to see if line segments are parallel
+  var atol2 = CCS_POLYGON_TOLERANCE * CCS_POLYGON_TOLERANCE;
+  var p0 = [];
+  var p1 = [];
+  var p2 = [];
+  var v1 = [];
+  var v2 = [];
+  var l1;
+  var l2;
+
+  for (var polyId = 0; polyId < polys.length; polyId++) {
+    var oldPoly = polys[polyId];
+    var n = oldPoly.length;
+    var newEdges = [];
+    polyEdges.push(newEdges); // Only useful if poly has more than three sides
+
+    if (n < 4) {
+      newEdges[0] = -1;
+      newEdges[1] = -1;
+      newEdges[2] = -1; // eslint-disable-next-line no-continue
+
+      continue;
+    } // While we remove points, m keeps track of how many points are left
+
+
+    var m = n; // Compute bounds for tolerance
+
+    var bounds = [];
+    var tol2 = vtkPolygon.getBounds(oldPoly, points, bounds) * atol2; // The new poly
+
+    var newPoly = [];
+    var cornerPointId = 0;
+    var oldOriginalId = -1; // Keep the partial edge from before the first corner is found
+
+    var partialEdge = [];
+    var cellCount = 0;
+    points.getPoint(oldPoly[n - 1], p0);
+    points.getPoint(oldPoly[0], p1);
+    subtract(p1, p0, v1);
+    l1 = dot(v1, v1);
+
+    for (var j = 0; j < n; j++) {
+      var k = j + 1;
+
+      if (k >= n) {
+        k -= n;
+      }
+
+      points.getPoint(oldPoly[k], p2);
+      subtract(p2, p1, v2);
+      l2 = dot(v2, v2); // Dot product is |v1||v2|cos(theta)
+
+      var c = dot(v1, v2); // sin^2(theta) = (1 - cos^2(theta))
+      // and   c*c = l1*l2*cos^2(theta)
+
+      var s2 = l1 * l2 - c * c; // In the small angle approximation, sin(theta) == theta, so
+      // s2/(l1*l2) is the angle that we want to check, but it's not
+      // a valid check if l1 or l2 is very close to zero.
+
+      var pointId = oldPoly[j]; // Keep the point if:
+      // 1) removing it would create a 2-point poly OR
+      // 2) it's more than "tol" distance from the prev point AND
+      // 3) the angle is greater than atol:
+
+      if (m <= 3 || l1 > tol2 && (c < 0 || l1 < tol2 || l2 < tol2 || s2 > l1 * l2 * atol2)) {
+        // Complete the previous edge only if the final point count
+        // will be greater than two
+        if (cellCount > 1) {
+          if (pointId !== oldOriginalId) {
+            originalEdges.push(pointId);
+            cellCount++;
+          } // Update the number of segments in the edge
+
+
+          var countLocation = originalEdges.length - cellCount - 1;
+          originalEdges[countLocation] = cellCount;
+          newEdges.push(countLocation);
+        } else if (cellCount === 0) {
+          partialEdge.push(pointId);
+        } else {
+          newEdges.push(-1);
+        }
+
+        newPoly.push(pointId); // Start a new edge with cornerPointId as a "virtual" point
+
+        cornerPointId = pointId;
+        oldOriginalId = pointId;
+        cellCount = 1; // Rotate to the next point
+
+        p0[0] = p2[0];
+        p0[1] = p2[1];
+        p0[2] = p2[2];
+        p1[0] = p2[0];
+        p1[1] = p2[1];
+        p1[2] = p2[2];
+        v1[0] = v2[0];
+        v1[1] = v2[1];
+        v1[2] = v2[2];
+        l1 = l2;
+      } else {
+        if (cellCount > 0 && pointId !== oldOriginalId) {
+          // First check to see if we have to add cornerPointId
+          if (cellCount === 1) {
+            originalEdges.push(1); // new edge
+
+            originalEdges.push(cornerPointId);
+          } // Then add the new point
+
+
+          originalEdges.push(pointId);
+          oldOriginalId = pointId;
+          cellCount++;
+        } else {
+          // No corner yet, so save the point
+          partialEdge.push(pointId);
+        } // Reduce the count
+
+
+        m--; // Join the previous two segments, since the point was removed
+
+        p1[0] = p2[0];
+        p1[1] = p2[1];
+        p1[2] = p2[2];
+        subtract(p2, p0, v1);
+        l1 = dot(v1, v1);
+      }
+    } // Add the partial edge to the end
+
+
+    for (var ii = 0; ii < partialEdge.length; ii++) {
+      var _pointId = partialEdge[ii];
+
+      if (_pointId !== oldOriginalId) {
+        if (cellCount === 1) {
+          originalEdges.push(1); // new edge
+
+          originalEdges.push(cornerPointId);
+        }
+
+        originalEdges.push(_pointId);
+        oldOriginalId = _pointId;
+        cellCount++;
+      }
+    } // Finalize
+
+
+    if (cellCount > 1) {
+      // Update the number of segments in the edge
+      var _countLocation = originalEdges.length - cellCount - 1;
+
+      originalEdges[_countLocation] = cellCount;
+      newEdges.push(_countLocation);
+    }
+
+    polys[polyId] = newPoly;
+  }
+} // ---------------------------------------------------
+
+/**
+ * Reverse a cleaned-up polygon along with the info about
+ * all of its original vertices.
+ *
+ * @param {Array} poly
+ * @param {Array} edges
+ * @param {Array} originalEdges
+ */
+
+function vtkCCSReversePoly(poly, edges, originalEdges) {
+  reverseElements(poly, 1, poly.length - 1);
+  edges.reverse();
+
+  for (var i = 0; i < edges.length; i++) {
+    if (edges[i] >= 0) {
+      var firstPtsIdx = edges[i] + 1;
+      var npts = originalEdges[edges[i]];
+      reverseElements(originalEdges, firstPtsIdx, firstPtsIdx + npts - 1);
+    }
+  }
+} // ---------------------------------------------------
+
+/**
+ * Check the sense of the polygon against the given normal. Returns
+ * zero if the normal is zero.
+ *
+ * @param {Array} poly
+ * @param {vtkPoints} points
+ * @param {Vector3} normal
+ */
+
+function vtkCCSCheckPolygonSense(poly, points, normal) {
+  // Compute the normal
+  var pnormal = [0.0, 0.0, 0.0];
+  var p0 = [];
+  var p1 = [];
+  var p2 = [];
+  var v1 = [];
+  var v2 = [];
+  var v = [];
+  points.getPoint(poly[0], p0);
+  points.getPoint(poly[1], p1);
+  subtract(p1, p0, v1);
+
+  for (var jj = 2; jj < poly.length; jj++) {
+    points.getPoint(poly[jj], p2);
+    subtract(p2, p0, v2);
+    cross(v1, v2, v);
+    add(pnormal, v, pnormal);
+    p1[0] = p2[0];
+    p1[1] = p2[1];
+    p1[2] = p2[2];
+    v1[0] = v2[0];
+    v1[1] = v2[1];
+    v1[2] = v2[2];
+  } // Check the normal
+
+
+  var d = dot(pnormal, normal);
+  return {
+    isNormalNotZero: d !== 0,
+    sense: d > 0
+  };
+} // ---------------------------------------------------
+
+/**
+ * Check whether innerPoly is inside outerPoly.
+ * The normal is needed to verify the polygon orientation.
+ * The values of pp, bounds, and tol2 must be precomputed
+ * by calling vtkCCSPrepareForPolyInPoly() on outerPoly.
+ *
+ * @param {Array} outerPoly
+ * @param {Array} innerPoly
+ * @param {vtkPoints} points
+ * @param {Vector3} normal
+ * @param {Float64Array} pp
+ * @param {Bounds} bounds
+ * @param {Number} tol2
+ */
+
+function vtkCCSPolyInPoly(outerPoly, innerPoly, points, normal, pp, bounds, tol2) {
+  // Find a vertex of poly "j" that isn't on the edge of poly "i".
+  // This is necessary or the PointInPolygon might return "true"
+  // based only on roundoff error.
+  var n = outerPoly.length;
+  var m = innerPoly.length;
+  var p = [];
+  var q1 = [];
+  var q2 = [];
+
+  for (var jj = 0; jj < m; jj++) {
+    // Semi-randomize the point order
+    // eslint-disable-next-line no-bitwise
+    var kk = (jj >> 1) + (jj & 1) * (m + 1 >> 1);
+    points.getPoint(innerPoly[kk], p);
+    var intersectionState = vtkPolygon.pointInPolygon(p, pp, bounds, normal);
+
+    if (intersectionState === PolygonWithPointIntersectionState.FAILURE) {
+      vtkErrorMacro('Error finding point in polygon in vtkCCSPolyInPoly');
+    }
+
+    if (intersectionState !== PolygonWithPointIntersectionState.OUTSIDE) {
+      var pointOnEdge = 0;
+      points.getPoint(outerPoly[n - 1], q1);
+
+      for (var ii = 0; ii < n; ii++) {
+        points.getPoint(outerPoly[ii], q2); // This method returns distance squared
+
+        var _vtkLine$distanceToLi = vtkLine.distanceToLine(p, q1, q2),
+            distance = _vtkLine$distanceToLi.distance;
+
+        if (distance < tol2) {
+          pointOnEdge = 1;
+          break;
+        }
+
+        q1[0] = q2[0];
+        q1[1] = q2[1];
+        q1[2] = q2[2];
+      }
+
+      if (!pointOnEdge) {
+        // Good result, point is in polygon
+        return true;
+      }
+    }
+  } // No matches found
+
+
+  return false;
+} // ---------------------------------------------------
+
+/**
+ * Precompute values needed for the PolyInPoly check.
+ * The values that are returned are as follows:
+ * pp: an array of the polygon vertices
+ * bounds: the polygon bounds
+ * tol2: a tolerance value based on the size of the polygon
+ * (note: pp must be pre-allocated to the 3*outerPoly.length)
+ *
+ * @param {Array} outerPoly
+ * @param {vtkPoints} points
+ * @param {Float64Array} pp
+ * @param {Bounds} bounds
+ */
+
+function vtkCCSPrepareForPolyInPoly(outerPoly, points, pp, bounds) {
+  var n = outerPoly.length;
+
+  if (n === 0) {
+    return 0.0; // to avoid false positive warning about uninitialized value
+  } // Pull out the points
+
+
+  var point = [];
+  var j = 0;
+
+  for (var i = 0; i < n; i++) {
+    points.getPoint(outerPoly[i], point);
+    pp[j++] = point[0];
+    pp[j++] = point[1];
+    pp[j++] = point[2];
+  } // Find the bounding box and tolerance for the polygon
+
+
+  return vtkPolygon.getBounds(outerPoly, points, bounds) * (CCS_POLYGON_TOLERANCE * CCS_POLYGON_TOLERANCE);
+} // ---------------------------------------------------
+
+/**
+ * Check for polygons within polygons. Group the polygons
+ * if they are within each other. Reverse the sense of
+ * the interior "hole" polygons. A hole within a hole
+ * will be reversed twice and will become its own group.
+ *
+ * @param {Array} newPolys
+ * @param {vtkPoints} points
+ * @param {Array} polyGroups
+ * @param {Array} polyEdges
+ * @param {Array} originalEdges
+ * @param {Vector3} normal
+ * @param {Boolean} oriented
+ */
+
+function vtkCCSMakeHoleyPolys(newPolys, points, polyGroups, polyEdges, originalEdges, normal, oriented) {
+  var numNewPolys = newPolys.length;
+
+  if (numNewPolys <= 1) {
+    return;
+  } // Use bit arrays to keep track of inner polys
+
+
+  var polyReversed = [];
+  var innerPolys = []; // GroupCount is an array only needed for unoriented polys
+
+  var groupCount;
+
+  if (!oriented) {
+    groupCount = new Int32Array(numNewPolys);
+  } // Find the maximum poly size
+
+
+  var nmax = 1;
+
+  for (var kk = 0; kk < numNewPolys; kk++) {
+    nmax = Math.max(nmax, newPolys[kk].length);
+  } // These are some values needed for poly-in-poly checks
+
+
+  var pp = new Float64Array(3 * nmax);
+  var bounds = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
+  var tol2; // Go through all polys
+
+  for (var i = 0; i < numNewPolys; i++) {
+    var n = newPolys[i].length;
+
+    if (n < 3) {
+      // eslint-disable-next-line no-continue
+      continue;
+    } // Check if poly is reversed
+
+
+    var _vtkCCSCheckPolygonSe = vtkCCSCheckPolygonSense(newPolys[i], points, normal),
+        isNormalNotZero = _vtkCCSCheckPolygonSe.isNormalNotZero,
+        sense = _vtkCCSCheckPolygonSe.sense;
+
+    if (isNormalNotZero) {
+      polyReversed[i] = !sense;
+    } // Precompute some values needed for poly-in-poly checks
+
+
+    tol2 = vtkCCSPrepareForPolyInPoly(newPolys[i], points, pp, bounds); // Look for polygons inside of this one
+
+    for (var j = 0; j < numNewPolys; j++) {
+      if (j !== i && newPolys[j].length >= 3) {
+        // Make sure polygon i is not in polygon j
+        var pg = polyGroups[j];
+
+        if (!pg.includes(i)) {
+          if (vtkCCSPolyInPoly(newPolys[i], newPolys[j], points, normal, pp.subarray(3 * n), bounds, tol2)) {
+            // Add to group
+            polyGroups[i].push(j);
+
+            if (groupCount) {
+              groupCount[j] += 1;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (!oriented) {
+    // build a stack of polys that aren't inside other polys=
+    var outerPolyStack = [];
+
+    for (var ll = 0; ll < numNewPolys; ll++) {
+      if (groupCount[ll] === 0) {
+        outerPolyStack.push(ll);
+      }
+    }
+
+    var _j;
+
+    while (outerPolyStack.length > 0) {
+      _j = outerPolyStack.length - 1;
+      outerPolyStack.pop();
+
+      if (polyReversed[_j]) {
+        vtkCCSReversePoly(newPolys[_j], polyEdges[_j], originalEdges);
+        polyReversed[_j] = false;
+      }
+
+      if (polyGroups[_j].length > 1) {
+        // Convert the group into a bit array, to make manipulation easier
+        innerPolys.length = 0;
+
+        for (var k = 1; k < polyGroups[_j].length; k++) {
+          var jj = polyGroups[_j][k];
+
+          if (groupCount[jj] > 1) {
+            groupCount[jj] -= 2;
+
+            if (groupCount[jj] === 0) {
+              outerPolyStack.push(jj);
+            }
+          } else {
+            innerPolys[jj] = 1;
+            polyGroups[jj].length = 0;
+
+            if (!polyReversed[jj]) {
+              vtkCCSReversePoly(newPolys[jj], polyEdges[jj], originalEdges);
+              polyReversed[jj] = false;
+            }
+          }
+        } // Use the bit array to recreate the polyGroup
+
+
+        polyGroups[_j].length = 0;
+
+        polyGroups[_j].push(_j);
+
+        for (var _jj2 = 0; _jj2 < numNewPolys; _jj2++) {
+          if (innerPolys[_jj2]) {
+            polyGroups[_j].push(_jj2);
+          }
+        }
+      }
+    }
+  } else {
+    // oriented
+    for (var _j2 = 0; _j2 < numNewPolys; _j2++) {
+      // Remove the groups for reversed polys
+      if (polyReversed[_j2]) {
+        polyGroups[_j2].length = 0;
+      } // Polys inside the interior polys have their own groups, so remove
+      // them from this group
+      else if (polyGroups[_j2].length > 1) {
+        // Convert the group into a bit array, to make manipulation easier
+        innerPolys.length = 0;
+
+        for (var _k = 1; _k < polyGroups[_j2].length; _k++) {
+          innerPolys[polyGroups[_j2][_k]] = true;
+        } // Look for non-reversed polys inside this one
+
+
+        for (var _kk = 1; _kk < polyGroups[_j2].length; _kk++) {
+          // jj is the index of the inner poly
+          var _jj3 = polyGroups[_j2][_kk]; // If inner poly is not reversed then
+
+          if (!polyReversed[_jj3]) {
+            // Remove that poly and all polys inside of it from the group
+            for (var ii = 0; ii < polyGroups[_jj3].length; ii++) {
+              innerPolys[polyGroups[_jj3][ii]] = false;
+            }
+          }
+        } // Use the bit array to recreate the polyGroup
+
+
+        polyGroups[_j2].length = 0;
+
+        polyGroups[_j2].push(_j2);
+
+        for (var _jj4 = 0; _jj4 < numNewPolys; _jj4++) {
+          if (innerPolys[_jj4]) {
+            polyGroups[_j2].push(_jj4);
+          }
+        }
+      }
+    }
+  } // delete[] groupCount;
+
+} // ---------------------------------------------------
+
+/**
+ * Check line segment with point Ids (i, j) to make sure that it
+ * doesn't cut through the edges of any polys in the group.
+ * Return value of zero means check failed and the cut is not
+ * usable.
+ *
+ * @param {Array[]} polys
+ * @param {vtkPoints} points
+ * @param {Vector3} normal
+ * @param {Array} polyGroup
+ * @param {Number} outerPolyId
+ * @param {Number} innerPolyId
+ * @param {Number} outerIdx
+ * @param {Number} innerIdx
+ */
+
+function vtkCCSCheckCut(polys, points, normal, polyGroup, outerPolyId, innerPolyId, outerIdx, innerIdx) {
+  var ptId1 = polys[outerPolyId][outerIdx];
+  var ptId2 = polys[innerPolyId][innerIdx];
+  var tol = CCS_POLYGON_TOLERANCE;
+  var p1 = [];
+  var p2 = [];
+  points.getPoint(ptId1, p1);
+  points.getPoint(ptId2, p2);
+  var w = [];
+  subtract(p2, p1, w);
+  var l = normalize(w); // Cuts between coincident points are good
+
+  if (l === 0) {
+    return true;
+  } // Define a tolerance with units of distance squared
+
+
+  var tol2 = l * l * tol * tol; // Check the sense of the cut: it must be pointing "in" for both polys.
+
+  var polyId = outerPolyId;
+  var polyIdx = outerIdx;
+  var r = p1;
+  var r1 = [];
+  var r2 = p2;
+  var r3 = [];
+
+  for (var ii = 0; ii < 2; ii++) {
+    var poly = polys[polyId];
+    var n = poly.length;
+    var prevIdx = n - polyIdx - 1;
+    var nextIdx = polyIdx + 1;
+
+    if (prevIdx >= n) {
+      prevIdx -= n;
+    }
+
+    if (nextIdx >= n) {
+      nextIdx -= n;
+    }
+
+    points.getPoint(poly[prevIdx], r1);
+    points.getPoint(poly[nextIdx], r3);
+
+    if (vtkCCSVectorProgression(r, r1, r2, r3, normal) > 0) {
+      return false;
+    }
+
+    polyId = innerPolyId;
+    polyIdx = innerIdx;
+    r = p2;
+    r2 = p1;
+  } // Check for intersections of the cut with polygon edges.
+  // First, create a cut plane that divides space at the cut line.
+
+
+  var pc = [];
+  cross(normal, w, pc);
+  pc[3] = -dot(pc, p1);
+
+  for (var i = 0; i < polyGroup.length; i++) {
+    var _poly2 = polys[polyGroup[i]];
+    var _n = _poly2.length;
+    var q1 = [];
+    var q2 = [];
+    var qtId1 = _poly2[_n - 1];
+    points.getPoint(qtId1, q1);
+    var v1 = pc[0] * q1[0] + pc[1] * q1[1] + pc[2] * q1[2] + pc[3];
+    var c1 = v1 > 0;
+
+    for (var j = 0; j < _n; j++) {
+      var qtId2 = _poly2[j];
+      points.getPoint(qtId2, q2);
+      var v2 = pc[0] * q2[0] + pc[1] * q2[1] + pc[2] * q2[2] + pc[3];
+      var c2 = v2 > 0; // If lines share an endpoint, they can't intersect,
+      // so don't bother with the check.
+
+      if (ptId1 !== qtId1 && ptId1 !== qtId2 && ptId2 !== qtId1 && ptId2 !== qtId2) {
+        // Check for intersection
+        if ((c1 ? !c2 : c2) || v1 * v1 < tol2 || v2 * v2 < tol2) {
+          subtract(q2, q1, w);
+
+          if (dot(w, w) > 0) {
+            var qc = [];
+            cross(w, normal, qc);
+            qc[3] = -dot(qc, q1);
+            var u1 = qc[0] * p1[0] + qc[1] * p1[1] + qc[2] * p1[2] + qc[3];
+            var u2 = qc[0] * p2[0] + qc[1] * p2[1] + qc[2] * p2[2] + qc[3];
+            var d1 = u1 > 0;
+            var d2 = u2 > 0;
+
+            if (d1 ? !d2 : d2) {
+              // One final check to make sure endpoints aren't coincident
+              var p = p1;
+              var q = q1;
+
+              if (v2 * v2 < v1 * v1) {
+                p = p2;
+              }
+
+              if (u2 * u2 < u1 * u1) {
+                q = q2;
+              }
+
+              if (distance2BetweenPoints(p, q) > tol2) {
+                return false;
+              }
+            }
+          }
+        }
+      }
+
+      qtId1 = qtId2;
+      q1[0] = q2[0];
+      q1[1] = q2[1];
+      q1[2] = q2[2];
+      v1 = v2;
+      c1 = c2;
+    }
+  }
+
+  return true;
+} // ---------------------------------------------------
+
+/**
+ * Check the quality of a cut between an outer and inner polygon.
+ * An ideal cut is one that forms a 90 degree angle with each
+ * line segment that it joins to.  Smaller values indicate a
+ * higher quality cut.
+ *
+ * @param {Array} outerPoly
+ * @param {Array} innerPoly
+ * @param {Number} i
+ * @param {Number} j
+ * @param {vtkPoints} points
+ */
+
+function vtkCCSCutQuality(outerPoly, innerPoly, i, j, points) {
+  var n = outerPoly.length;
+  var m = innerPoly.length;
+  var a = i > 0 ? i - 1 : n - 1;
+  var b = i < n - 1 ? i + 1 : 0;
+  var c = j > 0 ? j - 1 : m - 1;
+  var d = j < m - 1 ? j + 1 : 0;
+  var p0 = [];
+  var p1 = [];
+  var p2 = [];
+  points.getPoint(outerPoly[i], p1);
+  points.getPoint(innerPoly[j], p2);
+  var v1 = [];
+  var v2 = [];
+  subtract(p2, p1, v1);
+  var l1 = dot(v1, v1);
+  var l2;
+  var qmax = 0;
+  var q;
+  points.getPoint(outerPoly[a], p0);
+  subtract(p0, p1, v2);
+  l2 = dot(v2, v2);
+
+  if (l2 > 0) {
+    q = dot(v1, v2);
+    q *= q / l2;
+
+    if (q > qmax) {
+      qmax = q;
+    }
+  }
+
+  points.getPoint(outerPoly[b], p0);
+  subtract(p0, p1, v2);
+  l2 = dot(v2, v2);
+
+  if (l2 > 0) {
+    q = dot(v1, v2);
+    q *= q / l2;
+
+    if (q > qmax) {
+      qmax = q;
+    }
+  }
+
+  points.getPoint(innerPoly[c], p0);
+  subtract(p2, p0, v2);
+  l2 = dot(v2, v2);
+
+  if (l2 > 0) {
+    q = dot(v1, v2);
+    q *= q / l2;
+
+    if (q > qmax) {
+      qmax = q;
+    }
+  }
+
+  points.getPoint(innerPoly[d], p0);
+  subtract(p2, p0, v2);
+  l2 = dot(v2, v2);
+
+  if (l2 > 0) {
+    q = dot(v1, v2);
+    q *= q / l2;
+
+    if (q > qmax) {
+      qmax = q;
+    }
+  }
+
+  if (l1 > 0) {
+    return qmax / l1; // also l1 + qmax, incorporates distance;
+  }
+
+  return Number.MAX_VALUE;
+} // ---------------------------------------------------
+
+/**
+ * Find the two sharpest verts on an inner (i.e. inside-out) poly.
+ *
+ * @param {Array} poly
+ * @param {vtkPoints} points
+ * @param {Vector3} normal
+ * @param {[Number, Number]} verts
+ */
+
+function vtkCCSFindSharpestVerts(poly, points, normal, verts) {
+  var p1 = [];
+  var p2 = [];
+  var v1 = [];
+  var v2 = [];
+  var v = [];
+  var l1;
+  var l2;
+  var minVal = [0, 0];
+  verts[0] = 0;
+  verts[1] = 0;
+  var n = poly.length;
+  points.getPoint(poly[n - 1], p2);
+  points.getPoint(poly[0], p1);
+  subtract(p1, p2, v1);
+  l1 = Math.sqrt(dot(v1, v1));
+
+  for (var j = 0; j < n; j++) {
+    var k = j + 1;
+
+    if (k === n) {
+      k = 0;
+    }
+
+    points.getPoint(poly[k], p2);
+    subtract(p2, p1, v2);
+    l2 = Math.sqrt(dot(v2, v2));
+    cross(v1, v2, v);
+    var b = dot(v, normal);
+
+    if (b < 0 && l1 * l2 > 0) {
+      // Dot product is |v1||v2|cos(theta), range [-1, +1]
+      var val = dot(v1, v2) / (l1 * l2);
+
+      if (val < minVal[0]) {
+        minVal[1] = minVal[0];
+        minVal[0] = val;
+        verts[1] = verts[0];
+        verts[0] = j;
+      }
+    } // Rotate to the next point
+
+
+    p1[0] = p2[0];
+    p1[1] = p2[1];
+    p1[2] = p2[2];
+    v1[0] = v2[0];
+    v1[1] = v2[1];
+    v1[2] = v2[2];
+    l1 = l2;
+  }
+} // ---------------------------------------------------
+
+/**
+ * Find two valid cuts between outerPoly and innerPoly.
+ * Used by vtkCCSCutHoleyPolys.
+ *
+ * @param {Array} polys
+ * @param {Array} polyGroup
+ * @param {Number} outerPolyId
+ * @param {Number} innerPolyId
+ * @param {vtkPoints} points
+ * @param {Vector3} normal
+ * @param {Array[]} cuts
+ * @param {Boolean} exhaustive
+ */
+
+function vtkCCSFindCuts(polys, polyGroup, outerPolyId, innerPolyId, points, normal, cuts, exhaustive) {
+  var outerPoly = polys[outerPolyId];
+  var innerPoly = polys[innerPolyId];
+  var innerSize = innerPoly.length; // Find the two sharpest points on the inner poly
+
+  var verts = [];
+  vtkCCSFindSharpestVerts(innerPoly, points, normal, verts); // A list of cut locations according to quality
+
+  var cutlist = [];
+  cutlist.length = outerPoly.length; // Search for potential cuts (need to find two cuts)
+
+  var cutId = 0;
+  cuts[0][0] = 0;
+  cuts[0][1] = 0;
+  cuts[1][0] = 0;
+  cuts[1][1] = 0;
+  var foundCut = false;
+
+  for (cutId = 0; cutId < 2; cutId++) {
+    var count = exhaustive ? innerSize : 3;
+
+    for (var i = 0; i < count && !foundCut; i++) {
+      // Semi-randomize the search order
+      // TODO: Does this do the same as in C++?
+      // eslint-disable-next-line no-bitwise
+      var j = (i >> 1) + (i & 1) * (innerSize + 1 >> 1); // Start at the best first point
+
+      j = (j + verts[cutId]) % innerSize;
+
+      for (var kk = 0; kk < outerPoly.length; kk++) {
+        var q = vtkCCSCutQuality(outerPoly, innerPoly, kk, j, points);
+        cutlist[kk] = [q, kk];
+      }
+
+      cutlist.sort(function (a, b) {
+        return a[0] - b[0];
+      });
+
+      for (var lid = 0; lid < cutlist.length; lid++) {
+        var k = cutlist[lid][1]; // If this is the second cut, do extra checks
+
+        if (cutId > 0) {
+          // Make sure cuts don't share an endpoint
+          if (j === cuts[0][1] || k === cuts[0][0]) {
+            // eslint-disable-next-line no-continue
+            continue;
+          } // Make sure cuts don't intersect
+
+
+          var p1 = [];
+          var p2 = [];
+          points.getPoint(outerPoly[cuts[0][0]], p1);
+          points.getPoint(innerPoly[cuts[0][1]], p2);
+          var q1 = [];
+          var q2 = [];
+          points.getPoint(outerPoly[k], q1);
+          points.getPoint(innerPoly[j], q2);
+          var u = void 0;
+          var v = void 0;
+
+          if (vtkLine.intersection(p1, p2, q1, q2, u, v) === vtkLine.IntersectionState.YES_INTERSECTION) {
+            // eslint-disable-next-line no-continue
+            continue;
+          }
+        } // This check is done for both cuts
+
+
+        if (vtkCCSCheckCut(polys, points, normal, polyGroup, outerPolyId, innerPolyId, k, j)) {
+          cuts[cutId][0] = k;
+          cuts[cutId][1] = j;
+          foundCut = true;
+          break;
+        }
+      }
+    }
+
+    if (!foundCut) {
+      return false;
+    }
+  }
+
+  return true;
+} // ---------------------------------------------------
+
+/**
+ * Helper for vtkCCSCutHoleyPolys.  Change a polygon and a hole
+ * into two separate polygons by making two cuts between them.
+ *
+ * @param {Array[]} polys
+ * @param {Array} polyEdges
+ * @param {Number} outerPolyId
+ * @param {Number} innerPolyId
+ * @param {vtkPoints} points
+ * @param {Array[]} cuts
+ */
+
+function vtkCCSMakeCuts(polys, polyEdges, outerPolyId, innerPolyId, points, cuts) {
+  var q = [];
+  var r = [];
+
+  for (var bb = 0; bb < 2; bb++) {
+    var ptId1 = polys[outerPolyId][cuts[bb][0]];
+    var ptId2 = polys[innerPolyId][cuts[bb][1]];
+    points.getPoint(ptId1, q);
+    points.getPoint(ptId2, r);
+  }
+
+  var outerPoly = polys[outerPolyId];
+  var innerPoly = polys[innerPolyId];
+  var outerEdges = polyEdges[outerPolyId];
+  var innerEdges = polyEdges[innerPolyId]; // Generate new polys from the cuts
+
+  var n = outerPoly.length;
+  var m = innerPoly.length;
+  var idx; // Generate poly1
+
+  var n1 = n * (cuts[1][0] < cuts[0][0]) + cuts[1][0] - cuts[0][0] + 1;
+  var n2 = n1 + m * (cuts[0][1] < cuts[1][1]) + cuts[0][1] - cuts[1][1] + 1;
+  var poly1 = [];
+  poly1.length = n2;
+  var edges1 = new Array(n2);
+  idx = cuts[0][0];
+
+  for (var i1 = 0; i1 < n1; i1++) {
+    var k = idx++;
+    poly1[i1] = outerPoly[k];
+    edges1[i1] = outerEdges[k];
+    idx *= idx !== n;
+  }
+
+  edges1[n1 - 1] = -1;
+  idx = cuts[1][1];
+
+  for (var i2 = n1; i2 < n2; i2++) {
+    var _k2 = idx++;
+
+    poly1[i2] = innerPoly[_k2];
+    edges1[i2] = innerEdges[_k2];
+    idx *= idx !== m;
+  }
+
+  edges1[n2 - 1] = -1; // Generate poly2
+
+  var m1 = n * (cuts[0][0] < cuts[1][0]) + cuts[0][0] - cuts[1][0] + 1;
+  var m2 = m1 + m * (cuts[1][1] < cuts[0][1]) + cuts[1][1] - cuts[0][1] + 1;
+  var poly2 = [];
+  poly2.length = m2;
+  var edges2 = new Array(m2);
+  idx = cuts[1][0];
+
+  for (var j1 = 0; j1 < m1; j1++) {
+    var _k3 = idx++;
+
+    poly2[j1] = outerPoly[_k3];
+    edges2[j1] = outerEdges[_k3];
+    idx *= idx !== n;
+  }
+
+  edges2[m1 - 1] = -1;
+  idx = cuts[0][1];
+
+  for (var j2 = m1; j2 < m2; j2++) {
+    var _k4 = idx++;
+
+    poly2[j2] = innerPoly[_k4];
+    edges2[j2] = innerEdges[_k4];
+    idx *= idx !== m;
+  }
+
+  edges2[m2 - 1] = -1; // Replace outerPoly and innerPoly with these new polys
+
+  polys[outerPolyId] = poly1;
+  polys[innerPolyId] = poly2;
+  polyEdges[outerPolyId] = edges1;
+  polyEdges[innerPolyId] = edges2;
+} // ---------------------------------------------------
+
+/**
+ * After the holes have been identified, make cuts between the
+ * outer poly and each hole.  Make two cuts per hole.  The only
+ * strict requirement is that the cut must not intersect any
+ * edges, but it's best to make sure that no really sharp angles
+ * are created.
+ *
+ * @param {Array[]} polys
+ * @param {vtkPoints} points
+ * @param {Array[]} polyGroups
+ * @param {Array} polyEdges
+ * @param {Vector3} normal
+ * @returns {boolean}
+ */
+
+function vtkCCSCutHoleyPolys(polys, points, polyGroups, polyEdges, normal) {
+  var cutFailure = 0; // Go through all groups and cut out the first inner poly that is
+  // found.  Every time an inner poly is cut out, the groupId counter
+  // is reset because cutting a poly creates a new group.
+
+  var groupId = 0;
+
+  while (groupId < polyGroups.length) {
+    var polyGroup = polyGroups[groupId]; // Only need to make a cut if the group size is greater than 1
+
+    if (polyGroup.length > 1) {
+      // The first member of the group is the outer poly
+      var outerPolyId = polyGroup[0]; // The second member of the group is the first inner poly
+
+      var innerPolyId = polyGroup[1]; // Sort the group by size, do largest holes first
+
+      var innerBySize = new Array(polyGroup.length);
+
+      for (var i = 1; i < polyGroup.length; i++) {
+        innerBySize[i] = [polys[polyGroup[i]].length, i];
+      }
+
+      innerBySize = [innerBySize[0]].concat(_toConsumableArray(innerBySize.splice(1).sort(function (a, b) {
+        return a[0] - b[0];
+      })));
+      reverseElements(innerBySize, 1, innerBySize.length - 1); // Need to check all inner polys in sequence, until one succeeds.
+      // Do a quick search first, then do an exhaustive search.
+
+      var madeCut = 0;
+      var inner = 0;
+
+      for (var exhaustive = 0; exhaustive < 2 && !madeCut; exhaustive++) {
+        for (var j = 1; j < polyGroup.length; j++) {
+          inner = innerBySize[j][1];
+          innerPolyId = polyGroup[inner];
+          var cuts = [];
+
+          if (vtkCCSFindCuts(polys, polyGroup, outerPolyId, innerPolyId, points, normal, cuts, exhaustive)) {
+            vtkCCSMakeCuts(polys, polyEdges, outerPolyId, innerPolyId, points, cuts);
+            madeCut = 1;
+            break;
+          }
+        }
+      }
+
+      if (madeCut) {
+        // Move successfully cut innerPolyId into its own group
+        polyGroup.splice(inner, 1); // Only add if innerPolyId hasn't been set already.
+        // Having the same poly occur as both polyGroup and
+        // innerPoly would cause an infinite loop.
+
+        if (polyGroups[innerPolyId].length === 0) {
+          polyGroups[innerPolyId].push(innerPolyId);
+        }
+      } else {
+        // Remove all failed inner polys from the group
+        for (var k = 1; k < polyGroup.length; k++) {
+          innerPolyId = polyGroup[k]; // Only add if innerPolyId hasn't been set already.
+          // Having the same poly occur as both polyGroup and
+          // innerPoly would cause an infinite loop.
+
+          if (polyGroups[innerPolyId].length === 0) {
+            polyGroups[innerPolyId].push(innerPolyId);
+          }
+        }
+
+        polyGroup.length = 1;
+        cutFailure = 1;
+      } // If there are other interior polys in the group, find out whether
+      // they are in poly1 or poly2
+
+
+      if (polyGroup.length > 1) {
+        var poly1 = polys[outerPolyId];
+        var pp = new Float64Array(3 * poly1.length);
+        var bounds = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
+        var tol2 = vtkCCSPrepareForPolyInPoly(poly1, points, pp, bounds);
+        var nextGroupId = groupId;
+        var ii = 1;
+
+        while (ii < polyGroup.length) {
+          if (vtkCCSPolyInPoly(poly1, polys[polyGroup[ii]], points, normal, pp, bounds, tol2)) {
+            // Keep this poly in polyGroup
+            ii++;
+          } else {
+            // Move this poly to poly2 group
+            polyGroups[innerPolyId].push(polyGroup[ii]);
+            polyGroup.splice(ii, 1); // Reduce the groupId to ensure that this new group will get cut
+
+            if (innerPolyId < nextGroupId) {
+              nextGroupId = innerPolyId;
+            }
+          }
+        } // Set the groupId for the next iteration
+
+
+        groupId = nextGroupId; // eslint-disable-next-line no-continue
+
+        continue;
+      }
+    } // Increment to the next group
+
+
+    groupId++;
+  }
+
+  return !cutFailure;
+}
+
+export { reverseElements, vtkCCSCheckCut, vtkCCSCheckPolygonSense, vtkCCSCutHoleyPolys, vtkCCSCutQuality, vtkCCSFindCuts, vtkCCSFindSharpestVerts, vtkCCSFindTrueEdges, vtkCCSInsertTriangle, vtkCCSJoinLooseEnds, vtkCCSMakeCuts, vtkCCSMakeHoleyPolys, vtkCCSMakePolysFromLines, vtkCCSPolyInPoly, vtkCCSPrepareForPolyInPoly, vtkCCSReversePoly, vtkCCSSplitAtPinchPoints, vtkCCSTriangleQuality, vtkCCSTriangulate, vtkCCSVectorProgression };