@kitware/vtk.js 34.5.0 → 34.6.0

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,18 @@ 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,
+        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;

package/Filters/General/TransformPolyDataFilter.js

@@ -0,0 +1,194 @@
+import { m as macro } from '../../macros2.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// vtkTransformPolyDataFilter methods
+// ----------------------------------------------------------------------------
+
+function vtkTransformPolyDataFilter(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTransformPolyDataFilter');
+
+  // Internal method to handle the actual transformation
+  function transformPolyData(input, output) {
+    if (!model.transform) {
+      vtkErrorMacro('No transform defined!');
+      return false;
+    }
+    const inPts = input.getPoints();
+    const inPtData = input.getPointData();
+    const outPD = output.getPointData();
+    const inCellData = input.getCellData();
+    const outCD = output.getCellData();
+    if (!inPts) {
+      // Input polydata is empty. This is not an error, the output will be just empty, too.
+      return true;
+    }
+    const numPoints = inPts.getNumberOfPoints();
+
+    // Get input vectors and normals (points and cells)
+    const inVectors = inPtData.getVectors();
+    const inNormals = inPtData.getNormals();
+    const inCellVectors = inCellData.getVectors();
+    const inCellNormals = inCellData.getNormals();
+
+    // Set the desired precision for the points in the output
+    let pointType = inPts.getDataType();
+    if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
+      pointType = VtkDataTypes.FLOAT;
+    } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
+      pointType = VtkDataTypes.DOUBLE;
+    }
+
+    // Create output points with appropriate precision
+    const outPts = vtkPoints.newInstance({
+      dataType: pointType
+    });
+
+    // Transform points
+    const inPtsData = inPts.getData();
+    outPts.setNumberOfPoints(numPoints);
+    const outPtsData = outPts.getData();
+
+    // Transform vectors if present
+    let outVectors = null;
+    if (inVectors) {
+      outVectors = vtkDataArray.newInstance({
+        name: inVectors.getName(),
+        numberOfComponents: 3,
+        size: numPoints * 3
+      });
+    }
+
+    // Transform normals if present
+    let outNormals = null;
+    if (inNormals) {
+      outNormals = vtkDataArray.newInstance({
+        name: inNormals.getName(),
+        numberOfComponents: 3,
+        size: numPoints * 3
+      });
+    }
+    if (inVectors || inNormals) {
+      model.transform.transformPointsNormalsVectors(inPts, outPts, inNormals, outNormals, inVectors, outVectors);
+    } else {
+      model.transform.transformPoints(inPtsData, outPtsData);
+    }
+
+    // Transform cell vectors if present
+    let outCellVectors = null;
+    if (inCellVectors) {
+      const numCells = inCellVectors.getNumberOfTuples();
+      outCellVectors = vtkDataArray.newInstance({
+        name: inCellVectors.getName(),
+        numberOfComponents: 3,
+        size: numCells * 3
+      });
+      model.transform.transformVectors(inCellVectors, outCellVectors);
+    }
+
+    // Transform cell normals if present
+    let outCellNormals = null;
+    if (inCellNormals) {
+      const numCells = inCellNormals.getNumberOfTuples();
+      outCellNormals = vtkDataArray.newInstance({
+        name: inCellNormals.getName(),
+        numberOfComponents: 3,
+        size: numCells * 3
+      });
+      model.transform.transformNormals(inCellNormals, outCellNormals);
+    }
+
+    // Set output data
+    output.setPoints(outPts);
+
+    // Copy cell topology
+    output.setVerts(input.getVerts());
+    output.setLines(input.getLines());
+    output.setPolys(input.getPolys());
+    output.setStrips(input.getStrips());
+
+    // Set transformed point data
+    if (outNormals) {
+      outPD.setNormals(outNormals);
+      outPD.copyFieldOff(outNormals.getName());
+    }
+    if (outVectors) {
+      outPD.setVectors(outVectors);
+      outPD.copyFieldOff(outVectors.getName());
+    }
+
+    // Set transformed cell data
+    if (outCellNormals) {
+      outCD.setNormals(outCellNormals);
+      outCD.copyFieldOff(outCellNormals.getName());
+    }
+    if (outCellVectors) {
+      outCD.setVectors(outCellVectors);
+      outCD.copyFieldOff(outCellVectors.getName());
+    }
+
+    // Pass through other data
+    outPD.passData(inPtData);
+    outCD.passData(inCellData);
+    return true;
+  }
+  publicAPI.requestData = (inData, outData) => {
+    const input = inData[0];
+    const output = outData[0] || vtkPolyData.newInstance();
+    if (transformPolyData(input, output)) {
+      outData[0] = output;
+    } else {
+      vtkErrorMacro('TransformPolyDataFilter failed to transform input data.');
+    }
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  transform: null,
+  outputPointsPrecision: DesiredOutputPrecision.DEFAULT
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, 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);
+
+  // Set/Get methods
+  macro.setGet(publicAPI, model, ['transform', 'outputPointsPrecision']);
+
+  // Object specific methods
+  vtkTransformPolyDataFilter(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTransformPolyDataFilter');
+
+// ----------------------------------------------------------------------------
+
+var vtkTransformPolyDataFilter$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTransformPolyDataFilter$1 as default, extend, newInstance };

package/Filters/General.js

@@ -15,6 +15,7 @@ import vtkOBBTree from './General/OBBTree.js';
 import vtkOutlineFilter from './General/OutlineFilter.js';
 import vtkPaintFilter from './General/PaintFilter.js';
 import vtkScalarToRGBA from './General/ScalarToRGBA.js';
+import vtkTransformPolyDataFilter from './General/TransformPolyDataFilter.js';
 import vtkTriangleFilter from './General/TriangleFilter.js';
 import vtkTubeFilter from './General/TubeFilter.js';
 import vtkWarpScalar from './General/WarpScalar.js';
@@ -38,6 +39,7 @@ var General = {
   vtkOutlineFilter,
   vtkPaintFilter,
   vtkScalarToRGBA,
+  vtkTransformPolyDataFilter,
   vtkTriangleFilter,
   vtkTubeFilter,
   vtkWarpScalar,