@kitware/vtk.js 24.12.0 → 24.13.1

package/BREAKING_CHANGES.md

@@ -1,6 +1,6 @@
 ## From 23.x to 24
 
-All old-style widgets except OrientationMarkerWidget and PiecewiseGaussianWidget have been removed.
+- All old-style widgets except OrientationMarkerWidget and PiecewiseGaussianWidget have been removed.
 
 | **Old-style/deprecated widget**   | **New-style widget**            |
 |-----------------------------------|---------------------------------|
@@ -15,6 +15,16 @@ All old-style widgets except OrientationMarkerWidget and PiecewiseGaussianWidget
 | ResliceCursor                     | ResliceCursorWidget             |
 
 - In SVGLandmarkRepresentation: `model.showCircle` is replaced by `model.circleProps.visible`
+- In vtk.js subclasses, prefix with '_' the following "protected" model variables:
+  - vtk*: model.openglRenderWindow -> model._openglRenderWindow
+  - vtk*: model.openglRenderer -> model._openglRenderer
+  - vtkInteractorObserver, vtkOrientationMarkerWidget : model.interactor -> model._interactor
+  - vtkAbstractWidget, vtkViewNode: model.parent -> model._parent
+  - vtkProp: model.parentProp -> model._parentProp
+  - vtkRenderWindowInteractor: model.view -> model._view
+  - vtkRenderer: model.renderWindow -> model._renderWindow
+  - vtkHardwareSelector: model.renderer -> model._renderer
+  - vtkAbstractWidget: model.widgetManager -> model._widgetManager
 
 ## From 22.x to 23
 

package/Common/Core/Math/index.js

@@ -34,13 +34,8 @@ function vtkSwapVectors3(v1, v2) {
 
 function createArray() {
   var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;
-  var array = [];
-
-  while (array.length < size) {
-    array.push(0);
-  }
-
-  return array;
+  // faster than Array.from and/or while loop
+  return Array(size).fill(0);
 } // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------

package/Interaction/Style/InteractorStyleManipulator.js

@@ -42,13 +42,16 @@ function dollyToPosition(fact, position, renderer, rwi) {
 
   if (cam.getParallelProjection()) {
     // Zoom relatively to the cursor
-    var aSize = rwi.getView().getViewportSize(renderer);
+    var view = rwi.getView();
+    var aSize = view.getViewportSize(renderer);
+    var viewport = renderer.getViewport();
+    var viewSize = view.getSize();
     var w = aSize[0];
     var h = aSize[1];
     var x0 = w / 2;
     var y0 = h / 2;
-    var x1 = position.x;
-    var y1 = position.y;
+    var x1 = position.x - viewport[0] * viewSize[0];
+    var y1 = position.y - viewport[1] * viewSize[1];
     translateCamera(renderer, rwi, x0, y0, x1, y1);
     cam.setParallelScale(cam.getParallelScale() / fact);
     translateCamera(renderer, rwi, x1, y1, x0, y0);

package/Rendering/Core/Camera.js

@@ -27,6 +27,7 @@ function vtkCamera(publicAPI, model) {
   var dopbasis = new Float64Array([0.0, 0.0, -1.0]);
   var upbasis = new Float64Array([0.0, 1.0, 0.0]);
   var tmpMatrix = mat4.identity(new Float64Array(16));
+  var tmpMatrix2 = mat4.identity(new Float64Array(16));
   var tmpvec1 = new Float64Array(3);
   var tmpvec2 = new Float64Array(3);
   var tmpvec3 = new Float64Array(3);
@@ -60,6 +61,7 @@ function vtkCamera(publicAPI, model) {
     model.position[2] = z; // recompute the focal distance
 
     publicAPI.computeDistance();
+    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   };
 
@@ -73,6 +75,7 @@ function vtkCamera(publicAPI, model) {
     model.focalPoint[2] = z; // recompute the focal distance
 
     publicAPI.computeDistance();
+    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   };
 
@@ -94,6 +97,7 @@ function vtkCamera(publicAPI, model) {
     model.focalPoint[0] = model.position[0] + vec[0] * model.distance;
     model.focalPoint[1] = model.position[1] + vec[1] * model.distance;
     model.focalPoint[2] = model.position[2] + vec[2] * model.distance;
+    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   }; //----------------------------------------------------------------------------
   // This method must be called when the focal point or camera position changes
@@ -293,7 +297,20 @@ function vtkCamera(publicAPI, model) {
   publicAPI.getFrustumPlanes = function (aspect) {// Return array of 24 params (4 params for each of 6 plane equations)
   };
 
-  publicAPI.getCameraLightTransformMatrix = function () {};
+  publicAPI.getCameraLightTransformMatrix = function (matrix) {
+    mat4.copy(matrix, model.cameraLightTransform);
+    return matrix;
+  };
+
+  publicAPI.computeCameraLightTransform = function () {
+    // not sure if this is the correct transformation, based on the same funciton in VTK
+    mat4.copy(tmpMatrix, publicAPI.getViewMatrix());
+    mat4.invert(tmpMatrix, tmpMatrix);
+    mat4.fromScaling(tmpMatrix2, [model.distance, model.distance, model.distance]);
+    mat4.multiply(tmpMatrix, tmpMatrix, tmpMatrix2);
+    mat4.identity(model.cameraLightTransform);
+    mat4.translate(model.cameraLightTransform, tmpMatrix, [0.0, 0.0, -1.0]);
+  };
 
   publicAPI.deepCopy = function (sourceCamera) {};
 
@@ -602,6 +619,7 @@ var DEFAULT_VALUES = {
   freezeFocalPoint: false,
   projectionMatrix: null,
   viewMatrix: null,
+  cameraLightTransform: mat4.create(),
   // used for world to physical transformations
   physicalTranslation: [0, 0, 0],
   physicalScale: 1.0,

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

@@ -0,0 +1,17 @@
+export declare enum ColorSpace {
+  RGB = 0,
+  HSV = 1,
+  LAB = 2,
+  DIVERGING = 3,
+}
+
+export declare enum Scale {
+  LINEAR = 0,
+  LOG10 = 1,
+}
+
+declare const _default: {
+	ColorSpace: typeof ColorSpace;
+	Scale: typeof Scale;
+};
+export default _default;

package/Rendering/Core/ColorTransferFunction.d.ts

@@ -1,16 +1,6 @@
 import { vtkObject } from './../../interfaces';
+import { ColorSpace, Scale } from './ColorTransferFunction/Constants';
 
-export enum ColorSpace {
-  RGB,
-  HSV,
-  LAB,
-  DIVERGING,
-}
-
-export enum Scale {
-  LINEAR,
-  LOG10,
-}
 
 /* TODO: use VtkScalarsToColors instead of VtkObject */
 export interface vtkColorTransferFunction extends vtkObject {
@@ -358,5 +348,7 @@ export function newInstance(initialValues?: object): vtkColorTransferFunction;
 export declare const vtkColorTransferFunction: {
   newInstance: typeof newInstance;
   extend: typeof extend;
+  ColorSpace: typeof ColorSpace;
+  Scale: typeof Scale;
 };
 export default vtkColorTransferFunction;

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

@@ -0,0 +1,14 @@
+export declare enum Coordinate {
+  DISPLAY = 0,
+  NORMALIZED_DISPLAY = 1,
+  VIEWPORT = 2,
+  NORMALIZED_VIEWPORT = 3,
+  PROJECTION = 4,
+  VIEW = 5,
+  WORLD = 6,
+}
+
+declare const _default: {
+	Coordinate: typeof Coordinate;
+};
+export default _default;

package/Rendering/Core/Coordinate.d.ts

@@ -1,15 +1,7 @@
 import { vtkObject, vtkProperty } from './../../interfaces';
 import vtkRenderer from './Renderer';
+import { Coordinate } from './Coordinate/Constants';
 
-export enum Coordinate {
-	DISPLAY,
-	NORMALIZED_DISPLAY,
-	VIEWPORT,
-	NORMALIZED_VIEWPORT,
-	PROJECTION,
-	VIEW,
-	WORLD,
-}
 
 /**
  *
@@ -73,7 +65,7 @@ export interface vtkCoordinate extends vtkObject {
 	 * options are Display, Normalized Display, Viewport, Normalized Viewport,
 	 * View, and World.
 	 */
-	getCoordinateSystem(): number;
+	getCoordinateSystem(): Coordinate;
 
 	/**
 	 * Get the coordinate system which this coordinate is defined in as string.
@@ -251,7 +243,8 @@ export function newInstance(initialValues?: ICoordinateInitialValues): vtkCoordi
  * @see [vtkActor](./Rendering_Core_Actor.html)2D
  */
 export declare const vtkCoordinate: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	Coordinate: typeof Coordinate;
 };
 export default vtkCoordinate;

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

@@ -0,0 +1,17 @@
+export declare enum OrientationModes {
+	DIRECTION = 0,
+	ROTATION = 1,
+	MATRIX = 2,
+}
+
+export declare enum ScaleModes {
+	SCALE_BY_CONSTANT = 0,
+	SCALE_BY_MAGNITUDE = 1,
+	SCALE_BY_COMPONENTS = 2,
+}
+
+declare const _default: {
+	OrientationModes: typeof OrientationModes;
+	ScaleModes: typeof ScaleModes;
+};
+export default _default;

package/Rendering/Core/Glyph3DMapper.d.ts

@@ -1,17 +1,7 @@
 import { Bounds } from './../../types';
 import vtkMapper, { IMapperInitialValues } from './Mapper';
+import { OrientationModes, ScaleModes } from './Glyph3DMapper/Constants';
 
-export enum OrientationModes {
-	DIRECTION,
-	ROTATION,
-	MATRIX,
-}
-
-export enum ScaleModes {
-	SCALE_BY_CONSTANT,
-	SCALE_BY_MAGNITUDE,
-	SCALE_BY_COMPONENTS,
-}
 
 interface IPrimitiveCount {
 	points: number;
@@ -168,5 +158,7 @@ export function newInstance(initialValues?: IGlyph3DMapperInitialValues): vtkGly
 export declare const vtkGlyph3DMapper: {
 	newInstance: typeof newInstance;
 	extend: typeof extend;
+	OrientationModes: typeof OrientationModes;
+	ScaleModes: typeof ScaleModes;
 }
 export default vtkGlyph3DMapper;

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

@@ -0,0 +1,14 @@
+export declare enum SlicingMode {
+	NONE = -1,
+	I = 0,
+	J = 1,
+	K = 2,
+	X = 3,
+	Y = 4,
+	Z = 5,
+}
+
+declare const _default: {
+	SlicingMode: typeof SlicingMode;
+};
+export default _default;

package/Rendering/Core/ImageMapper.d.ts

@@ -1,16 +1,8 @@
 import vtkCamera from './Camera';
 import vtkAbstractMapper, { IAbstractMapperInitialValues } from './AbstractMapper';
 import { Bounds, Vector3 } from './../../types';
+import { SlicingMode } from './ImageMapper/Constants';
 
-export enum SlicingMode {
-	NONE,
-	I,
-	J,
-	K,
-	X,
-	Y,
-	Z,
-}
 
 interface IClosestIJKAxis {
 	ijkMode: SlicingMode,
@@ -325,5 +317,6 @@ export function newInstance(initialValues?: IImageMapperInitialValues): vtkImage
 export declare const vtkImageMapper: {
 	newInstance: typeof newInstance;
 	extend: typeof extend;
+	SlicingMode: typeof SlicingMode;
 }
 export default vtkImageMapper;

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

@@ -0,0 +1,9 @@
+export declare enum InterpolationType {
+	NEAREST = 0,
+	LINEAR = 1,
+}
+
+declare const _default: {
+	InterpolationType: typeof InterpolationType;
+};
+export default _default;

package/Rendering/Core/ImageProperty.d.ts

@@ -1,17 +1,14 @@
 import { vtkObject } from './../../interfaces';
 import vtkColorTransferFunction from './ColorTransferFunction';
-
-export enum InterpolationType {
-	NEAREST,
-	LINEAR,
-}
+import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
+import { InterpolationType } from './ImageProperty/Constants';
 
 interface IComponentData {
 	piecewiseFunction: number;
 	componentWeight: number;
 }
 
-export interface IImageMapperInitialValues {
+export interface IImagePropertyInitialValues {
 	independentComponents?: boolean;
 	interpolationType?: InterpolationType;
 	colorWindow?: number;
@@ -20,13 +17,13 @@ export interface IImageMapperInitialValues {
 	diffuse?: number;
 	opacity?: number;
 	componentData?: IComponentData[];
-        useLookupTableScalarRange?: boolean;
+	useLookupTableScalarRange?: boolean;
 }
 
 export interface vtkImageProperty extends vtkObject {
 
 	/**
-     * Get the lighting coefficient.
+	 * Get the lighting coefficient.
 	 * @default 1.0
 	 */
 	getAmbient(): number;
@@ -50,7 +47,7 @@ export interface vtkImageProperty extends vtkObject {
 	getComponentWeight(index: number): number;
 
 	/**
-     * Get the diffuse lighting coefficient.
+	 * Get the diffuse lighting coefficient.
 	 * @default 1.0
 	 */
 	getDiffuse(): number;
@@ -72,7 +69,7 @@ export interface vtkImageProperty extends vtkObject {
 	getInterpolationTypeAsString(): string;
 
 	/**
-     * Get the opacity of the object.
+	 * Get the opacity of the object.
 	 * @default 1.0
 	 */
 	getOpacity(): number;
@@ -81,25 +78,25 @@ export interface vtkImageProperty extends vtkObject {
 	 * Get the component weighting function.
 	 * @param {Number} [idx]
 	 */
-	getPiecewiseFunction(idx?: number): any;
+	getPiecewiseFunction(idx?: number): vtkPiecewiseFunction;
 
 	/**
 	 * Get the currently set RGB transfer function.
 	 * @param {Number} [idx]
 	 */
-	getRGBTransferFunction(idx?: number): any;
+	getRGBTransferFunction(idx?: number): vtkColorTransferFunction;
 
 	/**
 	 * Alias to get the piecewise function (backwards compatibility)
 	 * @param {Number} [idx]
 	 */
-	getScalarOpacity(idx: number): number;
+	getScalarOpacity(idx?: number): vtkPiecewiseFunction;
 
-    /**
+	/**
 	 * Set the ambient lighting coefficient.
-     * @param {Number} ambient The ambient lighting coefficient.
-     */
-    setAmbient(ambient: number): boolean;
+	 * @param {Number} ambient The ambient lighting coefficient.
+	 */
+	setAmbient(ambient: number): boolean;
 
 	/**
 	 * Set the level value for window/level.
@@ -120,11 +117,11 @@ export interface vtkImageProperty extends vtkObject {
 	 */
 	setComponentWeight(index: number, value: number): boolean;
 
-    /**
-     * Set the diffuse lighting coefficient.
-     * @param {Number} diffuse  The diffuse lighting coefficient.
-     */
-    setDiffuse(diffuse: number): boolean;
+	/**
+	 * Set the diffuse lighting coefficient.
+	 * @param {Number} diffuse  The diffuse lighting coefficient.
+	 */
+	setDiffuse(diffuse: number): boolean;
 
 	/**
 	 * 
@@ -149,7 +146,7 @@ export interface vtkImageProperty extends vtkObject {
 	setInterpolationTypeToNearest(): boolean;
 
 	/**
-     * Set the opacity of the object
+	 * Set the opacity of the object
 	 * @param {Number} opacity The opacity value.
 	 */
 	setOpacity(opacity: number): boolean;
@@ -157,9 +154,9 @@ export interface vtkImageProperty extends vtkObject {
 	/**
 	 * Set the piecewise function
 	 * @param {Number} index 
-	 * @param func 
+	 * @param {vtkPiecewiseFunction} func 
 	 */
-	setPiecewiseFunction(index: number, func: any): boolean;
+	setPiecewiseFunction(index: number, func: vtkPiecewiseFunction): boolean;
 
 	/**
 	 * Set the color of a volume to an RGB transfer function
@@ -171,14 +168,14 @@ export interface vtkImageProperty extends vtkObject {
 	/**
 	 * Alias to set the piecewise function
 	 * @param {Number} index 
-	 * @param func 
+	 * @param {vtkPiecewiseFunction} func 
 	 */
-	setScalarOpacity(index: any, func: any): boolean;
+	setScalarOpacity(index: number, func: vtkPiecewiseFunction): boolean;
 
 	/**
 	 * Use the range that is set on the lookup table, instead of setting the range from the
-         * ColorWindow/ColorLevel settings
-         * @default false
+		 * ColorWindow/ColorLevel settings
+		 * @default false
 	 * @param {Boolean} useLookupTableScalarRange
 	 */
 	setUseLookupTableScalarRange(useLookupTableScalarRange: boolean): boolean;
@@ -189,15 +186,15 @@ export interface vtkImageProperty extends vtkObject {
  *
  * @param publicAPI object on which methods will be bounds (public)
  * @param model object on which data structure will be bounds (protected)
- * @param {IImageMapperInitialValues} [initialValues] (default: {})
+ * @param {IImagePropertyInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IImageMapperInitialValues): void;
+export function extend(publicAPI: object, model: object, initialValues?: IImagePropertyInitialValues): void;
 
 /**
  * Method use to create a new instance of vtkImageProperty
- * @param {IImageMapperInitialValues} [initialValues] for pre-setting some of its content
+ * @param {IImagePropertyInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IImageMapperInitialValues): vtkImageProperty;
+export function newInstance(initialValues?: IImagePropertyInitialValues): vtkImageProperty;
 
 /**
  * vtkImageProperty provides 2D image display support for vtk.

package/Rendering/Core/Light.js

@@ -1,5 +1,6 @@
 import macro from '../../macros.js';
 import { l as normalize, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { vec3 } from 'gl-matrix';
 
 var LIGHT_TYPES = ['HeadLight', 'CameraLight', 'SceneLight']; // ----------------------------------------------------------------------------
 // vtkLight methods
@@ -8,21 +9,26 @@ var LIGHT_TYPES = ['HeadLight', 'CameraLight', 'SceneLight']; // ---------------
 function vtkLight(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLight');
+  var tmpVec = new Float64Array(3);
 
   publicAPI.getTransformedPosition = function () {
     if (model.transformMatrix) {
-      return []; // FIXME !!!!
+      vec3.transformMat4(tmpVec, model.position, model.transformMatrix);
+    } else {
+      vec3.set(tmpVec, model.position[0], model.position[1], model.position[2]);
     }
 
-    return [].concat(model.position);
+    return tmpVec;
   };
 
   publicAPI.getTransformedFocalPoint = function () {
     if (model.transformMatrix) {
-      return []; // FIXME !!!!
+      vec3.transformMat4(tmpVec, model.focalPoint, model.transformMatrix);
+    } else {
+      vec3.set(tmpVec, model.focalPoint[0], model.focalPoint[1], model.focalPoint[2]);
     }
 
-    return [].concat(model.focalPoint);
+    return tmpVec;
   };
 
   publicAPI.getDirection = function () {
@@ -96,7 +102,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['intensity', 'switch', 'positional', 'exponent', 'coneAngle', 'transformMatrix', 'lightType', 'shadowAttenuation']);
+  macro.setGet(publicAPI, model, ['intensity', 'switch', 'positional', 'exponent', 'coneAngle', 'transformMatrix', 'lightType', 'shadowAttenuation', 'attenuationValues']);
   macro.setGetArray(publicAPI, model, ['color', 'position', 'focalPoint', 'attenuationValues'], 3); // Object methods
 
   vtkLight(publicAPI, model);

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

@@ -1,12 +1,13 @@
 import { vtkObject } from './../../interfaces';
 import { RGBColor } from './../../types';
+import { DisplayLocation } from './Property2D/Constants';
 
 interface IProperty2DInitialValues{
 	color?: RGBColor;
 	opacity?: number;
 	pointSize?: number;
 	lineWidth?: number;
-	displayLocation?: string;
+	displayLocation?: DisplayLocation;
 }
 
 export interface vtkProperty2D extends vtkObject {
@@ -25,7 +26,7 @@ export interface vtkProperty2D extends vtkObject {
 	 * Get the display location of the object.
 	 * @default 'Foreground'
 	 */
-	getDisplayLocation(): string;
+	getDisplayLocation(): DisplayLocation;
 
 	/**
 	 * Get the width of a Line. 
@@ -84,7 +85,7 @@ export interface vtkProperty2D extends vtkObject {
 	 * Set the display location of the object.
 	 * @param {String} displayLocation
 	 */
-	setDisplayLocation(displayLocation: string): boolean;
+	setDisplayLocation(displayLocation: DisplayLocation): boolean;
 
 	/**
 	 * Set the width of a Line. The width is expressed in screen units.
@@ -138,7 +139,7 @@ export function newInstance(initialValues?: IProperty2DInitialValues): vtkProper
  * like backface properties can be set and manipulated with this object.
  */
 export declare const vtkProperty2D: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+	newInstance: typeof newInstance;
+	extend: typeof extend;
 };
 export default vtkProperty2D;

package/Rendering/Core/Renderer.js

@@ -55,11 +55,13 @@ function vtkRenderer(publicAPI, model) {
     // another renderer is setting up.
     var camera = publicAPI.getActiveCameraAndResetIfCreated();
     model.lights.forEach(function (light) {
-      if (light.lightTypeIsSceneLight() || light.lightTypeIsCameraLight()) ; else if (light.lightTypeIsHeadLight()) {
+      if (light.lightTypeIsSceneLight()) ; else if (light.lightTypeIsHeadLight()) {
         // update position and orientation of light to match camera.
         light.setPositionFrom(camera.getPositionByReference());
         light.setFocalPointFrom(camera.getFocalPointByReference());
         light.modified(camera.getMTime());
+      } else if (light.lightTypeIsCameraLight()) {
+        light.setTransformMatrix(camera.getCameraLightTransformMatrix(mat4.create()));
       } else {
         vtkErrorMacro('light has unknown light type', light.get());
       }