@kitware/vtk.js 34.5.0 → 34.7.0

package/Common/Transform/Transform.d.ts

@@ -1,6 +1,8 @@
-import { mat4, vec3 } from 'gl-matrix';
+import { mat3, mat4, vec3 } from 'gl-matrix';
 import { vtkObject } from './../../interfaces';
 import { TypedArray } from './../../types';
+import vtkDataArray from './../Core/DataArray';
+import vtkPoints from './../Core/Points';
 
 export interface ITransformInitialValues {
   preMultiplyFlag?: boolean;
@@ -144,6 +146,115 @@ export interface vtkTransform extends vtkObject {
    * @returns A new transform with an inversed internal matrix. Also copy the premultiply flag @see getPreMultiplyFlag.
    */
   getInverse(): vtkTransform;
+
+  /**
+   * Create a translation matrix and concatenate it with the current
+   * transformation according to preMultiply or postMultiply semantics.
+   * @param {Number} x X component of the translation
+   * @param {Number} y Y component of the translation
+   * @param {Number} z Z component of the translation
+   */
+  translate(x: number, y: number, z: number): void;
+
+  /**
+   * Create a rotation matrix and concatenate it with the current transformation
+   * according to preMultiply or postMultiply semantics.
+   * The angle is expressed in degrees.
+   * @param {Number} angle Angle in degrees
+   * @param {Number} x X component of the rotation axis
+   * @param {Number} y Y component of the rotation axis
+   * @param {Number} z Z component of the rotation axis
+   */
+  rotateWXYZ(angle: number, x: number, y: number, z: number): void;
+
+  /**
+   * Create a rotation matrix and concatenate it with the current transformation
+   * according to preMultiply or postMultiply semantics.
+   * The angle is expressed in degrees.
+   * @param {Number} angle Angle in degrees
+   */
+  rotateX(angle: number): void;
+
+  /**
+   * Create a rotation matrix about the X, Y, or Z axis and concatenate it with
+   * the current transformation according to preMultiply or postMultiply
+   * semantics.
+   * @param {Number} angle Angle in degrees
+   */
+  rotateY(angle: number): void;
+
+  /**
+   * Create a rotation matrix about the X, Y, or Z axis and concatenate it with
+   * the current transformation according to preMultiply or postMultiply
+   * semantics.
+   * @param {Number} angle Angle in degrees
+   */
+  rotateZ(angle: number): void;
+
+  /**
+   * Create a scale matrix (i.e. set the diagonal elements to x, y, z) and
+   * concatenate it with the current transformation according to preMultiply or
+   * postMultiply semantics.
+   * @param {Number} x Diagonal element for X axis
+   * @param {Number} y Diagonal element for Y axis
+   * @param {Number} z Diagonal element for Z axis
+   */
+  scale(x: number, y: number, z: number): void;
+
+  /**
+   * Apply the transformation to a normal.
+   * @param {vec3} inNormal The normal vector to transform
+   * @param {vec3} outNormal The output vector
+   * @returns {vec3} The transformed normal vector
+   */
+  transformNormal(inNormal: vec3, outNormal?: vec3): vec3;
+
+  /**
+   * Apply the transformation to a series of normals, and append the results to
+   * outNormals.
+   * @param {vtkDataArray} inNormals The normal vectors to transform
+   * @param {vtkDataArray} outNormals The output array
+   */
+  transformNormals(inNormals: vtkDataArray, outNormals: vtkDataArray): void;
+
+  /**
+   * Transform points, normals, and vectors simultaneously.
+   * @param {vtkPoints} inPoints Input points
+   * @param {vtkPoints} outPoints Output points
+   * @param {vtkDataArray} inNormals Input normals
+   * @param {vtkDataArray} outNormals Output normals
+   * @param {vtkDataArray} inVectors Input vectors
+   * @param {vtkDataArray} outVectors Output vectors
+   * @param {Array<vtkDataArray>} inVectorsArr Optional input vectors arrays
+   * @param {Array<vtkDataArray>} outVectorsArr Optional output vectors arrays
+   */
+  transformPointsNormalsVectors(
+    inPoints: vtkPoints,
+    outPoints: vtkPoints,
+    inNormals: vtkDataArray,
+    outNormals: vtkDataArray,
+    inVectors: vtkDataArray,
+    outVectors: vtkDataArray,
+    inVectorsArr?: Array<vtkDataArray>,
+    outVectorsArr?: Array<vtkDataArray>
+  ): void;
+
+  /**
+   * Apply the transformation to a vector.
+   * @param {vec3} inVector The vector to transform
+   * @param {vec3} outVector The output vector
+   * @param {mat3} [matrix=null] if null (default), the Transform matrix is being used.
+   * @returns {vec3} The transformed vector
+   */
+  transformVector(inVector: vec3, outVector?: vec3, matrix?: mat3): vec3;
+
+  /**
+   * Apply the transformation to a series of vectors, and append the results to
+   * outVectors.
+   * @param {vtkDataArray} inVectors The vectors to transform
+   * @param {vtkDataArray} outVectors The output array
+   */
+  transformVectors(inVectors: vtkDataArray, outVectors: vtkDataArray): void;
 }
 
 /**

package/Common/Transform/Transform.js

@@ -1,7 +1,11 @@
-import { IDENTITY } from '../Core/Math/Constants.js';
-import { vec3, mat4 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import { f as vtkMath } from '../Core/Math/index.js';
+import { IDENTITY } from '../Core/Math/Constants.js';
+import { vec3, mat4, quat, mat3 } from 'gl-matrix';
+
+const {
+  vtkWarningMacro
+} = macro;
 
 // ----------------------------------------------------------------------------
 // vtkTransform methods
@@ -79,6 +83,301 @@ function vtkTransform(publicAPI, model) {
     matrix: vtkMath.invertMatrix(Array.from(model.matrix), [], 4),
     preMultiplyFlag: model.preMultiplyFlag
   });
+
+  /**
+   * Create a translation matrix and concatenate it with the current
+   * transformation according to preMultiply or postMultiply semantics.
+   * @param {Number} x X component of the translation
+   * @param {Number} y Y component of the translation
+   * @param {Number} z Z component of the translation
+   */
+  publicAPI.translate = (x, y, z) => {
+    if (x === 0 && y === 0 && z === 0) {
+      return;
+    }
+    const tMat = mat4.create();
+    mat4.fromTranslation(tMat, [x, y, z]);
+    if (model.preMultiplyFlag) {
+      mat4.multiply(model.matrix, model.matrix, tMat);
+    } else {
+      mat4.multiply(model.matrix, tMat, model.matrix);
+    }
+    publicAPI.modified();
+  };
+
+  /**
+   * Create a rotation matrix and concatenate it with the current transformation
+   * according to preMultiply or postMultiply semantics.
+   * The angle is expressed in degrees.
+   * @param {Number} angle Angle in degrees
+   * @param {Number} x X component of the rotation axis
+   * @param {Number} y Y component of the rotation axis
+   * @param {Number} z Z component of the rotation axis
+   */
+  publicAPI.rotateWXYZ = (degrees, x, y, z) => {
+    if (x === 0.0 && y === 0.0 && z === 0.0) {
+      vtkWarningMacro('No rotation applied, axis is zero vector.');
+      return;
+    }
+    if (degrees === 0.0) {
+      return;
+    }
+
+    // convert to radians
+    const angle = vtkMath.radiansFromDegrees(degrees);
+    const q = quat.create();
+    quat.setAxisAngle(q, [x, y, z], angle);
+    const quatMat = new Float64Array(16);
+    mat4.fromQuat(quatMat, q);
+    if (model.preMultiplyFlag) {
+      mat4.multiply(model.matrix, model.matrix, quatMat);
+    } else {
+      mat4.multiply(model.matrix, quatMat, model.matrix);
+    }
+    publicAPI.modified();
+  };
+
+  /**
+   * Create a rotation matrix about the X, Y, or Z axis and concatenate it with
+   * the current transformation according to preMultiply or postMultiply
+   * semantics.
+   * The angle is expressed in degrees.
+   * @param {Number} angle Angle in degrees
+   */
+  publicAPI.rotateX = angle => {
+    publicAPI.rotateWXYZ(angle, 1, 0, 0);
+  };
+
+  /**
+   * Create a rotation matrix about the X, Y, or Z axis and concatenate it with
+   * the current transformation according to preMultiply or postMultiply
+   * semantics.
+   * @param {Number} angle Angle in degrees
+   */
+  publicAPI.rotateY = angle => {
+    publicAPI.rotateWXYZ(angle, 0, 1, 0);
+  };
+
+  /**
+   * Create a rotation matrix about the X, Y, or Z axis and concatenate it with
+   * the current transformation according to preMultiply or postMultiply
+   * semantics.
+   * @param {Number} angle Angle in degrees
+   */
+  publicAPI.rotateZ = angle => {
+    publicAPI.rotateWXYZ(angle, 0, 0, 1);
+  };
+
+  /**
+   * Create a scale matrix (i.e. set the diagonal elements to x, y, z) and
+   * concatenate it with the current transformation according to preMultiply or
+   * postMultiply semantics.
+   * @param {Number} x Diagonal element for X axis
+   * @param {Number} y Diagonal element for Y axis
+   * @param {Number} z Diagonal element for Z axis
+   */
+  publicAPI.scale = (x, y, z) => {
+    if (x === 1 && y === 1 && z === 1) {
+      return;
+    }
+    const sMat = mat4.create();
+    mat4.fromScaling(sMat, [x, y, z]);
+    if (model.preMultiplyFlag) {
+      mat4.multiply(model.matrix, model.matrix, sMat);
+    } else {
+      mat4.multiply(model.matrix, sMat, model.matrix);
+    }
+    publicAPI.modified();
+  };
+
+  /**
+   * Apply the transformation to a normal.
+   * @param {vec3} inNormal The normal vector to transform
+   * @param {vec3} outNormal The output vector
+   * @returns {vec3} The transformed normal vector
+   */
+  publicAPI.transformNormal = function (inNormal) {
+    let outNormal = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    const matrix3x3 = mat3.fromMat4(mat3.create(), model.matrix);
+    // Invert the upper 3x3 part of the matrix
+    const invMat3 = mat3.create();
+    mat3.invert(invMat3, matrix3x3);
+    // Transpose
+    const tMat3 = mat3.create();
+    mat3.transpose(tMat3, invMat3);
+    // Multiply normal
+    publicAPI.transformVector(inNormal, outNormal, tMat3);
+    // Ensure the output normal is normalized
+    vtkMath.normalize(outNormal);
+    return outNormal;
+  };
+
+  /**
+   * Apply the transformation to a series of normals, and append the results to
+   * outNormals.
+   * @param {vtkDataArray} inNormals The normal vectors to transform
+   * @param {vtkDataArray} outNormals The output array
+   */
+  publicAPI.transformNormals = (inNormals, outNormals) => {
+    const inArr = inNormals.getData();
+    const outArr = outNormals.getData();
+    const tmp = [0, 0, 0];
+    const matrix3x3 = mat3.fromMat4(mat3.create(), model.matrix);
+    // Invert the upper 3x3 part of the matrix
+    const invMat3 = mat3.create();
+    mat3.invert(invMat3, matrix3x3);
+    // Transpose
+    const tMat3 = mat3.create();
+    mat3.transpose(tMat3, invMat3);
+    for (let i = 0; i < inArr.length; i += 3) {
+      tmp[0] = inArr[i];
+      tmp[1] = inArr[i + 1];
+      tmp[2] = inArr[i + 2];
+      // matrix has been transposed & inverted, so use transformVector directly
+      // to apply the transformation
+      publicAPI.transformVector(tmp, tmp, tMat3);
+      vtkMath.normalize(tmp);
+      outArr[i] = tmp[0];
+      outArr[i + 1] = tmp[1];
+      outArr[i + 2] = tmp[2];
+    }
+  };
+
+  /**
+   * Apply the transformation to a vector.
+   * @param {vec3} inVector The vector to transform
+   * @param {vec3} outVector The output vector
+   * @param {mat3} [matrix=null] if null (default), the Transform matrix is being used.
+   * @returns {vec3} The transformed vector
+   */
+  publicAPI.transformVector = function (inVector) {
+    let outVector = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    let matrix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    const matrix3x3 = matrix || mat3.fromMat4(mat3.create(), model.matrix);
+    vec3.transformMat3(outVector, inVector, matrix3x3);
+    return outVector;
+  };
+
+  /**
+   * Apply the transformation to a series of vectors, and append the results to
+   * outVectors.
+   * @param {vtkDataArray} inVectors The vectors to transform
+   * @param {vtkDataArray} outVectors The output array
+   */
+  publicAPI.transformVectors = (inVectors, outVectors) => {
+    const inArr = inVectors.getData();
+    const outArr = outVectors.getData();
+    const tmp = [0, 0, 0];
+    for (let i = 0; i < inArr.length; i += 3) {
+      tmp[0] = inArr[i];
+      tmp[1] = inArr[i + 1];
+      tmp[2] = inArr[i + 2];
+      publicAPI.transformVector(tmp, tmp);
+      vtkMath.normalize(tmp);
+      outArr[i] = tmp[0];
+      outArr[i + 1] = tmp[1];
+      outArr[i + 2] = tmp[2];
+    }
+  };
+
+  /**
+   * Transform points, normals, and vectors simultaneously.
+   * @param {vtkPoints} inPoints Input points
+   * @param {vtkPoints} outPoints Output points
+   * @param {vtkDataArray} inNormals Input normals
+   * @param {vtkDataArray} outNormals Output normals
+   * @param {vtkDataArray} inVectors Input vectors
+   * @param {vtkDataArray} outVectors Output vectors
+   * @param {Array<vtkDataArray>} inVectorsArr Optional input vector arrays
+   * @param {Array<vtkDataArray>} outVectorsArr Optional output vector arrays
+   */
+  publicAPI.transformPointsNormalsVectors = function (inPoints, outPoints, inNormals, outNormals, inVectors, outVectors) {
+    let inVectorsArr = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
+    let outVectorsArr = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;
+    const n = inPoints.getNumberOfPoints();
+    const nOptionalVectors = inVectorsArr?.length ?? 0;
+    const point = new Float64Array(3);
+    const oldPoint = new Float64Array(3);
+    const oldVector = new Float64Array(3);
+    const oldNormal = new Float64Array(3);
+    let modifiedPoint = false;
+    let modifiedVector = false;
+    let modifiedNormal = false;
+    const modifiedVectorsArr = [];
+    for (let ptId = 0; ptId < n; ptId++) {
+      // Transform point
+      inPoints.getPoint(ptId, point);
+      oldPoint.set(point);
+      publicAPI.transformPoint(point, point);
+      outPoints.setPoint(ptId, ...point);
+      if (!vtkMath.areEquals(oldPoint, point)) {
+        modifiedPoint = true;
+      }
+
+      // Transform vectors
+      if (inVectors) {
+        const inData = inVectors.getData();
+        const outData = outVectors.getData();
+        point[0] = inData[ptId * 3];
+        point[1] = inData[ptId * 3 + 1];
+        point[2] = inData[ptId * 3 + 2];
+        oldVector.set(point);
+        publicAPI.transformVector(point, point);
+        outData[ptId * 3] = point[0];
+        outData[ptId * 3 + 1] = point[1];
+        outData[ptId * 3 + 2] = point[2];
+        if (!vtkMath.areEquals(oldVector, point)) {
+          modifiedVector = true;
+        }
+      }
+
+      // Transform normals
+      if (inNormals) {
+        const inData = inNormals.getData();
+        const outData = outNormals.getData();
+        point[0] = inData[ptId * 3];
+        point[1] = inData[ptId * 3 + 1];
+        point[2] = inData[ptId * 3 + 2];
+        oldNormal.set(point);
+        publicAPI.transformNormal(point, point);
+        outData[ptId * 3] = point[0];
+        outData[ptId * 3 + 1] = point[1];
+        outData[ptId * 3 + 2] = point[2];
+        if (!vtkMath.areEquals(oldNormal, point)) {
+          modifiedNormal = true;
+        }
+      }
+
+      // Transform optional vectors
+      if (inVectorsArr) {
+        for (let iArr = 0; iArr < nOptionalVectors; iArr++) {
+          const inData = inVectorsArr[iArr].getData();
+          const outData = outVectorsArr[iArr].getData();
+          point[0] = inData[ptId * 3];
+          point[1] = inData[ptId * 3 + 1];
+          point[2] = inData[ptId * 3 + 2];
+          oldVector.set(point);
+          publicAPI.transformVector(point, point);
+          outData[ptId * 3] = point[0];
+          outData[ptId * 3 + 1] = point[1];
+          outData[ptId * 3 + 2] = point[2];
+          if (!vtkMath.arrayEqual(oldVector, point) && !modifiedVectorsArr.includes(iArr)) {
+            modifiedVectorsArr.push(iArr);
+          }
+        }
+      }
+    }
+    if (modifiedPoint) {
+      outPoints.modified();
+    }
+    if (modifiedVector) {
+      outVectors.modified();
+    }
+    if (modifiedNormal) {
+      outNormals.modified();
+    }
+    modifiedVectorsArr.forEach(idx => outVectorsArr[idx].modified());
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Filters/Core/Cutter.js

@@ -1,4 +1,5 @@
 import { n as newInstance$1, o as obj, d as algo, e as setGet, c as macro, b as newTypedArrayFrom } from '../../macros2.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 const {
@@ -74,10 +75,18 @@ function vtkCutter(publicAPI, model) {
   function dataSetCutter(input, output) {
     const points = input.getPoints();
     const pointsData = points.getData();
+    const pointData = input.getPointData();
     const numPts = points.getNumberOfPoints();
     const newPointsData = [];
     const newLinesData = [];
     const newPolysData = [];
+    const newPointData = {}; // TODO: cell data must also be processed
+
+    // Initialize arrays
+    const numberOfArrays = pointData.getNumberOfArrays();
+    for (let arrayIdx = 0; arrayIdx < numberOfArrays; arrayIdx++) {
+      newPointData[pointData.getArrayName(arrayIdx)] = [];
+    }
     if (!model.cutScalars || model.cutScalars.length < numPts) {
       model.cutScalars = new Float32Array(numPts);
     }
@@ -169,6 +178,21 @@ function vtkCutter(publicAPI, model) {
 
         // Compute the intersected point on edge
         const computedIntersectedPoint = [x1[0] + t * (x2[0] - x1[0]), x1[1] + t * (x2[1] - x1[1]), x1[2] + t * (x2[2] - x1[2])];
+        const computedIntersectedArrays = {};
+        for (let arrayIdx = 0; arrayIdx < numberOfArrays; arrayIdx++) {
+          const array = pointData.getArrayByIndex(arrayIdx);
+          const name = pointData.getArrayName(arrayIdx);
+          const data = array.getData();
+          const n = array.getNumberOfComponents();
+          const computedIntersectedArray = new Array(n);
+          for (let j = 0; j < n; j++) {
+            const scalar1 = data[n * pointID1 + j];
+            const scalar2 = data[n * pointID2 + j];
+            computedIntersectedArray.push(scalar1 + t * (scalar2 - scalar1)); // FIXME: won't work when the array contains "normals" or "IDs"
+          }
+
+          computedIntersectedArrays[name] = computedIntersectedArray;
+        }
 
         // Keep track of it
         intersectedEdgesList.push({
@@ -178,6 +202,8 @@ function vtkCutter(publicAPI, model) {
           // id of one point of the edge
           intersectedPoint: computedIntersectedPoint,
           // 3D coordinate of points that intersected edge
+          intersectedArrays: computedIntersectedArrays,
+          // value(s) of the intersected arrays
           newPointID: -1 // id of the intersected point when it will be added into vtkPoints
         });
       }
@@ -201,6 +227,9 @@ function vtkCutter(publicAPI, model) {
           newPointsData.push(intersectedEdge.intersectedPoint[0]);
           newPointsData.push(intersectedEdge.intersectedPoint[1]);
           newPointsData.push(intersectedEdge.intersectedPoint[2]);
+          Object.keys(intersectedEdge.intersectedArrays).forEach(name => {
+            newPointData[name].push(...intersectedEdge.intersectedArrays[name]);
+          });
           intersectedEdgesList[i].newPointID = newPointsData.length / 3 - 1;
           crossedEdges.push(intersectedEdgesList[i]);
         }
@@ -222,6 +251,19 @@ function vtkCutter(publicAPI, model) {
     const outputPoints = output.getPoints();
     outputPoints.setData(newTypedArrayFrom(points.getDataType(), newPointsData), 3);
 
+    // Set scalars
+    const outputPointData = output.getPointData();
+    for (let arrayIdx = 0; arrayIdx < numberOfArrays; arrayIdx++) {
+      const name = pointData.getArrayName(arrayIdx);
+      const array = vtkDataArray.newInstance({
+        name,
+        dataType: pointData.getArrayByIndex(arrayIdx).getDataType(),
+        values: newPointData[name],
+        numberOfComponents: pointData.getArrayByIndex(arrayIdx).getNumberOfComponents()
+      });
+      outputPointData.addArray(array);
+    }
+
     // Set lines
     if (newLinesData.length !== 0) {
       output.getLines().setData(Uint16Array.from(newLinesData));

package/Filters/General/OBBTree.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkLine from '../../Common/DataModel/Line.js';
-import { d as dot, j as cross, n as norm, t as jacobi, l as normalize, k as add } from '../../Common/Core/Math/index.js';
+import { d as dot, j as cross, n as norm, w as jacobi, l as normalize, k as add } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkOBBNode from './OBBTree/OBBNode.js';
 import vtkPoints from '../../Common/Core/Points.js';

package/Filters/General/TransformPolyDataFilter.d.ts

@@ -0,0 +1,75 @@
+import { DesiredOutputPrecision } from './../../Common/DataModel/DataSetAttributes';
+import vtkTransform from './../../Common/Transform/Transform';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+
+export interface ITransformPolyDataFilterInitialValues {
+  transform?: vtkTransform;
+  outputPointsPrecision?: DesiredOutputPrecision;
+}
+
+type vtkTransformPolyDataFilterBase = vtkObject & vtkAlgorithm;
+
+export interface vtkTransformPolyDataFilter
+  extends vtkTransformPolyDataFilterBase {
+  /**
+   * Get the transform used by this filter.
+   */
+  getTransform(): vtkTransform;
+
+  /**
+   * Get the output points precision.
+   */
+  getOutputPointsPrecision(): DesiredOutputPrecision;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the output points precision.
+   * @param {DesiredOutputPrecision} precision
+   */
+  setOutputPointsPrecision(precision: DesiredOutputPrecision): boolean;
+
+  /**
+   * Set the transform used by this filter.
+   * @param {vtkTransform} transform
+   */
+  setTransform(transform: vtkTransform): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkTransformPolyDataFilter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ITransformPolyDataFilterInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ITransformPolyDataFilterInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkTransformPolyDataFilter.
+ * @param {ITransformPolyDataFilterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: ITransformPolyDataFilterInitialValues
+): vtkTransformPolyDataFilter;
+
+/**
+ * vtkTransformPolyDataFilter is a filter to transform point coordinates and
+ * associated point and cell normals and vectors. Other point and cell data is
+ * passed through the filter unchanged. This filter is specialized for polygonal
+ * data.
+ */
+export declare const vtkTransformPolyDataFilter: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkTransformPolyDataFilter;