@kitware/vtk.js 24.18.6 → 24.18.9

package/Common/DataModel/DataSet/Constants.d.ts

@@ -0,0 +1,27 @@
+export declare enum FieldAssociations {
+	FIELD_ASSOCIATION_POINTS = 0,
+	FIELD_ASSOCIATION_CELLS = 1,
+	FIELD_ASSOCIATION_NONE = 2,
+	FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3,
+	FIELD_ASSOCIATION_VERTICES = 4,
+	FIELD_ASSOCIATION_EDGES = 5,
+	FIELD_ASSOCIATION_ROWS = 6,
+	NUMBER_OF_ASSOCIATIONS = 7,
+}
+
+export declare enum FieldDataTypes {
+  UNIFORM = 0,
+  DATA_OBJECT_FIELD = 0,
+  COORDINATE = 1,
+  POINT_DATA = 1,
+  POINT = 2,
+  POINT_FIELD_DATA = 2, 
+  CELL = 3,
+  CELL_FIELD_DATA = 3,
+  VERTEX = 4,
+  VERTEX_FIELD_DATA = 4,
+  EDGE = 5,
+  EDGE_FIELD_DATA = 5,
+  ROW = 6,
+  ROW_DATA = 6,
+}

package/Common/DataModel/DataSet.d.ts

@@ -1,33 +1,6 @@
-import { vtkObject } from './../../interfaces' ;
 import vtkDataSetAttributes from './DataSetAttributes';
-
-export enum FieldDataTypes {
-	UNIFORM,
-	DATA_OBJECT_FIELD,
-	COORDINATE,
-	POINT_DATA,
-	POINT,
-	POINT_FIELD_DATA,
-	CELL,
-	CELL_FIELD_DATA,
-	VERTEX,
-	VERTEX_FIELD_DATA,
-	EDGE,
-	EDGE_FIELD_DATA,
-	ROW,
-	ROW_DATA,
-}
-
-export enum FieldAssociations {
-	FIELD_ASSOCIATION_POINTS,
-	FIELD_ASSOCIATION_CELLS,
-	FIELD_ASSOCIATION_NONE,
-	FIELD_ASSOCIATION_POINTS_THEN_CELLS,
-	FIELD_ASSOCIATION_VERTICES,
-	FIELD_ASSOCIATION_EDGES,
-	FIELD_ASSOCIATION_ROWS,
-	NUMBER_OF_ASSOCIATIONS,
-}
+import { vtkObject } from './../../interfaces' ;
+import { FieldAssociations, FieldDataTypes } from './DataSet/Constants';
 
 /**
  *
@@ -102,7 +75,9 @@ export function newInstance(initialValues? : IDataSetInitialValues): vtkDataSet;
  * operate on cell data, both cell and point data, either one, or none.
  */
 export declare const vtkDataSet: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	FieldAssociation: typeof FieldAssociations;
+	FieldDataTypes: typeof FieldDataTypes;
 };
 export default vtkDataSet;

package/Interaction/Widgets/OrientationMarkerWidget.d.ts

@@ -165,7 +165,6 @@ export function extend(publicAPI: object, model: object, initialValues?: IOrient
  */
 export function newInstance(initialValues?: IOrientationMarkerWidgetInitialValues): vtkOrientationMarkerWidget;
 
-
 /**
  * vtkOrientationMarkerWidget is a 2D widget for manipulating a marker prop
  */
@@ -174,4 +173,5 @@ export declare const vtkOrientationMarkerWidget: {
 	extend: typeof extend;
 	Corners: typeof Corners;
 }
+
 export default vtkOrientationMarkerWidget;

package/Rendering/Core/CellPicker.js

@@ -254,14 +254,19 @@ function vtkCellPicker(publicAPI, model) {
       var tempCellMap = createCellMap();
       var minCellMap = createCellMap();
       var numberOfCells = data.getNumberOfCells();
+      /* eslint-disable no-continue */
 
       for (var cellId = 0; cellId < numberOfCells; cellId++) {
         var pCoords = [0, 0, 0];
-        minCellType = data.getCellType(cellId);
+        minCellType = data.getCellType(cellId); // Skip cells that are marked as empty
+
+        if (minCellType === CellType.VTK_EMPTY_CELL) {
+          continue;
+        }
+
         var cell = tempCellMap[minCellType];
 
         if (cell == null) {
-          // eslint-disable-next-line no-continue
           continue;
         }
 
@@ -294,6 +299,8 @@ function vtkCellPicker(publicAPI, model) {
           }
         }
       }
+      /* eslint-enable no-continue */
+
     }
 
     if (minCellId >= 0 && tMin < model.globalTMin) {

package/Rendering/Core/InteractorObserver.d.ts

@@ -0,0 +1,132 @@
+import vtkRenderer from './Renderer';
+import vtkRenderWindowInteractor from './RenderWindowInteractor';
+import { vtkObject, EventHandler, vtkSubscription } from './../../interfaces';
+import { Vector3 } from './../../types';
+
+export interface vtkInteractorObserver extends vtkObject {
+  /**
+   * Invoke an interaction event.
+   * 
+   * @param args Event payload.
+   */
+  invokeInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when an interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called.
+   * @param {Number} [priority] The priority of the event.
+   */
+  onInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke a start interaction event.
+   * 
+   * @param args Event payload. 
+   */
+  invokeStartInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when a start interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called. 
+   * @param {Number} [priority] The callback to be called
+   */
+  onStartInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke an end interaction event.
+   * 
+   * @param args Event payload. 
+   */
+  invokeEndInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when an end interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called. 
+   * @param {Number?} [priority] The callback to be called
+   */
+  onEndInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /** 
+   * Retrieve the render window interactor instance. 
+   */
+  getInteractor(): vtkRenderWindowInteractor;
+
+  /** 
+   * Get wether or not this InteractorObserver instance is enabled. 
+   */
+  getEnabled(): boolean;
+  
+  /**
+   * Enable/disable the interactor observer. Note that if you are enabling the interactor observer, an interactor instance must exists on the model.
+   * Typically you can call `setInteractor`
+   * 
+   * @param {Boolean} enable 
+   */
+  setEnabled(enable: boolean): void;
+
+  /**
+   * Set the priority.
+   * 
+   * @param {Number} priority The priority level.
+   */
+  setPriority(priority: number): void;
+
+  /**
+   * Get the priority.
+   */
+  getPriority(): number;
+
+  /**
+   * Set whether or not the interactor observer instance should process events.
+   * 
+   * @param {Boolean} processEvents 
+   */
+  setProcessEvents(processEvents: boolean): boolean;
+
+  /**
+   * Get whether or not the interactor observer instance should process events.
+   */
+  getProcessEvents(): boolean;
+
+  /**
+   * Set the interactor instance.
+   * 
+   * @param {vtkRenderWindowInteractor} interactor 
+   */
+  setInteractor(interactor: vtkRenderWindowInteractor): void;
+
+  /**
+   * Transform from world to display coordinates.
+   * 
+   * @param {vtkRenderer} renderer 
+   * @param {Number} x 
+   * @param {Number} y 
+   * @param {Number} z 
+   */
+  computeWorldToDisplay(
+    renderer: vtkRenderer,
+    x: number,
+    y: number,
+    z: number
+  ): Vector3;
+
+  /**
+   * Transform from display to world coordinates.
+   *
+   * @param {vtkRenderer} renderer 
+   * @param {Number} x 
+   * @param {Number} y 
+   * @param {Number} z 
+   */
+  computeDisplayToWorld(
+    renderer: vtkRenderer,
+    x: number,
+    y: number,
+    z: number
+  ): Vector3;
+}
+
+export default vtkInteractorObserver;

package/Rendering/Misc/SynchronizableRenderWindow/ObjectManager.d.ts

@@ -0,0 +1,80 @@
+import { vtkObject } from './../../../interfaces' ;
+import { Nullable } from './../../../types' ;
+import { ISynchronizerContext, IViewState } from "..";
+
+export type BuilderFunction = <T extends vtkObject>(type: string, initialProps?: Record<string, unknown>) => Nullable<T>;
+export type UpdaterFunction = (instance: vtkObject, state: IViewState, context: ISynchronizerContext) => void;
+
+export interface IObjectManager {
+  /**
+   * Build a vtkObject.
+   */
+  build: BuilderFunction;
+
+  /**
+   * @param {String} type The type to update 
+   * @param {vtkObject} instance The specific instance 
+   * @param {IViewState} props 
+   * @param {ISynchronizerContext} context 
+   */
+  update(type: string, instance: vtkObject, props: IViewState, context: ISynchronizerContext): Promise<Error | void>;
+
+  /**
+   * Defines a new type handler with the specified builder and updater functions
+   * 
+   * @param {String} type The type you wish to register
+   * @param {BuilderFunction} [buildFn] The builder function to associate with the type 
+   * @param {UpdaterFunction} [updateFn] The updater function to associate with the type 
+   */
+  setTypeMapping(type: string, buildFn?: BuilderFunction, updateFn?: UpdaterFunction): void;
+  
+  /**
+   * Clear all type mappings
+   */
+  clearTypeMapping(): void;
+ 
+  /**
+   * Get a list of all supported types
+   * 
+   * @returns {string[]}
+   */
+  getSupportedTypes(): string[];
+ 
+  /**
+   * Clear all one time updaters
+   */
+  clearOneTimeUpdaters(): void;
+ 
+  /**
+   * Update the associated render window
+   */
+  updateRenderWindow(): void;
+ 
+  /**
+   * Register a new type to exclude
+   * 
+   * @param {string} type The type to exclude 
+   * @param {string} propertyName The property name to exclude
+   * @param {unknown} propertyValue The property value to exclude 
+   */
+  excludeInstance(type: string, propertyName: string, propertyValue: unknown): void;
+ 
+  /**
+   * Set the default types mapping
+   * 
+   * @param {boolean} [reset] Clear all existing type mappings, defaults to true 
+   */
+  setDefaultMapping(reset?: boolean): void;
+ 
+  /**
+   * Apply the default aliases
+   */
+  applyDefaultAliases(): void;
+ 
+  /**
+   * Always update the camera
+   */
+  alwaysUpdateCamera(): void;
+}
+
+export default IObjectManager;

package/Rendering/Misc/SynchronizableRenderWindow.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { newInstance as newInstance$1, event, get, chain, newTypedArray, traverseInstanceTree } from '../../macros.js';
 import Base64 from '../../Common/Core/Base64.js';
 import vtkRenderWindow from '../Core/RenderWindow.js';
-import vtkObjectManager from './SynchronizableRenderWindow/vtkObjectManager.js';
+import vtkObjectManager from './SynchronizableRenderWindow/ObjectManager.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 

package/Rendering/OpenGL/ImageMapper.js

@@ -202,6 +202,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);', 'float intensity = tcolor.r*cscale0 + cshift0;', 'gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tcolor.g + pwfshift0);']).result;
           break;
 
+        case 3:
+          FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;', 'gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,', '  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,', '  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);']).result;
+          break;
+
         default:
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;', 'gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,', '  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,', '  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);']).result;
       }

package/Widgets/Core/AbstractWidget.d.ts

@@ -0,0 +1,187 @@
+import vtkInteractorObserver from './../../Rendering/Core/InteractorObserver';
+import vtkProp from './../../Rendering/Core/Prop';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkWidgetManager from './WidgetManager';
+import vtkWidgetRepresentation from './../Representations/WidgetRepresentation';
+import vtkWidgetState from './WidgetState';
+import { Bounds } from './../../types';
+import { RenderingTypes } from './WidgetManager/Constants';
+import { EventHandler, vtkSubscription } from './../../interfaces';
+
+export interface vtkAbstractWidget extends vtkProp, vtkInteractorObserver {
+  /**
+   * Get the bounds of the widget
+   */
+  getBounds(): Bounds;
+
+  /**
+   * Get all representations of the widget.
+   */
+  getNestedProps(): vtkWidgetRepresentation[];
+
+  /**
+   * Activate a handle, identified by both a state and a representation.
+   * Will also invoke appropriate events.
+   * 
+   * @param locator An object describing the handle to activate.
+   */
+  activateHandle(locator: { 
+    selectedState: vtkWidgetState; 
+    representation: vtkWidgetRepresentation; 
+  }): void;
+
+  /**
+   * Deactivate all the handles on the widget instance.
+   */
+  deactivateAllHandles(): void;
+
+  /**
+   * Returns true if the widget instance holds the given actor, false otherwise.
+   * 
+   * @param {vtkProp} actor
+   */
+  hasActor(actor: vtkProp): boolean;
+
+  /**
+   * Make the widget instance grab the focus.
+   * Should not be called directly or this will lead to unexpected behavior.
+   * To grab the focus on a widget, one should call `vtkWidgetManager.grabFocus(widgetInstanceToGiveFocusTo)`
+   */
+  grabFocus(): void;
+
+  /**
+   * Make the widget instance release the focus.
+   */
+  loseFocus(): void;
+
+  /**
+   * Returns true if the widget instance holds the focus, false otherwise.
+   */
+  hasFocus(): boolean;
+
+  /**
+   * Place a widget at the given bounds.
+   * 
+   * @param {Bounds} bounds
+   */
+  placeWidget(bounds: Bounds): void;
+
+  /**
+   * Get the place factor.
+   */
+  getPlaceFactor(): number;
+
+  /**
+   * Set the place factor.
+   * 
+   * @param {Number} factor The place factor.
+   */
+  setPlaceFactor(factor: number): void;
+
+  /**
+   * Get the `vtkWidgetRepresentation` instance associated with the given `vtkActor` instance.
+   * 
+   * @param {vtkProp} actor 
+   */
+  getRepresentationFromActor(actor: vtkProp): vtkWidgetRepresentation;
+
+  /**
+   * Update all the widget representations for render.
+   * 
+   * @param {RenderingTypes} renderingType Default value if `RenderingTypes.FRONT_BUFFER` 
+   */
+  updateRepresentationForRender(renderingType: RenderingTypes): void;
+
+  /**
+   * Get all the underlyings view widgets.
+   */
+  getViewWidgets(): vtkAbstractWidget[];
+
+
+  /**
+   * Set the context visibility.
+   * 
+   * @param {Boolean} visible 
+   */
+  setContextVisibility(visible: boolean): void;
+
+  /**
+   * Get the context visibility.
+   */
+  getContextVisibility(): boolean;
+
+  /**
+   * Defines if the handles should be visible or not.
+   * 
+   * @param {Boolean} visible 
+   */
+  setHandleVisibility(visible: boolean): void;
+
+  /**
+   * Returns true if the handles are visible, false otherwise.
+   */
+  getHandleVisibility(): boolean;
+
+  /**
+   * Set the widget manager associated with the widget instance.
+   * 
+   * @param {vtkWidgetManager} wm The widget manager instance
+   */
+  setWidgetManager(wm: vtkWidgetManager): void;
+
+  /**
+   * Get the widget manager associated with the widget instance.
+   */
+  getWidgetManager(): vtkWidgetManager;
+
+  /**
+   * Get all the representations of the widget instance.
+   */
+  getRepresentations(): vtkWidgetRepresentation[];
+
+  /**
+   * Get the the state of the widget instance.
+   */
+  getWidgetState(): vtkWidgetState;
+
+  /**
+   * Register a callback to be invoked when the `ActivateHandle` event occurs.
+   * 
+   * @param {EventHandler} cb The callback to register
+   * @param {Number} [priority] Priority of this subscription
+   */
+  onActivateHandle(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke the `ActivateHandle` event with the given payload.
+   * 
+   * @param args The event payload
+   */
+  invokeActivateHandle(...args: unknown[]): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkAbstractWidget characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param initialValues (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : object): void;
+
+/**
+ * Method used to create a new instance of vtkAbstractWidget
+ * 
+ * @param initialValues For pre-setting some of its content
+ */
+export function newInstance(initialValues?: object): vtkAbstractWidget;
+
+/**
+ * vtkAbstractWidget is an abstract class to construct a widget.
+ */
+export declare const vtkAbstractWidget: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+
+export default vtkAbstractWidget;

package/Widgets/Core/AbstractWidgetFactory.d.ts

@@ -0,0 +1,126 @@
+import vtkAbstractWidget from './AbstractWidget';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkWidgetState from './WidgetState';
+import { ViewTypes } from './WidgetManager/Constants';
+import { Bounds, Nullable } from './../../types';
+import { EventHandler, vtkSubscription } from './../../interfaces';
+
+export interface IGetWidgetForViewParams {
+  viewId: number;
+  renderer?: vtkRenderer;
+  viewType?: ViewTypes;
+  initialValues?: object;
+}
+
+export interface vtkAbstractWidgetFactory {
+  /**
+   * Will return the widget associated with the view with Id id `locator.viewId`. 
+   * If there is no widget associated with the view, a new widget will be constructed, provided
+   * that the renderer, viewType, and optionally initialValues are also provided.
+   * 
+   * @param {IGetWidgetForViewParams} locator
+   */
+  getWidgetForView(locator: IGetWidgetForViewParams): Nullable<vtkAbstractWidget>;
+
+  /**
+   * Get a list of all the view ids.
+   */
+  getViewIds(): string[];
+
+  /**
+   * Set the visiblity on each underlying view widget.
+   * 
+   * @param {Boolean} visible
+   */
+  setVisibility(visible: boolean): void 
+
+  /**
+   * Set the pickable flag for each underlying view widget.
+   * 
+   * @param {Boolean} pickable 
+   */
+  setPickable(pickable: boolean): void
+
+  /**
+   * Set the dragable flag for each underlying view widget.
+   * 
+   * @param {Boolean} dragable 
+   */
+  setDragable(dragable: boolean): void
+
+  /**
+   * Set the context visibility for each associated view widget.
+   * 
+   * @param {Boolean} visible 
+   */
+  setContextVisibility(visible: boolean): void
+
+  /**
+   * Set the handles visibility for each underlying view widget.
+   * 
+   * @param {Boolean} visible 
+   */
+  setHandleVisiblity(visible: boolean): void
+
+  /**
+   * Place a new widget at the given bounds.
+   * 
+   * @param {Bounds} bounds 
+   */
+  placeWidget(bounds: Bounds);
+
+  /**
+   * Get the place factor.
+   */
+  getPlaceFactor(): number;
+
+  /**
+   * Set the place factor.
+   * 
+   * @param {Number} factor 
+   */
+  setPlaceFactor(factor: number): void;
+
+  /**
+   * Get the `vtkWidgetState` instance
+   */
+  getWidgetState(): vtkWidgetState;
+
+  /**
+   * Register a callback to be called when the WidgetChange event arise.
+   * 
+   * @param {EventHandler} cb The callback to be invoked.
+   * @param {Number} [priority] The priority of this subscription
+   */
+  onWidgetChangeEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke the WidgetChange event
+   * 
+   * @param args The event payload
+   */
+  invokeWidgetChangeEvent(...args: unknown[]): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkAbstractWidgetFactory characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param initialValues (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : object): void;
+
+/**
+ * Method used to create a new instance of vtkAbstractWidgetFactory
+ * 
+ * @param initialValues for pre-setting some of its content
+ */
+export function newInstance(initialValues?: object): vtkAbstractWidgetFactory;
+
+export declare const vtkAbstractWidgetFactory: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+
+export default vtkAbstractWidgetFactory;

package/Widgets/Core/WidgetManager/Constants.d.ts

@@ -0,0 +1,27 @@
+export declare enum ViewTypes {
+  DEFAULT = 0,
+  GEOMETRY = 1,
+  SLICE = 2,
+  VOLUME = 3,
+  YZ_PLANE = 4,
+  XZ_PLANE = 5,
+  XY_PLANE = 6
+}
+
+export declare enum RenderingTypes {
+  PICKING_BUFFER = 0,
+  FRONT_BUFFER = 1
+}
+
+export declare enum CaptureOn {
+  MOUSE_MOVE = 0,
+  MOUSE_RELEASE = 1
+}
+
+declare const _default: {
+  ViewTypes: typeof ViewTypes;
+  RenderingTypes: typeof RenderingTypes;
+  CaptureOn: typeof CaptureOn;
+}
+
+export default _default;