@kitware/vtk.js 27.4.6 → 28.0.0

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -2,10 +2,9 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../../macros.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkLine from '../../../Common/DataModel/Line.js';
-import vtkPlanePointManipulator from '../../Manipulators/PlaneManipulator.js';
-import { k as add, l as normalize, d as dot, j as cross, s as subtract, m as multiplyAccumulate, w as multiplyScalar, S as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
-import { getOtherLineName, updateState, boundPointOnPlane, getLinePlaneName, getLineInPlaneName, rotateVector } from './helpers.js';
-import { InteractionMethodsName, lineNames, ScrollingMethods, planeNameToViewType } from './Constants.js';
+import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, S as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { getLineNames, getOtherLineName, updateState, boundPointOnPlane, getLinePlaneName, getLineInPlaneName, rotateVector } from './helpers.js';
+import { InteractionMethodsName, ScrollingMethods, planeNameToViewType } from './Constants.js';
 
 function widgetBehavior(publicAPI, model) {
   model._isDragging = false;
@@ -46,7 +45,7 @@ function widgetBehavior(publicAPI, model) {
 
 
   publicAPI.getActiveLineName = function () {
-    return lineNames.find(function (lineName) {
+    return getLineNames(model.widgetState).find(function (lineName) {
       return model.widgetState.getStatesWithLabel(lineName).includes(model.activeState);
     });
   }; // FIXME: label information should be accessible from activeState instead of parent state.
@@ -67,19 +66,27 @@ function widgetBehavior(publicAPI, model) {
   publicAPI.getOtherLineHandle = function (lineName) {
     var _model$widgetState$2, _model$widgetState2;
 
-    return (_model$widgetState$2 = (_model$widgetState2 = model.widgetState)["getAxis".concat(getOtherLineName(lineName))]) === null || _model$widgetState$2 === void 0 ? void 0 : _model$widgetState$2.call(_model$widgetState2);
+    return (_model$widgetState$2 = (_model$widgetState2 = model.widgetState)["getAxis".concat(getOtherLineName(model.widgetState, lineName))]) === null || _model$widgetState$2 === void 0 ? void 0 : _model$widgetState$2.call(_model$widgetState2);
   }; // FIXME: label information should be accessible from activeState instead of parent state.
 
   /**
    * There are 2 rotation handles per axis: 'point0' and 'point1'.
    * This function returns which rotation handle (point0 or point1) is currently active.
    * ActiveState must be a RotationHandle.
-   * @returns 'point0' or 'point1'
+   * @returns 'point0', 'point1' or null if no point is active (e.g. line is being rotated)
    */
 
 
   publicAPI.getActiveRotationPointName = function () {
-    return model.widgetState.getStatesWithLabel('point0').includes(model.activeState) ? 'point0' : 'point1';
+    if (model.widgetState.getStatesWithLabel('point0').includes(model.activeState)) {
+      return 'point0';
+    }
+
+    if (model.widgetState.getStatesWithLabel('point1').includes(model.activeState)) {
+      return 'point1';
+    }
+
+    return null;
   };
 
   publicAPI.startScrolling = function (newPosition) {
@@ -122,12 +129,18 @@ function widgetBehavior(publicAPI, model) {
 
   publicAPI.handleLeftButtonPress = function (callData) {
     if (model.activeState && model.activeState.getActive()) {
+      var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
+
       model._isDragging = true;
       var viewType = model.viewType;
       var currentPlaneNormal = model.widgetState.getPlanes()[viewType].normal;
-      model.planeManipulator.setWidgetOrigin(model.widgetState.getCenter());
-      model.planeManipulator.setWidgetNormal(currentPlaneNormal);
-      var worldCoords = model.planeManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+      var manipulator = (_model$activeState$ge = (_model$activeState = model.activeState) === null || _model$activeState === void 0 ? void 0 : (_model$activeState$ge2 = _model$activeState.getManipulator) === null || _model$activeState$ge2 === void 0 ? void 0 : _model$activeState$ge2.call(_model$activeState)) !== null && _model$activeState$ge !== void 0 ? _model$activeState$ge : model.manipulator;
+      manipulator.setWidgetOrigin(model.widgetState.getCenter());
+      manipulator.setWidgetNormal(currentPlaneNormal);
+
+      var _manipulator$handleEv = manipulator.handleEvent(callData, model._apiSpecificRenderWindow),
+          worldCoords = _manipulator$handleEv.worldCoords;
+
       previousPosition = worldCoords;
       publicAPI.startInteraction();
     } else if (model.widgetState.getScrollingMethod() === ScrollingMethods.LEFT_MOUSE_BUTTON) {
@@ -261,6 +274,8 @@ function widgetBehavior(publicAPI, model) {
   };
 
   publicAPI[InteractionMethodsName.TranslateAxis] = function (calldata) {
+    var _model$activeState$ge3, _model$activeState2, _model$activeState2$g, _model$activeState3, _model$activeState3$g;
+
     var lineHandle = publicAPI.getActiveLineHandle();
     var lineName = publicAPI.getActiveLineName();
     var pointOnLine = add(lineHandle.getOrigin(), lineHandle.getDirection(), []);
@@ -268,25 +283,37 @@ function widgetBehavior(publicAPI, model) {
     normalize(currentLineVector); // Translate the current line along the other line
 
     var otherLineHandle = publicAPI.getOtherLineHandle(lineName);
-    var otherLineVector = otherLineHandle.getDirection();
-    normalize(otherLineVector);
-    var axisTranslation = otherLineVector;
-    var dot$1 = dot(currentLineVector, otherLineVector); // lines are colinear, translate along perpendicular axis from current line
+    var center = model.widgetState.getCenter();
+    var manipulator = (_model$activeState$ge3 = (_model$activeState2 = model.activeState) === null || _model$activeState2 === void 0 ? void 0 : (_model$activeState2$g = _model$activeState2.getManipulator) === null || _model$activeState2$g === void 0 ? void 0 : _model$activeState2$g.call(_model$activeState2)) !== null && _model$activeState$ge3 !== void 0 ? _model$activeState$ge3 : model.manipulator;
+    var worldCoords = null;
+    var newOrigin = [];
+
+    if ((_model$activeState3 = model.activeState) !== null && _model$activeState3 !== void 0 && (_model$activeState3$g = _model$activeState3.getManipulator) !== null && _model$activeState3$g !== void 0 && _model$activeState3$g.call(_model$activeState3)) {
+      worldCoords = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow).worldCoords;
+      var translation = subtract(worldCoords, previousPosition, []);
+      add(center, translation, newOrigin);
+    } else if (otherLineHandle) {
+      var otherLineVector = otherLineHandle.getDirection();
+      normalize(otherLineVector);
+      var axisTranslation = otherLineVector;
+      var dot$1 = dot(currentLineVector, otherLineVector); // lines are colinear, translate along perpendicular axis from current line
+
+      if (dot$1 === 1 || dot$1 === -1) {
+        cross(currentLineVector, manipulator.getWidgetNormal(), axisTranslation);
+      }
 
-    if (dot$1 === 1 || dot$1 === -1) {
-      cross(currentLineVector, model.planeManipulator.getWidgetNormal(), axisTranslation);
+      var closestPoint = [];
+      worldCoords = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow).worldCoords;
+      vtkLine.distanceToLine(worldCoords, lineHandle.getOrigin(), pointOnLine, closestPoint);
+      var translationVector = subtract(worldCoords, closestPoint, []);
+      var translationDistance = dot(translationVector, axisTranslation);
+      newOrigin = multiplyAccumulate(center, axisTranslation, translationDistance, newOrigin);
     }
 
-    var closestPoint = [];
-    var worldCoords = model.planeManipulator.handleEvent(calldata, model._apiSpecificRenderWindow);
-    vtkLine.distanceToLine(worldCoords, lineHandle.getOrigin(), pointOnLine, closestPoint);
-    var translationVector = subtract(worldCoords, closestPoint, []);
-    var translationDistance = dot(translationVector, axisTranslation);
-    var center = model.widgetState.getCenter();
-    var newOrigin = multiplyAccumulate(center, axisTranslation, translationDistance, [0, 0, 0]);
     newOrigin = publicAPI.getBoundedCenter(newOrigin);
     model.widgetState.setCenter(newOrigin);
     updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
+    previousPosition = worldCoords;
   };
 
   publicAPI.getBoundedCenter = function (newCenter) {
@@ -301,7 +328,13 @@ function widgetBehavior(publicAPI, model) {
   };
 
   publicAPI[InteractionMethodsName.TranslateCenter] = function (calldata) {
-    var worldCoords = model.planeManipulator.handleEvent(calldata, model._apiSpecificRenderWindow);
+    var _model$activeState$ge4, _model$activeState4, _model$activeState4$g;
+
+    var manipulator = (_model$activeState$ge4 = (_model$activeState4 = model.activeState) === null || _model$activeState4 === void 0 ? void 0 : (_model$activeState4$g = _model$activeState4.getManipulator) === null || _model$activeState4$g === void 0 ? void 0 : _model$activeState4$g.call(_model$activeState4)) !== null && _model$activeState$ge4 !== void 0 ? _model$activeState$ge4 : model.manipulator;
+
+    var _manipulator$handleEv2 = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow),
+        worldCoords = _manipulator$handleEv2.worldCoords;
+
     var translation = subtract(worldCoords, previousPosition, []);
     previousPosition = worldCoords;
     var newCenter = add(model.widgetState.getCenter(), translation, []);
@@ -311,20 +344,27 @@ function widgetBehavior(publicAPI, model) {
   };
 
   publicAPI[InteractionMethodsName.RotateLine] = function (calldata) {
+    var _model$activeState$ge5, _model$activeState5, _model$activeState5$g;
+
     var activeLineHandle = publicAPI.getActiveLineHandle();
-    var planeNormal = model.planeManipulator.getWidgetNormal();
-    var worldCoords = model.planeManipulator.handleEvent(calldata, model._apiSpecificRenderWindow);
+    var manipulator = (_model$activeState$ge5 = (_model$activeState5 = model.activeState) === null || _model$activeState5 === void 0 ? void 0 : (_model$activeState5$g = _model$activeState5.getManipulator) === null || _model$activeState5$g === void 0 ? void 0 : _model$activeState5$g.call(_model$activeState5)) !== null && _model$activeState$ge5 !== void 0 ? _model$activeState$ge5 : model.manipulator;
+    var planeNormal = manipulator.getWidgetNormal();
+
+    var _manipulator$handleEv3 = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow),
+        worldCoords = _manipulator$handleEv3.worldCoords;
+
     var center = model.widgetState.getCenter();
+    var currentVectorToOrigin = [0, 0, 0];
+    subtract(worldCoords, center, currentVectorToOrigin);
+    normalize(currentVectorToOrigin);
     var previousLineDirection = activeLineHandle.getDirection();
     normalize(previousLineDirection);
+    var activePointName = publicAPI.getActiveRotationPointName();
 
-    if (publicAPI.getActiveRotationPointName() === 'point1') {
+    if (activePointName === 'point1' || !activePointName && dot(currentVectorToOrigin, previousLineDirection) < 0) {
       multiplyScalar(previousLineDirection, -1);
     }
 
-    var currentVectorToOrigin = [0, 0, 0];
-    subtract(worldCoords, center, currentVectorToOrigin);
-    normalize(currentVectorToOrigin);
     var radianAngle = signedAngleBetweenVectors(previousLineDirection, currentVectorToOrigin, planeNormal);
     publicAPI.rotateLineInView(publicAPI.getActiveLineName(), radianAngle);
   };
@@ -342,7 +382,7 @@ function widgetBehavior(publicAPI, model) {
     publicAPI.rotatePlane(viewType, radianAngle, planeNormal);
 
     if (publicAPI.getKeepOrthogonality()) {
-      var otherLineName = getOtherLineName(lineName);
+      var otherLineName = getOtherLineName(model.widgetState, lineName);
       var otherPlaneName = getLinePlaneName(otherLineName);
       publicAPI.rotatePlane(planeNameToViewType[otherPlaneName], radianAngle, planeNormal);
     }
@@ -371,8 +411,6 @@ function widgetBehavior(publicAPI, model) {
   // initialization
   // --------------------------------------------------------------------------
 
-
-  model.planeManipulator = vtkPlanePointManipulator.newInstance();
 }
 
 export { widgetBehavior as default };

package/Widgets/Widgets3D/ResliceCursorWidget/cprBehavior.js

@@ -0,0 +1,92 @@
+import widgetBehavior$1 from './behavior.js';
+import { InteractionMethodsName } from './Constants.js';
+import { updateState } from './helpers.js';
+import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
+import { vec3 } from 'gl-matrix';
+
+function widgetBehavior(publicAPI, model) {
+  // We inherit resliceCursorBehavior
+  widgetBehavior$1(publicAPI, model);
+  var stretchPlaneName = 'Y';
+  var crossPlaneName = 'Z';
+
+  publicAPI.getActiveInteraction = function () {
+    if (model.widgetState.getStatesWithLabel("lineIn".concat(stretchPlaneName)).includes(model.activeState)) {
+      return InteractionMethodsName.TranslateCenterAndUpdatePlanes;
+    }
+
+    if (model.widgetState.getStatesWithLabel("lineIn".concat(crossPlaneName)).includes(model.activeState) || model.widgetState.getStatesWithLabel("rotationIn".concat(crossPlaneName)).includes(model.activeState)) {
+      return InteractionMethodsName.RotateLine;
+    }
+
+    return null;
+  };
+
+  publicAPI[InteractionMethodsName.TranslateCenterAndUpdatePlanes] = function (calldata) {
+    var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
+
+    var manipulator = (_model$activeState$ge = (_model$activeState = model.activeState) === null || _model$activeState === void 0 ? void 0 : (_model$activeState$ge2 = _model$activeState.getManipulator) === null || _model$activeState$ge2 === void 0 ? void 0 : _model$activeState$ge2.call(_model$activeState)) !== null && _model$activeState$ge !== void 0 ? _model$activeState$ge : model.manipulator;
+
+    var _manipulator$handleEv = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow),
+        worldCoords = _manipulator$handleEv.worldCoords,
+        worldDirection = _manipulator$handleEv.worldDirection;
+
+    publicAPI.updateCenterAndPlanes(worldCoords, worldDirection);
+  };
+
+  publicAPI.updateCenterAndPlanes = function (worldCoords, worldDirection) {
+    // Update center
+    var newBoundedCenter = publicAPI.getBoundedCenter(worldCoords);
+    model.widgetState.setCenter(newBoundedCenter); // Update planes if axes are given
+
+    if (worldDirection) {
+      var getAxis = function getAxis(idx) {
+        return vec3.normalize([], worldDirection.slice(3 * idx, 3 * idx + 3));
+      };
+
+      var planes = model.widgetState.getPlanes();
+      Object.keys(planes).forEach(function (viewType) {
+        switch (Number.parseInt(viewType, 10)) {
+          case ViewTypes.YZ_PLANE:
+            planes[viewType] = {
+              normal: getAxis(0),
+              viewUp: getAxis(2)
+            };
+            break;
+
+          case ViewTypes.XZ_PLANE:
+            planes[viewType] = {
+              normal: getAxis(1),
+              viewUp: getAxis(2)
+            };
+            break;
+
+          case ViewTypes.XY_PLANE:
+            planes[viewType] = {
+              normal: getAxis(2),
+              viewUp: getAxis(1)
+            };
+            break;
+        }
+      });
+    }
+
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
+  };
+
+  publicAPI.translateCenterOnPlaneDirection = function (nbSteps) {
+    var _model$_factory$getMa;
+
+    var handleScroll = (_model$_factory$getMa = model._factory.getManipulator()) === null || _model$_factory$getMa === void 0 ? void 0 : _model$_factory$getMa.handleScroll;
+
+    if (handleScroll) {
+      var _handleScroll = handleScroll(nbSteps),
+          worldCoords = _handleScroll.worldCoords,
+          worldDirection = _handleScroll.worldDirection;
+
+      publicAPI.updateCenterAndPlanes(worldCoords, worldDirection);
+    }
+  };
+}
+
+export { widgetBehavior as default };

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -5,8 +5,7 @@ import vtkCutter from '../../../Filters/Core/Cutter.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
 import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, S as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
-import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
-import { planeNames, lineNames, planeNameToViewType } from './Constants.js';
+import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 
 var EPSILON = 10e-7;
 /**
@@ -128,6 +127,18 @@ function rotateVector(vectorToBeRotated, axis, angle) {
   vtkMatrixBuilder.buildFromRadian().rotate(angle, axis).apply(rotatedVector);
   return rotatedVector;
 }
+/**
+ * Return ['X', 'Y'] if there are only 2 planes defined in the widget state.
+ * Return ['X', 'Y', 'Z'] if there are 3 planes defined in the widget state.
+ * @param {object} widgetState the state of the widget
+ * @returns An array of plane names
+ */
+
+function getPlaneNames(widgetState) {
+  return Object.keys(widgetState.getPlanes()).map(function (viewType) {
+    return viewTypeToPlaneName[viewType];
+  });
+}
 /**
  * Return X if lineName == XinY|XinZ, Y if lineName == YinX|YinZ and Z otherwise
  * @param {string} lineName name of the line (YinX, ZinX, XinY, ZinY, XinZ, YinZ)
@@ -144,15 +155,39 @@ function getLinePlaneName(lineName) {
 function getLineInPlaneName(lineName) {
   return lineName[3];
 }
+/**
+ * Returns ['XinY', 'YinX'] if planes == ['X', 'Y']
+ * ['XinY', 'XinZ', 'YinX', 'YinZ', 'ZinX', 'ZinY'] if planes == ['X', 'Y', 'Z']
+ * @param {string} planes name of the planes (e.g. ['X', 'Y'])
+ */
+
+function getPlanesLineNames() {
+  var planes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : planeNames;
+  var lines = [];
+  planes.forEach(function (plane) {
+    planes.forEach(function (inPlane) {
+      if (plane !== inPlane) {
+        lines.push("".concat(plane, "in").concat(inPlane));
+      }
+    });
+  });
+  return lines;
+}
+function getLineNames(widgetState) {
+  var planes = Object.keys(widgetState.getPlanes()).map(function (viewType) {
+    return viewTypeToPlaneName[viewType];
+  });
+  return getPlanesLineNames(planes);
+}
 /**
  * Return ZinX if lineName == YinX, YinX if lineName == ZinX, ZinY if lineName == XinY...
  * @param {string} lineName name of the line (YinX, ZinX, XinY, ZinY, XinZ, YinZ)
  */
 
-function getOtherLineName(lineName) {
+function getOtherLineName(widgetState, lineName) {
   var linePlaneName = getLinePlaneName(lineName);
   var lineInPlaneName = getLineInPlaneName(lineName);
-  var otherLineName = planeNames.find(function (planeName) {
+  var otherLineName = getPlaneNames(widgetState).find(function (planeName) {
     return planeName !== linePlaneName && planeName !== lineInPlaneName;
   });
   return "".concat(otherLineName, "in").concat(lineInPlaneName);
@@ -165,33 +200,44 @@ function computeRotationHandleOriginOffset(axis, rotationHandlePosition, volumeD
 
 
 function updateState(widgetState, scaleInPixels, rotationHandlePosition) {
-  // Compute line axis
-  var xNormal = widgetState.getPlanes()[ViewTypes.YZ_PLANE].normal;
-  var yNormal = widgetState.getPlanes()[ViewTypes.XZ_PLANE].normal;
-  var zNormal = widgetState.getPlanes()[ViewTypes.XY_PLANE].normal;
-  var axes = {
-    XY: cross(xNormal, yNormal, []),
-    YZ: cross(yNormal, zNormal, []),
-    XZ: cross(zNormal, xNormal, [])
-  };
-  axes.YX = axes.XY;
-  axes.ZY = axes.YZ;
-  axes.ZX = axes.XZ;
+  var planes = Object.keys(widgetState.getPlanes()).map(function (viewType) {
+    return viewTypeToPlaneName[viewType];
+  }); // Generates an object as such:
+  // axes = {'XY': cross(X, Y), 'YX': cross(X, Y), 'YZ': cross(Y, Z)...}
+
+  var axes = planes.reduce(function (res, plane) {
+    planes.filter(function (otherPlane) {
+      return plane !== otherPlane;
+    }).forEach(function (otherPlane) {
+      var cross$1 = cross(widgetState.getPlanes()[planeNameToViewType[plane]].normal, widgetState.getPlanes()[planeNameToViewType[otherPlane]].normal, []);
+      res["".concat(plane).concat(otherPlane)] = cross$1;
+      res["".concat(otherPlane).concat(plane)] = cross$1;
+    });
+    return res;
+  }, {});
   var bounds = widgetState.getImage().getBounds();
   var center = widgetState.getCenter(); // Length of the principal diagonal.
 
   var pdLength = vtkBoundingBox.getDiagonalLength(bounds);
   widgetState.getCenterHandle().setOrigin(center);
-  lineNames.forEach(function (lineName) {
+  getPlanesLineNames(planes).forEach(function (lineName) {
+    var _widgetState$$getMani, _widgetState$$getMani2, _widgetState$$getMani3, _widgetState$$getMani4, _lineHandle$getManipu, _lineHandle$getManipu2;
+
     var planeName = getLinePlaneName(lineName);
     var inPlaneName = getLineInPlaneName(lineName);
     var direction = axes["".concat(planeName).concat(inPlaneName)];
     widgetState["getRotationHandle".concat(lineName, "0")]().setOrigin(center);
+    (_widgetState$$getMani = widgetState["getRotationHandle".concat(lineName, "0")]().getManipulator()) === null || _widgetState$$getMani === void 0 ? void 0 : _widgetState$$getMani.setHandleOrigin(center);
+    (_widgetState$$getMani2 = widgetState["getRotationHandle".concat(lineName, "0")]().getManipulator()) === null || _widgetState$$getMani2 === void 0 ? void 0 : _widgetState$$getMani2.setHandleNormal(widgetState.getPlanes()[planeNameToViewType[planeName]].normal);
     widgetState["getRotationHandle".concat(lineName, "0")]().setOffset(computeRotationHandleOriginOffset(direction, rotationHandlePosition, pdLength, scaleInPixels));
     widgetState["getRotationHandle".concat(lineName, "1")]().setOrigin(center);
+    (_widgetState$$getMani3 = widgetState["getRotationHandle".concat(lineName, "1")]().getManipulator()) === null || _widgetState$$getMani3 === void 0 ? void 0 : _widgetState$$getMani3.setHandleOrigin(center);
+    (_widgetState$$getMani4 = widgetState["getRotationHandle".concat(lineName, "1")]().getManipulator()) === null || _widgetState$$getMani4 === void 0 ? void 0 : _widgetState$$getMani4.setHandleNormal(widgetState.getPlanes()[planeNameToViewType[planeName]].normal);
     widgetState["getRotationHandle".concat(lineName, "1")]().setOffset(computeRotationHandleOriginOffset(direction, -rotationHandlePosition, pdLength, scaleInPixels));
     var lineHandle = widgetState["getAxis".concat(lineName)]();
     lineHandle.setOrigin(center);
+    (_lineHandle$getManipu = lineHandle.getManipulator()) === null || _lineHandle$getManipu === void 0 ? void 0 : _lineHandle$getManipu.setHandleOrigin(center);
+    (_lineHandle$getManipu2 = lineHandle.getManipulator()) === null || _lineHandle$getManipu2 === void 0 ? void 0 : _lineHandle$getManipu2.setHandleNormal(widgetState.getPlanes()[planeNameToViewType[planeName]].normal);
     var scale = normalize(direction);
     var scale3 = lineHandle.getScale3();
     scale3[2] = 2 * scale;
@@ -222,4 +268,4 @@ function transformPlane(planeToTransform, targetCenter, targetNormal, targetView
   planeToTransform.setCenter(targetCenter);
 }
 
-export { boundPlane, boundPoint, boundPointOnPlane, getLineInPlaneName, getLinePlaneName, getOtherLineName, rotateVector, transformPlane, updateState };
+export { boundPlane, boundPoint, boundPointOnPlane, getLineInPlaneName, getLineNames, getLinePlaneName, getOtherLineName, getPlaneNames, getPlanesLineNames, rotateVector, transformPlane, updateState };

package/Widgets/Widgets3D/ResliceCursorWidget/state.js

@@ -1,8 +1,27 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import vtkStateBuilder from '../../Core/StateBuilder.js';
-import { ScrollingMethods, planeNames } from './Constants.js';
-import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
+import { planeNameToViewType, ScrollingMethods, planeNames } from './Constants.js';
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var defaultPlanes = {
+  X: {
+    normal: [1, 0, 0],
+    viewUp: [0, 0, 1],
+    color3: [255, 0, 0]
+  },
+  Y: {
+    normal: [0, -1, 0],
+    viewUp: [0, 0, 1],
+    color3: [0, 255, 0]
+  },
+  Z: {
+    normal: [0, 0, -1],
+    viewUp: [0, -1, 0],
+    color3: [0, 0, 255]
+  }
+};
 var viewsColor3 = {
   X: [255, 0, 0],
   // red
@@ -12,8 +31,7 @@ var viewsColor3 = {
 
 };
 function generateState() {
-  var _initialValue;
-
+  var planes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : planeNames;
   var state = vtkStateBuilder.createBuilder().addField({
     name: 'center',
     initialValue: [0, 0, 0]
@@ -25,16 +43,12 @@ function generateState() {
     initialValue: null
   }).addField({
     name: 'planes',
-    initialValue: (_initialValue = {}, _defineProperty(_initialValue, ViewTypes.YZ_PLANE, {
-      normal: [1, 0, 0],
-      viewUp: [0, 0, 1]
-    }), _defineProperty(_initialValue, ViewTypes.XZ_PLANE, {
-      normal: [0, -1, 0],
-      viewUp: [0, 0, 1]
-    }), _defineProperty(_initialValue, ViewTypes.XY_PLANE, {
-      normal: [0, 0, -1],
-      viewUp: [0, -1, 0]
-    }), _initialValue)
+    initialValue: planes.reduce(function (res, planeName) {
+      return _objectSpread(_objectSpread({}, res), {}, _defineProperty({}, planeNameToViewType[planeName], {
+        normal: defaultPlanes[planeName].normal,
+        viewUp: defaultPlanes[planeName].viewUp
+      }));
+    }, {})
   }).addField({
     name: 'scrollingMethod',
     initialValue: ScrollingMethods.MIDDLE_MOUSE_BUTTON
@@ -53,8 +67,8 @@ function generateState() {
       color3: [255, 255, 255]
     }
   });
-  planeNames.reduce(function (viewState, view) {
-    return planeNames.filter(function (v) {
+  planes.reduce(function (viewState, view) {
+    return planes.filter(function (v) {
       return v !== view;
     }).reduce(function (axisState, axis) {
       // Line handle

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -4,6 +4,7 @@ import macro from '../../macros.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPlaneSource from '../../Filters/Sources/PlaneSource.js';
+import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkLineHandleRepresentation from '../Representations/LineHandleRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import { e as distance2BetweenPoints, m as multiplyAccumulate, s as subtract, l as normalize, w as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
@@ -263,11 +264,9 @@ function vtkResliceCursorWidget(publicAPI, model) {
     updateCamera(renderer, normal, viewType, resetFocalPoint, keepCenterFocalDistance);
   };
 
-  publicAPI.updateReslicePlane = function (imageReslice, viewType) {
-    // Calculate appropriate pixel spacing for the reslicing
-    var spacing = model.widgetState.getImage().getSpacing(); // Compute original (i.e. before rotation) plane (i.e. origin, p1, p2)
+  publicAPI.getPlaneSource = function (viewType) {
+    // Compute original (i.e. before rotation) plane (i.e. origin, p1, p2)
     // centered on cursor center.
-
     var planeSource = computeReslicePlaneOrigin(viewType);
     var _model$widgetState$ge = model.widgetState.getPlanes()[viewType],
         normal = _model$widgetState$ge.normal,
@@ -286,18 +285,25 @@ function vtkResliceCursorWidget(publicAPI, model) {
     planeSource.setOrigin.apply(planeSource, _toConsumableArray(boundedOrigin));
     planeSource.setPoint1.apply(planeSource, _toConsumableArray(boundedP1));
     planeSource.setPoint2.apply(planeSource, _toConsumableArray(boundedP2));
-    var o = planeSource.getOrigin();
+    return planeSource;
+  };
+
+  publicAPI.getResliceAxes = function (viewType) {
+    // Compute original (i.e. before rotation) plane (i.e. origin, p1, p2)
+    // centered on cursor center.
+    var planeSource = publicAPI.getPlaneSource(viewType); // TBD: use normal from planeSource ?
+
+    var normal = model.widgetState.getPlanes()[viewType].normal;
+    var planeOrigin = planeSource.getOrigin();
     var p1 = planeSource.getPoint1();
     var planeAxis1 = [];
-    subtract(p1, o, planeAxis1);
+    subtract(p1, planeOrigin, planeAxis1);
+    normalize(planeAxis1);
     var p2 = planeSource.getPoint2();
     var planeAxis2 = [];
-    subtract(p2, o, planeAxis2); // The x,y dimensions of the plane
-
-    var planeSizeX = normalize(planeAxis1);
-    var planeSizeY = normalize(planeAxis2);
+    subtract(p2, planeOrigin, planeAxis2);
+    normalize(planeAxis2);
     var newResliceAxes = mat4.identity(new Float64Array(16));
-    var planeOrigin = planeSource.getOrigin();
 
     for (var i = 0; i < 3; i++) {
       newResliceAxes[i] = planeAxis1[i];
@@ -306,6 +312,21 @@ function vtkResliceCursorWidget(publicAPI, model) {
       newResliceAxes[12 + i] = planeOrigin[i];
     }
 
+    return newResliceAxes;
+  };
+
+  publicAPI.updateReslicePlane = function (imageReslice, viewType) {
+    // Calculate appropriate pixel spacing for the reslicing
+    var spacing = model.widgetState.getImage().getSpacing();
+    var planeSource = publicAPI.getPlaneSource(viewType);
+    var newResliceAxes = publicAPI.getResliceAxes(viewType);
+    var planeOrigin = planeSource.getOrigin();
+    var p1 = planeSource.getPoint1();
+    var planeAxis1 = subtract(p1, planeOrigin, []);
+    var planeSizeX = normalize(planeAxis1);
+    var p2 = planeSource.getPoint2();
+    var planeAxis2 = subtract(p2, planeOrigin, []);
+    var planeSizeY = normalize(planeAxis2);
     var spacingX = Math.abs(planeAxis1[0] * spacing[0]) + Math.abs(planeAxis1[1] * spacing[1]) + Math.abs(planeAxis1[2] * spacing[2]);
     var spacingY = Math.abs(planeAxis2[0] * spacing[0]) + Math.abs(planeAxis2[1] * spacing[1]) + Math.abs(planeAxis2[2] * spacing[2]); // Compute a new set of resliced extents
 
@@ -350,12 +371,7 @@ function vtkResliceCursorWidget(publicAPI, model) {
     modified = imageReslice.setOutputSpacing([outputSpacingX, outputSpacingY, 1]) || modified;
     modified = imageReslice.setOutputOrigin([0.5 * outputSpacingX, 0.5 * outputSpacingY, 0]) || modified;
     modified = imageReslice.setOutputExtent([0, extentX - 1, 0, extentY - 1, 0, 0]) || modified;
-    return {
-      modified: modified,
-      origin: o,
-      point1: p1,
-      point2: p2
-    };
+    return modified;
   };
   /**
    * Returns a plane source with origin at cursor center and
@@ -429,13 +445,20 @@ function vtkResliceCursorWidget(publicAPI, model) {
   });
 } // ----------------------------------------------------------------------------
 
+/**
+ * Initializes the model.
+ * @param {*} initialValues optional object of member variables. initialValues.planes is an optional list of axis names (e.g. ['X', 'Y'])
+ * @returns the initial model object
+ */
+
 
 var defaultValues = function defaultValues(initialValues) {
   return _objectSpread({
     behavior: widgetBehavior,
-    widgetState: generateState(),
+    widgetState: generateState(initialValues.planes),
     rotationHandlePosition: 0.5,
-    scaleInPixels: true
+    scaleInPixels: true,
+    manipulator: vtkPlanePointManipulator.newInstance()
   }, initialValues);
 }; // ----------------------------------------------------------------------------
 
@@ -444,7 +467,7 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['scaleInPixels', 'rotationHandlePosition']);
+  macro.setGet(publicAPI, model, ['scaleInPixels', 'rotationHandlePosition', 'manipulator']);
   vtkResliceCursorWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -369,7 +369,8 @@ function widgetBehavior(publicAPI, model) {
       model.shapeHandle.setDirection(normal);
     }
 
-    var worldCoords = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    var _manipulator$handleEv = manipulator.handleEvent(callData, model._apiSpecificRenderWindow),
+        worldCoords = _manipulator$handleEv.worldCoords;
 
     if (!worldCoords.length) {
       return macro.VOID;
@@ -413,7 +414,8 @@ function widgetBehavior(publicAPI, model) {
     }
 
     if (model.hasFocus) {
-      var worldCoords = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
+      var _manipulator$handleEv2 = manipulator.handleEvent(e, model._apiSpecificRenderWindow),
+          worldCoords = _manipulator$handleEv2.worldCoords;
 
       if (!model.point1) {
         model.point1Handle.setOrigin(worldCoords);

package/Widgets/Widgets3D/SphereWidget/behavior.js

@@ -56,7 +56,7 @@ function widgetBehavior(publicAPI, model) {
     var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
 
     var manipulator = (_model$activeState$ge = (_model$activeState = model.activeState) === null || _model$activeState === void 0 ? void 0 : (_model$activeState$ge2 = _model$activeState.getManipulator) === null || _model$activeState$ge2 === void 0 ? void 0 : _model$activeState$ge2.call(_model$activeState)) !== null && _model$activeState$ge !== void 0 ? _model$activeState$ge : model.manipulator;
-    return manipulator.handleEvent(e, model._apiSpecificRenderWindow);
+    return manipulator.handleEvent(e, model._apiSpecificRenderWindow).worldCoords;
   } // Update the sphere's center and radius.  Example:
   // handle.setCenterAndRadius([1,2,3], 10);