@kitware/vtk.js 34.11.0 → 34.11.2

package/Filters/General/LineFilter.js

@@ -9,7 +9,7 @@ function vtkLineFilter(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkLineFilter');
   publicAPI.requestData = (inData, outData) => {
-    const dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataset.getPoints().setData(inData[0].getPoints().getData());
     dataset.getLines().setData(inData[0].getLines().getData());
     outData[0] = dataset;

package/Filters/General/MoleculeToRepresentation.js

@@ -54,8 +54,8 @@ function vtkMoleculeToRepresentation(publicAPI, model) {
     }
 
     // output
-    const SphereData = vtkPolyData.newInstance();
-    const StickData = vtkPolyData.newInstance();
+    const SphereData = outData[0]?.initialize() || vtkPolyData.newInstance();
+    const StickData = outData[1]?.initialize() || vtkPolyData.newInstance();
 
     // Fetch from input molecule data
     let numPts = 0;

package/Filters/General/OutlineFilter.js

@@ -41,7 +41,7 @@ function vtkOutlineFilter(publicAPI, model) {
       return;
     }
     const bounds = input.getBounds();
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.getPoints().setData(Float32Array.from(BOUNDS_MAP.map(idx => bounds[idx])), 3);
     output.getLines().setData(Uint16Array.from(LINE_ARRAY));
     outData[0] = output;

package/Filters/General/ScalarToRGBA.js

@@ -52,7 +52,8 @@ function vtkScalarToRGBA(publicAPI, model) {
       values: rgbaArray
     });
     const datasetDefinition = input.get('extent', 'spacing', 'origin', 'direction');
-    const output = vtkImageData.newInstance(datasetDefinition);
+    const output = outData[0]?.initialize() || vtkImageData.newInstance();
+    output.set(datasetDefinition);
     output.getPointData().setScalars(colorArray);
     outData[0] = output;
   };

package/Filters/General/ShrinkPolyData.js

@@ -258,7 +258,7 @@ function vtkShrinkPolyData(publicAPI, model) {
   }
   publicAPI.requestData = (inData, outData) => {
     const input = inData[0];
-    const output = outData[0] || vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     if (!input) {
       vtkErrorMacro('No input!');
       return;

package/Filters/General/TransformPolyDataFilter.js

@@ -143,7 +143,7 @@ function vtkTransformPolyDataFilter(publicAPI, model) {
   }
   publicAPI.requestData = (inData, outData) => {
     const input = inData[0];
-    const output = outData[0] || vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     if (transformPolyData(input, output)) {
       outData[0] = output;
     } else {

package/Filters/General/TriangleFilter.js

@@ -72,7 +72,7 @@ function vtkTriangleFilter(publicAPI, model) {
         }
       }
     }
-    const dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataset.getPoints().setData(macro.newTypedArrayFrom(pointsDataType, newPoints));
     dataset.getPolys().setData(macro.newTypedArrayFrom(cellsDataType, newCells));
     outData[0] = dataset;

package/Filters/General/TubeFilter.js

@@ -535,7 +535,7 @@ function vtkTubeFilter(publicAPI, model) {
   publicAPI.requestData = (inData, outData) => {
     // implement requestData
     // pass through for now
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     outData[0] = output;
     const input = inData[0];
     if (!input) {
@@ -733,7 +733,6 @@ function vtkTubeFilter(publicAPI, model) {
     output.setStrips(newStrips);
     output.setPointData(outPD);
     outPD.setNormals(newNormals);
-    outData[0] = output;
   };
 }
 

package/Filters/General/WarpScalar.js

@@ -69,7 +69,7 @@ function vtkWarpScalar(publicAPI, model) {
       newPtsData[ptOffset + 1] = inPoints[ptOffset + 1] + model.scaleFactor * s * n[1];
       newPtsData[ptOffset + 2] = inPoints[ptOffset + 2] + model.scaleFactor * s * n[2];
     }
-    const newDataSet = vtk({
+    const newDataSet = outData[0] && outData[0] !== inData[0] ? outData[0].initialize() : vtk({
       vtkClass: input.getClassName()
     });
     newDataSet.shallowCopy(input);

package/Filters/General/WindowedSincPolyDataFilter.js

@@ -513,7 +513,7 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
     if (!input) {
       return;
     }
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     const outputPoints = publicAPI.vtkWindowedSincPolyDataFilterExecute(input.getPoints(), input, output);
     output.setPointData(input.getPointData());
     output.setCellData(input.getCellData());

package/Filters/Sources/ArcSource.js

@@ -21,7 +21,7 @@ function vtkArcSource(publicAPI, model) {
     const numLines = model.resolution;
     const numPts = model.resolution + 1;
     const tc = [0.0, 0.0];
-    const output = outData[0] || vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     let angle = 0.0;
     let radius = 0.5;
     const perpendicular = [0, 0, 0];

package/Filters/Sources/Arrow2DSource.js

@@ -11,8 +11,7 @@ const {
 // vtkArrow2DSource methods
 // ----------------------------------------------------------------------------
 
-function vtkStarSource(publicAPI, model) {
-  const dataset = vtkPolyData.newInstance();
+function vtkStarSource(publicAPI, model, dataset) {
   const points = macro.newTypedArray(model.pointType, 10 * 3);
   const edges = new Uint32Array(11);
   edges[0] = 10;
@@ -27,8 +26,7 @@ function vtkStarSource(publicAPI, model) {
   dataset.getPolys().setData(edges, 1);
   return dataset;
 }
-function vtk6PointsArrow(publicAPI, model) {
-  const dataset = vtkPolyData.newInstance();
+function vtk6PointsArrow(publicAPI, model, dataset) {
   const points = macro.newTypedArray(model.pointType, 6 * 3);
   const thickOp = model.height * 0.5 * model.thickness;
   const offsetOp = model.height * 0.5 - thickOp;
@@ -58,8 +56,7 @@ function vtk6PointsArrow(publicAPI, model) {
   dataset.getPolys().setData(cells, 1);
   return dataset;
 }
-function vtk4PointsArrow(publicAPI, model) {
-  const dataset = vtkPolyData.newInstance();
+function vtk4PointsArrow(publicAPI, model, dataset) {
   const points = macro.newTypedArray(model.pointType, 4 * 3);
   const thickOp = model.height / 3 * model.thickness;
   const offsetOp = model.height / 3 - thickOp;
@@ -81,8 +78,7 @@ function vtk4PointsArrow(publicAPI, model) {
   dataset.getPolys().setData(cells, 1);
   return dataset;
 }
-function vtkTriangleSource(publicAPI, model) {
-  const dataset = vtkPolyData.newInstance();
+function vtkTriangleSource(publicAPI, model, dataset) {
   const points = macro.newTypedArray(model.pointType, 3 * 3);
   const baseOffsetOp = model.height * (1 - model.base);
   points[0] = model.width / 2 * -1;
@@ -107,7 +103,8 @@ function vtkArrow2DSource(publicAPI, model) {
     [ShapeType.ARROW_6]: vtk6PointsArrow
   };
   publicAPI.requestData = (inData, outData) => {
-    outData[0] = shapeToSource[model.shape](publicAPI, model);
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
+    outData[0] = shapeToSource[model.shape](publicAPI, model, dataset);
     vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([1, 0, 0], model.direction).apply(outData[0].getPoints().getData());
   };
 }

package/Filters/Sources/ArrowSource.js

@@ -11,10 +11,7 @@ import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 function vtkArrowSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkArrowSource');
-  function requestData(inData, outData) {
-    if (model.deleted) {
-      return;
-    }
+  publicAPI.requestData = (inData, outData) => {
     const cylinder = vtkCylinderSource.newInstance({
       capping: true
     });
@@ -57,10 +54,7 @@ function vtkArrowSource(publicAPI, model) {
       // Update output
       outData[0] = append.getOutputData();
     }
-  }
-
-  // Expose methods
-  publicAPI.requestData = requestData;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Filters/Sources/CircleSource.js

@@ -10,11 +10,8 @@ import { x as multiplyScalar } from '../../Common/Core/Math/index.js';
 function vtkCircleSource(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkCircleSource');
-  function requestData(inData, outData) {
-    if (model.deleted) {
-      return;
-    }
-    let dataset = outData[0];
+  publicAPI.requestData = (inData, outData) => {
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
 
     // Points
     const points = macro.newTypedArray(model.pointType, model.resolution * 3);
@@ -36,7 +33,6 @@ function vtkCircleSource(publicAPI, model) {
 
     // connect endpoints
     edges[edges.length - 1] = edges[1];
-    dataset = vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
     if (model.lines) {
       dataset.getLines().setData(edges, 1);
@@ -50,10 +46,7 @@ function vtkCircleSource(publicAPI, model) {
 
     // Update output
     outData[0] = dataset;
-  }
-
-  // Expose methods
-  publicAPI.requestData = requestData;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Filters/Sources/ConcentricCylinderSource.js

@@ -64,14 +64,14 @@ function vtkConcentricCylinderSource(publicAPI, model) {
     }
   };
   publicAPI.getMaskLayer = index => index === undefined ? model.mask : model.mask[index];
-  function requestData(inData, outData) {
-    if (model.deleted || !model.radius.length) {
+  publicAPI.requestData = (inData, outData) => {
+    if (!model.radius.length) {
+      macro.vtkErrorMacro('No radius defined');
       return;
     }
 
     // Make sure we have consistency
     validateCellFields();
-    let dataset = outData[0];
     const numLayers = model.radius.length;
     const zRef = model.height / 2.0;
 
@@ -324,7 +324,7 @@ function vtkConcentricCylinderSource(publicAPI, model) {
 
     // Apply transformation to the point coordinates
     vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([0, 0, 1], model.direction).apply(points);
-    dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
     dataset.getPolys().setData(polys, 1);
     dataset.getCellData().setScalars(vtkDataArray.newInstance({
@@ -334,10 +334,7 @@ function vtkConcentricCylinderSource(publicAPI, model) {
 
     // Update output
     outData[0] = dataset;
-  }
-
-  // Expose methods
-  publicAPI.requestData = requestData;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Filters/Sources/ConeSource.js

@@ -9,11 +9,7 @@ import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 function vtkConeSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkConeSource');
-  function requestData(inData, outData) {
-    if (model.deleted) {
-      return;
-    }
-    let dataset = outData[0];
+  publicAPI.requestData = (inData, outData) => {
     const angle = 2 * Math.PI / model.resolution;
     const xbot = -model.height / 2.0;
     const numberOfPoints = model.resolution + 1;
@@ -60,16 +56,13 @@ function vtkConeSource(publicAPI, model) {
 
     // Apply transformation to the points coordinates
     vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([1, 0, 0], model.direction).apply(points);
-    dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
     dataset.getPolys().setData(polys, 1);
 
     // Update output
     outData[0] = dataset;
-  }
-
-  // Expose methods
-  publicAPI.requestData = requestData;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Filters/Sources/CubeSource.js

@@ -17,11 +17,8 @@ const POLY_ARRAY = [4, 0, 1, 3, 2, 4, 4, 6, 7, 5, 4, 8, 10, 11, 9, 4, 12, 13, 15
 function vtkCubeSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCubeSource');
-  function requestData(inData, outData) {
-    if (model.deleted) {
-      return;
-    }
-    const polyData = vtkPolyData.newInstance();
+  publicAPI.requestData = (inData, outData) => {
+    const polyData = outData[0]?.initialize() || vtkPolyData.newInstance();
     outData[0] = polyData;
     const numberOfPoints = 24;
 
@@ -183,7 +180,7 @@ function vtkCubeSource(publicAPI, model) {
       polyData.getLines().initialize();
     }
     polyData.modified();
-  }
+  };
   publicAPI.setBounds = function () {
     let boundsArray = [];
     if (Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
@@ -201,9 +198,6 @@ function vtkCubeSource(publicAPI, model) {
     publicAPI.setZLength(boundsArray[5] - boundsArray[4]);
     publicAPI.setCenter([(boundsArray[0] + boundsArray[1]) / 2.0, (boundsArray[2] + boundsArray[3]) / 2.0, (boundsArray[4] + boundsArray[5]) / 2.0]);
   };
-
-  // Expose methods
-  publicAPI.requestData = requestData;
 }
 
 // ----------------------------------------------------------------------------

package/Filters/Sources/Cursor3D.js

@@ -72,9 +72,6 @@ function vtkCursor3D(publicAPI, model) {
     publicAPI.setAll(false);
   };
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     let numPts = 0;
     let numLines = 0;
     // Check bounding box and origin
@@ -112,7 +109,7 @@ function vtkCursor3D(publicAPI, model) {
     if (numPts === 0) {
       return;
     }
-    const polyData = vtkPolyData.newInstance();
+    const polyData = outData[0]?.initialize() || vtkPolyData.newInstance();
     const newPts = vtkPoints.newInstance({
       size: numPts * 3
     });

package/Filters/Sources/CylinderSource.js

@@ -10,11 +10,7 @@ import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 function vtkCylinderSource(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkCylinderSource');
-  function requestData(inData, outData) {
-    if (model.deleted) {
-      return;
-    }
-    let dataset = outData[0];
+  publicAPI.requestData = (inData, outData) => {
     const angle = 2.0 * Math.PI / model.resolution;
     let numberOfPoints = 2 * model.resolution;
     let numberOfPolys = 5 * model.resolution;
@@ -147,7 +143,7 @@ function vtkCylinderSource(publicAPI, model) {
 
     // Apply transformation to the points coordinates
     vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([0, 1, 0], model.direction).translate(...model.center.map(c => c * -1)).apply(points);
-    dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
     dataset.getPolys().setData(polys, 1);
     dataset.getPointData().setNormals(normals);
@@ -155,10 +151,7 @@ function vtkCylinderSource(publicAPI, model) {
 
     // Update output
     outData[0] = dataset;
-  }
-
-  // Expose methods
-  publicAPI.requestData = requestData;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Filters/Sources/DiskSource.js

@@ -25,10 +25,6 @@ function vtkDiskSource(publicAPI, model) {
       circumferentialResolution,
       pointType
     } = model;
-    if (model.deleted) {
-      return;
-    }
-    let dataset = outData[0];
 
     // Points
     const points = vtkPoints.newInstance({
@@ -83,7 +79,7 @@ function vtkDiskSource(publicAPI, model) {
       }
     }
     polys.setData(cellData, cellCount, 1);
-    dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataset.setPoints(points);
     dataset.setPolys(polys);
 

package/Filters/Sources/EllipseArcSource.js

@@ -26,7 +26,7 @@ function vtkEllipseArcSource(publicAPI, model) {
     const numLines = resolution;
     const numPts = resolution + 1;
     const tc = [0.0, 0.0];
-    const output = outData[0] || vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
 
     // Make sure the normal vector is normalized
     const normal = [...model.normal];

package/Filters/Sources/ImageGridSource.js

@@ -10,9 +10,6 @@ function vtkImageGridSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageGridSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const state = {};
     const dataset = {
       type: 'vtkImageData',

package/Filters/Sources/LineSource.js

@@ -14,14 +14,11 @@ function vtkLineSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLineSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const dataset = outData[0];
 
     // Check input
     const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    const pd = vtkPolyData.newInstance();
+    const pd = dataset?.initialize() || vtkPolyData.newInstance();
     const v21 = [];
     subtract(model.point2, model.point1, v21);
     if (norm(v21) <= 0.0) {

package/Filters/Sources/PlaneSource.js

@@ -18,14 +18,11 @@ function vtkPlaneSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPlaneSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const dataset = outData[0];
 
     // Check input
     const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    const pd = vtkPolyData.newInstance();
+    const pd = dataset?.initialize() || vtkPolyData.newInstance();
     const v10 = [];
     const v20 = [];
     subtract(model.point1, model.origin, v10);

package/Filters/Sources/PlatonicSolidSource.js

@@ -63,7 +63,7 @@ function vtkPlatonicSolidSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPlatonicSolidSource');
   publicAPI.requestData = (inData, outData) => {
-    const output = outData[0] || vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     let solidData;
     switch (model.solidType) {
       case SolidType.VTK_SOLID_TETRAHEDRON:

package/Filters/Sources/PointSource.js

@@ -10,14 +10,11 @@ function vtkPointSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPointSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const dataset = outData[0];
 
     // Check input
     const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    const pd = vtkPolyData.newInstance();
+    const pd = dataset?.initialize() || vtkPolyData.newInstance();
 
     // hand create a point cloud
     const numPts = model.numberOfPoints;

package/Filters/Sources/RTAnalyticSource.js

@@ -8,9 +8,6 @@ function vtkRTAnalyticSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkRTAnalyticSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const state = {};
     const dataset = {
       type: 'vtkImageData',

package/Filters/Sources/SLICSource.js

@@ -60,11 +60,8 @@ function vtkSLICSource(publicAPI, model) {
   };
   publicAPI.getNumberOfClusters = () => model.clusters.length;
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const dataSize = model.dimensions[0] * model.dimensions[1] * model.dimensions[2];
-    const imageData = vtkImageData.newInstance();
+    const imageData = outData[0]?.initialize() || vtkImageData.newInstance();
     imageData.setSpacing(...model.spacing);
     imageData.setExtent(0, model.dimensions[0] - 1, 0, model.dimensions[1] - 1, 0, model.dimensions[2] - 1);
     imageData.setOrigin(...model.origin);

package/Filters/Sources/SphereSource.js

@@ -10,12 +10,9 @@ function vtkSphereSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSphereSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     let dataset = outData[0];
     const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    dataset = vtkPolyData.newInstance();
+    dataset = dataset?.initialize() || vtkPolyData.newInstance();
 
     // ----------------------------------------------------------------------
     let numPoles = 0;

package/Filters/Sources/ViewFinderSource.js

@@ -4,7 +4,7 @@ import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 function vtkViewFinderSource(publicAPI, model) {
   publicAPI.requestData = (inData, outData) => {
-    const dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     const points = macro.newTypedArray(model.pointType, 3 * 16);
     points[0] = model.radius;
     points[1] = model.radius / model.width;

package/Filters/Texture/TextureMapToPlane.js

@@ -90,16 +90,13 @@ function vtkTextureMapToPlane(publicAPI, model) {
     model.normal[2] = -1.0;
   }
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const input = inData[0];
     const nbPoints = input.getPoints().getNumberOfPoints();
     if (nbPoints < 3 && model.automaticPlaneGeneration) {
       vtkErrorMacro("Can't generate texture coordinates without points");
       return;
     }
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.getPoints().setData(new Float32Array(input.getPoints().getData()), 3);
     output.getPolys().setData(new Uint32Array(input.getPolys().getData()));
     const tcoordsData = [];

package/Filters/Texture/TextureMapToSphere.js

@@ -15,9 +15,6 @@ function vtkTextureMapToSphere(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkTextureMapToSphere');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const input = inData[0];
     const nbPoints = input.getPoints().getNumberOfPoints();
     if (nbPoints <= 1) {
@@ -108,7 +105,7 @@ function vtkTextureMapToSphere(publicAPI, model) {
       size: nbPoints,
       values: tcoordsData
     });
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.getPoints().setData(new Float32Array(input.getPoints().getData()), 3);
     output.getPolys().setData(new Uint32Array(input.getPolys().getData()));
     output.getPointData().setTCoords(tCoords);

package/Imaging/Core/ImageReslice.js

@@ -206,7 +206,7 @@ function vtkImageReslice(publicAPI, model) {
     });
 
     // Update output
-    const output = vtkImageData.newInstance();
+    const output = outData[0]?.initialize() || vtkImageData.newInstance();
     output.setDimensions(outDims);
     output.setOrigin(outOrigin);
     output.setSpacing(outSpacing);

package/Imaging/Hybrid/SampleFunction.js

@@ -39,7 +39,7 @@ function vtkSampleFunction(publicAPI, model) {
       vtkErrorMacro('Bad volume dimensions');
       return;
     }
-    const volume = vtkImageData.newInstance();
+    const volume = outData[0]?.initialize() || vtkImageData.newInstance();
     const origin = [model.modelBounds[0], model.modelBounds[2], model.modelBounds[4]];
     const spacing = [(model.modelBounds[1] - model.modelBounds[0]) / (dims[0] - 1), (model.modelBounds[3] - model.modelBounds[2]) / (dims[1] - 1), (model.modelBounds[5] - model.modelBounds[4]) / (dims[2] - 1)];
     const sliceSize = dims[0] * dims[1];

package/Rendering/Core/VectorText.js

@@ -241,11 +241,10 @@ function vtkVectorText(publicAPI, model) {
    * Creates a vtkPolyData from the processed shapes
    * @returns {Object} vtkPolyData instance
    */
-  function buildPolyData() {
+  function buildPolyData(polyData) {
     model.verticesArray = [];
     model.uvArray = [];
     model.colorArray = [];
-    const polyData = vtkPolyData.newInstance();
     const cells = vtkCellArray.newInstance();
     const pointData = polyData.getPointData();
 
@@ -328,7 +327,9 @@ function vtkVectorText(publicAPI, model) {
       return;
     }
     buildShape();
-    outData[0] = buildPolyData();
+    const polyData = outData[0]?.initialize() || vtkPolyData.newInstance();
+    buildPolyData(polyData);
+    outData[0] = polyData;
   };
 }
 

package/Rendering/Core/Viewport.d.ts

@@ -63,14 +63,19 @@ export interface vtkViewport extends vtkObject {
   getSize(): Size;
 
   /**
-   *
+   * Viewport for the Viewport to draw in the rendering window.
+   * Coordinates are expressed as (xmin,ymin,xmax,ymax), where each
+   * coordinate is 0 <= coordinate <= 1.0.
+   * @returns {Number[]}
+   * @see getViewportByReference()
+   * @see setViewport()
    */
-  getViewport(): vtkViewport;
+  getViewport(): [number, number, number, number];
 
   /**
    *
    */
-  getViewportByReference(): vtkViewport;
+  getViewportByReference(): [number, number, number, number];
 
   /**
    *