@kitware/vtk.js 23.4.1 → 24.0.0-beta.2

package/Interaction/Widgets/ResliceCursor/ResliceCursorActor.js

@@ -1,146 +0,0 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../../macros.js';
-import vtkActor from '../../../Rendering/Core/Actor.js';
-import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
-import vtkMapper from '../../../Rendering/Core/Mapper.js';
-import { u as uninitializeBounds } from '../../../Common/Core/Math/index.js';
-import vtkProp3D from '../../../Rendering/Core/Prop3D.js';
-import vtkProperty from '../../../Rendering/Core/Property.js';
-import vtkResliceCursorPolyDataAlgorithm from './ResliceCursorPolyDataAlgorithm.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; }
-// vtkResliceCursorActor methods
-// ----------------------------------------------------------------------------
-
-function vtkResliceCursorActor(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkResliceCursorActor');
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.getActors = function () {
-    if (model.cursorAlgorithm.getResliceCursor()) {
-      publicAPI.updateViewProps();
-    }
-
-    return _toConsumableArray(model.cursorCenterlineActor);
-  };
-
-  publicAPI.getNestedProps = function () {
-    return publicAPI.getActors();
-  };
-
-  publicAPI.updateViewProps = function () {
-    if (!model.cursorAlgorithm.getResliceCursor()) {
-      return;
-    }
-
-    model.cursorAlgorithm.update();
-    var axisNormal = model.cursorAlgorithm.getReslicePlaneNormal();
-    var axis1 = model.cursorAlgorithm.getPlaneAxis1();
-    var axis2 = model.cursorAlgorithm.getPlaneAxis2();
-    model.cursorCenterlineMapper[axis1].setInputData(model.cursorAlgorithm.getOutputData(0));
-    model.cursorCenterlineMapper[axis2].setInputData(model.cursorAlgorithm.getOutputData(1));
-    model.cursorCenterlineActor[axis1].setVisibility(model.visibility);
-    model.cursorCenterlineActor[axis2].setVisibility(model.visibility);
-    model.cursorCenterlineActor[axisNormal].setVisibility(0);
-  };
-
-  publicAPI.getBounds = function () {
-    uninitializeBounds(model.bounds);
-    publicAPI.updateViewProps();
-
-    var boundingBox = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS);
-
-    var bounds = [];
-
-    for (var i = 0; i < 3; i++) {
-      if (model.cursorCenterlineActor[i].getVisibility() && model.cursorCenterlineActor[i].getUseBounds()) {
-        bounds = model.cursorCenterlineActor[i].getBounds();
-        vtkBoundingBox.addBounds(boundingBox, bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]);
-      }
-    }
-
-    model.bounds = boundingBox;
-    return model.bounds;
-  };
-
-  publicAPI.getMTime = function () {
-    var mTime = superClass.getMTime();
-
-    if (model.cursorAlgorithm) {
-      var time = model.cursorAlgorithm.getMTime();
-
-      if (time > mTime) {
-        mTime = time;
-      }
-    }
-
-    return mTime;
-  };
-
-  publicAPI.getCenterlineProperty = function (i) {
-    return model.centerlineProperty[i];
-  };
-
-  publicAPI.getCenterlineActor = function (i) {
-    return model.cursorCenterlineActor[i];
-  };
-
-  publicAPI.setUserMatrix = function (matrix) {
-    model.cursorCenterlineActor[0].setUserMatrix(matrix);
-    model.cursorCenterlineActor[1].setUserMatrix(matrix);
-    model.cursorCenterlineActor[2].setUserMatrix(matrix);
-    superClass.setUserMatrix(matrix);
-  }; //----------------------------------------------------------------------------
-  // Public API methods
-  //----------------------------------------------------------------------------
-
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-  vtkProp3D.extend(publicAPI, model, initialValues);
-  model.cursorAlgorithm = vtkResliceCursorPolyDataAlgorithm.newInstance();
-  model.cursorCenterlineMapper = [];
-  model.cursorCenterlineActor = [];
-  model.centerlineProperty = [];
-
-  for (var i = 0; i < 3; i++) {
-    model.cursorCenterlineMapper[i] = vtkMapper.newInstance();
-    model.cursorCenterlineMapper[i].setScalarVisibility(false);
-    model.cursorCenterlineMapper[i].setResolveCoincidentTopologyToPolygonOffset();
-    model.cursorCenterlineMapper[i].setResolveCoincidentTopologyLineOffsetParameters(-1.0, -1.0);
-    model.cursorCenterlineActor[i] = vtkActor.newInstance({
-      parentProp: publicAPI
-    });
-    model.cursorCenterlineActor[i].setMapper(model.cursorCenterlineMapper[i]);
-    model.centerlineProperty[i] = vtkProperty.newInstance();
-    model.cursorCenterlineActor[i].setProperty(model.centerlineProperty[i]);
-  }
-
-  model.centerlineProperty[0].setColor(1, 0, 0);
-  model.centerlineProperty[1].setColor(0, 1, 0);
-  model.centerlineProperty[2].setColor(0, 0, 1);
-  macro.get(publicAPI, model, ['cursorAlgorithm']); // Object methods
-
-  vtkResliceCursorActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkResliceCursorActor'); // ----------------------------------------------------------------------------
-
-var vtkResliceCursorActor$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkResliceCursorActor$1 as default, extend, newInstance };

package/Interaction/Widgets/ResliceCursor/ResliceCursorLineRepresentation.js

@@ -1,332 +0,0 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../../macros.js';
-import vtkInteractorObserver from '../../../Rendering/Core/InteractorObserver.js';
-import vtkLine from '../../../Common/DataModel/Line.js';
-import { f as distance2BetweenPoints, l as normalize, d as dot, j as cross, u as uninitializeBounds } from '../../../Common/Core/Math/index.js';
-import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
-import vtkPlane from '../../../Common/DataModel/Plane.js';
-import vtkResliceCursorActor from './ResliceCursorActor.js';
-import vtkResliceCursorRepresentation from './ResliceCursorRepresentation.js';
-import { InteractionState } from './ResliceCursorRepresentation/Constants.js';
-
-// ResliceCursorLineRepresentation methods
-// ----------------------------------------------------------------------------
-
-function isAxisPicked(renderer, tolerance, axisPolyData, pickedPosition) {
-  var points = axisPolyData.getPoints();
-  var worldP1 = [];
-  points.getPoint(0, worldP1);
-  var displayP1 = vtkInteractorObserver.computeWorldToDisplay(renderer, worldP1[0], worldP1[1], worldP1[2]);
-  var worldP2 = [];
-  points.getPoint(points.getNumberOfPoints() - 1, worldP2);
-  var displayP2 = vtkInteractorObserver.computeWorldToDisplay(renderer, worldP2[0], worldP2[1], worldP2[2]);
-  var xyz = [pickedPosition[0], pickedPosition[1], 0];
-  var p1 = [displayP1[0], displayP1[1], 0];
-  var p2 = [displayP2[0], displayP2[1], 0];
-  var output = vtkLine.distanceToLine(xyz, p1, p2);
-  return output.distance <= tolerance * tolerance && output.t < 1.0 && output.t > 0.0;
-}
-
-function displayToWorld(displayPosition, renderer) {
-  var activeCamera = renderer.getActiveCamera();
-  var focalPoint = activeCamera.getFocalPoint();
-  var displayFocalPoint = vtkInteractorObserver.computeWorldToDisplay(renderer, focalPoint[0], focalPoint[1], focalPoint[2]);
-  var worldEventPosition = vtkInteractorObserver.computeDisplayToWorld(renderer, displayPosition[0], displayPosition[1], displayFocalPoint[2]);
-  return worldEventPosition;
-}
-
-function vtkResliceCursorLineRepresentation(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkResliceCursorLineRepresentation'); //----------------------------------------------------------------------------
-  // Public API methods
-  //----------------------------------------------------------------------------
-
-  publicAPI.getResliceCursor = function () {
-    return model.resliceCursorActor.getCursorAlgorithm().getResliceCursor();
-  };
-
-  publicAPI.getCursorAlgorithm = function () {
-    return model.resliceCursorActor.getCursorAlgorithm();
-  };
-
-  publicAPI.displayToReslicePlaneIntersection = function (displayPosition) {
-    var activeCamera = model.renderer.getActiveCamera();
-    var cameraPosition = activeCamera.getPosition();
-    var resliceCursor = publicAPI.getResliceCursor();
-    var worldEventPosition = displayToWorld(displayPosition, model.renderer);
-
-    if (!resliceCursor) {
-      return null;
-    }
-
-    var axisNormal = model.resliceCursorActor.getCursorAlgorithm().getReslicePlaneNormal();
-    var plane = resliceCursor.getPlane(axisNormal);
-    var intersection = vtkPlane.intersectWithLine(worldEventPosition, cameraPosition, plane.getOrigin(), plane.getNormal());
-    return intersection.x;
-  };
-
-  publicAPI.computeInteractionState = function (displayPos) {
-    model.interactionState = InteractionState.OUTSIDE;
-
-    if (!model.renderer || !model.resliceCursorActor.getVisibility()) {
-      return model.interactionState;
-    }
-
-    var resliceCursor = publicAPI.getResliceCursor();
-
-    if (!resliceCursor) {
-      return model.interactionState;
-    }
-
-    var axis1 = model.resliceCursorActor.getCursorAlgorithm().getAxis1();
-    var bounds = model.resliceCursorActor.getCenterlineActor(axis1).getBounds();
-
-    if (bounds[1] < bounds[0]) {
-      return model.interactionState;
-    } // Picking Axis1 interaction:
-
-
-    var axis1PolyData = resliceCursor.getCenterlineAxisPolyData(axis1);
-    var isAxis1Picked = isAxisPicked(model.renderer, model.tolerance, axis1PolyData, displayPos); // Picking Axis2 interaction:
-
-    var axis2 = model.resliceCursorActor.getCursorAlgorithm().getAxis2();
-    var axis2PolyData = resliceCursor.getCenterlineAxisPolyData(axis2);
-    var isAxis2Picked = isAxisPicked(model.renderer, model.tolerance, axis2PolyData, displayPos); // Picking center interaction:
-
-    var isCenterPicked = isAxis1Picked && isAxis2Picked;
-
-    if (isCenterPicked) {
-      var displayCenterPosition = vtkInteractorObserver.computeWorldToDisplay(model.renderer, resliceCursor.getCenter()[0], resliceCursor.getCenter()[1], resliceCursor.getCenter()[2]);
-      var distance = distance2BetweenPoints([displayCenterPosition[0], displayCenterPosition[1], 0], [displayPos[0], displayPos[1], 0]);
-
-      if (distance <= model.tolerance * model.tolerance) {
-        model.interactionState = InteractionState.ON_CENTER;
-      } else {
-        model.interactionState = InteractionState.ON_AXIS1;
-      }
-    } else if (isAxis1Picked) {
-      model.interactionState = InteractionState.ON_AXIS1;
-    } else if (isAxis2Picked) {
-      model.interactionState = InteractionState.ON_AXIS2;
-    }
-
-    model.startPickPosition = publicAPI.displayToReslicePlaneIntersection(displayPos);
-
-    if (model.startPickPosition === null) {
-      model.startPickPosition = [0, 0, 0];
-    }
-
-    return model.interactionState;
-  };
-
-  publicAPI.startComplexWidgetInteraction = function (startEventPos) {
-    model.startEventPosition[0] = startEventPos[0];
-    model.startEventPosition[1] = startEventPos[1];
-    model.startEventPosition[2] = 0.0;
-    var resliceCursor = publicAPI.getResliceCursor();
-
-    if (resliceCursor) {
-      model.startCenterPosition = resliceCursor.getCenter();
-    }
-
-    model.lastEventPosition[0] = startEventPos[0];
-    model.lastEventPosition[1] = startEventPos[1];
-    model.lastEventPosition[2] = 0.0;
-  };
-
-  publicAPI.complexWidgetInteraction = function (displayPosition) {
-    var resliceCursor = publicAPI.getResliceCursor();
-
-    if (model.interactionState === InteractionState.OUTSIDE || !model.renderer || !resliceCursor) {
-      model.lastEventPosition[0] = displayPosition[0];
-      model.lastEventPosition[1] = displayPosition[1];
-      return;
-    } // Depending on the state, perform different operations
-
-
-    if (model.interactionState === InteractionState.ON_CENTER) {
-      var intersectionPos = publicAPI.displayToReslicePlaneIntersection(displayPosition);
-
-      if (intersectionPos !== null) {
-        var newCenter = [];
-
-        for (var i = 0; i < 3; i++) {
-          newCenter[i] = model.startCenterPosition[i] + intersectionPos[i] - model.startPickPosition[i];
-        }
-
-        resliceCursor.setCenter(newCenter);
-      }
-    }
-
-    if (model.interactionState === InteractionState.ON_AXIS1) {
-      publicAPI.rotateAxis(displayPosition, model.resliceCursorActor.getCursorAlgorithm().getPlaneAxis1());
-    }
-
-    if (model.interactionState === InteractionState.ON_AXIS2) {
-      publicAPI.rotateAxis(displayPosition, model.resliceCursorActor.getCursorAlgorithm().getPlaneAxis2());
-    }
-
-    model.lastEventPosition = [].concat(_toConsumableArray(displayPosition), [0]);
-  };
-
-  publicAPI.rotateAxis = function (displayPos, axis) {
-    var resliceCursor = publicAPI.getResliceCursor();
-
-    if (!resliceCursor) {
-      return 0;
-    }
-
-    var center = resliceCursor.getCenter(); // Intersect with the viewing vector. We will use this point and the
-    // start event point to compute the rotation angle
-
-    var currentIntersectionPos = publicAPI.displayToReslicePlaneIntersection(displayPos);
-    var lastIntersectionPos = publicAPI.displayToReslicePlaneIntersection(model.lastEventPosition);
-
-    if (lastIntersectionPos[0] === currentIntersectionPos[0] && lastIntersectionPos[1] === currentIntersectionPos[1] && lastIntersectionPos[2] === currentIntersectionPos[2]) {
-      return 0;
-    }
-
-    var lastVector = [];
-    var currVector = [];
-
-    for (var i = 0; i < 3; i++) {
-      lastVector[i] = lastIntersectionPos[i] - center[i];
-      currVector[i] = currentIntersectionPos[i] - center[i];
-    }
-
-    normalize(lastVector);
-    normalize(currVector); // Compute the angle between both vectors. This is the amount to
-    // rotate by.
-
-    var angle = Math.acos(dot(lastVector, currVector));
-    var crossVector = [];
-    cross(lastVector, currVector, crossVector);
-    var resliceCursorPlaneId = model.resliceCursorActor.getCursorAlgorithm().getReslicePlaneNormal();
-    var normalPlane = resliceCursor.getPlane(resliceCursorPlaneId);
-    var aboutAxis = normalPlane.getNormal();
-    var align = dot(aboutAxis, crossVector);
-    var sign = align > 0 ? 1.0 : -1.0;
-    angle *= sign;
-
-    if (angle === 0) {
-      return 0;
-    }
-
-    publicAPI.applyRotation(axis, angle);
-    return angle;
-  };
-
-  publicAPI.applyRotation = function (axis, angle) {
-    var resliceCursor = publicAPI.getResliceCursor();
-    var resliceCursorPlaneId = model.resliceCursorActor.getCursorAlgorithm().getReslicePlaneNormal();
-    var planeToBeRotated = resliceCursor.getPlane(axis);
-    var viewUp = resliceCursor.getViewUp(axis);
-    var vectorToBeRotated = planeToBeRotated.getNormal();
-    var normalPlane = resliceCursor.getPlane(resliceCursorPlaneId);
-    var aboutAxis = normalPlane.getNormal();
-
-    var rotatedVector = _toConsumableArray(vectorToBeRotated);
-
-    vtkMatrixBuilder.buildFromRadian().rotate(angle, aboutAxis).apply(rotatedVector);
-    vtkMatrixBuilder.buildFromRadian().rotate(angle, aboutAxis).apply(viewUp);
-    planeToBeRotated.setNormal(rotatedVector);
-  };
-
-  publicAPI.getBounds = function () {
-    var bounds = [];
-    uninitializeBounds(bounds);
-    var resliceCursor = publicAPI.getResliceCursor();
-
-    if (resliceCursor) {
-      if (resliceCursor.getImage()) {
-        bounds = resliceCursor.getImage().getBounds();
-      }
-    }
-
-    return bounds;
-  };
-
-  publicAPI.getActors = function () {
-    // Update representation
-    publicAPI.buildRepresentation(); // Update CameraPosition
-
-    publicAPI.updateCamera();
-    return [model.imageActor].concat(_toConsumableArray(model.resliceCursorActor.getActors()));
-  };
-
-  publicAPI.updateCamera = function () {
-    var normalAxis = model.resliceCursorActor.getCursorAlgorithm().getReslicePlaneNormal(); // When the reslice plane is changed, update the camera to look at the
-    // normal to the reslice plane always.
-
-    var focalPoint = model.renderer.getActiveCamera().getFocalPoint();
-    var position = model.renderer.getActiveCamera().getPosition();
-    var normalPlane = publicAPI.getResliceCursor().getPlane(normalAxis);
-    var normal = normalPlane.getNormal();
-    var distance = Math.sqrt(distance2BetweenPoints(position, focalPoint));
-    var estimatedCameraPosition = [focalPoint[0] + distance * normal[0], focalPoint[1] + distance * normal[1], focalPoint[2] + distance * normal[2]]; // intersect with the plane to get updated focal point
-
-    var intersection = vtkPlane.intersectWithLine(focalPoint, estimatedCameraPosition, normalPlane.getOrigin(), normalPlane.getNormal());
-    var newFocalPoint = intersection.x;
-    model.renderer.getActiveCamera().setFocalPoint(newFocalPoint[0], newFocalPoint[1], newFocalPoint[2]);
-    var newCameraPosition = [newFocalPoint[0] + distance * normal[0], newFocalPoint[1] + distance * normal[1], newFocalPoint[2] + distance * normal[2]];
-    model.renderer.getActiveCamera().setPosition(newCameraPosition[0], newCameraPosition[1], newCameraPosition[2]); // Renderer may not have yet actor bounds
-
-    var rendererBounds = model.renderer.computeVisiblePropBounds();
-    var bounds = publicAPI.getBounds();
-    rendererBounds[0] = Math.min(bounds[0], rendererBounds[0]);
-    rendererBounds[1] = Math.max(bounds[1], rendererBounds[1]);
-    rendererBounds[2] = Math.min(bounds[2], rendererBounds[2]);
-    rendererBounds[3] = Math.max(bounds[3], rendererBounds[3]);
-    rendererBounds[4] = Math.min(bounds[4], rendererBounds[4]);
-    rendererBounds[5] = Math.max(bounds[5], rendererBounds[5]); // Don't clip away any part of the data.
-
-    model.renderer.resetCameraClippingRange(rendererBounds);
-  };
-  /**
-   * Reimplemented to look at image center instead of reslice cursor.
-   */
-
-
-  publicAPI.resetCamera = function () {
-    if (model.renderer) {
-      var normalAxis = publicAPI.getCursorAlgorithm().getReslicePlaneNormal();
-      var normal = publicAPI.getResliceCursor().getPlane(normalAxis).getNormal();
-      var viewUp = publicAPI.getResliceCursor().getViewUp(normalAxis);
-      var focalPoint = model.renderer.getActiveCamera().getFocalPoint();
-      var position = model.renderer.getActiveCamera().getPosition(); // Distance is preserved
-
-      var distance = Math.sqrt(distance2BetweenPoints(position, focalPoint));
-      var newCameraPosition = [focalPoint[0] + distance * normal[0], focalPoint[1] + distance * normal[1], focalPoint[2] + distance * normal[2]];
-      model.renderer.getActiveCamera().setPosition(newCameraPosition[0], newCameraPosition[1], newCameraPosition[2]);
-      model.renderer.getActiveCamera().setViewUp(viewUp[0], viewUp[1], viewUp[2]);
-    }
-  };
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-  vtkResliceCursorRepresentation.extend(publicAPI, model, DEFAULT_VALUES, initialValues);
-  model.resliceCursorActor = vtkResliceCursorActor.newInstance({
-    parentProp: publicAPI
-  });
-  model.startPickPosition = null;
-  model.startCenterPosition = null;
-  macro.get(publicAPI, model, ['resliceCursorActor']); // Object methods
-
-  vtkResliceCursorLineRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkResliceCursorLineRepresentation'); // ----------------------------------------------------------------------------
-
-var vtkResliceCursorLineRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkResliceCursorLineRepresentation$1 as default, extend, newInstance };

package/Interaction/Widgets/ResliceCursor/ResliceCursorPolyDataAlgorithm.js

@@ -1,134 +0,0 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../../macros.js';
-import { PlaneNormal } from './ResliceCursorActor/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; }
-// vtkResliceCursorPolyDataAlgorithm methods
-// ----------------------------------------------------------------------------
-
-function vtkResliceCursorPolyDataAlgorithm(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkResliceCursorPolyDataAlgorithm');
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.setReslicePlaneNormalToXAxis = function () {
-    publicAPI.setReslicePlaneNormal(PlaneNormal.XAxis);
-  };
-
-  publicAPI.setReslicePlaneNormalToYAxis = function () {
-    publicAPI.setReslicePlaneNormal(PlaneNormal.YAxis);
-  };
-
-  publicAPI.setReslicePlaneNormalToZAxis = function () {
-    publicAPI.setReslicePlaneNormal(PlaneNormal.ZAxis);
-  };
-
-  publicAPI.getCenterlineAxis1 = function () {
-    return publicAPI.getOutputData(0);
-  };
-
-  publicAPI.getCenterlineAxis2 = function () {
-    return publicAPI.getOutputData(1);
-  };
-
-  publicAPI.getAxis1 = function () {
-    if (model.reslicePlaneNormal === PlaneNormal.ZAxis) {
-      return 1;
-    }
-
-    return 2;
-  };
-
-  publicAPI.getAxis2 = function () {
-    if (model.reslicePlaneNormal === PlaneNormal.XAxis) {
-      return 1;
-    }
-
-    return 0;
-  };
-
-  publicAPI.getPlaneAxis1 = function () {
-    if (model.reslicePlaneNormal === PlaneNormal.XAxis) {
-      return 1;
-    }
-
-    return 0;
-  };
-
-  publicAPI.getPlaneAxis2 = function () {
-    if (model.reslicePlaneNormal === PlaneNormal.ZAxis) {
-      return 1;
-    }
-
-    return 2;
-  };
-
-  publicAPI.getOtherPlaneForAxis = function (p) {
-    for (var i = 0; i < 3; i++) {
-      if (i !== p && i !== model.reslicePlaneNormal) {
-        return i;
-      }
-    }
-
-    return -1;
-  };
-
-  publicAPI.getMTime = function () {
-    var mTime = superClass.getMTime();
-
-    if (model.resliceCursor) {
-      var time = model.resliceCursor.getMTime();
-
-      if (time > mTime) {
-        mTime = time;
-      }
-    }
-
-    return mTime;
-  };
-
-  publicAPI.requestData = function (inData, outData) {
-    if (!model.resliceCursor) {
-      return;
-    } // Cut the reslice cursor with the plane on which we are viewing.
-
-
-    var axis1 = publicAPI.getAxis1();
-    outData[0] = model.resliceCursor.getCenterlineAxisPolyData(axis1);
-    var axis2 = publicAPI.getAxis2();
-    outData[1] = model.resliceCursor.getCenterlineAxisPolyData(axis2);
-  }; //----------------------------------------------------------------------------
-  // Public API methods
-  //----------------------------------------------------------------------------
-
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
-  reslicePlaneNormal: PlaneNormal.XAxis
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-  model.resliceCursor = null;
-  macro.obj(publicAPI, model);
-  macro.algo(publicAPI, model, 0, 2);
-  macro.setGet(publicAPI, model, ['reslicePlaneNormal', 'resliceCursor']); // Object methods
-
-  vtkResliceCursorPolyDataAlgorithm(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkResliceCursorPolyDataAlgorithm'); // ----------------------------------------------------------------------------
-
-var vtkResliceCursorPolyDataAlgorithm$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkResliceCursorPolyDataAlgorithm$1 as default, extend, newInstance };

package/Interaction/Widgets/ResliceCursor/ResliceCursorRepresentation/Constants.js

@@ -1,16 +0,0 @@
-var InteractionState = {
-  OUTSIDE: 0,
-  NEAR_CENTER: 1,
-  NEAR_AXIS1: 2,
-  NEAR_AXIS2: 3,
-  ON_CENTER: 4,
-  ON_AXIS1: 5,
-  ON_AXIS2: 6
-};
-var ManipulationMode = {
-  NONE: 0,
-  PAN_AND_ROTATE: 1,
-  ROTATE_BOTH_AXES: 2
-};
-
-export { InteractionState, ManipulationMode };