@cornerstonejs/tools 1.42.1 → 1.43.0

package/src/tools/segmentation/strategies/fillCircle.ts

@@ -6,20 +6,20 @@ import {
   getCanvasEllipseCorners,
   precalculatePointInEllipse,
 } from '../../../utilities/math/ellipse';
-import pointInSphere from '../../../utilities/math/sphere/pointInSphere';
-import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
+import { getBoundingBoxAroundShapeIJK } from '../../../utilities/boundingBox';
 import BrushStrategy from './BrushStrategy';
 import type { Composition, InitializedOperationData } from './BrushStrategy';
 import type { CanvasCoordinates } from '../../../types';
 import { StrategyCallbacks } from '../../../enums';
 import compositions from './compositions';
+import { pointInSphere } from '../../../utilities/math/sphere';
 
 const { transformWorldToIndex, isEqual } = csUtils;
 
 const initializeCircle = {
   [StrategyCallbacks.Initialize]: (operationData: InitializedOperationData) => {
     const {
-      points,
+      points, // bottom, top, left, right
       imageVoxelManager: imageVoxelManager,
       viewport,
       segmentationImageData,
@@ -42,6 +42,7 @@ const initializeCircle = {
       segmentationImageData,
       center as Types.Point3
     );
+
     const canvasCoordinates = points.map((p) =>
       viewport.worldToCanvas(p)
     ) as CanvasCoordinates;
@@ -55,17 +56,18 @@ const initializeCircle = {
     const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
     const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
 
-    const ellipsoidCornersIJK = [
-      <Types.Point3>transformWorldToIndex(segmentationImageData, topLeftWorld),
-      <Types.Point3>(
-        transformWorldToIndex(segmentationImageData, bottomRightWorld)
-      ),
-    ];
+    const circleCornersIJK = points.map((world) => {
+      return transformWorldToIndex(segmentationImageData, world);
+    });
 
-    segmentationVoxelManager.boundsIJK = getBoundingBoxAroundShape(
-      ellipsoidCornersIJK,
-      segmentationVoxelManager.dimensions
+    // get the bounds from the circle points since in oblique images the
+    // circle will not be axis aligned
+    const boundsIJK = getBoundingBoxAroundShapeIJK(
+      circleCornersIJK,
+      segmentationImageData.getDimensions()
     );
+
+    segmentationVoxelManager.boundsIJK = boundsIJK;
     imageVoxelManager.isInObject = createPointInEllipse({
       topLeftWorld,
       bottomRightWorld,
@@ -113,9 +115,8 @@ function createPointInEllipse(worldInfo: {
     yRadius,
     zRadius,
   };
-  const inverts = precalculatePointInEllipse(ellipseObj);
-  const { precalculated } = inverts;
 
+  const { precalculated } = precalculatePointInEllipse(ellipseObj, {});
   return precalculated;
 }
 

package/src/tools/segmentation/strategies/fillRectangle.ts

@@ -1,11 +1,15 @@
-import { utilities as csUtils } from '@cornerstonejs/core';
+import { utilities as csUtils, StackViewport } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
-import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
+import {
+  getBoundingBoxAroundShapeIJK,
+  getBoundingBoxAroundShapeWorld,
+} from '../../../utilities/boundingBox';
 import { pointInShapeCallback } from '../../../utilities';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import { LabelmapToolOperationData } from '../../../types';
 import { getStrategyData } from './utils/getStrategyData';
+import { isAxisAlignedRectangle } from '../../../utilities/rectangleROITool/isAxisAlignedRectangle';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -29,6 +33,7 @@ function fillRectangle(
   const { points, segmentsLocked, segmentIndex, segmentationId } =
     operationData;
 
+  const { viewport } = enabledElement;
   const strategyData = getStrategyData({
     operationData,
     viewport: enabledElement.viewport,
@@ -52,13 +57,53 @@ function fillRectangle(
     });
   });
 
-  const boundsIJK = getBoundingBoxAroundShape(
+  const boundsIJK = getBoundingBoxAroundShapeIJK(
     rectangleCornersIJK,
     segmentationImageData.getDimensions()
   );
 
-  // Since always all points inside the boundsIJK is inside the rectangle...
-  const pointInRectangle = () => true;
+  const isStackViewport = viewport instanceof StackViewport;
+
+  // Are we working with 2D rectangle in axis aligned viewport view or not
+  const isAligned =
+    isStackViewport || isAxisAlignedRectangle(rectangleCornersIJK);
+
+  const direction = segmentationImageData.getDirection();
+  const spacing = segmentationImageData.getSpacing();
+  const { viewPlaneNormal } = viewport.getCamera();
+
+  // In case that we are working on oblique, our EPS is really the spacing in the
+  // normal direction, since we can't really test each voxel against a 2D rectangle
+  // we need some tolerance in the normal direction.
+  const EPS = csUtils.getSpacingInNormalDirection(
+    {
+      direction,
+      spacing,
+    },
+    viewPlaneNormal
+  );
+
+  const pointsBoundsLPS = getBoundingBoxAroundShapeWorld(points);
+  let [[xMin, xMax], [yMin, yMax], [zMin, zMax]] = pointsBoundsLPS;
+
+  // Update the bounds with +/- EPS
+  xMin -= EPS;
+  xMax += EPS;
+  yMin -= EPS;
+  yMax += EPS;
+  zMin -= EPS;
+  zMax += EPS;
+
+  const pointInShapeFn = isAligned
+    ? () => true
+    : (pointLPS) => {
+        const [x, y, z] = pointLPS;
+        const xInside = x >= xMin && x <= xMax;
+        const yInside = y >= yMin && y <= yMax;
+        const zInside = z >= zMin && z <= zMax;
+
+        return xInside && yInside && zInside;
+      };
 
   const callback = ({ value, index }) => {
     if (segmentsLocked.includes(value)) {
@@ -70,7 +115,7 @@ function fillRectangle(
 
   pointInShapeCallback(
     segmentationImageData,
-    pointInRectangle,
+    pointInShapeFn,
     callback,
     boundsIJK
   );

package/src/tools/segmentation/strategies/fillSphere.ts

@@ -2,16 +2,13 @@ import type { Types } from '@cornerstonejs/core';
 import { utilities as csUtils } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 
-import { getCanvasEllipseCorners } from '../../../utilities/math/ellipse';
-import { getBoundingBoxAroundShape } from '../../../utilities/boundingBox';
 import BrushStrategy from './BrushStrategy';
 import type { InitializedOperationData, Composition } from './BrushStrategy';
-import type { CanvasCoordinates } from '../../../types';
 import compositions from './compositions';
 import StrategyCallbacks from '../../../enums/StrategyCallbacks';
 import { createEllipseInPoint } from './fillCircle';
 const { transformWorldToIndex } = csUtils;
-
+import { getSphereBoundsInfo } from '../../../utilities/getSphereBoundsInfo';
 const sphereComposition = {
   [StrategyCallbacks.Initialize]: (operationData: InitializedOperationData) => {
     const {
@@ -38,43 +35,18 @@ const sphereComposition = {
       segmentationImageData,
       center as Types.Point3
     );
-    const canvasCoordinates = points.map((p) =>
-      viewport.worldToCanvas(p)
-    ) as CanvasCoordinates;
-
-    // 1. From the drawn tool: Get the ellipse (circle) topLeft and bottomRight
-    // corners in canvas coordinates
-    const [topLeftCanvas, bottomRightCanvas] =
-      getCanvasEllipseCorners(canvasCoordinates);
 
-    // 2. Find the extent of the ellipse (circle) in IJK index space of the image
-    const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
-    const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
-    // This will be 2d, now expand to 3d
-    const diameters = topLeftWorld.map((left, index) =>
-      Math.abs(bottomRightWorld[index] - left)
+    const {
+      boundsIJK: newBoundsIJK,
+      topLeftWorld,
+      bottomRightWorld,
+    } = getSphereBoundsInfo(
+      points.slice(0, 2) as [Types.Point3, Types.Point3],
+      segmentationImageData,
+      viewport
     );
-    const radius = Math.max(...diameters) / 2;
-    // Make 3d sphere
-    topLeftWorld.forEach((left, index) => {
-      const right = bottomRightWorld[index];
-      if (left === right) {
-        topLeftWorld[index] = left - radius;
-        bottomRightWorld[index] = left + radius;
-      }
-    });
 
-    const ellipsoidCornersIJK = [
-      <Types.Point3>transformWorldToIndex(segmentationImageData, topLeftWorld),
-      <Types.Point3>(
-        transformWorldToIndex(segmentationImageData, bottomRightWorld)
-      ),
-    ];
-
-    segmentationVoxelManager.boundsIJK = getBoundingBoxAroundShape(
-      ellipsoidCornersIJK,
-      segmentationVoxelManager.dimensions
-    );
+    segmentationVoxelManager.boundsIJK = newBoundsIJK;
 
     imageVoxelManager.isInObject = createEllipseInPoint({
       topLeftWorld,

package/src/types/LabelmapTypes.ts

@@ -7,10 +7,13 @@ import type { vtkPiecewiseFunction } from '@kitware/vtk.js/Common/DataModel/Piec
 export type LabelmapConfig = {
   /** whether to render segmentation outline  */
   renderOutline?: boolean;
-  /** thickness of the outline when segmentation is active */
+  /** thickness of the outline when segmentation is active - all segments */
   outlineWidthActive?: number;
-  /** thickness of the outline when segmentation is inactive */
+  /** thickness of the outline when segmentation is inactive - all segments */
   outlineWidthInactive?: number;
+  /** delta thickness of the active segment index outline (0 means same thickness,
+   * 1 means 1px thicker, -1 means 1px thinner) */
+  activeSegmentOutlineWidthDelta?: number;
   /** whether to render segmentation filling */
   renderFill?: boolean;
   /** whether to render segmentation filling when inactive */

package/src/utilities/boundingBox/getBoundingBoxAroundShape.ts

@@ -1,57 +1,108 @@
 import type { Types } from '@cornerstonejs/core';
+import { CONSTANTS } from '@cornerstonejs/core';
 
-/**
- * With a given vertices (points) coordinates in IJK, it calculates the minimum and maximum
- * coordinate in each axis, and returns them. If dimensions are provided it also
- * clip the min, max to the provided width, height and depth
- *
- * @param points - shape corner points coordinates (IJK)
- * @param dimensions - dimensions of the image
- * @returns [[xMin,xMax],[yMin,yMax], [zMin,zMax]]
- */
-function getBoundingBoxAroundShape(
-  points: Types.Point3[],
-  dimensions?: Types.Point3
-): [Types.Point2, Types.Point2, Types.Point2] {
+const { EPSILON } = CONSTANTS;
+
+/** Bounding box type */
+type BoundingBox =
+  | [Types.Point2, Types.Point2, null]
+  | [Types.Point2, Types.Point2, Types.Point2];
+
+function calculateBoundingBox(
+  points,
+  dimensions,
+  isWorld = false
+): BoundingBox {
   let xMin = Infinity;
-  let xMax = 0;
+  let xMax = isWorld ? -Infinity : 0;
   let yMin = Infinity;
-  let yMax = 0;
+  let yMax = isWorld ? -Infinity : 0;
   let zMin = Infinity;
-  let zMax = 0;
+  let zMax = isWorld ? -Infinity : 0;
+
+  const is3D = points[0]?.length === 3;
 
   points.forEach((p) => {
     xMin = Math.min(p[0], xMin);
     xMax = Math.max(p[0], xMax);
     yMin = Math.min(p[1], yMin);
     yMax = Math.max(p[1], yMax);
-    zMin = Math.min(p[2], zMin);
-    zMax = Math.max(p[2], zMax);
-  });
 
-  xMin = Math.floor(xMin);
-  xMax = Math.floor(xMax);
-  yMin = Math.floor(yMin);
-  yMax = Math.floor(yMax);
-  zMin = Math.floor(zMin);
-  zMax = Math.floor(zMax);
+    if (is3D) {
+      zMin = Math.min(p[2] ?? zMin, zMin);
+      zMax = Math.max(p[2] ?? zMax, zMax);
+    }
+  });
 
   if (dimensions) {
-    // clip the min, max to the provided width, height and depth
-    const [width, height, depth] = dimensions;
+    xMin = Math.max(isWorld ? dimensions[0] + EPSILON : 0, xMin);
+    xMax = Math.min(
+      isWorld ? dimensions[0] - EPSILON : dimensions[0] - 1,
+      xMax
+    );
+    yMin = Math.max(isWorld ? dimensions[1] + EPSILON : 0, yMin);
+    yMax = Math.min(
+      isWorld ? dimensions[1] - EPSILON : dimensions[1] - 1,
+      yMax
+    );
+
+    if (is3D && dimensions.length === 3) {
+      zMin = Math.max(isWorld ? dimensions[2] + EPSILON : 0, zMin);
+      zMax = Math.min(
+        isWorld ? dimensions[2] - EPSILON : dimensions[2] - 1,
+        zMax
+      );
+    }
+  } else if (!isWorld) {
+    // still need to bound to 0 and Infinity if no dimensions are provided for ijk
     xMin = Math.max(0, xMin);
-    xMax = Math.min(width - 1, xMax);
+    xMax = Math.min(Infinity, xMax);
     yMin = Math.max(0, yMin);
-    yMax = Math.min(height - 1, yMax);
-    zMin = Math.max(0, zMin);
-    zMax = Math.min(depth - 1, zMax);
+    yMax = Math.min(Infinity, yMax);
+
+    if (is3D) {
+      zMin = Math.max(0, zMin);
+      zMax = Math.min(Infinity, zMax);
+    }
   }
 
-  return [
-    [xMin, xMax],
-    [yMin, yMax],
-    [zMin, zMax],
-  ];
+  return is3D
+    ? [
+        [xMin, xMax],
+        [yMin, yMax],
+        [zMin, zMax],
+      ]
+    : [[xMin, xMax], [yMin, yMax], null];
 }
 
-export default getBoundingBoxAroundShape;
+/**
+ * With a given vertices (points) coordinates in 2D or 3D in IJK, it calculates the minimum and maximum
+ * coordinate in each axis, and returns them. If clipBounds are provided it also
+ * clip the min, max to the provided width, height and depth
+ *
+ * @param points - shape corner points coordinates either in IJK (image coordinate)
+ * @param dimensions - bounds to clip the min, max
+ * @returns [[xMin,xMax],[yMin,yMax], [zMin,zMax]]
+ */
+export function getBoundingBoxAroundShapeIJK(
+  points: Types.Point2[] | Types.Point3[],
+  dimensions?: Types.Point2 | Types.Point3
+): BoundingBox {
+  return calculateBoundingBox(points, dimensions, false);
+}
+
+/**
+ * With a given vertices (points) coordinates in 2D or 3D in World Coordinates, it calculates the minimum and maximum
+ * coordinate in each axis, and returns them. If clipBounds are provided it also
+ * clip the min, max to the provided width, height and depth
+ *
+ * @param points - shape corner points coordinates either in IJK (image coordinate)
+ * @param clipBounds - bounds to clip the min, max
+ * @returns [[xMin,xMax],[yMin,yMax], [zMin,zMax]]
+ */
+export function getBoundingBoxAroundShapeWorld(
+  points: Types.Point2[] | Types.Point3[],
+  clipBounds?: Types.Point2 | Types.Point3
+): BoundingBox {
+  return calculateBoundingBox(points, clipBounds, true);
+}

package/src/utilities/boundingBox/index.ts

@@ -1,4 +1,13 @@
 import extend2DBoundingBoxInViewAxis from './extend2DBoundingBoxInViewAxis';
-import getBoundingBoxAroundShape from './getBoundingBoxAroundShape';
+import {
+  getBoundingBoxAroundShapeIJK,
+  getBoundingBoxAroundShapeWorld,
+} from './getBoundingBoxAroundShape';
 
-export { extend2DBoundingBoxInViewAxis, getBoundingBoxAroundShape };
+export {
+  extend2DBoundingBoxInViewAxis,
+  getBoundingBoxAroundShapeIJK,
+  getBoundingBoxAroundShapeWorld,
+  // backwards compatibility
+  getBoundingBoxAroundShapeIJK as getBoundingBoxAroundShape,
+};

package/src/utilities/{pointInSurroundingSphereCallback.ts → getSphereBoundsInfo.ts}

@@ -3,12 +3,8 @@ import type { Types } from '@cornerstonejs/core';
 
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { vec3 } from 'gl-matrix';
-import { pointInSphere } from './math/sphere';
-import pointInShapeCallback, {
-  PointInShapeCallback,
-} from './pointInShapeCallback';
 import { BoundsIJK } from '../types';
-import { getBoundingBoxAroundShape } from './boundingBox';
+import { getBoundingBoxAroundShapeIJK } from './boundingBox';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -27,36 +23,7 @@ const { transformWorldToIndex } = csUtils;
  * @param circlePoints - bottom and top points of the great circle in world coordinates
  * @param callback - A callback function that will be called for each point in the shape.
  */
-export default function pointInSurroundingSphereCallback(
-  imageData: vtkImageData,
-  circlePoints: [Types.Point3, Types.Point3],
-  callback: PointInShapeCallback,
-  viewport?: Types.IVolumeViewport
-): void {
-  // We can run the sphere equation to determine if a point is inside
-  // the sphere; however, since the imageData dimensions can be quite large, we
-  // can narrow down the search by estimating the bounds of the sphere in index
-  // space.
-  const { boundsIJK, centerWorld, radiusWorld } = _getBounds(
-    circlePoints,
-    imageData,
-    viewport
-  );
-
-  const sphereObj = {
-    center: centerWorld,
-    radius: radiusWorld,
-  };
-
-  pointInShapeCallback(
-    imageData,
-    (pointLPS) => pointInSphere(sphereObj, pointLPS),
-    callback,
-    boundsIJK
-  );
-}
-
-function _getBounds(
+function getSphereBoundsInfo(
   circlePoints: [Types.Point3, Types.Point3],
   imageData: vtkImageData,
   viewport
@@ -64,6 +31,8 @@ function _getBounds(
   boundsIJK: BoundsIJK;
   centerWorld: Types.Point3;
   radiusWorld: number;
+  topLeftWorld: Types.Point3;
+  bottomRightWorld: Types.Point3;
 } {
   const [bottom, top] = circlePoints;
 
@@ -77,53 +46,27 @@ function _getBounds(
   // sphere radius in world
   const radiusWorld = vec3.distance(bottom, top) / 2;
 
-  let boundsIJK;
-
   if (!viewport) {
-    // If no viewport is provide (no camera), we can estimate the bounding box
-    // of the sphere in index space.
-    // This is done by calculating the maximum value for radius in the index
-    // space (since the radius is in world space, we need to convert it to index, and
-    // each dimensions can have a different scale factor). Therefore, by finding
-    // the minimum spacing value in the imageData, we can calculate the maximum
-    // radius in index space and use that to calculate the bounds of the sphere
-    // This will not be accurate, but it is a good first approximation.
-    // sphere center in index
-    const centerIJK = transformWorldToIndex(
-      imageData,
-      centerWorld as Types.Point3
+    throw new Error(
+      'viewport is required in order to calculate the sphere bounds'
     );
-
-    const spacings = imageData.getSpacing();
-    const minSpacing = Math.min(...spacings);
-
-    const maxRadiusIJK = Math.ceil(radiusWorld / minSpacing);
-
-    boundsIJK = [
-      [centerIJK[0] - maxRadiusIJK, centerIJK[0] + maxRadiusIJK],
-      [centerIJK[1] - maxRadiusIJK, centerIJK[1] + maxRadiusIJK],
-      [centerIJK[2] - maxRadiusIJK, centerIJK[2] + maxRadiusIJK],
-    ];
-
-    return {
-      boundsIJK,
-      centerWorld: centerWorld as Types.Point3,
-      radiusWorld,
-    };
   }
 
-  boundsIJK = _computeBoundsIJKWithCamera(
-    imageData,
-    viewport,
-    circlePoints,
-    centerWorld,
-    radiusWorld
-  );
+  const { boundsIJK, topLeftWorld, bottomRightWorld } =
+    _computeBoundsIJKWithCamera(
+      imageData,
+      viewport,
+      circlePoints,
+      centerWorld,
+      radiusWorld
+    );
 
   return {
     boundsIJK,
     centerWorld: centerWorld as Types.Point3,
     radiusWorld,
+    topLeftWorld: topLeftWorld as Types.Point3,
+    bottomRightWorld: bottomRightWorld as Types.Point3,
   };
 }
 
@@ -137,6 +80,7 @@ function _computeBoundsIJKWithCamera(
   const [bottom, top] = circlePoints;
 
   const dimensions = imageData.getDimensions() as Types.Point3;
+
   const camera = viewport.getCamera();
 
   // Calculate viewRight from the camera, this will get used in order to
@@ -172,17 +116,30 @@ function _computeBoundsIJKWithCamera(
   vec3.scaleAndAdd(topLeftWorld, topLeftWorld, viewRight, -radiusWorld);
   vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, viewRight, radiusWorld);
 
-  // convert the world coordinates to index coordinates
+  // In order to correctly come up with the boundsIJK, we need to consider
+  // all the points IJK to get the bounds, since the viewport might have
+  // rotate views and we cannot guarantee that the topLeft and bottomRight in the
+  // world, are the ones that will define the bounds in IJK
+  const topLeftIJK = transformWorldToIndex(
+    imageData,
+    topLeftWorld as Types.Point3
+  );
+  const bottomRightIJK = transformWorldToIndex(
+    imageData,
+    bottomRightWorld as Types.Point3
+  );
 
-  const sphereCornersIJK = [
-    <Types.Point3>transformWorldToIndex(imageData, <Types.Point3>topLeftWorld),
-    <Types.Point3>(
-      transformWorldToIndex(imageData, <Types.Point3>bottomRightWorld)
-    ),
-  ];
+  const pointsIJK = circlePoints.map((p) =>
+    transformWorldToIndex(imageData, p)
+  );
 
   // get the bounding box of the sphere in the image
-  const boundsIJK = getBoundingBoxAroundShape(sphereCornersIJK, dimensions);
+  const boundsIJK = getBoundingBoxAroundShapeIJK(
+    [topLeftIJK, bottomRightIJK, ...pointsIJK],
+    dimensions
+  );
 
-  return boundsIJK;
+  return { boundsIJK, topLeftWorld, bottomRightWorld };
 }
+
+export { getSphereBoundsInfo };

package/src/utilities/index.ts

@@ -21,7 +21,7 @@ import triggerAnnotationRender from './triggerAnnotationRender';
 import jumpToSlice from './viewport/jumpToSlice';
 
 import pointInShapeCallback from './pointInShapeCallback';
-import pointInSurroundingSphereCallback from './pointInSurroundingSphereCallback';
+import { getSphereBoundsInfo } from './getSphereBoundsInfo';
 import scroll from './scroll';
 import { pointToString } from './pointToString';
 import annotationFrameRange from './annotationFrameRange';
@@ -71,7 +71,7 @@ export {
   triggerAnnotationRenderForViewportIds,
   triggerAnnotationRender,
   pointInShapeCallback,
-  pointInSurroundingSphereCallback,
+  getSphereBoundsInfo,
   getAnnotationNearPoint,
   getAnnotationNearPointOnEnabledElement,
   jumpToSlice,

package/src/utilities/math/ellipse/pointInEllipse.ts

@@ -44,7 +44,7 @@ export default function pointInEllipse(
  * That is:
  *
  * ```
- *    const inverts = precalcualtePointInEllipse(ellipse);
+ *    const inverts = precalculatePointInEllipse(ellipse);
  *    if( inverts.precalculated(pointLPS) ) ...
  * ```
  */

package/src/utilities/pointInShapeCallback.ts

@@ -22,7 +22,7 @@ export type PointInShapeCallback = ({
   pointLPS: vec3;
 }) => void;
 
-export type ShapeFnCriteria = (pointIJK: vec3, pointLPS: vec3) => boolean;
+export type ShapeFnCriteria = (pointLPS: vec3, pointIJK: vec3) => boolean;
 
 /**
  * For each point in the image (If boundsIJK is not provided, otherwise, for each
@@ -121,7 +121,7 @@ export default function pointInShapeCallback(
         const pointIJK: Types.Point3 = [i, j, k];
 
         // The current world position (pointLPS) is now in currentPos
-        if (pointInShapeFn(currentPos as Types.Point3, currentPos)) {
+        if (pointInShapeFn(currentPos as Types.Point3, pointIJK)) {
           const index = k * zMultiple + j * yMultiple + i * xMultiple;
           let value;
           if (xMultiple > 2) {

package/src/utilities/rectangleROITool/getBoundsIJKFromRectangleAnnotations.ts

@@ -1,6 +1,6 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
-import getBoundingBoxAroundShape from '../boundingBox/getBoundingBoxAroundShape';
+import { getBoundingBoxAroundShapeIJK } from '../boundingBox/getBoundingBoxAroundShape';
 import extend2DBoundingBoxInViewAxis from '../boundingBox/extend2DBoundingBoxInViewAxis';
 
 type Options = {
@@ -29,7 +29,10 @@ function getBoundsIJKFromRectangleAnnotations(
     const rectangleCornersIJK = pointsToUse.map(
       (world) => csUtils.transformWorldToIndex(imageData, world) as Types.Point3
     );
-    let boundsIJK = getBoundingBoxAroundShape(rectangleCornersIJK, dimensions);
+    let boundsIJK = getBoundingBoxAroundShapeIJK(
+      rectangleCornersIJK,
+      dimensions
+    );
 
     // If the tool is 2D but it is configured to project to X amount of slices
     // Don't project the slices if projectionPoints have been used to define the extents

package/src/utilities/rectangleROITool/index.ts

@@ -1,3 +1,4 @@
 import getBoundsIJKFromRectangleAnnotations from './getBoundsIJKFromRectangleAnnotations';
+import { isAxisAlignedRectangle } from './isAxisAlignedRectangle';
 
-export { getBoundsIJKFromRectangleAnnotations };
+export { getBoundsIJKFromRectangleAnnotations, isAxisAlignedRectangle };