@kitware/vtk.js 26.8.1 → 26.9.0

package/Rendering/OpenGL/VolumeMapper.js

@@ -52,7 +52,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
   // intermixed volume rendering
 
 
-  publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
+  publicAPI.zBufferPass = function (prepass, renderPass) {
     if (prepass) {
       var zbt = renderPass.getZBufferTexture();
 
@@ -60,6 +60,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         model.zBufferTexture = zbt;
       }
     }
+  };
+
+  publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
+    return publicAPI.zBufferPass(prepass, renderPass);
   }; // Renders myself
 
 

package/Widgets/Core/AbstractWidget.js

@@ -87,11 +87,7 @@ function vtkAbstractWidget(publicAPI, model) {
   };
 
   publicAPI.getViewWidgets = function () {
-    return model._factory.getViewIds().map(function (viewId) {
-      return model._factory.getWidgetForView({
-        viewId: viewId
-      });
-    });
+    return model._factory.getViewWidgets();
   }; // --------------------------------------------------------------------------
   // Initialization calls
   // --------------------------------------------------------------------------

package/Widgets/Core/AbstractWidgetFactory.d.ts

@@ -27,6 +27,11 @@ export interface vtkAbstractWidgetFactory {
    */
   getViewIds(): string[];
 
+  /**
+   * Get a list of all the instances of the widget.
+   */
+  getViewWidgets(): vtkAbstractWidget[];
+
   /**
    * Set the visiblity on each underlying view widget.
    * 

package/Widgets/Core/AbstractWidgetFactory.js

@@ -121,6 +121,10 @@ function vtkAbstractWidgetFactory(publicAPI, model) {
 
   publicAPI.getViewIds = function () {
     return Object.keys(viewToWidget);
+  };
+
+  publicAPI.getViewWidgets = function () {
+    return Object.values(viewToWidget);
   }; // --------------------------------------------------------------------------
   // Widget visibility / enable
   // --------------------------------------------------------------------------

package/Widgets/Core/StateBuilder/color3Mixin.js

@@ -6,13 +6,15 @@ import macro from '../../../macros.js';
  */
 
 var DEFAULT_VALUES = {
-  color3: [255, 255, 255]
+  color3: [255, 255, 255],
+  opacity: 255
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.setGetArray(publicAPI, model, ['color3'], 3, 255);
+  macro.setGet(publicAPI, model, ['opacity']);
 } // ----------------------------------------------------------------------------
 
 var color3 = {

package/Widgets/Core/StateBuilder/originMixin.js

@@ -1,7 +1,16 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../../macros.js';
+import { f as vtkMath } from '../../../Common/Core/Math/index.js';
+import { getPixelWorldHeightAtCoord } from '../WidgetManager.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; }
 
 function vtkOriginMixin(publicAPI, model) {
+  var superClass = _objectSpread({}, publicAPI);
+
   publicAPI.translate = function (dx, dy, dz) {
     var _publicAPI$getOriginB = publicAPI.getOriginByReference(),
         _publicAPI$getOriginB2 = _slicedToArray(_publicAPI$getOriginB, 3),
@@ -11,18 +20,40 @@ function vtkOriginMixin(publicAPI, model) {
 
     publicAPI.setOrigin(x + dx, y + dy, z + dz);
   };
+
+  publicAPI.getOrigin = function (displayScaleParams) {
+    var origin = superClass.getOrigin();
+
+    if (!model.offset) {
+      return origin;
+    }
+
+    if (!displayScaleParams) {
+      return vtkMath.add(origin, model.offset, origin);
+    }
+
+    var pixelWorldHeight = getPixelWorldHeightAtCoord(origin, displayScaleParams);
+    var rendererPixelDims = displayScaleParams.rendererPixelDims;
+    var totalSize = Math.min(rendererPixelDims[0], rendererPixelDims[1]);
+    return vtkMath.multiplyAccumulate(origin, model.offset, totalSize * pixelWorldHeight, origin);
+  };
 } // ----------------------------------------------------------------------------
 
+/**
+ * offset: optional offset that can be scaled to pixel screen space.
+ */
+
 
 var DEFAULT_VALUES = {
-  origin: null
+  origin: null,
+  offset: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
-  macro.setGetArray(publicAPI, model, ['origin'], 3);
-  vtkOriginMixin(publicAPI);
+  macro.setGetArray(publicAPI, model, ['origin', 'offset'], 3);
+  vtkOriginMixin(publicAPI, model);
 } // ----------------------------------------------------------------------------
 
 var origin = {

package/Widgets/Core/WidgetManager.d.ts

@@ -37,6 +37,14 @@ export interface IRenderingComponents {
  */
 export function extractRenderingComponents(renderer: vtkRenderer): IRenderingComponents;
 
+/**
+ * This method returns the world distance that corresponds to the height of a
+ * single display pixel at a given coordinate. For example, to determine the
+ * (vertical) distance that matches a display distance of 30px for a coordinate
+ * `coord`, you would compute `30 * getPixelWorldHeightAtCoord(coord)`.
+ */
+export function getPixelWorldHeightAtCoord(coord: []): Number;
+
 export interface vtkWidgetManager extends vtkObject {
   /**
    * The the captureOn value. 

package/Widgets/Core/WidgetManager.js

@@ -1,7 +1,8 @@
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
-import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { f as vtkMath } from '../../Common/Core/Math/index.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import macro from '../../macros.js';
 import WidgetManagerConst from './WidgetManager/Constants.js';
@@ -28,6 +29,26 @@ function extractRenderingComponents(renderer) {
     apiSpecificRenderWindow: apiSpecificRenderWindow,
     camera: camera
   };
+}
+function getPixelWorldHeightAtCoord(worldCoord, displayScaleParams) {
+  var dispHeightFactor = displayScaleParams.dispHeightFactor,
+      cameraPosition = displayScaleParams.cameraPosition,
+      cameraDir = displayScaleParams.cameraDir,
+      isParallel = displayScaleParams.isParallel,
+      rendererPixelDims = displayScaleParams.rendererPixelDims;
+  var scale = 1;
+
+  if (isParallel) {
+    scale = dispHeightFactor;
+  } else {
+    var worldCoordToCamera = _toConsumableArray(worldCoord);
+
+    vtkMath.subtract(worldCoordToCamera, cameraPosition, worldCoordToCamera);
+    scale = vtkMath.dot(worldCoordToCamera, cameraDir) * dispHeightFactor;
+  }
+
+  var rHeight = rendererPixelDims[1];
+  return scale / rHeight;
 } // ----------------------------------------------------------------------------
 // vtkWidgetManager methods
 // ----------------------------------------------------------------------------
@@ -98,7 +119,7 @@ function vtkWidgetManager(publicAPI, model) {
 
       var isParallel = _camera.getParallelProjection();
 
-      var dispHeightFactor = isParallel ? 2 * _camera.getParallelScale() : 2 * Math.tan(radiansFromDegrees(_camera.getViewAngle()) / 2);
+      var dispHeightFactor = isParallel ? 2 * _camera.getParallelScale() : 2 * Math.tan(vtkMath.radiansFromDegrees(_camera.getViewAngle()) / 2);
       model.widgets.forEach(function (w) {
         w.getNestedProps().forEach(function (r) {
           if (r.getScaleInPixels()) {
@@ -327,7 +348,7 @@ function vtkWidgetManager(publicAPI, model) {
 
     model._selector.setFieldAssociation(FieldAssociations.FIELD_ASSOCIATION_POINTS);
 
-    subscriptions.push(model._apiSpecificRenderWindow.onModified(updateDisplayScaleParams));
+    subscriptions.push(model._apiSpecificRenderWindow.onWindowResizeEvent(updateDisplayScaleParams));
     subscriptions.push(model._camera.onModified(updateDisplayScaleParams));
     updateDisplayScaleParams();
     subscriptions.push(model._interactor.onStartAnimation(function () {
@@ -622,7 +643,8 @@ var newInstance = macro.newInstance(extend, 'vtkWidgetManager'); // ------------
 var vtkWidgetManager$1 = {
   newInstance: newInstance,
   extend: extend,
-  Constants: WidgetManagerConst
+  Constants: WidgetManagerConst,
+  getPixelWorldHeightAtCoord: getPixelWorldHeightAtCoord
 };
 
-export { vtkWidgetManager$1 as default, extend, extractRenderingComponents, newInstance };
+export { vtkWidgetManager$1 as default, extend, extractRenderingComponents, getPixelWorldHeightAtCoord, newInstance };

package/Widgets/Representations/CroppingOutlineRepresentation.js

@@ -28,7 +28,7 @@ function vtkCroppingOutlineRepresentation(publicAPI, model) {
     mtime: 0
   });
   allocateArray(model.internalPolyData, 'lines', OUTLINE_ARRAY.length).getData().set(OUTLINE_ARRAY);
-  var applyOrigin = origin(); // --------------------------------------------------------------------------
+  var applyOrigin = origin(publicAPI, model); // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 

package/Widgets/Representations/GlyphRepresentation.js

@@ -7,7 +7,8 @@ import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
-import vtkWidgetRepresentation, { allocateArray, getPixelWorldHeightAtCoord } from './WidgetRepresentation.js';
+import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';
+import vtkWidgetRepresentation, { allocateArray } from './WidgetRepresentation.js';
 import { Behavior } from './WidgetRepresentation/Constants.js';
 import { OrientationModes } from '../../Rendering/Core/Glyph3DMapper/Constants.js';
 
@@ -23,7 +24,7 @@ function origin(publicAPI, model) {
     var j = 0;
 
     for (var i = 0; i < states.length; ++i) {
-      var coord = states[i].getOrigin();
+      var coord = states[i].getOrigin(model.scaleInPixels && model.displayScaleParams);
       points[j++] = coord[0];
       points[j++] = coord[1];
       points[j++] = coord[2];
@@ -39,8 +40,9 @@ function color3(publicAPI, model) {
   return function (polyData, states) {
     model._pipeline.mapper.setColorByArrayName('color');
 
-    var colors = allocateArray(polyData, 'color', states.length, 'Uint8Array', // RGB
-    3).getData();
+    var colorArray = allocateArray(polyData, 'color', states.length, 'Uint8Array', // RGBA
+    4);
+    var colors = colorArray.getData();
     var j = 0;
 
     for (var i = 0; i < states.length; ++i) {
@@ -53,7 +55,10 @@ function color3(publicAPI, model) {
       colors[j++] = c3[0];
       colors[j++] = c3[1];
       colors[j++] = c3[2];
+      colors[j++] = states[i].getOpacity();
     }
+
+    colorArray.dataChange();
   };
 }
 function color(publicAPI, model) {
@@ -278,7 +283,7 @@ function defaultValues(publicAPI, model, initialValues) {
       })
     }, initialValues._pipeline),
     applyMixin: _objectSpread({
-      origin: (_initialValues$applyM = (_initialValues$applyM2 = initialValues.applyMixin) === null || _initialValues$applyM2 === void 0 ? void 0 : _initialValues$applyM2.origin) !== null && _initialValues$applyM !== void 0 ? _initialValues$applyM : origin(),
+      origin: (_initialValues$applyM = (_initialValues$applyM2 = initialValues.applyMixin) === null || _initialValues$applyM2 === void 0 ? void 0 : _initialValues$applyM2.origin) !== null && _initialValues$applyM !== void 0 ? _initialValues$applyM : origin(publicAPI, model),
       noPosition: (_initialValues$applyM3 = (_initialValues$applyM4 = initialValues.applyMixin) === null || _initialValues$applyM4 === void 0 ? void 0 : _initialValues$applyM4.noPosition) !== null && _initialValues$applyM3 !== void 0 ? _initialValues$applyM3 : noPosition(),
       color3: (_initialValues$applyM5 = (_initialValues$applyM6 = initialValues.applyMixin) === null || _initialValues$applyM6 === void 0 ? void 0 : _initialValues$applyM6.color3) !== null && _initialValues$applyM5 !== void 0 ? _initialValues$applyM5 : color3(publicAPI, model),
       color: (_initialValues$applyM7 = (_initialValues$applyM8 = initialValues.applyMixin) === null || _initialValues$applyM8 === void 0 ? void 0 : _initialValues$applyM8.color) !== null && _initialValues$applyM7 !== void 0 ? _initialValues$applyM7 : color(publicAPI, model),

package/Widgets/Representations/ImplicitPlaneRepresentation.js

@@ -11,7 +11,8 @@ import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import vtkStateBuilder from '../Core/StateBuilder.js';
-import vtkWidgetRepresentation, { getPixelWorldHeightAtCoord } from './WidgetRepresentation.js';
+import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';
+import vtkWidgetRepresentation from './WidgetRepresentation.js';
 import WidgetManagerConst from '../Core/WidgetManager/Constants.js';
 import PropertyConst from '../../Rendering/Core/Property/Constants.js';
 

package/Widgets/Representations/PolyLineRepresentation.js

@@ -5,7 +5,8 @@ import vtkMapper from '../../Rendering/Core/Mapper.js';
 import { B as areEquals } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkTubeFilter from '../../Filters/General/TubeFilter.js';
-import vtkWidgetRepresentation, { allocateArray, getPixelWorldHeightAtCoord } from './WidgetRepresentation.js';
+import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';
+import vtkWidgetRepresentation, { allocateArray } from './WidgetRepresentation.js';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 

package/Widgets/Representations/WidgetRepresentation.js

@@ -1,8 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkProp from '../../Rendering/Core/Prop.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPoints from '../../Common/Core/Points.js';
@@ -96,26 +94,6 @@ function connectPipeline(pipeline) {
   }
 
   pipeline.actor.setMapper(pipeline.mapper);
-}
-function getPixelWorldHeightAtCoord(worldCoord, displayScaleParams) {
-  var dispHeightFactor = displayScaleParams.dispHeightFactor,
-      cameraPosition = displayScaleParams.cameraPosition,
-      cameraDir = displayScaleParams.cameraDir,
-      isParallel = displayScaleParams.isParallel,
-      rendererPixelDims = displayScaleParams.rendererPixelDims;
-  var scale = 1;
-
-  if (isParallel) {
-    scale = dispHeightFactor;
-  } else {
-    var worldCoordToCamera = _toConsumableArray(worldCoord);
-
-    vtkMath.subtract(worldCoordToCamera, cameraPosition, worldCoordToCamera);
-    scale = vtkMath.dot(worldCoordToCamera, cameraDir) * dispHeightFactor;
-  }
-
-  var rHeight = rendererPixelDims[1];
-  return scale / rHeight;
 } // Internal convenient function to create a data array:
 
 function allocateArray(polyData, name, numberOfTuples, dataType, numberOfComponents) {
@@ -362,7 +340,7 @@ function extend(publicAPI, model) {
   // Object methods
   vtkProp.extend(publicAPI, model, defaultValues(initialValues));
   macro.algo(publicAPI, model, 1, 1);
-  macro.get(publicAPI, model, ['labels']);
+  macro.get(publicAPI, model, ['labels', 'displayScaleParams', 'coincidentTopologyParameters']);
   macro.set(publicAPI, model, [{
     type: 'object',
     name: 'displayScaleParams'
@@ -379,8 +357,7 @@ var vtkWidgetRepresentation$1 = {
   extend: extend,
   mergeStyles: mergeStyles,
   applyStyles: applyStyles,
-  connectPipeline: connectPipeline,
-  getPixelWorldHeightAtCoord: getPixelWorldHeightAtCoord
+  connectPipeline: connectPipeline
 };
 
-export { allocateArray, applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, getPixelWorldHeightAtCoord, mergeStyles };
+export { allocateArray, applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, mergeStyles };

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -10,7 +10,19 @@ import { InteractionMethodsName, lineNames, ScrollingMethods, planeNameToViewTyp
 function widgetBehavior(publicAPI, model) {
   model._isDragging = false;
   var isScrolling = false;
-  var previousPosition; // FIXME: label information should be accessible from activeState instead of parent state.
+  var previousPosition;
+  macro.setGet(publicAPI, model, ['keepOrthogonality']);
+
+  publicAPI.setEnableTranslation = function (enable) {
+    model.representations[0].setPickable(enable); // line handle
+
+    model.representations[2].setPickable(enable); // center handle
+  };
+
+  publicAPI.setEnableRotation = function (enable) {
+    model.representations[1].setPickable(enable); // rotation handle
+  }; // FIXME: label information should be accessible from activeState instead of parent state.
+
 
   publicAPI.getActiveInteraction = function () {
     if (model.widgetState.getStatesWithLabel('rotation').includes(model.activeState)) {
@@ -245,7 +257,7 @@ function widgetBehavior(publicAPI, model) {
     var newCenter = [oldCenter[0] + movingFactor * dirProj[0], oldCenter[1] + movingFactor * dirProj[1], oldCenter[2] + movingFactor * dirProj[2]];
     newCenter = publicAPI.getBoundedCenter(newCenter);
     model.widgetState.setCenter(newCenter);
-    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI[InteractionMethodsName.TranslateAxis] = function (calldata) {
@@ -274,7 +286,7 @@ function widgetBehavior(publicAPI, model) {
     var newOrigin = multiplyAccumulate(center, axisTranslation, translationDistance, [0, 0, 0]);
     newOrigin = publicAPI.getBoundedCenter(newOrigin);
     model.widgetState.setCenter(newOrigin);
-    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI.getBoundedCenter = function (newCenter) {
@@ -295,7 +307,7 @@ function widgetBehavior(publicAPI, model) {
     var newCenter = add(model.widgetState.getCenter(), translation, []);
     newCenter = publicAPI.getBoundedCenter(newCenter);
     model.widgetState.setCenter(newCenter);
-    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI[InteractionMethodsName.RotateLine] = function (calldata) {
@@ -306,7 +318,7 @@ function widgetBehavior(publicAPI, model) {
     var previousLineDirection = activeLineHandle.getDirection();
     normalize(previousLineDirection);
 
-    if (publicAPI.getActiveRotationPointName() === 'point0') {
+    if (publicAPI.getActiveRotationPointName() === 'point1') {
       multiplyScalar(previousLineDirection, -1);
     }
 
@@ -329,13 +341,13 @@ function widgetBehavior(publicAPI, model) {
     var planeNormal = model.widgetState.getPlanes()[inViewType].normal;
     publicAPI.rotatePlane(viewType, radianAngle, planeNormal);
 
-    if (model.widgetState.getKeepOrthogonality()) {
+    if (publicAPI.getKeepOrthogonality()) {
       var otherLineName = getOtherLineName(lineName);
       var otherPlaneName = getLinePlaneName(otherLineName);
       publicAPI.rotatePlane(planeNameToViewType[otherPlaneName], radianAngle, planeNormal);
     }
 
-    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
   };
   /**
    * Rotate a specified plane around an other specified plane.

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -6,7 +6,6 @@ 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 { getPixelWorldHeightAtCoord } from '../../Representations/WidgetRepresentation.js';
 import { planeNames, lineNames, planeNameToViewType } from './Constants.js';
 
 var EPSILON = 10e-7;
@@ -157,25 +156,15 @@ function getOtherLineName(lineName) {
     return planeName !== linePlaneName && planeName !== lineInPlaneName;
   });
   return "".concat(otherLineName, "in").concat(lineInPlaneName);
-} // Update the extremities and the rotation point coordinate of the line
+} // Compute the offset of the rotation handle origin
 
-function computeRotationHandleOrigin(center, axis, rotationHandlePosition, volumeDiagonalLength, displayScaleParams) {
+function computeRotationHandleOriginOffset(axis, rotationHandlePosition, volumeDiagonalLength, scaleInPixels) {
   // FIXME: p1 and p2 could be placed on the exact boundaries of the volume.
-  var distanceToCenter = volumeDiagonalLength; // displayScaleParams is not null when representation.getScaleInPixels() is true
-
-  if (displayScaleParams) {
-    var pixelWorldHeight = getPixelWorldHeightAtCoord(center, displayScaleParams);
-    var rendererPixelDims = displayScaleParams.rendererPixelDims;
-    var totalSize = Math.min(rendererPixelDims[0], rendererPixelDims[1]) / 2;
-    distanceToCenter = pixelWorldHeight * totalSize;
-  }
-
-  distanceToCenter *= rotationHandlePosition;
-  return multiplyAccumulate(center, axis, distanceToCenter, []);
+  return multiplyScalar(_toConsumableArray(axis), rotationHandlePosition * (scaleInPixels ? 1 : volumeDiagonalLength) / 2);
 } // Update the reslice cursor state according to the three planes normals and the origin
 
 
-function updateState(widgetState, displayScaleParams, rotationHandlePosition) {
+function updateState(widgetState, scaleInPixels, rotationHandlePosition) {
   // Compute line axis
   var xNormal = widgetState.getPlanes()[ViewTypes.YZ_PLANE].normal;
   var yNormal = widgetState.getPlanes()[ViewTypes.XZ_PLANE].normal;
@@ -196,13 +185,13 @@ function updateState(widgetState, displayScaleParams, rotationHandlePosition) {
   lineNames.forEach(function (lineName) {
     var planeName = getLinePlaneName(lineName);
     var inPlaneName = getLineInPlaneName(lineName);
-    var rotationPoint0 = computeRotationHandleOrigin(center, axes["".concat(planeName).concat(inPlaneName)], rotationHandlePosition, pdLength, displayScaleParams[planeNameToViewType[inPlaneName]]);
-    widgetState["getRotationHandle".concat(lineName, "0")]().setOrigin(rotationPoint0);
-    var rotationPoint1 = computeRotationHandleOrigin(center, multiplyScalar(axes["".concat(planeName).concat(inPlaneName)], -1), rotationHandlePosition, pdLength, displayScaleParams[planeNameToViewType[inPlaneName]]);
-    widgetState["getRotationHandle".concat(lineName, "1")]().setOrigin(rotationPoint1);
+    var direction = axes["".concat(planeName).concat(inPlaneName)];
+    widgetState["getRotationHandle".concat(lineName, "0")]().setOrigin(center);
+    widgetState["getRotationHandle".concat(lineName, "0")]().setOffset(computeRotationHandleOriginOffset(direction, rotationHandlePosition, pdLength, scaleInPixels));
+    widgetState["getRotationHandle".concat(lineName, "1")]().setOrigin(center);
+    widgetState["getRotationHandle".concat(lineName, "1")]().setOffset(computeRotationHandleOriginOffset(direction, -rotationHandlePosition, pdLength, scaleInPixels));
     var lineHandle = widgetState["getAxis".concat(lineName)]();
     lineHandle.setOrigin(center);
-    var direction = subtract(rotationPoint0, center, []);
     var scale = normalize(direction);
     var scale3 = lineHandle.getScale3();
     scale3[2] = 2 * scale;

package/Widgets/Widgets3D/ResliceCursorWidget/state.js

@@ -17,24 +17,12 @@ function generateState() {
   var state = vtkStateBuilder.createBuilder().addField({
     name: 'center',
     initialValue: [0, 0, 0]
-  }).addField({
-    name: 'opacity',
-    initialValue: 1
   }).addField({
     name: 'image',
     initialValue: null
   }).addField({
     name: 'activeViewType',
     initialValue: null
-  }).addField({
-    name: 'lineThickness',
-    initialValue: 2
-  }).addField({
-    name: 'sphereRadius',
-    initialValue: 5
-  }).addField({
-    name: 'showCenter',
-    initialValue: true
   }).addField({
     name: 'planes',
     initialValue: (_initialValue = {}, _defineProperty(_initialValue, ViewTypes.YZ_PLANE, {
@@ -47,15 +35,6 @@ function generateState() {
       normal: [0, 0, -1],
       viewUp: [0, -1, 0]
     }), _initialValue)
-  }).addField({
-    name: 'enableRotation',
-    initialValue: true
-  }).addField({
-    name: 'enableTranslation',
-    initialValue: true
-  }).addField({
-    name: 'keepOrthogonality',
-    initialValue: false
   }).addField({
     name: 'scrollingMethod',
     initialValue: ScrollingMethods.MIDDLE_MOUSE_BUTTON
@@ -66,7 +45,7 @@ function generateState() {
     name: 'viewUpFromViewType',
     initialValue: {}
   }).addStateFromMixin({
-    labels: ['handles', 'center'],
+    labels: ['handles', 'sphere', 'center'],
     mixins: ['origin', 'color3', 'scale1', 'visible', 'manipulator'],
     name: 'centerHandle',
     initialValues: {
@@ -92,7 +71,7 @@ function generateState() {
 
       for (var rotationHandle = 0; rotationHandle < 2; ++rotationHandle) {
         axisState.addStateFromMixin({
-          labels: ['handles', 'rotation', "rotationIn".concat(view), "".concat(axis, "in").concat(view), "point".concat(rotationHandle)],
+          labels: ['handles', 'sphere', 'rotation', "rotationIn".concat(view), "".concat(axis, "in").concat(view), "point".concat(rotationHandle)],
           mixins: ['origin', 'color3', 'scale1', 'visible', 'manipulator'],
           name: "rotationHandle".concat(axis, "in").concat(view).concat(rotationHandle),
           initialValues: {