@kitware/vtk.js 26.3.2 → 26.4.1

package/Common/Core/CellArray.d.ts

@@ -9,6 +9,10 @@ export interface ICellArrayInitialValues extends IDataArrayInitialValues {
 	empty?: boolean;
 }
 
+/**
+ * You are NOT allowed to modify the cell array via `getData()`.
+ * Only via `setData` or `insertNextCell`
+ */
 export interface vtkCellArray extends vtkDataArray {
 
 	/**

package/Common/Core/CellArray.js

@@ -71,6 +71,10 @@ function vtkCellArray(publicAPI, model) {
     model.cellSizes = extractCellSizes(publicAPI.getData());
     return model.cellSizes;
   };
+  /**
+   * When `resize()` is being used, you then MUST use `insertNextCell()`.
+   */
+
 
   publicAPI.resize = function (requestedNumTuples) {
     var oldNumTuples = publicAPI.getNumberOfTuples();

package/Common/Core/LookupTable.js

@@ -61,7 +61,7 @@ function vtkLookupTable(publicAPI, model) {
 
 
   publicAPI.getNumberOfAvailableColors = function () {
-    return model.table.length;
+    return model.table.length / 4;
   }; //----------------------------------------------------------------------------
   // Apply shift/scale to the scalar value v and return the index.
 
@@ -94,7 +94,7 @@ function vtkLookupTable(publicAPI, model) {
     }
 
     var offset = 4 * index;
-    return [table[offset], table[offset + 1], table[offset + 2], table[offset + 3]];
+    return table.slice(offset, offset + 4);
   };
 
   publicAPI.indexedLookupFunction = function (v, table, p) {
@@ -180,6 +180,7 @@ function vtkLookupTable(publicAPI, model) {
       ainc = (model.alphaRange[1] - model.alphaRange[0]) / maxIndex;
     }
 
+    model.table.length = 4 * maxIndex + 16;
     var hsv = [];
     var rgba = [];
 
@@ -213,6 +214,7 @@ function vtkLookupTable(publicAPI, model) {
 
     model.numberOfColors = table.getNumberOfTuples();
     var data = table.getData();
+    model.table.length = data.length;
 
     for (var i = 0; i < data.length; i++) {
       model.table[i] = data[i];

package/Common/DataModel/Collection.d.ts

@@ -0,0 +1,118 @@
+import { vtkObject } from './../../interfaces';
+import { Nullable } from './../../types';
+
+/**
+ *
+ */
+export interface ICollectionInitialValues {
+	collection?: vtkObject[];
+}
+
+
+export interface vtkCollection extends vtkObject {
+
+	/**
+	 * Add item (vtkObject) to the collection
+	 * @param {vtkObject} item item to be added to the collection
+	 */
+  	addItem(item: vtkObject): void;
+
+	/**
+	 * Add item (vtkObject) to the collection _at_ the given index.
+	 * This differs from VTK-C++ where insertItem inserts at position
+	 * after the provided index value.
+	 * @param {number} idx index where the new item should be inserted.
+	 * @param {vtkObject} item item to be inserted
+	 */
+	insertItem(idx: number, item: vtkObject): void;
+
+	/**
+	 * Replace an existing item (vtkObject) with a new one
+	 * @param {number} idx index of item to be replaced
+	 * @param {vtkObject} item
+	 */
+	replaceItem(idx: number, item: vtkObject): void;
+
+	/**
+	 * Remove an existing item from the collection
+	 * @param {number|vtkObject} inValue index or reference of an item to be removed
+	 */
+	removeItem(inValue: number|vtkObject): void;
+
+	/**
+	 * Remove all items from the collection
+	 */
+	removeAllItems(): void;
+
+	/**
+	 * Check if a provided item is already present in the collection
+	 */
+	isItemPresent(item: vtkObject): boolean;
+
+	/**
+	 * Get the total number of items in the collection
+	 */
+	getNumberOfItems(): number;
+
+	/**
+	 * Check if the collection is empty
+	 */
+	empty(): boolean;
+
+	/**
+	 * get the current item and provided index, returns null if index is out of bounds
+	 */
+	getItem(idx: number): Nullable<vtkObject>;
+
+	/**
+	 * Execute a passed function on every item in the collection
+	 * @param callbackfn callback function to be executed on every item in the collection
+	 */
+	forEach<T>(callbackfn: (value: T, index: number, array: readonly T[]) => void): void;
+
+	/**
+	 * Execute a passed function on every item in the collection, in order to calculate an aggregated return value.
+	 * @param callbackfn callback function to be used for aggregating a single value from each item in the collection
+	 * @param initialValue starting value to calculate aggregation
+	 */
+	reduce<T>(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+
+	/**
+	 * Similar to forEach, but returns an array of resulting values.
+	 * @param callbackfn callback function to execute on each item in the collection, that returns a value.
+	 */
+	map<T>(callbackfn: (value: T, index: number, array: readonly T[]) => void): void;
+
+	/**
+	 * Check each element for modified time and update the collection's
+	 * MTime to the latest timestamp from individual items in the collection.
+	 */
+	updateMTimeWithElements(): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkCollection characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ICollectionInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : ICollectionInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkCollection.
+ * @param {ICollectionInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues? : ICollectionInitialValues): vtkCollection;
+
+/**
+ * vtkCollection is a container of multiple vtkObject items.
+ * This can be useful for encapsulating multiple vtkObjects such as images
+ * into a single vtkObject (vtkCollection instance) to be passed as input
+ * to other filters and mappers as a single unit.
+ */
+export declare const vtkCollection: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+};
+export default vtkCollection;

package/Common/DataModel/Collection.js

@@ -0,0 +1,113 @@
+import macro from '../../macros.js';
+
+var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+// vtkCollection methods
+// ----------------------------------------------------------------------------
+
+function vtkCollection(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkCollection');
+
+  publicAPI.addItem = function (item) {
+    model.collection.push(item);
+    publicAPI.modified();
+  };
+
+  publicAPI.insertItem = function (idx, item) {
+    if (idx < 0 || model.collection.length < idx) {
+      vtkErrorMacro('idx out of bounds for insertion.');
+    }
+
+    model.collection.splice(idx, 0, item);
+    publicAPI.modified();
+  };
+
+  publicAPI.replaceItem = function (idx, item) {
+    model.collection.splice(idx, 1, item);
+    publicAPI.modified();
+  };
+
+  publicAPI.removeItem = function (inValue) {
+    var idx = typeof inValue === 'number' ? inValue : model.collection.indexOf(inValue);
+
+    if (idx >= 0 && idx < model.collection.length) {
+      model.collection.splice(idx, 1);
+      publicAPI.modified();
+    } else {
+      vtkErrorMacro('idx out of bounds for removeItem.');
+    }
+  };
+
+  publicAPI.removeAllItems = function () {
+    model.collection = [];
+    publicAPI.modified();
+  };
+
+  publicAPI.isItemPresent = function (item) {
+    return model.collection.includes(item);
+  };
+
+  publicAPI.getNumberOfItems = function () {
+    return model.collection.length;
+  };
+
+  publicAPI.empty = function () {
+    return model.collection.length === 0;
+  };
+
+  publicAPI.getItem = function (idx) {
+    return model.collection[idx];
+  };
+
+  publicAPI.forEach = function (ftor) {
+    model.collection.forEach(ftor); // Call modified() for the collection, since ftor could have modified the elements.
+
+    publicAPI.updateMTimeWithElements();
+  };
+
+  publicAPI.reduce = function (ftor, initialValue) {
+    return model.collection.reduce(ftor, initialValue);
+  };
+
+  publicAPI.map = function (ftor) {
+    return model.collection.map(ftor);
+  };
+
+  publicAPI.updateMTimeWithElements = function () {
+    var maxMTimeOfItems = 0; // we expect time values to be positive numbers
+
+    for (var i = 0; i < model.collection.length; ++i) {
+      var elem = model.collection[i];
+      maxMTimeOfItems = Math.max(maxMTimeOfItems, elem.getMTime());
+    }
+
+    if (maxMTimeOfItems > publicAPI.getMTime()) {
+      publicAPI.modified();
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  collection: []
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+
+  macro.obj(publicAPI, model); // Object specific methods
+
+  vtkCollection(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkCollection'); // ----------------------------------------------------------------------------
+
+var index = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { index as default, extend, newInstance };

package/Interaction/Manipulators/CompositeCameraManipulator.d.ts

@@ -0,0 +1,68 @@
+import vtkInteractorObserver from './../../Rendering/Core/InteractorObserver';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import { Vector2, Vector3 } from './../../types';
+
+export interface vtkCompositeCameraManipulator {
+  /**
+   * Computes the display center.
+   * @param observer
+   * @param renderer
+   */
+  computeDisplayCenter(
+    observer: vtkInteractorObserver,
+    renderer: vtkRenderer
+  ): void;
+
+  /**
+   * Sets the rotation factor.
+   * @param factor
+   */
+  setRotationFactor(factor: number): boolean;
+
+  /**
+   * Gets the rotation factor.
+   */
+  getRotationFactor(): number;
+
+  /**
+   * Sets the display center.
+   * @param center
+   */
+  setDisplayCenter(center: Vector2): boolean;
+  setDisplayCenter(x: number, y: number): boolean;
+
+  /**
+   * Gets the display center.
+   */
+  getDisplayCenter(): Vector2;
+
+  /**
+   * Sets the center.
+   * @param center
+   */
+  setCenter(center: Vector3): boolean;
+  setCenter(x: number, y: number, z: number): boolean;
+
+  /**
+   * Gets the center.
+   */
+  getCenter(): Vector3;
+}
+
+export interface ICompositeCameraManipulatorInitialValues {
+  center?: Vector3;
+  rotationFactor?: number;
+  displayCenter?: Vector2;
+}
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICompositeCameraManipulatorInitialValues
+): void;
+
+export const vtkCompositeCameraManipulator: {
+  extend: typeof extend;
+};
+
+export default vtkCompositeCameraManipulator;

package/Interaction/Manipulators/CompositeGestureManipulator.d.ts

@@ -0,0 +1,168 @@
+import vtkInteractorStyle from './../../Rendering/Core/InteractorStyle';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import { Nullable } from './../../types';
+
+export interface vtkCompositeGestureManipulator {
+  /**
+   * Starts an interaction event.
+   */
+  startInteraction(): void;
+
+  /**
+   * Ends an interaction event.
+   */
+  endInteraction(): void;
+
+  /**
+   * Handles a start pinch gesture.
+   * @param interactor
+   * @param scale
+   */
+  onStartPinch(interactor: vtkRenderWindowInteractor, scale: number): void;
+
+  /**
+   * Handles a pinch gesture.
+   * @param interactor
+   * @param renderer
+   * @param scale
+   */
+  onPinch(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    scale: number
+  ): void;
+
+  /**
+   * Handles an end pinch gesture.
+   * @param interactor
+   */
+  onEndPinch(interactor: vtkRenderWindowInteractor): void;
+
+  /**
+   * Handles a start rotate gesture.
+   * @param interactor
+   * @param rotation
+   */
+  onStartRotate(interactor: vtkRenderWindowInteractor, rotation: number): void;
+
+  /**
+   * Handles a rotate gesture.
+   * @param interactor
+   * @param renderer
+   * @param rotation
+   */
+  onRotate(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    rotation: number
+  ): void;
+
+  /**
+   * Handles an end pinch gesture.
+   * @param interactor
+   */
+  onEndRotate(interactor: vtkRenderWindowInteractor): void;
+
+  /**
+   * Handles a start pan gesture.
+   * @param interactor
+   * @param translation
+   */
+  onStartPan(interactor: vtkRenderWindowInteractor, translation: number): void;
+
+  /**
+   * Handles a pan gesture.
+   * @param interactor
+   * @param renderer
+   * @param translation
+   */
+  onPan(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    translation: number
+  ): void;
+
+  /**
+   * Handles an end pan gesture.
+   * @param interactor
+   */
+  onEndPan(interactor: vtkRenderWindowInteractor): void;
+
+  /**
+   * Is pinch enabled.
+   */
+  isPinchEnabled(): boolean;
+
+  /**
+   * Sets if pinch is enabled.
+   * @param pinch
+   */
+  setPinchEnabled(pinch: boolean): boolean;
+
+  /**
+   * Gets flag if pinch is enabled.
+   */
+  getPinchEnabled(): boolean;
+
+  /**
+   * Is pan enabled.
+   */
+  isPanEnabled(): boolean;
+
+  /**
+   * Sets if pan is enabled.
+   * @param pan
+   */
+  setPanEnabled(pan: boolean): boolean;
+
+  /**
+   * Gets flag if pan is enabled.
+   */
+  getPanEnabled(): boolean;
+
+  /**
+   * Is rotate enabled.
+   */
+  isRotateEnabled(): boolean;
+
+  /**
+   * Sets if rotate is enabled.
+   * @param rotate
+   */
+  setRotateEnabled(rotate: boolean): boolean;
+
+  /**
+   * Gets flag if rotate is enabled.
+   */
+  getRotateEnabled(): boolean;
+
+  /**
+   * Sets the interactor style.
+   * @param style vtkInteractorStyle
+   */
+  setInteractorStyle(style: Nullable<vtkInteractorStyle>): boolean;
+
+  /**
+   * Gets the interactor style.
+   */
+  getInteractorStyle(): Nullable<vtkInteractorStyle>;
+}
+
+export interface ICompositeGestureManipulatorInitialValues {
+  pinchEnabled?: boolean;
+  panEnabled?: boolean;
+  rotateEnabled?: boolean;
+}
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICompositeGestureManipulatorInitialValues
+): void;
+
+export const vtkCompositeGestureManipulator: {
+  extend: typeof extend;
+};
+
+export default vtkCompositeGestureManipulator;

package/Interaction/Manipulators/CompositeKeyboardManipulator.d.ts

@@ -0,0 +1,48 @@
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+
+export interface vtkCompositeKeyboardManipulator {
+  /**
+   * Handles a keypress event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyPress(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+
+  /**
+   * Handles a keydown event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyDown(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+
+  /**
+   * Handles a keyup event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyUp(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+}
+
+export function extend(publicAPI: object, model: object): void;
+
+export const vtkCompositeKeyboardManipulator: {
+  extend: typeof extend;
+};
+
+export default vtkCompositeKeyboardManipulator;