@kitware/vtk.js 23.4.3 → 23.4.4

package/Common/DataModel/Quad.d.ts

@@ -0,0 +1,91 @@
+import { Vector3, Vector4 } from './../../types';
+import vtkCell, { ICellInitialValues } from './Cell';
+import { IIntersectWithLine } from './Triangle';
+
+export interface IQuadInitialValues extends ICellInitialValues {}
+
+export interface vtkQuad extends vtkCell {
+  getCellType(): number;
+  /**
+   * Get the topological dimensional of the cell (0, 1, 2 or 3).
+   */
+  getCellDimension(): number;
+  getNumberOfEdges(): number;
+  getNumberOfFaces(): number;
+
+  /**
+   * Compute the intersection point of the intersection between quad and
+   * line defined by p1 and p2. tol Tolerance use for the position evaluation
+   * x is the point which intersect triangle (computed in function) pcoords
+   * parametric coordinates (computed in function) A javascript object is
+   * returned :
+   *
+   * ```js
+   * {
+   *    evaluation: define if the triangle has been intersected or not
+   *    subId: always set to 0
+   *    t: parametric coordinate along the line.
+   *    betweenPoints: Define if the intersection is between input points
+   * }
+   * ```
+   *
+   * @param {Vector3} p1 The first point coordinate.
+   * @param {Vector3} p2 The second point coordinate.
+   * @param {Number} tol The tolerance to use.
+   * @param {Vector3} x The point which intersect triangle.
+   * @param {Vector3} pcoords The parametric coordinates.
+   */
+  intersectWithLine(
+    p1: Vector3,
+    p2: Vector3,
+    tol: number,
+    x: Vector3,
+    pcoords: Vector3
+  ): IIntersectWithLine;
+
+  /**
+   * Determine global coordinate (x]) from subId and parametric coordinates.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector3} x The x point coordinate.
+   * @param {Number[]} weights The number of weights.
+   */
+  evaluateLocation(pcoords: Vector3, x: Vector3, weights: number[]): void;
+
+  /*
+   *  Compute iso-parametric interpolation functions
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector4} sf out weights.
+   */
+  interpolationFunctions(pcoords: Vector3, sf: Vector4);
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkQuad characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IQuadInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IQuadInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkQuad.
+ * @param {IQuadInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IQuadInitialValues): vtkQuad;
+
+/**
+ * vtkQuad is a cell which represents a quadrilateral. It may contain static
+ * methods to make some computations directly link to quads.
+ *
+ * @see vtkCell
+ */
+export declare const vtkQuad: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkQuad;

package/Common/DataModel/Quad.js

@@ -0,0 +1,235 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../macros.js';
+import vtkCell from './Cell.js';
+import { e as distance2BetweenPoints } from '../Core/Math/index.js';
+import { CellType } from './CellTypes/Constants.js';
+import vtkTriangle from './Triangle.js';
+import vtkPoints from '../Core/Points.js';
+
+function intersectionStruct() {
+  return {
+    intersected: false,
+    subId: -1,
+    x: [0.0, 0.0, 0.0],
+    pCoords: [0.0, 0.0, 0.0],
+    t: -1
+  };
+}
+
+function vtkQuad(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkQuad');
+
+  publicAPI.getCellDimension = function () {
+    return 2;
+  };
+
+  publicAPI.getCellType = function () {
+    return CellType.VTK_QUAD;
+  };
+
+  publicAPI.getNumberOfEdges = function () {
+    return 4;
+  };
+
+  publicAPI.getNumberOfFaces = function () {
+    return 0;
+  };
+
+  publicAPI.intersectWithLine = function (p1, p2, tol, x, pcoords) {
+    var _points, _points2, _points3, _points4, _points5, _points6, _points7, _points8, _points9, _points10, _points11, _points12;
+
+    var outObj = {
+      subId: 0,
+      t: Number.MAX_VALUE,
+      intersect: 0,
+      betweenPoints: false
+    };
+    var diagonalCase;
+    var point0 = model.points.getPoint(0, []);
+    var point1 = model.points.getPoint(1, []);
+    var point2 = model.points.getPoint(2, []);
+    var point3 = model.points.getPoint(3, []);
+    var d1 = distance2BetweenPoints(point0, point2);
+    var d2 = distance2BetweenPoints(point1, point3);
+    /* Figure out how to uniquely tessellate the quad. Watch out for
+     * equivalent triangulations (i.e., the triangulation is equivalent
+     * no matter where the diagonal). In this case use the point ids as
+     * a tie breaker to ensure unique triangulation across the quad.
+     */
+    // rare case; discriminate based on point id
+
+    if (d1 === d2) {
+      // find the maximum id
+      var id;
+      var maxId = 0;
+      var maxIdx = 0;
+
+      for (var i = 0; i < 4; i++) {
+        id = model.pointsIds[i];
+
+        if (id > maxId) {
+          maxId = id;
+          maxIdx = i;
+        }
+      }
+
+      if (maxIdx === 0 || maxIdx === 2) {
+        diagonalCase = 0;
+      } else {
+        diagonalCase = 1;
+      }
+    } else if (d1 < d2) {
+      diagonalCase = 0;
+    } else {
+      diagonalCase = 1;
+    }
+
+    var points = null;
+
+    if (!model.triangle) {
+      model.triangle = vtkTriangle.newInstance();
+      points = vtkPoints.newInstance();
+      points.setNumberOfPoints(3);
+      model.triangle.initialize(points);
+    } else {
+      points = model.triangle.getPoints();
+    }
+
+    var firstIntersect;
+    var firstIntersectTmpObj = intersectionStruct();
+    var secondIntersect;
+    var secondIntersectTmpObj = intersectionStruct();
+    var useFirstIntersection;
+    var useSecondIntersection;
+
+    switch (diagonalCase) {
+      case 0:
+        (_points = points).setPoint.apply(_points, [0].concat(_toConsumableArray(point0)));
+
+        (_points2 = points).setPoint.apply(_points2, [1].concat(_toConsumableArray(point1)));
+
+        (_points3 = points).setPoint.apply(_points3, [2].concat(_toConsumableArray(point2)));
+
+        firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
+
+        (_points4 = points).setPoint.apply(_points4, [0].concat(_toConsumableArray(point2)));
+
+        (_points5 = points).setPoint.apply(_points5, [1].concat(_toConsumableArray(point3)));
+
+        (_points6 = points).setPoint.apply(_points6, [2].concat(_toConsumableArray(point0)));
+
+        secondIntersect = model.triangle.intersectWithLine(p1, p2, tol, secondIntersectTmpObj.x, secondIntersectTmpObj.pCoords);
+        useFirstIntersection = firstIntersect.intersect && secondIntersect.intersect ? firstIntersect.t <= secondIntersect.t : firstIntersect.intersect;
+        useSecondIntersection = firstIntersect.intersect && secondIntersect.intersect ? secondIntersect.t < firstIntersect.t : secondIntersect.intersect;
+
+        if (useFirstIntersection) {
+          outObj = firstIntersect;
+          x[0] = firstIntersectTmpObj.x[0];
+          x[1] = firstIntersectTmpObj.x[1];
+          x[2] = firstIntersectTmpObj.x[2];
+          pcoords[0] = firstIntersectTmpObj.pCoords[0] + firstIntersectTmpObj.pCoords[1];
+          pcoords[1] = firstIntersectTmpObj.pCoords[1];
+          pcoords[2] = firstIntersectTmpObj.pCoords[2];
+        } else if (useSecondIntersection) {
+          outObj = secondIntersect;
+          x[0] = secondIntersectTmpObj.x[0];
+          x[1] = secondIntersectTmpObj.x[1];
+          x[2] = secondIntersectTmpObj.x[2];
+          pcoords[0] = 1.0 - (secondIntersectTmpObj.pCoords[0] + secondIntersectTmpObj.pCoords[1]);
+          pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
+          pcoords[2] = secondIntersectTmpObj.pCoords[2];
+        }
+
+        break;
+
+      case 1:
+        (_points7 = points).setPoint.apply(_points7, [0].concat(_toConsumableArray(point0)));
+
+        (_points8 = points).setPoint.apply(_points8, [1].concat(_toConsumableArray(point1)));
+
+        (_points9 = points).setPoint.apply(_points9, [2].concat(_toConsumableArray(point3)));
+
+        firstIntersect = model.triangle.intersectWithLine(p1, p2, tol, firstIntersectTmpObj.x, firstIntersectTmpObj.pCoords);
+
+        (_points10 = points).setPoint.apply(_points10, [0].concat(_toConsumableArray(point2)));
+
+        (_points11 = points).setPoint.apply(_points11, [1].concat(_toConsumableArray(point3)));
+
+        (_points12 = points).setPoint.apply(_points12, [2].concat(_toConsumableArray(point1)));
+
+        secondIntersect = model.triangle.intersectWithLine(p1, p2, tol, secondIntersectTmpObj.x, secondIntersectTmpObj.pCoords);
+        useFirstIntersection = firstIntersect.intersect && secondIntersect.intersect ? firstIntersect.t <= secondIntersect.t : firstIntersect.intersect;
+        useSecondIntersection = firstIntersect.intersect && secondIntersect.intersect ? secondIntersect.t < firstIntersect.t : secondIntersect.intersect;
+
+        if (useFirstIntersection) {
+          outObj = firstIntersect;
+          x[0] = firstIntersectTmpObj.x[0];
+          x[1] = firstIntersectTmpObj.x[1];
+          x[2] = firstIntersectTmpObj.x[2];
+          pcoords[0] = firstIntersectTmpObj.pCoords[0];
+          pcoords[1] = firstIntersectTmpObj.pCoords[1];
+          pcoords[2] = firstIntersectTmpObj.pCoords[2];
+        } else if (useSecondIntersection) {
+          outObj = secondIntersect;
+          x[0] = secondIntersectTmpObj.x[0];
+          x[1] = secondIntersectTmpObj.x[1];
+          x[2] = secondIntersectTmpObj.x[2];
+          pcoords[0] = 1 - secondIntersectTmpObj.pCoords[0];
+          pcoords[1] = 1 - secondIntersectTmpObj.pCoords[1];
+          pcoords[2] = secondIntersectTmpObj.pCoords[2];
+        }
+
+        break;
+    }
+
+    return outObj;
+  };
+
+  publicAPI.interpolationFunctions = function (pcoords, weights) {
+    var rm = 1 - pcoords[0];
+    var sm = 1 - pcoords[1];
+    weights[0] = rm * sm;
+    weights[1] = pcoords[0] * sm;
+    weights[2] = pcoords[0] * pcoords[1];
+    weights[3] = rm * pcoords[1];
+  };
+
+  publicAPI.evaluateLocation = function (pcoords, x, weights) {
+    var point = []; // Calculate the weights
+
+    publicAPI.interpolationFunctions(pcoords, weights);
+    x[0] = 0.0;
+    x[1] = 0.0;
+    x[2] = 0.0;
+
+    for (var i = 0; i < 4; i++) {
+      model.points.getPoint(i, point);
+
+      for (var j = 0; j < 3; j++) {
+        x[j] += point[j] * weights[i];
+      }
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkCell.extend(publicAPI, model, initialValues);
+  vtkQuad(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkQuad'); // ----------------------------------------------------------------------------
+
+var vtkQuad$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkQuad$1 as default, extend, newInstance };

package/Common/DataModel/SelectionNode/Constants.d.ts

@@ -0,0 +1,27 @@
+export declare enum SelectionContent {
+    GLOBALIDS = 0,
+    PEDIGREEIDS = 1,
+    VALUES = 2,
+    INDICES = 3,
+    FRUSTUM = 4,
+    LOCATIONS = 5,
+    THRESHOLDS = 6,
+    BLOCKS = 7,
+    QUERY = 8,
+}
+
+export declare enum SelectionField {
+    CELL = 0,
+    POINT = 1,
+    FIELD = 2,
+    VERTEX = 3,
+    EDGE = 4,
+    ROW = 5,
+}
+
+declare const _default: {
+    SelectionContent: typeof SelectionContent;
+    SelectionField: typeof SelectionField;
+}
+
+export default _default;

package/Common/DataModel/Spline1D/Constants.js

@@ -0,0 +1,17 @@
+// Boundary conditions available to compute open splines
+// DEFAULT : desired slope at boundary point is derivative from two points (boundary and second interior)
+// DERIVATIVE : desired slope at boundary point is the boundary value given.
+// SECOND_DERIVATIVE : second derivative at boundary point is the boundary value given.
+// SECOND_DERIVATIVE_INTERIOR_POINT : desired second derivative at boundary point is the boundary value given times second derivative
+// at first interior point.
+var BoundaryCondition = {
+  DEFAULT: 0,
+  DERIVATIVE: 1,
+  SECOND_DERIVATIVE: 2,
+  SECOND_DERIVATIVE_INTERIOR_POINT: 3
+};
+var Constants = {
+  BoundaryCondition: BoundaryCondition
+};
+
+export { BoundaryCondition, Constants as default };

package/Common/DataModel/Spline3D/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum splineKind {
+	CARDINAL_SPLINE = 'CARDINAL_SPLINE',
+	KOCHANEK_SPLINE = 'KOCHANEK_SPLINE',
+}
+
+declare const _default: {
+	splineKind: typeof splineKind;
+};
+export default _default;

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 { f 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/Filters/Core/PolyDataNormals.js

@@ -0,0 +1,124 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkTriangle from '../../Common/DataModel/Triangle.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+// vtkPolyDataNormals methods
+// ----------------------------------------------------------------------------
+
+function vtkPolyDataNormals(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPolyDataNormals');
+
+  publicAPI.vtkPolyDataNormalsExecute = function (pointsData, polysData) {
+    if (!pointsData) {
+      return null;
+    }
+
+    var normalsData = new Float32Array(pointsData.length);
+    var numberOfPoints = 0;
+    var polysDataLength = polysData.length;
+    var cellPointIds = [0, 0, 0];
+
+    for (var c = 0; c < polysDataLength; c += numberOfPoints + 1) {
+      numberOfPoints = polysData[c];
+
+      if (numberOfPoints < 3) {
+        continue; // eslint-disable-line
+      }
+
+      for (var i = 1; i <= 3; ++i) {
+        cellPointIds[i - 1] = 3 * polysData[c + i];
+      }
+
+      var cellNormal = [];
+      vtkTriangle.computeNormal(pointsData.slice(cellPointIds[0], cellPointIds[0] + 3), pointsData.slice(cellPointIds[1], cellPointIds[1] + 3), pointsData.slice(cellPointIds[2], cellPointIds[2] + 3), cellNormal);
+
+      for (var _i = 1; _i <= numberOfPoints; ++_i) {
+        var pointId = 3 * polysData[c + _i];
+        normalsData[pointId] += cellNormal[0];
+        normalsData[++pointId] += cellNormal[1];
+        normalsData[++pointId] += cellNormal[2];
+      }
+    }
+    /* Normalize normals */
+
+
+    for (var _i2 = 0; _i2 < pointsData.length;) {
+      var pointNormal = normalsData.slice(_i2, _i2 + 3);
+      vtkMath.normalize(pointNormal);
+      normalsData[_i2++] = pointNormal[0];
+      normalsData[_i2++] = pointNormal[1];
+      normalsData[_i2++] = pointNormal[2];
+    }
+
+    return normalsData;
+  };
+
+  publicAPI.requestData = function (inData, outData) {
+    var numberOfInputs = publicAPI.getNumberOfInputPorts();
+
+    if (!numberOfInputs) {
+      return;
+    }
+
+    var input = inData[0];
+
+    if (!input) {
+      return;
+    }
+
+    var outputNormalsData = publicAPI.vtkPolyDataNormalsExecute(input.getPoints().getData(), input.getPolys().getData());
+    var output = vtkPolyData.newInstance();
+    var outputNormals = vtkDataArray.newInstance({
+      numberOfComponents: 3,
+      values: outputNormalsData
+    });
+    output.setPoints(input.getPoints());
+    output.setVerts(input.getVerts());
+    output.setLines(input.getLines());
+    output.setPolys(input.getPolys());
+    output.setStrips(input.getStrips());
+    output.getPointData().passData(input.getPointData());
+    output.getCellData().passData(input.getCellData());
+    output.getFieldData().passData(input.getFieldData());
+    output.getPointData().setNormals(outputNormals);
+    outData[0] = output;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+function defaultValues(initialValues) {
+  return _objectSpread({}, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
+  /* Make this a VTK object */
+
+  macro.obj(publicAPI, model);
+  /* Also make it an algorithm with one input and one output */
+
+  macro.algo(publicAPI, model, 1, 1);
+  /* Object specific methods */
+
+  vtkPolyDataNormals(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkPolyDataNormals'); // ----------------------------------------------------------------------------
+
+var vtkPolyDataNormals$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkPolyDataNormals$1 as default, extend, newInstance };

package/Filters/General/ClipClosedSurface/Constants.js

@@ -0,0 +1,10 @@
+var ScalarMode = {
+  NONE: 0,
+  COLORS: 1,
+  LABELS: 2
+};
+var Constants = {
+  ScalarMode: ScalarMode
+};
+
+export { ScalarMode, Constants as default };

package/Filters/General/ClipClosedSurface.d.ts

@@ -0,0 +1,95 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+import vtkPlane from './../../Common/DataModel/Plane';
+
+/**
+ *
+ */
+export enum ScalarMode {
+	NONE,
+	COLORS,
+	LABELS,
+}
+
+/**
+ *
+ */
+export interface IClipClosedSurfaceInitialValues {
+	clippingPlanes?: vtkPlane[];
+	tolerance?: number;
+	passPointData?: boolean;
+	triangulatePolys?: boolean;
+	scalarMode?: ScalarMode;
+	generateOutline?: boolean;
+	generateFaces?: boolean;
+	activePlaneId?: number;
+	baseColor?: Vector3;
+	clipColor?: Vector3;
+	activePlaneColor?: Vector3;
+	triangulationErrorDisplay?: boolean;
+}
+
+type vtkClipClosedSurfaceBase = vtkObject & vtkAlgorithm;
+
+export interface vtkClipClosedSurface extends vtkClipClosedSurfaceBase {
+	/**
+	 *
+	 * @param {any} inData
+	 * @param {any} outData
+	 */
+	requestData(inData: any, outData: any): void;
+
+	/**
+	 * Set scalarMode to NONE.
+	 */
+	setScalarModeToNone(): void;
+
+	/**
+	 * Set scalarMode to COLOR.
+	 */
+	setScalarModeToColor(): void;
+
+	/**
+	 * Set scalarMode to LABEL.
+	 */
+	setScalarModeToLabel(): void;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkClipClosedSurface characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {object} [initialValues] (default: {})
+ */
+export function extend(
+	publicAPI: object,
+	model: object,
+	initialValues?: IClipClosedSurfaceInitialValues
+): void;
+
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to create a new instance of vtkClipClosedSurface
+ * @param {IClipClosedSurfaceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+	initialValues?: IClipClosedSurfaceInitialValues
+): vtkClipClosedSurface;
+
+/**
+ * vtkClipClosedSurface
+ */
+export declare const vtkClipClosedSurface: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	// constants
+	ScalarMode: typeof ScalarMode;
+};
+
+export default vtkClipClosedSurface;