@kitware/vtk.js 24.6.0 → 24.8.0

package/IO/XML/XMLImageDataReader.js

@@ -10,6 +10,8 @@ function vtkXMLImageDataReader(publicAPI, model) {
   model.classHierarchy.push('vtkXMLImageDataReader');
 
   publicAPI.parseXML = function (rootElem, type, compressor, byteOrder, headerType) {
+    var _imageDataElem$getAtt;
+
     var imageDataElem = rootElem.getElementsByTagName(model.dataType)[0];
     var origin = imageDataElem.getAttribute('Origin').split(' ').map(function (t) {
       return Number(t);
@@ -17,6 +19,9 @@ function vtkXMLImageDataReader(publicAPI, model) {
     var spacing = imageDataElem.getAttribute('Spacing').split(' ').map(function (t) {
       return Number(t);
     });
+    var direction = (_imageDataElem$getAtt = imageDataElem.getAttribute('Direction')) === null || _imageDataElem$getAtt === void 0 ? void 0 : _imageDataElem$getAtt.split(' ').map(function (t) {
+      return Number(t);
+    });
     var pieces = imageDataElem.getElementsByTagName('Piece');
     var nbPieces = pieces.length;
 
@@ -29,6 +34,7 @@ function vtkXMLImageDataReader(publicAPI, model) {
       var imageData = vtkImageData.newInstance({
         origin: origin,
         spacing: spacing,
+        direction: direction,
         extent: extent
       }); // Fill data
 

package/IO/XML/XMLImageDataWriter.js

@@ -22,7 +22,8 @@ function vtkXMLImageDataWriter(publicAPI, model) {
     var imageData = parent.ele('ImageData', {
       WholeExtent: dataObject.getExtent().join(' '),
       Origin: dataObject.getOrigin().join(' '),
-      Spacing: dataObject.getSpacing().join(' ')
+      Spacing: dataObject.getSpacing().join(' '),
+      Direction: dataObject.getDirection().join(' ')
     });
     var piece = imageData.ele('Piece', {
       Extent: dataObject.getExtent().join(' ')

package/Interaction/Manipulators/MouseCameraAxisRotateManipulator.js

@@ -43,7 +43,7 @@ function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
     mat4.translate(trans, trans, center);
     var dx = model.previousPosition.x - position.x;
     var dy = model.previousPosition.y - position.y;
-    var size = interactor.getView().getSize(); // Azimuth
+    var size = interactor.getView().getViewportSize(renderer); // Azimuth
 
     mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), rotationAxis); // Elevation
 

package/Interaction/Manipulators/MouseCameraTrackballMultiRotateManipulator.js

@@ -23,7 +23,7 @@ function vtkMouseCameraTrackballMultiRotateManipulator(publicAPI, model) {
   var currentManipulator = null;
 
   publicAPI.onButtonDown = function (interactor, renderer, position) {
-    var viewSize = interactor.getView().getSize();
+    var viewSize = interactor.getView().getViewportSize(renderer);
     var viewCenter = [0.5 * viewSize[0], 0.5 * viewSize[1]];
     var rotateRadius = 0.9 * max(viewCenter[0], viewCenter[1]);
     var dist2 = sqr(viewCenter[0] - position.x) + sqr(viewCenter[1] - position.y);

package/Interaction/Manipulators/MouseCameraTrackballPanManipulator.js

@@ -33,7 +33,7 @@ function vtkMouseCameraTrackballPanManipulator(publicAPI, model) {
       var right = [0, 0, 0];
       cross(vpn, up, right); // These are different because y is flipped.
 
-      var height = interactor.getView().getSize()[1];
+      var height = interactor.getView().getViewportSize(renderer)[1];
       var dx = (pos.x - lastPos.x) / height;
       var dy = (lastPos.y - pos.y) / height;
       var scale = camera.getParallelScale();

package/Interaction/Manipulators/MouseCameraTrackballRotateManipulator.js

@@ -42,7 +42,7 @@ function vtkMouseCameraTrackballRotateManipulator(publicAPI, model) {
 
     var dx = model.previousPosition.x - position.x;
     var dy = model.previousPosition.y - position.y;
-    var size = interactor.getView().getSize(); // Azimuth
+    var size = interactor.getView().getViewportSize(renderer); // Azimuth
 
     var viewUp = camera.getViewUp();
 

package/Interaction/Manipulators/MouseCameraTrackballZoomManipulator.js

@@ -11,7 +11,7 @@ function vtkMouseCameraTrackballZoomManipulator(publicAPI, model) {
 
   publicAPI.onButtonDown = function (interactor, renderer, position) {
     model.previousPosition = position;
-    var size = interactor.getView().getSize();
+    var size = interactor.getView().getViewportSize(renderer);
     var camera = renderer.getActiveCamera();
     var direction = model.flipDirection ? -1 : 1;
 

package/Interaction/Manipulators/MouseCameraUnicamManipulator.js

@@ -26,7 +26,9 @@ function vtkMouseCameraUnicamManipulator(publicAPI, model) {
   }); //----------------------------------------------------------------------------
 
   var normalize$1 = function normalize(position, interactor) {
-    var _interactor$getView$g = interactor.getView().getSize(),
+    var renderer = interactor.findPokedRenderer();
+
+    var _interactor$getView$g = interactor.getView().getViewportSize(renderer),
         _interactor$getView$g2 = _slicedToArray(_interactor$getView$g, 2),
         width = _interactor$getView$g2[0],
         height = _interactor$getView$g2[1];
@@ -63,8 +65,9 @@ function vtkMouseCameraUnicamManipulator(publicAPI, model) {
     normalize(atV);
     var l = dot(cameraToPointVec, atV);
     var viewAngle = radiansFromDegrees(camera.getViewAngle());
+    var renderer = interactor.findPokedRenderer();
 
-    var _interactor$getView$g3 = interactor.getView().getSize(),
+    var _interactor$getView$g3 = interactor.getView().getViewportSize(renderer),
         _interactor$getView$g4 = _slicedToArray(_interactor$getView$g3, 2),
         width = _interactor$getView$g4[0],
         height = _interactor$getView$g4[1];

package/Interaction/Manipulators/MouseCameraUnicamRotateManipulator.js

@@ -55,7 +55,9 @@ function vtkMouseCameraUnicamRotateManipulator(publicAPI, model) {
 
 
   var normalize$1 = function normalize(position, interactor) {
-    var _interactor$getView$g = interactor.getView().getSize(),
+    var renderer = interactor.findPokedRenderer();
+
+    var _interactor$getView$g = interactor.getView().getViewportSize(renderer),
         _interactor$getView$g2 = _slicedToArray(_interactor$getView$g, 2),
         width = _interactor$getView$g2[0],
         height = _interactor$getView$g2[1];

package/Interaction/Style/InteractorStyleManipulator.js

@@ -42,7 +42,7 @@ function dollyToPosition(fact, position, renderer, rwi) {
 
   if (cam.getParallelProjection()) {
     // Zoom relatively to the cursor
-    var aSize = rwi.getView().getSize();
+    var aSize = rwi.getView().getViewportSize(renderer);
     var w = aSize[0];
     var h = aSize[1];
     var x0 = w / 2;

package/Rendering/Core/RenderWindowInteractor.js

@@ -118,10 +118,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   };
 
   function getScreenEventPositionFor(source) {
-    var bounds = model.container.getBoundingClientRect();
-
     var canvas = model._view.getCanvas();
 
+    var bounds = canvas.getBoundingClientRect();
     var scaleX = canvas.width / bounds.width;
     var scaleY = canvas.height / bounds.height;
     var position = {

package/Rendering/Core/Renderer.d.ts

@@ -559,7 +559,7 @@ export interface vtkRenderer extends vtkViewport {
 	/**
 	 * Get the number of visible actors.
 	 */
-	visibleActorCount(): void;
+	visibleActorCount(): number;
 
 	/**
 	 * Not Implemented yet

package/Widgets/Core/StateBuilder/manipulatorMixin.js

@@ -7,23 +7,23 @@ function vtkManipulatorMixin(publicAPI, model) {
           normal = model.normal,
           direction = model.direction;
       var _model$manipulator = model.manipulator,
-          setOrigin = _model$manipulator.setOrigin,
-          setCenter = _model$manipulator.setCenter,
-          setNormal = _model$manipulator.setNormal,
-          setDirection = _model$manipulator.setDirection;
-
-      if (origin && setOrigin) {
-        setOrigin(origin);
-      } else if (origin && setCenter) {
-        setCenter(origin);
+          setHandleOrigin = _model$manipulator.setHandleOrigin,
+          setHandleCenter = _model$manipulator.setHandleCenter,
+          setHandleNormal = _model$manipulator.setHandleNormal,
+          setHandleDirection = _model$manipulator.setHandleDirection;
+
+      if (origin && setHandleOrigin) {
+        setHandleOrigin(origin);
+      } else if (origin && setHandleCenter) {
+        setHandleCenter(origin);
       }
 
-      if (direction && setDirection) {
-        setDirection(direction);
-      } else if (direction && !normal && setNormal) {
-        setNormal(direction);
-      } else if (normal && setDirection) {
-        setDirection(normal);
+      if (direction && setHandleDirection) {
+        setHandleDirection(direction);
+      } else if (direction && !normal && setHandleNormal) {
+        setHandleNormal(direction);
+      } else if (normal && setHandleDirection) {
+        setHandleDirection(normal);
       }
     }
   };

package/Widgets/Core/WidgetManager.js

@@ -37,7 +37,6 @@ function extractRenderingComponents(renderer) {
 
 function createSvgRoot(id) {
   var svgRoot = createSvgDomElement('svg');
-  svgRoot.setAttribute('style', 'position: absolute; top: 0; left: 0; width: 100%; height: 100%;');
   svgRoot.setAttribute('version', '1.1');
   svgRoot.setAttribute('baseProfile', 'full');
   return svgRoot;
@@ -122,7 +121,7 @@ function vtkWidgetManager(publicAPI, model) {
   }
 
   function setSvgSize() {
-    var _model$_apiSpecificRe = model._apiSpecificRenderWindow.getSize(),
+    var _model$_apiSpecificRe = model._apiSpecificRenderWindow.getViewportSize(model._renderer),
         _model$_apiSpecificRe2 = _slicedToArray(_model$_apiSpecificRe, 2),
         cwidth = _model$_apiSpecificRe2[0],
         cheight = _model$_apiSpecificRe2[1];
@@ -148,6 +147,14 @@ function vtkWidgetManager(publicAPI, model) {
     }
   }
 
+  function setSvgRootStyle() {
+    var viewport = model._renderer.getViewport().map(function (v) {
+      return v * 100;
+    });
+
+    model.svgRoot.setAttribute('style', "position: absolute; left: ".concat(viewport[0], "%; top: ").concat(100 - viewport[3], "%; width: ").concat(viewport[2] - viewport[0], "%; height: ").concat(viewport[3] - viewport[1], "%;"));
+  }
+
   function updateSvg() {
     if (model.useSvgLayer) {
       var _loop = function _loop(i) {
@@ -459,6 +466,8 @@ function vtkWidgetManager(publicAPI, model) {
     model._selector.setFieldAssociation(FieldAssociations.FIELD_ASSOCIATION_POINTS);
 
     subscriptions.push(model._interactor.onRenderEvent(updateSvg));
+    subscriptions.push(renderer.onModified(setSvgRootStyle));
+    setSvgRootStyle();
     subscriptions.push(model._apiSpecificRenderWindow.onModified(setSvgSize));
     setSvgSize();
     subscriptions.push(model._apiSpecificRenderWindow.onModified(updateDisplayScaleParams));

package/Widgets/Manipulators/AbstractManipulator.d.ts

@@ -0,0 +1,221 @@
+import { vtkObject } from './../../interfaces';
+import { vtkOpenGLRenderWindow } from './../../Rendering/OpenGL/RenderWindow'
+import { Vector3 } from './../../types';
+
+/**
+ *
+ */
+export interface IAbstractManipulatorInitialValues {
+    userOrigin?: Vector3;
+    handleOrigin?: Vector3;
+    widgetOrigin?: Vector3;
+    userNormal?: Vector3;
+    handleNormal?: Vector3;
+    widgetNormal?: Vector3;
+}
+
+export interface vtkAbstractManipulator extends vtkObject {
+
+    /**
+     * Get the normal of the line
+     */
+    getNormal(callData: any): Vector3;
+
+    /**
+     * Get the origin of the line
+     */
+    getOrigin(callData: any): Vector3;
+
+    /**
+     * Get the value of useCameraFocalPoint
+     */
+    getUseCameraFocalPoint(): boolean;
+
+    /**
+     * Set the value of useCameraFocalPoint
+     * @param useCameraFocalPoint if true, the focal point of the camera will be used if userOrigin is not set.
+     */
+    setUseCameraFocalPoint(useCameraFocalPoint: boolean): boolean;
+
+    /**
+     * Get the value of useCameraNormal
+     */
+    getUseCameraNormal(): boolean;
+
+    /**
+     * Set the value of useCameraNormal
+     * @param useCameraNormal if true, the normal of the camera will be used if userNormal is not set.
+     */
+    setUseCameraNormal(useCameraNormal: boolean): boolean;
+
+    /**
+     * 
+     * @param callData 
+     * @param glRenderWindow 
+     */
+    handleEvent(callData: any, glRenderWindow: vtkOpenGLRenderWindow): Vector3;
+
+    /* ------------------------------------------------------------------- */
+
+    /**
+     * Set the user normal. 
+     * This normal take precedence on the handleNormal and the widgetNormal.
+     * This normal should not be set within the widget internal code.
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setUserNormal(normal: Vector3): boolean;
+
+    /**
+     * Set the user normal (see setUserNormal).
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Number} z The z coordinate.
+     */
+    setUserNormal(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the user normal (see setUserNormal).
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setUserNormalFrom(normal: Vector3): boolean;
+
+    /**
+     * Set the user origin.
+     * This origin take precedence on the handleOrigin and the widgetOrigin.
+     * This origin should not be set within the widget internal code.
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setUserOrigin(origin: Vector3): boolean;
+
+    /**
+     * Set the user origin (see setUserOrigin).
+     * @param {Number} x The x coordinate of the origin point.
+     * @param {Number} y The y coordinate of the origin point.
+     * @param {Number} z The z coordinate of the origin point.
+     */
+    setUserOrigin(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the user origin (see setUserOrigin).
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setUserOriginFrom(origin: Vector3): boolean;
+
+    /* ------------------------------------------------------------------- */
+
+    /**
+     * Set the handle normal. 
+     * This normal is used after the userNormal and before the widgetNormal.
+     * This normal is automatically set by any state having a manipulatorMixin,
+     * and can be overridden in the widget code.
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setHandleNormal(normal: Vector3): boolean;
+
+    /**
+     * Set the handle normal (see setHandleNormal).
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Number} z The z coordinate.
+     */
+    setHandleNormal(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the handle normal (see setHandleNormal).
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setHandleNormalFrom(normal: Vector3): boolean;
+
+    /**
+     * Set the handle origin.
+     * This origin is used after the userOrigin and before the widgetOrigin.
+     * This origin is automatically set by any state having a manipulatorMixin,
+     * and can be overridden in the widget code.
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setHandleOrigin(origin: Vector3): boolean;
+
+    /**
+     * Set the handle origin (see setHandleOrigin).
+     * @param {Number} x The x coordinate of the origin point.
+     * @param {Number} y The y coordinate of the origin point.
+     * @param {Number} z The z coordinate of the origin point.
+     */
+    setHandleOrigin(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the handle origin (see setHandleOrigin).
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setHandleOriginFrom(origin: Vector3): boolean;
+
+    /* ------------------------------------------------------------------- */
+
+    /**
+     * Set the widget normal. 
+     * This normal is used if no other normals are set. 
+     * It can be used to define a normal global to the whole widget.
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setWidgetNormal(normal: Vector3): boolean;
+
+    /**
+     * Set the widget normal (see setWidgetNormal).
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Number} z The z coordinate.
+     */
+    setWidgetNormal(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the widget normal (see setWidgetNormal).
+     * @param {Vector3} normal The normal coordinate.
+     */
+    setWidgetNormalFrom(normal: Vector3): boolean;
+
+    /**
+     * Set the widget origin.
+     * This origin is used if no other origins are set.
+     * It can be used to define an origin global to the whole widget.
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setWidgetOrigin(origin: Vector3): boolean;
+
+    /**
+     * Set the widget origin (see setWidgetOrigin).
+     * @param {Number} x The x coordinate of the origin point.
+     * @param {Number} y The y coordinate of the origin point.
+     * @param {Number} z The z coordinate of the origin point.
+     */
+    setWidgetOrigin(x: number, y: number, z: number): boolean;
+
+    /**
+     * Set the widget origin (see setWidgetOrigin).
+     * @param {Vector3} origin The coordinate of the origin point.
+     */
+    setWidgetOriginFrom(origin: Vector3): boolean;
+}
+
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkAbstractManipulator characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IAbstractManipulatorInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IAbstractManipulatorInitialValues): void;
+
+/**
+ * Method use to create a new instance of vtkAbstractManipulator
+ */
+export function newInstance(initialValues?: IAbstractManipulatorInitialValues): vtkAbstractManipulator;
+
+/**
+ * vtkAbstractManipulator.
+ */
+export declare const vtkAbstractManipulator: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+export default vtkAbstractManipulator;

package/Widgets/Manipulators/AbstractManipulator.js

@@ -0,0 +1,57 @@
+import macro from '../../macros.js';
+
+// vtkAbstractManipulator methods
+// ----------------------------------------------------------------------------
+
+function vtkAbstractManipulator(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkAbstractManipulator');
+
+  publicAPI.getOrigin = function (callData) {
+    if (model.userOrigin) return model.userOrigin;
+    if (model.useCameraFocalPoint) return callData.pokedRenderer.getActiveCamera().getFocalPoint();
+    if (model.handleOrigin) return model.handleOrigin;
+    if (model.widgetOrigin) return model.widgetOrigin;
+    return [0, 0, 0];
+  };
+
+  publicAPI.getNormal = function (callData) {
+    if (model.userNormal) return model.userNormal;
+    if (model.useCameraNormal) return callData.pokedRenderer.getActiveCamera().getDirectionOfProjection();
+    if (model.handleNormal) return model.handleNormal;
+    if (model.widgetNormal) return model.widgetNormal;
+    return [0, 0, 1];
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  // userOrigin: null,
+  // handleOrigin: null,
+  // widgetOrigin: null,
+  // userNormal: null,
+  // handleNormal: null,
+  // widgetNormal: null
+  useCameraFocalPoint: false,
+  useCameraNormal: false
+}; // ----------------------------------------------------------------------------
+
+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, ['useCameraFocalPoint', 'useCameraNormal']);
+  macro.setGetArray(publicAPI, model, ['userOrigin', 'handleOrigin', 'widgetOrigin', 'userNormal', 'handleNormal', 'widgetNormal'], 3);
+  vtkAbstractManipulator(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkAbstractManipulator'); // ----------------------------------------------------------------------------
+
+var vtkAbstractManipulator$1 = {
+  extend: extend,
+  newInstance: newInstance
+};
+
+export { vtkAbstractManipulator$1 as default, extend, newInstance };

package/Widgets/Manipulators/LineManipulator.d.ts

@@ -1,81 +1,15 @@
-import { vtkObject } from './../../interfaces';
+import { IAbstractManipulatorInitialValues, vtkAbstractManipulator } from './AbstractManipulator';
+import { Vector3 } from './../../types';
 
 /**
  *
  */
-export interface ILineManipulatorInitialValues {
-	origin?: number[];
-	normal?: number[];
-}
-
-export interface vtkLineManipulator extends vtkObject {
-
-	/**
-	 * Set the normal of the line
-	 */
-	getNormal(): number[];
-
-	/**
-	 * Set the normal of the line
-	 */
-	getNormalByReference(): number[];
-
-	/**
-	 * Set the origin of the line
-	 */
-	getOrigin(): number[];
-
-	/**
-	 * Set the origin of the line
-	 */
-	getOriginByReference(): number[];
+export interface ILineManipulatorInitialValues extends IAbstractManipulatorInitialValues {
 
-	/**
-	 * 
-	 * @param callData 
-	 * @param glRenderWindow 
-	 */
-	handleEvent(callData: any, glRenderWindow: any): number[];
-
-	/**
-	 * Set the normal of the line
-	 * @param {Number[]} normal The normal coordinate.
-	 */
-	setNormal(normal: number[]): boolean;
-
-	/**
-	 * Set the normal of the line
-	 * @param {Number} x The x coordinate.
-	 * @param {Number} y The y coordinate.
-	 * @param {Number} z The z coordinate.
-	 */
-	setNormal(x: number, y: number, z: number): boolean;
-
-	/**
-	 * Set the normal of the line
-	 * @param {Number[]} normal The normal coordinate.
-	 */
-	setNormalFrom(normal: number[]): boolean;
-
-	/**
-	 * Set the origin of the line.
-	 * @param {Number[]} origin The coordinate of the origin point.
-	 */
-	setOrigin(origin: number[]): boolean;
+}
 
-	/**
-	 * Set the origin of the line
-	 * @param {Number} x The x coordinate of the origin point.
-	 * @param {Number} y The y coordinate of the origin point.
-	 * @param {Number} z The z coordinate of the origin point.
-	 */
-	setOrigin(x: number, y: number, z: number): boolean;
+export interface vtkLineManipulator extends vtkAbstractManipulator {
 
-	/**
-	 * Set the origin of the line
-	 * @param {Number[]} origin The coordinate of the origin point.
-	 */
-	setOriginFrom(origin: number[]): boolean;
 }
 
 
@@ -97,12 +31,12 @@ export function newInstance(initialValues?: ILineManipulatorInitialValues): vtkL
  * 
  * @param {Number} x 
  * @param {Number} y 
- * @param {Number[]} lineOrigin 
- * @param {Number[]} lineDirection 
+ * @param {Vector3} lineOrigin 
+ * @param {Vector3} lineDirection 
  * @param renderer 
  * @param glRenderWindow 
  */
-export function projectDisplayToLine(x: number, y: number, lineOrigin: number[], lineDirection: number[], renderer: any, glRenderWindow: any): number[];
+export function projectDisplayToLine(x: number, y: number, lineOrigin: Vector3, lineDirection: Vector3, renderer: any, glRenderWindow: any): Vector3;
 
 /**
  * vtkLineManipulator.

package/Widgets/Manipulators/LineManipulator.js

@@ -1,6 +1,11 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import { g as subtract, j as cross, d as dot, x as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
+import vtkAbstractManipulator from './AbstractManipulator.js';
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function projectDisplayToLine(x, y, lineOrigin, lineDirection, renderer, glRenderWindow) {
   var near = glRenderWindow.displayToWorld(x, y, 0, renderer);
   var far = glRenderWindow.displayToWorld(x, y, 1, renderer);
@@ -20,27 +25,25 @@ function projectDisplayToLine(x, y, lineOrigin, lineDirection, renderer, glRende
 // ----------------------------------------------------------------------------
 
 function vtkLineManipulator(publicAPI, model) {
-  // Set our classNae
-  model.classHierarchy.push('vtkLineManipulator'); // --------------------------------------------------------------------------
+  // Set our className
+  model.classHierarchy.push('vtkLineManipulator');
 
   publicAPI.handleEvent = function (callData, glRenderWindow) {
-    return projectDisplayToLine(callData.position.x, callData.position.y, model.origin, model.normal, callData.pokedRenderer, glRenderWindow);
+    return projectDisplayToLine(callData.position.x, callData.position.y, publicAPI.getOrigin(callData), publicAPI.getNormal(callData), callData.pokedRenderer, glRenderWindow);
   };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  origin: [0, 0, 0],
-  normal: [0, 0, 1]
-}; // ----------------------------------------------------------------------------
+function defaultValues(initialValues) {
+  return _objectSpread({}, initialValues);
+} // ----------------------------------------------------------------------------
+
 
 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.setGetArray(publicAPI, model, ['origin', 'normal'], 3);
+  vtkAbstractManipulator.extend(publicAPI, model, defaultValues(initialValues));
   vtkLineManipulator(publicAPI, model);
 } // ----------------------------------------------------------------------------