@kitware/vtk.js 30.5.3 → 30.6.0

package/Widgets/Manipulators/AbstractManipulator.d.ts

@@ -49,11 +49,37 @@ export interface vtkAbstractManipulator extends vtkObject {
     setUseCameraNormal(useCameraNormal: boolean): boolean;
 
     /**
-     * 
+     * Processes a vtkRenderWindowInteractor event into 3D world positional info.
+     *
+     * Returns an object containing:
+     * - worldCoords: a 3D coordinate corresponding to the 2D event.
+     * - worldDelta: a 3D position delta between the current and the previous call to handleEvent.
+     * - worldDirection: a 3D directional vector. Only on select manipulators.
+     *
+     * worldCoords can be null if the pointer event enters an invalid manipulator region. For example,
+     * the PickerManipulator returns null when the pointer event is off of the picked geometry.
+     *
+     * worldDelta only makes sense between two calls of `handleEvent`. In a queue of `handleEvent` calls,
+     * the i-th call returns the delta between the i-th worldCoords and the (i-1)-th worldCoords.
+     * Thus, calling `handleEvent` is necessary for maintaining a valid worldDelta even when the return
+     * value is ignored.
+     *
+     * There are three cases where worldDelta needs to handle null events:
+     * 1. the first call to `handleEvent`, since there is no previously cached event position.
+     *    worldDelta is set to [0, 0, 0].
+     * 2. if the current `handleEvent` call returns a null worldCoords. worldDelta is set to [0, 0, 0].
+     * 3. if the previous `handleEvent` call returned a null worldCoords. In this case, worldDelta is the
+     *     delta between the current worldCoords and the previous non-null worldCoords, referring to the
+     *     previous 2 cases when applicable.
+     *
      * @param callData 
      * @param glRenderWindow 
      */
-    handleEvent(callData: any, glRenderWindow: vtkOpenGLRenderWindow): { worldCoords: Nullable<Vector3>, worldDirection?: Matrix3x3 };
+    handleEvent(callData: any, glRenderWindow: vtkOpenGLRenderWindow): {
+      worldCoords: Nullable<Vector3>,
+      worldDelta: Vector3,
+      worldDirection?: Matrix3x3,
+    };
 
     /* ------------------------------------------------------------------- */
 

package/Widgets/Manipulators/AbstractManipulator.js

@@ -1,4 +1,5 @@
 import { m as macro } from '../../macros2.js';
+import { s as subtract } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkAbstractManipulator methods
@@ -7,6 +8,7 @@ import { m as macro } from '../../macros2.js';
 function vtkAbstractManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkAbstractManipulator');
+  model._prevWorldCoords = [];
   publicAPI.getOrigin = callData => {
     if (model.userOrigin) return model.userOrigin;
     if (model.useCameraFocalPoint) return callData.pokedRenderer.getActiveCamera().getFocalPoint();
@@ -21,6 +23,24 @@ function vtkAbstractManipulator(publicAPI, model) {
     if (model.widgetNormal) return model.widgetNormal;
     return [0, 0, 1];
   };
+  model._computeDeltaFromPrevCoords = curWorldCoords => {
+    if (!model._prevWorldCoords?.length || !curWorldCoords?.length) return [0, 0, 0];
+    return subtract(curWorldCoords, model._prevWorldCoords, []);
+  };
+  model._addWorldDeltas = manipulatorResults => {
+    const {
+      worldCoords: curWorldCoords
+    } = manipulatorResults;
+    const worldDelta = model._computeDeltaFromPrevCoords(curWorldCoords);
+    if (curWorldCoords) model._prevWorldCoords = curWorldCoords;
+    const deltas = {
+      worldDelta
+    };
+    return {
+      ...manipulatorResults,
+      ...deltas
+    };
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Widgets/Manipulators/CPRManipulator.js

@@ -19,9 +19,9 @@ function vtkCPRManipulator(publicAPI, model) {
   publicAPI.handleEvent = (callData, glRenderWindow) => {
     const mapper = model.cprActor?.getMapper();
     if (!mapper) {
-      return {
+      return model._addWorldDeltas({
         worldCoords: null
-      };
+      });
     }
 
     // Get normal and origin of the picking plane from the actor matrix
@@ -38,7 +38,7 @@ function vtkCPRManipulator(publicAPI, model) {
     vec3.transformMat4(modelPlanePicking, worldPlanePicking, inversecprActorMatrix);
     const height = mapper.getHeight();
     const distance = height - modelPlanePicking[1];
-    return publicAPI.distanceEvent(distance);
+    return model._addWorldDeltas(publicAPI.distanceEvent(distance));
   };
   publicAPI.distanceEvent = distance => {
     const mapper = model.cprActor?.getMapper();

package/Widgets/Manipulators/LineManipulator.js

@@ -36,7 +36,7 @@ function projectDisplayToLine(x, y, lineOrigin, lineDirection, renderer, glRende
 function vtkLineManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLineManipulator');
-  publicAPI.handleEvent = (callData, glRenderWindow) => ({
+  publicAPI.handleEvent = (callData, glRenderWindow) => model._addWorldDeltas({
     worldCoords: projectDisplayToLine(callData.position.x, callData.position.y, publicAPI.getOrigin(callData), publicAPI.getNormal(callData), callData.pokedRenderer, glRenderWindow)
   });
 }

package/Widgets/Manipulators/PickerManipulator.js

@@ -20,9 +20,9 @@ function vtkPickerManipulator(publicAPI, model) {
     } else {
       model.position = null;
     }
-    return {
+    return model._addWorldDeltas({
       worldCoords: model.position
-    };
+    });
   };
 }
 

package/Widgets/Manipulators/PlaneManipulator.js

@@ -15,7 +15,7 @@ function intersectDisplayWithPlane(x, y, planeOrigin, planeNormal, renderer, glR
 function vtkPlaneManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPlaneManipulator');
-  publicAPI.handleEvent = (callData, glRenderWindow) => ({
+  publicAPI.handleEvent = (callData, glRenderWindow) => model._addWorldDeltas({
     worldCoords: intersectDisplayWithPlane(callData.position.x, callData.position.y, publicAPI.getOrigin(callData), publicAPI.getNormal(callData), callData.pokedRenderer, glRenderWindow)
   });
 }

package/Widgets/Manipulators/TrackballManipulator.js

@@ -36,9 +36,9 @@ function vtkTrackballManipulator(publicAPI, model) {
     const newDirection = trackballRotate(prevX, prevY, callData.position.x, callData.position.y, publicAPI.getOrigin(callData), publicAPI.getNormal(callData), callData.pokedRenderer);
     prevX = callData.position.x;
     prevY = callData.position.y;
-    return {
+    return model._addWorldDeltas({
       worldCoords: newDirection
-    };
+    });
   };
   publicAPI.reset = callData => {
     prevX = callData.position.x;

package/Widgets/Widgets3D/AngleWidget/behavior.js

@@ -1,4 +1,5 @@
 import { m as macro } from '../../../macros2.js';
+import { k as add } from '../../../Common/Core/Math/index.js';
 import vtkPointPicker from '../../../Rendering/Core/PointPicker.js';
 
 const MAX_POINTS = 3;
@@ -33,10 +34,10 @@ function widgetBehavior(publicAPI, model) {
     picker.initializePickList();
     picker.setPickList(publicAPI.getNestedProps());
     const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
+    const {
+      worldCoords
+    } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
     if (model.activeState === model.widgetState.getMoveHandle() && model.widgetState.getHandleList().length < MAX_POINTS && manipulator) {
-      const {
-        worldCoords
-      } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
       // Commit handle to location
       const moveHandle = model.widgetState.getMoveHandle();
       moveHandle.setOrigin(...worldCoords);
@@ -62,11 +63,17 @@ function widgetBehavior(publicAPI, model) {
     const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
     if (manipulator && model.pickable && model.dragable && model.activeState && model.activeState.getActive() && !ignoreKey(callData)) {
       const {
-        worldCoords
+        worldCoords,
+        worldDelta
       } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-      if (worldCoords.length && (model.activeState === model.widgetState.getMoveHandle() || model._isDragging) && model.activeState.setOrigin // e.g. the line is pickable but not draggable
-      ) {
-        model.activeState.setOrigin(worldCoords);
+      const isHandleMoving = model.activeState === model.widgetState.getMoveHandle() || model._isDragging;
+      if (isHandleMoving && worldCoords.length && model.activeState.setOrigin) {
+        const curOrigin = model.activeState.getOrigin();
+        if (curOrigin) {
+          model.activeState.setOrigin(add(curOrigin, worldDelta, []));
+        } else {
+          model.activeState.setOrigin(worldCoords);
+        }
         publicAPI.invokeInteractionEvent();
         return macro.EVENT_ABORT;
       }

package/Widgets/Widgets3D/ImageCroppingWidget/behavior.js

@@ -1,14 +1,17 @@
 import { m as macro } from '../../../macros2.js';
+import { k as add } from '../../../Common/Core/Math/index.js';
 import { handleTypeFromName, AXES, calculateCropperCenter, calculateDirection, transformVec3 } from './helpers.js';
 
 function widgetBehavior(publicAPI, model) {
   model._isDragging = false;
   publicAPI.setDisplayCallback = callback => model.representations[0].setDisplayCallback(callback);
-  publicAPI.handleLeftButtonPress = () => {
+  publicAPI.handleLeftButtonPress = callData => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
     if (model.dragable) {
+      // updates worldDelta
+      model.activeState.getManipulator().handleEvent(callData, model._apiSpecificRenderWindow);
       model._isDragging = true;
       model._apiSpecificRenderWindow.setCursor('grabbing');
       model._interactor.requestAnimation(publicAPI);
@@ -42,16 +45,23 @@ function widgetBehavior(publicAPI, model) {
         const planes = model.widgetState.getCroppingPlanes().getPlanes();
         const indexToWorldT = model.widgetState.getIndexToWorldT();
         let worldCoords = [];
+        let worldDelta = [];
         if (type === 'corners') {
           // manipulator should be a plane manipulator
-          worldCoords = manipulator.handleEvent(callData, model._apiSpecificRenderWindow).worldCoords;
+          ({
+            worldCoords,
+            worldDelta
+          } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow));
         }
         if (type === 'faces') {
           // get center of current crop box
           const worldCenter = calculateCropperCenter(planes, indexToWorldT);
           manipulator.setHandleOrigin(worldCenter);
           manipulator.setHandleNormal(calculateDirection(model.activeState.getOrigin(), worldCenter));
-          worldCoords = manipulator.handleEvent(callData, model._apiSpecificRenderWindow).worldCoords;
+          ({
+            worldCoords,
+            worldDelta
+          } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow));
         }
         if (type === 'edges') {
           // constrain to a plane with a normal parallel to the edge
@@ -61,9 +71,12 @@ function widgetBehavior(publicAPI, model) {
           // get center of current crop box
           const worldCenter = calculateCropperCenter(planes, indexToWorldT);
           manipulator.setHandleNormal(calculateDirection(handle.getOrigin(), worldCenter));
-          worldCoords = manipulator.handleEvent(callData, model._apiSpecificRenderWindow).worldCoords;
+          ({
+            worldCoords,
+            worldDelta
+          } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow));
         }
-        if (worldCoords.length) {
+        if (worldCoords.length && worldDelta.length) {
           // transform worldCoords to indexCoords, and then update the croppingPlanes() state with setPlanes().
           const worldToIndexT = model.widgetState.getWorldToIndexT();
           const indexCoords = transformVec3(worldCoords, worldToIndexT);
@@ -74,7 +87,7 @@ function widgetBehavior(publicAPI, model) {
               planes[i * 2 + 1] = indexCoords[i];
             }
           }
-          model.activeState.setOrigin(...worldCoords);
+          model.activeState.setOrigin(add(model.activeState.getOrigin(), worldDelta, []));
           model.widgetState.getCroppingPlanes().setPlanes(...planes);
           return macro.EVENT_ABORT;
         }

package/Widgets/Widgets3D/ImplicitPlaneWidget.js

@@ -1,4 +1,5 @@
 import { m as macro } from '../../macros2.js';
+import { k as add } from '../../Common/Core/Math/index.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkImplicitPlaneRepresentation from '../Representations/ImplicitPlaneRepresentation.js';
 import vtkLineManipulator from '../Manipulators/LineManipulator.js';
@@ -13,6 +14,8 @@ import { ViewTypes } from '../Core/WidgetManager/Constants.js';
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkPlaneWidget');
   model._isDragging = false;
+  // used to track the constrained widget position
+  model._draggingWidgetOrigin = [0, 0, 0];
   publicAPI.setDisplayCallback = callback => model.representations[0].setDisplayCallback(callback);
   publicAPI.updateCursor = () => {
     switch (model.activeState.getUpdateMethodName()) {
@@ -38,7 +41,11 @@ function widgetBehavior(publicAPI, model) {
     model.planeManipulator.setWidgetOrigin(model.widgetState.getOrigin());
     model.trackballManipulator.reset(callData); // setup trackball delta
 
+    // updates worldDelta
+    model.lineManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    model.planeManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
     if (model.dragable) {
+      model._draggingWidgetOrigin = model.widgetState.getOrigin();
       model._isDragging = true;
       model._apiSpecificRenderWindow.setCursor('grabbing');
       model._interactor.requestAnimation(publicAPI);
@@ -80,10 +87,14 @@ function widgetBehavior(publicAPI, model) {
   publicAPI.updateFromOrigin = callData => {
     model.planeManipulator.setWidgetNormal(model.widgetState.getNormal());
     const {
-      worldCoords
+      worldCoords,
+      worldDelta
     } = model.planeManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-    if (model.widgetState.containsPoint(worldCoords)) {
-      model.activeState.setOrigin(worldCoords);
+    add(model._draggingWidgetOrigin, worldDelta, model._draggingWidgetOrigin);
+
+    // test containment of interaction coords
+    if (model.widgetState.containsPoint(...worldCoords)) {
+      model.activeState.setOrigin(model._draggingWidgetOrigin);
     }
   };
 
@@ -93,10 +104,11 @@ function widgetBehavior(publicAPI, model) {
     // Move origin along normal axis
     model.lineManipulator.setWidgetNormal(model.activeState.getNormal());
     const {
-      worldCoords
+      worldDelta
     } = model.lineManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-    if (model.widgetState.containsPoint(...worldCoords)) {
-      model.activeState.setOrigin(worldCoords);
+    add(model._draggingWidgetOrigin, worldDelta, model._draggingWidgetOrigin);
+    if (model.widgetState.containsPoint(...model._draggingWidgetOrigin)) {
+      model.activeState.setOrigin(model._draggingWidgetOrigin);
     }
   };
 

package/Widgets/Widgets3D/LabelWidget/behavior.js

@@ -1,4 +1,5 @@
 import { m as macro } from '../../../macros2.js';
+import { k as add } from '../../../Common/Core/Math/index.js';
 
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkLabelWidgetProp');
@@ -37,10 +38,10 @@ function widgetBehavior(publicAPI, model) {
       return macro.VOID;
     }
     const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
+    const {
+      worldCoords
+    } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
     if (model.activeState === model.widgetState.getMoveHandle() && manipulator) {
-      const {
-        worldCoords
-      } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
       // Commit handle to location
       const moveHandle = model.widgetState.getMoveHandle();
       moveHandle.setOrigin(worldCoords);
@@ -87,14 +88,17 @@ function widgetBehavior(publicAPI, model) {
     const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
     if (manipulator && model.pickable && model.dragable && model.activeState && model.activeState.getActive() && !ignoreKey(callData)) {
       const {
-        worldCoords
+        worldCoords,
+        worldDelta
       } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-      if (worldCoords.length && (model.activeState === model.widgetState.getMoveHandle() || model._isDragging)) {
-        model.activeState.setOrigin(worldCoords);
-        model.widgetState.getText().setOrigin(model.activeState.getOrigin());
-        publicAPI.invokeInteractionEvent();
-        return macro.EVENT_ABORT;
-      }
+      const isHandleMoving = model.widgetState.getMoveHandle() === model.activeState || model._isDragging;
+      if (!isHandleMoving || !worldCoords.length || !worldDelta.length) return macro.VOID;
+      const curOrigin = model.activeState.getOrigin();
+      const newOrigin = curOrigin ? add(curOrigin, worldDelta, []) : worldCoords;
+      model.activeState.setOrigin(newOrigin);
+      model.widgetState.getText().setOrigin(newOrigin);
+      publicAPI.invokeInteractionEvent();
+      return macro.EVENT_ABORT;
     }
     return macro.VOID;
   };

package/Widgets/Widgets3D/LineWidget/behavior.js

@@ -1,6 +1,6 @@
 import Constants from './Constants.js';
 import { m as macro } from '../../../macros2.js';
-import { s as subtract, k as add, l as normalize } from '../../../Common/Core/Math/index.js';
+import { k as add, s as subtract, l as normalize } from '../../../Common/Core/Math/index.js';
 import { getNumberOfPlacedHandles, isHandlePlaced, calculateTextPosition, updateTextPosition, getPoint } from './helpers.js';
 
 const {
@@ -47,7 +47,7 @@ function widgetBehavior(publicAPI, model) {
   function updateCursor(callData) {
     model._isDragging = true;
     const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
-    model.previousPosition = manipulator.handleEvent(callData, model._apiSpecificRenderWindow).worldCoords;
+    manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
     model._apiSpecificRenderWindow.setCursor('grabbing');
     model._interactor.requestAnimation(publicAPI);
   }
@@ -181,22 +181,32 @@ function widgetBehavior(publicAPI, model) {
     const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
     if (manipulator && model.pickable && model.dragable && model.activeState && model.activeState.getActive() && !ignoreKey(callData)) {
       const {
-        worldCoords
+        worldCoords,
+        worldDelta
       } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-      const translation = model.previousPosition ? subtract(worldCoords, model.previousPosition, []) : [0, 0, 0];
-      model.previousPosition = worldCoords;
-      if (
+      const isHandleMoving =
       // is placing first or second handle
       model.activeState === model.widgetState.getMoveHandle() ||
       // is dragging already placed first or second handle
-      model._isDragging) {
-        if (model.activeState.setOrigin) {
-          model.activeState.setOrigin(worldCoords);
+      model._isDragging;
+
+      // the line state doesn't have setOrigin
+      const isDraggingLine = !model.activeState.setOrigin;
+      if (isHandleMoving) {
+        if (!isDraggingLine) {
+          const curOrigin = model.activeState.getOrigin();
+          if (curOrigin) {
+            model.activeState.setOrigin(add(model.activeState.getOrigin(), worldDelta, []));
+          } else {
+            model.activeState.setOrigin(worldCoords);
+          }
           publicAPI.updateHandleVisibility(publicAPI.getHandleIndex(model.activeState));
         } else {
-          // Dragging line
-          publicAPI.getHandle(0).setOrigin(add(publicAPI.getHandle(0).getOrigin(), translation, []));
-          publicAPI.getHandle(1).setOrigin(add(publicAPI.getHandle(1).getOrigin(), translation, []));
+          // Dragging line; move all handles
+          for (let i = 0; i < 2; i++) {
+            const handleOrigin = publicAPI.getHandle(i).getOrigin();
+            publicAPI.getHandle(i).setOrigin(add(handleOrigin, worldDelta, []));
+          }
         }
         publicAPI.updateHandleOrientations();
         updateTextPosition(model);

package/Widgets/Widgets3D/PolyLineWidget/behavior.js

@@ -1,4 +1,5 @@
 import { m as macro } from '../../../macros2.js';
+import { k as add } from '../../../Common/Core/Math/index.js';
 
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkPolyLineWidgetProp');
@@ -23,11 +24,20 @@ function widgetBehavior(publicAPI, model) {
       return macro.VOID;
     }
     const {
-      worldCoords
+      worldCoords,
+      worldDelta
     } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-    if (worldCoords.length && (model.activeState === model.widgetState.getMoveHandle() || model._isDragging) && model.activeState.setOrigin // e.g. the line is pickable but not draggable
-    ) {
-      model.activeState.setOrigin(worldCoords);
+    const isHandleMoving = model.activeState === model.widgetState.getMoveHandle() || model._isDragging;
+
+    // the line is pickable but not draggable
+    const isPickingLine = !model.activeState.setOrigin;
+    if (worldCoords.length && isHandleMoving && !isPickingLine) {
+      const curOrigin = model.activeState.getOrigin();
+      if (curOrigin) {
+        model.activeState.setOrigin(add(curOrigin, worldDelta, []));
+      } else {
+        model.activeState.setOrigin(worldCoords);
+      }
       publicAPI.invokeInteractionEvent();
       return macro.EVENT_ABORT;
     }
@@ -73,6 +83,8 @@ function widgetBehavior(publicAPI, model) {
       newHandle.setScale1(moveHandle.getScale1());
       newHandle.setManipulator(manipulator);
     } else if (model.dragable) {
+      // Update worldDelta
+      manipulator.handleEvent(e, model._apiSpecificRenderWindow);
       model._isDragging = true;
       model._apiSpecificRenderWindow.setCursor('grabbing');
       model._interactor.requestAnimation(publicAPI);

package/Widgets/Widgets3D/PolyLineWidget.js

@@ -53,11 +53,6 @@ function vtkPolyLineWidget(publicAPI, model) {
   // initialization
   // --------------------------------------------------------------------------
 
-  model.widgetState.onBoundsChange(bounds => {
-    const center = [(bounds[0] + bounds[1]) * 0.5, (bounds[2] + bounds[3]) * 0.5, (bounds[4] + bounds[5]) * 0.5];
-    model.widgetState.getMoveHandle().setOrigin(center);
-  });
-
   // Default manipulator
   publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
     useCameraFocalPoint: true,

package/Widgets/Widgets3D/SeedWidget/behavior.js

@@ -5,7 +5,6 @@ function widgetBehavior(publicAPI, model) {
   const moveHandle = model.widgetState.getMoveHandle();
   moveHandle.setVisible(true);
   model._isDragging = false;
-  model.previousPosition = null;
   function isValidHandle(handle) {
     return handle === moveHandle;
   }
@@ -32,7 +31,6 @@ function widgetBehavior(publicAPI, model) {
     if (model.activeState === moveHandle) {
       if (!moveHandle.getOrigin() && worldCoords) {
         moveHandle.setOrigin(worldCoords);
-        model.previousPosition = [...worldCoords];
       }
     }
     model._isDragging = true;
@@ -46,7 +44,6 @@ function widgetBehavior(publicAPI, model) {
       return macro.VOID;
     }
     if (isPlaced()) {
-      model.previousPosition = null;
       model._widgetManager.enablePicking();
       model._apiSpecificRenderWindow.setCursor('pointer');
       model._isDragging = false;
@@ -63,10 +60,7 @@ function widgetBehavior(publicAPI, model) {
     }
     if (!model.activeState) throw Error('no activestate');
     const worldCoords = currentWorldCoords(e);
-    if (worldCoords) {
-      model.activeState.setOrigin(worldCoords);
-      model.previousPosition = worldCoords;
-    }
+    model.activeState.setOrigin(worldCoords);
     return macro.VOID;
   };
   publicAPI.grabFocus = () => {

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -295,7 +295,8 @@ function widgetBehavior(publicAPI, model) {
       model.shapeHandle.setDirection(normal);
     }
     const {
-      worldCoords
+      worldCoords,
+      worldDelta
     } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
     if (!worldCoords.length) {
       return macro.VOID;
@@ -311,11 +312,11 @@ function widgetBehavior(publicAPI, model) {
       }
     } else if (model._isDragging) {
       if (model.activeState === model.point1Handle) {
-        model.point1Handle.setOrigin(worldCoords);
-        model.point1 = worldCoords;
+        vtkMath.add(model.point1Handle.getOrigin(), worldDelta, model.point1);
+        model.point1Handle.setOrigin(model.point1);
       } else {
-        model.point2Handle.setOrigin(worldCoords);
-        model.point2 = worldCoords;
+        vtkMath.add(model.point2Handle.getOrigin(), worldDelta, model.point2);
+        model.point2Handle.setOrigin(model.point2);
       }
       publicAPI.updateShapeBounds();
       publicAPI.invokeInteractionEvent();
@@ -332,10 +333,10 @@ function widgetBehavior(publicAPI, model) {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable || !manipulator) {
       return macro.VOID;
     }
+    const {
+      worldCoords
+    } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
     if (model.hasFocus) {
-      const {
-        worldCoords
-      } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
       if (!model.point1) {
         model.point1Handle.setOrigin(worldCoords);
         publicAPI.placePoint1(model.point1Handle.getOrigin());

package/Widgets/Widgets3D/SphereWidget/behavior.js

@@ -1,4 +1,5 @@
 import { m as macro } from '../../../macros2.js';
+import { k as add } from '../../../Common/Core/Math/index.js';
 import { vec3 } from 'gl-matrix';
 
 function widgetBehavior(publicAPI, model) {
@@ -10,8 +11,6 @@ function widgetBehavior(publicAPI, model) {
 
   // Set while moving the center or border handle.
   model._isDragging = false;
-  // The last world coordinate of the mouse cursor during dragging.
-  model.previousPosition = null;
   model.classHierarchy.push('vtkSphereWidgetProp');
   moveHandle.setVisible(true);
   centerHandle.setVisible(false);
@@ -47,7 +46,7 @@ function widgetBehavior(publicAPI, model) {
   }
   function currentWorldCoords(e) {
     const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
-    return manipulator.handleEvent(e, model._apiSpecificRenderWindow).worldCoords;
+    return manipulator.handleEvent(e, model._apiSpecificRenderWindow);
   }
 
   // Update the sphere's center and radius.  Example:
@@ -75,19 +74,22 @@ function widgetBehavior(publicAPI, model) {
       model.activeState = null;
       return macro.VOID;
     }
-    const worldCoords = currentWorldCoords(e);
+    const {
+      worldCoords
+    } = currentWorldCoords(e);
     if (model.activeState === moveHandle) {
       // Initial sphere placement.
       if (!centerHandle.getOrigin()) {
         centerHandle.setOrigin(worldCoords);
       } else if (!borderHandle.getOrigin()) {
         borderHandle.setOrigin(worldCoords);
+        publicAPI.loseFocus();
       }
       updateSphere();
+      return macro.EVENT_ABORT;
     }
     model._isDragging = true;
     model._apiSpecificRenderWindow.setCursor('grabbing');
-    model.previousPosition = [...currentWorldCoords(e)];
     publicAPI.invokeStartInteractionEvent();
     return macro.EVENT_ABORT;
   };
@@ -97,7 +99,6 @@ function widgetBehavior(publicAPI, model) {
       return macro.VOID;
     }
     if (isPlaced()) {
-      model.previousPosition = null;
       model._widgetManager.enablePicking();
       model._apiSpecificRenderWindow.setCursor('pointer');
       model._isDragging = false;
@@ -108,43 +109,33 @@ function widgetBehavior(publicAPI, model) {
     return macro.EVENT_ABORT;
   };
   publicAPI.handleMouseMove = e => {
-    if (!model._isDragging) {
-      model.activeState = null;
-      return macro.VOID;
+    if (!model.activeState) return macro.VOID;
+    const {
+      worldCoords,
+      worldDelta
+    } = currentWorldCoords(e);
+    if (model.hasFocus) {
+      model.activeState.setOrigin(worldCoords);
+    } else if (model._isDragging) {
+      model.activeState.setOrigin(add(model.activeState.getOrigin(), worldDelta, []));
     }
-    if (!model.activeState) throw Error('no activestate');
-    const worldCoords = currentWorldCoords(e);
-    model.activeState.setOrigin(worldCoords);
-    if (model.activeState === centerHandle) {
-      // When the sphere is fully placed, and the user is moving the
-      // center, we move the whole sphere.
-      if (borderHandle.getOrigin()) {
-        if (!model.previousPosition) {
-          // !previousPosition here happens only immediately
-          // after grabFocus, but grabFocus resets
-          // borderHandle.origin.
-          throw Error(`no pos ${model.activeState} ${model.previousPosition}`);
-        }
-        const translation = vec3.sub(vec3.create(), worldCoords, model.previousPosition);
-        borderHandle.setOrigin(vec3.add(vec3.create(), borderHandle.getOrigin(), translation));
-      }
-    }
-    model.previousPosition = worldCoords;
     updateSphere();
     return macro.VOID;
   };
+  const superGrabFocus = publicAPI.grabFocus;
   publicAPI.grabFocus = () => {
+    superGrabFocus();
     moveHandle.setVisible(true);
     centerHandle.setVisible(false);
     borderHandle.setVisible(false);
     centerHandle.setOrigin(null);
     borderHandle.setOrigin(null);
-    model._isDragging = true;
     model.activeState = moveHandle;
     model._interactor.render();
   };
+  const superLoseFocus = publicAPI.loseFocus;
   publicAPI.loseFocus = () => {
-    model._isDragging = false;
+    superLoseFocus();
     model.activeState = null;
   };
 }

package/Widgets/Widgets3D/SplineWidget/behavior.js

@@ -1,4 +1,5 @@
 import { m as macro } from '../../../macros2.js';
+import { k as add } from '../../../Common/Core/Math/index.js';
 import { vec3 } from 'gl-matrix';
 
 function widgetBehavior(publicAPI, model) {
@@ -153,9 +154,13 @@ function widgetBehavior(publicAPI, model) {
   // --------------------------------------------------------------------------
 
   publicAPI.handleLeftButtonPress = e => {
-    if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
+    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
+    if (!manipulator || !model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
+
+    // update worldDelta
+    manipulator.handleEvent(e, model._apiSpecificRenderWindow);
     if (model.activeState === model.moveHandle) {
       if (model.widgetState.getHandleList().length === 0) {
         addPoint();
@@ -230,7 +235,8 @@ function widgetBehavior(publicAPI, model) {
       return macro.VOID;
     }
     const {
-      worldCoords
+      worldCoords,
+      worldDelta
     } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
     const hoveredHandle = getHoveredHandle();
     if (hoveredHandle) {
@@ -245,8 +251,14 @@ function widgetBehavior(publicAPI, model) {
     if (model.lastHandle) {
       model.lastHandle.setVisible(true);
     }
-    if (worldCoords.length && (model._isDragging || model.activeState === model.moveHandle)) {
-      model.activeState.setOrigin(worldCoords);
+    const isHandleMoving = model._isDragging || model.activeState === model.moveHandle;
+    if (worldCoords.length && isHandleMoving) {
+      const curOrigin = model.activeState.getOrigin();
+      if (curOrigin) {
+        model.activeState.setOrigin(add(curOrigin, worldDelta, []));
+      } else {
+        model.activeState.setOrigin(worldCoords);
+      }
       if (model._isDragging) {
         model.draggedPoint = true;
       }

package/package.json

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