@kitware/vtk.js 29.1.2 → 29.1.3

package/Common/DataModel/BoundingBox.d.ts

@@ -202,7 +202,7 @@ export function getMaxPoint(bounds: Bounds): Vector3;
 export function getCorners(bounds: Bounds, corners: Vector3[]): Vector3[];
 
 /**
- * Computes the two corner poitns with min and max coords.
+ * Computes the two corner points with min and max coords.
  * @param {Bounds} bounds
  * @param {Vector3} point1
  * @param {Vector3} point2
@@ -502,7 +502,7 @@ declare class BoundingBox {
   getCorners(bounds: Bounds, corners: Vector3[]): Vector3[];
 
   /**
-   * Computes the two corner poitns with min and max coords.
+   * Computes the two corner points with min and max coords.
    * @param {Bounds} bounds
    * @param {Vector3} point1
    * @param {Vector3} point2

package/Common/DataModel/BoundingBox.js

@@ -210,7 +210,7 @@ function getCorners(bounds, corners) {
   return corners;
 }
 
-// Computes the two corners with minimal and miximal coordinates
+// Computes the two corners with minimal and maximal coordinates
 function computeCornerPoints(bounds, point1, point2) {
   point1[0] = bounds[0];
   point1[1] = bounds[2];
@@ -318,7 +318,7 @@ function intersectBox(bounds, origin, dir, coord, tolerance) {
     }
   }
 
-  // Check for valie intersection along line
+  // Check for value intersection along line
   if (maxT[whichPlane] > 1.0 || maxT[whichPlane] < 0.0) {
     return 0;
   }

package/Common/DataModel/Box.d.ts

@@ -6,6 +6,11 @@ export interface IBoxInitialValues {
     bbox?: Bounds;
 }
 
+export interface IBoxIntersections {
+    t1, t2: number;
+    x1, x2: Vector3;
+  }
+  
 export interface vtkBox extends vtkObject {
 
     /**
@@ -26,6 +31,16 @@ export interface vtkBox extends vtkObject {
      */
     evaluateFunction(x: Vector3): number;
 
+    /**
+     * Intersect box with line and return the parametric values and points of the two intercepts
+     * @param bounds 
+     * @param p1 
+     * @param p2 
+     * returns @object IBoxIntersections {t1, t2, x1, x2} object containing the t1, t2 parametric values and
+     * x1, x2 coordinates of the line intercept points in the bounding box or undefined
+     */
+    intersectWithLine(p1: Vector3, p2: Vector3) : IBoxIntersections | undefined;
+
     /**
      * 
 	 * @param {Number} x The x coordinate.
@@ -61,6 +76,12 @@ export function extend(publicAPI: object, model: object, initialValues?: IBoxIni
  */
 export function newInstance(initialValues?: IBoxInitialValues): vtkBox;
 
+//------------------------------------------------------------------------------
+// Bounding box intersection code from David Gobbi.  Go through the
+// bounding planes one at a time and compute the parametric coordinate
+// of each intersection and return the parametric values and the calculated points
+export function intersectWithLine(bounds, p1, p2): IBoxIntersections | undefined;
+
 /**
  * vtkBox provides methods for creating a 1D cubic spline object from given
  * parameters, and allows for the calculation of the spline value and derivative
@@ -68,6 +89,7 @@ export function newInstance(initialValues?: IBoxInitialValues): vtkBox;
  */
 export declare const vtkBox: {
 	newInstance: typeof newInstance,
-	extend: typeof extend
+	extend: typeof extend,
+    intersectWithLine: typeof intersectWithLine
 };
 export default vtkBox;

package/Common/DataModel/Box.js

@@ -5,6 +5,88 @@ import vtkBoundingBox from './BoundingBox.js';
 // Global methods
 // ----------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+// Bounding box intersection code from David Gobbi.  Go through the
+// bounding planes one at a time and compute the parametric coordinate
+// of each intersection and return the parametric values and the calculated points
+function intersectWithLine(bounds, p1, p2) {
+  let plane1 = -1;
+  let plane2 = -1;
+  let t1 = 0.0;
+  let t2 = 1.0;
+  for (let j = 0; j < 3; j++) {
+    for (let k = 0; k < 2; k++) {
+      // Compute distances of p1 and p2 from the plane along the plane normal
+      const i = 2 * j + k;
+      const d1 = (bounds[i] - p1[j]) * (1 - 2 * k);
+      const d2 = (bounds[i] - p2[j]) * (1 - 2 * k);
+
+      // If both distances are positive, both points are outside
+      if (d1 > 0 && d2 > 0) {
+        return;
+      }
+      // If one of the distances is positive, the line crosses the plane
+      if (d1 > 0 || d2 > 0) {
+        // Compute fractional distance "t" of the crossing between p1 & p2
+        let t = 0.0;
+        if (d1 !== 0) {
+          t = d1 / (d1 - d2);
+        }
+
+        // If point p1 was clipped, adjust t1
+        if (d1 > 0) {
+          if (t >= t1) {
+            t1 = t;
+            plane1 = i;
+          }
+        }
+        // else point p2 was clipped, so adjust t2
+        else if (t <= t2) {
+          t2 = t;
+          plane2 = i;
+        }
+        // If this happens, there's no line left
+        if (t1 > t2) {
+          // Allow for planes that are coincident or slightly inverted
+          if (plane1 < 0 || plane2 < 0) {
+            return;
+          }
+        }
+      }
+    }
+  }
+  function getValues(plane, t) {
+    const x = [0, 0, 0];
+    for (let count = 0; count < 2; count++) {
+      for (let i = 0; i < 3; i++) {
+        if (plane === 2 * i || plane === 2 * i + 1) {
+          x[i] = bounds[plane];
+        } else {
+          x[i] = p1[i] * (1.0 - t) + p2[i] * t;
+          if (x[i] < bounds[2 * i]) {
+            x[i] = bounds[2 * i];
+          }
+          if (x[i] > bounds[2 * i + 1]) {
+            x[i] = bounds[2 * i + 1];
+          }
+        }
+      }
+    }
+    return x;
+  }
+  const x1 = getValues(plane1, t1);
+  const x2 = getValues(plane2, t2);
+  const outObject = {
+    t1,
+    t2,
+    x1,
+    x2
+  };
+
+  // eslint-disable-next-line consistent-return
+  return outObject;
+}
+
 // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
@@ -14,7 +96,6 @@ const STATIC = {};
 // ----------------------------------------------------------------------------
 // vtkBox methods
 // ----------------------------------------------------------------------------
-
 function vtkBox(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkBox');
@@ -67,7 +148,7 @@ function vtkBox(publicAPI, model) {
             dist = point[i] - maxPoint[i];
           }
           if (dist > minDistance) {
-            // remember, it's engative
+            // remember, it's negative
             minDistance = dist;
           }
         } // end if inside
@@ -103,6 +184,7 @@ function vtkBox(publicAPI, model) {
     publicAPI.modified();
   };
   publicAPI.addBox = other => publicAPI.addBounds(other.getBounds());
+  publicAPI.intersectWithLine = (p1, p2) => intersectWithLine(model.bbox, p1, p2);
 }
 
 // ----------------------------------------------------------------------------
@@ -133,7 +215,8 @@ const newInstance = macro.newInstance(extend, 'vtkBox');
 var vtkBox$1 = {
   newInstance,
   extend,
+  intersectWithLine,
   ...STATIC
 };
 
-export { STATIC, vtkBox$1 as default, extend, newInstance };
+export { STATIC, vtkBox$1 as default, extend, intersectWithLine, newInstance };

package/Rendering/Core/CellPicker.js

@@ -5,10 +5,11 @@ import vtkPicker from './Picker.js';
 import vtkPolyLine from '../../Common/DataModel/PolyLine.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
 import vtkQuad from '../../Common/DataModel/Quad.js';
-import { l as normalize, G as isIdentity3x3 } from '../../Common/Core/Math/index.js';
+import { l as normalize, G as isIdentity3x3, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import { CellType } from '../../Common/DataModel/CellTypes/Constants.js';
 import { vec3, vec4 } from 'gl-matrix';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
+import vtkBox from '../../Common/DataModel/Box.js';
 
 // ----------------------------------------------------------------------------
 // Global methods
@@ -159,8 +160,8 @@ function vtkCellPicker(publicAPI, model) {
   };
   publicAPI.intersectWithLine = (p1, p2, tol, actor, mapper) => {
     let tMin = Number.MAX_VALUE;
-    const t1 = 0.0;
-    const t2 = 1.0;
+    let t1 = 0.0;
+    let t2 = 1.0;
     const vtkCellPickerPlaneTol = 1e-14;
     const clipLine = clipLineWithPlane(mapper, model.transformMatrix, p1, p2);
     if (mapper && !clipLine.intersect) {
@@ -174,7 +175,13 @@ function vtkCellPicker(publicAPI, model) {
         model.pCoords = pickData.pCoords;
       }
     } else if (mapper.isA('vtkVolumeMapper')) {
-      tMin = publicAPI.intersectVolumeWithLine(p1, p2, clipLine.t1, clipLine.t2, tol, actor);
+      // 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
+      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);
     } else if (mapper.isA('vtkMapper')) {
       tMin = publicAPI.intersectActorWithLine(p1, p2, t1, t2, tol, mapper);
     }
@@ -255,16 +262,19 @@ function vtkCellPicker(publicAPI, model) {
     const x1 = [0, 0, 0];
     const x2 = [0, 0, 0];
     for (let i = 0; i < 3; i++) {
-      x1[i] = (p1[i] - origin[i]) / spacing[i];
-      x2[i] = (p2[i] - origin[i]) / spacing[i];
+      x1[i] = (q1[i] - origin[i]) / spacing[i];
+      x2[i] = (q2[i] - origin[i]) / spacing[i];
     }
     const x = [0, 0, 0, 0];
     const xi = [0, 0, 0];
     const sliceSize = dims[1] * dims[0];
     const rowSize = dims[0];
-    const nSteps = 100;
+    // here the step is the 1 over the distance between volume index location x1 and x2
+    const step = 1 / Math.sqrt(distance2BetweenPoints(x1, x2));
     let insideVolume;
-    for (let t = t1; t < t2; t += 1 / nSteps) {
+    // here we reinterpret the t value as the distance between x1 and x2
+    // When calculating the tMin, we weight t between t1 and t2 values
+    for (let t = 0; t < 1; t += step) {
       // calculate the location of the point
       insideVolume = true;
       for (let j = 0; j < 3; j++) {
@@ -297,7 +307,8 @@ function vtkCellPicker(publicAPI, model) {
         value = Math.floor((value - oRange[0]) * scale);
         const opacity = tmpTable[value];
         if (opacity > model.opacityThreshold) {
-          tMin = t;
+          // returning the tMin to the original scale, if t1 > 0 or t2 < 1
+          tMin = t1 * (1.0 - t) + t2 * t;
           break;
         }
       }

package/package.json

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