@kitware/vtk.js 24.7.0 → 24.9.0

package/Common/DataModel/ITKHelper.d.ts

@@ -0,0 +1,54 @@
+import vtkPolyData from './PolyData';
+import vtkImageData from './ImageData';
+
+export interface IOptions {
+	pointDataName: string;
+	scalarArrayName: string;
+	cellDataName: string;
+}
+
+/**
+ * Converts an itk-wasm Image to a vtk.js vtkImageData.
+ * Requires an itk-wasm Image as input.
+ * @param itkImage 
+ * @param {IOptions} [options] 
+ */
+export function convertItkToVtkImage(itkImage: any, options?: IOptions): vtkImageData;
+
+/**
+ * Converts a vtk.js vtkImageData to an itk-wasm Image.
+ * Requires a vtk.js vtkImageData as input.
+ * @param {vtkImageData} vtkImage 
+ * @param {IOptions} [options] 
+ */
+export function convertVtkToItkImage(vtkImage: vtkImageData, options?: IOptions): any;
+
+/**
+ * Converts an itk-wasm PolyData to a vtk.js vtkPolyData.
+ * Requires an itk-wasm PolyData as input.
+ * @param itkPolyData 
+ * @param {IOptions} [options] 
+ */
+export function convertItkToVtkPolyData(itkPolyData: any, options?: IOptions): vtkPolyData;
+
+/**
+ * Converts a vtk.js vtkPolyData to an itk-wasm PolyData.
+ * Requires a vtk.js vtkPolyData as input.
+ * 
+ * @param {vtkPolyData} polyData 
+ * @param {IOptions} [options] 
+ */
+export function convertVtkToItkPolyData(polyData: vtkPolyData, options?: IOptions): any;
+
+
+/** 
+ * vtkITKHelper is a helper which provides a set of functions to work with
+ * itk-wasm module.
+ */
+export declare const vtkITKHelper: {
+	convertItkToVtkImage: typeof convertItkToVtkImage,
+	convertVtkToItkImage: typeof convertVtkToItkImage,
+	convertItkToVtkPolyData: typeof convertItkToVtkPolyData,
+	convertVtkToItkPolyData: typeof convertVtkToItkPolyData,
+};
+export default vtkITKHelper;

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/Manipulators/MouseRangeManipulator.js

@@ -18,9 +18,13 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
 
   function processDelta(listener, delta) {
-    var oldValue = listener.getValue(); // Apply scale and cached delta to current delta
+    var oldValue = listener.getValue(); // if exponential scroll is enabled, we raise our scale to the
+    //  exponent of the net delta of the interaction. The further away
+    // the user's cursor is from the start of the interaction, the more
+    // their movements will effect the value.
 
-    var newDelta = delta * listener.scale + incrementalDelta.get(listener);
+    var scalingFactor = listener.exponentialScroll ? Math.pow(listener.scale, Math.log2(Math.abs(model.interactionNetDelta) + 2)) : listener.scale;
+    var newDelta = delta * scalingFactor + incrementalDelta.get(listener);
     var value = oldValue + newDelta; // Compute new value based on step
 
     var difference = value - listener.min;
@@ -52,6 +56,7 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
   publicAPI.setHorizontalListener = function (min, max, step, getValue, setValue) {
     var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     var getFn = Number.isFinite(getValue) ? function () {
       return getValue;
     } : getValue;
@@ -61,7 +66,8 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       step: step,
       getValue: getFn,
       setValue: setValue,
-      scale: scale
+      scale: scale,
+      exponentialScroll: exponentialScroll
     };
     incrementalDelta.set(model.horizontalListener, 0);
     publicAPI.modified();
@@ -70,6 +76,7 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
   publicAPI.setVerticalListener = function (min, max, step, getValue, setValue) {
     var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     var getFn = Number.isFinite(getValue) ? function () {
       return getValue;
     } : getValue;
@@ -79,7 +86,8 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       step: step,
       getValue: getFn,
       setValue: setValue,
-      scale: scale
+      scale: scale,
+      exponentialScroll: exponentialScroll
     };
     incrementalDelta.set(model.verticalListener, 0);
     publicAPI.modified();
@@ -88,6 +96,7 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
   publicAPI.setScrollListener = function (min, max, step, getValue, setValue) {
     var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     var getFn = Number.isFinite(getValue) ? function () {
       return getValue;
     } : getValue;
@@ -97,7 +106,8 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       step: step,
       getValue: getFn,
       setValue: setValue,
-      scale: scale
+      scale: scale,
+      exponentialScroll: exponentialScroll
     };
     incrementalDelta.set(model.scrollListener, 0);
     publicAPI.modified();
@@ -140,6 +150,7 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
   publicAPI.onButtonDown = function (interactor, renderer, position) {
     model.previousPosition = position;
+    model.interactionNetDelta = 0;
     var glRenderWindow = interactor.getView(); // Ratio is the dom size vs renderwindow size
 
     var ratio = glRenderWindow.getContainerSize()[0] / glRenderWindow.getSize()[0]; // Get proper pixel range used by viewport in rw size space
@@ -216,12 +227,14 @@ function vtkMouseRangeManipulator(publicAPI, model) {
     if (model.horizontalListener) {
       var dxNorm = (position.x - model.previousPosition.x) / model.containerSize[0];
       var dx = scaleDeltaToRange(model.horizontalListener, dxNorm);
+      model.interactionNetDelta += dx;
       processDelta(model.horizontalListener, dx);
     }
 
     if (model.verticalListener) {
       var dyNorm = (position.y - model.previousPosition.y) / model.containerSize[1];
       var dy = scaleDeltaToRange(model.verticalListener, dyNorm);
+      model.interactionNetDelta += dy;
       processDelta(model.verticalListener, dy);
     }
 
@@ -234,10 +247,14 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       return;
     }
 
+    model.interactionNetDelta += delta * model.scrollListener.step;
     processDelta(model.scrollListener, delta * model.scrollListener.step);
   };
 
-  publicAPI.onStartScroll = publicAPI.onScroll;
+  publicAPI.onStartScroll = function (payload) {
+    model.interactionNetDelta = 0;
+    publicAPI.onScroll(payload);
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

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/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 };