@kitware/vtk.js 25.9.1 → 26.0.0-beta.1

package/Widgets/Representations/WidgetRepresentation.js

@@ -1,11 +1,15 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 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 { s as subtract, d as dot } from '../../Common/Core/Math/index.js';
+import { g 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';
 import { Behavior } from './WidgetRepresentation/Constants.js';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 import { CATEGORIES } from '../../Rendering/Core/Mapper/CoincidentTopologyHelper.js';
+import { POLYDATA_FIELDS } from '../../Common/DataModel/PolyData/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; }
 
@@ -67,10 +71,24 @@ function applyStyles(pipelines, styles, activeActor) {
 } // ----------------------------------------------------------------------------
 
 function connectPipeline(pipeline) {
-  if (pipeline.source.isA('vtkDataSet')) {
-    pipeline.mapper.setInputData(pipeline.source);
-  } else {
-    pipeline.mapper.setInputConnection(pipeline.source.getOutputPort());
+  var source = pipeline.source;
+
+  if (pipeline.filter) {
+    if (source.isA('vtkDataSet')) {
+      pipeline.filter.setInputData(source);
+    } else {
+      pipeline.filter.setInputConnection(source.getOutputPort());
+    }
+
+    source = pipeline.filter;
+  }
+
+  if (source) {
+    if (source.isA('vtkDataSet')) {
+      pipeline.mapper.setInputData(source);
+    } else {
+      pipeline.mapper.setInputConnection(source.getOutputPort());
+    }
   }
 
   if (pipeline.glyph) {
@@ -78,16 +96,84 @@ 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) {
+  var _polyData$;
+
+  // Check first whether name is points, verts, lines, polys, otherwise it is a point data array.
+  var dataArray = ((_polyData$ = polyData["get".concat(macro.capitalize(name))]) === null || _polyData$ === void 0 ? void 0 : _polyData$.call(polyData)) || polyData.getPointData().getArrayByName(name);
+
+  if (!dataArray || dataType !== undefined && dataArray.getDataType() !== dataType || numberOfComponents !== undefined && dataArray.getNumberOfComponents() !== numberOfComponents) {
+    var arrayType = vtkDataArray;
+    var arrayDataType = dataType;
+    var arrayNumberOfComponents = numberOfComponents;
+
+    if (name === 'points') {
+      var _arrayDataType;
+
+      arrayType = vtkPoints;
+      arrayDataType = (_arrayDataType = arrayDataType) !== null && _arrayDataType !== void 0 ? _arrayDataType : 'Float32Array';
+      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 3;
+    } else if (POLYDATA_FIELDS.includes(name)) {
+      var _arrayDataType2;
+
+      arrayType = vtkCellArray;
+      arrayDataType = (_arrayDataType2 = arrayDataType) !== null && _arrayDataType2 !== void 0 ? _arrayDataType2 : 'Uint16Array';
+      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 1;
+    } else {
+      var _arrayDataType3;
+
+      // data array
+      arrayDataType = (_arrayDataType3 = arrayDataType) !== null && _arrayDataType3 !== void 0 ? _arrayDataType3 : 'Float32Array';
+      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 1;
+    }
+
+    dataArray = arrayType.newInstance({
+      name: name,
+      dataType: arrayDataType,
+      numberOfComponents: arrayNumberOfComponents,
+      size: arrayNumberOfComponents * numberOfTuples,
+      empty: numberOfTuples === 0
+    });
+
+    if (name === 'points' || POLYDATA_FIELDS.includes(name)) {
+      polyData["set".concat(macro.capitalize(name))](dataArray);
+    } else {
+      polyData.getPointData().addArray(dataArray);
+    }
+  } else if (dataArray.getNumberOfTuples() !== numberOfTuples) {
+    dataArray.resize(numberOfTuples);
+  }
+
+  return dataArray;
 } // ----------------------------------------------------------------------------
 // vtkWidgetRepresentation
 // ----------------------------------------------------------------------------
 
 function vtkWidgetRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWidgetRepresentation');
-
-  var superclass = _objectSpread({}, publicAPI); // Internal cache
-
+  model.classHierarchy.push('vtkWidgetRepresentation'); // Internal cache
 
   var cache = {
     mtimes: {},
@@ -217,35 +303,10 @@ function vtkWidgetRepresentation(publicAPI, model) {
   };
 
   publicAPI.setCoincidentTopologyParameters = function (parameters) {
-    var modified = superclass.setCoincidentTopologyParameters(parameters);
-
-    if (modified) {
-      publicAPI.getActors().forEach(function (actor) {
-        applyCoincidentTopologyParametersToMapper(actor.getMapper(), model.coincidentTopologyParameters);
-      });
-    }
-  };
-
-  publicAPI.getPixelWorldHeightAtCoord = function (worldCoord) {
-    var _model$displayScalePa = model.displayScaleParams,
-        dispHeightFactor = _model$displayScalePa.dispHeightFactor,
-        cameraPosition = _model$displayScalePa.cameraPosition,
-        cameraDir = _model$displayScalePa.cameraDir,
-        isParallel = _model$displayScalePa.isParallel,
-        rendererPixelDims = _model$displayScalePa.rendererPixelDims;
-    var scale = 1;
-
-    if (isParallel) {
-      scale = dispHeightFactor;
-    } else {
-      var worldCoordToCamera = _toConsumableArray(worldCoord);
-
-      subtract(worldCoordToCamera, cameraPosition, worldCoordToCamera);
-      scale = dot(worldCoordToCamera, cameraDir) * dispHeightFactor;
-    }
-
-    var rHeight = rendererPixelDims[1];
-    return scale / rHeight;
+    model.coincidentTopologyParameters = parameters;
+    publicAPI.getActors().forEach(function (actor) {
+      applyCoincidentTopologyParametersToMapper(actor.getMapper(), model.coincidentTopologyParameters);
+    });
   }; // Make sure setting the labels at build time works with string/array...
 
 
@@ -255,49 +316,49 @@ function vtkWidgetRepresentation(publicAPI, model) {
 // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  actors: [],
-  labels: [],
-  behavior: Behavior.CONTEXT,
-  coincidentTopologyParameters: {
-    Point: {
-      factor: -1.0,
-      offset: -1.0
+function defaultValues(initialValues) {
+  return _objectSpread({
+    activeScaleFactor: 1.2,
+    activeColor: 1,
+    useActiveColor: true,
+    actors: [],
+    labels: [],
+    behavior: Behavior.CONTEXT,
+    coincidentTopologyParameters: {
+      Point: {
+        factor: -1.0,
+        offset: -1.0
+      },
+      Line: {
+        factor: -1.0,
+        offset: -1.0
+      },
+      Polygon: {
+        factor: -1.0,
+        offset: -1.0
+      }
     },
-    Line: {
-      factor: -1.0,
-      offset: -1.0
+    scaleInPixels: false,
+    displayScaleParams: {
+      dispHeightFactor: 1,
+      cameraPosition: [0, 0, 0],
+      cameraDir: [1, 0, 0],
+      isParallel: false,
+      rendererPixelDims: [1, 1]
     },
-    Polygon: {
-      factor: -1.0,
-      offset: -1.0
-    }
-  },
-  scaleInPixels: false,
-  displayScaleParams: {
-    dispHeightFactor: 1,
-    cameraPosition: [0, 0, 0],
-    cameraDir: [1, 0, 0],
-    isParallel: false,
-    rendererPixelDims: [1, 1]
-  }
-}; // ----------------------------------------------------------------------------
+    _internalArrays: {}
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
-
-  vtkProp.extend(publicAPI, model, initialValues);
+  // Object methods
+  vtkProp.extend(publicAPI, model, defaultValues(initialValues));
   macro.algo(publicAPI, model, 1, 1);
-  macro.get(publicAPI, model, ['labels']);
-  macro.set(publicAPI, model, [{
-    type: 'object',
-    name: 'displayScaleParams'
-  }, {
-    type: 'object',
-    name: 'coincidentTopologyParameters'
-  }]);
-  macro.setGet(publicAPI, model, ['scaleInPixels']); // Object specific methods
+  macro.get(publicAPI, model, ['labels', 'coincidentTopologyParameters']);
+  macro.set(publicAPI, model, ['displayScaleParams']);
+  macro.setGet(publicAPI, model, ['scaleInPixels', 'activeScaleFactor', 'activeColor', 'useActiveColor']); // Object specific methods
 
   vtkWidgetRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------
@@ -306,7 +367,8 @@ var vtkWidgetRepresentation$1 = {
   extend: extend,
   mergeStyles: mergeStyles,
   applyStyles: applyStyles,
-  connectPipeline: connectPipeline
+  connectPipeline: connectPipeline,
+  getPixelWorldHeightAtCoord: getPixelWorldHeightAtCoord
 };
 
-export { applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, mergeStyles };
+export { allocateArray, applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, getPixelWorldHeightAtCoord, mergeStyles };

package/Widgets/Representations.js

@@ -2,11 +2,14 @@ import vtkCircleContextRepresentation from './Representations/CircleContextRepre
 import vtkContextRepresentation from './Representations/ContextRepresentation.js';
 import vtkConvexFaceContextRepresentation from './Representations/ConvexFaceContextRepresentation.js';
 import vtkCubeHandleRepresentation from './Representations/CubeHandleRepresentation.js';
+import vtkGlyphRepresentation from './Representations/GlyphRepresentation.js';
 import vtkHandleRepresentation from './Representations/HandleRepresentation.js';
 import vtkImplicitPlaneRepresentation from './Representations/ImplicitPlaneRepresentation.js';
+import vtkLineHandleRepresentation from './Representations/LineHandleRepresentation.js';
 import vtkOutlineContextRepresentation from './Representations/OutlineContextRepresentation.js';
 import vtkPolyLineRepresentation from './Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from './Representations/SphereHandleRepresentation.js';
+import vtkSplineContextRepresentation from './Representations/SplineContextRepresentation.js';
 import vtkWidgetRepresentation from './Representations/WidgetRepresentation.js';
 
 var Representations = {
@@ -14,11 +17,14 @@ var Representations = {
   vtkContextRepresentation: vtkContextRepresentation,
   vtkConvexFaceContextRepresentation: vtkConvexFaceContextRepresentation,
   vtkCubeHandleRepresentation: vtkCubeHandleRepresentation,
+  vtkGlyphRepresentation: vtkGlyphRepresentation,
   vtkHandleRepresentation: vtkHandleRepresentation,
   vtkImplicitPlaneRepresentation: vtkImplicitPlaneRepresentation,
+  vtkLineHandleRepresentation: vtkLineHandleRepresentation,
   vtkOutlineContextRepresentation: vtkOutlineContextRepresentation,
   vtkPolyLineRepresentation: vtkPolyLineRepresentation,
   vtkSphereHandleRepresentation: vtkSphereHandleRepresentation,
+  vtkSplineContextRepresentation: vtkSplineContextRepresentation,
   vtkWidgetRepresentation: vtkWidgetRepresentation
 };
 

package/Widgets/SVG/SVGLandmarkRepresentation.js

@@ -152,19 +152,7 @@ function defaultValues(initialValues) {
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   vtkSVGRepresentation.extend(publicAPI, model, defaultValues(initialValues));
-  macro.setGet(publicAPI, model, [{
-    type: 'object',
-    name: 'circleProps'
-  }, {
-    type: 'object',
-    name: 'fontProperties'
-  }, {
-    type: 'object',
-    name: 'strokeFontProperties'
-  }, {
-    type: 'object',
-    name: 'textProps'
-  }]); // Object specific methods
+  macro.setGet(publicAPI, model, ['circleProps', 'fontProperties', 'strokeFontProperties', 'textProps']); // Object specific methods
 
   vtkSVGLandmarkRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Widgets3D/AngleWidget.js

@@ -32,10 +32,7 @@ function vtkAngleWidget(publicAPI, model) {
       default:
         return [{
           builder: vtkSphereHandleRepresentation,
-          labels: ['handles']
-        }, {
-          builder: vtkSphereHandleRepresentation,
-          labels: ['moveHandle']
+          labels: ['handles', 'moveHandle']
         }, {
           builder: vtkPolyLineRepresentation,
           labels: ['handles', 'moveHandle']

package/Widgets/Widgets3D/EllipseWidget/state.js

@@ -23,7 +23,7 @@ function generateState() {
     mixins: ['origin', 'color', 'scale3', 'visible', 'orientation'],
     name: 'ellipseHandle',
     initialValues: {
-      visible: false,
+      // visible: false,
       scale3: [1, 1, 1]
     }
   }) // FIXME: How to not duplicate with RectangleWidget

package/Widgets/Widgets3D/ResliceCursorWidget/Constants.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
 
-var _defaultViewUpFromVie, _viewTypeToXYZ;
+var _defaultViewUpFromVie, _viewTypeToXYZ, _viewTypeToPlaneName;
 var ScrollingMethods = {
   MIDDLE_MOUSE_BUTTON: 0,
   LEFT_MOUSE_BUTTON: 1,
@@ -17,11 +17,23 @@ var InteractionMethodsName = {
 var defaultViewUpFromViewType = (_defaultViewUpFromVie = {}, _defineProperty(_defaultViewUpFromVie, ViewTypes.YZ_PLANE, [0, 0, 1]), _defineProperty(_defaultViewUpFromVie, ViewTypes.XZ_PLANE, [0, 0, 1]), _defineProperty(_defaultViewUpFromVie, ViewTypes.XY_PLANE, [0, -1, 0]), _defaultViewUpFromVie);
 var xyzToViewType = [ViewTypes.YZ_PLANE, ViewTypes.XZ_PLANE, ViewTypes.XY_PLANE];
 var viewTypeToXYZ = (_viewTypeToXYZ = {}, _defineProperty(_viewTypeToXYZ, ViewTypes.YZ_PLANE, 0), _defineProperty(_viewTypeToXYZ, ViewTypes.XZ_PLANE, 1), _defineProperty(_viewTypeToXYZ, ViewTypes.XY_PLANE, 2), _viewTypeToXYZ);
+var planeNames = ['X', 'Y', 'Z'];
+var viewTypeToPlaneName = (_viewTypeToPlaneName = {}, _defineProperty(_viewTypeToPlaneName, ViewTypes.YZ_PLANE, 'X'), _defineProperty(_viewTypeToPlaneName, ViewTypes.XZ_PLANE, 'Y'), _defineProperty(_viewTypeToPlaneName, ViewTypes.XY_PLANE, 'Z'), _viewTypeToPlaneName);
+var planeNameToViewType = {
+  X: ViewTypes.YZ_PLANE,
+  Y: ViewTypes.XZ_PLANE,
+  Z: ViewTypes.XY_PLANE
+};
+var lineNames = ['YinX', 'ZinX', 'XinY', 'ZinY', 'XinZ', 'YinZ'];
 var Constants = {
   ScrollingMethods: ScrollingMethods,
   InteractionMethodsName: InteractionMethodsName,
   xyzToViewType: xyzToViewType,
-  viewTypeToXYZ: viewTypeToXYZ
+  viewTypeToXYZ: viewTypeToXYZ,
+  planeNames: planeNames,
+  viewTypeToPlaneName: viewTypeToPlaneName,
+  planeNameToViewType: planeNameToViewType,
+  lineNames: lineNames
 };
 
-export { InteractionMethodsName, ScrollingMethods, Constants as default, defaultViewUpFromViewType, viewTypeToXYZ, xyzToViewType };
+export { InteractionMethodsName, ScrollingMethods, Constants as default, defaultViewUpFromViewType, lineNames, planeNameToViewType, planeNames, viewTypeToPlaneName, viewTypeToXYZ, xyzToViewType };

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -3,16 +3,75 @@ 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 { s as subtract, m as normalize, d as dot, k as cross, o as multiplyAccumulate, x as multiplyScalar, T as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
-import { updateState, getAssociatedLinesName, boundPointOnPlane, rotateVector } from './helpers.js';
-import { InteractionMethodsName, ScrollingMethods } from './Constants.js';
+import { l as add, m as normalize, d as dot, k as cross, s as subtract, o as multiplyAccumulate, x as multiplyScalar, T 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';
 
 function widgetBehavior(publicAPI, model) {
   model._isDragging = false;
-  var isScrolling = false; // Reset "updateMethodName" attribute when no actors are selected
+  var isScrolling = false; // FIXME: label information should be accessible from activeState instead of parent state.
+
+  publicAPI.getActiveInteraction = function () {
+    if (model.widgetState.getStatesWithLabel('rotation').includes(model.activeState)) {
+      return InteractionMethodsName.RotateLine;
+    }
+
+    if (model.widgetState.getStatesWithLabel('line').includes(model.activeState)) {
+      return InteractionMethodsName.TranslateAxis;
+    }
+
+    if (model.widgetState.getStatesWithLabel('center').includes(model.activeState)) {
+      return InteractionMethodsName.TranslateCenter;
+    }
+
+    return null;
+  };
+  /**
+   * ActiveState can be RotationHandle or a LineHandle
+   * @returns 'YinX', 'ZinX', 'XinY', 'ZinY', 'XinZ' or 'YinZ'
+   */
+
+
+  publicAPI.getActiveLineName = function () {
+    return lineNames.find(function (lineName) {
+      return model.widgetState.getStatesWithLabel(lineName).includes(model.activeState);
+    });
+  }; // FIXME: label information should be accessible from activeState instead of parent state.
+
+
+  publicAPI.getActiveLineHandle = function () {
+    var _model$widgetState$, _model$widgetState;
+
+    return (_model$widgetState$ = (_model$widgetState = model.widgetState)["getAxis".concat(publicAPI.getActiveLineName())]) === null || _model$widgetState$ === void 0 ? void 0 : _model$widgetState$.call(_model$widgetState);
+  };
+  /**
+   * Return the line handle of the other line in the same view.
+   * @param {string} lineName name of the line (YinX, ZinX, XinY, ZinY, XinZ, YinZ)
+   * @returns ZinX if lineName == YinX, YinX if lineName == ZinX, ZinY if lineName == XinY...
+   */
+
+
+  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);
+  }; // 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'
+   */
+
+
+  publicAPI.getActiveRotationPointName = function () {
+    return model.widgetState.getStatesWithLabel('point0').includes(model.activeState) ? 'point0' : 'point1';
+  }; // Reset "updateMethodName" attribute when no actors are selected
   // Useful to update 'updateMethodeName' to the correct name which
   // will be TranslateCenter by default
 
+
   publicAPI.resetUpdateMethod = function () {
     if (model.representations.length !== 0) {
       model.representations[0].getSelectedState();
@@ -35,7 +94,7 @@ function widgetBehavior(publicAPI, model) {
   };
 
   publicAPI.updateCursor = function () {
-    switch (model.activeState.getUpdateMethodName()) {
+    switch (publicAPI.getActiveInteraction()) {
       case InteractionMethodsName.TranslateCenter:
         model._apiSpecificRenderWindow.setCursor('move');
 
@@ -61,7 +120,7 @@ function widgetBehavior(publicAPI, model) {
   publicAPI.handleLeftButtonPress = function (callData) {
     if (model.activeState && model.activeState.getActive()) {
       model._isDragging = true;
-      var viewType = model.widgetState.getActiveViewType();
+      var viewType = model.viewType;
       var currentPlaneNormal = model.widgetState.getPlanes()[viewType].normal;
       model.planeManipulator.setWidgetOrigin(model.widgetState.getCenter());
       model.planeManipulator.setWidgetNormal(currentPlaneNormal);
@@ -145,7 +204,7 @@ function widgetBehavior(publicAPI, model) {
 
   publicAPI.handleEvent = function (callData) {
     if (model.activeState.getActive()) {
-      publicAPI[model.activeState.getUpdateMethodName()](callData);
+      publicAPI[publicAPI.getActiveInteraction()](callData);
       publicAPI.invokeInternalInteractionEvent();
       return macro.EVENT_ABORT;
     }
@@ -154,7 +213,7 @@ function widgetBehavior(publicAPI, model) {
   };
 
   publicAPI.invokeInternalInteractionEvent = function () {
-    var methodName = model.activeState ? model.activeState.getUpdateMethodName() : '';
+    var methodName = publicAPI.getActiveInteraction();
     var computeFocalPointOffset = methodName !== InteractionMethodsName.RotateLine;
     var canUpdateFocalPoint = methodName === InteractionMethodsName.RotateLine;
     publicAPI.invokeInteractionEvent({
@@ -194,22 +253,20 @@ 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);
+    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI[InteractionMethodsName.TranslateAxis] = function (calldata) {
-    var stateLine = model.widgetState.getActiveLineState();
-    var worldCoords = model.planeManipulator.handleEvent(calldata, model._apiSpecificRenderWindow);
-    var point1 = stateLine.getPoint1();
-    var point2 = stateLine.getPoint2(); // Translate the current line along the other line
-
-    var otherLineName = getAssociatedLinesName(stateLine.getName());
-    var otherLine = model.widgetState["get".concat(otherLineName)]();
-    var otherLineVector = subtract(otherLine.getPoint2(), otherLine.getPoint1(), []);
+    var lineHandle = publicAPI.getActiveLineHandle();
+    var lineName = publicAPI.getActiveLineName();
+    var pointOnLine = add(lineHandle.getOrigin(), lineHandle.getDirection(), []);
+    var currentLineVector = lineHandle.getDirection();
+    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 currentLineVector = subtract(point2, point1, [0, 0, 0]);
-    normalize(currentLineVector);
     var dot$1 = dot(currentLineVector, otherLineVector); // lines are colinear, translate along perpendicular axis from current line
 
     if (dot$1 === 1 || dot$1 === -1) {
@@ -217,14 +274,15 @@ function widgetBehavior(publicAPI, model) {
     }
 
     var closestPoint = [];
-    vtkLine.distanceToLine(worldCoords, point1, point2, 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);
+    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI.getBoundedCenter = function (newCenter) {
@@ -241,19 +299,19 @@ function widgetBehavior(publicAPI, model) {
   publicAPI[InteractionMethodsName.TranslateCenter] = function (calldata) {
     var worldCoords = model.planeManipulator.handleEvent(calldata, model._apiSpecificRenderWindow);
     worldCoords = publicAPI.getBoundedCenter(worldCoords);
-    model.activeState.setCenter(worldCoords);
-    updateState(model.widgetState);
+    model.widgetState.setCenter(worldCoords);
+    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI[InteractionMethodsName.RotateLine] = function (calldata) {
-    var activeLine = model.widgetState.getActiveLineState();
+    var activeLineHandle = publicAPI.getActiveLineHandle();
     var planeNormal = model.planeManipulator.getWidgetNormal();
     var worldCoords = model.planeManipulator.handleEvent(calldata, model._apiSpecificRenderWindow);
     var center = model.widgetState.getCenter();
-    var previousLineDirection = subtract(activeLine.getPoint1(), activeLine.getPoint2(), []);
+    var previousLineDirection = activeLineHandle.getDirection();
     normalize(previousLineDirection);
 
-    if (model.widgetState.getActiveRotationPointName() === 'point1') {
+    if (publicAPI.getActiveRotationPointName() === 'point0') {
       multiplyScalar(previousLineDirection, -1);
     }
 
@@ -261,29 +319,28 @@ function widgetBehavior(publicAPI, model) {
     subtract(worldCoords, center, currentVectorToOrigin);
     normalize(currentVectorToOrigin);
     var radianAngle = signedAngleBetweenVectors(previousLineDirection, currentVectorToOrigin, planeNormal);
-    publicAPI.rotateLineInView(activeLine, radianAngle);
+    publicAPI.rotateLineInView(publicAPI.getActiveLineName(), radianAngle);
   };
   /**
    * Rotate a line by a specified angle
-   * @param {Line} line The line to rotate (e.g. getActiveLineState())
+   * @param {string} lineName The line name to rotate (e.g. YinX, ZinX, XinY, ZinY, XinZ, YinZ)
    * @param {Number} radianAngle Applied angle in radian
    */
 
 
-  publicAPI.rotateLineInView = function (line, radianAngle) {
-    var viewType = line.getViewType();
-    var inViewType = line.getInViewType();
+  publicAPI.rotateLineInView = function (lineName, radianAngle) {
+    var viewType = planeNameToViewType[getLinePlaneName(lineName)];
+    var inViewType = planeNameToViewType[getLineInPlaneName(lineName)];
     var planeNormal = model.widgetState.getPlanes()[inViewType].normal;
     publicAPI.rotatePlane(viewType, radianAngle, planeNormal);
 
     if (model.widgetState.getKeepOrthogonality()) {
-      var associatedLineName = getAssociatedLinesName(line.getName());
-      var associatedLine = model.widgetState["get".concat(associatedLineName)]();
-      var associatedViewType = associatedLine.getViewType();
-      publicAPI.rotatePlane(associatedViewType, radianAngle, planeNormal);
+      var otherLineName = getOtherLineName(lineName);
+      var otherPlaneName = getLinePlaneName(otherLineName);
+      publicAPI.rotatePlane(planeNameToViewType[otherPlaneName], radianAngle, planeNormal);
     }
 
-    updateState(model.widgetState);
+    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
   };
   /**
    * Rotate a specified plane around an other specified plane.