@kitware/vtk.js 23.4.2 → 23.4.4

package/Rendering/Core/InteractorStyle.d.ts

@@ -0,0 +1,229 @@
+import { EventHandler, vtkSubscription } from './../../interfaces';
+import vtkInteractorObserver from './InteractorObserver';
+
+export interface vtkInteractorStyle extends vtkInteractorObserver {
+  /**
+   * Start a Rotate event.
+   */
+  startRotate(): void;
+
+  /**
+   * Invoke a StartRotate event.
+   */
+  invokeStartRotateEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartRotate event.
+   */
+  onStartRotateEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Rotate event.
+   */
+  endRotate(): void;
+
+  /**
+   * Invoke an EndRotate event.
+   */
+  invokeEndRotateEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndRotate event.
+   */
+  onEndRotateEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Pan event.
+   */
+  startPan(): void;
+
+  /**
+   * Invoke a StartPan event.
+   */
+  invokeStartPanEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartPan event.
+   */
+  onStartPanEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Pan event.
+   */
+  endPan(): void;
+
+  /**
+   * Invoke an EndPan event.
+   */
+  invokeEndPanEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndPan event.
+   */
+  onEndPanEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Spin event.
+   */
+  startSpin(): void;
+
+  /**
+   * Invoke a StartSpin event.
+   */
+  invokeStartSpinEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartSpin event.
+   */
+  onStartSpinEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Spin event.
+   */
+  endSpin(): void;
+
+  /**
+   * Invoke an EndSpin event.
+   */
+  invokeEndSpinEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndSpin event.
+   */
+  onEndSpinEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Dolly event.
+   */
+  startDolly(): void;
+
+  /**
+   * Invoke a StartDolly event.
+   */
+  invokeStartDollyEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartDolly event.
+   */
+  onStartDollyEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Dolly event.
+   */
+  endDolly(): void;
+
+  /**
+   * Invoke an EndDolly event.
+   */
+  invokeEndDollyEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndDolly event.
+   */
+  onEndDollyEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a CameraPose event.
+   */
+  startCameraPose(): void;
+
+  /**
+   * Invoke a StartCameraPose event.
+   */
+  invokeStartCameraPoseEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartCameraPose event.
+   */
+  onStartCameraPoseEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a CameraPose event.
+   */
+  endCameraPose(): void;
+
+  /**
+   * Invoke an EndCameraPose event.
+   */
+  invokeEndCameraPoseEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndCameraPose event.
+   */
+  onEndCameraPoseEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a WindowLevel event.
+   */
+  startWindowLevel(): void;
+
+  /**
+   * Invoke a StartWindowLevel event.
+   */
+  invokeStartWindowLevelEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartWindowLevel event.
+   */
+  onStartWindowLevelEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a WindowLevel event.
+   */
+  endWindowLevel(): void;
+
+  /**
+   * Invoke an EndWindowLevel event.
+   */
+  invokeEndWindowLevelEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndWindowLevel event.
+   */
+  onEndWindowLevelEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Slice event.
+   */
+  startSlice(): void;
+
+  /**
+   * Invoke a StartSlice event.
+   */
+  invokeStartSliceEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartSlice event.
+   */
+  onStartSliceEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Slice event.
+   */
+  endSlice(): void;
+
+  /**
+   * Invoke an EndSlice event.
+   */
+  invokeEndSliceEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndSlice event.
+   */
+  onEndSliceEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Handles a keypress.
+   */
+  handleKeyPress(callData: unknown): void;
+}
+
+export interface IInteractorStyleInitialValues {
+  autoAdjustCameraClippingRange?: boolean;
+}
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IInteractorStyleInitialValues
+): void;
+
+export const vtkInteractorStyle: {
+  extend: typeof extend;
+};
+
+export default vtkInteractorStyle;

package/Rendering/Core/Light.js

@@ -1,5 +1,5 @@
 import macro from '../../macros.js';
-import { l as normalize, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { g as normalize, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 
 var LIGHT_TYPES = ['HeadLight', 'CameraLight', 'SceneLight']; // ----------------------------------------------------------------------------
 // vtkLight methods

package/Rendering/Core/Mapper/Constants.d.ts

@@ -0,0 +1,26 @@
+export declare enum ColorMode {
+	DEFAULT = 0,
+	MAP_SCALARS = 1,
+	DIRECT_SCALARS = 2,
+}
+
+export declare enum ScalarMode {
+	DEFAULT = 0,
+	USE_POINT_DATA = 1,
+	USE_CELL_DATA = 2,
+	USE_POINT_FIELD_DATA = 3,
+	USE_CELL_FIELD_DATA = 4,
+	USE_FIELD_DATA = 5,
+}
+
+export declare enum GetArray {
+	BY_ID = 0,
+	BY_NAME = 1,
+}
+
+declare const _default: {
+	ColorMode: typeof ColorMode;
+	ScalarMode: typeof ScalarMode;
+	GetArray: typeof GetArray;
+};
+export default _default;

package/Rendering/Core/Mapper.js

@@ -4,7 +4,7 @@ import vtkAbstractMapper3D from './AbstractMapper3D.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkLookupTable from '../../Common/Core/LookupTable.js';
-import { M as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors/Constants.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import Constants from './Mapper/Constants.js';

package/Rendering/Core/Picker.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractPicker from './AbstractPicker.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { d as dot, l as normalize, n as norm, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { d as dot, g as normalize, n as norm, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import { mat4, vec4 } from 'gl-matrix';
 
 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/Core/Prop/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum CoordinateSystem {
+	WORLD = 0,
+	DISPLAY = 1,
+}
+
+declare const _default: {
+	CoordinateSystem: typeof CoordinateSystem;
+};
+export default _default;

package/Rendering/Core/Prop/Constants.js

@@ -0,0 +1,9 @@
+var CoordinateSystem = {
+  DISPLAY: 0,
+  WORLD: 1
+};
+var Constants = {
+  CoordinateSystem: CoordinateSystem
+};
+
+export { CoordinateSystem, Constants as default };

package/Rendering/Core/Property/Constants.d.ts

@@ -0,0 +1,24 @@
+export declare enum Shading {
+	FLAT = 0,
+	GOURAUD = 1,
+	PHONG = 2,
+}
+
+export declare enum Representation {
+	POINTS = 0,
+	WIREFRAME = 1,
+	SURFACE = 2,
+}
+
+export declare enum Interpolation {
+	FLAT = 0,
+	GOURAUD = 1,
+	PHONG = 2,
+}
+
+declare const _default: {
+	Shading: typeof Shading;
+	Representation: typeof Representation;
+	Interpolation: typeof Interpolation;
+};
+export default _default;

package/Rendering/Core/Property2D/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum DisplayLocation {
+  BACKGROUND = 0,
+  FOREGROUND = 1,
+}
+
+declare const _default: {
+	DisplayLocation: typeof DisplayLocation;
+};
+export default _default;

package/Rendering/Core/RenderWindow.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 
-var DEFAULT_VIEW_API = navigator.gpu ? 'WebGPU' : 'WebGL';
+var DEFAULT_VIEW_API = 'WebGL';
 var VIEW_CONSTRUCTORS = Object.create(null); // ----------------------------------------------------------------------------
 // static methods
 // ----------------------------------------------------------------------------

package/Rendering/Core/RenderWindowInteractor/Constants.d.ts

@@ -0,0 +1,31 @@
+export declare enum Device {
+	Unknown = 0,
+	LeftController = 1,
+	RightController = 2,
+}
+
+export declare enum Input {
+	Unknown = 0,
+	Trigger = 1,
+	TrackPad = 2,
+	Grip = 3,
+	Thumbstick = 4,
+	A = 5,
+	B = 6,
+	ApplicationMenu = 7, // Not exposed in WebXR API
+}
+
+export declare enum Axis {
+	Unknown = 0,
+	TouchpadX = 1,
+	TouchpadY = 2,
+	ThumbstickX = 3,
+	ThumbstickY = 4,
+}
+
+declare const _default: {
+	Device: typeof Device;
+	Input: typeof Input;
+	Axis: typeof Axis;
+};
+export default _default;

package/Rendering/Core/Renderer.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, get, setGet, getArray, setGetArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
-import { O as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { O as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 

package/Rendering/Core/VolumeMapper/Constants.d.ts

@@ -0,0 +1,20 @@
+export declare enum BlendMode {
+	COMPOSITE_BLEND = 0,
+	MAXIMUM_INTENSITY_BLEND = 1,
+	MINIMUM_INTENSITY_BLEND = 2,
+	AVERAGE_INTENSITY_BLEND = 3,
+	ADDITIVE_INTENSITY_BLEND = 4,
+	RADON_TRANSFORM_BLEND = 5,
+}
+
+export declare enum FilterMode {
+	OFF = 0,
+	NORMALIZED = 1,
+	RAW = 2,
+}
+
+declare const _default: {
+	BlendMode: typeof BlendMode;
+	FilterMode: typeof FilterMode;
+};
+export default _default;

package/Rendering/Core/VolumeMapper.js

@@ -1,5 +1,5 @@
 import macro from '../../macros.js';
-import { M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 

package/Rendering/Core/VolumeProperty/Constants.d.ts

@@ -0,0 +1,16 @@
+export declare enum InterpolationType {
+	NEAREST = 0,
+	LINEAR = 1,
+	FAST_LINEAR = 2
+}
+
+export declare enum OpacityMode {
+	FRACTIONAL = 0,
+	PROPORTIONAL = 1,
+}
+
+declare const _default: {
+	InterpolationType: typeof InterpolationType;
+	OpacityMode: typeof OpacityMode;
+};
+export default _default;

package/Rendering/Misc/SynchronizableRenderWindow/BehaviorManager/CameraSynchronizer.js

@@ -0,0 +1,129 @@
+import { newInstance as newInstance$1, obj, setGet, setGetArray, chain } from '../../../../macros.js';
+import { l as normalize } from '../../../../Common/Core/Math/index.js';
+
+var MODE_RESET_CAMERA = 'resetcamera';
+var MODE_ORIENTATION = 'orientation';
+var MODE_SAME = 'same';
+var SynchronizationMode = {
+  MODE_RESET_CAMERA: MODE_RESET_CAMERA,
+  MODE_ORIENTATION: MODE_ORIENTATION,
+  MODE_SAME: MODE_SAME
+};
+
+function vtkCameraSynchronizer(publicAPI, model) {
+  model.classHierarchy.push('vtkCameraSynchronizer');
+  var cameraState = new Float64Array(9);
+  var direction = new Float64Array(3);
+  var subscriptions = [];
+
+  function updateListeners() {
+    while (subscriptions.length) {
+      subscriptions.pop().unsubscribe();
+    }
+
+    if (!model.srcRenderer || !model.dstRenderer) {
+      return;
+    }
+
+    var srcCamera = model.srcRenderer.getActiveCamera();
+    var interactor = model.srcRenderer.getRenderWindow().getInteractor();
+    subscriptions.push(srcCamera.onModified(function () {
+      if (!interactor.isAnimating()) {
+        publicAPI.update();
+      }
+    }));
+    subscriptions.push(interactor.onAnimation(publicAPI.update));
+    subscriptions.push(interactor.onEndAnimation(publicAPI.update));
+  } // Update listeners automatically
+
+
+  model._srcRendererChanged = updateListeners;
+  model._dstRendererChanged = updateListeners;
+
+  function updatePreviousValues(position, focalPoint, viewUp) {
+    if (cameraState[0] !== position[0] || cameraState[1] !== position[1] || cameraState[2] !== position[2] || cameraState[3] !== focalPoint[0] || cameraState[4] !== focalPoint[1] || cameraState[5] !== focalPoint[2] || cameraState[6] !== viewUp[0] || cameraState[7] !== viewUp[1] || cameraState[8] !== viewUp[2]) {
+      cameraState[0] = position[0];
+      cameraState[1] = position[1];
+      cameraState[2] = position[2];
+      cameraState[3] = focalPoint[0];
+      cameraState[4] = focalPoint[1];
+      cameraState[5] = focalPoint[2];
+      cameraState[6] = viewUp[0];
+      cameraState[7] = viewUp[1];
+      cameraState[8] = viewUp[2];
+      return cameraState;
+    }
+
+    return false;
+  }
+
+  publicAPI.update = function () {
+    if (!model.active || !model.srcRenderer || !model.dstRenderer) {
+      return;
+    }
+
+    var srcCamera = model.srcRenderer.getActiveCamera();
+    var dstCamera = model.dstRenderer.getActiveCamera();
+    var position = srcCamera.getReferenceByName('position');
+    var focalPoint = srcCamera.getReferenceByName('focalPoint');
+    var viewUp = srcCamera.getReferenceByName('viewUp');
+    var change = updatePreviousValues(position, focalPoint, viewUp);
+
+    if (!change) {
+      return;
+    }
+
+    if (model.mode === MODE_ORIENTATION) {
+      direction[0] = change[0] - change[3];
+      direction[1] = change[1] - change[4];
+      direction[2] = change[2] - change[5];
+      normalize(direction);
+      dstCamera.setPosition(model.focalPoint[0] + model.distance * direction[0], model.focalPoint[1] + model.distance * direction[1], model.focalPoint[2] + model.distance * direction[2]);
+      dstCamera.setFocalPoint(model.focalPoint[0], model.focalPoint[1], model.focalPoint[2]);
+      dstCamera.setViewUp(change[6], change[7], change[8]);
+    } else {
+      dstCamera.setPosition(change[0], change[1], change[2]);
+      dstCamera.setFocalPoint(change[3], change[4], change[5]);
+      dstCamera.setViewUp(change[6], change[7], change[8]);
+    }
+
+    if (model.mode === MODE_RESET_CAMERA) {
+      model.dstRenderer.resetCamera();
+    }
+  };
+
+  publicAPI.delete = chain(function () {
+    return publicAPI.setSrcRenderer(null);
+  }, // Will clear any listener
+  publicAPI.delete); // If src/dstRenderer provided at constructor register listeners
+
+  updateListeners();
+}
+
+var DEFAULT_VALUES = {
+  mode: MODE_ORIENTATION,
+  focalPoint: [0, 0, 0],
+  distance: 6.8,
+  active: true // srcRenderer: null,
+  // dstRenderer: null,
+
+};
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+
+  obj(publicAPI, model);
+  setGet(publicAPI, model, ['mode', 'active', 'srcRenderer', 'dstRenderer', 'distance']);
+  setGetArray(publicAPI, model, ['focalPoint'], 3, 0); // Object methods
+
+  vtkCameraSynchronizer(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = newInstance$1(extend, 'vtkCameraSynchronizer');
+var vtkCameraSynchronizer$1 = {
+  newInstance: newInstance,
+  extend: extend,
+  SynchronizationMode: SynchronizationMode
+};
+
+export { DEFAULT_VALUES, MODE_ORIENTATION, MODE_RESET_CAMERA, MODE_SAME, SynchronizationMode, vtkCameraSynchronizer$1 as default, extend, newInstance };