@kitware/vtk.js 29.4.3 → 29.4.5

package/Rendering/Core/Picker.js

@@ -33,6 +33,35 @@ function vtkPicker(publicAPI, model) {
     model.globalTMin = Number.MAX_VALUE;
   }
 
+  /**
+   * Compute the tolerance in world coordinates.
+   * Do this by determining the world coordinates of the diagonal points of the
+   * window, computing the width of the window in world coordinates, and
+   * multiplying by the tolerance.
+   * @param {Number} selectionZ
+   * @param {Number} aspect
+   * @param {vtkRenderer} renderer
+   * @returns {Number} the computed tolerance
+   */
+  function computeTolerance(selectionZ, aspect, renderer) {
+    let tolerance = 0.0;
+    const view = renderer.getRenderWindow().getViews()[0];
+    const viewport = renderer.getViewport();
+    const winSize = view.getSize();
+    let x = winSize[0] * viewport[0];
+    let y = winSize[1] * viewport[1];
+    const normalizedLeftDisplay = view.displayToNormalizedDisplay(x, y, selectionZ);
+    const windowLowerLeft = renderer.normalizedDisplayToWorld(normalizedLeftDisplay[0], normalizedLeftDisplay[1], normalizedLeftDisplay[2], aspect);
+    x = winSize[0] * viewport[2];
+    y = winSize[1] * viewport[3];
+    const normalizedRightDisplay = view.displayToNormalizedDisplay(x, y, selectionZ);
+    const windowUpperRight = renderer.normalizedDisplayToWorld(normalizedRightDisplay[0], normalizedRightDisplay[1], normalizedRightDisplay[2], aspect);
+    for (let i = 0; i < 3; i++) {
+      tolerance += (windowUpperRight[i] - windowLowerLeft[i]) * (windowUpperRight[i] - windowLowerLeft[i]);
+    }
+    return Math.sqrt(tolerance);
+  }
+
   // Intersect data with specified ray.
   // Project the center point of the mapper onto the ray and determine its parametric value
   publicAPI.intersectWithLine = (p1, p2, tol, mapper) => {
@@ -73,13 +102,6 @@ function vtkPicker(publicAPI, model) {
     let tB;
     const p1World = [];
     const p2World = [];
-    let viewport = [];
-    let winSize = [];
-    let x;
-    let y;
-    let windowLowerLeft = [];
-    let windowUpperRight = [];
-    let tol = 0.0;
     let props = [];
     let pickable = false;
     const p1Mapper = new Float64Array(4);
@@ -108,6 +130,7 @@ function vtkPicker(publicAPI, model) {
     displayCoords = renderer.worldToNormalizedDisplay(cameraFP[0], cameraFP[1], cameraFP[2], aspect);
     displayCoords = view.normalizedDisplayToDisplay(displayCoords[0], displayCoords[1], displayCoords[2]);
     selectionZ = displayCoords[2];
+    const tolerance = computeTolerance(selectionZ, aspect, renderer) * model.tolerance;
 
     // Convert the selection point into world coordinates.
     const normalizedDisplay = view.displayToNormalizedDisplay(selectionX, selectionY, selectionZ);
@@ -150,27 +173,6 @@ function vtkPicker(publicAPI, model) {
     }
     p1World[3] = 1.0;
     p2World[3] = 1.0;
-
-    // Compute the tolerance in world coordinates.  Do this by
-    // determining the world coordinates of the diagonal points of the
-    // window, computing the width of the window in world coordinates, and
-    // multiplying by the tolerance.
-    viewport = renderer.getViewport();
-    if (renderer.getRenderWindow()) {
-      winSize = renderer.getRenderWindow().getViews()[0].getSize();
-    }
-    x = winSize[0] * viewport[0];
-    y = winSize[1] * viewport[1];
-    const normalizedLeftDisplay = view.displayToNormalizedDisplay(x, y, selectionZ);
-    windowLowerLeft = renderer.normalizedDisplayToWorld(normalizedLeftDisplay[0], normalizedLeftDisplay[1], normalizedLeftDisplay[2], aspect);
-    x = winSize[0] * viewport[2];
-    y = winSize[1] * viewport[3];
-    const normalizedRightDisplay = view.displayToNormalizedDisplay(x, y, selectionZ);
-    windowUpperRight = renderer.normalizedDisplayToWorld(normalizedRightDisplay[0], normalizedRightDisplay[1], normalizedRightDisplay[2], aspect);
-    for (let i = 0; i < 3; i++) {
-      tol += (windowUpperRight[i] - windowLowerLeft[i]) * (windowUpperRight[i] - windowLowerLeft[i]);
-    }
-    tol = Math.sqrt(tol) * model.tolerance;
     if (model.pickFromList) {
       props = model.pickList;
     } else {
@@ -209,12 +211,12 @@ function vtkPicker(publicAPI, model) {
         }
         if (mapper) {
           bbox.setBounds(mapper.getBounds());
-          bbox.inflate(tol);
+          bbox.inflate(tolerance);
         } else {
           bbox.reset();
         }
         if (bbox.intersectBox(p1Mapper, ray, hitPosition, t)) {
-          t[0] = publicAPI.intersectWithLine(p1Mapper, p2Mapper, tol * 0.333 * (scale[0] + scale[1] + scale[2]), prop, mapper);
+          t[0] = publicAPI.intersectWithLine(p1Mapper, p2Mapper, tolerance * 0.333 * (scale[0] + scale[1] + scale[2]), prop, mapper);
           if (t[0] < Number.MAX_VALUE) {
             const p = [];
             p[0] = (1.0 - t[0]) * p1World[0] + t[0] * p2World[0];

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -93,7 +93,7 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 *
 	 * @default null
 	 */
-	getContainer(): HTMLElement;
+	getContainer(): Nullable<HTMLElement>;
 
 	/**
 	 *
@@ -827,6 +827,13 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 */
 	rotateEvent(args: any): any;
 
+	/**
+	 * Add an HTMLElement as the new container for the interactor.
+	 * All events will be bound to this new container.
+	 * Any old container will be removed along with its listeners.
+	 */
+	setContainer(container: Nullable<HTMLElement>): boolean;
+
 	/**
 	 * Turn on/off the automatic repositioning of lights as the camera moves.
 	 * @param lightFollowCamera
@@ -992,12 +999,15 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 
 	/**
 	 *
-	 * @param container
+	 * @param container kept for backward compatibility.
+	 * @deprecated please use vtkRenderWindowInteractor.setContainer(container: HTMLElement)
+	 *     which will also bind events.
 	 */
 	bindEvents(container: any): void;
 
 	/**
 	 *
+	 * @deprecated please use vtkRenderWindowInteractor.setContainer(null) instead.
 	 */
 	unbindEvents(): void;
 

package/Rendering/Core/RenderWindowInteractor.js

@@ -51,6 +51,11 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkRenderWindowInteractor');
 
+  // Capture "parentClass" api for internal use
+  const superClass = {
+    ...publicAPI
+  };
+
   // Initialize list of requesters
   const animationRequesters = new Set();
 
@@ -161,8 +166,13 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   function getDeviceTypeFor(event) {
     return event.pointerType || '';
   }
-  publicAPI.bindEvents = container => {
-    model.container = container;
+  const _bindEvents = () => {
+    if (model.container === null) {
+      return;
+    }
+    const {
+      container
+    } = model;
     container.addEventListener('contextmenu', preventDefault);
     container.addEventListener('wheel', publicAPI.handleWheel);
     container.addEventListener('DOMMouseScroll', publicAPI.handleWheel);
@@ -188,30 +198,53 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     // disables tap highlight for when cursor is pointer
     container.style.webkitTapHighlightColor = 'rgba(0,0,0,0)';
   };
-  publicAPI.unbindEvents = () => {
+
+  // For backward compatibility.
+  // Necessary for using unbind/bindEvent without calling setContainer.
+  publicAPI.bindEvents = container => {
+    if (container === null) {
+      return;
+    }
+    const res = superClass.setContainer(container);
+    if (res) {
+      _bindEvents();
+    }
+  };
+  const _unbindEvents = () => {
+    // Clear any previous timeouts and state variables that control mouse / touchpad behavior.
+    clearTimeout(model.moveTimeoutID);
+    clearTimeout(model.wheelTimeoutID);
+    model.moveTimeoutID = 0;
+    model.wheelTimeoutID = 0;
+    wheelCoefficient = 1.0;
     const {
       container
     } = model;
-    container.removeEventListener('contextmenu', preventDefault);
-    container.removeEventListener('wheel', publicAPI.handleWheel);
-    container.removeEventListener('DOMMouseScroll', publicAPI.handleWheel);
-    container.removeEventListener('pointerenter', publicAPI.handlePointerEnter);
-    container.removeEventListener('pointerleave', publicAPI.handlePointerLeave);
-    container.removeEventListener('pointermove', publicAPI.handlePointerMove, {
-      passive: false
-    });
-    container.removeEventListener('pointerdown', publicAPI.handlePointerDown, {
-      passive: false
-    });
-    container.removeEventListener('pointerup', publicAPI.handlePointerUp);
-    container.removeEventListener('pointercancel', publicAPI.handlePointerCancel);
+    if (container) {
+      container.removeEventListener('contextmenu', preventDefault);
+      container.removeEventListener('wheel', publicAPI.handleWheel);
+      container.removeEventListener('DOMMouseScroll', publicAPI.handleWheel);
+      container.removeEventListener('pointerenter', publicAPI.handlePointerEnter);
+      container.removeEventListener('pointerleave', publicAPI.handlePointerLeave);
+      container.removeEventListener('pointermove', publicAPI.handlePointerMove, {
+        passive: false
+      });
+      container.removeEventListener('pointerdown', publicAPI.handlePointerDown, {
+        passive: false
+      });
+      container.removeEventListener('pointerup', publicAPI.handlePointerUp);
+      container.removeEventListener('pointercancel', publicAPI.handlePointerCancel);
+    }
     document.removeEventListener('keypress', publicAPI.handleKeyPress);
     document.removeEventListener('keydown', publicAPI.handleKeyDown);
     document.removeEventListener('keyup', publicAPI.handleKeyUp);
     document.removeEventListener('pointerlockchange', publicAPI.handlePointerLockChange);
-    model.container = null;
     pointerCache.clear();
   };
+  publicAPI.unbindEvents = () => {
+    _unbindEvents();
+    superClass.setContainer(null);
+  };
   publicAPI.handleKeyPress = event => {
     const data = getKeysFor(event);
     publicAPI.keyPressEvent(data);
@@ -947,9 +980,16 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     model._forcedRenderer = !!r;
     model.currentRenderer = r;
   };
+  publicAPI.setContainer = container => {
+    _unbindEvents();
+    const res = superClass.setContainer(container ?? null);
+    if (res) {
+      _bindEvents();
+    }
+    return res;
+  };
 
   // Stop animating if the renderWindowInteractor is deleted.
-  const superDelete = publicAPI.delete;
   publicAPI.delete = () => {
     while (animationRequesters.size) {
       publicAPI.cancelAnimation(animationRequesters.values().next().value);
@@ -958,9 +998,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
       document.removeEventListener('visibilitychange', publicAPI.handleVisibilityChange);
     }
     if (model.container) {
-      publicAPI.unbindEvents();
+      publicAPI.setContainer(null);
     }
-    superDelete();
+    superClass.delete();
   };
 
   // Use the Page Visibility API to detect when we switch away from or back to
@@ -1017,10 +1057,10 @@ function extend(publicAPI, model) {
   handledEvents.forEach(eventName => macro.event(publicAPI, model, eventName));
 
   // Create get-only macros
-  macro.get(publicAPI, model, ['initialized', 'container', 'interactorStyle', 'lastFrameTime', 'recentAnimationFrameRate', '_view']);
+  macro.get(publicAPI, model, ['initialized', 'interactorStyle', 'lastFrameTime', 'recentAnimationFrameRate', '_view']);
 
   // Create get-set macros
-  macro.setGet(publicAPI, model, ['lightFollowCamera', 'enabled', 'enableRender', 'recognizeGestures', 'desiredUpdateRate', 'stillUpdateRate', 'picker', 'preventDefaultOnPointerDown', 'preventDefaultOnPointerUp', 'mouseScrollDebounceByPass']);
+  macro.setGet(publicAPI, model, ['container', 'lightFollowCamera', 'enabled', 'enableRender', 'recognizeGestures', 'desiredUpdateRate', 'stillUpdateRate', 'picker', 'preventDefaultOnPointerDown', 'preventDefaultOnPointerUp', 'mouseScrollDebounceByPass']);
   macro.moveToProtected(publicAPI, model, ['view']);
 
   // For more macro methods, see "Sources/macros.js"

package/Widgets/Widgets3D/PaintWidget/behavior.js

@@ -24,29 +24,30 @@ function widgetBehavior(publicAPI, model) {
   };
   publicAPI.handleEvent = callData => {
     const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
-    if (manipulator && model.activeState && model.activeState.getActive()) {
-      const normal = model._camera.getDirectionOfProjection();
-      const up = model._camera.getViewUp();
-      const right = [];
-      vec3.cross(right, up, normal);
-      model.activeState.setUp(...up);
-      model.activeState.setRight(...right);
-      model.activeState.setDirection(...normal);
-      const {
-        worldCoords
-      } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-      if (worldCoords.length) {
-        model.widgetState.setTrueOrigin(...worldCoords);
-        model.activeState.setOrigin(...worldCoords);
-        if (model.painting) {
-          const trailCircle = model.widgetState.addTrail();
-          trailCircle.set(model.activeState.get('origin', 'up', 'right', 'direction', 'scale1'));
-        }
-      }
-      publicAPI.invokeInteractionEvent();
-      return macro.EVENT_ABORT;
+    if (!(manipulator && model.activeState && model.activeState.getActive())) {
+      return macro.VOID;
+    }
+    const normal = model._camera.getDirectionOfProjection();
+    const up = model._camera.getViewUp();
+    const right = [];
+    vec3.cross(right, up, normal);
+    model.activeState.setUp(...up);
+    model.activeState.setRight(...right);
+    model.activeState.setDirection(...normal);
+    const {
+      worldCoords
+    } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    if (!worldCoords?.length) {
+      return macro.VOID;
     }
-    return macro.VOID;
+    model.widgetState.setTrueOrigin(...worldCoords);
+    model.activeState.setOrigin(...worldCoords);
+    if (model.painting) {
+      const trailCircle = model.widgetState.addTrail();
+      trailCircle.set(model.activeState.get('origin', 'up', 'right', 'direction', 'scale1'));
+    }
+    publicAPI.invokeInteractionEvent();
+    return macro.EVENT_ABORT;
   };
   publicAPI.grabFocus = () => {
     if (!model.hasFocus) {

package/Widgets/Widgets3D/ResliceCursorWidget.d.ts

@@ -75,7 +75,7 @@ export interface vtkResliceCursorWidget extends vtkAbstractWidgetFactory {
    * Return an array of the first and the last possible points of the plane
    * along its normal.
    * @param {ViewTypes} viewType
-   * @returns {[Vector3, Vector3]} first and last points
+   * @returns {Array<Vector3>} two Vector3 arrays (first and last points)
    */
   getPlaneExtremities(viewType: ViewTypes): Array<Vector3>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "29.4.3",
+  "version": "29.4.5",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -118,7 +118,6 @@
     "string-replace-loader": "3.1.0",
     "style-loader": "3.3.1",
     "tape": "5.5.3",
-    "tape-catch": "1.0.6",
     "webpack": "5.76.0",
     "webpack-bundle-analyzer": "4.5.0",
     "webpack-cli": "4.9.2",