@kitware/vtk.js 29.11.2 → 30.1.0

package/BREAKING_CHANGES.md

@@ -1,3 +1,8 @@
+## From 29.x to 30
+
+- **ResliceCursorWidget.interactionEvent**: no longer pass an object of computeFocalPointOffset, canUpdateFocalPoint but simply the type of the handle that triggers the event. Those values can easily be recomputed by the consumers of the event. Regarding `computeFocalPointOffset`, it is no longer adviced to compute focal point offset for each interaction, instead observing `startInteraction()` should be considered (see ResliceCursorWidget example).
+  - **ResliceCursorWidget.invokeInternalInteractionEvent(methodName)**: has been removed and should be replaced by `ResliceCursorWidget.invokeInteractionEvent(methodName)`.
+
 ## From 28.x to 29
 
 - **getOpenGLRenderWindow**: `getOpenGLRenderWindow` has been renamed to `getApiSpecificRenderWindow` in `vtkFullScreenRenderWindow`, `vtkGenericRenderWindow` and `vtkViewProxy` to support WebGL and WebGPU backend. ([#2816](https://github.com/Kitware/vtk-js/pull/2816))

package/Interaction/Manipulators/3DControllerModelSelectorManipulator/index.js

@@ -0,0 +1,182 @@
+import { vec3, vec4, quat, mat4 } from 'gl-matrix';
+import vtkCompositeVRManipulator from '../CompositeVRManipulator.js';
+import vtkPicker from '../../../Rendering/Core/Picker.js';
+import { m as macro } from '../../../macros2.js';
+import { States } from '../../../Rendering/Core/InteractorStyle/Constants.js';
+
+// ----------------------------------------------------------------------------
+// vtk3DControllerModelSelectorManipulator methods
+// ----------------------------------------------------------------------------
+
+function vtk3DControllerModelSelectorManipulator(publicAPI, model) {
+  model.classHierarchy.push('vtk3DControllerModelSelectorManipulator');
+  const picker = vtkPicker.newInstance();
+
+  // The current prop we are manipulating, if any.
+  let pickedProp;
+
+  // pre-allocate array buffers
+  const physicalToWorldMatrix = new Float64Array(16);
+
+  // arrays holding deltas from lastWorldPosition and lastOrientation
+  const translation = new Float64Array(3);
+  const rotation = new Float64Array(4);
+  const lastOrientationConjugate = new Float64Array(4);
+  const orientationAxis = new Float64Array(3);
+
+  // arrays holding the transform
+  const computedTransform = new Float64Array(16);
+  const computedTransformRotation = new Float64Array(4);
+
+  // arrays holding the current state of pickedProp.
+  const transposedPropMatrix = new Float64Array(16);
+  const propCurrentOrientation = new Float64Array(4);
+  const propCurrentOrientationConjugate = new Float64Array(4);
+
+  // arrays holding the new properties that must be assigned to pickedProp.
+  const propNewTranslation = new Float64Array(3);
+  const propNewScaling = new Float64Array(3);
+  const propNewOrientation = new Float64Array(4);
+  function applyPositionAndOrientationToProp(prop, worldPosition, orientation) {
+    vec3.subtract(translation, worldPosition, model.lastWorldPosition);
+    quat.conjugate(lastOrientationConjugate, model.lastOrientation);
+    quat.multiply(rotation, orientation, lastOrientationConjugate);
+    quat.normalize(rotation, rotation);
+    const rotationAngle = quat.getAxisAngle(orientationAxis, rotation);
+
+    // reset to identity
+    mat4.identity(computedTransform);
+
+    // compute transform
+    mat4.translate(computedTransform, computedTransform, worldPosition);
+    mat4.rotate(computedTransform, computedTransform, rotationAngle, orientationAxis);
+    mat4.translate(computedTransform, computedTransform, vec3.negate(new Float64Array(3), worldPosition));
+    mat4.translate(computedTransform, computedTransform, translation);
+
+    // lookup the prop internal matrix
+    mat4.transpose(transposedPropMatrix, prop.getMatrix());
+    // apply the new computedTransform to the prop internal matrix
+    mat4.multiply(computedTransform, computedTransform, transposedPropMatrix);
+
+    // Multiply the computedTransform with the current prop orientation to get the delta
+    // that must be applied to the prop
+    mat4.getRotation(computedTransformRotation, computedTransform);
+    prop.getOrientationQuaternion(propCurrentOrientation);
+    quat.conjugate(propCurrentOrientationConjugate, propCurrentOrientation);
+    quat.multiply(propNewOrientation, propCurrentOrientationConjugate, computedTransformRotation);
+    quat.normalize(propNewOrientation, propNewOrientation);
+    mat4.getTranslation(propNewTranslation, computedTransform);
+    mat4.getScaling(propNewScaling, computedTransform);
+
+    // Update the prop internal matrix
+    prop.setPosition(...propNewTranslation);
+    prop.setScale(...propNewScaling);
+    prop.rotateQuaternion(propNewOrientation);
+  }
+  function releasePickedProp() {
+    model.lastOrientation = null;
+    model.lastWorldPosition = null;
+    if (pickedProp) {
+      pickedProp.setDragable(true);
+    }
+    pickedProp = null;
+  }
+  publicAPI.onButton3D = (interactorStyle, renderer, state, eventData) => {
+    // If the button is not pressed, clear the state
+    if (!eventData.pressed) {
+      releasePickedProp();
+      return macro.VOID;
+    }
+    const camera = renderer.getActiveCamera();
+    camera.getPhysicalToWorldMatrix(physicalToWorldMatrix);
+    const {
+      targetPosition,
+      targetOrientation
+    } = eventData;
+
+    // Since targetPosition is in physical coordinates,
+    // transform it using the physicalToWorldMatrix to get it in world coordinates
+    const targetRayWorldPosition = vec3.transformMat4([], [targetPosition.x, targetPosition.y, targetPosition.z], physicalToWorldMatrix);
+    const targetRayWorldDirection = camera.physicalOrientationToWorldDirection([targetOrientation.x, targetOrientation.y, targetOrientation.z, targetOrientation.w]);
+    const dist = renderer.getActiveCamera().getClippingRange()[1];
+    const rayPoint1 = [...targetRayWorldPosition, 1.0];
+    const rayPoint2 = [rayPoint1[0] - targetRayWorldDirection[0] * dist, rayPoint1[1] - targetRayWorldDirection[1] * dist, rayPoint1[2] - targetRayWorldDirection[2] * dist, 1.0];
+
+    // Perform picking on the given renderer
+    picker.pick3DPoint(rayPoint1, rayPoint2, renderer);
+    const props = picker.getActors();
+
+    // If we have picked props, store the first one.
+    if (props.length > 0 && props[0].getNestedDragable()) {
+      pickedProp = props[0];
+
+      // prevent the prop from being dragged somewhere else
+      pickedProp.setDragable(false);
+    } else {
+      releasePickedProp();
+    }
+    return macro.EVENT_ABORT;
+  };
+
+  // pre-allocation to reduce gc in onMove3D
+  const currentTargetRayWorldPosition = new Float64Array(3);
+  const currentTargetRayOrientation = new Float64Array(4);
+  publicAPI.onMove3D = (interactorStyle, renderer, state, eventData) => {
+    // If we are not interacting with any prop, we have nothing to do.
+    // Also check for dragable
+    if (state !== States.IS_CAMERA_POSE || pickedProp == null) {
+      return macro.VOID;
+    }
+    const camera = renderer.getActiveCamera();
+    camera.getPhysicalToWorldMatrix(physicalToWorldMatrix);
+    const {
+      targetPosition
+    } = eventData;
+    vec3.transformMat4(currentTargetRayWorldPosition, [targetPosition.x, targetPosition.y, targetPosition.z], physicalToWorldMatrix);
+
+    // this is a unit quaternion
+    vec4.set(currentTargetRayOrientation, eventData.targetOrientation.x, eventData.targetOrientation.y, eventData.targetOrientation.z, eventData.targetOrientation.w);
+    if (model.lastWorldPosition && model.lastOrientation) {
+      applyPositionAndOrientationToProp(pickedProp, currentTargetRayWorldPosition, currentTargetRayOrientation);
+    } else {
+      // allocate
+      model.lastWorldPosition = new Float64Array(3);
+      model.lastOrientation = new Float64Array(4);
+    }
+    vec3.copy(model.lastWorldPosition, currentTargetRayWorldPosition);
+    vec4.copy(model.lastOrientation, currentTargetRayOrientation);
+    return macro.EVENT_ABORT;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  macro.get(publicAPI, model, ['lastWorldPosition', 'lastOrientation']);
+  macro.obj(publicAPI, model);
+  vtkCompositeVRManipulator.extend(publicAPI, model, initialValues);
+
+  // Object specific methods
+  vtk3DControllerModelSelectorManipulator(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtk3DControllerModelSelectorManipulator');
+
+// ----------------------------------------------------------------------------
+
+var vtk3DControllerModelSelectorManipulator$1 = {
+  newInstance,
+  extend
+};
+
+export { vtk3DControllerModelSelectorManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/3DControllerModelSelectorManipulator.d.ts

@@ -0,0 +1,19 @@
+import vtkCompositeVRManipulator from './CompositeVRManipulator';
+
+export interface vtk3DControllerModelSelectorManipulator
+  extends vtkCompositeVRManipulator {}
+
+export interface I3DControllerModelSelectorManipulatorInitialValues
+  extends vtkCompositeVRManipulator {}
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: I3DControllerModelSelectorManipulatorInitialValues
+): void;
+
+export const vtk3DControllerModelSelectorManipulator: {
+  extend: typeof extend;
+};
+
+export default vtk3DControllerModelSelectorManipulator;

package/Interaction/Manipulators/CompositeVRManipulator.d.ts

@@ -1,28 +1,28 @@
 import { States } from './../../Rendering/Core/InteractorStyle/Constants';
 import vtkRenderer from './../../Rendering/Core/Renderer';
-import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import vtkInteractorObserver from './../../Rendering/Core/InteractorObserver';
 import {
   Device,
   Input,
 } from './../../Rendering/Core/RenderWindowInteractor/Constants';
+import {
+  I3DEvent,
+  IButton3DEvent,
+} from './../../Rendering/Core/RenderWindowInteractor';
 
 export interface vtkCompositeVRManipulator {
   onButton3D(
-    interactor: vtkRenderWindowInteractor,
+    interactorStyle: vtkInteractorObserver,
     renderer: vtkRenderer,
     state: States,
-    device: Device,
-    input: Input,
-    pressed: boolean
+    eventData: IButton3DEvent
   ): void;
 
   onMove3D(
-    interactor: vtkRenderWindowInteractor,
+    interactorStyle: vtkInteractorObserver,
     renderer: vtkRenderer,
     state: States,
-    device: Device,
-    input: Input,
-    pressed: boolean
+    eventData: I3DEvent
   ): void;
 }
 

package/Interaction/Manipulators/CompositeVRManipulator.js

@@ -8,8 +8,8 @@ import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Const
 function vtkCompositeVRManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCompositeVRManipulator');
-  publicAPI.onButton3D = (interactor, renderer, state, device, input, pressed) => {};
-  publicAPI.onMove3D = (interactor, renderer, state, device, input, pressed) => {};
+  publicAPI.onButton3D = (interactorStyle, renderer, state, eventData) => {};
+  publicAPI.onMove3D = (interactorStyle, renderer, state, eventData) => {};
 }
 
 // ----------------------------------------------------------------------------

package/Interaction/Manipulators/VRButtonPanManipulator.js

@@ -10,14 +10,14 @@ import { States } from '../../Rendering/Core/InteractorStyle/Constants.js';
 function vtkVRButtonPanManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVRButtonPanManipulator');
-  publicAPI.onButton3D = (interactorStyle, renderer, state, device, input, pressed) => {
-    if (pressed) {
+  publicAPI.onButton3D = (interactorStyle, renderer, state, eventData) => {
+    if (eventData.pressed) {
       interactorStyle.startCameraPose();
     } else if (state === States.IS_CAMERA_POSE) {
       interactorStyle.endCameraPose();
     }
   };
-  publicAPI.onMove3D = (interactorStyle, renderer, state, data) => {
+  publicAPI.onMove3D = (interactorStyle, renderer, state, eventData) => {
     if (state !== States.IS_CAMERA_POSE) {
       return;
     }
@@ -28,13 +28,13 @@ function vtkVRButtonPanManipulator(publicAPI, model) {
     const oldTrans = camera.getPhysicalTranslation();
 
     // look at the y axis to determine how fast / what direction to move
-    const speed = data.gamepad.axes[1];
+    const speed = eventData.gamepad.axes[1];
 
     // 0.05 meters / frame movement
     const pscale = speed * 0.05 * camera.getPhysicalScale();
 
     // convert orientation to world coordinate direction
-    const dir = camera.physicalOrientationToWorldDirection(data.orientation);
+    const dir = camera.physicalOrientationToWorldDirection(eventData.orientation);
     camera.setPhysicalTranslation(oldTrans[0] + dir[0] * pscale, oldTrans[1] + dir[1] * pscale, oldTrans[2] + dir[2] * pscale);
   };
 }

package/Interaction/Style/InteractorStyleHMDXR.d.ts

@@ -0,0 +1,22 @@
+import vtkInteractorStyleManipulator, { IInteractorStyleManipulatorInitialValues } from './InteractorStyleManipulator';
+
+export interface vtkInteractorStyleHMDXR extends vtkInteractorStyleManipulator {}
+
+export interface IInteractorStyleHMDXRInitialValues extends IInteractorStyleManipulatorInitialValues {}
+
+export function newInstance(
+  initialValues?: IInteractorStyleHMDXRInitialValues
+): vtkInteractorStyleHMDXR;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IInteractorStyleHMDXRInitialValues
+): void;
+
+export const vtkInteractorStyleHMDXR: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkInteractorStyleHMDXR;

package/Interaction/Style/InteractorStyleHMDXR.js

@@ -0,0 +1,50 @@
+import { m as macro } from '../../macros2.js';
+import vtkInteractorStyleManipulator from './InteractorStyleManipulator.js';
+import vtk3DControllerModelSelectorManipulator from '../Manipulators/3DControllerModelSelectorManipulator/index.js';
+import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
+
+function vtkInteractorStyleHMDXR(publicAPI, model) {
+  model.classHierarchy.push('vtkInteractorStyleHMDXR');
+  const leftHandManipulator = vtk3DControllerModelSelectorManipulator.newInstance({
+    device: Device.LeftController,
+    input: Input.A
+  });
+  const rightHandManipulator = vtk3DControllerModelSelectorManipulator.newInstance({
+    device: Device.RightController,
+    input: Input.A
+  });
+  publicAPI.addVRManipulator(leftHandManipulator);
+  publicAPI.addVRManipulator(rightHandManipulator);
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  vtkInteractorStyleManipulator.extend(publicAPI, model, initialValues);
+
+  // Object specific methods
+  vtkInteractorStyleHMDXR(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkInteractorStyleHMDXR');
+
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend
+};
+
+export { index as default, extend, newInstance };

package/Interaction/Style/InteractorStyleManipulator.js

@@ -118,6 +118,7 @@ const STATIC = {
 function vtkInteractorStyleManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkInteractorStyleManipulator');
+  model.currentVRManipulators = new Map();
   model.mouseManipulators = [];
   model.keyboardManipulators = [];
   model.vrManipulators = [];
@@ -246,13 +247,20 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     }
 
     // Look for a matching 3D camera interactor.
-    model.currentManipulator = publicAPI.findVRManipulator(ed.device, ed.input, ed.pressed);
-    if (model.currentManipulator) {
-      model.currentManipulator.onButton3D(publicAPI, ed.pokedRenderer, model.state, ed.device, ed.input, ed.pressed);
+    const manipulator = publicAPI.findVRManipulator(ed.device, ed.input, ed.pressed);
+    if (manipulator) {
+      // register the manipulator for this device
+      model.currentVRManipulators.set(ed.device, manipulator);
+      manipulator.onButton3D(publicAPI, ed.pokedRenderer, model.state, ed);
       if (ed.pressed) {
         publicAPI.startCameraPose();
       } else {
-        publicAPI.endCameraPose();
+        model.currentVRManipulators.delete(ed.device);
+
+        // make sure we don't end camera pose if other VR manipulators are currently interacting
+        if (model.currentVRManipulators.size === 0) {
+          publicAPI.endCameraPose();
+        }
       }
     } else {
       vtkDebugMacro('No manipulator found');
@@ -261,8 +269,9 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
 
   //-------------------------------------------------------------------------
   publicAPI.handleMove3D = ed => {
-    if (model.currentManipulator && model.state === States.IS_CAMERA_POSE) {
-      model.currentManipulator.onMove3D(publicAPI, ed.pokedRenderer, model.state, ed);
+    const manipulator = model.currentVRManipulators.get(ed.device);
+    if (manipulator && model.state === States.IS_CAMERA_POSE) {
+      manipulator.onMove3D(publicAPI, ed.pokedRenderer, model.state, ed);
     }
   };
 
@@ -576,7 +585,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
+const defaultValues = initialValues => ({
   cachedMousePosition: null,
   currentManipulator: null,
   currentWheelManipulator: null,
@@ -585,14 +594,15 @@ const DEFAULT_VALUES = {
   // vrManipulators: null,
   // gestureManipulators: null,
   centerOfRotation: [0, 0, 0],
-  rotationFactor: 1
-};
+  rotationFactor: 1,
+  ...initialValues
+});
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
 
   // Inheritance
   vtkInteractorStyle.extend(publicAPI, model, initialValues);

package/Rendering/Core/CellPicker.d.ts

@@ -2,7 +2,9 @@ import vtkCell from './../../Common/DataModel/Cell';
 import { Vector3 } from './../../types';
 import vtkMapper from './Mapper';
 import vtkPicker, { IPickerInitialValues } from './Picker';
+import vtkProp3D from './Prop3D';
 import vtkRenderer from './Renderer';
+import { Nullable } from './../../types';
 
 /**
  * 
@@ -83,26 +85,6 @@ export interface vtkCellPicker extends vtkPicker {
 	 * @param {vtkRenderer} renderer The vtkRenderer instance.
 	 */
 	pick(selection: any, renderer: vtkRenderer): void;
-
-	/**
-	 * 
-	 * @param {Vector3} p1 
-	 * @param {Vector3} p2 
-	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper The vtkMapper instance.
-	 */
-	intersectWithLine(p1: Vector3, p2: Vector3, tol: number, mapper: vtkMapper): number;
-
-	/**
-	 * 
-	 * @param {Vector3} p1 
-	 * @param {Vector3} p2 
-	 * @param {Number} t1 
-	 * @param {Number} t2 
-	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper The vtkMapper instance.
-	 */
-	intersectActorWithLine(p1: Vector3, p2: Vector3, t1: number, t2: number, tol: number, mapper: vtkMapper): number;
 }
 
 /**

package/Rendering/Core/CellPicker.js

@@ -158,7 +158,7 @@ function vtkCellPicker(publicAPI, model) {
     }
     return pickResult;
   };
-  publicAPI.intersectWithLine = (p1, p2, tol, actor, mapper) => {
+  model.intersectWithLine = (p1, p2, tolerance, prop, mapper) => {
     let tMin = Number.MAX_VALUE;
     let t1 = 0.0;
     let t2 = 1.0;
@@ -177,13 +177,13 @@ function vtkCellPicker(publicAPI, model) {
     } else if (mapper.isA('vtkVolumeMapper')) {
       // we calculate here the parametric intercept points between the ray and the bounding box, so
       // if the application defines for some reason a too large ray length (1e6), it restrict the calculation
-      // to the vtkVolume actor bounding box
+      // to the vtkVolume prop bounding box
       const interceptionObject = vtkBox.intersectWithLine(mapper.getBounds(), p1, p2);
       t1 = interceptionObject?.t1 > clipLine.t1 ? interceptionObject.t1 : clipLine.t1;
       t2 = interceptionObject?.t2 < clipLine.t2 ? interceptionObject.t2 : clipLine.t2;
-      tMin = publicAPI.intersectVolumeWithLine(p1, p2, t1, t2, tol, actor);
+      tMin = model.intersectVolumeWithLine(p1, p2, t1, t2, tolerance, prop);
     } else if (mapper.isA('vtkMapper')) {
-      tMin = publicAPI.intersectActorWithLine(p1, p2, t1, t2, tol, mapper);
+      tMin = model.intersectActorWithLine(p1, p2, t1, t2, tolerance, mapper);
     }
     if (tMin < model.globalTMin) {
       model.globalTMin = tMin;
@@ -208,7 +208,7 @@ function vtkCellPicker(publicAPI, model) {
     }
     return tMin;
   };
-  publicAPI.intersectVolumeWithLine = (p1, p2, t1, t2, tol, volume) => {
+  model.intersectVolumeWithLine = (p1, p2, t1, t2, tolerance, volume) => {
     let tMin = Number.MAX_VALUE;
     const mapper = volume.getMapper();
     const imageData = mapper.getInputData();
@@ -315,7 +315,7 @@ function vtkCellPicker(publicAPI, model) {
     }
     return tMin;
   };
-  publicAPI.intersectActorWithLine = (p1, p2, t1, t2, tol, mapper) => {
+  model.intersectActorWithLine = (p1, p2, t1, t2, tolerance, mapper) => {
     let tMin = Number.MAX_VALUE;
     const minXYZ = [0, 0, 0];
     let pDistMin = Number.MAX_VALUE;
@@ -368,9 +368,9 @@ function vtkCellPicker(publicAPI, model) {
         let cellPicked;
         {
           if (vtkCellTypes.hasSubCells(minCellType)) {
-            cellPicked = cell.intersectWithLine(t1, t2, p1, p2, tol, x, pCoords);
+            cellPicked = cell.intersectWithLine(t1, t2, p1, p2, tolerance, x, pCoords);
           } else {
-            cellPicked = cell.intersectWithLine(p1, p2, tol, x, pCoords);
+            cellPicked = cell.intersectWithLine(p1, p2, tolerance, x, pCoords);
           }
         }
         if (cellPicked.intersect === 1 && cellPicked.t <= tMin + model.tolerance && cellPicked.t >= t1 && cellPicked.t <= t2) {

package/Rendering/Core/Picker.d.ts

@@ -2,6 +2,7 @@ import { Vector3, Nullable } from './../../types';
 import vtkAbstractPicker, { IAbstractPickerInitialValues } from './AbstractPicker';
 import vtkActor from './Actor';
 import vtkMapper from './Mapper';
+import vtkProp3D from './Prop3D';
 import vtkRenderer from './Renderer';
 import { vtkSubscription } from './../../interfaces';
 
@@ -67,16 +68,6 @@ export interface vtkPicker extends vtkAbstractPicker {
 	 */
 	onPickChange(callback: OnPickChangeCallback): vtkSubscription;
 
-	/**
-	 * Intersect data with specified ray.
-	 * Project the center point of the mapper onto the ray and determine its parametric value
-	 * @param {Vector3} p1 
-	 * @param {Vector3} p2 
-	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper 
-	 */
-	intersectWithLine(p1: Vector3, p2: Vector3, tol: number, mapper: vtkMapper): number;
-
 	/**
 	 * Perform pick operation with selection point provided.
 	 * @param {Vector3} selection First two values should be x-y pixel coordinate, the third is usually zero.
@@ -84,6 +75,15 @@ export interface vtkPicker extends vtkAbstractPicker {
 	 */
 	pick(selection: Vector3, renderer: vtkRenderer): void;
 
+	/**
+	 * Perform pick operation with the provided selection and focal points.
+	 * Both point are in world coordinates.
+	 * @param {Vector3} selectionPoint
+	 * @param {Vector3} focalPoint
+	 * @param {vtkRenderer} renderer
+	 */
+	pick3DPoint(selectionPoint: Vector3, focalPoint: Vector3, renderer: vtkRenderer): void;
+
 	/**
 	 * Set position in mapper coordinates of pick point.
 	 * @param {Number} x The x coordinate.
@@ -141,6 +141,8 @@ export function newInstance(initialValues?: IPickerInitialValues): vtkPicker;
  * picking of points or cells based on the geometry of any vtkProp3D, use the
  * subclasses vtkPointPicker or vtkCellPicker.  For hardware-accelerated
  * picking of any type of vtkProp, use vtkPropPicker or vtkWorldPointPicker.
+ *
+ * Note that only vtkProp3D's can be picked by vtkPicker.
  */
 export declare const vtkPicker: {
 	newInstance: typeof newInstance,