@cornerstonejs/tools 1.42.0 → 1.43.0

package/src/tools/displayTools/Labelmap/labelmapDisplay.ts

@@ -4,12 +4,12 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import {
   cache,
   getEnabledElementByIds,
+  StackViewport,
   Types,
-  utilities,
+  VolumeViewport,
 } from '@cornerstonejs/core';
 
 import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { getToolGroup } from '../../../store/ToolGroupManager';
 import type {
@@ -18,7 +18,6 @@ import type {
   LabelmapSegmentationData,
 } from '../../../types/LabelmapTypes';
 import {
-  RepresentationPublicInput,
   SegmentationRepresentationConfig,
   ToolGroupSpecificRepresentation,
 } from '../../../types/SegmentationStateTypes';
@@ -131,11 +130,21 @@ async function render(
   } = representation;
 
   const segmentation = SegmentationState.getSegmentation(segmentationId);
+
+  if (!segmentation) {
+    console.warn('No segmentation found for segmentationId: ', segmentationId);
+    return;
+  }
+
   const labelmapData =
     segmentation.representationData[Representations.Labelmap];
 
   let actorEntry = viewport.getActor(segmentationRepresentationUID);
   if (isVolumeSegmentation(labelmapData)) {
+    if (viewport instanceof StackViewport) {
+      return;
+    }
+
     const { volumeId: labelmapUID } = labelmapData;
 
     const labelmap = cache.getVolume(labelmapUID);
@@ -159,6 +168,10 @@ async function render(
 
     actorEntry = viewport.getActor(segmentationRepresentationUID);
   } else {
+    if (viewport instanceof VolumeViewport) {
+      return;
+    }
+
     // stack segmentation
     const imageId = viewport.getCurrentImageId();
     const { imageIdReferenceMap } = labelmapData;
@@ -288,27 +301,39 @@ function _setLabelmapColorAndOpacity(
     }
   }
 
-  const actor = actorEntry.actor as Types.Actor;
+  const actor = actorEntry.actor as Types.VolumeActor;
 
-  // @ts-ignore
   actor.getProperty().setRGBTransferFunction(0, cfun);
 
   ofun.setClamping(false);
 
-  // @ts-ignore
   actor.getProperty().setScalarOpacity(0, ofun);
-  // @ts-ignore
   actor.getProperty().setInterpolationTypeToNearest();
+  actor.getProperty().setUseLabelOutline(renderOutline);
+
+  // @ts-ignore - fix type in vtk
+  actor.getProperty().setLabelOutlineOpacity(outlineOpacity);
 
-  if (utilities.actorIsA(actorEntry, 'vtkVolume')) {
-    // @ts-ignore
-    actor.getProperty().setUseLabelOutline(renderOutline);
-    // @ts-ignore
-    actor.getProperty().setLabelOutlineOpacity(outlineOpacity);
-    // @ts-ignore
-    actor.getProperty().setLabelOutlineThickness(outlineWidth);
+  const { activeSegmentIndex } = SegmentationState.getSegmentation(
+    segmentationRepresentation.segmentationId
+  );
+
+  // create an array that contains all the segment indices and for the active
+  // segment index, use the activeSegmentOutlineWidthDelta, otherwise use the
+  // outlineWidth
+  // Pre-allocate the array with the required size to avoid dynamic resizing.
+  const outlineWidths = new Array(numColors - 1);
+
+  for (let i = 1; i < numColors; i++) {
+    // Start from 1 to skip the background segment index.
+    outlineWidths[i - 1] =
+      i === activeSegmentIndex
+        ? outlineWidth + toolGroupLabelmapConfig.activeSegmentOutlineWidthDelta
+        : outlineWidth;
   }
 
+  actor.getProperty().setLabelOutlineThickness(outlineWidths);
+
   // Set visibility based on whether actor visibility is specifically asked
   // to be turned on/off (on by default) AND whether is is in active but
   // we are rendering inactive labelmap

package/src/tools/index.ts

@@ -47,6 +47,7 @@ import RectangleROIStartEndThresholdTool from './segmentation/RectangleROIStartE
 import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
+import SegmentSelectTool from './segmentation/SegmentSelectTool';
 
 export {
   // ~~ BASE
@@ -99,4 +100,5 @@ export {
   PaintFillTool,
   ScaleOverlayTool,
   OrientationMarkerTool,
+  SegmentSelectTool,
 };

package/src/tools/segmentation/BrushTool.ts

@@ -171,7 +171,7 @@ class BrushTool extends BaseTool {
 
   createEditData(element) {
     const enabledElement = getEnabledElement(element);
-    const { viewport, renderingEngine } = enabledElement;
+    const { viewport } = enabledElement;
 
     const toolGroupId = this.toolGroupId;
 
@@ -179,7 +179,7 @@ class BrushTool extends BaseTool {
       activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
     if (!activeSegmentationRepresentation) {
       throw new Error(
-        'No active segmentation detected, create one before using the brush tool'
+        'No active segmentation detected, create a segmentation representation before using the brush tool'
       );
     }
 
@@ -198,8 +198,6 @@ class BrushTool extends BaseTool {
     const labelmapData =
       representationData[SegmentationRepresentations.Labelmap];
 
-    const viewportIdsToRender = [viewport.id];
-
     if (isVolumeSegmentation(labelmapData)) {
       const { volumeId } = representationData[
         type
@@ -235,11 +233,9 @@ class BrushTool extends BaseTool {
       // and should throw an error or maybe simply just allow circle manipulation
       // and not sphere manipulation
       if (this.configuration.activeStrategy.includes('SPHERE')) {
-        console.warn(
-          'Sphere manipulation is not supported for this stack of images yet'
+        throw new Error(
+          'Sphere manipulation is not supported for stacks of image segmentations yet'
         );
-        return;
-
         // Todo: add sphere (volumetric) manipulation support for stacks of images
         // we should basically check if the stack constructs a valid volume
         // meaning all the metadata is present and consistent
@@ -275,9 +271,11 @@ class BrushTool extends BaseTool {
     this._previewData.isDrag = false;
     this._previewData.timerStart = Date.now();
 
+    const hoverData = this._hoverData || this.createHoverData(element);
+
     triggerAnnotationRenderForViewportUIDs(
       renderingEngine,
-      this._hoverData.viewportIdsToRender
+      hoverData.viewportIdsToRender
     );
 
     this.applyActiveStrategyCallback(
@@ -366,6 +364,40 @@ class BrushTool extends BaseTool {
     const camera = viewport.getCamera();
     const { viewPlaneNormal, viewUp } = camera;
 
+    const viewportIdsToRender = [viewport.id];
+
+    const {
+      segmentIndex,
+      segmentationId,
+      segmentationRepresentationUID,
+      segmentColor,
+    } = this.getActiveSegmentationData() || {};
+
+    // Center of circle in canvas Coordinates
+    const brushCursor = {
+      metadata: {
+        viewPlaneNormal: <Types.Point3>[...viewPlaneNormal],
+        viewUp: <Types.Point3>[...viewUp],
+        FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+        referencedImageId: '',
+        toolName: this.getToolName(),
+        segmentColor,
+      },
+      data: {},
+    };
+
+    return {
+      brushCursor,
+      centerCanvas,
+      segmentIndex,
+      segmentationId,
+      segmentationRepresentationUID,
+      segmentColor,
+      viewportIdsToRender,
+    };
+  }
+
+  private getActiveSegmentationData() {
     const toolGroupId = this.toolGroupId;
 
     const activeSegmentationRepresentation =
@@ -388,30 +420,11 @@ class BrushTool extends BaseTool {
       segmentIndex
     );
 
-    const viewportIdsToRender = [viewport.id];
-
-    // Center of circle in canvas Coordinates
-
-    const brushCursor = {
-      metadata: {
-        viewPlaneNormal: <Types.Point3>[...viewPlaneNormal],
-        viewUp: <Types.Point3>[...viewUp],
-        FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
-        referencedImageId: '',
-        toolName: this.getToolName(),
-        segmentColor,
-      },
-      data: {},
-    };
-
     return {
-      brushCursor,
-      centerCanvas,
       segmentIndex,
       segmentationId,
       segmentationRepresentationUID,
       segmentColor,
-      viewportIdsToRender,
     };
   }
 
@@ -428,6 +441,10 @@ class BrushTool extends BaseTool {
 
     this._calculateCursor(element, centerCanvas);
 
+    if (!this._hoverData) {
+      return;
+    }
+
     triggerAnnotationRenderForViewportUIDs(
       getEnabledElement(element).renderingEngine,
       this._hoverData.viewportIdsToRender
@@ -549,6 +566,10 @@ class BrushTool extends BaseTool {
       rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
     }
 
+    if (!this._hoverData) {
+      return;
+    }
+
     const { brushCursor } = this._hoverData;
     const { data } = brushCursor;
 
@@ -674,11 +695,17 @@ class BrushTool extends BaseTool {
   };
 
   public invalidateBrushCursor() {
-    if (this._hoverData !== undefined) {
-      const { data } = this._hoverData.brushCursor;
-
-      data.invalidated = true;
+    if (this._hoverData === undefined) {
+      return;
     }
+    const { data } = this._hoverData.brushCursor;
+
+    data.invalidated = true;
+
+    // Todo: figure out if other brush metadata (other than segment color) should get updated
+    // during the brush cursor invalidation
+    const { segmentColor } = this.getActiveSegmentationData() || {};
+    this._hoverData.brushCursor.metadata.segmentColor = segmentColor;
   }
 
   renderAnnotation(
@@ -709,6 +736,10 @@ class BrushTool extends BaseTool {
     }
 
     const toolMetadata = brushCursor.metadata;
+    if (!toolMetadata) {
+      return;
+    }
+
     const annotationUID = toolMetadata.brushCursorUID;
 
     const data = brushCursor.data;
@@ -725,7 +756,7 @@ class BrushTool extends BaseTool {
 
     const radius = Math.abs(bottom[1] - Math.floor((bottom[1] + top[1]) / 2));
 
-    const color = `rgb(${toolMetadata.segmentColor.slice(0, 3)})`;
+    const color = `rgb(${toolMetadata.segmentColor?.slice(0, 3) || [0, 0, 0]})`;
 
     // If rendering engine has been destroyed while rendering
     if (!viewport.getRenderingEngine()) {

package/src/tools/segmentation/CircleScissorsTool.ts

@@ -89,6 +89,13 @@ class CircleScissorsTool extends BaseTool {
    *
    */
   preMouseDownCallback = (evt: EventTypes.InteractionEventType): boolean => {
+    // if we are already drawing, means we have started with a click, and now we
+    // are moving the mouse (not dragging) so the final click should not
+    // be handled by this preMouseDownCallback but rather the endCallback
+    if (this.isDrawing === true) {
+      return;
+    }
+
     const eventDetail = evt.detail;
     const { currentPoints, element } = eventDetail;
     const worldPos = currentPoints.world;
@@ -292,6 +299,7 @@ class CircleScissorsTool extends BaseTool {
     element.addEventListener(Events.MOUSE_UP, this._endCallback);
     element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
     element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+    element.addEventListener(Events.MOUSE_MOVE, this._dragCallback);
 
     element.addEventListener(Events.TOUCH_TAP, this._endCallback);
     element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
@@ -305,6 +313,7 @@ class CircleScissorsTool extends BaseTool {
     element.removeEventListener(Events.MOUSE_UP, this._endCallback);
     element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
     element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+    element.removeEventListener(Events.MOUSE_MOVE, this._dragCallback);
 
     element.removeEventListener(Events.TOUCH_END, this._endCallback);
     element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);

package/src/tools/segmentation/RectangleScissorsTool.ts

@@ -91,6 +91,13 @@ class RectangleScissorsTool extends BaseTool {
    *
    */
   preMouseDownCallback = (evt: EventTypes.InteractionEventType): boolean => {
+    // if we are already drawing, means we have started with a click, and now we
+    // are moving the mouse (not dragging) so the final click should not
+    // be handled by this preMouseDownCallback but rather the endCallback
+    if (this.isDrawing === true) {
+      return;
+    }
+
     const eventDetail = evt.detail;
     const { currentPoints, element } = eventDetail;
     const worldPos = currentPoints.world;
@@ -315,6 +322,7 @@ class RectangleScissorsTool extends BaseTool {
   _activateDraw = (element) => {
     element.addEventListener(Events.MOUSE_UP, this._endCallback);
     element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+    element.addEventListener(Events.MOUSE_MOVE, this._dragCallback);
     element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
 
     element.addEventListener(Events.TOUCH_END, this._endCallback);
@@ -328,9 +336,10 @@ class RectangleScissorsTool extends BaseTool {
   _deactivateDraw = (element) => {
     element.removeEventListener(Events.MOUSE_UP, this._endCallback);
     element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+    element.removeEventListener(Events.MOUSE_MOVE, this._dragCallback);
     element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
-    element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
 
+    element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
     element.removeEventListener(Events.TOUCH_END, this._endCallback);
     element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
   };

package/src/tools/segmentation/SegmentSelectTool.ts

@@ -0,0 +1,182 @@
+import {
+  cache,
+  getEnabledElement,
+  utilities as csUtils,
+} from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+import { BaseTool } from '../base';
+import {
+  PublicToolProps,
+  ToolProps,
+  EventTypes,
+  Segmentation,
+} from '../../types';
+import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../types/LabelmapTypes';
+import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
+import {
+  getActiveSegmentation,
+  getActiveSegmentationRepresentation,
+} from '../../stateManagement/segmentation/activeSegmentation';
+import RepresentationTypes from '../../enums/SegmentationRepresentations';
+import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
+
+/**
+ * Represents a tool used for segment selection. It is used to select a segment
+ * by hovering over it.
+ *
+ */
+class SegmentSelectTool extends BaseTool {
+  static toolName;
+  private hoverTimer: ReturnType<typeof setTimeout> | null;
+
+  constructor(
+    toolProps: PublicToolProps = {},
+    defaultToolProps: ToolProps = {
+      supportedInteractionTypes: ['Mouse', 'Touch'],
+      configuration: {
+        hoverTimeout: 750,
+      },
+    }
+  ) {
+    super(toolProps, defaultToolProps);
+    this.hoverTimer = null;
+  }
+
+  mouseMoveCallback = (evt: EventTypes.InteractionEventType): boolean => {
+    if (this.hoverTimer) {
+      clearTimeout(this.hoverTimer);
+    }
+
+    this.hoverTimer = setTimeout(() => {
+      this._setActiveSegment(evt);
+      this.hoverTimer = null;
+    }, this.configuration.hoverTimeout);
+
+    return true;
+  };
+
+  onSetToolEnabled = (): void => {
+    this.onSetToolActive();
+  };
+
+  onSetToolActive = (): void => {
+    this.hoverTimer = null;
+  };
+
+  onSetToolDisabled = (): void => {
+    this.hoverTimer = null;
+  };
+
+  _setActiveSegment(evt = {} as EventTypes.InteractionEventType): void {
+    const { element, currentPoints } = evt.detail;
+
+    const worldPoint = currentPoints.world;
+
+    const enabledElement = getEnabledElement(element);
+
+    if (!enabledElement) {
+      return;
+    }
+
+    const { viewport } = enabledElement;
+
+    const activeSegmentation = getActiveSegmentation(this.toolGroupId);
+
+    if (activeSegmentation.type === RepresentationTypes.Labelmap) {
+      this._setActiveSegmentLabelmap(activeSegmentation, worldPoint, viewport);
+    } else {
+      throw Error('non-labelmap segmentation not supported yet');
+    }
+  }
+
+  _setActiveSegmentLabelmap(
+    activeSegmentation: Segmentation,
+    worldPoint: Types.Point3,
+    viewport: Types.IStackViewport | Types.IVolumeViewport
+  ): void {
+    const imageDataInfo = viewport.getImageData();
+
+    if (!imageDataInfo) {
+      return;
+    }
+
+    const labelmapData = activeSegmentation.representationData.LABELMAP;
+
+    let hoveredSegmentIndex;
+
+    if (isVolumeSegmentation(activeSegmentation.representationData.LABELMAP)) {
+      const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
+
+      const segmentationVolume = cache.getVolume(volumeId);
+
+      if (!segmentationVolume) {
+        return;
+      }
+
+      hoveredSegmentIndex =
+        segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
+    } else {
+      const { imageIdReferenceMap } =
+        labelmapData as LabelmapSegmentationDataStack;
+
+      const currentImageId = viewport.getCurrentImageId();
+      const segmentationImageId = imageIdReferenceMap.get(currentImageId);
+
+      const image = cache.getImage(segmentationImageId);
+
+      if (!image) {
+        return;
+      }
+
+      const activeSegmentationRepresentation =
+        getActiveSegmentationRepresentation(this.toolGroupId);
+
+      if (!activeSegmentationRepresentation) {
+        return;
+      }
+
+      const segmentationActor = viewport.getActor(
+        activeSegmentationRepresentation.segmentationRepresentationUID
+      );
+
+      const imageData = segmentationActor?.actor.getMapper().getInputData();
+
+      const indexIJK = csUtils.transformWorldToIndex(imageData, worldPoint);
+
+      // since it is a stack we don't need to check the z
+      const flattenedIndex = indexIJK[0] + indexIJK[1] * image.columns;
+
+      const scalars = imageData.getPointData().getScalars().getData();
+
+      hoveredSegmentIndex = scalars[flattenedIndex];
+    }
+
+    // No need to select background
+    if (!hoveredSegmentIndex || hoveredSegmentIndex === 0) {
+      return;
+    }
+
+    setActiveSegmentIndex(
+      activeSegmentation.segmentationId,
+      hoveredSegmentIndex
+    );
+
+    const renderingEngine = viewport.getRenderingEngine();
+
+    // update states
+    triggerSegmentationModified(activeSegmentation.segmentationId);
+    triggerAnnotationRenderForViewportIds(
+      renderingEngine,
+      renderingEngine.getViewports().map((v) => v.id)
+    );
+  }
+}
+
+SegmentSelectTool.toolName = 'SegmentSelectTool';
+export default SegmentSelectTool;

package/src/tools/segmentation/SphereScissorsTool.ts

@@ -91,6 +91,13 @@ class SphereScissorsTool extends BaseTool {
    *
    */
   preMouseDownCallback = (evt: EventTypes.InteractionEventType): true => {
+    // if we are already drawing, means we have started with a click, and now we
+    // are moving the mouse (not dragging) so the final click should not
+    // be handled by this preMouseDownCallback but rather the endCallback
+    if (this.isDrawing === true) {
+      return;
+    }
+
     const eventDetail = evt.detail;
     const { currentPoints, element } = eventDetail;
     const worldPos = currentPoints.world;
@@ -296,6 +303,7 @@ class SphereScissorsTool extends BaseTool {
     element.addEventListener(Events.MOUSE_UP, this._endCallback);
     element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
     element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+    element.addEventListener(Events.MOUSE_MOVE, this._dragCallback);
 
     element.addEventListener(Events.TOUCH_END, this._endCallback);
     element.addEventListener(Events.TOUCH_TAP, this._endCallback);
@@ -309,6 +317,7 @@ class SphereScissorsTool extends BaseTool {
     element.removeEventListener(Events.MOUSE_UP, this._endCallback);
     element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
     element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+    element.removeEventListener(Events.MOUSE_MOVE, this._dragCallback);
 
     element.removeEventListener(Events.TOUCH_END, this._endCallback);
     element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);

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

@@ -10,6 +10,7 @@ import type {
   LabelmapToolOperationDataAny,
   LabelmapToolOperationDataVolume,
 } from '../../../types/LabelmapToolOperationData';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 
 const { VoxelManager } = csUtils;
 
@@ -21,7 +22,7 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
   viewport: Types.IViewport;
   imageVoxelManager: csUtils.VoxelManager<number>;
   segmentationVoxelManager: csUtils.VoxelManager<number>;
-  segmentationImageData: ImageData;
+  segmentationImageData: vtkImageData;
   previewVoxelManager: csUtils.VoxelManager<number>;
   // The index to use for the preview segment.  Currently always undefined or 255
   // but define it here for future expansion of LUT tables

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

@@ -6,23 +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 } = csUtils;
-const EPSILON = 1e-4;
-const nearOrZero = (testValue, nearValue) =>
-  Math.abs(testValue) < EPSILON || Math.abs(testValue - nearValue) < EPSILON;
+const { transformWorldToIndex, isEqual } = csUtils;
 
 const initializeCircle = {
   [StrategyCallbacks.Initialize]: (operationData: InitializedOperationData) => {
     const {
-      points,
+      points, // bottom, top, left, right
       imageVoxelManager: imageVoxelManager,
       viewport,
       segmentationImageData,
@@ -45,6 +42,7 @@ const initializeCircle = {
       segmentationImageData,
       center as Types.Point3
     );
+
     const canvasCoordinates = points.map((p) =>
       viewport.worldToCanvas(p)
     ) as CanvasCoordinates;
@@ -58,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,
@@ -98,9 +97,9 @@ function createPointInEllipse(worldInfo: {
 
   const radius = Math.max(xRadius, yRadius, zRadius);
   if (
-    nearOrZero(xRadius, radius) &&
-    nearOrZero(yRadius, radius) &&
-    nearOrZero(zRadius, radius)
+    isEqual(xRadius, radius) &&
+    isEqual(yRadius, radius) &&
+    isEqual(zRadius, radius)
   ) {
     const sphereObj = {
       center,
@@ -116,9 +115,8 @@ function createPointInEllipse(worldInfo: {
     yRadius,
     zRadius,
   };
-  const inverts = precalculatePointInEllipse(ellipseObj);
-  const { precalculated } = inverts;
 
+  const { precalculated } = precalculatePointInEllipse(ellipseObj, {});
   return precalculated;
 }