@kitware/vtk.js 30.5.3 → 30.6.1

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.d.ts

@@ -1,28 +1,27 @@
-import { IAbstractManipulatorInitialValues, vtkAbstractManipulator } from './AbstractManipulator';
+import {
+  IAbstractManipulatorInitialValues,
+  vtkAbstractManipulator,
+} from './AbstractManipulator';
 import vtkPicker from './../../Rendering/Core/Picker';
 
 /**
  *
  */
-export interface IPickerManipulatorInitialValues extends IAbstractManipulatorInitialValues {
-
-}
+export interface IPickerManipulatorInitialValues
+  extends IAbstractManipulatorInitialValues {}
 
 export interface vtkPickerManipulator extends vtkAbstractManipulator {
-
   /**
-	 *
-	 */
-	getPicker(): vtkPicker;
+   *
+   */
+  getPicker(): vtkPicker;
 
   /**
-	 *
-	 */
-	setPicker(picker: vtkPicker): void;
-
+   *
+   */
+  setPicker(picker: vtkPicker): void;
 }
 
-
 /**
  * Method use to decorate a given object (publicAPI+model) with vtkPickerManipulator characteristics.
  *
@@ -30,19 +29,24 @@ export interface vtkPickerManipulator extends vtkAbstractManipulator {
  * @param model object on which data structure will be bounds (protected)
  * @param {IPickerManipulatorInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPickerManipulatorInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPickerManipulatorInitialValues
+): void;
 
 /**
  * Method use to create a new instance of vtkPickerManipulator
  */
-export function newInstance(initialValues?: IPickerManipulatorInitialValues): vtkPickerManipulator;
-
+export function newInstance(
+  initialValues?: IPickerManipulatorInitialValues
+): vtkPickerManipulator;
 
 /**
  * vtkPickerManipulator.
  */
 export declare const vtkPickerManipulator: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkPickerManipulator;

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.d.ts

@@ -1,17 +1,16 @@
-import { IAbstractManipulatorInitialValues, vtkAbstractManipulator } from './AbstractManipulator';
+import {
+  IAbstractManipulatorInitialValues,
+  vtkAbstractManipulator,
+} from './AbstractManipulator';
 import { Vector3 } from './../../types';
 
 /**
  *
  */
-export interface IPlaneManipulatorInitialValues extends IAbstractManipulatorInitialValues {
-
-}
-
-export interface vtkPlaneManipulator extends vtkAbstractManipulator {
-
-}
+export interface IPlaneManipulatorInitialValues
+  extends IAbstractManipulatorInitialValues {}
 
+export interface vtkPlaneManipulator extends vtkAbstractManipulator {}
 
 /**
  * Method use to decorate a given object (publicAPI+model) with vtkPlaneManipulator characteristics.
@@ -20,31 +19,43 @@ export interface vtkPlaneManipulator extends vtkAbstractManipulator {
  * @param model object on which data structure will be bounds (protected)
  * @param {IPlaneManipulatorInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPlaneManipulatorInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPlaneManipulatorInitialValues
+): void;
 
 /**
  * Method use to create a new instance of vtkPlaneManipulator
  */
-export function newInstance(initialValues?: IPlaneManipulatorInitialValues): vtkPlaneManipulator;
+export function newInstance(
+  initialValues?: IPlaneManipulatorInitialValues
+): vtkPlaneManipulator;
 
 /**
- * 
- * @param {Number} x 
- * @param {Number} y 
- * @param {Vector3} planeOrigin 
- * @param {Vector3} planeNormal 
- * @param renderer 
- * @param glRenderWindow 
+ *
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Vector3} planeOrigin
+ * @param {Vector3} planeNormal
+ * @param renderer
+ * @param glRenderWindow
  */
-export function intersectDisplayWithPlane(x: number, y: number, planeOrigin: Vector3, planeNormal: Vector3, renderer: any, glRenderWindow: any): Vector3;
-
+export function intersectDisplayWithPlane(
+  x: number,
+  y: number,
+  planeOrigin: Vector3,
+  planeNormal: Vector3,
+  renderer: any,
+  glRenderWindow: any
+): Vector3;
 
 /**
  * vtkPlaneManipulator.
  */
 export declare const vtkPlaneManipulator: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
-	intersectDisplayWithPlane: typeof intersectDisplayWithPlane;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  intersectDisplayWithPlane: typeof intersectDisplayWithPlane;
 };
 export default vtkPlaneManipulator;

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.d.ts

@@ -1,22 +1,22 @@
-import { IAbstractManipulatorInitialValues, vtkAbstractManipulator } from './AbstractManipulator';
+import {
+  IAbstractManipulatorInitialValues,
+  vtkAbstractManipulator,
+} from './AbstractManipulator';
 import { Vector3 } from './../../types';
 
 /**
  *
  */
-export interface ITrackballManipulatorInitialValues extends IAbstractManipulatorInitialValues {
-
-}
+export interface ITrackballManipulatorInitialValues
+  extends IAbstractManipulatorInitialValues {}
 
 export interface vtkTrackballManipulator extends vtkAbstractManipulator {
-
-	/**
-	 * 
-	 */
-	reset(callData: any): void;
+  /**
+   *
+   */
+  reset(callData: any): void;
 }
 
-
 /**
  * Method use to decorate a given object (publicAPI+model) with vtkTrackballManipulator characteristics.
  *
@@ -24,33 +24,47 @@ export interface vtkTrackballManipulator extends vtkAbstractManipulator {
  * @param model object on which data structure will be bounds (protected)
  * @param {ITrackballManipulatorInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: ITrackballManipulatorInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ITrackballManipulatorInitialValues
+): void;
 
 /**
  * Method use to create a new instance of vtkTrackballManipulator
  */
-export function newInstance(initialValues?: ITrackballManipulatorInitialValues): vtkTrackballManipulator;
+export function newInstance(
+  initialValues?: ITrackballManipulatorInitialValues
+): vtkTrackballManipulator;
 
 /**
- * 
- * @param {Number} prevX 
- * @param {Number} prevY 
- * @param {Number} curX 
- * @param {Number} curY 
- * @param {Vector3} origin 
- * @param {Vector3} direction 
- * @param renderer 
- * @param glRenderWindow 
+ *
+ * @param {Number} prevX
+ * @param {Number} prevY
+ * @param {Number} curX
+ * @param {Number} curY
+ * @param {Vector3} origin
+ * @param {Vector3} direction
+ * @param renderer
+ * @param glRenderWindow
  */
-export function trackballRotate(prevX: number, prevY: number, curX: number, curY: number, origin: Vector3, direction: Vector3, renderer: any, glRenderWindow: any): void;
-
+export function trackballRotate(
+  prevX: number,
+  prevY: number,
+  curX: number,
+  curY: number,
+  origin: Vector3,
+  direction: Vector3,
+  renderer: any,
+  glRenderWindow: any
+): void;
 
 /**
  * vtkTrackballManipulator.
  */
 export declare const vtkTrackballManipulator: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
-	trackballRotate: typeof trackballRotate;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  trackballRotate: typeof trackballRotate;
 };
 export default vtkTrackballManipulator;

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/Representations/WidgetRepresentation.d.ts

@@ -3,51 +3,51 @@ import vtkPolyData from './../../Common/DataModel/PolyData';
 import { vtkObject } from './../../interfaces';
 import vtkProp from './../../Rendering/Core/Prop';
 export interface IDisplayScaleParams {
-	dispHeightFactor: number,
-	cameraPosition: number[],
-	cameraDir: number[],
-	isParallel: boolean,
-	rendererPixelDims: number[],
+  dispHeightFactor: number;
+  cameraPosition: number[];
+  cameraDir: number[];
+  isParallel: boolean;
+  rendererPixelDims: number[];
 }
 
 export interface IWidgetRepresentationInitialValues {
-    labels?: Array<any>,
-    coincidentTopologyParameters?: object,
-    displayScaleParams?: IDisplayScaleParams,
-    scaleInPixels?: boolean
+  labels?: Array<any>;
+  coincidentTopologyParameters?: object;
+  displayScaleParams?: IDisplayScaleParams;
+  scaleInPixels?: boolean;
 }
 
 export interface vtkWidgetRepresentation extends vtkProp {
-    getLabels(): Array<any>;
-    setLabels(labels: Array<any>): void;
+  getLabels(): Array<any>;
+  setLabels(labels: Array<any>): void;
 
-    /**
-     * Gets the coincident topology parameters applied on the actor mappers
-     */
-    getCoincidentTopologyParameters(): object;
-    /**
-     * Sets the coincident topology parameters applied on the actor mappers
-     */
-    setCoincidentTopologyParameters(parameters: object): boolean;
+  /**
+   * Gets the coincident topology parameters applied on the actor mappers
+   */
+  getCoincidentTopologyParameters(): object;
+  /**
+   * Sets the coincident topology parameters applied on the actor mappers
+   */
+  setCoincidentTopologyParameters(parameters: object): boolean;
 
-    /**
-     * Sets the current view and camera scale parameters.
-     * Called by the WidgetManager.
-     * @see setScaleInPixels()
-     */
-    setDisplayScaleParams(params: object): boolean;
+  /**
+   * Sets the current view and camera scale parameters.
+   * Called by the WidgetManager.
+   * @see setScaleInPixels()
+   */
+  setDisplayScaleParams(params: object): boolean;
 
-    /**
-     * Gets wether actors should have a fix size in display coordinates.
-     * @see setScaleInPixels()
-     */
-    getScaleInPixels(): boolean;
+  /**
+   * Gets wether actors should have a fix size in display coordinates.
+   * @see setScaleInPixels()
+   */
+  getScaleInPixels(): boolean;
 
-    /**
-     * Sets wether actors should have a fix size in display coordinates.
-     * @see getScaleInPixels()
-     */
-    setScaleInPixels(scale: boolean): boolean;
+  /**
+   * Sets wether actors should have a fix size in display coordinates.
+   * @see getScaleInPixels()
+   */
+  setScaleInPixels(scale: boolean): boolean;
 }
 
 /**
@@ -57,27 +57,36 @@ export interface vtkWidgetRepresentation extends vtkProp {
  * @param model object on which data structure will be bounds (protected)
  * @param {IWidgetRepresentationInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IWidgetRepresentationInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IWidgetRepresentationInitialValues
+): void;
 
 /**
  * Method use to create a new instance of vtkWidgetRepresentation
  * @param {IWidgetRepresentationInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IWidgetRepresentationInitialValues): vtkWidgetRepresentation;
+export function newInstance(
+  initialValues?: IWidgetRepresentationInitialValues
+): vtkWidgetRepresentation;
 
 /**
  * Static function to get the pixel size of a 3D point.
  * @param {Number[]} worldCoord 3D point in world coordinates
  * @param {IDisplayScaleParams} displayScaleParams Display and camera information
  */
-export function getPixelWorldHeightAtCoord(worldCoord: number[], displayScaleParams: IDisplayScaleParams): number[];
+export function getPixelWorldHeightAtCoord(
+  worldCoord: number[],
+  displayScaleParams: IDisplayScaleParams
+): number[];
 
 export interface IWidgetPipeline {
-	source?: object,
-	filter?: object,
-	glyph?: object,
-	mapper: object,
-	actor: object
+  source?: object;
+  filter?: object;
+  glyph?: object;
+  mapper: object;
+  actor: object;
 }
 /**
  * If provided, connects `source` (dataset or filter) to `filter`.
@@ -100,14 +109,16 @@ export function connectPipeline(pipeline: IWidgetPipeline): void;
  * @param {String} dataType The typed array type name.
  * @param {Number} numberOfComponents The number of components of the array.
  */
- export function allocateArray(polyData: vtkPolyData,
-    name: string,
-    numberOfTuples: number,
-    dataType?: string,
-    numberOfComponents?: number): vtkDataArray|null;
+export function allocateArray(
+  polyData: vtkPolyData,
+  name: string,
+  numberOfTuples: number,
+  dataType?: string,
+  numberOfComponents?: number
+): vtkDataArray | null;
 
 export declare const vtkWidgetRepresentation: {
-	newInstance: typeof newInstance;
-	extend: typeof extend;
-}
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
 export default vtkWidgetRepresentation;

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()) {
@@ -34,11 +37,33 @@ function widgetBehavior(publicAPI, model) {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
-    model.lineManipulator.setWidgetOrigin(model.widgetState.getOrigin());
-    model.planeManipulator.setWidgetOrigin(model.widgetState.getOrigin());
+    model.lineManipulator.setWidgetOrigin(model.activeState.getOrigin());
+    model.lineManipulator.setWidgetNormal(model.activeState.getNormal());
+    model.planeManipulator.setWidgetOrigin(model.activeState.getOrigin());
+    model.planeManipulator.setWidgetNormal(model.activeManipulator.getNormal());
     model.trackballManipulator.reset(callData); // setup trackball delta
+    model.trackballManipulator.setWidgetNormal(model.activeState.getNormal());
 
+    // update worldDelta with the proper manipulator
+    let activeManipulator = null;
+    switch (model.activeState.getUpdateMethodName()) {
+      case 'updateFromOrigin':
+        activeManipulator = model.planeManipulator;
+        break;
+      case 'updateFromPlane':
+        activeManipulator = model.lineManipulator;
+        break;
+      case 'updateFromNormal':
+        activeManipulator = model.trackballManipulator;
+        break;
+      // skip
+    }
+
+    if (activeManipulator) {
+      activeManipulator.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 +105,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 +122,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);
     }
   };