@kitware/vtk.js 21.1.5 → 21.3.0

package/Rendering/Core/Property.d.ts

@@ -1,5 +1,5 @@
 import { vtkObject } from '@kitware/vtk.js/interfaces';
-import { Color } from '@kitware/vtk.js/types';
+import { RGBColor } from '@kitware/vtk.js/types';
 
 export enum Shading {
 	FLAT,
@@ -19,12 +19,12 @@ export enum Interpolation {
 	PHONG,
 }
 
-interface IPropertyValues {
-	color?: Color;
-	ambientColor?: Color;
-	diffuseColor?: Color;
-	specularColor?: Color;
-	edgeColor?: Color;
+export interface IPropertyInitialValues {
+	color?: RGBColor;
+	ambientColor?: RGBColor;
+	diffuseColor?: RGBColor;
+	specularColor?: RGBColor;
+	edgeColor?: RGBColor;
 	ambient?: number;
 	diffuse?: number;
 	specular?: number;
@@ -63,14 +63,14 @@ export interface vtkProperty extends vtkObject {
 	 * and diffuse colors. From a physical standpoint it really doesn't make too
 	 * much sense to have both. For the rendering libraries that don't support
 	 * both, the diffuse color is used.
-	 * @return {Color} Array of RGB color.
+	 * @return {RGBColor} Array of RGB color.
 	 */
-	getAmbientColor(): Color;
+	getAmbientColor(): RGBColor;
 
 	/**
-	 * 
+	 * Get the ambient surface color.
 	 */
-	getAmbientColorByReference(): Color;
+	getAmbientColorByReference(): RGBColor;
 
 	/**
 	 * 
@@ -80,7 +80,7 @@ export interface vtkProperty extends vtkObject {
 	/**
 	 * Get the color of the object.the color of the object
 	 */
-	getColor(): Color;
+	getColor(): RGBColor;
 
 	/**
 	 * Get the diffuse lighting coefficient.
@@ -90,23 +90,23 @@ export interface vtkProperty extends vtkObject {
 
 	/**
 	 * Get the diffuse surface color.
-	 * @return {Color} Array of RGB color.
+	 * @return {RGBColor} Array of RGB color.
 	 */
-	getDiffuseColor(): Color;
+	getDiffuseColor(): RGBColor;
 	/**
 	 * 
 	 */
-	getDiffuseColorByReference(): Color;
+	getDiffuseColorByReference(): RGBColor;
 
 	/**
 	 * 
 	 */
-	getEdgeColor(): Color;
+	getEdgeColor(): RGBColor;
 
 	/**
 	 * 
 	 */
-	getEdgeColorByReference(): Color;
+	getEdgeColorByReference(): RGBColor;
 
 	/**
 	 * 
@@ -180,14 +180,14 @@ export interface vtkProperty extends vtkObject {
 
 	/**
 	 * Get the specular surface color.
-	 * @return {Color} Array of RGB color.
+	 * @return {RGBColor} Array of RGB color.
 	 */
-	getSpecularColor(): Color;
+	getSpecularColor(): RGBColor;
 
 	/**
-	 * 
+	 * Get the specular surface color.
 	 */
-	getSpecularColorByReference(): Color;
+	getSpecularColorByReference(): RGBColor;
 
 	/**
 	 * Get the specular power.
@@ -218,15 +218,15 @@ export interface vtkProperty extends vtkObject {
 	 * ambient and diffuse colors. From a physical standpoint it really
 	 * doesn't make too much sense to have both. For the rendering
 	 * libraries that don’t support both, the diffuse color is used.
-	 * @param {Color} ambientColor An Array of the RGB color.
+	 * @param {RGBColor} ambientColor An Array of the RGB color.
 	 */
-	setAmbientColor(ambientColor: Color): boolean;
+	setAmbientColor(ambientColor: RGBColor): boolean;
 
 	/**
 	 * Set the ambient surface color from an RGB array
-	 * @param {Color} ambientColor An Array of the RGB color.
+	 * @param {RGBColor} ambientColor An Array of the RGB color.
 	 */
-	setAmbientColorFrom(ambientColor: Color): boolean;
+	setAmbientColorFrom(ambientColor: RGBColor): boolean;
 
 	/**
 	 * Turn on/off fast culling of polygons based on orientation of normal
@@ -250,9 +250,9 @@ export interface vtkProperty extends vtkObject {
 	 * Set the color of the object. Has the side effect of setting the
 	 * ambient diffuse and specular colors as well. This is basically
 	 * a quick overall color setting method.
-	 * @param {Color} color An Array of the RGB color.
+	 * @param {RGBColor} color An Array of the RGB color.
 	 */
-	setColor(color: Color): boolean;
+	setColor(color: RGBColor): boolean;
 
 	/**
 	 * Set the diffuse lighting coefficient.
@@ -270,15 +270,15 @@ export interface vtkProperty extends vtkObject {
 
 	/**
 	 * Set the diffuse surface color.
-	 * @param {Color} diffuseColor An Array of the RGB color.
+	 * @param {RGBColor} diffuseColor An Array of the RGB color.
 	 */
-	setDiffuseColor(diffuseColor: Color): boolean;
+	setDiffuseColor(diffuseColor: RGBColor): boolean;
 
 	/**
 	 * Set the diffuse surface color from an RGB array
-	 * @param {Color} diffuseColor An Array of the RGB color.
+	 * @param {RGBColor} diffuseColor An Array of the RGB color.
 	 */
-	setDiffuseColorFrom(diffuseColor: Color): boolean;
+	setDiffuseColorFrom(diffuseColor: RGBColor): boolean;
 
 	/**
 	 * Set the color of primitive edges (if edge visibility is enabled).
@@ -290,15 +290,15 @@ export interface vtkProperty extends vtkObject {
 
 	/**
 	 * Set the color of primitive edges (if edge visibility is enabled).
-	 * @param {Color} edgeColor An Array of the RGB color.
+	 * @param {RGBColor} edgeColor An Array of the RGB color.
 	 */
-	setEdgeColor(edgeColor: Color): boolean;
+	setEdgeColor(edgeColor: RGBColor): boolean;
 
 	/**
 	 * Set the color of primitive edges from an RGB array.
-	 * @param {Color} edgeColor An Array of the RGB color.
+	 * @param {RGBColor} edgeColor An Array of the RGB color.
 	 */
-	setEdgeColorFrom(edgeColor: Color): boolean;
+	setEdgeColorFrom(edgeColor: RGBColor): boolean;
 
 	/**
 	 * Turn on/off the visibility of edges. On some renderers it is
@@ -412,15 +412,15 @@ export interface vtkProperty extends vtkObject {
 
 	/**
 	 * Set the specular surface color from an RGB array
-	 * @param {Color} specularColor An Array of the RGB color.
+	 * @param {RGBColor} specularColor An Array of the RGB color.
 	 */
-	setSpecularColor(specularColor: Color): boolean;
+	setSpecularColor(specularColor: RGBColor): boolean;
 
 	/**
 	 * Set the specular surface color from an RGB array
-	 * @param {Color} specularColor An Array of the RGB color.
+	 * @param {RGBColor} specularColor An Array of the RGB color.
 	 */
-	setSpecularColorFrom(specularColor: Color): boolean;
+	setSpecularColorFrom(specularColor: RGBColor): boolean;
 
 	/**
 	 * Set the specular power.
@@ -434,18 +434,18 @@ export interface vtkProperty extends vtkObject {
  *
  * @param publicAPI object on which methods will be bounds (public)
  * @param model object on which data structure will be bounds (protected)
- * @param {IPropertyValues} [initialValues] (default: {})
+ * @param {IPropertyInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPropertyValues): void;
+export function extend(publicAPI: object, model: object, initialValues?: IPropertyInitialValues): void;
 
 /**
  * Method use to create a new instance of vtkProperty with object color, ambient color, diffuse color,
  * specular color, and edge color white; ambient coefficient=0; diffuse
  * coefficient=0; specular coefficient=0; specular power=1; Gouraud shading;
  * and surface representation. Backface and frontface culling are off.
- * @param {IPropertyValues} [initialValues] for pre-setting some of its content
+ * @param {IPropertyInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IPropertyValues): vtkProperty;
+export function newInstance(initialValues?: IPropertyInitialValues): vtkProperty;
 
 /** 
  * vtkProperty is an object that represents lighting and other surface

package/Rendering/Core/Property2D/Constants.js

@@ -0,0 +1,9 @@
+var DisplayLocation = {
+  BACKGROUND: 0,
+  FOREGROUND: 1
+};
+var Constants = {
+  DisplayLocation: DisplayLocation
+};
+
+export { DisplayLocation, Constants as default };

package/Rendering/Core/Property2D.d.ts

@@ -1,8 +1,8 @@
 import { vtkObject } from '@kitware/vtk.js/interfaces';
-import { Color } from '@kitware/vtk.js/types';
+import { RGBColor } from '@kitware/vtk.js/types';
 
 interface IProperty2DInitialValues{
-	color?: number[];
+	color?: RGBColor;
 	opacity?: number;
 	pointSize?: number;
 	lineWidth?: number;
@@ -14,12 +14,12 @@ export interface vtkProperty2D extends vtkObject {
 	/**
 	 * Get the color of the object.
 	 */
-	getColor(): Color;
+	getColor(): RGBColor;
 
 	/**
 	 * Get the color of the object.
 	 */
-	getColorByReference(): Color;
+	getColorByReference(): RGBColor;
 
 	/**
 	 * Get the display location of the object.
@@ -54,6 +54,14 @@ export interface vtkProperty2D extends vtkObject {
 	 */
 	setColor(r: number, g: number, b: number): boolean;
 
+	/**
+	 * Set the color of the object. Has the side effect of setting the
+	 * ambient diffuse and specular colors as well. This is basically
+	 * a quick overall color setting method.
+	 * @param {RGBColor} color Defines the RGB color array..
+	 */
+	setColor(color: RGBColor): boolean;
+
 	/**
 	 * Set the color of the object. Has the side effect of setting the
 	 * ambient diffuse and specular colors as well. This is basically
@@ -62,7 +70,15 @@ export interface vtkProperty2D extends vtkObject {
 	 * @param {Number} g Defines the green component (between 0 and 1).
 	 * @param {Number} b Defines the blue component (between 0 and 1).
 	 */
-	setColorFrom(color: number[]): boolean;
+	setColorFrom(r: number, g: number, b: number): boolean;
+
+	/**
+	 * Set the color of the object. Has the side effect of setting the
+	 * ambient diffuse and specular colors as well. This is basically
+	 * a quick overall color setting method.
+	 * @param {RGBColor} color Defines the RGB color array..
+	 */
+	setColorFrom(color: RGBColor): boolean;
 
 	/**
 	 * Set the display location of the object.

package/Rendering/Core/Property2D.js

@@ -1,11 +1,38 @@
 import macro from '../../macros.js';
+import Constants from './Property2D/Constants.js';
+import { Representation } from './Property/Constants.js';
 
+var DisplayLocation = Constants.DisplayLocation; // ----------------------------------------------------------------------------
 // vtkProperty2D methods
 // ----------------------------------------------------------------------------
 
 function vtkProperty2D(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProperty2D');
+
+  publicAPI.setDisplayLocationToBackground = function () {
+    return publicAPI.setDisplayLocation(DisplayLocation.BACKGROUND);
+  };
+
+  publicAPI.setDisplayLocationToForeground = function () {
+    return publicAPI.setDisplayLocation(DisplayLocation.FOREGROUND);
+  };
+
+  publicAPI.setRepresentationToWireframe = function () {
+    return publicAPI.setRepresentation(Representation.WIREFRAME);
+  };
+
+  publicAPI.setRepresentationToSurface = function () {
+    return publicAPI.setRepresentation(Representation.SURFACE);
+  };
+
+  publicAPI.setRepresentationToPoints = function () {
+    return publicAPI.setRepresentation(Representation.POINTS);
+  };
+
+  publicAPI.getRepresentationAsString = function () {
+    return macro.enumToString(Representation, model.representation);
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -16,7 +43,8 @@ var DEFAULT_VALUES = {
   opacity: 1,
   pointSize: 1,
   lineWidth: 1,
-  displayLocation: 'Foreground'
+  representation: Representation.SURFACE,
+  displayLocation: DisplayLocation.FOREGROUND
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -24,7 +52,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['opacity', 'lineWidth', 'pointSize', 'displayLocation']);
+  macro.setGet(publicAPI, model, ['opacity', 'lineWidth', 'pointSize', 'displayLocation', 'representation']);
   macro.setGetArray(publicAPI, model, ['color'], 3); // Object methods
 
   vtkProperty2D(publicAPI, model);

package/Rendering/Core/RenderWindowInteractor.js

@@ -325,7 +325,7 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
     animationRequesters.add(requestor);
 
-    if (animationRequesters.size === 1) {
+    if (animationRequesters.size === 1 && !model.xrAnimation) {
       model.lastFrameTime = 0.1;
       model.lastFrameStart = Date.now();
       model.animationRequest = requestAnimationFrame(publicAPI.handleAnimation);
@@ -334,7 +334,7 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   };
 
   publicAPI.isAnimating = function () {
-    return model.vrAnimation || model.animationRequest !== null;
+    return model.xrAnimation || model.animationRequest !== null;
   };
 
   publicAPI.cancelAnimation = function (requestor) {
@@ -359,18 +359,18 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     }
   };
 
-  publicAPI.switchToVRAnimation = function () {
+  publicAPI.switchToXRAnimation = function () {
     // cancel existing animation if any
     if (model.animationRequest) {
       cancelAnimationFrame(model.animationRequest);
       model.animationRequest = null;
     }
 
-    model.vrAnimation = true;
+    model.xrAnimation = true;
   };
 
-  publicAPI.returnFromVRAnimation = function () {
-    model.vrAnimation = false;
+  publicAPI.returnFromXRAnimation = function () {
+    model.xrAnimation = false;
 
     if (animationRequesters.size !== 0) {
       model.FrameTime = -1;
@@ -723,7 +723,7 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
 
   publicAPI.render = function () {
-    if (model.animationRequest === null && !model.inRender) {
+    if (!publicAPI.isAnimating() && !model.inRender) {
       forceRender();
     }
   }; // create the generic Event methods

package/Rendering/Core/Volume.d.ts

@@ -121,6 +121,15 @@ export function newInstance(initialValues?: IVolumeInitialValues): vtkVolume;
  * 
  * @example
  * ```js
+ * // Load the rendering pieces we want to use (for both WebGL and WebGPU)
+ * import 'vtk.js/Sources/Rendering/Profiles/Volume';
+ * 
+ * import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+ * import vtkHttpDataSetReader from '@kitware/vtk.js/IO/Core/HttpDataSetReader';
+ * 
+ * import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+ * import vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
+
  * const vol = vtkVolume.newInstance();
  * const mapper = vtkVolumeMapper.newInstance();
  * mapper.setSampleDistance(2.0);

package/Rendering/Core.js

@@ -22,6 +22,7 @@ import vtkInteractorObserver from './Core/InteractorObserver.js';
 import vtkInteractorStyle from './Core/InteractorStyle.js';
 import vtkLight from './Core/Light.js';
 import vtkMapper from './Core/Mapper.js';
+import vtkMapper2D from './Core/Mapper2D.js';
 import vtkPicker from './Core/Picker.js';
 import vtkPixelSpaceCallbackMapper from './Core/PixelSpaceCallbackMapper.js';
 import vtkPointPicker from './Core/PointPicker.js';
@@ -70,6 +71,7 @@ var Core = {
   vtkInteractorStyle: vtkInteractorStyle,
   vtkLight: vtkLight,
   vtkMapper: vtkMapper,
+  vtkMapper2D: vtkMapper2D,
   vtkPicker: vtkPicker,
   vtkPixelSpaceCallbackMapper: vtkPixelSpaceCallbackMapper,
   vtkPointPicker: vtkPointPicker,

package/Rendering/OpenGL/Actor2D.js

@@ -21,52 +21,85 @@ function vtkOpenGLActor2D(publicAPI, model) {
       publicAPI.prepareNodes();
       publicAPI.addMissingNodes(model.renderable.getTextures());
       publicAPI.addMissingNode(model.renderable.getMapper());
-      publicAPI.removeUnusedNodes();
+      publicAPI.removeUnusedNodes(); // we store textures and mapper
+
+      model.ogltextures = null;
+      model.activeTextures = null;
+
+      for (var index = 0; index < model.children.length; index++) {
+        var child = model.children[index];
+
+        if (child.isA('vtkOpenGLTexture')) {
+          if (!model.ogltextures) {
+            model.ogltextures = [];
+          }
+
+          model.ogltextures.push(child);
+        } else {
+          model.oglmapper = child;
+        }
+      }
+    }
+  };
+
+  publicAPI.queryPass = function (prepass, renderPass) {
+    if (prepass) {
+      if (!model.renderable || !model.renderable.getVisibility()) {
+        return;
+      }
+
+      renderPass.incrementOverlayActorCount();
     }
   }; // we draw textures, then mapper, then post pass textures
 
 
   publicAPI.traverseOpaquePass = function (renderPass) {
-    if (!model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
+    if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
 
     publicAPI.apply(renderPass, true);
-    model.children.forEach(function (child) {
-      if (!child.isA('vtkOpenGLTexture')) {
-        child.traverse(renderPass);
-      }
-    });
+    model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
   }; // we draw textures, then mapper, then post pass textures
 
 
   publicAPI.traverseTranslucentPass = function (renderPass) {
-    if (!model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
+    if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
 
     publicAPI.apply(renderPass, true);
-    model.children.forEach(function (child) {
-      if (!child.isA('vtkOpenGLTexture')) {
-        child.traverse(renderPass);
-      }
-    });
+    model.oglmapper.traverse(renderPass);
+    publicAPI.apply(renderPass, false);
+  };
+
+  publicAPI.traverseOverlayPass = function (renderPass) {
+    if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable) {
+      return;
+    }
+
+    publicAPI.apply(renderPass, true);
+    model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
   };
 
   publicAPI.activateTextures = function () {
     // always traverse textures first, then mapper
+    if (!model.ogltextures) {
+      return;
+    }
+
     model.activeTextures = [];
-    model.children.forEach(function (child) {
-      if (child.isA('vtkOpenGLTexture')) {
-        child.render();
 
-        if (child.getHandle()) {
-          model.activeTextures.push(child);
-        }
+    for (var index = 0; index < model.ogltextures.length; index++) {
+      var child = model.ogltextures[index];
+      child.render();
+
+      if (child.getHandle()) {
+        model.activeTextures.push(child);
       }
-    });
+    }
   }; // Renders myself
 
 
@@ -74,11 +107,11 @@ function vtkOpenGLActor2D(publicAPI, model) {
     if (prepass) {
       model.context.depthMask(true);
       publicAPI.activateTextures();
-    } else {
+    } else if (model.activeTextures) {
       // deactivate textures
-      model.activeTextures.forEach(function (child) {
-        child.deactivate();
-      });
+      for (var index = 0; index < model.activeTextures.length; index++) {
+        model.activeTextures[index].deactivate();
+      }
     }
   }; // Renders myself
 
@@ -87,12 +120,23 @@ function vtkOpenGLActor2D(publicAPI, model) {
     if (prepass) {
       model.context.depthMask(false);
       publicAPI.activateTextures();
-    } else {
-      // deactivate textures
-      model.activeTextures.forEach(function (child) {
-        child.deactivate();
-      });
+    } else if (model.activeTextures) {
+      for (var index = 0; index < model.activeTextures.length; index++) {
+        model.activeTextures[index].deactivate();
+      }
+    }
+  }; // Renders myself
+
+
+  publicAPI.overlayPass = function (prepass, renderPass) {
+    if (prepass) {
       model.context.depthMask(true);
+      publicAPI.activateTextures();
+    } else if (model.activeTextures) {
+      // deactivate textures
+      for (var index = 0; index < model.activeTextures.length; index++) {
+        model.activeTextures[index].deactivate();
+      }
     }
   };
 } // ----------------------------------------------------------------------------
@@ -102,7 +146,7 @@ function vtkOpenGLActor2D(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   context: null,
-  activeTextures: []
+  activeTextures: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Rendering/OpenGL/ForwardPass.js

@@ -35,6 +35,7 @@ function vtkForwardPass(publicAPI, model) {
           model.opaqueActorCount = 0;
           model.translucentActorCount = 0;
           model.volumeCount = 0;
+          model.overlayActorCount = 0;
           publicAPI.setCurrentOperation('queryPass');
           renNode.traverse(publicAPI); // do we need to capture a zbuffer?
 
@@ -79,6 +80,11 @@ function vtkForwardPass(publicAPI, model) {
             publicAPI.setCurrentOperation('volumePass');
             renNode.traverse(publicAPI);
           }
+
+          if (model.overlayActorCount > 0) {
+            publicAPI.setCurrentOperation('overlayPass');
+            renNode.traverse(publicAPI);
+          }
         }
       }
     }
@@ -107,6 +113,10 @@ function vtkForwardPass(publicAPI, model) {
   publicAPI.incrementVolumeCount = function () {
     return model.volumeCount++;
   };
+
+  publicAPI.incrementOverlayActorCount = function () {
+    return model.overlayActorCount++;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -116,6 +126,7 @@ var DEFAULT_VALUES = {
   opaqueActorCount: 0,
   translucentActorCount: 0,
   volumeCount: 0,
+  overlayActorCount: 0,
   framebuffer: null,
   depthRequested: false
 }; // ----------------------------------------------------------------------------

package/Rendering/OpenGL/ImageMapper.js

@@ -396,7 +396,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       }
 
       cellBO.getProgram().setUniformi('numClipPlanes', numClipPlanes);
-      cellBO.getProgram().setUniform4fv('clipPlanes', 6, planeEquations);
+      cellBO.getProgram().setUniform4fv('clipPlanes', planeEquations);
     }
   };