@kitware/vtk.js 23.4.0 → 24.0.0-beta.1

package/Interaction/Widgets/LineWidget.js

@@ -1,296 +0,0 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import HandleRepConstants from './HandleRepresentation/Constants.js';
-import macro from '../../macros.js';
-import vtkAbstractWidget from './AbstractWidget.js';
-import vtkHandleWidget from './HandleWidget.js';
-import vtkLineRepresentation from './LineRepresentation.js';
-import { State } from './LineRepresentation/Constants.js';
-import Constants from './LineWidget/Constants.js';
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var WidgetState = Constants.WidgetState;
-var InteractionState = HandleRepConstants.InteractionState; // ----------------------------------------------------------------------------
-// vtkHandleWidget methods
-// ----------------------------------------------------------------------------
-
-function vtkLineWidget(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkLineWidget');
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.setCursor = function (state) {
-    switch (state) {
-      case State.OUTSIDE:
-        {
-          model.interactor.getView().setCursor('default');
-          break;
-        }
-
-      default:
-        {
-          model.interactor.getView().setCursor('pointer');
-        }
-    }
-  };
-
-  publicAPI.setCurrentHandle = function (value) {
-    model.currentHandle = value;
-  };
-
-  publicAPI.setInteractor = function (i) {
-    superClass.setInteractor(i);
-    model.point1Widget.setInteractor(model.interactor);
-    model.point2Widget.setInteractor(model.interactor);
-    publicAPI.modified();
-  };
-
-  publicAPI.setEnabled = function (enabling) {
-    superClass.setEnabled(enabling);
-
-    if (!model.widgetRep) {
-      return;
-    } // Use the representations from the line widget
-    // for the point widgets to avoid creating
-    // default representations when setting the
-    // interactor below
-
-
-    model.point1Widget.setWidgetRep(model.widgetRep.getPoint1Representation());
-    model.point2Widget.setWidgetRep(model.widgetRep.getPoint2Representation());
-
-    if (model.widgetState === WidgetState.START) {
-      model.point1Widget.setEnabled(0);
-      model.point2Widget.setEnabled(0);
-      model.widgetRep.setLineVisibility(0);
-      model.widgetRep.setPoint1Visibility(1);
-      model.widgetRep.setPoint2Visibility(0);
-    } else {
-      model.point1Widget.setEnabled(enabling);
-      model.point2Widget.setEnabled(enabling);
-      model.widgetRep.setLineVisibility(1);
-      model.widgetRep.setPoint1Visibility(1);
-      model.widgetRep.setPoint2Visibility(1);
-    }
-  };
-
-  publicAPI.setProcessEvents = function (processEvents) {
-    superClass.setProcessEvents(processEvents);
-    model.point1Widget.setProcessEvents(processEvents);
-    model.point2Widget.setProcessEvents(processEvents);
-  };
-
-  publicAPI.setWidgetStateToStart = function () {
-    model.widgetState = WidgetState.START;
-    publicAPI.setCurrentHandle(0);
-    publicAPI.setEnabled(model.enabled);
-  };
-
-  publicAPI.setWidgetStateToManipulate = function () {
-    model.widgetState = WidgetState.MANIPULATE;
-    publicAPI.setCurrentHandle(-1);
-    publicAPI.setEnabled(model.enabled);
-  };
-
-  publicAPI.handleMouseMove = function (callData) {
-    return publicAPI.moveAction(callData);
-  };
-
-  publicAPI.handleLeftButtonPress = function (callData) {
-    return publicAPI.selectAction(callData);
-  };
-
-  publicAPI.handleLeftButtonRelease = function (callData) {
-    return publicAPI.endSelectAction(callData);
-  };
-
-  publicAPI.handleMiddleButtonPress = function (callData) {
-    return publicAPI.translateAction(callData);
-  };
-
-  publicAPI.handleMiddleButtonRelease = function (callData) {
-    return publicAPI.endSelectAction(callData);
-  };
-
-  publicAPI.handleRightButtonPress = function (callData) {
-    return publicAPI.scaleAction(callData);
-  };
-
-  publicAPI.handleRightButtonRelease = function (callData) {
-    return publicAPI.endSelectAction(callData);
-  };
-
-  publicAPI.selectAction = function (callData) {
-    var position = [callData.position.x, callData.position.y];
-
-    if (model.widgetState === WidgetState.START) {
-      var pos3D = model.point1Widget.getWidgetRep().displayToWorld(position, 0); // The first time we click, the method is called twice
-
-      if (model.currentHandle < 1) {
-        model.widgetRep.setLineVisibility(1);
-        model.widgetRep.setPoint1WorldPosition(pos3D); // Trick to avoid a line with a zero length
-        // If the line has a zero length, it appears with bad extremities
-
-        pos3D[0] += 0.000000001;
-        model.widgetRep.setPoint2WorldPosition(pos3D);
-        publicAPI.setCurrentHandle(model.currentHandle + 1);
-      } else {
-        model.widgetRep.setPoint2Visibility(1);
-        model.widgetRep.setPoint2WorldPosition(pos3D); // When two points are placed, we go back to the native
-
-        model.widgetState = WidgetState.MANIPULATE;
-        publicAPI.setCurrentHandle(-1);
-      }
-    } else {
-      var state = model.widgetRep.computeInteractionState(position);
-
-      if (state === InteractionState.OUTSIDE) {
-        return;
-      }
-
-      model.widgetState = WidgetState.ACTIVE;
-      publicAPI.updateHandleWidgets(state);
-      publicAPI.invokeStartInteractionEvent();
-    }
-
-    model.widgetRep.startComplexWidgetInteraction(position);
-    publicAPI.render();
-  };
-
-  publicAPI.translateAction = function (callData) {
-    var position = [callData.position.x, callData.position.y];
-    var state = model.widgetRep.computeInteractionState(position);
-
-    if (state === InteractionState.OUTSIDE) {
-      return;
-    }
-
-    model.widgetState = WidgetState.ACTIVE;
-    model.widgetRep.startComplexWidgetInteraction(position);
-    publicAPI.invokeStartInteractionEvent();
-  };
-
-  publicAPI.scaleAction = function (callData) {
-    var position = [callData.position.x, callData.position.y];
-    var state = model.widgetRep.computeInteractionState(position);
-
-    if (state === InteractionState.OUTSIDE) {
-      return;
-    }
-
-    model.widgetState = WidgetState.ACTIVE;
-    model.widgetRep.startComplexWidgetInteraction(position);
-    publicAPI.invokeStartInteractionEvent();
-  };
-
-  publicAPI.moveAction = function (callData) {
-    var position = [callData.position.x, callData.position.y];
-    var modified = false;
-
-    if (model.widgetState === WidgetState.MANIPULATE) {
-      // In MANIPULATE, we are hovering above the widget
-      // Check if above a sphere and enable/disable if needed
-      var state = model.widgetRep.computeInteractionState(position);
-      modified = publicAPI.updateHandleWidgets(state);
-    } else if (model.widgetState === WidgetState.START) {
-      // In START, we are placing the sphere widgets.
-      // Move current handle along the mouse position.
-      model.widgetRep.complexWidgetInteraction(position);
-      var pos3D = model.point1Widget.getWidgetRep().displayToWorld(position, 0);
-
-      if (model.currentHandle === 0) {
-        model.widgetRep.setPoint1WorldPosition(pos3D);
-      } else {
-        model.widgetRep.setPoint2WorldPosition(pos3D);
-      }
-
-      modified = true;
-    } else if (model.widgetState === WidgetState.ACTIVE) {
-      // In ACTIVE, we are moving a sphere widget.
-      // Update the line extremities to follow the spheres.
-      model.widgetRep.setPoint1WorldPosition(model.point1Widget.getWidgetRep().getWorldPosition());
-      model.widgetRep.setPoint2WorldPosition(model.point2Widget.getWidgetRep().getWorldPosition());
-      modified = true;
-    }
-
-    if (modified) {
-      publicAPI.invokeInteractionEvent();
-      publicAPI.render();
-    }
-  };
-
-  publicAPI.endSelectAction = function (callData) {
-    if (model.widgetState === WidgetState.START) {
-      return;
-    }
-
-    var position = [callData.position.x, callData.position.y];
-    model.widgetRep.complexWidgetInteraction(position);
-    model.widgetRep.setPoint1WorldPosition(model.point1Widget.getWidgetRep().getWorldPosition());
-    model.widgetRep.setPoint2WorldPosition(model.point2Widget.getWidgetRep().getWorldPosition());
-    model.widgetState = WidgetState.MANIPULATE;
-    publicAPI.invokeEndInteractionEvent();
-    publicAPI.render();
-  };
-
-  publicAPI.createDefaultRepresentation = function () {
-    if (!model.widgetRep) {
-      model.widgetRep = vtkLineRepresentation.newInstance();
-    }
-  };
-
-  publicAPI.updateHandleWidgets = function (state) {
-    var modified = false;
-    publicAPI.setCursor(state);
-    var enablePoint1Widget = state === State.ONP1;
-    var enablePoint2Widget = state === State.ONP2;
-
-    if (enablePoint1Widget !== model.point1Widget.getEnabled()) {
-      model.point1Widget.setEnabled(enablePoint1Widget);
-      modified = true;
-    }
-
-    if (enablePoint2Widget !== model.point2Widget.getEnabled()) {
-      model.point2Widget.setEnabled(enablePoint2Widget);
-      modified = true;
-    }
-
-    return modified;
-  };
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
-  widgetState: WidgetState.START,
-  currentHandle: 0,
-  point1Widget: null,
-  point2Widget: null
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
-
-  vtkAbstractWidget.extend(publicAPI, model, initialValues);
-  model.point1Widget = vtkHandleWidget.newInstance();
-  model.point1Widget.setParent(publicAPI);
-  model.point1Widget.createDefaultRepresentation();
-  model.point2Widget = vtkHandleWidget.newInstance();
-  model.point2Widget.setParent(publicAPI);
-  model.point2Widget.createDefaultRepresentation(); // Object methods
-
-  vtkLineWidget(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkLineWidget'); // ----------------------------------------------------------------------------
-
-var vtkLineWidget$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkLineWidget$1 as default, extend, newInstance };

package/Interaction/Widgets/PointPlacer.js

@@ -1,51 +0,0 @@
-import macro from '../../macros.js';
-import vtkCoordinate from '../../Rendering/Core/Coordinate.js';
-
-// vtkPointPlacer methods
-// ----------------------------------------------------------------------------
-
-function vtkPointPlacer(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkPointPlacer');
-
-  publicAPI.computeWorldPosition = function (renderer, displayPos, worldPos) {
-    if (renderer) {
-      var dPos = vtkCoordinate.newInstance();
-      dPos.setCoordinateSystemToDisplay();
-      dPos.setValue(displayPos[0], displayPos[1]);
-      worldPos[0] = dPos.getComputedWorldValue(renderer)[0];
-      worldPos[1] = dPos.getComputedWorldValue(renderer)[1];
-      worldPos[2] = dPos.getComputedWorldValue(renderer)[2];
-      return 1;
-    }
-
-    return 0;
-  };
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
-  pixelTolerance: 5,
-  worldTolerance: 0.001
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
-
-  macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['pixelTolerance', 'worldTolerance']); // Object methods
-
-  vtkPointPlacer(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkPointPlacer'); // ----------------------------------------------------------------------------
-
-var vtkPointPlacer$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkPointPlacer$1 as default, extend, newInstance };

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

@@ -1,10 +0,0 @@
-var CenterProjectionType = {
-  INSIDE_BOUNDS: 0,
-  IGNORE_BOUNDS: 1,
-  FIT_BOUNDS: 2
-};
-var Constants = {
-  CenterProjectionType: CenterProjectionType
-};
-
-export { CenterProjectionType, Constants as default };

package/Interaction/Widgets/ResliceCursor/ResliceCursor.js

@@ -1,269 +0,0 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../../macros.js';
-import { j as cross, l as normalize, A as clampValue } from '../../../Common/Core/Math/index.js';
-import vtkPolyData from '../../../Common/DataModel/PolyData.js';
-import vtkPlane from '../../../Common/DataModel/Plane.js';
-import vtkCellArray from '../../../Common/Core/CellArray.js';
-import { CenterProjectionType } from './ResliceCursor/Constants.js';
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
-// vtkResliceCursor methods
-// ----------------------------------------------------------------------------
-
-function vtkResliceCursor(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkResliceCursor');
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  function projectCenterToFitBounds(center, bounds) {
-    if (center[0] >= bounds[0] && center[0] <= bounds[1] && center[1] >= bounds[2] && center[1] <= bounds[3] && center[2] >= bounds[4] && center[2] <= bounds[5]) {
-      return center;
-    }
-
-    center[0] = clampValue(center[0], bounds[0], bounds[1]);
-    center[1] = clampValue(center[1], bounds[2], bounds[3]);
-    center[2] = clampValue(center[2], bounds[4], bounds[5]);
-    return center;
-  } //----------------------------------------------------------------------------
-  // Public API methods
-  //----------------------------------------------------------------------------
-
-
-  publicAPI.buildCursorTopology = function () {
-    for (var i = 0; i < 3; ++i) {
-      // Set number of points
-      model.centerlinesAxis[i].getPoints().setNumberOfPoints(2); // Define polys
-
-      var cellsData = new Float32Array(3);
-      var cells = vtkCellArray.newInstance({
-        values: cellsData
-      });
-      cellsData[0] = 2;
-      cellsData[1] = 0;
-      cellsData[2] = 1;
-      model.centerlinesAxis[i].setLines(cells);
-    }
-  };
-
-  publicAPI.buildCursorGeometry = function () {
-    publicAPI.computeAxes();
-    var bounds = model.image.getBounds(); // Length of the principal diagonal.
-
-    var pdLength = 20 * 0.5 * Math.sqrt((bounds[1] - bounds[0]) * (bounds[1] - bounds[0]) + (bounds[3] - bounds[2]) * (bounds[3] - bounds[2]) + (bounds[5] - bounds[4]) * (bounds[5] - bounds[4])); // Precompute prior to use within the loop.
-
-    var pts = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]];
-
-    for (var i = 0; i < 3; i++) {
-      pts[0][i] = model.center[i] - pdLength * model.xAxis[i];
-      pts[1][i] = model.center[i] + pdLength * model.xAxis[i];
-      pts[2][i] = model.center[i] - pdLength * model.yAxis[i];
-      pts[3][i] = model.center[i] + pdLength * model.yAxis[i];
-      pts[4][i] = model.center[i] - pdLength * model.zAxis[i];
-      pts[5][i] = model.center[i] + pdLength * model.zAxis[i];
-    }
-
-    for (var j = 0; j < 3; j++) {
-      var points = model.centerlinesAxis[j].getPoints();
-      var pointsData = points.getData();
-      pointsData[0] = pts[2 * j][0];
-      pointsData[1] = pts[2 * j][1];
-      pointsData[2] = pts[2 * j][2];
-      pointsData[3] = pts[2 * j + 1][0];
-      pointsData[4] = pts[2 * j + 1][1];
-      pointsData[5] = pts[2 * j + 1][2];
-      model.centerlinesAxis[j].modified();
-    }
-
-    model.polyDataBuildTime.modified();
-  };
-
-  publicAPI.computeAxes = function () {
-    var normals = [];
-
-    for (var i = 0; i < 3; ++i) {
-      normals[i] = publicAPI.getPlane(i).getNormal();
-    }
-
-    cross(normals[0], normals[1], model.zAxis);
-    cross(normals[1], normals[2], model.xAxis);
-    cross(normals[2], normals[0], model.yAxis);
-    normalize(model.xAxis);
-    normalize(model.yAxis);
-    normalize(model.zAxis);
-  }; // Reset cursor to its initial position
-
-
-  publicAPI.reset = function () {
-    model.xAxis = [1, 0, 0];
-    model.yAxis = [0, 1, 0];
-    model.zAxis = [0, 0, 1];
-    model.xViewUp = [0, 0, 1];
-    model.yViewUp = [0, 0, 1];
-    model.zViewUp = [0, -1, 0];
-
-    if (publicAPI.getImage()) {
-      model.center = publicAPI.getImage().getCenter();
-    } else {
-      model.center = [0, 0, 0];
-    }
-
-    for (var i = 0; i < 3; ++i) {
-      publicAPI.getPlane(i).setOrigin(model.center);
-    }
-
-    model.reslicePlanes[0].setNormal([1, 0, 0]);
-    model.reslicePlanes[1].setNormal([0, -1, 0]);
-    model.reslicePlanes[2].setNormal([0, 0, 1]);
-    publicAPI.buildCursorTopology();
-    publicAPI.buildCursorGeometry();
-  };
-
-  publicAPI.getPlane = function (i) {
-    return model.reslicePlanes[i];
-  };
-
-  publicAPI.update = function () {
-    if (!publicAPI.getImage()) {
-      vtkErrorMacro('Image not set! ');
-      return;
-    }
-
-    if (publicAPI.getMTime() > model.polyDataBuildTime.getMTime()) {
-      publicAPI.buildCursorTopology();
-      publicAPI.buildCursorGeometry();
-    }
-  };
-
-  publicAPI.getPolyData = function () {
-    publicAPI.update();
-    return model.polyData;
-  };
-
-  publicAPI.setCenter = function (center) {
-    var centerProjectionType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CenterProjectionType.INSIDE_BOUNDS;
-
-    if (model.center[0] === center[0] && model.center[1] === center[1] && model.center[2] === center[2]) {
-      return;
-    }
-
-    if (model.image) {
-      var bounds = model.image.getBounds();
-
-      var newCenter = _toConsumableArray(center);
-
-      if (centerProjectionType === CenterProjectionType.INSIDE_BOUNDS && (newCenter[0] < bounds[0] || newCenter[0] > bounds[1] || newCenter[1] < bounds[2] || newCenter[1] > bounds[3] || newCenter[2] < bounds[4] || newCenter[2] > bounds[5])) {
-        return;
-      }
-
-      if (centerProjectionType === CenterProjectionType.FIT_BOUNDS) {
-        newCenter = projectCenterToFitBounds(newCenter, bounds);
-
-        if (newCenter.length !== 3) {
-          return;
-        }
-      }
-
-      model.center = newCenter;
-      publicAPI.getPlane(0).setOrigin(model.center);
-      publicAPI.getPlane(1).setOrigin(model.center);
-      publicAPI.getPlane(2).setOrigin(model.center);
-      publicAPI.modified();
-    }
-  };
-
-  publicAPI.getCenterlineAxisPolyData = function (axis) {
-    publicAPI.update();
-    return model.centerlinesAxis[axis];
-  };
-
-  publicAPI.getAxis = function (i) {
-    if (i === 0) {
-      return model.xAxis;
-    }
-
-    if (i === 1) {
-      return model.yAxis;
-    }
-
-    return model.zAxis;
-  };
-
-  publicAPI.getViewUp = function (i) {
-    if (i === 0) {
-      return model.xViewUp;
-    }
-
-    if (i === 1) {
-      return model.yViewUp;
-    }
-
-    return model.zViewUp;
-  };
-
-  publicAPI.getMTime = function () {
-    var mTime = superClass.getMTime();
-
-    for (var i = 0; i < 3; ++i) {
-      var planeMTime = publicAPI.getPlane(i).getMTime();
-
-      if (planeMTime > mTime) {
-        mTime = planeMTime;
-      }
-    }
-
-    return mTime;
-  };
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
-  image: null,
-  center: [0, 0, 0],
-  xAxis: [1, 0, 0],
-  yAxis: [0, 1, 0],
-  zAxis: [0, 0, 1],
-  xViewUp: [0, 0, 1],
-  yViewUp: [0, 0, 1],
-  zViewUp: [0, -1, 0]
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-  macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['image']);
-  macro.setGetArray(publicAPI, model, ['xAxis', 'yAxis', 'zAxis', 'xViewUp', 'yViewUp', 'zViewUp'], 3);
-  macro.getArray(publicAPI, model, ['center'], 3);
-  model.reslicePlanes = [];
-  model.centerlinesAxis = [];
-  model.polyDataBuildTime = {};
-  macro.obj(model.polyDataBuildTime); // Object methods
-
-  vtkResliceCursor(publicAPI, model);
-
-  for (var i = 0; i < 3; ++i) {
-    model.reslicePlanes.push(vtkPlane.newInstance());
-    model.centerlinesAxis.push(vtkPolyData.newInstance());
-  }
-
-  model.reslicePlanes[0].setNormal([1, 0, 0]);
-  model.reslicePlanes[1].setNormal([0, -1, 0]);
-  model.reslicePlanes[2].setNormal([0, 0, -1]);
-  publicAPI.buildCursorTopology();
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkResliceCursor'); // ----------------------------------------------------------------------------
-
-var vtkResliceCursor$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkResliceCursor$1 as default, extend, newInstance };

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

@@ -1,10 +0,0 @@
-var PlaneNormal = {
-  XAxis: 0,
-  YAxis: 1,
-  ZAxis: 2
-};
-var Constants = {
-  PlaneNormal: PlaneNormal
-};
-
-export { PlaneNormal, Constants as default };