@kitware/vtk.js 33.0.2 → 33.1.0

package/Interaction/Manipulators/MouseCameraTrackballFirstPersonManipulator.js

@@ -13,77 +13,35 @@ function vtkMouseCameraTrackballFirstPersonManipulator(publicAPI, model) {
   model.classHierarchy.push('vtkMouseCameraTrackballFirstPersonManipulator');
   const internal = {
     interactor: null,
-    renderer: null,
-    previousPosition: null
+    renderer: null
   };
 
   //--------------------------------------------------------------------------
 
   publicAPI.onButtonDown = (interactor, renderer, position) => {
-    internal.previousPosition = position;
     if (model.usePointerLock && !interactor.isPointerLocked()) {
       Object.assign(internal, {
         interactor,
         renderer
       });
       interactor.requestPointerLock();
-      publicAPI.startPointerLockInteraction();
     }
   };
 
   //--------------------------------------------------------------------------
 
-  publicAPI.startPointerLockInteraction = () => {
-    const {
-      interactor
-    } = internal;
-
-    // TODO: at some point, this should perhaps be done in
-    // RenderWindowInteractor instead of here.
-    // We need to hook into mousemove directly for two reasons:
-    // 1. We need to keep receiving mouse move events after the mouse button
-    //    is released. This is currently not possible with
-    //    vtkInteractorStyleManipulator.
-    // 2. Since the mouse is stationary in pointer lock mode, we need the
-    //    event.movementX and event.movementY info, which are not currently
-    //    passed via interactor.onMouseMove.
-    document.addEventListener('mousemove', publicAPI.onPointerLockMove);
-    let subscription = null;
-    const endInteraction = () => {
-      document.removeEventListener('mousemove', publicAPI.onPointerLockMove);
-      subscription.unsubscribe();
-    };
-    subscription = interactor.onEndPointerLock(endInteraction);
-  };
-
-  //--------------------------------------------------------------------------
-
-  publicAPI.onPointerLockMove = e => {
-    const sensitivity = model.sensitivity;
-    const yaw = -1 * e.movementX * sensitivity;
-    const pitch = -1 * e.movementY * sensitivity;
-    publicAPI.moveCamera(yaw, pitch);
-  };
-
-  //--------------------------------------------------------------------------
-
   publicAPI.onMouseMove = (interactor, renderer, position) => {
-    // This is currently only being called for non pointer lock mode
     if (!position) {
       return;
     }
-    const {
-      previousPosition
-    } = internal;
     const sensitivity = model.sensitivity;
-    const yaw = (previousPosition.x - position.x) * sensitivity;
-    const pitch = (position.y - previousPosition.y) * sensitivity;
+    const yaw = -position.movementX * sensitivity;
+    const pitch = -position.movementY * sensitivity;
     Object.assign(internal, {
       interactor,
       renderer
     });
     publicAPI.moveCamera(yaw, pitch);
-    internal.previousPosition = position;
   };
 
   //--------------------------------------------------------------------------

package/Interaction/Style/InteractorStyleManipulator.d.ts

@@ -6,6 +6,7 @@ import vtkInteractorStyle from './../../Rendering/Core/InteractorStyle';
 import {
   Device,
   Input,
+  MouseButton,
 } from './../../Rendering/Core/RenderWindowInteractor/Constants';
 import { Nullable, Vector3 } from './../../types';
 
@@ -120,7 +121,7 @@ export interface vtkInteractorStyleManipulator extends vtkInteractorStyle {
    * @param alt alt enabled
    */
   findMouseManipulator(
-    button: number,
+    button: MouseButton,
     shift: boolean,
     scroll: boolean,
     alt: boolean
@@ -285,13 +286,13 @@ export interface vtkInteractorStyleManipulator extends vtkInteractorStyle {
    * @param button which button
    * @param callData event data
    */
-  onButtonDown(button: number, callData: unknown): void;
+  onButtonDown(button: MouseButton, callData: unknown): void;
 
   /**
    * Handles a button up event.
    * @param button which button
    */
-  onButtonUp(button: number): void;
+  onButtonUp(button: MouseButton): void;
 
   /**
    * Sets the rotation factor.

package/Interaction/Style/InteractorStyleManipulator.js

@@ -1,4 +1,5 @@
 import { m as macro } from '../../macros2.js';
+import { MouseButton } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 import vtkInteractorStyle from '../../Rendering/Core/InteractorStyle.js';
 
 const {
@@ -225,19 +226,19 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleLeftButtonPress = callData => {
     model.previousPosition = callData.position;
-    publicAPI.onButtonDown(1, callData);
+    publicAPI.onButtonDown(MouseButton.LeftButton, callData);
   };
 
   //-------------------------------------------------------------------------
   publicAPI.handleMiddleButtonPress = callData => {
     model.previousPosition = callData.position;
-    publicAPI.onButtonDown(2, callData);
+    publicAPI.onButtonDown(MouseButton.MiddleButton, callData);
   };
 
   //-------------------------------------------------------------------------
   publicAPI.handleRightButtonPress = callData => {
     model.previousPosition = callData.position;
-    publicAPI.onButtonDown(3, callData);
+    publicAPI.onButtonDown(MouseButton.RightButton, callData);
   };
 
   //-------------------------------------------------------------------------
@@ -330,17 +331,17 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
 
   //-------------------------------------------------------------------------
   publicAPI.handleLeftButtonRelease = () => {
-    publicAPI.onButtonUp(1);
+    publicAPI.onButtonUp(MouseButton.LeftButton);
   };
 
   //-------------------------------------------------------------------------
   publicAPI.handleMiddleButtonRelease = () => {
-    publicAPI.onButtonUp(2);
+    publicAPI.onButtonUp(MouseButton.MiddleButton);
   };
 
   //-------------------------------------------------------------------------
   publicAPI.handleRightButtonRelease = () => {
-    publicAPI.onButtonUp(3);
+    publicAPI.onButtonUp(MouseButton.RightButton);
   };
 
   //-------------------------------------------------------------------------
@@ -351,12 +352,18 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     if (model.currentManipulator.getButton && model.currentManipulator.getButton() === button) {
       model.currentManipulator.onButtonUp(model._interactor);
       model.currentManipulator.endInteraction();
-      model.currentManipulator = null;
-      model._interactor.cancelAnimation(publicAPI.onButtonDown);
+      if (!model._interactor.isPointerLocked()) {
+        model.currentManipulator = null;
+      }
       publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
     }
   };
 
+  //-------------------------------------------------------------------------
+  publicAPI.handleEndPointerLock = () => {
+    model.currentManipulator = null;
+  };
+
   //-------------------------------------------------------------------------
   publicAPI.handleStartMouseWheel = callData => {
     // Must not be processing a wheel interaction to start another.

package/Rendering/Core/ColorTransferFunction.d.ts

@@ -312,6 +312,30 @@ export interface vtkColorTransferFunction extends vtkScalarsToColors {
    * @param colorMap
    */
   applyColorMap(colorMap: any): void;
+
+  /**
+   * Get the color space of the color transfer function.
+   * @returns {ColorSpace}
+   */
+  getColorSpace(): ColorSpace;
+
+  /**
+   * Set the color space of the color transfer function.
+   * @param {ColorSpace} colorSpace
+   */
+  setColorSpace(colorSpace: ColorSpace): void;
+
+  /**
+   * Get the scale of the color transfer function.
+   * @returns {Scale}
+   */
+  getScale(): Scale;
+
+  /**
+   * Set the scale of the color transfer function.
+   * @param {Scale} scale
+   */
+  setScale(scale: Scale): void;
 }
 
 /**

package/Rendering/Core/Mapper.js

@@ -135,12 +135,13 @@ const colorTextureCoordinatesCache = new WeakMap();
  * @param {vtkDataArray} input The input data array used for coloring
  * @param {Number} component The component of the input data array that is used for coloring (-1 for magnitude of the vectors)
  * @param {Range} range The range of the scalars
+ * @param {boolean} useLogScale Should the values be transformed to logarithmic scale. When true, the range must already be in logarithmic scale.
  * @param {Number} numberOfColorsInRange The number of colors that are used in the range
  * @param {vec3} dimensions The dimensions of the texture
  * @param {boolean} useZigzagPattern If a zigzag pattern should be used. Otherwise 1 row for colors (including min and max) and 1 row for NaN are used.
  * @returns A vtkDataArray containing the texture coordinates (2D or 3D)
  */
-function getOrCreateColorTextureCoordinates(input, component, range, numberOfColorsInRange, dimensions, useZigzagPattern) {
+function getOrCreateColorTextureCoordinates(input, component, range, useLogScale, numberOfColorsInRange, dimensions, useZigzagPattern) {
   // Caching using the "arguments" special object (because it is a pure function)
   const argStrings = new Array(arguments.length);
   for (let argIndex = 0; argIndex < arguments.length; ++argIndex) {
@@ -199,6 +200,9 @@ function getOrCreateColorTextureCoordinates(input, component, range, numberOfCol
     } else {
       scalarValue = inputV[inputIdx + component];
     }
+    if (useLogScale) {
+      scalarValue = Math.log10(scalarValue);
+    }
     inputIdx += numComps;
 
     // Convert to texture coordinates and update output
@@ -396,6 +400,7 @@ function vtkMapper(publicAPI, model) {
     const range = model.lookupTable.getRange();
     const useLogScale = model.lookupTable.usingLogScale();
     const origAlpha = model.lookupTable.getAlpha();
+    const scaledRange = useLogScale ? [Math.log10(range[0]), Math.log10(range[1])] : range;
 
     // Get rid of vertex color array.  Only texture or vertex coloring
     // can be active at one time.  The existence of the array is the
@@ -438,7 +443,6 @@ function vtkMapper(publicAPI, model) {
       const numberOfNonSpecialColors = model.numberOfColorsInRange;
       const numberOfNonNaNColors = numberOfNonSpecialColors + 2;
       const textureCoordinates = [0, 0, 0];
-      const scaledRange = useLogScale ? [Math.log10(range[0]), Math.log10(range[1])] : range;
       const rangeMin = scaledRange[0];
       const rangeDifference = scaledRange[1] - scaledRange[0];
       for (let i = 0; i < numberOfNonNaNColors; ++i) {
@@ -472,7 +476,7 @@ function vtkMapper(publicAPI, model) {
     // A zigzag pattern can be used with cell data, as there will be no texture coordinates interpolation
     // The texture generated using a zigzag pattern in one dimension is the same as without zigzag
     // Therefore, the same code can be used for texture generation of point/cell data but not for texture coordinates
-    model.colorCoordinates = getOrCreateColorTextureCoordinates(scalars, scalarComponent, range, model.numberOfColorsInRange, model.colorTextureMap.getDimensions(), cellFlag);
+    model.colorCoordinates = getOrCreateColorTextureCoordinates(scalars, scalarComponent, scaledRange, useLogScale, model.numberOfColorsInRange, model.colorTextureMap.getDimensions(), cellFlag);
   };
   publicAPI.getIsOpaque = () => {
     const input = publicAPI.getInputData();

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

@@ -23,9 +23,16 @@ export declare enum Axis {
   ThumbstickY = 4,
 }
 
+export declare enum MouseButton {
+  LeftButton = 1,
+  MiddleButton = 2,
+  RightButton = 3,
+}
+
 declare const _default: {
   Device: typeof Device;
   Input: typeof Input;
   Axis: typeof Axis;
+  MouseButton: typeof MouseButton;
 };
 export default _default;

package/Rendering/Core/RenderWindowInteractor/Constants.js

@@ -21,10 +21,16 @@ const Axis = {
   ThumbstickX: 3,
   ThumbstickY: 4
 };
+const MouseButton = {
+  LeftButton: 1,
+  MiddleButton: 2,
+  RightButton: 3
+};
 var Constants = {
   Device,
   Input,
-  Axis
+  Axis,
+  MouseButton
 };
 
-export { Axis, Device, Input, Constants as default };
+export { Axis, Device, Input, MouseButton, Constants as default };

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -1,7 +1,7 @@
 import { vtkObject, vtkSubscription } from './../../interfaces';
 import { Nullable } from './../../types';
 import vtkRenderer from './Renderer';
-import { Axis, Device, Input } from './RenderWindowInteractor/Constants';
+import { Axis, Device, Input, MouseButton } from './RenderWindowInteractor/Constants';
 
 declare enum handledEvents {
   'StartAnimation',
@@ -1397,5 +1397,6 @@ export declare const vtkRenderWindowInteractor: {
   Device: typeof Device;
   Input: typeof Input;
   Axis: typeof Axis;
+  MouseButton: typeof MouseButton;
 };
 export default vtkRenderWindowInteractor;

package/Rendering/Core/RenderWindowInteractor.js

@@ -136,7 +136,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     const position = {
       x: scaleX * (source.clientX - bounds.left),
       y: scaleY * (bounds.height - source.clientY + bounds.top),
-      z: 0
+      z: 0,
+      movementX: scaleX * source.movementX,
+      movementY: scaleY * source.movementY
     };
 
     // if multitouch, do not update the current renderer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "33.0.2",
+  "version": "33.1.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",