@kitware/vtk.js 24.13.0 → 24.14.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/Actor.js

@@ -165,6 +165,12 @@ function vtkActor(publicAPI, model) {
   publicAPI.getSupportsSelection = function () {
     return model.mapper ? model.mapper.getSupportsSelection() : false;
   };
+
+  publicAPI.processSelectorPixelBuffers = function (selector, pixelOffsets) {
+    if (model.mapper && model.mapper.processSelectorPixelBuffers) {
+      model.mapper.processSelectorPixelBuffers(selector, pixelOffsets);
+    }
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

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/Mapper.js

@@ -8,10 +8,13 @@ import { N as createUninitializedBounds, i as isNan } from '../../Common/Core/Ma
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors/Constants.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import Constants from './Mapper/Constants.js';
+import vtkDataSet from '../../Common/DataModel/DataSet.js';
+import { PassTypes } from '../OpenGL/HardwareSelector/Constants.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; }
+var FieldAssociations = vtkDataSet.FieldAssociations;
 var staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
     otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods;
 var ColorMode = Constants.ColorMode,
@@ -455,6 +458,64 @@ function vtkMapper(publicAPI, model) {
   publicAPI.colorToValue = notImplemented('ColorToValue');
   publicAPI.useInvertibleColorFor = notImplemented('UseInvertibleColorFor');
   publicAPI.clearInvertibleColor = notImplemented('ClearInvertibleColor');
+
+  publicAPI.processSelectorPixelBuffers = function (selector, pixelOffsets) {
+    /* eslint-disable no-bitwise */
+    if (!selector || !model.selectionWebGLIdsToVTKIds || !model.populateSelectionSettings) {
+      return;
+    }
+
+    var rawLowData = selector.getRawPixelBuffer(PassTypes.ID_LOW24);
+    var rawHighData = selector.getRawPixelBuffer(PassTypes.ID_HIGH24);
+    var currentPass = selector.getCurrentPass();
+    var fieldAssociation = selector.getFieldAssociation();
+    var idMap = null;
+
+    if (fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_POINTS) {
+      idMap = model.selectionWebGLIdsToVTKIds.points;
+    } else if (fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_CELLS) {
+      idMap = model.selectionWebGLIdsToVTKIds.cells;
+    }
+
+    if (!idMap) {
+      return;
+    }
+
+    pixelOffsets.forEach(function (pos) {
+      if (currentPass === PassTypes.ID_LOW24) {
+        var inValue = 0;
+
+        if (rawHighData) {
+          inValue += rawHighData[pos];
+          inValue *= 256;
+        }
+
+        inValue += rawLowData[pos + 2];
+        inValue *= 256;
+        inValue += rawLowData[pos + 1];
+        inValue *= 256;
+        inValue += rawLowData[pos];
+        var outValue = idMap[inValue];
+        var lowData = selector.getPixelBuffer(PassTypes.ID_LOW24);
+        lowData[pos] = outValue & 0xff;
+        lowData[pos + 1] = (outValue & 0xff00) >> 8;
+        lowData[pos + 2] = (outValue & 0xff0000) >> 16;
+      } else if (currentPass === PassTypes.ID_HIGH24 && rawHighData) {
+        var _inValue = 0;
+        _inValue += rawHighData[pos];
+        _inValue *= 256;
+        _inValue += rawLowData[pos];
+        _inValue *= 256;
+        _inValue += rawLowData[pos + 1];
+        _inValue *= 256;
+        _inValue += rawLowData[pos + 2];
+        var _outValue = idMap[_inValue];
+        var highData = selector.getPixelBuffer(PassTypes.ID_HIGH24);
+        highData[pos] = (_outValue & 0xff000000) >> 24;
+      }
+    });
+    /* eslint-enable no-bitwise */
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -475,6 +536,8 @@ var DEFAULT_VALUES = {
   renderTime: 0,
   colorByArrayName: null,
   fieldDataTupleId: -1,
+  populateSelectionSettings: true,
+  selectionWebGLIdsToVTKIds: null,
   interpolateScalarsBeforeMapping: false,
   colorCoordinates: null,
   colorTextureMap: null,
@@ -491,7 +554,7 @@ function extend(publicAPI, model) {
 
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['colorCoordinates', 'colorMapColors', 'colorTextureMap']);
-  macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'renderTime', 'scalarMode', 'scalarVisibility', 'static', 'useLookupTableScalarRange', 'viewSpecificProperties', 'customShaderAttributes' // point data array names that will be transferred to the VBO
+  macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'populateSelectionSettings', 'renderTime', 'scalarMode', 'scalarVisibility', 'selectionWebGLIdsToVTKIds', 'static', 'useLookupTableScalarRange', 'viewSpecificProperties', 'customShaderAttributes' // point data array names that will be transferred to the VBO
   ]);
   macro.setGetArray(publicAPI, model, ['scalarRange'], 2);
 

package/Rendering/Core/Prop.js

@@ -27,6 +27,8 @@ function vtkProp(publicAPI, model) {
     return m1;
   };
 
+  publicAPI.processSelectorPixelBuffers = function (selector, pixeloffsets) {};
+
   publicAPI.getNestedProps = function () {
     return null;
   };

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;