@kitware/vtk.js 34.10.0 → 34.11.1

package/Common/DataModel/PointSet.d.ts

@@ -8,6 +8,12 @@ import vtkDataSet, { IDataSetInitialValues } from './DataSet';
 export interface IPointSetInitialValues extends IDataSetInitialValues {}
 
 export interface vtkPointSet extends vtkDataSet {
+  /**
+   * Empty the points and initialize the data set and .
+   * @see vtkDataSet::initialize()
+   */
+  initialize(): void;
+
   /**
    * Compute the (X, Y, Z) bounds of the data.
    */

package/Common/DataModel/PointSet.js

@@ -33,6 +33,16 @@ function vtkPointSet(publicAPI, model) {
     model.points = vtkPoints.newInstance();
     model.points.shallowCopy(other.getPoints());
   };
+  const superGetMTime = publicAPI.getMTime;
+  publicAPI.getMTime = () => {
+    const mTime = superGetMTime();
+    return Math.max(mTime, model.points?.getMTime() ?? mTime);
+  };
+  const superInitialize = publicAPI.initialize;
+  publicAPI.initialize = () => {
+    model.points?.initialize();
+    return superInitialize();
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Common/DataModel/PolyData.d.ts

@@ -8,6 +8,12 @@ import vtkPointSet, { IPointSetInitialValues } from './PointSet';
 export interface IPolyDataInitialValues extends IPointSetInitialValues {}
 
 export interface vtkPolyData extends vtkPointSet {
+  /**
+   * Empty the cells and initialize the point set.
+   * @see vtkPointSet::initialize()
+   */
+  initialize(): void;
+
   /**
    * Create data structure that allows random access of cells.
    */

package/Common/DataModel/PolyData.js

@@ -48,6 +48,13 @@ function vtkPolyData(publicAPI, model) {
       model[type].shallowCopy(other.getReferenceByName(type));
     });
   };
+  const superGetMTime = publicAPI.getMTime;
+  publicAPI.getMTime = () => POLYDATA_FIELDS.reduce((mTime, type) => Math.max(mTime, model[type]?.getMTime() ?? mTime), superGetMTime());
+  const superInitialize = publicAPI.initialize;
+  publicAPI.initialize = () => {
+    POLYDATA_FIELDS.forEach(type => model[type]?.initialize());
+    return superInitialize();
+  };
   publicAPI.buildCells = () => {
     // here are the number of cells we have
     const nVerts = publicAPI.getNumberOfVerts();

package/Filters/Core/Cutter.js

@@ -287,7 +287,7 @@ function vtkCutter(publicAPI, model) {
       vtkErrorMacro('Missing cut function');
       return;
     }
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataSetCutter(input, output);
     outData[0] = output;
   };

package/Filters/Core/PolyDataNormals.js

@@ -70,7 +70,7 @@ function vtkPolyDataNormals(publicAPI, model) {
     if (!input) {
       return;
     }
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.setPoints(input.getPoints());
     output.setVerts(input.getVerts());
     output.setLines(input.getLines());

package/Filters/Core/ThresholdPoints.js

@@ -43,7 +43,7 @@ function vtkThresholdPoints(publicAPI, model) {
   model.classHierarchy.push('vtkThresholdPoints');
   publicAPI.requestData = (inData, outData) => {
     const input = inData[0];
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     outData[0] = output;
     if (model.criterias.length === 0) {
       output.shallowCopy(input);
@@ -170,7 +170,6 @@ function vtkThresholdPoints(publicAPI, model) {
         dataType: input.getPolys().getDataType()
       }));
     });
-    outData[0] = output;
   };
 }
 

package/Filters/General/AppendPolyData.js

@@ -43,7 +43,7 @@ function vtkAppendPolyData(publicAPI, model) {
     }
 
     // Allocate output
-    const output = vtkPolyData.newInstance();
+    const output = outData[0] && inData[0] !== outData[0] ? outData[0].initialize() : vtkPolyData.newInstance();
     let numPts = 0;
     let pointType = 0;
     let ttype = 1;

package/Filters/General/Calculator.js

@@ -172,7 +172,7 @@ function vtkCalculator(publicAPI, model) {
       return 0;
     }
     const arraySpec = model.formula.getArrays(inData);
-    const newDataSet = vtk({
+    const newDataSet = outData[0]?.initialize() || vtk({
       vtkClass: inData[0].getClassName()
     });
     newDataSet.shallowCopy(inData[0]);

package/Filters/General/ClipClosedSurface.js

@@ -499,7 +499,7 @@ function vtkClipClosedSurface(publicAPI, model) {
   publicAPI.requestData = (inData, outData) => {
     // implement requestData
     const input = inData[0];
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     outData[0] = output;
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
@@ -830,8 +830,8 @@ function vtkClipClosedSurface(publicAPI, model) {
     squeezeOutputPoints(output, points, pointData, inputPointsType);
     // TODO: Check
     // output.squeeze();
-    outData[0] = output;
   };
+
   Object.keys(ScalarMode).forEach(key => {
     const name = capitalize(key.toLowerCase());
     publicAPI[`setScalarModeTo${name}`] = () => {

package/Filters/General/ClosedPolyLineToSurfaceFilter.js

@@ -125,7 +125,7 @@ function vtkClosedPolyLineToSurfaceFilter(publicAPI, model) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.shallowCopy(input);
 
     // Extract faces

package/Filters/General/ContourLoopExtraction.js

@@ -9,10 +9,8 @@ const visited = new Set();
 function vtkContourLoopExtraction(publicAPI, model) {
   publicAPI.requestData = (inData, outData) => {
     const [input] = inData;
-    if (!outData[0]) {
-      outData[0] = vtkPolyData.newInstance();
-    }
-    const [output] = outData;
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
+    outData[0] = output;
     publicAPI.extractContours(input, output);
     output.modified();
   };

package/Filters/General/ContourTriangulator.js

@@ -137,8 +137,7 @@ function vtkContourTriangulator(publicAPI, model) {
   publicAPI.requestData = (inData, outData) => {
     // implement requestData
     const input = inData[0];
-    // FIXME: do not instantiate a new polydata each time the filter is executed.
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     outData[0] = output;
     if (!input) {
       vtkErrorMacro('Invalid or missing input');

package/Filters/General/ImageCropFilter.js

@@ -32,6 +32,8 @@ function vtkImageCropFilter(publicAPI, model) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
+    const outImage = outData[0]?.initialize() || vtkImageData.newInstance();
+    outData[0] = outImage;
     const scalars = input.getPointData().getScalars();
     if (!scalars) {
       vtkErrorMacro('No scalars from input');
@@ -47,9 +49,7 @@ function vtkImageCropFilter(publicAPI, model) {
       return Math.min(e, Math.round(model.croppingPlanes[i]));
     }) : extent.slice();
     if (cropped[0] === extent[0] && cropped[1] === extent[1] && cropped[2] === extent[2] && cropped[3] === extent[3] && cropped[4] === extent[4] && cropped[5] === extent[5]) {
-      const sameAsInput = vtkImageData.newInstance();
-      sameAsInput.shallowCopy(input); // Force new mtime
-      outData[0] = sameAsInput;
+      outImage.shallowCopy(input); // Force new mtime
       return;
     }
 
@@ -88,19 +88,16 @@ function vtkImageCropFilter(publicAPI, model) {
         index += slice.length;
       }
     }
-    const outImage = vtkImageData.newInstance({
-      extent: cropped,
-      origin: input.getOrigin(),
-      direction: input.getDirection(),
-      spacing: input.getSpacing()
-    });
+    outImage.setExtent(cropped);
+    outImage.setOrigin(input.getOrigin());
+    outImage.setSpacing(input.getSpacing());
+    outImage.setDirection(input.getDirection());
     const croppedScalars = vtkDataArray.newInstance({
       name: scalars.getName(),
       numberOfComponents,
       values: croppedArray
     });
     outImage.getPointData().setScalars(croppedScalars);
-    outData[0] = outImage;
   };
   publicAPI.isResetAvailable = () => {
     if (model.croppingPlanes == null || model.croppingPlanes.length === 0) {

package/Filters/General/ImageMarchingCubes.js

@@ -251,7 +251,7 @@ function vtkImageMarchingCubes(publicAPI, model) {
     edgeLocator.initialize();
 
     // Update output
-    const polydata = vtkPolyData.newInstance();
+    const polydata = outData[0]?.initialize() || vtkPolyData.newInstance();
     polydata.getPoints().setData(new Float32Array(pBuffer), 3);
     polydata.getPolys().setData(new Uint32Array(tBuffer));
     if (model.computeNormals) {

package/Filters/General/ImageMarchingSquares.js

@@ -207,7 +207,7 @@ function vtkImageMarchingSquares(publicAPI, model) {
     }
 
     // Update output
-    const polydata = vtkPolyData.newInstance();
+    const polydata = outData[0]?.initialize() || vtkPolyData.newInstance();
     polydata.getPoints().setData(new Float32Array(points), 3);
     polydata.getLines().setData(new Uint32Array(lines));
     outData[0] = polydata;

package/Filters/General/ImageOutlineFilter.js

@@ -19,7 +19,8 @@ function vtkImageOutlineFilter(publicAPI, model) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-    const output = vtkImageData.newInstance(input.get('spacing', 'origin', 'direction'));
+    const output = outData[0]?.initialize() || vtkImageData.newInstance();
+    output.set(input.get('spacing', 'origin', 'direction'));
     const getIndex = (point, dims) => point[0] + point[1] * dims[0] + point[2] * dims[0] * dims[1];
     const getIJK = (index, dims) => {
       const ijk = [0, 0, 0];

package/Filters/General/ImageSliceFilter.js

@@ -37,7 +37,8 @@ function vtkImageSliceFilter(publicAPI, model) {
       numberOfComponents,
       values: sliceRawArray
     });
-    const output = vtkImageData.newInstance(datasetDefinition);
+    const output = outData[0]?.initialize() || vtkImageData.newInstance();
+    output.set(datasetDefinition);
     output.getPointData().setScalars(sliceArray);
     outData[0] = output;
   };

package/Filters/General/ImageStreamline.js

@@ -210,7 +210,7 @@ function vtkImageStreamline(publicAPI, model) {
       pointArray.set(data[0], offset2);
       offset2 += data[0].length;
     });
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.getPoints().setData(pointArray, 3);
     output.getLines().setData(cellArray);
     outData[0] = output;

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
     });