@kitware/vtk.js 29.11.1 → 30.0.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/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,

package/Rendering/Core/Picker.js

@@ -1,8 +1,8 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractPicker from './AbstractPicker.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { d as dot, l as normalize, n as norm, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
-import { mat4, vec4 } from 'gl-matrix';
+import { d as dot, l as normalize, s as subtract, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { vec3, mat4, vec4 } from 'gl-matrix';
 
 const {
   vtkErrorMacro
@@ -62,17 +62,114 @@ function vtkPicker(publicAPI, model) {
     return Math.sqrt(tolerance);
   }
 
+  /**
+   * Perform picking on the given renderer, given a ray defined in world coordinates.
+   * @param {*} renderer
+   * @param {*} tolerance
+   * @param {*} p1World
+   * @param {*} p2World
+   * @returns true if we picked something else false
+   */
+  function pick3DInternal(renderer, tolerance, p1World, p2World) {
+    const p1Mapper = new Float64Array(4);
+    const p2Mapper = new Float64Array(4);
+    const ray = [];
+    const hitPosition = [];
+    const props = model.pickFromList ? model.pickList : renderer.getActors();
+
+    // pre-allocate some arrays.
+    const transformScale = new Float64Array(3);
+    const pickedPosition = new Float64Array(3);
+
+    // Loop over props.
+    // Transform ray (defined from position of camera to selection point) into coordinates of mapper (not
+    // transformed to actors coordinates!  Reduces overall computation!!!).
+    // Note that only vtkProp3D's can be picked by vtkPicker.
+    props.forEach(prop => {
+      const mapper = prop.getMapper();
+      const propIsNotFullyTranslucent = prop.getProperty?.()?.getOpacity() > 0.0;
+      const pickable = prop.getNestedPickable() && prop.getNestedVisibility() && propIsNotFullyTranslucent;
+      if (!pickable) {
+        // prop cannot be picked
+        return;
+      }
+
+      // The prop is candidate for picking:
+      // - get its composite matrix and invert it
+      // - use the inverted matrix to transform the ray points into mapper coordinates
+      model.transformMatrix = prop.getMatrix().slice(0);
+      mat4.transpose(model.transformMatrix, model.transformMatrix);
+      mat4.invert(model.transformMatrix, model.transformMatrix);
+      vec4.transformMat4(p1Mapper, p1World, model.transformMatrix);
+      vec4.transformMat4(p2Mapper, p2World, model.transformMatrix);
+      vec3.scale(p1Mapper, p1Mapper, 1 / p1Mapper[3]);
+      vec3.scale(p2Mapper, p2Mapper, 1 / p2Mapper[3]);
+      subtract(p2Mapper, p1Mapper, ray);
+
+      // We now have the ray endpoints in mapper coordinates.
+      // Compare it with the mapper bounds to check if intersection is possible.
+
+      // Get the bounding box of the mapper.
+      // Note that the tolerance is added to the bounding box to make sure things on the edge of the
+      // bounding box are picked correctly.
+      const bounds = mapper ? vtkBoundingBox.inflate(mapper.getBounds(), tolerance) : [...vtkBoundingBox.INIT_BOUNDS];
+      if (vtkBoundingBox.intersectBox(bounds, p1Mapper, ray, hitPosition, [])) {
+        mat4.getScaling(transformScale, model.transformMatrix);
+        const t = model.intersectWithLine(p1Mapper, p2Mapper, tolerance * 0.333 * (transformScale[0] + transformScale[1] + transformScale[2]), prop, mapper);
+        if (t < Number.MAX_VALUE) {
+          pickedPosition[0] = (1.0 - t) * p1World[0] + t * p2World[0];
+          pickedPosition[1] = (1.0 - t) * p1World[1] + t * p2World[1];
+          pickedPosition[2] = (1.0 - t) * p1World[2] + t * p2World[2];
+          const actorIndex = model.actors.indexOf(prop);
+          if (actorIndex !== -1) {
+            // If already in list, compare the previous picked position with the new one.
+            // Store the new one if it is closer from the ray endpoint.
+            const previousPickedPosition = model.pickedPositions[actorIndex];
+            if (distance2BetweenPoints(p1World, pickedPosition) < distance2BetweenPoints(p1World, previousPickedPosition)) {
+              model.pickedPositions[actorIndex] = pickedPosition.slice(0);
+            }
+          } else {
+            model.actors.push(prop);
+            model.pickedPositions.push(pickedPosition.slice(0));
+          }
+        }
+      }
+    });
+
+    // sort array by distance
+    const tempArray = [];
+    for (let i = 0; i < model.pickedPositions.length; i++) {
+      tempArray.push({
+        actor: model.actors[i],
+        pickedPosition: model.pickedPositions[i],
+        distance2: distance2BetweenPoints(p1World, model.pickedPositions[i])
+      });
+    }
+    tempArray.sort((a, b) => {
+      const keyA = a.distance2;
+      const keyB = b.distance2;
+      // order the actors based on the distance2 attribute, so the near actors comes
+      // first in the list
+      if (keyA < keyB) return -1;
+      if (keyA > keyB) return 1;
+      return 0;
+    });
+    model.pickedPositions = [];
+    model.actors = [];
+    tempArray.forEach(obj => {
+      model.pickedPositions.push(obj.pickedPosition);
+      model.actors.push(obj.actor);
+    });
+  }
+
   // Intersect data with specified ray.
   // Project the center point of the mapper onto the ray and determine its parametric value
-  publicAPI.intersectWithLine = (p1, p2, tol, mapper) => {
+  model.intersectWithLine = (p1, p2, tolerance, prop, mapper) => {
     if (!mapper) {
       return Number.MAX_VALUE;
     }
     const center = mapper.getCenter();
-    const ray = [];
-    for (let i = 0; i < 3; i++) {
-      ray[i] = p2[i] - p1[i];
-    }
+    const ray = vec3.subtract(new Float64Array(3), p2, p1);
     const rayFactor = dot(ray, ray);
     if (rayFactor === 0.0) {
       return 2.0;
@@ -86,55 +183,43 @@ function vtkPicker(publicAPI, model) {
   // To be overridden in subclasses
   publicAPI.pick = (selection, renderer) => {
     if (selection.length !== 3) {
-      vtkWarningMacro('vtkPicker::pick: selectionPt needs three components');
+      vtkWarningMacro('vtkPicker.pick - selection needs three components');
     }
+    if (!renderer) {
+      vtkErrorMacro('vtkPicker.pick - renderer cannot be null');
+      throw new Error('renderer cannot be null');
+    }
+    initialize();
     const selectionX = selection[0];
     const selectionY = selection[1];
     let selectionZ = selection[2];
-    let cameraPos = [];
-    let cameraFP = [];
-    let displayCoords = [];
-    let worldCoords = [];
-    const ray = [];
-    const cameraDOP = [];
-    let clipRange = [];
-    let tF;
-    let tB;
-    const p1World = [];
-    const p2World = [];
-    let props = [];
-    let pickable = false;
-    const p1Mapper = new Float64Array(4);
-    const p2Mapper = new Float64Array(4);
-    const bbox = vtkBoundingBox.newInstance();
-    const t = [];
-    const hitPosition = [];
-    const view = renderer.getRenderWindow().getViews()[0];
-    initialize();
     model.renderer = renderer;
     model.selectionPoint[0] = selectionX;
     model.selectionPoint[1] = selectionY;
     model.selectionPoint[2] = selectionZ;
-    if (!renderer) {
-      vtkErrorMacro('Picker::Pick Must specify renderer');
-      return;
-    }
+    const p1World = new Float64Array(4);
+    const p2World = new Float64Array(4);
 
     // Get camera focal point and position. Convert to display (screen)
     // coordinates. We need a depth value for z-buffer.
     const camera = renderer.getActiveCamera();
-    cameraPos = camera.getPosition();
-    cameraFP = camera.getFocalPoint();
+    const cameraPos = camera.getPosition();
+    const cameraFP = camera.getFocalPoint();
+    const view = renderer.getRenderWindow().getViews()[0];
     const dims = view.getViewportSize(renderer);
+    if (dims[1] === 0) {
+      vtkWarningMacro('vtkPicker.pick - viewport area is 0');
+      return;
+    }
     const aspect = dims[0] / dims[1];
+    let displayCoords = [];
     displayCoords = renderer.worldToNormalizedDisplay(cameraFP[0], cameraFP[1], cameraFP[2], aspect);
     displayCoords = view.normalizedDisplayToDisplay(displayCoords[0], displayCoords[1], displayCoords[2]);
     selectionZ = displayCoords[2];
-    const tolerance = computeTolerance(selectionZ, aspect, renderer) * model.tolerance;
 
     // Convert the selection point into world coordinates.
     const normalizedDisplay = view.displayToNormalizedDisplay(selectionX, selectionY, selectionZ);
-    worldCoords = renderer.normalizedDisplayToWorld(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2], aspect);
+    const worldCoords = renderer.normalizedDisplayToWorld(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2], aspect);
     for (let i = 0; i < 3; i++) {
       model.pickPosition[i] = worldCoords[i];
     }
@@ -143,9 +228,11 @@ function vtkPicker(publicAPI, model) {
     //  the camera position to the selection point, starting where this line
     //  intersects the front clipping plane, and terminating where this
     //  line intersects the back clipping plane.
+    const ray = [];
     for (let i = 0; i < 3; i++) {
       ray[i] = model.pickPosition[i] - cameraPos[i];
     }
+    const cameraDOP = [];
     for (let i = 0; i < 3; i++) {
       cameraDOP[i] = cameraFP[i] - cameraPos[i];
     }
@@ -155,7 +242,9 @@ function vtkPicker(publicAPI, model) {
       vtkWarningMacro('Picker::Pick Cannot process points');
       return;
     }
-    clipRange = camera.getClippingRange();
+    const clipRange = camera.getClippingRange();
+    let tF;
+    let tB;
     if (camera.getParallelProjection()) {
       tF = clipRange[0] - rayLength;
       tB = clipRange[1] - rayLength;
@@ -173,105 +262,25 @@ function vtkPicker(publicAPI, model) {
     }
     p1World[3] = 1.0;
     p2World[3] = 1.0;
-    if (model.pickFromList) {
-      props = model.pickList;
-    } else {
-      props = renderer.getActors();
+    const tolerance = computeTolerance(selectionZ, aspect, renderer) * model.tolerance;
+    pick3DInternal(model.renderer, tolerance, p1World, p2World);
+  };
+  publicAPI.pick3DPoint = (selectionPoint, focalPoint, renderer) => {
+    if (!renderer) {
+      throw new Error('renderer cannot be null');
     }
-    const scale = [];
-    props.forEach(prop => {
-      const mapper = prop.getMapper();
-      pickable = prop.getNestedPickable() && prop.getNestedVisibility();
-      if (prop.getProperty().getOpacity?.() <= 0.0) {
-        pickable = false;
-      }
-      if (pickable) {
-        model.transformMatrix = prop.getMatrix().slice(0);
-        // Webgl need a transpose matrix but we need the untransposed one to project world points
-        // into the right referential
-        mat4.transpose(model.transformMatrix, model.transformMatrix);
-        mat4.invert(model.transformMatrix, model.transformMatrix);
-        // Extract scale
-        const col1 = [model.transformMatrix[0], model.transformMatrix[1], model.transformMatrix[2]];
-        const col2 = [model.transformMatrix[4], model.transformMatrix[5], model.transformMatrix[6]];
-        const col3 = [model.transformMatrix[8], model.transformMatrix[9], model.transformMatrix[10]];
-        scale[0] = norm(col1);
-        scale[1] = norm(col2);
-        scale[2] = norm(col3);
-        vec4.transformMat4(p1Mapper, p1World, model.transformMatrix);
-        vec4.transformMat4(p2Mapper, p2World, model.transformMatrix);
-        p1Mapper[0] /= p1Mapper[3];
-        p1Mapper[1] /= p1Mapper[3];
-        p1Mapper[2] /= p1Mapper[3];
-        p2Mapper[0] /= p2Mapper[3];
-        p2Mapper[1] /= p2Mapper[3];
-        p2Mapper[2] /= p2Mapper[3];
-        for (let i = 0; i < 3; i++) {
-          ray[i] = p2Mapper[i] - p1Mapper[i];
-        }
-        if (mapper) {
-          bbox.setBounds(mapper.getBounds());
-          bbox.inflate(tolerance);
-        } else {
-          bbox.reset();
-        }
-        if (bbox.intersectBox(p1Mapper, ray, hitPosition, t)) {
-          t[0] = publicAPI.intersectWithLine(p1Mapper, p2Mapper, tolerance * 0.333 * (scale[0] + scale[1] + scale[2]), prop, mapper);
-          if (t[0] < Number.MAX_VALUE) {
-            const p = [];
-            p[0] = (1.0 - t[0]) * p1World[0] + t[0] * p2World[0];
-            p[1] = (1.0 - t[0]) * p1World[1] + t[0] * p2World[1];
-            p[2] = (1.0 - t[0]) * p1World[2] + t[0] * p2World[2];
-
-            // Check if the current actor is already in the list
-            let actorID = -1;
-            for (let i = 0; i < model.actors.length; i++) {
-              if (model.actors[i] === prop) {
-                actorID = i;
-                break;
-              }
-            }
-            if (actorID === -1) {
-              model.actors.push(prop);
-              model.pickedPositions.push(p);
-            } else {
-              const oldPoint = model.pickedPositions[actorID];
-              const distOld = distance2BetweenPoints(p1World, oldPoint);
-              const distCurrent = distance2BetweenPoints(p1World, p);
-              if (distCurrent < distOld) {
-                model.pickedPositions[actorID] = p;
-              }
-            }
-          }
-        }
-      }
-      publicAPI.invokePickChange(model.pickedPositions);
-      return 1;
-    });
-    // sort array by distance
-    const tempArray = [];
-    for (let i = 0; i < model.pickedPositions.length; i++) {
-      tempArray.push({
-        actor: model.actors[i],
-        pickedPosition: model.pickedPositions[i],
-        distance2: distance2BetweenPoints(p1World, model.pickedPositions[i])
-      });
+    initialize();
+    model.renderer = renderer;
+    vec3.copy(model.selectionPoint, selectionPoint);
+    const view = renderer.getRenderWindow().getViews()[0];
+    const dims = view.getViewportSize(renderer);
+    if (dims[1] === 0) {
+      vtkWarningMacro('vtkPicker.pick3DPoint - viewport area is 0');
+      return;
     }
-    tempArray.sort((a, b) => {
-      const keyA = a.distance2;
-      const keyB = b.distance2;
-      // order the actors based on the distance2 attribute, so the near actors comes
-      // first in the list
-      if (keyA < keyB) return -1;
-      if (keyA > keyB) return 1;
-      return 0;
-    });
-    model.pickedPositions = [];
-    model.actors = [];
-    tempArray.forEach(obj => {
-      model.pickedPositions.push(obj.pickedPosition);
-      model.actors.push(obj.actor);
-    });
+    const aspect = dims[0] / dims[1];
+    const tolerance = computeTolerance(model.selectionPoint[2], aspect, renderer) * model.tolerance;
+    pick3DInternal(renderer, tolerance, selectionPoint, focalPoint);
   };
 }
 

package/Rendering/Core/PointPicker.d.ts

@@ -1,6 +1,8 @@
 import vtkPicker, { IPickerInitialValues } from './Picker';
 import vtkMapper from './Mapper';
 import { Vector3 } from './../../types';
+import vtkProp3D from './Prop3D';
+import { Nullable } from './../../types';
 
 interface IPointPickerInitialValues extends IPickerInitialValues {
 	pointId?: number;
@@ -31,24 +33,6 @@ export interface vtkPointPicker extends vtkPicker {
 	 */
 	getUseCells(): boolean;
 
-	/**
-	 * 
-	 * @param {Vector3} p1 
-	 * @param {Vector3} p2 
-	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper 
-	 */
-	intersectWithLine(p1: Vector3, p2: Vector3, tol: number, mapper: vtkMapper): number;
-
-	/**
-	 * 
-	 * @param {Vector3} p1 
-	 * @param {Vector3} p2 
-	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper 
-	 */
-	intersectActorWithLine(p1: Vector3, p2: Vector3, tol: number, mapper: vtkMapper): number;
-
 	/**
 	 * Specify whether the point search should be based on cell points or directly on the point list.
 	 * @param useCells 

package/Rendering/Core/PointPicker.js

@@ -13,7 +13,7 @@ const {
 function vtkPointPicker(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPointPicker');
-  publicAPI.intersectWithLine = (p1, p2, tol, actor, mapper) => {
+  model.intersectWithLine = (p1, p2, tolerance, prop, mapper) => {
     let tMin = Number.MAX_VALUE;
     if (mapper.isA('vtkImageMapper') || mapper.isA('vtkImageArrayMapper')) {
       const pickData = mapper.intersectWithLineForPointPicking(p1, p2);
@@ -22,11 +22,11 @@ function vtkPointPicker(publicAPI, model) {
         model.pointIJK = pickData.ijk;
       }
     } else if (mapper.isA('vtkMapper')) {
-      tMin = publicAPI.intersectActorWithLine(p1, p2, tol, mapper);
+      tMin = model.intersectActorWithLine(p1, p2, tolerance, mapper);
     }
     return tMin;
   };
-  publicAPI.intersectActorWithLine = (p1, p2, tol, mapper) => {
+  model.intersectActorWithLine = (p1, p2, tolerance, mapper) => {
     // Get dataset
     const input = mapper.getInputData();
 
@@ -77,7 +77,7 @@ function vtkPointPicker(publicAPI, model) {
                 maxDist = dist;
               }
             } // end for i
-            if (maxDist <= tol && maxDist < minPtDist) {
+            if (maxDist <= tolerance && maxDist < minPtDist) {
               // within tolerance
               minPtId = ptId;
               minPtDist = maxDist;
@@ -105,7 +105,7 @@ function vtkPointPicker(publicAPI, model) {
               maxDist = dist;
             }
           } // end for i
-          if (maxDist <= tol && maxDist < minPtDist) {
+          if (maxDist <= tolerance && maxDist < minPtDist) {
             // within tolerance
             minPtId = ptId;
             minPtDist = maxDist;

package/Rendering/Core/VolumeMapper.d.ts

@@ -1,12 +1,12 @@
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { Bounds, Range } from './../../types';
-import vtkAbstractMapper, { IAbstractMapperInitialValues } from './AbstractMapper';
+import vtkAbstractMapper3D, { IAbstractMapper3DInitialValues } from './AbstractMapper3D';
 import { BlendMode, FilterMode } from './VolumeMapper/Constants';
 
 /**
  *
  */
-export interface IVolumeMapperInitialValues extends IAbstractMapperInitialValues {
+export interface IVolumeMapperInitialValues extends IAbstractMapper3DInitialValues {
 	anisotropy?: number;
 	autoAdjustSampleDistances?: boolean;
 	averageIPScalarRange?: Range;
@@ -23,7 +23,7 @@ export interface IVolumeMapperInitialValues extends IAbstractMapperInitialValues
 	LAOKernelSize?: number;
 }
 
-export interface vtkVolumeMapper extends vtkAbstractMapper {
+export interface vtkVolumeMapper extends vtkAbstractMapper3D {
 
 	/**
      * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -487,7 +487,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     // weighting shift and scale
     `uniform float pwfshift0;`, `uniform float pwfscale0;`];
     if (useProjection) {
-      tcoordFSDec.push('uniform vec3 spacing;', 'uniform int projectionSlabNumberOfSamples;', 'uniform float projectionConstantOffset;', 'uniform float projectionStepLength;');
+      tcoordFSDec.push('uniform vec3 volumeSizeMC;', 'uniform int projectionSlabNumberOfSamples;', 'uniform float projectionConstantOffset;', 'uniform float projectionStepLength;');
     }
     if (isDirectionUniform) {
       tcoordFSDec.push('in vec3 samplingDirVSOutput;');
@@ -571,7 +571,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       }
 
       // Loop on all the samples of the projection
-      tcoordFSImpl.push('vec3 projectionScaledDirection = projectionDirection / spacing;', 'vec3 projectionStep = projectionStepLength * projectionScaledDirection;', 'vec3 projectionStartPosition = volumePosTC + projectionConstantOffset * projectionScaledDirection;', 'vec4 tvalue = initialProjectionTextureValue;', 'for (int projectionSampleIdx = 0; projectionSampleIdx < projectionSlabNumberOfSamples; ++projectionSampleIdx) {', '  vec3 projectionSamplePosition = projectionStartPosition + float(projectionSampleIdx) * projectionStep;', '  vec4 sampledTextureValue = texture(volumeTexture, projectionSamplePosition);');
+      tcoordFSImpl.push('vec3 projectionScaledDirection = projectionDirection / volumeSizeMC;', 'vec3 projectionStep = projectionStepLength * projectionScaledDirection;', 'vec3 projectionStartPosition = volumePosTC + projectionConstantOffset * projectionScaledDirection;', 'vec4 tvalue = initialProjectionTextureValue;', 'for (int projectionSampleIdx = 0; projectionSampleIdx < projectionSlabNumberOfSamples; ++projectionSampleIdx) {', '  vec3 projectionSamplePosition = projectionStartPosition + float(projectionSampleIdx) * projectionStep;', '  vec4 sampledTextureValue = texture(volumeTexture, projectionSamplePosition);');
       switch (projectionMode) {
         case ProjectionMode.MAX:
           tcoordFSImpl.push('  tvalue = max(tvalue, sampledTextureValue);');
@@ -706,9 +706,11 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (model.renderable.isProjectionEnabled()) {
       const image = model.currentImageDataInput;
       const spacing = image.getSpacing();
+      const dimensions = image.getDimensions();
       const projectionSlabThickness = model.renderable.getProjectionSlabThickness();
       const projectionSlabNumberOfSamples = model.renderable.getProjectionSlabNumberOfSamples();
-      program.setUniform3fArray('spacing', spacing);
+      const volumeSize = vec3.mul([], spacing, dimensions);
+      program.setUniform3fArray('volumeSizeMC', volumeSize);
       program.setUniformi('projectionSlabNumberOfSamples', projectionSlabNumberOfSamples);
       const constantOffset = -0.5 * projectionSlabThickness;
       program.setUniformf('projectionConstantOffset', constantOffset);

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.d.ts

@@ -1,5 +1,4 @@
 import vtkAbstractWidget from '../../Core/AbstractWidget';
 
 export default interface vtkResliceCursorWidgetDefaultInstance extends vtkAbstractWidget {
-    invokeInternalInteractionEvent: () => void;
 }

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -135,7 +135,7 @@ function widgetBehavior(publicAPI, model) {
         const step = previousPosition.y - callData.position.y;
         publicAPI.translateCenterOnPlaneDirection(step);
         previousPosition = callData.position;
-        publicAPI.invokeInternalInteractionEvent();
+        publicAPI.invokeInteractionEvent(publicAPI.getActiveInteraction());
       }
     }
     return macro.VOID;
@@ -164,7 +164,7 @@ function widgetBehavior(publicAPI, model) {
     const step = calldata.spinY;
     isScrolling = true;
     publicAPI.translateCenterOnPlaneDirection(step);
-    publicAPI.invokeInternalInteractionEvent(
+    publicAPI.invokeInteractionEvent(
     // Force interaction mode because mouse cursor could be above rotation handle
     InteractionMethodsName.TranslateCenter);
     isScrolling = false;
@@ -187,20 +187,11 @@ function widgetBehavior(publicAPI, model) {
     if (model.activeState.getActive()) {
       const methodName = publicAPI.getActiveInteraction();
       publicAPI[methodName](callData);
-      publicAPI.invokeInternalInteractionEvent(methodName);
+      publicAPI.invokeInteractionEvent(methodName);
       return macro.EVENT_ABORT;
     }
     return macro.VOID;
   };
-  publicAPI.invokeInternalInteractionEvent = function () {
-    let methodName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getActiveInteraction();
-    const computeFocalPointOffset = methodName !== InteractionMethodsName.RotateLine;
-    const canUpdateFocalPoint = methodName === InteractionMethodsName.RotateLine;
-    publicAPI.invokeInteractionEvent({
-      computeFocalPointOffset,
-      canUpdateFocalPoint
-    });
-  };
   publicAPI.startInteraction = () => {
     publicAPI.invokeStartInteractionEvent();
     // When interacting, plane actor and lines must be re-rendered on other views

package/Widgets/Widgets3D/ResliceCursorWidget.d.ts

@@ -33,7 +33,6 @@ export interface vtkResliceCursorWidget<WidgetInstance extends vtkAbstractWidget
     renderer: vtkRenderer,
     viewType: ViewTypes,
     resetFocalPoint: boolean,
-    keepCenterFocalDistance: boolean,
     computeFocalPointOffset: boolean
   ): void;
 

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -215,8 +215,8 @@ function vtkResliceCursorWidget(publicAPI, model) {
   // Methods
   // --------------------------------------------------------------------------
 
-  publicAPI.updateCameraPoints = (renderer, viewType, resetFocalPoint, keepCenterFocalDistance, computeFocalPointOffset) => {
-    publicAPI.resetCamera(renderer, viewType, resetFocalPoint, keepCenterFocalDistance);
+  publicAPI.updateCameraPoints = (renderer, viewType, resetFocalPoint, computeFocalPointOffset) => {
+    publicAPI.resetCamera(renderer, viewType, resetFocalPoint, !computeFocalPointOffset);
     if (computeFocalPointOffset) {
       computeFocalPointOffsetFromResliceCursorCenter(viewType, renderer);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "29.11.1",
+  "version": "30.0.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",