@kitware/vtk.js 34.10.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.
@@ -81,6 +91,14 @@ export interface vtkPoints extends vtkDataArray {
    * @returns {Number} Index of the inserted point.
    */
   insertNextPoint(x: number, y: number, z: number): number;
+
+  /**
+   * Insert the [x,y,z] coordinates of a point at the given index.
+   * @param {Number} ptId The index of point.
+   * @param {Number[]} point The [x, y, z] coordinates of the point.
+   * @returns {Number} The index of the inserted point.
+   */
+  insertPoint(ptId: number, point: number[]): number;
 }
 
 /**

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');
 
@@ -35,7 +37,24 @@ function vtkPoints(publicAPI, model) {
   publicAPI.getPoint = publicAPI.getTuple;
   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];
@@ -46,27 +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) {
-      vtkErrorMacro(`getBounds called on an array with components of
-        ${publicAPI.getNumberOfComponents()}`);
-      return INVALID_BOUNDS;
+    } 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()}`);
+      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/AbstractPointLocator.d.ts

@@ -1,6 +1,6 @@
 import { vtkObject } from './../../interfaces';
 import { Bounds } from './../../types';
-import { ILocatorInitialValues } from './Locator';
+import vtkLocator, { ILocatorInitialValues } from './Locator';
 
 /**
  *
@@ -11,7 +11,7 @@ export interface IAbstractPointLocatorInitialValues
   numberOfBuckets: number;
 }
 
-export interface vtkAbstractPointLocator extends vtkObject {
+export interface vtkAbstractPointLocator extends vtkLocator {
   /**
    * Set the bounds of this object.
    * @param {Bounds} input

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.
@@ -325,6 +332,37 @@ export function cutWithPlane(
   normal: Vector3
 ): boolean;
 
+/**
+ * Clamp the divisions to ensure the total number doesn't exceed targetBins
+ * @param {Number} targetBins - Maximum number of bins allowed
+ * @param {Number[]} divs - Divisions array to adjust [divX, divY, divZ]
+ */
+export function clampDivisions(targetBins: number, divs: number[]): void;
+
+/**
+ * Compute the number of divisions given the current bounding box and a
+ * target number of buckets/bins. Handles degenerate bounding boxes properly.
+ * @param {Bounds} bounds - The bounding box
+ * @param {Number} totalBins - Target number of bins
+ * @param {Number[]} divs - Output array to store divisions [divX, divY, divZ]
+ * @param {Bounds} [adjustedBounds] - Output array to store adjusted bounds if needed
+ * @returns {Number} The actual total number of bins
+ */
+export function computeDivisions(
+  bounds: Bounds,
+  totalBins: number,
+  divs: number[],
+  adjustedBounds?: Bounds
+): number;
+
+/**
+ * Calculate the squared distance from point x to the specified bounds.
+ * @param {Vector3} x  The point coordinates
+ * @param {Bounds} bounds  The bounding box coordinates
+ * @returns {Number} The squared distance to the bounds
+ */
+export function distance2ToBounds(x: Vector3, bounds: Bounds): number;
+
 declare class BoundingBox {
   getBounds(): Bounds;
   /**
@@ -409,10 +447,9 @@ declare class BoundingBox {
 
   /**
    * Inflates a bounding box.
-   * @param {Bounds} bounds
-   * @param {number} delta
+   * @param {number} [delta] The amount to inflate the bounding box by.
    */
-  inflate(bounds: Bounds, delta: number): Bounds;
+  inflate(delta?: number): Bounds;
 
   /**
    * Scales a bounding box.
@@ -476,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): number;
+  getDiagonalLength(bounds: Bounds): Nullable<number>;
+
+  /**
+   * Gets the squared diagonal length of the bounding box.
+   * @param {Bounds} bounds
+   */
+  getDiagonalLength2(bounds: Bounds): Nullable<number>;
 
   /**
    * Gets the min point.
@@ -611,6 +654,14 @@ declare class BoundingBox {
    * @param {Vector3} normal
    */
   cutWithPlane(bounds: Bounds, origin: Vector3, normal: Vector3): boolean;
+
+  /**
+   * Calculate the squared distance from point x to the specified bounds.
+   * @param {Vector3} x  The point coordinates
+   * @param {Bounds} bounds  The bounding box coordinates
+   * @returns {Number} The squared distance to the bounds
+   */
+  distance2ToBounds(x: Vector3, bounds: Bounds): number;
 }
 
 export interface IBoundingBoxInitialValues {
@@ -636,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;
@@ -653,6 +705,7 @@ declare const vtkBoundingBox: {
   intersects: typeof intersects;
   containsPoint: typeof containsPoint;
   contains: typeof contains;
+  distance2ToBounds: typeof distance2ToBounds;
   INIT_BOUNDS: Bounds;
 };
 

package/Common/DataModel/BoundingBox.js

@@ -96,6 +96,10 @@ function setMaxPoint(bounds, x, y, z) {
   return xMax !== x || yMax !== y || zMax !== z;
 }
 function inflate(bounds, delta) {
+  if (delta == null) {
+    // eslint-disable-next-line no-use-before-define
+    return minInflate(bounds);
+  }
   bounds[0] -= delta;
   bounds[1] += delta;
   bounds[2] -= delta;
@@ -104,6 +108,33 @@ function inflate(bounds, delta) {
   bounds[5] += delta;
   return bounds;
 }
+function minInflate(bounds) {
+  const nonZero = [0, 0, 0];
+  let maxIdx = -1;
+  let max = 0.0;
+  let w = 0.0;
+  for (let i = 0; i < 3; ++i) {
+    w = bounds[i * 2 + 1] - bounds[i * 2];
+    if (w > max) {
+      max = w;
+      maxIdx = i;
+    }
+    nonZero[i] = w > 0.0 ? 1 : 0;
+  }
+  if (maxIdx < 0) {
+    return inflate(bounds, 0.5);
+  }
+
+  // Any zero width sides are bumped out 1% of max side
+  for (let i = 0; i < 3; ++i) {
+    if (!nonZero[i]) {
+      const d = 0.005 * max;
+      bounds[i * 2] -= d;
+      bounds[i * 2 + 1] += d;
+    }
+  }
+  return bounds;
+}
 function scale(bounds, sx, sy, sz) {
   if (!isValid(bounds)) {
     return false;
@@ -182,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]];
 }
@@ -513,6 +548,145 @@ function cutWithPlane(bounds, origin, normal) {
   return true;
 }
 
+/**
+ * Clamp the divisions to ensure the total number doesn't exceed targetBins
+ * @param {Number} targetBins - Maximum number of bins allowed
+ * @param {Array} divs - Divisions array to adjust [divX, divY, divZ]
+ */
+function clampDivisions(targetBins, divs) {
+  for (let i = 0; i < 3; ++i) {
+    divs[i] = divs[i] < 1 ? 1 : divs[i];
+  }
+  let numBins = divs[0] * divs[1] * divs[2];
+  while (numBins > targetBins) {
+    for (let i = 0; i < 3; ++i) {
+      divs[i] = divs[i] > 1 ? divs[i] - 1 : 1;
+    }
+    numBins = divs[0] * divs[1] * divs[2];
+  }
+}
+
+/**
+ * Compute the number of divisions given the current bounding box and a
+ * target number of buckets/bins. Handles degenerate bounding boxes properly.
+ * @param {Bounds} bounds - The bounding box
+ * @param {Number} totalBins - Target number of bins
+ * @param {Array} divs - Output array to store divisions [divX, divY, divZ]
+ * @param {Array} [adjustedBounds] - Output array to store adjusted bounds if needed
+ * @returns {Number} The actual total number of bins
+ */
+function computeDivisions(bounds, totalBins, divs) {
+  let adjustedBounds = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  // This will always produce at least one bin
+  // eslint-disable-next-line no-param-reassign
+  totalBins = totalBins <= 0 ? 1 : totalBins;
+
+  // First determine the maximum length of the side of the bounds. Keep track
+  // of zero width sides of the bounding box.
+  let numNonZero = 0;
+  const nonZero = [0, 0, 0];
+  let maxIdx = -1;
+  let max = 0.0;
+  const lengths = getLengths(bounds);
+
+  // Use a finite tolerance when detecting zero width sides
+  const totLen = lengths[0] + lengths[1] + lengths[2];
+  const zeroDetectionTolerance = totLen * (0.001 / 3.0);
+  for (let i = 0; i < 3; ++i) {
+    if (lengths[i] > max) {
+      maxIdx = i;
+      max = lengths[i];
+    }
+    if (lengths[i] > zeroDetectionTolerance) {
+      nonZero[i] = 1;
+      numNonZero++;
+    } else {
+      nonZero[i] = 0;
+    }
+  }
+
+  // Get min and max points
+  const minPoint = getMinPoint(bounds);
+  const maxPoint = getMaxPoint(bounds);
+
+  // If the bounding box is degenerate, then one bin of arbitrary size
+  if (numNonZero < 1) {
+    divs[0] = 1;
+    divs[1] = 1;
+    divs[2] = 1;
+    adjustedBounds[0] = minPoint[0] - 0.5;
+    adjustedBounds[1] = maxPoint[0] + 0.5;
+    adjustedBounds[2] = minPoint[1] - 0.5;
+    adjustedBounds[3] = maxPoint[1] + 0.5;
+    adjustedBounds[4] = minPoint[2] - 0.5;
+    adjustedBounds[5] = maxPoint[2] + 0.5;
+    return 1;
+  }
+
+  // Compute the divisions roughly in proportion to the bounding box edge lengths
+  let f = totalBins;
+  f /= nonZero[0] ? lengths[0] / totLen : 1.0;
+  f /= nonZero[1] ? lengths[1] / totLen : 1.0;
+  f /= nonZero[2] ? lengths[2] / totLen : 1.0;
+  f **= 1.0 / numNonZero;
+  for (let i = 0; i < 3; ++i) {
+    divs[i] = nonZero[i] ? Math.floor(f * lengths[i] / totLen) : 1;
+    divs[i] = divs[i] < 1 ? 1 : divs[i];
+  }
+
+  // Make sure that we do not exceed the totalBins
+  clampDivisions(totalBins, divs);
+
+  // Now compute the final bounds, making sure it is a non-zero volume
+  const delta = 0.5 * lengths[maxIdx] / divs[maxIdx];
+  for (let i = 0; i < 3; ++i) {
+    if (nonZero[i]) {
+      adjustedBounds[2 * i] = minPoint[i];
+      adjustedBounds[2 * i + 1] = maxPoint[i];
+    } else {
+      adjustedBounds[2 * i] = minPoint[i] - delta;
+      adjustedBounds[2 * i + 1] = maxPoint[i] + delta;
+    }
+  }
+  return divs[0] * divs[1] * divs[2];
+}
+
+/**
+ * Calculate the squared distance from point x to the specified bounds.
+ * @param {Vector3} x  The point coordinates
+ * @param {Bounds} bounds  The bounding box coordinates
+ * @returns {Number} The squared distance to the bounds
+ */
+function distance2ToBounds(x, bounds) {
+  // Are we within the bounds?
+  if (x[0] >= bounds[0] && x[0] <= bounds[1] && x[1] >= bounds[2] && x[1] <= bounds[3] && x[2] >= bounds[4] && x[2] <= bounds[5]) {
+    return 0.0;
+  }
+  const deltas = [0.0, 0.0, 0.0];
+
+  // dx
+  if (x[0] < bounds[0]) {
+    deltas[0] = bounds[0] - x[0];
+  } else if (x[0] > bounds[1]) {
+    deltas[0] = x[0] - bounds[1];
+  }
+
+  // dy
+  if (x[1] < bounds[2]) {
+    deltas[1] = bounds[2] - x[1];
+  } else if (x[1] > bounds[3]) {
+    deltas[1] = x[1] - bounds[3];
+  }
+
+  // dz
+  if (x[2] < bounds[4]) {
+    deltas[2] = bounds[4] - x[2];
+  } else if (x[2] > bounds[5]) {
+    deltas[2] = x[2] - bounds[5];
+  }
+  return dot(deltas, deltas);
+}
+
 // ----------------------------------------------------------------------------
 // Light Weight class
 // ----------------------------------------------------------------------------
@@ -578,6 +752,9 @@ class BoundingBox {
   getDiagonalLength() {
     return getDiagonalLength(this.bounds);
   }
+  getDiagonalLength2() {
+    return getDiagonalLength2(this.bounds);
+  }
   getMinPoint() {
     return getMinPoint(this.bounds);
   }
@@ -630,6 +807,13 @@ class BoundingBox {
   contains(otherBounds) {
     return intersects(this.bounds, otherBounds);
   }
+  computeDivisions(totalBins, divs) {
+    let adjustedBounds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    return computeDivisions(this.bounds, totalBins, divs, adjustedBounds);
+  }
+  distance2ToBounds(x) {
+    return distance2ToBounds(x, this.bounds);
+  }
 }
 function newInstance(initialValues) {
   const bounds = initialValues && initialValues.bounds;
@@ -675,6 +859,9 @@ const STATIC = {
   intersects,
   containsPoint,
   contains,
+  computeDivisions,
+  clampDivisions,
+  distance2ToBounds,
   INIT_BOUNDS
 };
 var vtkBoundingBox = {
@@ -682,4 +869,4 @@ var vtkBoundingBox = {
   ...STATIC
 };
 
-export { STATIC, addBounds, addPoint, addPoints, computeCornerPoints, computeLocalBounds, computeScale3, contains, containsPoint, cutWithPlane, vtkBoundingBox as default, equals, getCenter, getCorners, getDiagonalLength, getLength, getLengths, getMaxLength, getMaxPoint, getMinPoint, getXRange, getYRange, getZRange, inflate, 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();
+  };
 }
 
 // ----------------------------------------------------------------------------