@kitware/vtk.js 34.11.0 → 34.11.1

package/Common/Core/DataArray.js

@@ -196,9 +196,10 @@ function vtkDataArray(publicAPI, model) {
     return false;
   };
 
-  // FIXME, to rename into "clear()" or "reset()"
+  // Restore the array to initial state
   publicAPI.initialize = () => {
     publicAPI.resize(0);
+    return publicAPI;
   };
   publicAPI.getElementComponentSize = () => model.values.BYTES_PER_ELEMENT;
 

package/Common/Core/Points.d.ts

@@ -17,11 +17,21 @@ export interface vtkPoints extends vtkDataArray {
   computeBounds(): Bounds;
 
   /**
-   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * Get a copy of the bounds of the array.
+   * Bounds are [xmin, xmax, ymin, ymax,zmin, zmax].
+   * Will recompute the bounds if necessary.
    * @return {Bounds} The bounds for the mapper.
    */
   getBounds(): Bounds;
 
+  /**
+   * Get a reference to the model bounds of the array.
+   * Bounds are [xmin, xmax, ymin, ymax,zmin, zmax].
+   * Will recompute the bounds if necessary.
+   * @return {Bounds} The bounds for the mapper.
+   */
+  getBoundsByReference(): Bounds;
+
   /**
    * Get the coordinate of a point.
    * @param {Number} idx The index of point.

package/Common/Core/Points.js

@@ -1,17 +1,19 @@
 import { m as macro } from '../../macros2.js';
 import vtkDataArray from './DataArray.js';
 import { VtkDataTypes } from './DataArray/Constants.js';
+import { u as uninitializeBounds } from './Math/index.js';
 
 const {
   vtkErrorMacro
 } = macro;
-const INVALID_BOUNDS = [1, -1, 1, -1, 1, -1];
-
 // ----------------------------------------------------------------------------
 // vtkPoints methods
 // ----------------------------------------------------------------------------
 
 function vtkPoints(publicAPI, model) {
+  // Keep track of modified time for bounds computation
+  let boundMTime = 0;
+
   // Set our className
   model.classHierarchy.push('vtkPoints');
 
@@ -36,7 +38,23 @@ function vtkPoints(publicAPI, model) {
   publicAPI.findPoint = publicAPI.findTuple;
   publicAPI.insertNextPoint = (x, y, z) => publicAPI.insertNextTuple([x, y, z]);
   publicAPI.insertPoint = (ptId, point) => publicAPI.insertTuple(ptId, point);
+  const superGetBounds = publicAPI.getBounds;
   publicAPI.getBounds = () => {
+    if (boundMTime < model.mtime) {
+      publicAPI.computeBounds();
+    }
+    return superGetBounds();
+  };
+  const superGetBoundsByReference = publicAPI.getBoundsByReference;
+  publicAPI.getBoundsByReference = () => {
+    if (boundMTime < model.mtime) {
+      publicAPI.computeBounds();
+    }
+    return superGetBoundsByReference();
+  };
+
+  // Trigger the computation of bounds
+  publicAPI.computeBounds = () => {
     if (publicAPI.getNumberOfComponents() === 3) {
       const xRange = publicAPI.getRange(0);
       model.bounds[0] = xRange[0];
@@ -47,26 +65,22 @@ function vtkPoints(publicAPI, model) {
       const zRange = publicAPI.getRange(2);
       model.bounds[4] = zRange[0];
       model.bounds[5] = zRange[1];
-      return model.bounds;
-    }
-    if (publicAPI.getNumberOfComponents() !== 2) {
+    } else if (publicAPI.getNumberOfComponents() === 2) {
+      const xRange = publicAPI.getRange(0);
+      model.bounds[0] = xRange[0];
+      model.bounds[1] = xRange[1];
+      const yRange = publicAPI.getRange(1);
+      model.bounds[2] = yRange[0];
+      model.bounds[3] = yRange[1];
+      model.bounds[4] = 0;
+      model.bounds[5] = 0;
+    } else {
       vtkErrorMacro(`getBounds called on an array with components of ${publicAPI.getNumberOfComponents()}`);
-      return INVALID_BOUNDS;
+      uninitializeBounds(model.bounds);
     }
-    const xRange = publicAPI.getRange(0);
-    model.bounds[0] = xRange[0];
-    model.bounds[1] = xRange[1];
-    const yRange = publicAPI.getRange(1);
-    model.bounds[2] = yRange[0];
-    model.bounds[3] = yRange[1];
-    model.bounds[4] = 0;
-    model.bounds[5] = 0;
-    return model.bounds;
+    boundMTime = macro.getCurrentGlobalMTime();
   };
 
-  // Trigger the computation of bounds
-  publicAPI.computeBounds = publicAPI.getBounds;
-
   // Initialize
   publicAPI.setNumberOfComponents(model.numberOfComponents < 2 ? 3 : model.numberOfComponents);
 }
@@ -88,6 +102,7 @@ function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkDataArray.extend(publicAPI, model, initialValues);
+  macro.getArray(publicAPI, model, ['bounds'], 6);
   vtkPoints(publicAPI, model);
 }
 

package/Common/DataModel/BoundingBox.d.ts

@@ -1,6 +1,7 @@
 import { mat4 } from 'gl-matrix';
 import { Bounds, Vector2, Vector3 } from './../../types';
 import vtkPoints from './../Core/Points';
+import { Nullable } from './../../types';
 
 /**
  * Tests whether two bounds equal.
@@ -176,10 +177,16 @@ export function getZRange(bounds: Bounds): Vector2;
 export function getMaxLength(bounds: Bounds): number;
 
 /**
- * Gets the diagonal of the bounding box.
+ * Gets the diagonal length of the bounding box.
  * @param {Bounds} bounds
  */
-export function getDiagonalLength(bounds: Bounds): number;
+export function getDiagonalLength(bounds: Bounds): Nullable<number>;
+
+/**
+ * Gets the squared diagonal length of the bounding box.
+ * @param {Bounds} bounds
+ */
+export function getDiagonalLength2(bounds: Bounds): Nullable<number>;
 
 /**
  * Gets the min point.
@@ -506,10 +513,16 @@ declare class BoundingBox {
   getMaxLength(bounds: Bounds): number;
 
   /**
-   * Gets the diagonal of the bounding box.
+   * Gets the diagonal length of the bounding box.
+   * @param {Bounds} bounds
+   */
+  getDiagonalLength(bounds: Bounds): Nullable<number>;
+
+  /**
+   * Gets the squared diagonal length of the bounding box.
    * @param {Bounds} bounds
    */
-  getDiagonalLength(bounds: Bounds): number;
+  getDiagonalLength2(bounds: Bounds): Nullable<number>;
 
   /**
    * Gets the min point.
@@ -674,6 +687,7 @@ declare const vtkBoundingBox: {
   getLengths: typeof getLengths;
   getMaxLength: typeof getMaxLength;
   getDiagonalLength: typeof getDiagonalLength;
+  getDiagonalLength2: typeof getDiagonalLength2;
   getMinPoint: typeof getMinPoint;
   getMaxPoint: typeof getMaxPoint;
   getXRange: typeof getXRange;

package/Common/DataModel/BoundingBox.js

@@ -213,13 +213,17 @@ function getMaxLength(bounds) {
   }
   return l[2];
 }
-function getDiagonalLength(bounds) {
+function getDiagonalLength2(bounds) {
   if (isValid(bounds)) {
     const l = getLengths(bounds);
-    return Math.sqrt(l[0] * l[0] + l[1] * l[1] + l[2] * l[2]);
+    return l[0] * l[0] + l[1] * l[1] + l[2] * l[2];
   }
   return null;
 }
+function getDiagonalLength(bounds) {
+  const lenght2 = getDiagonalLength2(bounds);
+  return lenght2 !== null ? Math.sqrt(lenght2) : null;
+}
 function getMinPoint(bounds) {
   return [bounds[0], bounds[2], bounds[4]];
 }
@@ -748,6 +752,9 @@ class BoundingBox {
   getDiagonalLength() {
     return getDiagonalLength(this.bounds);
   }
+  getDiagonalLength2() {
+    return getDiagonalLength2(this.bounds);
+  }
   getMinPoint() {
     return getMinPoint(this.bounds);
   }
@@ -862,4 +869,4 @@ var vtkBoundingBox = {
   ...STATIC
 };
 
-export { STATIC, addBounds, addPoint, addPoints, clampDivisions, computeCornerPoints, computeDivisions, computeLocalBounds, computeScale3, contains, containsPoint, cutWithPlane, vtkBoundingBox as default, distance2ToBounds, equals, getCenter, getCorners, getDiagonalLength, getLength, getLengths, getMaxLength, getMaxPoint, getMinPoint, getXRange, getYRange, getZRange, intersect, intersectBox, intersectPlane, intersects, isValid, reset, scale, scaleAboutCenter, setBounds, setMaxPoint, setMinPoint, transformBounds };
+export { STATIC, addBounds, addPoint, addPoints, clampDivisions, computeCornerPoints, computeDivisions, computeLocalBounds, computeScale3, contains, containsPoint, cutWithPlane, vtkBoundingBox as default, distance2ToBounds, equals, getCenter, getCorners, getDiagonalLength, getDiagonalLength2, getLength, getLengths, getMaxLength, getMaxPoint, getMinPoint, getXRange, getYRange, getZRange, intersect, intersectBox, intersectPlane, intersects, isValid, reset, scale, scaleAboutCenter, setBounds, setMaxPoint, setMinPoint, transformBounds };

package/Common/DataModel/Cell.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { u as uninitializeBounds } from '../Core/Math/index.js';
+import vtkBoundingBox from './BoundingBox.js';
 import vtkPoints from '../Core/Points.js';
 
 // ----------------------------------------------------------------------------
@@ -36,40 +36,10 @@ function vtkCell(publicAPI, model) {
       model.points.setData(triangleData);
     }
   };
-  publicAPI.getBounds = () => {
-    const nbPoints = model.points.getNumberOfPoints();
-    const x = [];
-    if (nbPoints) {
-      model.points.getPoint(0, x);
-      model.bounds[0] = x[0];
-      model.bounds[1] = x[0];
-      model.bounds[2] = x[1];
-      model.bounds[3] = x[1];
-      model.bounds[4] = x[2];
-      model.bounds[5] = x[2];
-      for (let i = 1; i < nbPoints; i++) {
-        model.points.getPoint(i, x);
-        model.bounds[0] = x[0] < model.bounds[0] ? x[0] : model.bounds[0];
-        model.bounds[1] = x[0] > model.bounds[1] ? x[0] : model.bounds[1];
-        model.bounds[2] = x[1] < model.bounds[2] ? x[1] : model.bounds[2];
-        model.bounds[3] = x[1] > model.bounds[3] ? x[1] : model.bounds[3];
-        model.bounds[4] = x[2] < model.bounds[4] ? x[2] : model.bounds[4];
-        model.bounds[5] = x[2] > model.bounds[5] ? x[2] : model.bounds[5];
-      }
-    } else {
-      uninitializeBounds(model.bounds);
-    }
-    return model.bounds;
-  };
+  publicAPI.getBounds = () => model.points.getBounds();
   publicAPI.getLength2 = () => {
-    publicAPI.getBounds();
-    let length = 0.0;
-    let diff = 0;
-    for (let i = 0; i < 3; i++) {
-      diff = model.bounds[2 * i + 1] - model.bounds[2 * i];
-      length += diff * diff;
-    }
-    return length;
+    const lengths = vtkBoundingBox.getLengths(publicAPI.getBounds());
+    return lengths[0] * lengths[0] + lengths[1] * lengths[1] + lengths[2] * lengths[2];
   };
   publicAPI.getParametricDistance = pcoords => {
     let pDist;

package/Common/DataModel/DataSet.d.ts

@@ -8,6 +8,13 @@ import { FieldAssociations, FieldDataTypes } from './DataSet/Constants';
 export interface IDataSetInitialValues {}
 
 export interface vtkDataSet extends vtkObject {
+  /**
+   * Initialize the field, cell and point data.
+   * @see vtkDataSetAttributes::initialize()
+   * @see vtkFieldData::initialize()
+   */
+  initialize(): void;
+
   /**
    * Get dataset's cell data
    */

package/Common/DataModel/DataSet.js

@@ -65,6 +65,12 @@ function vtkDataSet(publicAPI, model) {
       model[fieldName].shallowCopy(other.getReferenceByName(fieldName));
     });
   };
+  const superGetMTime = publicAPI.getMTime;
+  publicAPI.getMTime = () => DATASET_FIELDS.reduce((mTime, fieldName) => Math.max(mTime, model[fieldName]?.getMTime() ?? mTime), superGetMTime());
+  publicAPI.initialize = () => {
+    DATASET_FIELDS.forEach(fieldName => model[fieldName]?.initialize());
+    return publicAPI;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Common/DataModel/DataSetAttributes/FieldData.d.ts

@@ -22,12 +22,16 @@ interface IArrayWithIndex {
 
 export interface vtkFieldData extends vtkObject {
   /**
-   *
+   * Initialize fields, clear flags and restore copy beahvior.
+   * @see initializeFields
+   * @see clearFieldFlags
+   * @see copyAllOn
    */
   initialize(): void;
 
   /**
-   *
+   * Delete all arrays and clear flags.
+   * @see initialize
    */
   initializeFields(): void;
 

package/Common/DataModel/DataSetAttributes.d.ts

@@ -229,7 +229,8 @@ export interface vtkDataSetAttributes extends vtkFieldData {
   removeArrayByIndex(arrayIdx: number): void;
 
   /**
-   *
+   * Called when initialize() is called.
+   * @see initialize
    */
   initializeAttributeCopyFlags(): void;
 

package/Common/DataModel/ImageData.d.ts

@@ -20,6 +20,13 @@ interface IComputeHistogram {
 }
 
 export interface vtkImageData extends vtkDataSet {
+  /**
+   * Reinitialize the state (direction, spacing, origin, extent, etc.)
+   * and the data set.
+   * @see vtkDataSet::initialize()
+   */
+  initialize(): void;
+
   /**
    * Returns an object with `{ minimum, maximum, average, variance, sigma, count }`
    * of the imageData points found within the provided `worldBounds`.

package/Common/DataModel/ImageData.js

@@ -314,6 +314,17 @@ function vtkImageData(publicAPI, model) {
     }
     return publicAPI.getPointData().getScalars().getComponent(offsetIndex, comp);
   };
+  const superInitialize = publicAPI.initialize;
+  publicAPI.initialize = () => {
+    publicAPI.set({
+      direction: mat3.identity(model.direction),
+      spacing: [1.0, 1.0, 1.0],
+      origin: [0.0, 0.0, 0.0],
+      extent: [0, -1, 0, -1, 0, -1],
+      dataDescription: StructuredType.EMPTY
+    });
+    return superInitialize();
+  };
 }
 
 // ----------------------------------------------------------------------------

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;