@kitware/vtk.js 23.4.2 → 23.4.4

package/Widgets/Core/WidgetManager.d.ts

@@ -0,0 +1,231 @@
+import vtkAbstractWidget from './AbstractWidget';
+import vtkAbstractWidgetFactory from './AbstractWidgetFactory';
+import vtkCamera from './../../Rendering/Core/Camera';
+import vtkProp from './../../Rendering/Core/Prop';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkRenderWindow from './../../Rendering/Core/RenderWindow';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import vtkSelectionNode from './../../Common/DataModel/SelectionNode';
+import vtkWidgetRepresentation from './../Representations/WidgetRepresentation';
+import vtkWidgetState from './WidgetState';
+import { vtkObject } from './../../interfaces';
+import { CaptureOn, ViewTypes } from './WidgetManager/Constants';
+import { Nullable } from './../../types';
+
+export interface ISelectedData {
+  requestCount: number;
+  propID: number;
+  compositeID: number;
+  prop: vtkProp;
+  widget: vtkAbstractWidget;
+  representation: vtkWidgetRepresentation;
+  selectedState: vtkWidgetState;
+}
+
+export interface IRenderingComponents {
+  renderer: vtkRenderer;
+  renderWindow: vtkRenderWindow;
+  interactor: vtkRenderWindowInteractor;
+  apiSpecificRenderWindow: vtkRenderWindow;
+  camera: vtkCamera;
+}
+
+/**
+ * Extract the rendering components from the given renderer.
+ * 
+ * @param {vtkRenderer} renderer The vtkRenderer instance.
+ */
+export function extractRenderingComponents(renderer: vtkRenderer): IRenderingComponents;
+
+/**
+ * This method returns the world distance that corresponds to the height of a
+ * single display pixel at a given coordinate. For example, to determine the
+ * (vertical) distance that matches a display distance of 30px for a coordinate
+ * `coord`, you would compute `30 * getPixelWorldHeightAtCoord(coord)`.
+ */
+export function getPixelWorldHeightAtCoord(coord: []): Number;
+
+export interface vtkWidgetManager extends vtkObject {
+  /**
+   * The the captureOn value. 
+   * `CaptureOn.MOUSE_MOVE`: captures small region when moving mouse
+   * `CaptureOn.MOUSE_RELEASE`: captures entire region when mouse button is released
+   * 
+   * @param {CaptureOn} captureOn
+   */
+  setCaptureOn(captureOn: CaptureOn): boolean;
+
+  /**
+   * Get the captureOn value.
+   */
+  getCaptureOn(): CaptureOn;
+
+  /**
+   * The the view type.
+   * 
+   * @param {ViewTypes} type
+   */
+  setViewType(type: ViewTypes): boolean;
+
+  /**
+   * Get the view type.
+   */
+  getViewType(): ViewTypes;
+
+  /**
+   * Get the current selection.
+   */
+  getSelections(): vtkSelectionNode[];
+
+  /**
+   * Get all the underlying widgets.
+   */
+  getWidgets(): vtkAbstractWidget[];
+
+  /**
+   * Get the active widget.
+   *
+   * If no widget is active, returns null.
+   */
+  getActiveWidget(): Nullable<vtkAbstractWidget>;
+
+  /**
+   * Get the view id.
+   */
+  getViewId(): string;
+
+  /**
+   * Returns true if picking is enabled, false otherwise.
+   */
+  getPickingEnabled(): boolean;
+
+  /**
+   * @deprecated
+   */
+  getUseSvgLayer(): boolean;
+
+  /**
+   * @deprecated
+   */
+  setUseSvgLayer(use: boolean): boolean;
+
+  /**
+   * Enable the picking.
+   */
+  enablePicking(): void;
+
+  /**
+   * Renders all the widgets.
+   */
+  renderWidgets(): void;
+
+  /**
+   * Disable the picking.
+   */
+  disablePicking(): void;
+
+  /**
+   * Set the renderer.
+   * 
+   * @param {vtkRenderer} renderer
+   */
+  setRenderer(renderer: vtkRenderer): void;
+
+  /**
+   * Register a widget on the widget manager instance. 
+   * Please note that one should link the widget manager to a view before calling this method. 
+   * 
+   * @param {vtkAbstractWidgetFactory} widget The abstract widget factory.
+   * @param {ViewTypes} [viewType]
+   * @param {Object} [initialValues]
+   */
+  addWidget(
+    widget: vtkAbstractWidgetFactory,
+    viewType?: ViewTypes,
+    initialValues?: object
+  ): Nullable<vtkAbstractWidget>;
+
+  /**
+   * Unregister all widgets from the widget manager.
+   */
+  removeWidgets(): void;
+
+  /**
+   * Remove a widget from the widget manager.
+   * 
+   * @param {vtkAbstractWidget | vtkAbstractWidgetFactory} widget The widget to remove
+   */
+  removeWidget(widget: vtkAbstractWidget | vtkAbstractWidgetFactory): void;
+
+  /**
+   * Given x and y parameter, get selected data.
+   * 
+   * @param {Number} x
+   * @param {Number} y
+   */
+  getSelectedDataForXY(x: number, y: number): Promise<ISelectedData>;
+
+  /**
+   * @deprecated
+   */
+  updateSelectionFromXY(x: number, y: number): void;
+
+  /**
+   * @deprecated
+   */
+  updateSelectionFromMouseEvent(event: MouseEvent): void;
+
+  /**
+   * The all currently selected data.
+   */
+  getSelectedData(): ISelectedData | {};
+
+  /**
+   * Given the focus to the given widget instance.
+   * 
+   * @param {vtkAbstractWidget | vtkAbstractWidgetFactory} widget The widget instance which should get the focus.
+   */
+  grabFocus(widget: vtkAbstractWidget | vtkAbstractWidgetFactory): void;
+
+  /**
+   * Release the focus.
+   */
+  releaseFocus(): void;
+}
+
+export interface IWidgetManagerInitialValues {
+  captureOn?: CaptureOn;
+  viewType?: ViewTypes;
+  pickingEnabled?: boolean;
+  /**
+   * @deprecated
+   */
+  useSvgLayer?: boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkWidgetManager 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?: IWidgetManagerInitialValues
+): vtkWidgetManager;
+
+/**
+ * Method used to create a new instance of vtkCellArray
+ * 
+ * @param initialValues for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IWidgetManagerInitialValues): vtkWidgetManager;
+
+export declare const vtkWidgetManager: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkWidgetManager;

package/Widgets/Core/WidgetState.d.ts

@@ -0,0 +1,81 @@
+import { vtkObject } from './../../interfaces';
+
+export interface vtkWidgetState extends vtkObject {
+  /**
+   * Set the active flag of the widget state instance
+   * 
+   * @param active The active flag
+   */
+  setActive(active: boolean): boolean;
+
+  /**
+   * Get the active flag of the widget state instance
+   */
+  getActive(): boolean;
+
+  /**
+   * Bind a state to one or more labels. If no label is provided, the default one will be used.
+   * 
+   * @param {vtkWidgetState} subState The state to bound.
+   * @param {String | String[]} [labels] The labels to which the state should be bound.
+   */
+  bindState(subState: vtkWidgetState, labels?: string | string[]): void;
+
+  /**
+   * Unbind a specific state from the widget state instance
+   * 
+   * @param {vtkWidgetState} subState The state to be unbound.
+   */
+  unbindState(subState: vtkWidgetState): void;
+
+  /**
+   * Unbind all states from the widget state instance
+   */
+  unbindAll(): void;
+
+  /**
+   * Activate the widget state instance. Same as calling `vtkWidgetState.setActive(true)`
+   */
+  activate(): void;
+
+  /**
+   * Deactivate thie widget state instance and all its sub states, except the `excludingState` argument.
+   * 
+   * @param {vtkWidgetState} [excludingState] A sub-state instance that should not be deactivated.
+   */
+  deactivate(excludingState?: vtkWidgetState): void;
+
+  /**
+   * Activate only the passed in sub state. Every other sub states will be deactivated.
+   * 
+   * @param {vtkWidgetState} subState The sub-state that should be activated.
+   */
+  activateOnly(subState: vtkWidgetState): void;
+
+  /**
+   * Get every states that are associated with the given label.
+   * 
+   * @param {String} label The label from which to retrieve the states.
+   */
+  getStatesWithLabel(label: string): vtkWidgetState[];
+
+  /**
+   * Get all the nested states on the widget state instance.
+   */
+  getAllNestedStates(): vtkWidgetState[];
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkWidgetState characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {object} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: object): vtkWidgetState;
+
+export declare const vtkWidgetState: {
+  extend: typeof extend;
+};
+
+export default vtkWidgetState;

package/Widgets/Manipulators/AbstractManipulator.d.ts

@@ -0,0 +1,221 @@
+import { vtkObject } from './../../interfaces';
+import { vtkOpenGLRenderWindow } from './../../Rendering/OpenGL/RenderWindow'
+import { Vector3 } from './../../types';
+
+/**
+ *
+ */
+export interface IAbstractManipulatorInitialValues {
+    userOrigin?: Vector3;
+    handleOrigin?: Vector3;
+    widgetOrigin?: Vector3;
+    userNormal?: Vector3;
+    handleNormal?: Vector3;
+    widgetNormal?: Vector3;
+}
+
+export interface vtkAbstractManipulator extends vtkObject {
+
+    /**
+     * Get the normal of the line
+     */
+    getNormal(callData: any): Vector3;
+
+    /**
+     * Get the origin of the line
+     */
+    getOrigin(callData: any): Vector3;
+
+    /**
+     * Get the value of useCameraFocalPoint
+     */
+    getUseCameraFocalPoint(): boolean;
+
+    /**
+     * Set the value of useCameraFocalPoint
+     * @param useCameraFocalPoint if true, the focal point of the camera will be used if userOrigin is not set.
+     */
+    setUseCameraFocalPoint(useCameraFocalPoint: boolean): boolean;
+
+    /**
+     * Get the value of useCameraNormal
+     */
+    getUseCameraNormal(): boolean;
+
+    /**
+     * Set the value of useCameraNormal
+     * @param useCameraNormal if true, the normal of the camera will be used if userNormal is not set.
+     */
+    setUseCameraNormal(useCameraNormal: boolean): boolean;
+
+    /**
+     * 
+     * @param callData 
+     * @param glRenderWindow 
+     */
+    handleEvent(callData: any, glRenderWindow: vtkOpenGLRenderWindow): Vector3;
+
+    /* ------------------------------------------------------------------- */
+
+    /**
+     * Set the user normal.
+     * This normal take precedence on the handleNormal and the widgetNormal.
+     * This normal should not be set within the widget internal code.
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setUserNormal(normal: Vector3): boolean;
+
+    /**
+     * Set the user normal (see setUserNormal).
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Number} z The z coordinate.
+     */
+    setUserNormal(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the user normal (see setUserNormal).
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setUserNormalFrom(normal: Vector3): boolean;
+
+    /**
+     * Set the user origin.
+     * This origin take precedence on the handleOrigin and the widgetOrigin.
+     * This origin should not be set within the widget internal code.
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setUserOrigin(origin: Vector3): boolean;
+
+    /**
+     * Set the user origin (see setUserOrigin).
+     * @param {Number} x The x coordinate of the origin point.
+     * @param {Number} y The y coordinate of the origin point.
+     * @param {Number} z The z coordinate of the origin point.
+     */
+    setUserOrigin(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the user origin (see setUserOrigin).
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setUserOriginFrom(origin: Vector3): boolean;
+
+    /* ------------------------------------------------------------------- */
+
+    /**
+     * Set the handle normal. 
+     * This normal is used after the userNormal and before the widgetNormal.
+     * This normal is automatically set by any state having a manipulatorMixin,
+     * and can be overridden in the widget code.
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setHandleNormal(normal: Vector3): boolean;
+
+    /**
+     * Set the handle normal (see setHandleNormal).
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Number} z The z coordinate.
+     */
+    setHandleNormal(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the handle normal (see setHandleNormal).
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setHandleNormalFrom(normal: Vector3): boolean;
+
+    /**
+     * Set the handle origin.
+     * This origin is used after the userOrigin and before the widgetOrigin.
+     * This origin is automatically set by any state having a manipulatorMixin,
+     * and can be overridden in the widget code.
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setHandleOrigin(origin: Vector3): boolean;
+
+    /**
+     * Set the handle origin (see setHandleOrigin).
+     * @param {Number} x The x coordinate of the origin point.
+     * @param {Number} y The y coordinate of the origin point.
+     * @param {Number} z The z coordinate of the origin point.
+     */
+    setHandleOrigin(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the handle origin (see setHandleOrigin).
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setHandleOriginFrom(origin: Vector3): boolean;
+
+    /* ------------------------------------------------------------------- */
+
+    /**
+     * Set the widget normal. 
+     * This normal is used if no other normals are set. 
+     * It can be used to define a normal global to the whole widget.
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setWidgetNormal(normal: Vector3): boolean;
+
+    /**
+     * Set the widget normal (see setWidgetNormal).
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Number} z The z coordinate.
+     */
+    setWidgetNormal(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the widget normal (see setWidgetNormal).
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setWidgetNormalFrom(normal: Vector3): boolean;
+
+    /**
+     * Set the widget origin.
+     * This origin is used if no other origins are set.
+     * It can be used to define an origin global to the whole widget.
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setWidgetOrigin(origin: Vector3): boolean;
+
+    /**
+     * Set the widget origin (see setWidgetOrigin).
+     * @param {Number} x The x coordinate of the origin point.
+     * @param {Number} y The y coordinate of the origin point.
+     * @param {Number} z The z coordinate of the origin point.
+     */
+    setWidgetOrigin(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the widget origin (see setWidgetOrigin).
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setWidgetOriginFrom(origin: Vector3): boolean;
+}
+
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkAbstractManipulator characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IAbstractManipulatorInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IAbstractManipulatorInitialValues): void;
+
+/**
+ * Method use to create a new instance of vtkAbstractManipulator
+ */
+export function newInstance(initialValues?: IAbstractManipulatorInitialValues): vtkAbstractManipulator;
+
+/**
+ * vtkAbstractManipulator.
+ */
+export declare const vtkAbstractManipulator: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+export default vtkAbstractManipulator;

package/Widgets/Manipulators/AbstractManipulator.js

@@ -0,0 +1,57 @@
+import macro from '../../macros.js';
+
+// vtkAbstractManipulator methods
+// ----------------------------------------------------------------------------
+
+function vtkAbstractManipulator(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkAbstractManipulator');
+
+  publicAPI.getOrigin = function (callData) {
+    if (model.userOrigin) return model.userOrigin;
+    if (model.useCameraFocalPoint) return callData.pokedRenderer.getActiveCamera().getFocalPoint();
+    if (model.handleOrigin) return model.handleOrigin;
+    if (model.widgetOrigin) return model.widgetOrigin;
+    return [0, 0, 0];
+  };
+
+  publicAPI.getNormal = function (callData) {
+    if (model.userNormal) return model.userNormal;
+    if (model.useCameraNormal) return callData.pokedRenderer.getActiveCamera().getDirectionOfProjection();
+    if (model.handleNormal) return model.handleNormal;
+    if (model.widgetNormal) return model.widgetNormal;
+    return [0, 0, 1];
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  // userOrigin: null,
+  // handleOrigin: null,
+  // widgetOrigin: null,
+  // userNormal: null,
+  // handleNormal: null,
+  // widgetNormal: null
+  useCameraFocalPoint: false,
+  useCameraNormal: false
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['useCameraFocalPoint', 'useCameraNormal']);
+  macro.setGetArray(publicAPI, model, ['userOrigin', 'handleOrigin', 'widgetOrigin', 'userNormal', 'handleNormal', 'widgetNormal'], 3);
+  vtkAbstractManipulator(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkAbstractManipulator'); // ----------------------------------------------------------------------------
+
+var vtkAbstractManipulator$1 = {
+  extend: extend,
+  newInstance: newInstance
+};
+
+export { vtkAbstractManipulator$1 as default, extend, newInstance };

package/Widgets/Manipulators/LineManipulator.js

@@ -1,5 +1,5 @@
 import macro from '../../macros.js';
-import { g as subtract, j as cross, d as dot, t as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
+import { j as subtract, k as cross, d as dot, t as multiplyScalar, l as add } from '../../Common/Core/Math/index.js';
 
 function projectDisplayToLine(x, y, lineOrigin, lineDirection, renderer, glRenderWindow) {
   var near = glRenderWindow.displayToWorld(x, y, 0, renderer);

package/Widgets/Manipulators/TrackballManipulator.js

@@ -1,6 +1,6 @@
 import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
-import { j as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { k as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 
 function trackballRotate(prevX, prevY, curX, curY, origin, direction, renderer, glRenderWindow) {
   var dx = curX - prevX;