@kitware/vtk.js 25.3.0 → 25.6.0

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -218,6 +218,10 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
 
   publicAPI.handleMouseRotate = function (renderer, position) {
+    if (!model.previousPosition) {
+      return;
+    }
+
     var rwi = model._interactor;
     var dx = position.x - model.previousPosition.x;
     var dy = position.y - model.previousPosition.y;
@@ -251,6 +255,10 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
 
   publicAPI.handleMouseSpin = function (renderer, position) {
+    if (!model.previousPosition) {
+      return;
+    }
+
     var rwi = model._interactor;
     var camera = renderer.getActiveCamera();
     var center = rwi.getView().getViewportCenter(renderer);
@@ -265,6 +273,10 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
 
   publicAPI.handleMousePan = function (renderer, position) {
+    if (!model.previousPosition) {
+      return;
+    }
+
     var camera = renderer.getActiveCamera(); // Calculate the focal depth since we'll be using it a lot
 
     var viewFocus = camera.getFocalPoint();
@@ -291,6 +303,10 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
 
   publicAPI.handleMouseDolly = function (renderer, position) {
+    if (!model.previousPosition) {
+      return;
+    }
+
     var dy = position.y - model.previousPosition.y;
     var rwi = model._interactor;
     var center = rwi.getView().getViewportCenter(renderer);

package/README.md

@@ -48,8 +48,8 @@ In general VTK tries to be as portable as possible; the specific configurations
 
 vtk.js supports the following development environments:
 
-- Node 12+
-- NPM 6+
+- Node 14+
+- NPM 7+
 
 and we use [@babel/preset-env](https://www.npmjs.com/package/@babel/preset-env) with the [defaults](https://github.com/Kitware/vtk-js/blob/master/.browserslistrc) set of [browsers target](https://browserl.ist/?q=defaults).
 But when built from source this could be adjusted to support any browser as long they provide WebGL.

package/Rendering/Core/Actor2D.d.ts

@@ -1,7 +1,7 @@
 import vtkProp, { IPropInitialValues } from './Prop';
 import vtkCoordinate from './Coordinate';
 import vtkMapper from './Mapper';
-import vtkProperty from './Property';
+import vtkProperty2D, { IProperty2DInitialValues } from './Property2D';
 import { Bounds } from './../../types';
 
 /**
@@ -9,7 +9,7 @@ import { Bounds } from './../../types';
  */
 export interface IActor2DInitialValues extends IPropInitialValues {
 	mapper?: vtkMapper;
-	property?: vtkProperty;
+	property?: vtkProperty2D;
 	layerNumber?: number;
 	positionCoordinate?: vtkCoordinate;
 	positionCoordinate2?: vtkCoordinate;
@@ -31,12 +31,18 @@ export interface vtkActor2D extends vtkProp {
 
 	/**
 	 * Return the property object that controls this actors surface
-	 * properties. This should be an instance of a vtkProperty object. Every
+	 * properties. This should be an instance of a vtkProperty2D object. Every
 	 * actor must have a property associated with it. If one isn’t specified,
 	 * then one will be generated automatically. Multiple actors can share one
 	 * property object.
 	 */
-	getProperty(): vtkProperty;
+	getProperty(): vtkProperty2D;
+
+	/**
+	 * Create a new property suitable for use with this type of Actor.
+	 * @param {IProperty2DInitialValues} [initialValues] (default: {})
+	 */
+	 makeProperty(initialValues?: IProperty2DInitialValues): vtkProperty2D;
 
 	/**
 	 * 
@@ -112,8 +118,8 @@ export function newInstance(initialValues?: IActor2DInitialValues): vtkActor2D;
  * vtkProp. The actor also has scaling and maintains a reference to the
  * defining geometry (i.e., the mapper), rendering properties, and possibly a
  * texture map.
- * @see [vtkMapper](./Rendering_Core_Mapper.html)2D
- * @see [vtkProperty](./Rendering_Core_Property.html)2D 
+ * @see [vtkMapper2D](./Rendering_Core_Mapper2D.html)
+ * @see [vtkProperty2D](./Rendering_Core_Property2D.html)
  */
 export declare const vtkActor2D: {
 	newInstance: typeof newInstance,

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

@@ -0,0 +1,24 @@
+/**
+ * vtkColorMaps represents a global registry of preset color maps.
+ */
+
+import { Vector3 } from '../../../types';
+
+export interface IColorMapPreset {
+  Name: string;
+  Creator?: string;
+  ColorSpace?: string;
+  NanColor?: Vector3;
+  RGBPoints: number[];
+  IndexedColors?: number[];
+  Annotations?: (number | string)[];
+}
+
+export declare const vtkColorMaps: {
+  addPreset(preset: IColorMapPreset): void;
+  removePresetByName(name: string): void;
+  getPresetByName(name: string): IColorMapPreset;
+  rgbPresetNames: string[];
+};
+
+export default vtkColorMaps;

package/Rendering/Core/Property2D.d.ts

@@ -2,7 +2,7 @@ import { vtkObject } from './../../interfaces';
 import { RGBColor } from './../../types';
 import { DisplayLocation } from './Property2D/Constants';
 
-interface IProperty2DInitialValues{
+export interface IProperty2DInitialValues{
 	color?: RGBColor;
 	opacity?: number;
 	pointSize?: number;

package/Rendering/Core/Renderer.d.ts

@@ -35,6 +35,10 @@ export interface IRendererInitialValues extends IViewportInitialValues {
 	occlusionRatio?: number;
 	maximumNumberOfPeels?: number;
 	texturedBackground?: boolean;
+	environmentTexture?: vtkTexture;
+	environmentTextureDiffuseStrength?: number;
+	environmentTextureSpecularStrength?: number;
+	useEnvironmentTextureAsBackground?: boolean;
 	pass?: number;
 }
 
@@ -115,7 +119,25 @@ export interface vtkRenderer extends vtkViewport {
 	 * 
 	 * @default null
 	 */
-	getBackgroundTexture(): vtkTexture;
+	getEnvironmentTexture(): vtkTexture;
+
+	/**
+	 * Returns the diffuse strength of the set environment texture.
+	 * @default 1
+	 */
+	getEnvironmentTextureDiffuseStrength(): number;
+
+	/**
+	 * Returns the specular strength of the set environment texture.
+	 * @default 1
+	 */
+	getEnvironmentTextureSpecularStrength(): number;
+
+	/**
+	  * Gets whether or not the environment texture is being used as the background for the view.
+	  * @default false
+	  */
+	getUseEnvironmentTextureAsBackground(): boolean;
 
 	/**
 	 * 
@@ -347,9 +369,27 @@ export interface vtkRenderer extends vtkViewport {
 
 	/**
 	 * 
-	 * @param {vtkTexture} backgroundTexture 
+	 * @param {vtkTexture} environmentTexture 
+	 */
+	setEnvironmentTexture(environmentTexture: vtkTexture): boolean;
+
+	/**
+	 * Sets the diffuse strength of the set environment texture.
+	 * @param {number} diffuseStrength the new diffuse strength.
 	 */
-	setBackgroundTexture(backgroundTexture: vtkTexture): boolean;
+	setEnvironmentTextureDiffuseStrength(diffuseStrength: number): boolean;
+
+	 /**
+	  * Sets the specular strength of the set environment texture.
+	  * @param {number} specularStrength the new specular strength.
+	  */
+	setEnvironmentTextureSpecularStrength(specularStrength: number): boolean;
+
+	/**
+	  * Sets whether or not to use the environment texture as the background for the view.
+	  * @param {number} textureAsBackground
+	  */
+	setUseEnvironmentTextureAsBackground(textureAsBackground: boolean): boolean;
 
 	/**
 	 * 

package/Rendering/Core/Renderer.js

@@ -593,6 +593,10 @@ var DEFAULT_VALUES = {
   delegate: null,
   texturedBackground: false,
   backgroundTexture: null,
+  environmentTexture: null,
+  environmentTextureDiffuseStrength: 1,
+  environmentTextureSpecularStrength: 1,
+  useEnvironmentTextureAsBackground: false,
   pass: 0
 }; // ----------------------------------------------------------------------------
 
@@ -611,7 +615,7 @@ function extend(publicAPI, model) {
   if (model.background.length === 3) model.background.push(1); // Build VTK API
 
   get(publicAPI, model, ['_renderWindow', 'allocatedRenderTime', 'timeFactor', 'lastRenderTimeInSeconds', 'numberOfPropsRendered', 'lastRenderingUsedDepthPeeling', 'selector']);
-  setGet(publicAPI, model, ['twoSidedLighting', 'lightFollowCamera', 'automaticLightCreation', 'erase', 'draw', 'nearClippingPlaneTolerance', 'clippingRangeExpansion', 'backingStore', 'interactive', 'layer', 'preserveColorBuffer', 'preserveDepthBuffer', 'useDepthPeeling', 'occlusionRatio', 'maximumNumberOfPeels', 'delegate', 'backgroundTexture', 'texturedBackground', 'useShadows', 'pass']);
+  setGet(publicAPI, model, ['twoSidedLighting', 'lightFollowCamera', 'automaticLightCreation', 'erase', 'draw', 'nearClippingPlaneTolerance', 'clippingRangeExpansion', 'backingStore', 'interactive', 'layer', 'preserveColorBuffer', 'preserveDepthBuffer', 'useDepthPeeling', 'occlusionRatio', 'maximumNumberOfPeels', 'delegate', 'backgroundTexture', 'texturedBackground', 'environmentTexture', 'environmentTextureDiffuseStrength', 'environmentTextureSpecularStrength', 'useEnvironmentTextureAsBackground', 'useShadows', 'pass']);
   getArray(publicAPI, model, ['actors', 'volumes', 'lights']);
   setGetArray(publicAPI, model, ['background'], 4, 1.0);
   moveToProtected(publicAPI, model, ['renderWindow']); // Object methods

package/Rendering/Core/Texture.d.ts

@@ -5,6 +5,7 @@ export interface ITextureInitialValues {
 	interpolate?: boolean;
 	edgeClamp?: boolean;
 	imageLoaded?: boolean;
+	mipLevel?: number;
 }
 
 export interface vtkTexture extends vtkAlgorithm {
@@ -34,6 +35,11 @@ export interface vtkTexture extends vtkAlgorithm {
 	 */
 	getImageLoaded(): boolean;
 
+	/**
+	 * 
+	 */
+	getMipLevel(): number;
+
 	/**
 	 * 
 	 * @param repeat 
@@ -62,6 +68,11 @@ export interface vtkTexture extends vtkAlgorithm {
 	 * @default null
 	 */
 	setImage(image: any): void;
+
+	/**
+	 * @param level
+	 */
+	setMipLevel(level: number): boolean;
 }
 
 /**
@@ -79,6 +90,17 @@ export function extend(publicAPI: object, model: object, initialValues?: ITextur
  */
 export function newInstance(initialValues?: ITextureInitialValues): vtkTexture;
 
+/**
+ * Method used to create mipmaps from given texture data. Works best with textures that have a 
+ * width and a height that are powers of two.
+ * 
+ * @param nativeArray the array of data to create mipmaps from.
+ * @param width the width of the data
+ * @param height the height of the data
+ * @param level the level to which additional mipmaps are generated.
+ */
+export function generateMipmaps(nativeArray: any, width: number, height: number, level: number): Array<Uint8ClampedArray>;
+
 /** 
  * vtkTexture is an image algorithm that handles loading and binding of texture maps.
  * It obtains its data from an input image data dataset type. 

package/Rendering/Core/Texture.js

@@ -1,5 +1,10 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.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; }
 // vtkTexture methods
 // ----------------------------------------------------------------------------
 
@@ -103,19 +108,160 @@ function vtkTexture(publicAPI, model) {
     var dimensionality = (width > 1) + (height > 1) + (depth > 1);
     return dimensionality;
   };
-} // ----------------------------------------------------------------------------
+
+  publicAPI.getInputAsJsImageData = function () {
+    if (!model.imageLoaded || publicAPI.getInputData()) return null;
+
+    if (model.jsImageData) {
+      return model.jsImageData();
+    }
+
+    if (model.canvas) {
+      var context = model.canvas.getContext('2d');
+      var imageData = context.getImageData(0, 0, model.canvas.width, model.canvas.height);
+      return imageData;
+    }
+
+    if (model.image) {
+      var canvas = document.createElement('canvas');
+      canvas.width = model.image.width;
+      canvas.height = model.image.height;
+
+      var _context = canvas.getContext('2d');
+
+      _context.translate(0, canvas.height);
+
+      _context.scale(1, -1);
+
+      _context.drawImage(model.image, 0, 0, model.image.width, model.image.height);
+
+      var _imageData = _context.getImageData(0, 0, canvas.width, canvas.height);
+
+      return _imageData;
+    }
+
+    return null;
+  };
+} // Use nativeArray instead of self
+
+
+var generateMipmaps = function generateMipmaps(nativeArray, width, height, level) {
+  // TODO: FIX UNEVEN TEXTURE MIP GENERATION:
+  // When textures don't have standard ratios, higher mip levels
+  // result in their color chanels getting messed up and shifting
+  // 3x3 gaussian kernel
+  var g3m = [1, 2, 1]; // eslint-disable-line
+
+  var g3w = 4; // eslint-disable-line
+
+  var kernel = g3m;
+  var kernelWeight = g3w;
+  var hs = nativeArray.length / (width * height); // TODO: support for textures with depth more than 1
+
+  var currentWidth = width;
+  var currentHeight = height;
+  var imageData = nativeArray;
+  var maps = [imageData];
+
+  for (var i = 0; i < level; i++) {
+    var oldData = _toConsumableArray(imageData);
+
+    currentWidth /= 2;
+    currentHeight /= 2;
+    imageData = new Uint8ClampedArray(currentWidth * currentHeight * hs);
+    var vs = hs * currentWidth; // Scale down
+
+    var shift = 0;
+
+    for (var p = 0; p < imageData.length; p += hs) {
+      if (p % vs === 0) {
+        shift += 2 * hs * currentWidth;
+      }
+
+      for (var c = 0; c < hs; c++) {
+        var sample = oldData[shift + c];
+        sample += oldData[shift + hs + c];
+        sample += oldData[shift - 2 * vs + c];
+        sample += oldData[shift - 2 * vs + hs + c];
+        sample /= 4;
+        imageData[p + c] = sample;
+      }
+
+      shift += 2 * hs;
+    } // Horizontal Pass
+
+
+    var dataCopy = _toConsumableArray(imageData);
+
+    for (var _p = 0; _p < imageData.length; _p += hs) {
+      for (var _c = 0; _c < hs; _c++) {
+        var x = -(kernel.length - 1) / 2;
+        var kw = kernelWeight;
+        var value = 0.0;
+
+        for (var k = 0; k < kernel.length; k++) {
+          var index = _p + _c + x * hs;
+          var lineShift = index % vs - (_p + _c) % vs;
+          if (lineShift > hs) index += vs;
+          if (lineShift < -hs) index -= vs;
+
+          if (dataCopy[index]) {
+            value += dataCopy[index] * kernel[k];
+          } else {
+            kw -= kernel[k];
+          }
+
+          x += 1;
+        }
+
+        imageData[_p + _c] = value / kw;
+      }
+    } // Vertical Pass
+
+
+    dataCopy = _toConsumableArray(imageData);
+
+    for (var _p2 = 0; _p2 < imageData.length; _p2 += hs) {
+      for (var _c2 = 0; _c2 < hs; _c2++) {
+        var _x = -(kernel.length - 1) / 2;
+
+        var _kw = kernelWeight;
+        var _value = 0.0;
+
+        for (var _k = 0; _k < kernel.length; _k++) {
+          var _index = _p2 + _c2 + _x * vs;
+
+          if (dataCopy[_index]) {
+            _value += dataCopy[_index] * kernel[_k];
+          } else {
+            _kw -= kernel[_k];
+          }
+
+          _x += 1;
+        }
+
+        imageData[_p2 + _c2] = _value / _kw;
+      }
+    }
+
+    maps.push(imageData);
+  }
+
+  return maps;
+}; // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
 var DEFAULT_VALUES = {
-  repeat: false,
-  interpolate: false,
-  edgeClamp: false,
   image: null,
   canvas: null,
+  jsImageData: null,
   imageLoaded: false,
-  jsImageData: null
+  repeat: false,
+  interpolate: false,
+  edgeClamp: false,
+  mipLevel: 0
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -125,15 +271,18 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model);
   macro.algo(publicAPI, model, 6, 0);
   macro.get(publicAPI, model, ['canvas', 'image', 'jsImageData', 'imageLoaded']);
-  macro.setGet(publicAPI, model, ['repeat', 'edgeClamp', 'interpolate']);
+  macro.setGet(publicAPI, model, ['repeat', 'edgeClamp', 'interpolate', 'mipLevel']);
   vtkTexture(publicAPI, model);
 } // ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkTexture'); // ----------------------------------------------------------------------------
+var newInstance = macro.newInstance(extend, 'vtkTexture');
+var STATIC = {
+  generateMipmaps: generateMipmaps
+}; // ----------------------------------------------------------------------------
 
-var vtkTexture$1 = {
+var vtkTexture$1 = _objectSpread({
   newInstance: newInstance,
   extend: extend
-};
+}, STATIC);
 
-export { vtkTexture$1 as default, extend, newInstance };
+export { STATIC, vtkTexture$1 as default, extend, newInstance };

package/Rendering/Core/VolumeProperty.d.ts

@@ -5,7 +5,7 @@ import { InterpolationType, OpacityMode } from './VolumeProperty/Constants';
 
 export interface IVolumePropertyInitialValues  {
 	independentComponents?: boolean;
-	shade?: number;
+	shade?: boolean;
 	ambient?: number;
 	diffuse?: number;
 	specular?: number;
@@ -111,7 +111,7 @@ export interface vtkVolumeProperty extends vtkObject {
 	/**
 	 * Get the shading of a volume.
 	 */
-	getShade(): number;
+	getShade(): boolean;
 
 	/**
 	 *
@@ -236,9 +236,9 @@ export interface vtkVolumeProperty extends vtkObject {
 	 * turning shading off is generally the same as setting ambient=1,
 	 * diffuse=0, specular=0. Shading can be independently turned on/off per
 	 * component.
-	 * @param {Number} shade 
+	 * @param {Boolean} shade
 	 */
-	setShade(shade: number): boolean;
+	setShade(shade: boolean): boolean;
 
 	/**
 	 *

package/Rendering/Core/VolumeProperty.js

@@ -237,7 +237,7 @@ function vtkVolumeProperty(publicAPI, model) {
 var DEFAULT_VALUES = {
   independentComponents: true,
   interpolationType: InterpolationType.FAST_LINEAR,
-  shade: 0,
+  shade: false,
   ambient: 0.1,
   diffuse: 0.7,
   specular: 0.2,

package/Rendering/OpenGL/RenderWindow/ContextProxy.js

@@ -0,0 +1,65 @@
+function createContextProxyHandler() {
+  var cache = new Map();
+  var getParameterHandler = {
+    apply: function apply(target, gl, args) {
+      if (cache.has(args[0])) {
+        return cache.get(args[0]);
+      }
+
+      return target.apply(gl, args);
+    }
+  }; // only supports single-value setters
+
+  function cachedSetterHandler(key) {
+    return {
+      apply: function apply(target, gl, args) {
+        cache.set(key, args[0]);
+        return target.apply(gl, args);
+      }
+    };
+  } // When a property is accessed on the webgl context proxy,
+  // it's accessed is intercepted. If the property name matches
+  // any of the keys of `propHandlers`, then that handler is called
+  // with the following arguments: (gl, prop, receiver, propValue)
+  // - gl (WebGL2RenderingContext): the underlying webgl context
+  // - propName (string): the property name
+  // - receiver (Proxy): the webgl context proxy
+  // - propValue (unknown): the value of `gl[propName]`
+
+
+  var propHandlers = Object.create(null); // Sets getParameter(property) as a cached getter proxy.
+  // propValue.bind(gl) is to avoid Illegal Invocation errors.
+
+  propHandlers.getParameter = function (gl, prop, receiver, propValue) {
+    return new Proxy(propValue.bind(gl), getParameterHandler);
+  }; // Sets depthMask(flag) as a cached setter proxy.
+
+
+  propHandlers.depthMask = function (gl, prop, receiver, propValue) {
+    return new Proxy(propValue.bind(gl), cachedSetterHandler(gl.DEPTH_WRITEMASK));
+  };
+
+  return {
+    get: function get(gl, prop, receiver) {
+      var value = Reflect.get(gl, prop, receiver);
+
+      if (value instanceof Function) {
+        // prevents Illegal Invocation errors
+        value = value.bind(gl);
+      }
+
+      var propHandler = propHandlers[prop];
+
+      if (propHandler) {
+        return propHandler(gl, prop, receiver, value);
+      }
+
+      return value;
+    }
+  };
+}
+var ContextProxy = {
+  createContextProxyHandler: createContextProxyHandler
+};
+
+export { createContextProxyHandler, ContextProxy as default };

package/Rendering/OpenGL/RenderWindow.js

@@ -12,6 +12,7 @@ import vtkTextureUnitManager from './TextureUnitManager.js';
 import vtkViewNodeFactory from './ViewNodeFactory.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkRenderWindowViewNode from '../SceneGraph/RenderWindowViewNode.js';
+import { createContextProxyHandler } from './RenderWindow/ContextProxy.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro,
     vtkErrorMacro = macro.vtkErrorMacro;
@@ -84,6 +85,7 @@ function popMonitorGLContextCount(cb) {
 function vtkOpenGLRenderWindow(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLRenderWindow');
+  var cachingContextHandler = createContextProxyHandler();
 
   publicAPI.getViewNodeFactory = function () {
     return model.myFactory;
@@ -256,7 +258,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
       result = model.canvas.getContext('webgl', options) || model.canvas.getContext('experimental-webgl', options);
     }
 
-    return result;
+    return new Proxy(result, cachingContextHandler);
   }; // Request an XR session on the user device with WebXR,
   // typically in response to a user request such as a button press