@kitware/vtk.js 26.3.1 → 26.4.0

package/Interaction/Style/InteractorStyleManipulator.d.ts

@@ -0,0 +1,333 @@
+import vtkCompositeGestureManipulator from './../Manipulators/CompositeGestureManipulator';
+import vtkCompositeKeyboardManipulator from './../Manipulators/CompositeKeyboardManipulator';
+import vtkCompositeMouseManipulator from './../Manipulators/CompositeMouseManipulator';
+import vtkCompositeVRManipulator from './../Manipulators/CompositeVRManipulator';
+import vtkInteractorStyle from './../../Rendering/Core/InteractorStyle';
+import {
+  Device,
+  Input,
+} from './../../Rendering/Core/RenderWindowInteractor/Constants';
+import { Nullable, Vector3 } from './../../types';
+
+export interface vtkInteractorStyleManipulator extends vtkInteractorStyle {
+  /**
+   * Remove all manipulators.
+   */
+  removeAllManipulators(): void;
+
+  /**
+   * Remove mouse manipulators.
+   */
+  removeAllMouseManipulators(): void;
+
+  /**
+   * Remove keyboard manipulators.
+   */
+  removeAllKeyboardManipulators(): void;
+
+  /**
+   * Remove VR manipulators.
+   */
+  removeAllVRManipulators(): void;
+
+  /**
+   * Remove gesture manipulators.
+   */
+  removeAllGestureManipulators(): void;
+
+  /**
+   * Adds a mouse manipulator.
+   * @param manipulator the manipulator to add
+   * @returns whether the manipulator has been added
+   */
+  addMouseManipulator(manipulator: vtkCompositeMouseManipulator): boolean;
+
+  /**
+   * Adds a keyboard manipulator.
+   * @param manipulator the manipulator to add
+   * @returns whether the manipulator has been added
+   */
+  addKeyboardManipulator(manipulator: vtkCompositeKeyboardManipulator): boolean;
+
+  /**
+   * Adds a VR manipulator.
+   * @param manipulator the manipulator to add
+   * @returns whether the manipulator has been added
+   */
+  addVRManipulator(manipulator: vtkCompositeVRManipulator): boolean;
+
+  /**
+   * Adds a gesture manipulator.
+   * @param manipulator the manipulator to add
+   * @returns whether the manipulator has been added
+   */
+  addGestureManipulator(manipulator: vtkCompositeGestureManipulator): boolean;
+
+  /**
+   * Removes a mouse manipulator.
+   * @param manipulator the manipulator to remove
+   */
+  removeMouseManipulator(manipulator: vtkCompositeMouseManipulator): void;
+
+  /**
+   * Removes a keyboard manipulator.
+   * @param manipulator the manipulator to remove
+   */
+  removeKeyboardManipulator(manipulator: vtkCompositeKeyboardManipulator): void;
+
+  /**
+   * Removes a VR manipulator.
+   * @param manipulator the manipulator to remove
+   */
+  removeVRManipulator(manipulator: vtkCompositeVRManipulator): void;
+
+  /**
+   * Removes a gesture manipulator.
+   * @param manipulator the manipulator to remove
+   */
+  removeGestureManipulator(manipulator: vtkCompositeGestureManipulator): void;
+
+  /**
+   * Gets the number of mouse manipulators.
+   */
+  getNumberOfMouseManipulators(): number;
+
+  /**
+   * Gets the number of keyboard manipulators.
+   */
+  getNumberOfKeyboardManipulators(): number;
+
+  /**
+   * Gets the number of VR manipulators.
+   */
+  getNumberOfVRManipulators(): number;
+
+  /**
+   * Gets the number of gesture manipulators.
+   */
+  getNumberOfGestureManipulators(): number;
+
+  /**
+   * Resets/clears the current manipulator.
+   */
+  resetCurrentManipulator(): void;
+
+  /**
+   * Finds a mouse manipulator with a given control set.
+   * @param button which button
+   * @param shift shift enabled
+   * @param scroll scroll enabled
+   * @param alt alt enabled
+   */
+  findMouseManipulator(
+    button: number,
+    shift: boolean,
+    scroll: boolean,
+    alt: boolean
+  ): Nullable<vtkCompositeMouseManipulator>;
+
+  /**
+   * Finds a VR manipulator with a given device + input.
+   * @param device
+   * @param input
+   */
+  findVRManipulator(
+    device: Device,
+    input: Input
+  ): Nullable<vtkCompositeVRManipulator>;
+
+  /**
+   * Handles a left button press event.
+   * @param callData event data
+   */
+  handleLeftButtonPress(callData: unknown): void;
+
+  /**
+   * Handles a middle button press event.
+   * @param callData event data
+   */
+  handleMiddleButtonPress(callData: unknown): void;
+
+  /**
+   * Handles a right button press event.
+   * @param callData event data
+   */
+  handleRightButtonPress(callData: unknown): void;
+
+  /**
+   * Handles a left button release event.
+   * @param callData event data
+   */
+  handleLeftButtonRelease(callData: unknown): void;
+
+  /**
+   * Handles a middle button release event.
+   * @param callData event data
+   */
+  handleMiddleButtonRelease(callData: unknown): void;
+
+  /**
+   * Handles a right button release event.
+   * @param callData event data
+   */
+  handleRightButtonRelease(callData: unknown): void;
+
+  /**
+   * Handles the start of a wheel event.
+   * @param callData event data
+   */
+  handleStartMouseWheel(callData: unknown): void;
+
+  /**
+   * Handles a wheel event.
+   * @param callData event data
+   */
+  handleMouseWheel(callData: unknown): void;
+
+  /**
+   * Handles the end of a wheel event.
+   * @param callData event data
+   */
+  handleEndMouseWheel(callData: unknown): void;
+
+  /**
+   * Handles a mouse move.
+   * @param callData event data
+   */
+  handleMouseMove(callData: unknown): void;
+
+  /**
+   * Handles a 3D button event.
+   * @param callData event data
+   */
+  handleButton3D(ed: unknown): void;
+
+  /**
+   * Handles a 3D move event.
+   * @param ed event data
+   */
+  handleMove3D(ed: unknown): void;
+
+  /**
+   * Handles a keypress.
+   * @param callData event data
+   */
+  handleKeyPress(callData: unknown): void;
+
+  /**
+   * Handles a keydown event.
+   * @param callData event data
+   */
+  handleKeyDown(callData: unknown): void;
+
+  /**
+   * Handles a keyup event.
+   * @param callData event data
+   */
+  handleKeyUp(callData: unknown): void;
+
+  /**
+   * Handles the start of a pinch gesture.
+   * @param callData event data
+   */
+  handleStartPinch(callData: unknown): void;
+
+  /**
+   * Handles the end of a pinch gesture.
+   * @param callData event data
+   */
+  handleEndPinch(callData: unknown): void;
+
+  /**
+   * Handles the start of a rotate gesture.
+   * @param callData event data
+   */
+  handleStartRotate(callData: unknown): void;
+
+  /**
+   * Handles the end of a rotate gesture.
+   * @param callData event data
+   */
+  handleEndRotate(callData: unknown): void;
+
+  /**
+   * Handles the start of a pan gesture.
+   * @param callData event data
+   */
+  handleStartPan(callData: unknown): void;
+
+  /**
+   * Handles the end of a pan gesture.
+   * @param callData event data
+   */
+  handleEndPan(callData: unknown): void;
+
+  /**
+   * Handles a pinch gesture.
+   * @param callData event data
+   */
+  handlePinch(callData: unknown): void;
+
+  /**
+   * Handles a rotate gesture.
+   * @param callData event data
+   */
+  handleRotate(callData: unknown): void;
+
+  /**
+   * Handles a pan gesture.
+   * @param callData event data
+   */
+  handlePan(callData: unknown): void;
+
+  /**
+   * Handles a button down event.
+   * @param button which button
+   * @param callData event data
+   */
+  onButtonDown(button: number, callData: unknown): void;
+
+  /**
+   * Handles a button up event.
+   * @param button which button
+   */
+  onButtonUp(button: number): void;
+
+  /**
+   * Sets the rotation factor.
+   * @param factor rotation factor
+   */
+  setRotationFactor(factor: number): boolean;
+
+  /**
+   * Gets the rotation factor.
+   */
+  getRotationFactor(): number;
+
+  getMouseManipulators(): vtkCompositeMouseManipulator[];
+  getMouseManipulators(): vtkCompositeMouseManipulator[];
+  getMouseManipulators(): vtkCompositeMouseManipulator[];
+  getMouseManipulators(): vtkCompositeMouseManipulator[];
+}
+
+export interface IInteractorStyleManipulatorInitialValues {
+  centerOfRotation?: Vector3;
+  rotationFactor?: number;
+}
+
+export function newInstance(
+  initialValues?: IInteractorStyleManipulatorInitialValues
+): vtkInteractorStyleManipulator;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IInteractorStyleManipulatorInitialValues
+): void;
+
+export const vtkInteractorStyleManipulator: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkInteractorStyleManipulator;

package/Proxy/Core/AbstractRepresentationProxy.d.ts

@@ -0,0 +1,24 @@
+import { vtkObject } from './../../interfaces';
+import { VtkProxy } from './../../macros';
+import vtkSourceProxy from './SourceProxy';
+import vtkAbstractMapper from './../../Rendering/Core/AbstractMapper';
+import vtkActor from './../../Rendering/Core/Actor';
+import vtkVolume from './../../Rendering/Core/Volume';
+
+export interface vtkAbstractRepresentationProxy extends VtkProxy {
+  setInput<T>(source: vtkSourceProxy<T>): void;
+  getInputDataSet(): vtkObject | null;
+  setColorBy(
+    arrayName: string | null,
+    arrayLocation: string,
+    componentIndex: number
+  );
+  setRescaleOnColorBy(rescale: boolean): boolean;
+  getRescaleOnColorBy(): boolean;
+  getInput(): VtkProxy;
+  getMapper(): vtkAbstractMapper;
+  getActors(): vtkActor[];
+  getVolumes(): vtkVolume[];
+}
+
+export default vtkAbstractRepresentationProxy;

package/Proxy/Core/LookupTableProxy.d.ts

@@ -0,0 +1,45 @@
+import { VtkProxy } from './../../macros';
+import vtkColorTransferFunction from './../../Rendering/Core/ColorTransferFunction';
+
+// [x, r/h, g/s, b/v, m=0.5, s=0.0]
+export type RGBHSVPoint = [number, number, number, number, number?, number?];
+
+export enum ILookupTableProxyMode {
+  Preset = 0,
+  RGBPoints = 1,
+  HSVPoints = 2,
+  Nodes = 3,
+}
+
+export interface vtkLookupTableProxy extends VtkProxy {
+  setPresetName(name: string): void;
+  getPresetName(): string;
+  setRGBPoints(points: RGBHSVPoint[]): void;
+  getRGBPoints(): RGBHSVPoint[];
+  setHSVPoints(points: RGBHSVPoint[]): void;
+  getHSVPoints(): RGBHSVPoint[];
+  // Node: { x, y, midpoint, sharpness }
+  setNodes(nodes: number[][]): void;
+  getNodes(nodes): number[][];
+  setMode(mode: number): void;
+  getMode(): number;
+  applyMode(): void;
+  setDataRange(min: number, max: number): void;
+  getDataRange(): [number, number];
+  getLookupTable(): vtkColorTransferFunction;
+}
+
+export interface ILookupTableProxyInitialValues {
+  lookupTable?: vtkColorTransferFunction;
+}
+
+export function newInstance(
+  initialValues?: ILookupTableProxyInitialValues
+): vtkLookupTableProxy;
+
+export declare const vtkLookupTableProxy: {
+  newInstance: typeof newInstance;
+  Mode: ILookupTableProxyMode;
+};
+
+export default vtkLookupTableProxy;

package/Proxy/Core/PiecewiseFunctionProxy.d.ts

@@ -0,0 +1,62 @@
+import vtkLookupTableProxy from './LookupTableProxy';
+import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
+import { VtkProxy } from './../../macros';
+
+// [x, r/h, g/s, b/v, m=0.5, s=0.0]
+export interface PiecewiseGaussian {
+  position: number;
+  height: number;
+  width: number;
+  xBias: number;
+  yBias: number;
+}
+
+export interface PiecewiseNode {
+  x: number;
+  y: number;
+  midpoint: number;
+  sharpness: number;
+}
+
+export enum IPiecewiseFunctionProxyMode {
+  Gaussians = 0,
+  Points = 1,
+  Nodes = 2,
+}
+
+export interface IPiecewiseFunctionProxyDefaults {
+  Gaussians: PiecewiseGaussian[];
+  Points: number[][];
+  Nodes: PiecewiseNode[];
+}
+
+export interface vtkPiecewiseFunctionProxy extends VtkProxy {
+  setGaussians(gaussians: PiecewiseGaussian[]): void;
+  getGaussians(): PiecewiseGaussian[];
+  setPoints(points: number[][]): void;
+  getPoints(): number[][];
+  setNodes(nodes: PiecewiseNode[]): void;
+  getNodes(): PiecewiseNode[];
+  setMode(mode: number): void;
+  getMode(): number;
+  applyMode(): void;
+  getLookupTableProxy(): vtkLookupTableProxy;
+  setDataRange(min: number, max: number): void;
+  getDataRange(): [number, number];
+  getPiecewiseFunction(): vtkPiecewiseFunction;
+}
+
+export interface IPiecewiseFunctionProxyInitialValues {
+  piecewiseFunction?: vtkPiecewiseFunction;
+}
+
+export function newInstance(
+  initialValues?: IPiecewiseFunctionProxyInitialValues
+): vtkPiecewiseFunctionProxy;
+
+export declare const vtkPiecewiseFunctionProxy: {
+  newInstance: typeof newInstance;
+  Mode: typeof IPiecewiseFunctionProxyMode;
+  Defaults: IPiecewiseFunctionProxyDefaults;
+};
+export default vtkPiecewiseFunctionProxy;

package/Proxy/Core/ProxyManager.d.ts

@@ -0,0 +1,81 @@
+import { vtkObject } from './../../interfaces';
+import vtkSourceProxy from './SourceProxy';
+import vtkViewProxy from './ViewProxy';
+import vtkAbstractRepresentationProxy from './AbstractRepresentationProxy';
+import vtkLookupTableProxy from './LookupTableProxy';
+import vtkPiecewiseFunctionProxy from './PiecewiseFunctionProxy';
+import { VtkProxy } from './../../macros';
+
+export type ProxyConfiguration = Object;
+
+export interface ProxyRegistrationChangeInfo {
+  action: 'register' | 'unregister';
+  proxyId: string;
+  proxyName: string;
+  proxyGroup: string;
+  proxy: VtkProxy;
+}
+
+export interface vtkProxyManager extends vtkObject {
+  // core //
+
+  setProxyConfiguration(config: ProxyConfiguration): boolean;
+  getProxyConfiguration(): ProxyConfiguration;
+
+  setActiveSource<T>(sourceProxy: vtkSourceProxy<T>): boolean;
+  getActiveSource<T>(): vtkSourceProxy<T>;
+
+  setActiveView(viewProxy: vtkViewProxy): boolean;
+  getActiveView(): vtkViewProxy;
+
+  onProxyRegistrationChange(
+    callback: (changeInfo: ProxyRegistrationChangeInfo) => void
+  );
+
+  getProxyById<T extends VtkProxy>(id: string): T | undefined;
+  getProxyGroups(): string[];
+  getProxyInGroup(groupName: string): VtkProxy[];
+
+  getSources(): vtkSourceProxy<any>[];
+  getRepresentations(): vtkAbstractRepresentationProxy[];
+  getViews(): vtkViewProxy[];
+
+  createProxy<T extends VtkProxy>(
+    group: string,
+    name: string,
+    options?: Object
+  ): T;
+
+  getRepresentation<T extends vtkAbstractRepresentationProxy>(
+    source: vtkSourceProxy<any>,
+    view: vtkViewProxy
+  ): T | null;
+
+  deleteProxy(proxy: VtkProxy): void;
+
+  // view //
+
+  render(view?: vtkViewProxy): void;
+  renderAllViews(): void;
+  setAnimationOnAllViews(): void;
+  autoAnimateViews(debounceTimeout: number): void;
+  resizeAllViews(): void;
+  resetCamera(view?: vtkViewProxy): void;
+  createRepresentationInAllViews(source: vtkSourceProxy<any>): void;
+  resetCameraInAllViews(): void;
+
+  // properties //
+
+  // these are specific to the proxy configuration...
+  getLookupTable(arrayName: string, options?: any): vtkLookupTableProxy;
+  getPiecewiseFunction(
+    arrayName: string,
+    options?: any
+  ): vtkPiecewiseFunctionProxy;
+  rescaleTransferFunctionToDataRange(
+    arrayName: string,
+    dataRange: [number, number]
+  ): void;
+}
+
+export default vtkProxyManager;

package/Proxy/Core/SourceProxy.d.ts

@@ -0,0 +1,22 @@
+import { vtkAlgorithm } from './../../interfaces';
+import { VtkProxy } from './../../macros';
+
+export interface vtkSourceProxy<T> extends VtkProxy {
+  setInputProxy(source: vtkSourceProxy<T>): void;
+  setInputData(dataset: T, type?: string): void;
+  setInputAlgorithm(
+    algo: vtkAlgorithm,
+    type: string,
+    autoUpdate: boolean
+  ): void;
+  update(): void;
+
+  getName(): string;
+  setName(name: string): boolean;
+  getType(): string;
+  getDataset(): T | null;
+  getAlgo(): vtkAlgorithm | null;
+  getInputProxy(): vtkSourceProxy<T> | null;
+}
+
+export default vtkSourceProxy;

package/Proxy/Core/View2DProxy.d.ts

@@ -0,0 +1,7 @@
+import vtkViewProxy from './ViewProxy';
+
+export interface vtkView2DProxy extends vtkViewProxy {
+  getAxis(): number;
+}
+
+export default vtkView2DProxy;

package/Proxy/Core/ViewProxy.d.ts

@@ -0,0 +1,86 @@
+import vtkActor from './../../Rendering/Core/Actor';
+import vtkAbstractRepresentationProxy from './AbstractRepresentationProxy';
+import { Vector3, Vector4 } from './../../types';
+import vtkCamera from './../../Rendering/Core/Camera';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import vtkInteractorStyle from './../../Rendering/Core/InteractorStyle';
+import { vtkSubscription, vtkObject } from './../../interfaces';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkRenderWindow from './../../Rendering/Core/RenderWindow';
+import vtkOpenGLRenderWindow from './../../Rendering/OpenGL/RenderWindow';
+import { VtkProxy } from './../../macros';
+
+export interface vtkViewProxy extends VtkProxy {
+  setPresetToInteractor3D(nameOrDefinitions: string | Object): boolean;
+  setPresetToInteractor2D(nameOrDefinitions: string | Object): boolean;
+
+  setOrientationAxesType(type: string): void;
+  setOrientationAxesVisibility(visible: boolean): boolean;
+  registerOrientationAxis(name: string, actor: vtkActor): void;
+  unregisterOrientationAxis(name: string): void;
+  listOrientationAxis(): string[];
+  setPresetToOrientationAxes(nameOrDefinitions: string | Object): boolean;
+
+  setContainer(container: HTMLElement | null): void;
+  resize(): void;
+  renderLater(): void;
+  render(blocking: boolean): void;
+  resetCamera(): void;
+
+  addRepresentation(representation: vtkAbstractRepresentationProxy): void;
+  removeRepresentation(representation: vtkAbstractRepresentationProxy): void;
+
+  // TODO correct?
+  captureImage(opts: { format: string } & Object): Array<Promise<string>>;
+  openCaptureImage(target: string): void;
+
+  // TODO corner annotations
+
+  setBackground(color: Vector3 | Vector4): void;
+  getBackground(): Vector3 | Vector4;
+
+  setAnimation(enable: boolean, requester?: vtkObject);
+
+  updateOrientation(
+    axisIndex: 0 | 1 | 2,
+    orientation: -1 | 1,
+    viewUp: Vector3,
+    animateSteps: number
+  ): Promise<void>;
+  moveCamera(
+    focalPoint: Vector3,
+    position: Vector3,
+    viewUp: Vector3,
+    animateSteps: number
+  ): Promise<void>;
+
+  resetOrientation(animateSteps: number): void;
+  rotate(angle): void;
+
+  focusTo(focalPoint: Vector3): void;
+
+  getCamera(): vtkCamera;
+  // getAnnotationOpacity
+  getContainer(): HTMLElement | null;
+  // getCornerAnnotation
+  getInteractor(): vtkRenderWindowInteractor;
+  getInteractorStyle2D(): vtkInteractorStyle;
+  getInteractorStyle3D(): vtkInteractorStyle;
+  getOpenglRenderWindow(): vtkOpenGLRenderWindow;
+  getOrientationAxesType(): string;
+  getPresetToOrientationAxes(): any;
+  getRenderer(): vtkRenderer;
+  getRenderWindow(): vtkRenderWindow;
+  getRepresentations(): vtkAbstractRepresentationProxy[];
+  getUseParallelRendering(): boolean;
+  getDisableAnimation(): boolean;
+  setDisableAnimation(disabled: boolean): boolean;
+
+  onResize(
+    cb: (size: { width: number; height: number }) => void
+  ): vtkSubscription;
+
+  // TODO proxy property mappings
+}
+
+export default vtkViewProxy;

package/Proxy/Representations/SliceRepresentationProxy.d.ts

@@ -0,0 +1,27 @@
+import vtkAbstractRepresentationProxy from './../Core/AbstractRepresentationProxy';
+
+export interface vtkSliceRepresentationProxy
+  extends vtkAbstractRepresentationProxy {
+  /**
+   * @param mode XYZIJK
+   */
+  setSlicingMode(mode: string): boolean;
+  getSlicingMode(): string;
+  getSliceIndex(): number;
+  getAnnotations(): any;
+
+  // proxy property mappings
+
+  setVisibility(visible: boolean): boolean;
+  getVisibility(): boolean;
+  setWindowWidth(width: number): boolean;
+  getWindowWidth(): number;
+  setWindowLevel(level: number): boolean;
+  getWindowLevel(): number;
+  setInterpolationType(type: number): boolean;
+  getInterpolationType(): number;
+  setSlice(type: number): boolean;
+  getSlice(): number;
+}
+
+export default vtkSliceRepresentationProxy;