@kitware/vtk.js 26.3.1 → 26.4.0

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;

package/Interaction/Manipulators/CompositeMouseManipulator.d.ts

@@ -0,0 +1,149 @@
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+
+export interface vtkCompositeMouseManipulator {
+  /**
+   * Starts an interaction event.
+   */
+  startInteraction(): void;
+
+  /**
+   * Ends an interaction event.
+   */
+  endInteraction(): void;
+
+  /**
+   * Handles a button down event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param position the display position
+   */
+  onButtonDown(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    position: { x: number; y: number }
+  ): void;
+
+  /**
+   * Handles a button up event.
+   * @param interactor the interactor
+   */
+  onButtonUp(interactor: vtkRenderWindowInteractor): void;
+
+  /**
+   * Handles a mouse move event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param position the display position
+   */
+  onMouseMove(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    position: { x: number; y: number }
+  ): void;
+
+  /**
+   * Handles a start scroll event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param delta the scroll delta
+   */
+  onStartScroll(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    delta: number
+  ): void;
+
+  /**
+   * Handles a scroll event.
+   * @param interactor the interactor
+   */
+  onEndScroll(interactor: vtkRenderWindowInteractor): void;
+
+  /**
+   * Is drag enabled.
+   */
+  isDragEnabled(): boolean;
+
+  /**
+   * Sets if drag is enabled.
+   * @param enabled
+   */
+  setDragEnabled(enabled: boolean): boolean;
+
+  /**
+   * Is scroll enabled.
+   */
+  isScrollEnabled(): boolean;
+
+  /**
+   * Sets if scroll is enabled.
+   * @param enabled
+   */
+  setScrollEnabled(enabled: boolean): boolean;
+
+  /**
+   * Sets the associated button.
+   * @param btn
+   */
+  setButton(btn: number): boolean;
+
+  /**
+   * Gets the associated button.
+   */
+  getButton(): number;
+
+  /**
+   * Sets if the shift key is required.
+   * @param shift
+   */
+  setShift(shift: boolean): boolean;
+
+  /**
+   * Gets flag if shift key is required.
+   */
+  getShift(): boolean;
+
+  /**
+   * Sets if the control key is required.
+   * @param ctrl
+   */
+  setControl(ctrl: boolean): boolean;
+
+  /**
+   * Gets flag if control key is required.
+   */
+  getControl(): boolean;
+
+  /**
+   * Sets if the alt key is required.
+   * @param alt
+   */
+  setAlt(alt: boolean): boolean;
+
+  /**
+   * Gets flag if alt key is required.
+   */
+  getAlt(): boolean;
+}
+
+export interface ICompositeMouseManipulatorInitialValues {
+  button?: number;
+  shift?: boolean;
+  control?: boolean;
+  alt?: boolean;
+  dragEnabled?: boolean;
+  scrollEnabled?: boolean;
+}
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICompositeMouseManipulatorInitialValues
+): void;
+
+export const vtkCompositeMouseManipulator: {
+  extend: typeof extend;
+};
+
+export default vtkCompositeMouseManipulator;

package/Interaction/Manipulators/CompositeVRManipulator.d.ts

@@ -0,0 +1,44 @@
+import { States } from './../../Rendering/Core/InteractorStyle/Constants';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import {
+  Device,
+  Input,
+} from './../../Rendering/Core/RenderWindowInteractor/Constants';
+
+export interface vtkCompositeVRManipulator {
+  onButton3D(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    state: States,
+    device: Device,
+    input: Input,
+    pressed: boolean
+  ): void;
+
+  onMove3D(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    state: States,
+    device: Device,
+    input: Input,
+    pressed: boolean
+  ): void;
+}
+
+export interface ICompositeVRManipulatorInitialValues {
+  device?: Device;
+  input?: Input;
+}
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICompositeVRManipulatorInitialValues
+): void;
+
+export const vtkCompositeVRManipulator: {
+  extend: typeof extend;
+};
+
+export default vtkCompositeVRManipulator;