@kitware/vtk.js 23.4.2 → 23.4.4

package/Filters/General/TubeFilter.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { l as normalize, j as cross, n as norm, d as dot, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { g as normalize, k as cross, n as norm, d as dot, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';

package/Filters/Sources/LineSource.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import { g as subtract, n as norm } from '../../Common/Core/Math/index.js';
+import { j as subtract, n as norm } from '../../Common/Core/Math/index.js';
 
 var vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
 // vtkLineSource methods

package/Filters/Sources/PlaneSource.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { g as subtract, l as normalize, d as dot, j as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { j as subtract, g as normalize, d as dot, k as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 

package/Filters/Texture/TextureMapToPlane.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { l as normalize, d as dot, j as cross, f as distance2BetweenPoints, x as determinant3x3 } from '../../Common/Core/Math/index.js';
+import { g as normalize, d as dot, k as cross, f as distance2BetweenPoints, x as determinant3x3 } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------

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;

package/Interaction/Manipulators/GestureCameraManipulator.d.ts

@@ -0,0 +1,34 @@
+import vtkCompositeCameraManipulator, {
+  ICompositeCameraManipulatorInitialValues,
+} from './CompositeCameraManipulator';
+import vtkCompositeGestureManipulator, {
+  ICompositeGestureManipulatorInitialValues,
+} from './CompositeGestureManipulator';
+import { vtkObject } from './../../interfaces';
+export interface vtkGestureCameraManipulator
+  extends vtkObject,
+    vtkCompositeCameraManipulator,
+    vtkCompositeGestureManipulator {}
+
+export interface IGestureCameraManipulatorInitialValues
+  extends ICompositeCameraManipulatorInitialValues,
+    ICompositeGestureManipulatorInitialValues {
+  flipDirection?: boolean;
+}
+
+export function newInstance(
+  initialValues?: IGestureCameraManipulatorInitialValues
+): vtkGestureCameraManipulator;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IGestureCameraManipulatorInitialValues
+): void;
+
+export const vtkGestureCameraManipulator: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkGestureCameraManipulator;

package/Interaction/Manipulators/KeyboardCameraManipulator.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkCompositeKeyboardManipulator from './CompositeKeyboardManipulator.js';
-import { k as add, l as normalize, j as cross } from '../../Common/Core/Math/index.js';
+import { l as add, g as normalize, k as cross } from '../../Common/Core/Math/index.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro;
 var ANIMATION_REQUESTER = 'vtkKeyboardCameraManipulator'; // ----------------------------------------------------------------------------

package/Interaction/Manipulators/MouseBoxSelectorManipulator.d.ts

@@ -0,0 +1,88 @@
+import vtkCompositeMouseManipulator, {
+  ICompositeMouseManipulatorInitialValues,
+} from './CompositeMouseManipulator';
+import { EventHandler, vtkObject, vtkSubscription } from './../../interfaces';
+import { Nullable } from './../../types';
+
+export interface vtkMouseBoxSelectorManipulator
+  extends vtkObject,
+    vtkCompositeMouseManipulator {
+  /**
+   * Invokes a box select change event.
+   */
+  invokeBoxSelectChange(data: unknown): void;
+
+  /**
+   * Registers a callback when a box select change event occurs.
+   * @param cb EventHandler
+   */
+  onBoxSelectChange(cb: EventHandler): vtkSubscription;
+
+  /**
+   * Invokes a box select input event.
+   */
+  invokeBoxSelectInput(data: unknown): void;
+
+  /**
+   * Registers a callback when a box select input event occurs.
+   * @param cb EventHandler
+   */
+  onBoxSelectInput(cb: EventHandler): vtkSubscription;
+
+  /**
+   * Sets whether to render the selection.
+   * @param render
+   */
+  setRenderSelection(render: boolean): boolean;
+
+  /**
+   * Get whether to render the selection.
+   */
+  getRenderSelection(): boolean;
+
+  /**
+   * Sets the selection box style.
+   * @param style
+   */
+  setSelectionStyle(style: Record<string, string>): boolean;
+
+  /**
+   * Gets the selection box style.
+   */
+  getSelectionStyle(): Record<string, string>;
+
+  /**
+   * Sets the box container.
+   * @param container
+   */
+  setContainer(container: Element): boolean;
+
+  /**
+   * Gets the box container.
+   */
+  getContainer(): Nullable<Element>;
+}
+
+export interface IMouseBoxSelectorManipulatorInitialValues
+  extends ICompositeMouseManipulatorInitialValues {
+  renderSelection?: boolean;
+  selectionStyle?: Record<string, string>;
+  container?: Element;
+}
+
+export function newInstance(
+  initialValues?: IMouseBoxSelectorManipulatorInitialValues
+): vtkMouseBoxSelectorManipulator;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IMouseBoxSelectorManipulatorInitialValues
+): void;
+
+export const vtkMouseBoxSelectorManipulator: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkMouseBoxSelectorManipulator;

package/Interaction/Manipulators/MouseCameraAxisRotateManipulator.js

@@ -3,7 +3,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, k as cross } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
 // vtkMouseCameraAxisRotateManipulator methods

package/Interaction/Manipulators/MouseCameraTrackballMultiRotateManipulator.d.ts

@@ -0,0 +1,32 @@
+import vtkCompositeCameraManipulator, {
+  ICompositeCameraManipulatorInitialValues,
+} from './CompositeCameraManipulator';
+import vtkCompositeMouseManipulator, {
+  ICompositeMouseManipulatorInitialValues,
+} from './CompositeMouseManipulator';
+import { vtkObject } from './../../interfaces';
+export interface vtkMouseCameraTrackballMultiRotateManipulator
+  extends vtkObject,
+    vtkCompositeCameraManipulator,
+    vtkCompositeMouseManipulator {}
+
+export interface IMouseCameraTrackballMultiRotateManipulatorInitialValues
+  extends ICompositeCameraManipulatorInitialValues,
+    ICompositeMouseManipulatorInitialValues {}
+
+export function newInstance(
+  initialValues?: IMouseCameraTrackballMultiRotateManipulatorInitialValues
+): vtkMouseCameraTrackballMultiRotateManipulator;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IMouseCameraTrackballMultiRotateManipulatorInitialValues
+): void;
+
+export const vtkMouseCameraTrackballMultiRotateManipulator: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkMouseCameraTrackballMultiRotateManipulator;