@kitware/vtk.js 34.6.0 → 34.8.0

package/Common/Core/Math/index.js

@@ -258,6 +258,16 @@ function normalize(x) {
   }
   return den;
 }
+function normalize4D(x) {
+  const den = norm(x, 3);
+  if (den !== 0.0) {
+    x[0] /= den;
+    x[1] /= den;
+    x[2] /= den;
+    x[3] /= den;
+  }
+  return den;
+}
 function perpendiculars(x, y, z, theta) {
   const x2 = x[0] * x[0];
   const y2 = x[1] * x[1];
@@ -2171,6 +2181,7 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   cross: cross,
   norm: norm,
   normalize: normalize,
+  normalize4D: normalize4D,
   perpendiculars: perpendiculars,
   projectVector: projectVector,
   dot2D: dot2D,
@@ -2256,4 +2267,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { Pi as $, rowsToMat3 as A, degreesFromRadians as B, ldexp as C, xyz2rgb as D, areEquals as E, clampValue as F, arrayRange as G, getMajorAxisIndex as H, createUninitializedBounds as I, identity as J, multiplyMatrix as K, floor as L, isInf as M, rgb2hsv as N, rgb2lab as O, lab2rgb as P, round as Q, normalize2D as R, nearestPowerOfTwo as S, multiply3x3_vect3 as T, getSparseOrthogonalMatrix as U, areBoundsInitialized as V, floatRGB2HexCode as W, isPowerOfTwo as X, angleBetweenVectors as Y, signedAngleBetweenVectors as Z, createArray as _, areMatricesEqual as a, floatToHex2 as a$, ceil as a0, min as a1, max as a2, arrayMin as a3, arrayMax as a4, ceilLog2 as a5, factorial as a6, binomial as a7, beginCombination as a8, nextCombination as a9, roundNumber as aA, matrix3x3ToQuaternion as aB, multiplyQuaternion as aC, orthogonalize3x3 as aD, diagonalize3x3 as aE, singularValueDecomposition3x3 as aF, luFactorLinearSystem as aG, luSolveLinearSystem as aH, estimateMatrixCondition as aI, solveHomogeneousLeastSquares as aJ, solveLeastSquares as aK, hex2float as aL, lab2xyz as aM, xyz2lab as aN, rgb2xyz as aO, computeBoundsFromPoints as aP, clampAndNormalizeValue as aQ, getScalarTypeFittingRange as aR, getAdjustedScalarRange as aS, extentIsWithinOtherExtent as aT, boundsIsWithinOtherBounds as aU, pointIsWithinBounds as aV, solve3PointCircle as aW, inf as aX, negInf as aY, isFinite as aZ, isNaN as a_, randomSeed as aa, getSeed as ab, gaussian as ac, multiplyScalar2D as ad, multiplyAccumulate2D as ae, outer as af, projectVector as ag, dot2D as ah, projectVector2D as ai, gaussianAmplitude as aj, gaussianWeight as ak, outer2D as al, norm2D as am, rowsToMat4 as an, columnsToMat4 as ao, columnsToMat3 as ap, LUFactor3x3 as aq, LUSolve3x3 as ar, linearSolve3x3 as as, multiply3x3_mat3 as at, transpose3x3 as au, invert3x3 as av, identity3x3 as aw, isIdentity as ax, isIdentity3x3 as ay, quaternionToMatrix3x3 as az, roundVector as b, float2CssRGBA as b0, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, invertMatrix as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };
+export { createArray as $, rowsToMat3 as A, degreesFromRadians as B, ldexp as C, xyz2rgb as D, areEquals as E, clampValue as F, arrayRange as G, getMajorAxisIndex as H, createUninitializedBounds as I, normalize4D as J, identity as K, multiplyMatrix as L, floor as M, isInf as N, rgb2hsv as O, rgb2lab as P, lab2rgb as Q, round as R, normalize2D as S, nearestPowerOfTwo as T, multiply3x3_vect3 as U, getSparseOrthogonalMatrix as V, areBoundsInitialized as W, floatRGB2HexCode as X, isPowerOfTwo as Y, angleBetweenVectors as Z, signedAngleBetweenVectors as _, areMatricesEqual as a, isNaN as a$, Pi as a0, ceil as a1, min as a2, max as a3, arrayMin as a4, arrayMax as a5, ceilLog2 as a6, factorial as a7, binomial as a8, beginCombination as a9, quaternionToMatrix3x3 as aA, roundNumber as aB, matrix3x3ToQuaternion as aC, multiplyQuaternion as aD, orthogonalize3x3 as aE, diagonalize3x3 as aF, singularValueDecomposition3x3 as aG, luFactorLinearSystem as aH, luSolveLinearSystem as aI, estimateMatrixCondition as aJ, solveHomogeneousLeastSquares as aK, solveLeastSquares as aL, hex2float as aM, lab2xyz as aN, xyz2lab as aO, rgb2xyz as aP, computeBoundsFromPoints as aQ, clampAndNormalizeValue as aR, getScalarTypeFittingRange as aS, getAdjustedScalarRange as aT, extentIsWithinOtherExtent as aU, boundsIsWithinOtherBounds as aV, pointIsWithinBounds as aW, solve3PointCircle as aX, inf as aY, negInf as aZ, isFinite as a_, nextCombination as aa, randomSeed as ab, getSeed as ac, gaussian as ad, multiplyScalar2D as ae, multiplyAccumulate2D as af, outer as ag, projectVector as ah, dot2D as ai, projectVector2D as aj, gaussianAmplitude as ak, gaussianWeight as al, outer2D as am, norm2D as an, rowsToMat4 as ao, columnsToMat4 as ap, columnsToMat3 as aq, LUFactor3x3 as ar, LUSolve3x3 as as, linearSolve3x3 as at, multiply3x3_mat3 as au, transpose3x3 as av, invert3x3 as aw, identity3x3 as ax, isIdentity as ay, isIdentity3x3 as az, roundVector as b, floatToHex2 as b0, float2CssRGBA as b1, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, invertMatrix as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };

package/Common/Core/Math.d.ts

@@ -203,7 +203,7 @@ export function getSeed(): number;
 export function random(minValue: number, maxValue: number): number;
 
 /**
- * Addition of two 3-vectors.
+ * Add two 3-vectors.
  * @param {Vector3} a The first 3D vector.
  * @param {Vector3} b The second 3D vector.
  * @param {Vector3} out The output 3D vector.
@@ -215,7 +215,7 @@ export function random(minValue: number, maxValue: number): number;
 export function add(a: Vector3, b: Vector3, out: Vector3): Vector3;
 
 /**
- * Subtraction of two 3-vectors.
+ * Substract two 3-vectors.
  * @param {Vector3} a The first 3D vector.
  * @param {Vector3} b The second 3D vector.
  * @param {Vector3} out The output 3D vector.
@@ -227,7 +227,7 @@ export function add(a: Vector3, b: Vector3, out: Vector3): Vector3;
 export function subtract(a: Vector3, b: Vector3, out: Vector3): Vector3;
 
 /**
- *
+ * Multiply a 3-vector by a scalar.
  * @param {Vector3} vec
  * @param {Number} scalar
  * @example
@@ -238,7 +238,7 @@ export function subtract(a: Vector3, b: Vector3, out: Vector3): Vector3;
 export function multiplyScalar(vec: Vector3, scalar: number): Vector3;
 
 /**
- *
+ * Multiply a 3-vector by a scalar.
  * @param {Vector2} vec
  * @param {Number} scalar
  * @example
@@ -249,7 +249,7 @@ export function multiplyScalar(vec: Vector3, scalar: number): Vector3;
 export function multiplyScalar2D(vec: Vector2, scalar: number): Vector2;
 
 /**
- *
+ * Multiply two 3-vectors.
  * @param {Vector3} a
  * @param {Vector3} b
  * @param {Number} scalar
@@ -267,7 +267,7 @@ export function multiplyAccumulate(
 ): Vector3;
 
 /**
- *
+ * Multiply two 2-vectors.
  * @param {Vector2} a
  * @param {Vector2} b
  * @param {Number} scalar
@@ -285,7 +285,7 @@ export function multiplyAccumulate2D(
 ): Vector2;
 
 /**
- *
+ * Dot product of two 3-vectors.
  * @param {Vector3} x
  * @param {Vector3} y
  * @example
@@ -312,17 +312,23 @@ export function outer(x: Vector3, y: Vector3, out_3x3: Matrix3x3): void;
 export function cross(x: Vector3, y: Vector3, out: Vector3): Vector3;
 
 /**
- *
- * @param {Number[]} x
- * @param {Number} n
+ * Compute the norm of a vector.
+ * @param {Number[]} x The vector to compute the norm of.
+ * @param {Number} [n] The number of components to consider (default is 3).
  */
-export function norm(x: number[], n: number): number;
+export function norm(x: number[], n?: number): number;
 
 /**
  * Normalize in place. Returns norm.
- * @param {Vector3} x The vector to normlize.
+ * @param {Number[]} x The vector to normalize.
  */
-export function normalize(x: Vector3): number;
+export function normalize(x: number[]): number;
+
+/**
+ * Normalize in place. Returns norm.
+ * @param {Number[]} x The vector to normalize.
+ */
+export function normalize4D(x: number[]): number;
 
 /**
  * Given a unit vector v1, find two unit vectors v2 and v3 such that v1 cross v2 = v3
@@ -339,10 +345,10 @@ export function perpendiculars(
 ): void;
 
 /**
- *
- * @param {Vector3} a
- * @param {Vector3} b
- * @param {Vector3} projection
+ * Project vector `a` onto vector `b` and returns the result in projection vector.
+ * @param {Vector3} a The first 3D vector.
+ * @param {Vector3} b The second 3D vector.
+ * @param {Vector3} projection The projection 3D vector.
  */
 export function projectVector(
   a: Vector3,
@@ -351,7 +357,7 @@ export function projectVector(
 ): boolean;
 
 /**
- *
+ * Compute the dot product of two 2D vectors.
  * @param {Vector2} x
  * @param {Vector2} y
  */

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import 'seedrandom';
 import '../../macros2.js';
 import './Math/Constants.js';
-export { aq as LUFactor3x3, ar as LUSolve3x3, $ as Pi, k as add, Y as angleBetweenVectors, V as areBoundsInitialized, E as areEquals, a as areMatricesEqual, a4 as arrayMax, a3 as arrayMin, G as arrayRange, a8 as beginCombination, a7 as binomial, aU as boundsIsWithinOtherBounds, a0 as ceil, a5 as ceilLog2, aQ as clampAndNormalizeValue, F as clampValue, c as clampVector, ap as columnsToMat3, ao as columnsToMat4, aP as computeBoundsFromPoints, _ as createArray, I as createUninitializedBounds, j as cross, f as default, B as degreesFromRadians, o as determinant2x2, z as determinant3x3, aE as diagonalize3x3, e as distance2BetweenPoints, d as dot, ah as dot2D, aI as estimateMatrixCondition, aT as extentIsWithinOtherExtent, a6 as factorial, b0 as float2CssRGBA, W as floatRGB2HexCode, a$ as floatToHex2, L as floor, ac as gaussian, aj as gaussianAmplitude, ak as gaussianWeight, aS as getAdjustedScalarRange, H as getMajorAxisIndex, aR as getScalarTypeFittingRange, ab as getSeed, U as getSparseOrthogonalMatrix, aL as hex2float, h as hsv2rgb, J as identity, aw as identity3x3, aX as inf, av as invert3x3, p as invertMatrix, aZ as isFinite, ax as isIdentity, ay as isIdentity3x3, M as isInf, a_ as isNaN, i as isNan, X as isPowerOfTwo, w as jacobi, q as jacobiN, P as lab2rgb, aM as lab2xyz, C as ldexp, as as linearSolve3x3, aG as luFactorLinearSystem, aH as luSolveLinearSystem, aB as matrix3x3ToQuaternion, a2 as max, a1 as min, at as multiply3x3_mat3, T as multiply3x3_vect3, m as multiplyAccumulate, ae as multiplyAccumulate2D, K as multiplyMatrix, aC as multiplyQuaternion, x as multiplyScalar, ad as multiplyScalar2D, S as nearestPowerOfTwo, aY as negInf, a9 as nextCombination, n as norm, am as norm2D, l as normalize, R as normalize2D, aD as orthogonalize3x3, af as outer, al as outer2D, t as perpendiculars, aV as pointIsWithinBounds, ag as projectVector, ai as projectVector2D, az as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, aa as randomSeed, N as rgb2hsv, O as rgb2lab, aO as rgb2xyz, Q as round, aA as roundNumber, b as roundVector, A as rowsToMat3, an as rowsToMat4, Z as signedAngleBetweenVectors, aF as singularValueDecomposition3x3, aW as solve3PointCircle, aJ as solveHomogeneousLeastSquares, aK as solveLeastSquares, g as solveLinearSystem, s as subtract, au as transpose3x3, u as uninitializeBounds, aN as xyz2lab, D as xyz2rgb } from './Math/index.js';
+export { ar as LUFactor3x3, as as LUSolve3x3, a0 as Pi, k as add, Z as angleBetweenVectors, W as areBoundsInitialized, E as areEquals, a as areMatricesEqual, a5 as arrayMax, a4 as arrayMin, G as arrayRange, a9 as beginCombination, a8 as binomial, aV as boundsIsWithinOtherBounds, a1 as ceil, a6 as ceilLog2, aR as clampAndNormalizeValue, F as clampValue, c as clampVector, aq as columnsToMat3, ap as columnsToMat4, aQ as computeBoundsFromPoints, $ as createArray, I as createUninitializedBounds, j as cross, f as default, B as degreesFromRadians, o as determinant2x2, z as determinant3x3, aF as diagonalize3x3, e as distance2BetweenPoints, d as dot, ai as dot2D, aJ as estimateMatrixCondition, aU as extentIsWithinOtherExtent, a7 as factorial, b1 as float2CssRGBA, X as floatRGB2HexCode, b0 as floatToHex2, M as floor, ad as gaussian, ak as gaussianAmplitude, al as gaussianWeight, aT as getAdjustedScalarRange, H as getMajorAxisIndex, aS as getScalarTypeFittingRange, ac as getSeed, V as getSparseOrthogonalMatrix, aM as hex2float, h as hsv2rgb, K as identity, ax as identity3x3, aY as inf, aw as invert3x3, p as invertMatrix, a_ as isFinite, ay as isIdentity, az as isIdentity3x3, N as isInf, a$ as isNaN, i as isNan, Y as isPowerOfTwo, w as jacobi, q as jacobiN, Q as lab2rgb, aN as lab2xyz, C as ldexp, at as linearSolve3x3, aH as luFactorLinearSystem, aI as luSolveLinearSystem, aC as matrix3x3ToQuaternion, a3 as max, a2 as min, au as multiply3x3_mat3, U as multiply3x3_vect3, m as multiplyAccumulate, af as multiplyAccumulate2D, L as multiplyMatrix, aD as multiplyQuaternion, x as multiplyScalar, ae as multiplyScalar2D, T as nearestPowerOfTwo, aZ as negInf, aa as nextCombination, n as norm, an as norm2D, l as normalize, S as normalize2D, J as normalize4D, aE as orthogonalize3x3, ag as outer, am as outer2D, t as perpendiculars, aW as pointIsWithinBounds, ah as projectVector, aj as projectVector2D, aA as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, ab as randomSeed, O as rgb2hsv, P as rgb2lab, aP as rgb2xyz, R as round, aB as roundNumber, b as roundVector, A as rowsToMat3, ao as rowsToMat4, _ as signedAngleBetweenVectors, aG as singularValueDecomposition3x3, aX as solve3PointCircle, aK as solveHomogeneousLeastSquares, aL as solveLeastSquares, g as solveLinearSystem, s as subtract, av as transpose3x3, u as uninitializeBounds, aO as xyz2lab, D as xyz2rgb } from './Math/index.js';

package/Common/DataModel/Polygon.d.ts

@@ -60,6 +60,19 @@ export function pointInPolygon(
   normal: Vector3
 ): PolygonIntersectionState;
 
+/**
+ * Compute the centroid of a polygon.
+ * @param {Array<number>} poly - Array of point indices for the polygon
+ * @param {vtkPoints} points - vtkPoints instance
+ * @param {Vector3} [centroid] - Optional output array (length 3)
+ * @returns {Vector3} The centroid as [x, y, z]
+ */
+export function computeCentroid(
+  poly: Array<number>,
+  points: TypedArray,
+  centroid?: Vector3
+): Vector3;
+
 /**
  * Method used to decorate a given object (publicAPI+model) with vtkPolygon characteristics.
  *

package/Common/DataModel/Polygon.js

@@ -187,6 +187,32 @@ function getNormal(poly, points, normal) {
   return normalize(normal);
 }
 
+/**
+ * Compute the centroid of a polygon.
+ * @param {Array<number>} poly - Array of point indices for the polygon
+ * @param {vtkPoints} points - vtkPoints instance
+ * @param {Vector3} [centroid] - Optional output array (length 3)
+ * @returns {Vector3} The centroid as [x, y, z]
+ */
+function computeCentroid(poly, points) {
+  let centroid = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [0, 0, 0];
+  centroid[0] = 0;
+  centroid[1] = 0;
+  centroid[2] = 0;
+  const n = poly.length;
+  const p = [];
+  for (let i = 0; i < n; i++) {
+    points.getPoint(poly[i], p);
+    centroid[0] += p[0];
+    centroid[1] += p[1];
+    centroid[2] += p[2];
+  }
+  centroid[0] /= n;
+  centroid[1] /= n;
+  centroid[2] /= n;
+  return centroid;
+}
+
 // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
@@ -195,7 +221,8 @@ const STATIC = {
   PolygonWithPointIntersectionState,
   pointInPolygon,
   getBounds,
-  getNormal
+  getNormal,
+  computeCentroid
 };
 
 // ----------------------------------------------------------------------------
@@ -384,4 +411,4 @@ var vtkPolygon$1 = {
   ...STATIC
 };
 
-export { vtkPolygon$1 as default, extend, getBounds, getNormal, newInstance };
+export { computeCentroid, vtkPolygon$1 as default, extend, getBounds, getNormal, newInstance };

package/Common/DataModel/Triangle.js

@@ -1,6 +1,6 @@
-import { m as macro } from '../../macros2.js';
+import { m as macro, T as TYPED_ARRAYS } from '../../macros2.js';
 import vtkCell from './Cell.js';
-import { d as dot, j as cross, l as normalize, m as multiplyAccumulate, e as distance2BetweenPoints, o as determinant2x2, p as invertMatrix } from '../Core/Math/index.js';
+import { d as dot, j as cross, l as normalize, m as multiplyAccumulate, e as distance2BetweenPoints, o as determinant2x2, s as subtract, p as invertMatrix } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 
@@ -590,21 +590,16 @@ function vtkTriangle(publicAPI, model) {
    * @param {Number[]} derivs - The derivatives.
    */
   publicAPI.derivatives = (subId, pcoords, values, dim, derivs) => {
-    const x0 = [];
-    const x1 = [];
-    const x2 = [];
-    model.points.getPoint(0, x0);
-    model.points.getPoint(1, x1);
-    model.points.getPoint(2, x2);
+    const x0 = model.points.getPoint(0);
+    const x1 = model.points.getPoint(1);
+    const x2 = model.points.getPoint(2);
     const n = [];
     const v10 = [];
     const v20 = [];
     const v = [];
     computeNormal(x0, x1, x2, n);
-    for (let i = 0; i < 3; i++) {
-      v10[i] = x1[i] - x0[i];
-      v[i] = x2[i] - x0[i];
-    }
+    subtract(x1, x0, v10);
+    subtract(x2, x0, v);
     cross(n, v10, v20);
     const lenX = normalize(v10); // check for degenerate triangle
 
@@ -629,7 +624,7 @@ function vtkTriangle(publicAPI, model) {
     const J = [v1[0] - v0[0], v1[1] - v0[1], v2[0] - v0[0], v2[1] - v0[1]];
 
     // Compute inverse Jacobian (expects flat array)
-    const JI = new Array(4).fill(0.0);
+    const JI = macro.newTypedArray(TYPED_ARRAYS.Float64Array, 4);
     invertMatrix(J, JI, 2); // returns flat array [JI00, JI01, JI10, JI11]
 
     // Compute derivatives

package/Filters/Core/Cutter.js

@@ -257,6 +257,7 @@ function vtkCutter(publicAPI, model) {
       const name = pointData.getArrayName(arrayIdx);
       const array = vtkDataArray.newInstance({
         name,
+        dataType: pointData.getArrayByIndex(arrayIdx).getDataType(),
         values: newPointData[name],
         numberOfComponents: pointData.getArrayByIndex(arrayIdx).getNumberOfComponents()
       });

package/Filters/General/ShrinkPolyData.d.ts

@@ -0,0 +1,85 @@
+import { DesiredOutputPrecision } from './../../Common/DataModel/DataSetAttributes';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+
+/**
+ *
+ */
+export interface IShrinkPolyDataInitialValues {
+  shrinkFactor?: number;
+}
+
+type vtkShrinkPolyDataBase = vtkObject & vtkAlgorithm;
+
+export interface vtkShrinkPolyData extends vtkShrinkPolyDataBase {
+  /**
+   * Expose methods
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Get the shrink factor.
+   */
+  getShrinkFactor(): number;
+
+  /**
+   * Set the shrink factor.
+   * @param {Number} shrinkFactor
+   */
+  setShrinkFactor(shrinkFactor: number): boolean;
+
+  /**
+   * Shrink two points towards their midpoint by a shrink factor.
+   * @param {Vector3} p1 - The [x, y, z] coordinates of the first point
+   * @param {Vector3} p2 - The [x, y, z] coordinates of the second point
+   * @param {number} shrinkFactor - The shrink factor (0.0 to 1.0)
+   * @param {Number[]} [shrunkPoints] - Optional array to store the shrunk points
+   * @returns {Number[]} Array containing the two new points
+   */
+  shrinkLine(
+    p1: Vector3,
+    p2: Vector3,
+    shrinkFactor: number,
+    shrunkPoints?: Number[]
+  ): Number[];
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkShrinkPolyData characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IShrinkPolyDataInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IShrinkPolyDataInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkShrinkPolyData.
+ * @param {IShrinkPolyDataInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IShrinkPolyDataInitialValues
+): vtkShrinkPolyData;
+
+/**
+ * vtkShrinkPolyData shrinks cells composing a polygonal dataset (e.g.,
+ * vertices, lines, polygons, and triangle strips) towards their centroid. The
+ * centroid of a cell is computed as the average position of the cell points.
+ * Shrinking results in disconnecting the cells from one another. The output
+ * dataset type of this filter is polygonal data.
+ *
+ * During execution the filter passes its input cell data to its output. Point
+ * data attributes are copied to the points created during the shrinking
+ * process.
+ */
+export declare const vtkShrinkPolyData: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkShrinkPolyData;