fix(interactorstylemprslice): fix getSliceRange when input image has orientation matrix

getBounds() rotates the extent, however it produces new corner points. Those new corner points were
used to compute the slice range along the slice normal . Instead we keep the original extent corner
points to apply the image direction along the slice normal.

Author: finetjul

Sources/Common/DataModel/BoundingBox/index.js

@@ -285,14 +285,14 @@ function oppositeSign(a, b) {
 }
 
 export function getCorners(bounds, corners) {
-  let count = 0;
-  for (let ix = 0; ix < 2; ix++) {
-    for (let iy = 2; iy < 4; iy++) {
-      for (let iz = 4; iz < 6; iz++) {
-        corners[count++] = [bounds[ix], bounds[iy], bounds[iz]];
-      }
-    }
-  }
+  corners[0] = [bounds[0], bounds[2], bounds[4]];
+  corners[1] = [bounds[0], bounds[2], bounds[5]];
+  corners[2] = [bounds[0], bounds[3], bounds[4]];
+  corners[3] = [bounds[0], bounds[3], bounds[5]];
+  corners[4] = [bounds[1], bounds[2], bounds[4]];
+  corners[5] = [bounds[1], bounds[2], bounds[5]];
+  corners[6] = [bounds[1], bounds[3], bounds[4]];
+  corners[7] = [bounds[1], bounds[3], bounds[5]];
   return corners;
 }
 

Sources/Interaction/Style/InteractorStyleMPRSlice/index.js

@@ -1,29 +1,18 @@
 import macro from 'vtk.js/Sources/macros';
 import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
 import vtkMatrixBuilder from 'vtk.js/Sources/Common/Core/MatrixBuilder';
+import vtkBoundingBox from 'vtk.js/Sources/Common/DataModel/BoundingBox';
 import vtkInteractorStyleManipulator from 'vtk.js/Sources/Interaction/Style/InteractorStyleManipulator';
 import vtkMouseCameraTrackballRotateManipulator from 'vtk.js/Sources/Interaction/Manipulators/MouseCameraTrackballRotateManipulator';
 import vtkMouseCameraTrackballPanManipulator from 'vtk.js/Sources/Interaction/Manipulators/MouseCameraTrackballPanManipulator';
 import vtkMouseCameraTrackballZoomManipulator from 'vtk.js/Sources/Interaction/Manipulators/MouseCameraTrackballZoomManipulator';
 import vtkMouseRangeManipulator from 'vtk.js/Sources/Interaction/Manipulators/MouseRangeManipulator';
 
+import { mat4 } from 'gl-matrix';
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
-function boundsToCorners(bounds) {
-  return [
-    [bounds[0], bounds[2], bounds[4]],
-    [bounds[0], bounds[2], bounds[5]],
-    [bounds[0], bounds[3], bounds[4]],
-    [bounds[0], bounds[3], bounds[5]],
-    [bounds[1], bounds[2], bounds[4]],
-    [bounds[1], bounds[2], bounds[5]],
-    [bounds[1], bounds[3], bounds[4]],
-    [bounds[1], bounds[3], bounds[5]],
-  ];
-}
-
 // ----------------------------------------------------------------------------
 
 function clamp(value, min, max) {
@@ -153,14 +142,9 @@ function vtkInteractorStyleMPRSlice(publicAPI, model) {
 
     if (model.volumeMapper) {
       const range = publicAPI.getSliceRange();
-      const bounds = model.volumeMapper.getBounds();
 
       const clampedSlice = clamp(slice, ...range);
-      const center = [
-        (bounds[0] + bounds[1]) / 2.0,
-        (bounds[2] + bounds[3]) / 2.0,
-        (bounds[4] + bounds[5]) / 2.0,
-      ];
+      const center = model.volumeMapper.getCenter();
 
       const distance = camera.getDistance();
       const dop = camera.getDirectionOfProjection();
@@ -193,37 +177,33 @@ function vtkInteractorStyleMPRSlice(publicAPI, model) {
     if (model.volumeMapper) {
       const sliceNormal = publicAPI.getSliceNormal();
 
-      if (
-        sliceNormal[0] === cache.sliceNormal[0] &&
-        sliceNormal[1] === cache.sliceNormal[1] &&
-        sliceNormal[2] === cache.sliceNormal[2]
-      ) {
+      if (vtkMath.areEquals(sliceNormal, cache.sliceNormal)) {
         return cache.sliceRange;
       }
 
-      const bounds = model.volumeMapper.getBounds();
-      const points = boundsToCorners(bounds);
-
       // Get rotation matrix from normal to +X (since bounds is aligned to XYZ)
-      const transform = vtkMatrixBuilder
+      const sliceOrientation = vtkMatrixBuilder
         .buildFromDegree()
         .identity()
         .rotateFromDirections(sliceNormal, [1, 0, 0]);
+      const imageAlongSliceNormal = mat4.create();
+      mat4.multiply(
+        imageAlongSliceNormal,
+        sliceOrientation.getMatrix(),
+        model.volumeMapper.getInputData().getIndexToWorld()
+      );
 
-      points.forEach((pt) => transform.apply(pt));
+      // Transform the 8 corners of the input data's bounding box
+      // to rotate into the slice plane space without the intermediate
+      // axis-aligned box (provided by getBounds) which would grow the bounds.
+      const transformedBounds = vtkBoundingBox.transformBounds(
+        model.volumeMapper.getInputData().getSpatialExtent(),
+        imageAlongSliceNormal
+      );
 
       // range is now maximum X distance
-      let minX = Infinity;
-      let maxX = -Infinity;
-      for (let i = 0; i < 8; i++) {
-        const x = points[i][0];
-        if (x > maxX) {
-          maxX = x;
-        }
-        if (x < minX) {
-          minX = x;
-        }
-      }
+      const minX = transformedBounds[0];
+      const maxX = transformedBounds[1];
 
       cache.sliceNormal = sliceNormal;
       cache.sliceRange = [minX, maxX];