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

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -6,6 +6,8 @@ import vtkPlane from '../../../Common/DataModel/Plane.js';
 import { s as subtract, m as normalize, k as cross, x as multiplyScalar, o as multiplyAccumulate, T 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;
 /**
@@ -126,35 +128,91 @@ function rotateVector(vectorToBeRotated, axis, angle) {
 
   vtkMatrixBuilder.buildFromRadian().rotate(angle, axis).apply(rotatedVector);
   return rotatedVector;
+}
+/**
+ * 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)
+ */
+
+function getLinePlaneName(lineName) {
+  return lineName[0];
+}
+/**
+ * Return X if lineName == YinX|ZinX, Y if lineName == XinY|ZinY and Z otherwise
+ * @param {string} lineName name of the line (YinX, ZinX, XinY, ZinY, XinZ, YinZ)
+ */
+
+function getLineInPlaneName(lineName) {
+  return lineName[3];
+}
+/**
+ * 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) {
+  var linePlaneName = getLinePlaneName(lineName);
+  var lineInPlaneName = getLineInPlaneName(lineName);
+  var otherLineName = planeNames.find(function (planeName) {
+    return planeName !== linePlaneName && planeName !== lineInPlaneName;
+  });
+  return "".concat(otherLineName, "in").concat(lineInPlaneName);
 } // Update the extremities and the rotation point coordinate of the line
 
-function updateLine(lineState, center, axis, lineLength) {
-  var p1 = [center[0] - lineLength * axis[0], center[1] - lineLength * axis[1], center[2] - lineLength * axis[2]];
-  var p2 = [center[0] + lineLength * axis[0], center[1] + lineLength * axis[1], center[2] + lineLength * axis[2]]; // FIXME: p1 and p2 should be placed on the boundaries of the volume.
+function computeRotationHandleOrigin(center, axis, rotationHandlePosition, volumeDiagonalLength, displayScaleParams) {
+  // 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;
+  }
 
-  lineState.setPoint1(p1);
-  lineState.setPoint2(p2);
+  distanceToCenter *= rotationHandlePosition;
+  return multiplyAccumulate(center, axis, distanceToCenter, []);
 } // Update the reslice cursor state according to the three planes normals and the origin
 
 
-function updateState(widgetState) {
+function updateState(widgetState, displayScaleParams, 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 yzIntersectionLineAxis = cross(yNormal, zNormal, []);
-  var xzIntersectionLineAxis = cross(zNormal, xNormal, []);
-  var xyIntersectionLineAxis = cross(xNormal, yNormal, []);
+  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 bounds = widgetState.getImage().getBounds();
   var center = widgetState.getCenter(); // Length of the principal diagonal.
 
-  var pdLength = 0.5 * vtkBoundingBox.getDiagonalLength(bounds);
-  updateLine(widgetState.getAxisXinY(), center, xyIntersectionLineAxis, pdLength);
-  updateLine(widgetState.getAxisYinX(), center, xyIntersectionLineAxis, pdLength);
-  updateLine(widgetState.getAxisYinZ(), center, yzIntersectionLineAxis, pdLength);
-  updateLine(widgetState.getAxisZinY(), center, yzIntersectionLineAxis, pdLength);
-  updateLine(widgetState.getAxisXinZ(), center, xzIntersectionLineAxis, pdLength);
-  updateLine(widgetState.getAxisZinX(), center, xzIntersectionLineAxis, pdLength);
+  var pdLength = vtkBoundingBox.getDiagonalLength(bounds);
+  widgetState.getCenterHandle().setOrigin(center);
+  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 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;
+    lineHandle.setScale3(scale3);
+    var right = widgetState.getPlanes()[planeNameToViewType[inPlaneName]].normal;
+    var up = cross(direction, right, []);
+    lineHandle.setRight(right);
+    lineHandle.setUp(up);
+    lineHandle.setDirection(direction);
+  });
 }
 /**
  * First rotate planeToTransform to match targetPlane normal.
@@ -173,71 +231,6 @@ function transformPlane(planeToTransform, targetCenter, targetNormal, targetView
   var angle = signedAngleBetweenVectors(viewUp, targetViewUp, targetNormal);
   planeToTransform.rotate(angle, targetNormal);
   planeToTransform.setCenter(targetCenter);
-} // Get name of the line in the same plane as the input
-
-function getAssociatedLinesName(lineName) {
-  switch (lineName) {
-    case 'AxisXinY':
-      return 'AxisZinY';
-
-    case 'AxisXinZ':
-      return 'AxisYinZ';
-
-    case 'AxisYinX':
-      return 'AxisZinX';
-
-    case 'AxisYinZ':
-      return 'AxisXinZ';
-
-    case 'AxisZinX':
-      return 'AxisYinX';
-
-    case 'AxisZinY':
-      return 'AxisXinY';
-
-    default:
-      return '';
-  }
-}
-/**
- * Get the line name, constructs from the plane name and where the plane is displayed
- * Example: planeName='X' rotatedPlaneName='Y', then the return values will be 'AxisXinY'
- * @param {String} planeName Value between 'X', 'Y' and 'Z'
- * @param {String} rotatedPlaneName Value between 'X', 'Y' and 'Z'
- * @returns {String}
- */
-
-function getLineNameFromPlaneAndRotatedPlaneName(planeName, rotatedPlaneName) {
-  return "Axis".concat(planeName, "in").concat(rotatedPlaneName);
-}
-/**
- * Extract the plane name from the line name
- * Example: 'AxisXinY' will return 'X'
- * @param {String} lineName Should be following this template : 'Axis_in_' with _ a character
- * @returns {String} Value between 'X', 'Y' and 'Z' or null if an error occured
- */
-
-function getPlaneNameFromLineName(lineName) {
-  var match = lineName.match('([XYZ])in[XYZ]');
-
-  if (match) {
-    return match[1];
-  }
-
-  return null;
-}
-/**
- * Get the orthogonal plane name of 'planeName' in a specific 'rotatedPlaneName'
- * Example: planeName='X' on rotatedPlaneName='Z', then the associated plane name
- * of 'X' plane is 'Y'
- * @param {String} planeName
- * @param {String} rotatedPlaneName
- */
-
-function getAssociatedPlaneName(planeName, rotatedPlaneName) {
-  var lineName = getLineNameFromPlaneAndRotatedPlaneName(planeName, rotatedPlaneName);
-  var associatedLine = getAssociatedLinesName(lineName);
-  return getPlaneNameFromLineName(associatedLine);
 }
 
-export { boundPlane, boundPoint, boundPointOnPlane, getAssociatedLinesName, getAssociatedPlaneName, getLineNameFromPlaneAndRotatedPlaneName, getPlaneNameFromLineName, rotateVector, transformPlane, updateState };
+export { boundPlane, boundPoint, boundPointOnPlane, getLineInPlaneName, getLinePlaneName, getOtherLineName, rotateVector, transformPlane, updateState };

package/Widgets/Widgets3D/ResliceCursorWidget/state.js

@@ -1,184 +1,25 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import vtkStateBuilder from '../../Core/StateBuilder.js';
-import { ScrollingMethods } from './Constants.js';
+import { ScrollingMethods, planeNames } from './Constants.js';
 import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
 
-var factor = 1;
-var axisXColor = [1, 0, 0];
-var axisYColor = [0, 1, 0];
-var axisZColor = [0, 0, 1];
+var viewsColor3 = {
+  X: [255, 0, 0],
+  // red
+  Y: [0, 255, 0],
+  // green
+  Z: [0, 0, 255] // blue
 
-var generateAxisXinY = function generateAxisXinY() {
-  return vtkStateBuilder.createBuilder().addField({
-    name: 'point1',
-    initialValue: [0, 0, -factor]
-  }).addField({
-    name: 'point2',
-    initialValue: [0, 0, factor]
-  }).addField({
-    name: 'color',
-    initialValue: axisXColor
-  }).addField({
-    name: 'name',
-    initialValue: 'AxisXinY'
-  }).addField({
-    name: 'viewType',
-    initialValue: ViewTypes.YZ_PLANE
-  }).addField({
-    name: 'inViewType',
-    initialValue: ViewTypes.XZ_PLANE
-  }).build();
-};
-
-var generateAxisXinZ = function generateAxisXinZ() {
-  return vtkStateBuilder.createBuilder().addField({
-    name: 'point1',
-    initialValue: [0, -factor, 0]
-  }).addField({
-    name: 'point2',
-    initialValue: [0, factor, 0]
-  }).addField({
-    name: 'color',
-    initialValue: axisXColor
-  }).addField({
-    name: 'name',
-    initialValue: 'AxisXinZ'
-  }).addField({
-    name: 'viewType',
-    initialValue: ViewTypes.YZ_PLANE
-  }).addField({
-    name: 'inViewType',
-    initialValue: ViewTypes.XY_PLANE
-  }).build();
-};
-
-var generateAxisYinX = function generateAxisYinX() {
-  return vtkStateBuilder.createBuilder().addField({
-    name: 'point1',
-    initialValue: [0, 0, -factor]
-  }).addField({
-    name: 'point2',
-    initialValue: [0, 0, factor]
-  }).addField({
-    name: 'color',
-    initialValue: axisYColor
-  }).addField({
-    name: 'name',
-    initialValue: 'AxisYinX'
-  }).addField({
-    name: 'viewType',
-    initialValue: ViewTypes.XZ_PLANE
-  }).addField({
-    name: 'inViewType',
-    initialValue: ViewTypes.YZ_PLANE
-  }).build();
-};
-
-var generateAxisYinZ = function generateAxisYinZ() {
-  return vtkStateBuilder.createBuilder().addField({
-    name: 'point1',
-    initialValue: [-factor, 0, 0]
-  }).addField({
-    name: 'point2',
-    initialValue: [factor, 0, 0]
-  }).addField({
-    name: 'color',
-    initialValue: axisYColor
-  }).addField({
-    name: 'name',
-    initialValue: 'AxisYinZ'
-  }).addField({
-    name: 'viewType',
-    initialValue: ViewTypes.XZ_PLANE
-  }).addField({
-    name: 'inViewType',
-    initialValue: ViewTypes.XY_PLANE
-  }).build();
-};
-
-var generateAxisZinX = function generateAxisZinX() {
-  return vtkStateBuilder.createBuilder().addField({
-    name: 'point1',
-    initialValue: [0, -factor, 0]
-  }).addField({
-    name: 'point2',
-    initialValue: [0, factor, 0]
-  }).addField({
-    name: 'color',
-    initialValue: axisZColor
-  }).addField({
-    name: 'name',
-    initialValue: 'AxisZinX'
-  }).addField({
-    name: 'viewType',
-    initialValue: ViewTypes.XY_PLANE
-  }).addField({
-    name: 'inViewType',
-    initialValue: ViewTypes.YZ_PLANE
-  }).build();
-};
-
-var generateAxisZinY = function generateAxisZinY() {
-  return vtkStateBuilder.createBuilder().addField({
-    name: 'point1',
-    initialValue: [-factor, 0, 0]
-  }).addField({
-    name: 'point2',
-    initialValue: [factor, 0, 0]
-  }).addField({
-    name: 'color',
-    initialValue: axisZColor
-  }).addField({
-    name: 'name',
-    initialValue: 'AxisZinY'
-  }).addField({
-    name: 'viewType',
-    initialValue: ViewTypes.XY_PLANE
-  }).addField({
-    name: 'inViewType',
-    initialValue: ViewTypes.XZ_PLANE
-  }).build();
 };
-
 function generateState() {
   var _initialValue;
 
-  return vtkStateBuilder.createBuilder().addStateFromInstance({
-    labels: ['AxisXinY'],
-    name: 'AxisXinY',
-    instance: generateAxisXinY()
-  }).addStateFromInstance({
-    labels: ['AxisXinZ'],
-    name: 'AxisXinZ',
-    instance: generateAxisXinZ()
-  }).addStateFromInstance({
-    labels: ['AxisYinX'],
-    name: 'AxisYinX',
-    instance: generateAxisYinX()
-  }).addStateFromInstance({
-    labels: ['AxisYinZ'],
-    name: 'AxisYinZ',
-    instance: generateAxisYinZ()
-  }).addStateFromInstance({
-    labels: ['AxisZinX'],
-    name: 'AxisZinX',
-    instance: generateAxisZinX()
-  }).addStateFromInstance({
-    labels: ['AxisZinY'],
-    name: 'AxisZinY',
-    instance: generateAxisZinY()
-  }).addField({
+  var state = vtkStateBuilder.createBuilder().addField({
     name: 'center',
     initialValue: [0, 0, 0]
   }).addField({
     name: 'opacity',
     initialValue: 1
-  }).addField({
-    name: 'activeLineState',
-    initialValue: null
-  }).addField({
-    name: 'activeRotationPointName',
-    initialValue: ''
   }).addField({
     name: 'image',
     initialValue: null
@@ -194,8 +35,6 @@ function generateState() {
   }).addField({
     name: 'showCenter',
     initialValue: true
-  }).addField({
-    name: 'updateMethodName'
   }).addField({
     name: 'planes',
     initialValue: (_initialValue = {}, _defineProperty(_initialValue, ViewTypes.YZ_PLANE, {
@@ -226,7 +65,47 @@ function generateState() {
   }).addField({
     name: 'viewUpFromViewType',
     initialValue: {}
-  }).build();
+  }).addStateFromMixin({
+    labels: ['handles', 'center'],
+    mixins: ['origin', 'color3', 'scale1', 'visible', 'manipulator'],
+    name: 'centerHandle',
+    initialValues: {
+      scale1: 30,
+      color3: [255, 255, 255]
+    }
+  });
+  planeNames.reduce(function (viewState, view) {
+    return planeNames.filter(function (v) {
+      return v !== view;
+    }).reduce(function (axisState, axis) {
+      // Line handle
+      axisState.addStateFromMixin({
+        labels: ['handles', 'line', "lineIn".concat(view), "".concat(axis, "in").concat(view)],
+        mixins: ['origin', 'color3', 'scale3', // scale3[2] will be automatically overwritten
+        'orientation', 'visible', 'manipulator'],
+        name: "axis".concat(axis, "in").concat(view),
+        initialValues: {
+          scale3: [4, 4, 4],
+          color3: viewsColor3[axis]
+        }
+      }); // Rotation handle
+
+      for (var rotationHandle = 0; rotationHandle < 2; ++rotationHandle) {
+        axisState.addStateFromMixin({
+          labels: ['handles', '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: {
+            scale1: 30,
+            color3: viewsColor3[axis]
+          }
+        });
+      }
+
+      return axisState;
+    }, viewState);
+  }, state);
+  return state.build();
 }
 
 export { generateState as default };

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -4,7 +4,8 @@ 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 vtkResliceCursorContextRepresentation from '../Representations/ResliceCursorContextRepresentation.js';
+import vtkLineHandleRepresentation from '../Representations/LineHandleRepresentation.js';
+import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import { f as distance2BetweenPoints, o as multiplyAccumulate, s as subtract, m as normalize, x as multiplyScalar, l as add } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './ResliceCursorWidget/behavior.js';
 import generateState from './ResliceCursorWidget/state.js';
@@ -23,7 +24,7 @@ var vtkErrorMacro = macro.vtkErrorMacro; // ------------------------------------
 
 function vtkResliceCursorWidget(publicAPI, model) {
   model.classHierarchy.push('vtkResliceCursorWidget');
-  model.methodsToLink = ['scaleInPixels', 'rotationHandlePosition']; // --------------------------------------------------------------------------
+  model.methodsToLink = ['scaleInPixels']; // --------------------------------------------------------------------------
   // Private methods
   // --------------------------------------------------------------------------
 
@@ -135,6 +136,23 @@ function vtkResliceCursorWidget(publicAPI, model) {
     }
 
     renderer.resetCameraClippingRange(bounds);
+  }
+  /**
+   * Convenient function to return the ResliceCursorRepresentation for a given viewType
+   * @param {string} viewType
+   * @returns
+   */
+
+
+  function findRepresentationsForViewType(viewType) {
+    var widgetForViewType = publicAPI.getViewIds().map(function (viewId) {
+      return publicAPI.getWidgetForView({
+        viewId: viewId
+      });
+    }).find(function (widget) {
+      return widget.getViewType() === viewType;
+    });
+    return widgetForViewType.getRepresentations();
   } // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------
@@ -144,37 +162,46 @@ function vtkResliceCursorWidget(publicAPI, model) {
     switch (viewType) {
       case ViewTypes.XY_PLANE:
         return [{
-          builder: vtkResliceCursorContextRepresentation,
-          labels: ['AxisXinZ', 'AxisYinZ'],
+          builder: vtkLineHandleRepresentation,
+          labels: ['lineInZ'],
+          initialValues: {
+            useActiveColor: false
+          }
+        }, {
+          builder: vtkSphereHandleRepresentation,
+          labels: ['rotationInZ', 'center'],
           initialValues: {
-            axis1Name: 'AxisXinZ',
-            axis2Name: 'AxisYinZ',
-            viewType: ViewTypes.XY_PLANE,
-            rotationEnabled: model.widgetState.getEnableRotation()
+            useActiveColor: false
           }
         }];
 
       case ViewTypes.XZ_PLANE:
         return [{
-          builder: vtkResliceCursorContextRepresentation,
-          labels: ['AxisXinY', 'AxisZinY'],
+          builder: vtkLineHandleRepresentation,
+          labels: ['lineInY'],
           initialValues: {
-            axis1Name: 'AxisXinY',
-            axis2Name: 'AxisZinY',
-            viewType: ViewTypes.XZ_PLANE,
-            rotationEnabled: model.widgetState.getEnableRotation()
+            useActiveColor: false
+          }
+        }, {
+          builder: vtkSphereHandleRepresentation,
+          labels: ['rotationInY', 'center'],
+          initialValues: {
+            useActiveColor: false
           }
         }];
 
       case ViewTypes.YZ_PLANE:
         return [{
-          builder: vtkResliceCursorContextRepresentation,
-          labels: ['AxisYinX', 'AxisZinX'],
+          builder: vtkLineHandleRepresentation,
+          labels: ['lineInX'],
+          initialValues: {
+            useActiveColor: false
+          }
+        }, {
+          builder: vtkSphereHandleRepresentation,
+          labels: ['rotationInX', 'center'],
           initialValues: {
-            axis1Name: 'AxisYinX',
-            axis2Name: 'AxisZinX',
-            viewType: ViewTypes.YZ_PLANE,
-            rotationEnabled: model.widgetState.getEnableRotation()
+            useActiveColor: false
           }
         }];
 
@@ -191,12 +218,12 @@ function vtkResliceCursorWidget(publicAPI, model) {
     model.widgetState.setImage(image);
     var center = image.getCenter();
     model.widgetState.setCenter(center);
-    updateState(model.widgetState);
+    updateState(model.widgetState, publicAPI.getDisplayScaleParams(), model.rotationHandlePosition);
   };
 
   publicAPI.setCenter = function (center) {
     model.widgetState.setCenter(center);
-    updateState(model.widgetState);
+    updateState(model.widgetState, publicAPI.getDisplayScaleParams(), model.rotationHandlePosition);
     publicAPI.modified();
   }; // --------------------------------------------------------------------------
   // Methods
@@ -398,13 +425,23 @@ function vtkResliceCursorWidget(publicAPI, model) {
 
     return m;
   };
+
+  publicAPI.getDisplayScaleParams = function () {
+    return [ViewTypes.YZ_PLANE, ViewTypes.XZ_PLANE, ViewTypes.XY_PLANE].reduce(function (res, viewType) {
+      var _findRepresentationsF, _findRepresentationsF2;
+
+      res[viewType] = (_findRepresentationsF = (_findRepresentationsF2 = findRepresentationsForViewType(viewType)[0]).getDisplayScaleParams) === null || _findRepresentationsF === void 0 ? void 0 : _findRepresentationsF.call(_findRepresentationsF2);
+      return res;
+    }, {});
+  };
 } // ----------------------------------------------------------------------------
 
 
 var defaultValues = function defaultValues(initialValues) {
   return _objectSpread({
     behavior: widgetBehavior,
-    widgetState: generateState()
+    widgetState: generateState(),
+    rotationHandlePosition: 0.25
   }, initialValues);
 }; // ----------------------------------------------------------------------------
 
@@ -413,6 +450,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, ['rotationHandlePosition']);
   vtkResliceCursorWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/index.d.ts

@@ -174,7 +174,6 @@
 /// <reference path="./Widgets/Manipulators/LineManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/PlaneManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/TrackballManipulator.d.ts" />
-/// <reference path="./Widgets/Representations/ResliceCursorContextRepresentation.d.ts" />
 /// <reference path="./Widgets/Representations/WidgetRepresentation.d.ts" />
 /// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/SphereWidget.d.ts" />

package/macros.d.ts

@@ -172,19 +172,17 @@ export function get(publicAPI: object, model: object, fieldNames: Array<string>)
  * @param publicAPI object on which public methods get attached to
  * @param model object on which protected fields are stored
  * @param fieldNames list of fields available in model that we want to expose as set{FieldName} methods on the publicAPI
- * * Can be a string (the name of the field to expose) or an object (e.g. {type:enum, name: {FieldName}, enum: FieldEnum}).
  */
-export function set(publicAPI: object, model: object, fields: Array<string|object>): void;
+export function set(publicAPI: object, model: object, fields: Array<string>): void;
 
 /**
  * Add setter+getter methods to the provided publicAPI
  *
  * @param publicAPI object on which public methods get attached to
  * @param model object on which protected fields are stored
- * @param fieldNames list of fields available in model that we want to expose as set{FieldName}+get{FieldName} methods on the publicAPI.
- * Can be a string (the name of the field to expose) or an object (e.g. {type:enum, name: {FieldName}, enum: FieldEnum}).
+ * @param fieldNames list of fields available in model that we want to expose as set{FieldName}+get{FieldName} methods on the publicAPI
  */
-export function setGet(publicAPI: object, model: object, fields: Array<string|object>): void;
+export function setGet(publicAPI: object, model: object, fields: Array<string>): void;
 
 /**
  * Add getter methods to the provided publicAPI for arrays.