@kitware/vtk.js 24.7.1 → 24.10.0

package/Rendering/Core/VolumeMapper.d.ts

@@ -1,12 +1,6 @@
 import { Bounds, Range } from './../../types';
 import vtkAbstractMapper, { IAbstractMapperInitialValues } from './AbstractMapper';
-
-export enum BlendMode {
-	COMPOSITE_BLEND,
-	MAXIMUM_INTENSITY_BLEND,
-	MINIMUM_INTENSITY_BLEND,
-	AVERAGE_INTENSITY_BLEND,
-}
+import { BlendMode, FilterMode } from './VolumeMapper/Constants';
 
 /**
  * 
@@ -165,7 +159,9 @@ export function newInstance(initialValues?: IVolumeMapperInitialValues): vtkVolu
  * A volume mapper that performs ray casting on the GPU using fragment programs.
  */
 export declare const vtkVolumeMapper: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	BlendMode: typeof BlendMode;
+	FilterMode: typeof FilterMode;
 };
 export default vtkVolumeMapper;

package/Rendering/Core/VolumeProperty.d.ts

@@ -1,15 +1,5 @@
 import { vtkObject } from './../../interfaces';
-
-export enum InterpolationType {
-	NEAREST,
-	LINEAR,
-	FAST_LINEAR,
-}
-
-export enum OpacityMode {
-	FRACTIONAL,
-	PROPORTIONAL,
-}
+import { InterpolationType, OpacityMode } from './VolumeProperty/Constants';
 
 interface IVolumePropertyInitialValues  {
 	independentComponents?: boolean;
@@ -412,7 +402,9 @@ export function newInstance(initialValues?: IVolumePropertyInitialValues): vtkVo
  * ```
  */
 export declare const vtkVolumeProperty: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	InterpolationType: typeof InterpolationType;
+	OpacityMode: typeof OpacityMode;
 };
 export default vtkVolumeProperty;

package/Rendering/Misc/FullScreenRenderWindow.d.ts

@@ -13,10 +13,11 @@ import vtkRenderWindowInteractor from './../Core/RenderWindowInteractor';
  */
 export interface IFullScreenRenderWindowInitialValues {
 	background?: RGBColor;
+	container?: HTMLElement
 	containerStyle?: object;
-	controlPanelStyle?: object,
-	listenWindowResize?: boolean;
+	controlPanelStyle?: object;
 	controllerVisibility?: boolean;
+	listenWindowResize?: boolean;
 	resizeCallback?: any;
 }
 

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -1,7 +1,7 @@
 import { vtkAlgorithm, vtkObject } from './../../interfaces';
 import { Nullable, Size, Vector2, Vector3 } from './../../types';
-import { vtkRenderer } from './../Core/Renderer';
 import { VtkDataTypes } from './../../Common/Core/DataArray';
+import vtkRenderer from './../Core/Renderer';
 import vtkTexture from './../Core/Texture';
 import vtkViewStream from './../../IO/Core/ImageStream/ViewStream';
 
@@ -9,15 +9,33 @@ import vtkViewStream from './../../IO/Core/ImageStream/ViewStream';
  *
  */
 export interface IOpenGLRenderWindowInitialValues {
-	resolution?: number;
-	point1?: Vector3;
-	point2?: Vector3;
-	pointType?: string;
+	cullFaceEnabled?: boolean;
+	shaderCache?: null;
+	initialized?: boolean;
+	context?: WebGLRenderingContext | WebGL2RenderingContext;
+	canvas?: HTMLCanvasElement;
+	cursorVisibility?: boolean;
+	cursor?: string;
+	textureUnitManager?: null;
+	textureResourceIds?: null;
+	containerSize?: Size;
+	renderPasses?: any[];
+	notifyStartCaptureImage?: boolean;
+	webgl2?: boolean;
+	defaultToWebgl2?: boolean;
+	activeFramebuffer?: any;
+	xrSession?: any;
+	xrSessionIsAR?: boolean;
+	xrReferenceSpace?: any;
+	xrSupported?: boolean;
+	imageFormat?: 'image/png';
+	useOffScreen?: boolean;
+	useBackgroundImage?: boolean;
 }
 
-export interface IOptions {
-	resetCamera: boolean,
-	size: Size,
+export interface ICaptureOptions {
+	resetCamera: boolean;
+	size: Size;
 	scale: number
 }
 
@@ -278,9 +296,9 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * size is assumed.  The default format is "image/png". Returns a promise
 	 * that resolves to the captured screenshot.
 	 * @param {String} format
-	 * @param {IOptions} options
+	 * @param {ICaptureOptions} options
 	 */
-	captureNextImage(format: string, options: IOptions): Nullable<Promise<string>>;
+	captureNextImage(format: string, options: ICaptureOptions): Nullable<Promise<string>>;
 
 	/**
 	 *

package/Widgets/Core/StateBuilder/manipulatorMixin.js

@@ -7,23 +7,23 @@ function vtkManipulatorMixin(publicAPI, model) {
           normal = model.normal,
           direction = model.direction;
       var _model$manipulator = model.manipulator,
-          setOrigin = _model$manipulator.setOrigin,
-          setCenter = _model$manipulator.setCenter,
-          setNormal = _model$manipulator.setNormal,
-          setDirection = _model$manipulator.setDirection;
-
-      if (origin && setOrigin) {
-        setOrigin(origin);
-      } else if (origin && setCenter) {
-        setCenter(origin);
+          setHandleOrigin = _model$manipulator.setHandleOrigin,
+          setHandleCenter = _model$manipulator.setHandleCenter,
+          setHandleNormal = _model$manipulator.setHandleNormal,
+          setHandleDirection = _model$manipulator.setHandleDirection;
+
+      if (origin && setHandleOrigin) {
+        setHandleOrigin(origin);
+      } else if (origin && setHandleCenter) {
+        setHandleCenter(origin);
       }
 
-      if (direction && setDirection) {
-        setDirection(direction);
-      } else if (direction && !normal && setNormal) {
-        setNormal(direction);
-      } else if (normal && setDirection) {
-        setDirection(normal);
+      if (direction && setHandleDirection) {
+        setHandleDirection(direction);
+      } else if (direction && !normal && setHandleNormal) {
+        setHandleNormal(direction);
+      } else if (normal && setHandleDirection) {
+        setHandleDirection(normal);
       }
     }
   };

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.d.ts

@@ -1,81 +1,15 @@
-import { vtkObject } from './../../interfaces';
+import { IAbstractManipulatorInitialValues, vtkAbstractManipulator } from './AbstractManipulator';
+import { Vector3 } from './../../types';
 
 /**
  *
  */
-export interface ILineManipulatorInitialValues {
-	origin?: number[];
-	normal?: number[];
-}
-
-export interface vtkLineManipulator extends vtkObject {
-
-	/**
-	 * Set the normal of the line
-	 */
-	getNormal(): number[];
-
-	/**
-	 * Set the normal of the line
-	 */
-	getNormalByReference(): number[];
-
-	/**
-	 * Set the origin of the line
-	 */
-	getOrigin(): number[];
-
-	/**
-	 * Set the origin of the line
-	 */
-	getOriginByReference(): number[];
+export interface ILineManipulatorInitialValues extends IAbstractManipulatorInitialValues {
 
-	/**
-	 * 
-	 * @param callData 
-	 * @param glRenderWindow 
-	 */
-	handleEvent(callData: any, glRenderWindow: any): number[];
-
-	/**
-	 * Set the normal of the line
-	 * @param {Number[]} normal The normal coordinate.
-	 */
-	setNormal(normal: number[]): boolean;
-
-	/**
-	 * Set the normal of the line
-	 * @param {Number} x The x coordinate.
-	 * @param {Number} y The y coordinate.
-	 * @param {Number} z The z coordinate.
-	 */
-	setNormal(x: number, y: number, z: number): boolean;
-
-	/**
-	 * Set the normal of the line
-	 * @param {Number[]} normal The normal coordinate.
-	 */
-	setNormalFrom(normal: number[]): boolean;
-
-	/**
-	 * Set the origin of the line.
-	 * @param {Number[]} origin The coordinate of the origin point.
-	 */
-	setOrigin(origin: number[]): boolean;
+}
 
-	/**
-	 * Set the origin of the line
-	 * @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.
-	 */
-	setOrigin(x: number, y: number, z: number): boolean;
+export interface vtkLineManipulator extends vtkAbstractManipulator {
 
-	/**
-	 * Set the origin of the line
-	 * @param {Number[]} origin The coordinate of the origin point.
-	 */
-	setOriginFrom(origin: number[]): boolean;
 }
 
 
@@ -97,12 +31,12 @@ export function newInstance(initialValues?: ILineManipulatorInitialValues): vtkL
  * 
  * @param {Number} x 
  * @param {Number} y 
- * @param {Number[]} lineOrigin 
- * @param {Number[]} lineDirection 
+ * @param {Vector3} lineOrigin 
+ * @param {Vector3} lineDirection 
  * @param renderer 
  * @param glRenderWindow 
  */
-export function projectDisplayToLine(x: number, y: number, lineOrigin: number[], lineDirection: number[], renderer: any, glRenderWindow: any): number[];
+export function projectDisplayToLine(x: number, y: number, lineOrigin: Vector3, lineDirection: Vector3, renderer: any, glRenderWindow: any): Vector3;
 
 /**
  * vtkLineManipulator.

package/Widgets/Manipulators/LineManipulator.js

@@ -1,6 +1,11 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { g as subtract, j as cross, d as dot, x as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
+import { s as subtract, j as cross, d as dot, x as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
+import vtkAbstractManipulator from './AbstractManipulator.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; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function projectDisplayToLine(x, y, lineOrigin, lineDirection, renderer, glRenderWindow) {
   var near = glRenderWindow.displayToWorld(x, y, 0, renderer);
   var far = glRenderWindow.displayToWorld(x, y, 1, renderer);
@@ -20,27 +25,25 @@ function projectDisplayToLine(x, y, lineOrigin, lineDirection, renderer, glRende
 // ----------------------------------------------------------------------------
 
 function vtkLineManipulator(publicAPI, model) {
-  // Set our classNae
-  model.classHierarchy.push('vtkLineManipulator'); // --------------------------------------------------------------------------
+  // Set our className
+  model.classHierarchy.push('vtkLineManipulator');
 
   publicAPI.handleEvent = function (callData, glRenderWindow) {
-    return projectDisplayToLine(callData.position.x, callData.position.y, model.origin, model.normal, callData.pokedRenderer, glRenderWindow);
+    return projectDisplayToLine(callData.position.x, callData.position.y, publicAPI.getOrigin(callData), publicAPI.getNormal(callData), callData.pokedRenderer, glRenderWindow);
   };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  origin: [0, 0, 0],
-  normal: [0, 0, 1]
-}; // ----------------------------------------------------------------------------
+function defaultValues(initialValues) {
+  return _objectSpread({}, initialValues);
+} // ----------------------------------------------------------------------------
+
 
 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.setGetArray(publicAPI, model, ['origin', 'normal'], 3);
+  vtkAbstractManipulator.extend(publicAPI, model, defaultValues(initialValues));
   vtkLineManipulator(publicAPI, model);
 } // ----------------------------------------------------------------------------