@kitware/vtk.js 33.0.1 → 33.1.0

package/IO/Geometry/PLYReader.d.ts

@@ -13,7 +13,19 @@ interface IPLYReaderOptions {
 /**
  *
  */
-export interface IPLYReaderInitialValues {}
+export interface IPLYReaderInitialValues {
+  /**
+   * Controls whether points are duplicated for face-texture mapping.
+   * Default is true.
+   */
+  duplicatePointsForFaceTexture?: boolean;
+
+  /**
+   * The tolerance used to determine if two points are the same.
+   * Default is 0.000001.
+   */
+  faceTextureTolerance?: number;
+}
 
 type vtkPLYReaderBase = vtkObject &
   Omit<
@@ -41,6 +53,16 @@ export interface vtkPLYReader extends vtkPLYReaderBase {
     | JSZipDataAccessHelper
     | LiteHttpDataAccessHelper;
 
+  /**
+   * Controls whether points are duplicated for face-texture mapping.
+   */
+  getDuplicatePointsForFaceTexture(): boolean;
+
+  /**
+   * Get the tolerance used to determine if two points are the same.
+   */
+  getFaceTextureTolerance(): number;
+
   /**
    * Get the url of the object to load.
    */

package/IO/Geometry/PLYReader.js

@@ -95,7 +95,7 @@ function parseHeader(data) {
   }
   return header;
 }
-function postProcess(buffer, elements) {
+function postProcess(buffer, elements, faceTextureTolerance, duplicatePointsForFaceTexture) {
   const vertElement = elements.find(element => element.name === 'vertex');
   const faceElement = elements.find(element => element.name === 'face');
   let nbVerts = 0;
@@ -106,14 +106,20 @@ function postProcess(buffer, elements) {
   if (faceElement) {
     nbFaces = faceElement.count;
   }
-  const pointValues = new Float32Array(nbVerts * 3);
-  const colorArray = new Uint8Array(nbVerts * 3);
-  const tcoordsArray = new Float32Array(nbVerts * 2);
-  const normalsArray = new Float32Array(nbVerts * 3);
+  let pointValues = new Float32Array(nbVerts * 3);
+  let colorArray = new Uint8Array(nbVerts * 3);
+  let tcoordsArray = new Float32Array(nbVerts * 2);
+  let normalsArray = new Float32Array(nbVerts * 3);
   const hasColor = buffer.colors.length > 0;
   const hasVertTCoords = buffer.uvs.length > 0;
   const hasNorms = buffer.normals.length > 0;
   const hasFaceTCoords = buffer.faceVertexUvs.length > 0;
+
+  // For duplicate point handling
+  const pointIds = new Map(); // Maps texture coords to arrays of point IDs
+  let nextPointId = nbVerts;
+
+  // Initialize base points
   for (let vertIdx = 0; vertIdx < nbVerts; vertIdx++) {
     let a = vertIdx * 3 + 0;
     let b = vertIdx * 3 + 1;
@@ -131,6 +137,10 @@ function postProcess(buffer, elements) {
       b = vertIdx * 2 + 1;
       tcoordsArray[a] = buffer.uvs[a];
       tcoordsArray[b] = buffer.uvs[b];
+    } else {
+      // Initialize with sentinel value
+      tcoordsArray[vertIdx * 2] = -1;
+      tcoordsArray[vertIdx * 2 + 1] = -1;
     }
     if (hasNorms) {
       normalsArray[a] = buffer.normals[a];
@@ -138,33 +148,153 @@ function postProcess(buffer, elements) {
       normalsArray[c] = buffer.normals[c];
     }
   }
-  if (!hasVertTCoords && hasFaceTCoords) {
+
+  // Process face texture coordinates
+  if (hasFaceTCoords && !hasVertTCoords && nbFaces > 0) {
     // don't use array.shift, because buffer.indices will be used later
     let idxVerts = 0;
     let idxCoord = 0;
-    for (let faceIdx = 0; faceIdx < nbFaces; ++faceIdx) {
-      const nbFaceVerts = buffer.indices[idxVerts++];
-      const texcoords = buffer.faceVertexUvs[idxCoord++];
-      if (texcoords && nbFaceVerts * 2 === texcoords.length) {
-        // grab the vertex index
-        for (let vertIdx = 0; vertIdx < nbFaceVerts; ++vertIdx) {
-          const vert = buffer.indices[idxVerts++];
-          // new texture stored at the current face
-          tcoordsArray[vert * 2 + 0] = texcoords[vertIdx * 2 + 0];
-          tcoordsArray[vert * 2 + 1] = texcoords[vertIdx * 2 + 1];
+    if (duplicatePointsForFaceTexture) {
+      // Arrays to store duplicated point data
+      const extraPoints = [];
+      const extraColors = [];
+      const extraNormals = [];
+      const extraTCoords = [];
+      for (let faceIdx = 0; faceIdx < nbFaces; ++faceIdx) {
+        const nbFaceVerts = buffer.indices[idxVerts++];
+        const texcoords = buffer.faceVertexUvs[idxCoord++];
+        if (texcoords && nbFaceVerts * 2 === texcoords.length) {
+          for (let vertIdx = 0; vertIdx < nbFaceVerts; ++vertIdx) {
+            const vertId = buffer.indices[idxVerts + vertIdx];
+            const newTex = [texcoords[vertIdx * 2], texcoords[vertIdx * 2 + 1]];
+            const currentTex = [tcoordsArray[vertId * 2], tcoordsArray[vertId * 2 + 1]];
+            if (currentTex[0] === -1) {
+              // First time seeing texture coordinates for this vertex
+              tcoordsArray[vertId * 2] = newTex[0];
+              tcoordsArray[vertId * 2 + 1] = newTex[1];
+              const key = `${newTex[0]},${newTex[1]}`;
+              if (!pointIds.has(key)) {
+                pointIds.set(key, []);
+              }
+              pointIds.get(key).push(vertId);
+            } else {
+              // Check if we need to duplicate the vertex
+              const needsDuplication = Math.abs(currentTex[0] - newTex[0]) > faceTextureTolerance || Math.abs(currentTex[1] - newTex[1]) > faceTextureTolerance;
+              if (needsDuplication) {
+                const key = `${newTex[0]},${newTex[1]}`;
+                let existingPointId = -1;
+
+                // Check if we already have a point with these texture coordinates
+                if (pointIds.has(key)) {
+                  const candidates = pointIds.get(key);
+                  for (let i = 0, len = candidates.length; i < len; i++) {
+                    const candidateId = candidates[i];
+                    const samePosition = Math.abs(pointValues[candidateId * 3] - pointValues[vertId * 3]) <= faceTextureTolerance && Math.abs(pointValues[candidateId * 3 + 1] - pointValues[vertId * 3 + 1]) <= faceTextureTolerance && Math.abs(pointValues[candidateId * 3 + 2] - pointValues[vertId * 3 + 2]) <= faceTextureTolerance;
+                    if (samePosition) {
+                      existingPointId = candidateId;
+                      break;
+                    }
+                  }
+                }
+                if (existingPointId === -1) {
+                  // Create new point
+                  extraPoints.push(pointValues[vertId * 3], pointValues[vertId * 3 + 1], pointValues[vertId * 3 + 2]);
+                  if (hasColor) {
+                    extraColors.push(colorArray[vertId * 3], colorArray[vertId * 3 + 1], colorArray[vertId * 3 + 2]);
+                  }
+                  if (hasNorms) {
+                    extraNormals.push(normalsArray[vertId * 3], normalsArray[vertId * 3 + 1], normalsArray[vertId * 3 + 2]);
+                  }
+                  extraTCoords.push(newTex[0], newTex[1]);
+                  if (!pointIds.has(key)) {
+                    pointIds.set(key, []);
+                  }
+                  pointIds.get(key).push(nextPointId);
+                  buffer.indices[idxVerts + vertIdx] = nextPointId;
+                  nextPointId++;
+                } else {
+                  buffer.indices[idxVerts + vertIdx] = existingPointId;
+                }
+              }
+            }
+          }
         }
-      } else {
         idxVerts += nbFaceVerts;
       }
+
+      // Extend arrays with duplicated points if needed
+      if (extraPoints.length > 0) {
+        const newPointCount = nbVerts + extraPoints.length / 3;
+        const newPointValues = new Float32Array(newPointCount * 3);
+        const newTcoordsArray = new Float32Array(newPointCount * 2);
+        const newColorArray = hasColor ? new Uint8Array(newPointCount * 3) : null;
+        const newNormalsArray = hasNorms ? new Float32Array(newPointCount * 3) : null;
+
+        // Copy existing data
+        newPointValues.set(pointValues);
+        newTcoordsArray.set(tcoordsArray);
+        if (hasColor && newColorArray) {
+          newColorArray.set(colorArray);
+        }
+        if (hasNorms && newNormalsArray) {
+          newNormalsArray.set(normalsArray);
+        }
+
+        // Add new data
+        newPointValues.set(extraPoints, nbVerts * 3);
+        newTcoordsArray.set(extraTCoords, nbVerts * 2);
+        if (hasColor && newColorArray) {
+          newColorArray.set(extraColors, nbVerts * 3);
+        }
+        if (hasNorms && newNormalsArray) {
+          newNormalsArray.set(extraNormals, nbVerts * 3);
+        }
+        pointValues = newPointValues;
+        tcoordsArray = newTcoordsArray;
+        if (hasColor) {
+          colorArray = newColorArray;
+        }
+        if (hasNorms) {
+          normalsArray = newNormalsArray;
+        }
+      }
+    } else {
+      for (let faceIdx = 0; faceIdx < nbFaces; ++faceIdx) {
+        const nbFaceVerts = buffer.indices[idxVerts++];
+        const texcoords = buffer.faceVertexUvs[idxCoord++];
+        if (texcoords && nbFaceVerts * 2 === texcoords.length) {
+          for (let vertIdx = 0; vertIdx < nbFaceVerts; ++vertIdx) {
+            const vert = buffer.indices[idxVerts++];
+            tcoordsArray[vert * 2] = texcoords[vertIdx * 2];
+            tcoordsArray[vert * 2 + 1] = texcoords[vertIdx * 2 + 1];
+          }
+        } else {
+          idxVerts += nbFaceVerts;
+        }
+      }
     }
   }
   const polydata = vtkPolyData.newInstance();
   polydata.getPoints().setData(pointValues, 3);
+
+  // If we have faces, add them as polys
+  if (nbFaces > 0) {
+    polydata.getPolys().setData(Uint32Array.from(buffer.indices));
+  } else {
+    // Point cloud - create a vertex list containing all points
+    const verts = new Uint32Array(nbVerts * 2);
+    for (let i = 0; i < nbVerts; i++) {
+      verts[i * 2] = 1; // number of points in vertex cell (always 1)
+      verts[i * 2 + 1] = i; // point index
+    }
+
+    polydata.getVerts().setData(verts);
+  }
   if (hasColor) {
     polydata.getPointData().setScalars(vtkDataArray.newInstance({
       numberOfComponents: 3,
       values: colorArray,
-      name: 'Scalars'
+      name: 'RGB'
     }));
   }
   if (hasVertTCoords || hasFaceTCoords) {
@@ -184,7 +314,6 @@ function postProcess(buffer, elements) {
       values: normalsArray
     }));
   }
-  polydata.getPolys().setData(Uint32Array.from(buffer.indices));
   return polydata;
 }
 function parseNumber(n, type) {
@@ -410,7 +539,10 @@ function vtkPLYReader(publicAPI, model) {
     }
 
     // Header
-    const text = BinaryHelper.arrayBufferToString(content);
+    let text = content;
+    if (content instanceof ArrayBuffer) {
+      text = BinaryHelper.arrayBufferToString(content);
+    }
     const header = parseHeader(text);
 
     // ascii/binary detection
@@ -418,7 +550,7 @@ function vtkPLYReader(publicAPI, model) {
 
     // Check if ascii format
     if (!isBinary) {
-      publicAPI.parseAsText(content);
+      publicAPI.parseAsText(text);
       return;
     }
     model.parseData = content;
@@ -445,7 +577,7 @@ function vtkPLYReader(publicAPI, model) {
         handleElement(buffer, header.elements[elem].name, element);
       }
     }
-    const polydata = postProcess(buffer, header.elements);
+    const polydata = postProcess(buffer, header.elements, model.faceTextureTolerance, model.duplicatePointsForFaceTexture);
 
     // Add new output
     model.output[0] = polydata;
@@ -462,7 +594,10 @@ function vtkPLYReader(publicAPI, model) {
     model.parseData = content;
 
     // Header
-    const text = BinaryHelper.arrayBufferToString(content);
+    let text = content;
+    if (content instanceof ArrayBuffer) {
+      text = BinaryHelper.arrayBufferToString(content);
+    }
     const header = parseHeader(text);
 
     // ascii/binary detection
@@ -504,7 +639,7 @@ function vtkPLYReader(publicAPI, model) {
         idx++;
       }
     }
-    const polydata = postProcess(buffer, header.elements);
+    const polydata = postProcess(buffer, header.elements, model.faceTextureTolerance, model.duplicatePointsForFaceTexture);
 
     // Add new output
     model.output[0] = polydata;
@@ -522,6 +657,8 @@ const DEFAULT_VALUES = {
   // baseURL: null,
   // dataAccessHelper: null,
   // url: null,
+  faceTextureTolerance: 1e-6,
+  duplicatePointsForFaceTexture: true
 };
 
 // ----------------------------------------------------------------------------
@@ -532,7 +669,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['url', 'baseURL']);
+  macro.get(publicAPI, model, ['url', 'baseURL', 'duplicatePointsForFaceTexture', 'faceTextureTolerance']);
   macro.setGet(publicAPI, model, ['dataAccessHelper']);
   macro.algo(publicAPI, model, 0, 1);
 

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.1",
+  "version": "33.1.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",