@kitware/vtk.js 26.0.0-beta.2 → 26.0.0-beta.4

package/Common/DataModel/IncrementalOctreeNode.js

@@ -56,6 +56,20 @@ function vtkIncrementalOctreeNode(publicAPI, model) {
     bounds[3] = model.maxBounds[1];
     bounds[4] = model.minBounds[2];
     bounds[5] = model.maxBounds[2];
+  };
+
+  publicAPI.getChildIndex = function (point) {
+    return Number(point[0] > model.children[0].getMaxBoundsByReference()[0]) + ( // eslint-disable-next-line no-bitwise
+    Number(point[1] > model.children[0].getMaxBoundsByReference()[1]) << 1) + ( // eslint-disable-next-line no-bitwise
+    Number(point[2] > model.children[0].getMaxBoundsByReference()[2]) << 2);
+  };
+
+  publicAPI.containsPoint = function (pnt) {
+    return model.minBounds[0] < pnt[0] && pnt[0] <= model.maxBounds[0] && model.minBounds[1] < pnt[1] && pnt[1] <= model.maxBounds[1] && model.minBounds[2] < pnt[2] && pnt[2] <= model.maxBounds[2] ? 1 : 0;
+  };
+
+  publicAPI.containsPointByData = function (pnt) {
+    return model.minDataBounds[0] <= pnt[0] && pnt[0] <= model.maxDataBounds[0] && model.minDataBounds[1] <= pnt[1] && pnt[1] <= model.maxDataBounds[1] && model.minDataBounds[2] <= pnt[2] && pnt[2] <= model.maxDataBounds[2] ? 1 : 0;
   }; //------------------------------------------------------------------------------
 
 
@@ -118,6 +132,8 @@ function vtkIncrementalOctreeNode(publicAPI, model) {
     return model.children[i];
   }; //------------------------------------------------------------------------------
 
+  /* eslint-disable no-use-before-define */
+
 
   publicAPI.separateExactlyDuplicatePointsFromNewInsertion = function (points, pntIds, newPnt, pntIdx, maxPts, ptMode) {
     // the number of points already maintained in this leaf node
@@ -148,7 +164,7 @@ function vtkIncrementalOctreeNode(publicAPI, model) {
       boxPtr[2] = ocNode.maxBounds; // create eight child nodes
       // FIXME: May be too slow to use vtk newInstance()
 
-      ocNode.children = [vtkIncrementalOctreeNode.newInstance(), vtkIncrementalOctreeNode.newInstance(), vtkIncrementalOctreeNode.newInstance(), vtkIncrementalOctreeNode.newInstance(), vtkIncrementalOctreeNode.newInstance(), vtkIncrementalOctreeNode.newInstance(), vtkIncrementalOctreeNode.newInstance(), vtkIncrementalOctreeNode.newInstance()];
+      ocNode.children = [newInstance(), newInstance(), newInstance(), newInstance(), newInstance(), newInstance(), newInstance(), newInstance()];
 
       for (i = 0; i < 8; i++) {
         // x-bound: axis 0
@@ -160,7 +176,7 @@ function vtkIncrementalOctreeNode(publicAPI, model) {
 
         octMin[2] = boxPtr[OCTREE_CHILD_BOUNDS_LUT[i][2][0]][2];
         octMax[2] = boxPtr[OCTREE_CHILD_BOUNDS_LUT[i][2][1]][2];
-        ocNode.children[i] = vtkIncrementalOctreeNode.newInstance();
+        ocNode.children[i] = newInstance();
         ocNode.children[i].setParent(ocNode);
         ocNode.children[i].setBounds(octMin[0], octMax[0], octMin[1], octMax[1], octMin[2], octMax[2]);
       } // determine the leaf node of the duplicate points & that of the new point
@@ -186,7 +202,9 @@ function vtkIncrementalOctreeNode(publicAPI, model) {
     duplic.setPointIdSet(pntIds);
     duplic.updateCounterAndDataBoundsRecursively(dupPnt, pntIds.length, 1, publicAPI);
     return pointIdx;
-  }; //------------------------------------------------------------------------------
+  };
+  /* eslint-enable no-use-before-define */
+  //------------------------------------------------------------------------------
 
 
   publicAPI.createChildNodes = function (points, pntIds, newPnt, pntIdx, maxPts, ptMode, numberOfNodes) {
@@ -240,9 +258,10 @@ function vtkIncrementalOctreeNode(publicAPI, model) {
 
       octMin[2] = boxPtr[OCTREE_CHILD_BOUNDS_LUT[i][2][0]][2];
       octMax[2] = boxPtr[OCTREE_CHILD_BOUNDS_LUT[i][2][1]][2]; // This call internally sets the cener and default data bounding box, too.
+      // eslint-disable-next-line no-use-before-define
+
+      model.children[i] = newInstance(); // model.children[i].iD = nbNodes++;
 
-      model.children[i] = vtkIncrementalOctreeNode.newInstance();
-      model.children[i].iD = nbNodes++;
       model.children[i].setParent(publicAPI);
       model.children[i].setBounds(octMin[0], octMax[0], octMin[1], octMax[1], octMin[2], octMax[2]); // allocate a list of point-indices (size = 2^n) for index registration
       // eslint-disable-next-line no-bitwise
@@ -258,7 +277,7 @@ function vtkIncrementalOctreeNode(publicAPI, model) {
       tempId = pntIds[i];
       points.getPoint(tempId, tempPt);
       target = publicAPI.getChildIndex(tempPt);
-      model.children[target].getPointIdSet().insertNextId(tempId);
+      model.children[target].getPointIdSet().push(tempId);
       model.children[target].updateCounterAndDataBounds(tempPt);
       numIds[target]++;
     } // locate the full child, just if any
@@ -301,7 +320,7 @@ function vtkIncrementalOctreeNode(publicAPI, model) {
 
     for (i = 0; i < 8; i++) {
       if (numIds[i] === 0 || i === dvidId) {
-        model.children[i].deletePointIdSet();
+        model.children[i].getPointIdSet().length = 0;
       }
     } // notify vtkIncrementalOctreeNode::InsertPoint() to destroy pntIds
 
@@ -604,7 +623,7 @@ function extend(publicAPI, model) {
 
   macro.obj(publicAPI, model);
   macro.setGetArray(publicAPI, model, ['minBounds', 'maxBounds', 'minDataBounds', 'maxDataBounds'], 6);
-  macro.get(publicAPI, model, ['pointIdSet']); // TODO: No get?
+  macro.get(publicAPI, model, ['pointIdSet', 'numberOfPoints']); // TODO: No get?
 
   macro.set(publicAPI, model, ['parent']); // Object specific methods
 

package/Common/DataModel/IncrementalOctreePointLocator.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import macro from '../../macros.js';
 import { g as vtkMath } from '../Core/Math/index.js';
 import vtkBoundingBox from './BoundingBox.js';
@@ -65,6 +65,58 @@ function vtkIncrementalOctreePointLocator(publicAPI, model) {
 
     idList = null;
     return [pntIdx, dist2];
+  };
+
+  publicAPI.findClosestPointInSphere = function (point, radius2, maskNode, refDist2) {
+    var pointIndx = -1;
+    var minDist2 = Number.MAX_VALUE;
+    var nodesBase = [];
+    nodesBase.push(model.octreeRootNode);
+    var checkNode;
+    var childNode;
+    var distToData;
+    var tempDist2;
+    var tempPntId;
+
+    while (!nodesBase.length === 0 && minDist2 > 0.0) {
+      checkNode = nodesBase.top();
+      nodesBase.pop();
+
+      if (!checkNode.isLeaf()) {
+        for (var i = 0; i < 8; i++) {
+          childNode = checkNode.getChild(i); // use ( radius2 + radius2 ) to skip empty nodes
+
+          distToData = childNode.getNumberOfPoints() ? childNode.getDistance2ToBoundary(point, model.octreeRootNode, 1) : radius2 + radius2; // If a child node is not the mask node AND its distance, specifically
+          // the data bounding box (determined by the points inside or under) to
+          // the point, is less than the threshold radius (one exception is the
+          // point's container nodes), it is pushed to the stack as a suspect.
+
+          if (childNode !== maskNode && (distToData <= refDist2 || childNode.containsPoint(point) === 1)) {
+            nodesBase.push(childNode);
+          }
+
+          childNode = null;
+        }
+      } else {
+        // now that the node under check is a leaf, let's find the closest
+        // point therein and the minimum distance
+        var _publicAPI$findCloses = publicAPI.findClosestPointInLeafNode(checkNode, point);
+
+        var _publicAPI$findCloses2 = _slicedToArray(_publicAPI$findCloses, 2);
+
+        tempPntId = _publicAPI$findCloses2[0];
+        tempDist2 = _publicAPI$findCloses2[1];
+
+        if (tempDist2 < minDist2) {
+          minDist2 = tempDist2;
+          pointIndx = tempPntId;
+        }
+      }
+
+      checkNode = null;
+    }
+
+    return [minDist2 <= radius2 ? pointIndx : -1, minDist2];
   }; //------------------------------------------------------------------------------
 
 
@@ -130,6 +182,10 @@ function vtkIncrementalOctreePointLocator(publicAPI, model) {
     (_model$octreeRootNode = model.octreeRootNode).setBounds.apply(_model$octreeRootNode, _toConsumableArray(tmpBbox));
 
     return true;
+  };
+
+  publicAPI.findClosestPointInSphereWithTolerance = function (point, radius2, maskNode) {
+    return publicAPI.findClosestPointInSphere(point, radius2, maskNode, model.octreeMaxDimSize * model.octreeMaxDimSize * 4.0, radius2);
   }; //------------------------------------------------------------------------------
 
 
@@ -265,10 +321,10 @@ function vtkIncrementalOctreePointLocator(publicAPI, model) {
 
     var leafContainer = getLeafContainer(model.octreeRootNode, x);
 
-    var _publicAPI$findCloses = publicAPI.findClosestPointInLeafNode(leafContainer, x),
-        _publicAPI$findCloses2 = _slicedToArray(_publicAPI$findCloses, 2),
-        pointIdx = _publicAPI$findCloses2[0],
-        minDist2 = _publicAPI$findCloses2[1];
+    var _publicAPI$findCloses3 = publicAPI.findClosestPointInLeafNode(leafContainer, x),
+        _publicAPI$findCloses4 = _slicedToArray(_publicAPI$findCloses3, 2),
+        pointIdx = _publicAPI$findCloses4[0],
+        minDist2 = _publicAPI$findCloses4[1];
 
     if (minDist2 === 0.0) {
       return {

package/Common/DataModel/Polygon.js

@@ -156,10 +156,10 @@ function getBounds(poly, points, bounds) {
 
   for (var j = 1; j < n; j++) {
     points.getPoint(poly[j], p);
-    vtkBoundingBox.addPoint(bounds, p);
+    vtkBoundingBox.addPoint.apply(vtkBoundingBox, [bounds].concat(p));
   }
 
-  var length = vtkBoundingBox.getLength(bounds);
+  var length = vtkBoundingBox.getLengths(bounds);
   return dot(length, length);
 } // ---------------------------------------------------
 

package/Common/Transform/Transform.js

@@ -0,0 +1,51 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { vec3 } from 'gl-matrix';
+import macro from '../../macros.js';
+import { g as vtkMath } from '../Core/Math/index.js';
+import { IDENTITY } from '../Core/Math/Constants.js';
+
+// vtkTransform methods
+// ----------------------------------------------------------------------------
+// eslint-disable-next-line import/no-mutable-exports
+
+var newInstance;
+
+function vtkTransform(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkAbstractTransform', 'vtkHomogeneousTransform', 'vtkTransform');
+
+  publicAPI.transformPoint = function (point, out) {
+    vec3.transformMat4(out, point, model.matrix);
+    return out;
+  };
+
+  publicAPI.getInverse = function () {
+    return newInstance({
+      matrix: vtkMath.invertMatrix(Array.from(model.matrix), [], 4)
+    });
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  matrix: _toConsumableArray(IDENTITY)
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  macro.obj(publicAPI, model);
+  macro.setGetArray(publicAPI, model, ['matrix'], 16);
+  vtkTransform(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+newInstance = macro.newInstance(extend, 'vtkTransform');
+
+var vtkTransform$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkTransform$1 as default, extend, newInstance };

package/Common/Transform.js

@@ -1,7 +1,9 @@
 import vtkLandmarkTransform from './Transform/LandmarkTransform.js';
+import vtkTransform from './Transform/Transform.js';
 
 var Transform = {
-  vtkLandmarkTransform: vtkLandmarkTransform
+  vtkLandmarkTransform: vtkLandmarkTransform,
+  vtkTransform: vtkTransform
 };
 
 export { Transform as default };

package/Filters/General/ClipClosedSurface.js

@@ -9,8 +9,8 @@ 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';
-import CCSEdgeLocator from './ClipClosedSurface/ccsEdgeLocator.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; }
 
@@ -84,10 +84,10 @@ function vtkClipClosedSurface(publicAPI, model) {
     // Check to see if this point has already been computed
 
 
-    var node = locator.insertUniqueEdge(i0, i1);
+    var edge = locator.insertUniqueEdge(i0, i1);
 
-    if (node.edgeId !== -1) {
-      return node.edgeId;
+    if (edge.value != null) {
+      return edge.value;
     } // Get the edge and interpolate the new point
 
 
@@ -100,26 +100,26 @@ function vtkClipClosedSurface(publicAPI, model) {
     var tol2 = tol * tol; // Make sure that new point is far enough from kept point
 
     if (distance2BetweenPoints(p, p0) < tol2) {
-      node.edgeId = i0;
+      edge.value = i0;
       return i0;
     }
 
     if (distance2BetweenPoints(p, p1) < tol2) {
-      node.edgeId = i1;
+      edge.value = i1;
       return i1;
     }
 
-    node.edgeId = points.insertNextTuple(p);
-    pointData.interpolateData(pointData, i0, i1, node.edgeId, t);
-    return node.edgeId;
+    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 {vtvtkDataSetAttributesk} pointData
-   * @param {CCSEdgeLocator} edgeLocator
+   * @param {vtkDataSetAttributesk} pointData
+   * @param {vtkEdgeLocator} edgeLocator
    * @param {vtkCellArray} inputLines
    * @param {vtkCellArray} outputLines
    * @param {vtkDataSetAttributes} inLineData
@@ -353,7 +353,7 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkPoints} points
    * @param {vtkDataArray} pointScalars
    * @param {vtkDataSetAttributes} pointData
-   * @param {CCSEdgeLocator} edgeLocator
+   * @param {vtkEdgeLocator} edgeLocator
    * @param {Number} triangulate
    * @param {vtkCellArray} inputPolys
    * @param {vtkCellArray} outputPolys
@@ -611,7 +611,7 @@ function vtkClipClosedSurface(publicAPI, model) {
     } // An edge locator to avoid point duplication while clipping
 
 
-    var edgeLocator = new CCSEdgeLocator(); // A temporary polydata for the contour lines that are triangulated
+    var edgeLocator = vtkEdgeLocator.newInstance(); // A temporary polydata for the contour lines that are triangulated
 
     var tmpContourData = vtkPolyData.newInstance(); // The cell scalars
 
@@ -939,9 +939,12 @@ var DEFAULT_VALUES = {
   generateOutline: false,
   generateFaces: true,
   activePlaneId: -1,
-  baseColor: null,
-  clipColor: null,
-  activePlaneColor: null,
+  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,
 
 }; // ----------------------------------------------------------------------------
@@ -961,9 +964,9 @@ function extend(publicAPI, model) {
 
 var newInstance = macro.newInstance(extend, 'vtkClipClosedSurface'); // ----------------------------------------------------------------------------
 
-var index = _objectSpread({
+var vtkClipClosedSurface$1 = _objectSpread({
   newInstance: newInstance,
   extend: extend
 }, Constants);
 
-export { index as default, extend, newInstance };
+export { vtkClipClosedSurface$1 as default, extend, newInstance };

package/Filters/General/ContourTriangulator/helper.js

@@ -411,7 +411,7 @@ function vtkCCSMakePolysFromLines(polyData, firstLine, endLine, oriented, newPol
           }
         }
 
-        if (!matches.length === 0) {
+        if (matches.length > 0) {
           // Multiple matches mean we need to decide which path to take
           if (matches.length > 1) {
             // Remove double-backs

package/Filters/General/ImageMarchingCubes.js

@@ -1,5 +1,6 @@
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
+import vtkEdgeLocator from '../../Common/DataModel/EdgeLocator.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { m as normalize } from '../../Common/Core/Math/index.js';
 import vtkCaseTable from './ImageMarchingCubes/caseTable.js';
@@ -16,7 +17,7 @@ function vtkImageMarchingCubes(publicAPI, model) {
   var voxelScalars = [];
   var voxelGradients = [];
   var voxelPts = [];
-  var edgeMap = new Map(); // Retrieve scalars and voxel coordinates. i-j-k is origin of voxel.
+  var edgeLocator = vtkEdgeLocator.newInstance(); // Retrieve scalars and voxel coordinates. i-j-k is origin of voxel.
 
   publicAPI.getVoxelScalars = function (i, j, k, slice, dims, origin, spacing, s) {
     // First get the indices for the voxel
@@ -172,8 +173,6 @@ function vtkImageMarchingCubes(publicAPI, model) {
     var xyz = [];
     var n = [];
     var pId;
-    var tmp;
-    var edge = [];
     publicAPI.getVoxelScalars(i, j, k, slice, dims, origin, spacing, scalars);
     var index = 0;
 
@@ -203,16 +202,9 @@ function vtkImageMarchingCubes(publicAPI, model) {
         pId = undefined;
 
         if (model.mergePoints) {
-          edge[0] = ids[edgeVerts[0]];
-          edge[1] = ids[edgeVerts[1]];
+          var _edgeLocator$isInsert;
 
-          if (edge[0] > edge[1]) {
-            tmp = edge[0];
-            edge[0] = edge[1];
-            edge[1] = tmp;
-          }
-
-          pId = edgeMap.get(edge);
+          pId = (_edgeLocator$isInsert = edgeLocator.isInsertedEdge(ids[edgeVerts[0]], ids[edgeVerts[1]])) === null || _edgeLocator$isInsert === void 0 ? void 0 : _edgeLocator$isInsert.value;
         }
 
         if (pId === undefined) {
@@ -236,16 +228,7 @@ function vtkImageMarchingCubes(publicAPI, model) {
           }
 
           if (model.mergePoints) {
-            edge[0] = ids[edgeVerts[0]];
-            edge[1] = ids[edgeVerts[1]];
-
-            if (edge[0] > edge[1]) {
-              tmp = edge[0];
-              edge[0] = edge[1];
-              edge[1] = tmp;
-            }
-
-            edgeMap[edge] = pId;
+            edgeLocator.insertEdge(ids[edgeVerts[0]], ids[edgeVerts[1]], pId);
           }
         }
 

package/Filters/General/ImageMarchingSquares.js

@@ -1,5 +1,6 @@
 import macro from '../../macros.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkEdgeLocator from '../../Common/DataModel/EdgeLocator.js';
 import vtkCaseTable from './ImageMarchingSquares/caseTable.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro,
@@ -23,7 +24,7 @@ function vtkImageMarchingSquares(publicAPI, model) {
   var ids = [];
   var pixelScalars = [];
   var pixelPts = [];
-  var edgeMap = new Map(); // Retrieve scalars and pixel coordinates. i-j-k is origin of pixel.
+  var edgeLocator = vtkEdgeLocator.newInstance(); // Retrieve scalars and pixel coordinates. i-j-k is origin of pixel.
 
   publicAPI.getPixelScalars = function (i, j, k, slice, dims, origin, spacing, s) {
     // First get the indices for the pixel
@@ -63,8 +64,6 @@ function vtkImageMarchingSquares(publicAPI, model) {
 
     var xyz = [];
     var pId;
-    var tmp;
-    var edge = [];
     publicAPI.getPixelScalars(i, j, k, slice, dims, origin, spacing, scalars);
     var index = 0;
 
@@ -91,16 +90,9 @@ function vtkImageMarchingSquares(publicAPI, model) {
         pId = undefined;
 
         if (model.mergePoints) {
-          edge[0] = ids[edgeVerts[0]];
-          edge[1] = ids[edgeVerts[1]];
+          var _edgeLocator$isInsert;
 
-          if (edge[0] > edge[1]) {
-            tmp = edge[0];
-            edge[0] = edge[1];
-            edge[1] = tmp;
-          }
-
-          pId = edgeMap.get(edge);
+          pId = (_edgeLocator$isInsert = edgeLocator.isInsertedEdge(ids[edgeVerts[0]], ids[edgeVerts[1]])) === null || _edgeLocator$isInsert === void 0 ? void 0 : _edgeLocator$isInsert.value;
         }
 
         if (pId === undefined) {
@@ -113,16 +105,7 @@ function vtkImageMarchingSquares(publicAPI, model) {
           points.push(xyz[0], xyz[1], z);
 
           if (model.mergePoints) {
-            edge[0] = ids[edgeVerts[0]];
-            edge[1] = ids[edgeVerts[1]];
-
-            if (edge[0] > edge[1]) {
-              tmp = edge[0];
-              edge[0] = edge[1];
-              edge[1] = tmp;
-            }
-
-            edgeMap[edge] = pId;
+            edgeLocator.insertEdge(ids[edgeVerts[0]], ids[edgeVerts[1]], pId);
           }
         }
 
@@ -166,7 +149,7 @@ function vtkImageMarchingSquares(publicAPI, model) {
         }
       }
 
-      edgeMap.clear();
+      edgeLocator.initialize();
     } // Update output
 
 

package/Filters/General.js

@@ -1,12 +1,15 @@
 import vtkAppendPolyData from './General/AppendPolyData.js';
 import vtkCalculator from './General/Calculator.js';
+import vtkClipClosedSurface from './General/ClipClosedSurface.js';
 import vtkClosedPolyLineToSurfaceFilter from './General/ClosedPolyLineToSurfaceFilter.js';
+import vtkContourTriangulator from './General/ContourTriangulator.js';
 import vtkImageCropFilter from './General/ImageCropFilter.js';
 import vtkImageMarchingCubes from './General/ImageMarchingCubes.js';
 import vtkImageMarchingSquares from './General/ImageMarchingSquares.js';
 import vtkImageOutlineFilter from './General/ImageOutlineFilter.js';
 import vtkImageSliceFilter from './General/ImageSliceFilter.js';
 import vtkImageStreamline from './General/ImageStreamline.js';
+import vtkLineFilter from './General/LineFilter.js';
 import vtkMoleculeToRepresentation from './General/MoleculeToRepresentation.js';
 import vtkOBBTree from './General/OBBTree.js';
 import vtkOutlineFilter from './General/OutlineFilter.js';
@@ -20,13 +23,16 @@ import vtkWindowedSincPolyDataFilter from './General/WindowedSincPolyDataFilter.
 var General = {
   vtkAppendPolyData: vtkAppendPolyData,
   vtkCalculator: vtkCalculator,
+  vtkClipClosedSurface: vtkClipClosedSurface,
   vtkClosedPolyLineToSurfaceFilter: vtkClosedPolyLineToSurfaceFilter,
+  vtkContourTriangulator: vtkContourTriangulator,
   vtkImageCropFilter: vtkImageCropFilter,
   vtkImageMarchingCubes: vtkImageMarchingCubes,
   vtkImageMarchingSquares: vtkImageMarchingSquares,
   vtkImageOutlineFilter: vtkImageOutlineFilter,
   vtkImageSliceFilter: vtkImageSliceFilter,
   vtkImageStreamline: vtkImageStreamline,
+  vtkLineFilter: vtkLineFilter,
   vtkMoleculeToRepresentation: vtkMoleculeToRepresentation,
   vtkOBBTree: vtkOBBTree,
   vtkOutlineFilter: vtkOutlineFilter,