@cornerstonejs/tools 2.0.0-beta.27 → 2.0.0-beta.28

package/dist/esm/tools/segmentation/BrushTool.js

@@ -1,4 +1,4 @@
-import { utilities as csUtils, cache, getEnabledElement, StackViewport, eventTarget, Enums, } from '@cornerstonejs/core';
+import { utilities as csUtils, cache, getEnabledElement, StackViewport, eventTarget, Enums, BaseVolumeViewport, } from '@cornerstonejs/core';
 import { vec3, vec2 } from 'gl-matrix';
 import { BaseTool } from '../base';
 import { fillInsideSphere, thresholdInsideSphere, } from './strategies/fillSphere';
@@ -9,12 +9,12 @@ import { Events, ToolModes, SegmentationRepresentations, StrategyCallbacks, } fr
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
-import { getActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -194,19 +194,23 @@ class BrushTool extends BaseTool {
     createEditData(element) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const activeRepresentation = getActiveSegmentationRepresentation(viewport.id);
-        if (!activeRepresentation) {
-            throw new Error('No active segmentation detected, create a segmentation representation before using the brush tool');
-        }
-        const { segmentationId, type } = activeRepresentation;
-        if (type === SegmentationRepresentations.Contour) {
-            throw new Error('Not implemented yet');
+        const activeSegmentation = getActiveSegmentation(viewport.id);
+        if (!activeSegmentation) {
+            const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+                detail: {
+                    type: 'Segmentation',
+                    message: 'No active segmentation detected, create a segmentation representation before using the brush tool',
+                },
+                cancelable: true,
+            });
+            eventTarget.dispatchEvent(event);
+            return null;
         }
+        const { segmentationId } = activeSegmentation;
         const segmentsLocked = getLockedSegmentIndices(segmentationId);
         const { representationData } = getSegmentation(segmentationId);
-        const labelmapData = representationData[SegmentationRepresentations.Labelmap];
-        if (isVolumeSegmentation(labelmapData, viewport)) {
-            const { volumeId } = representationData[type];
+        if (viewport instanceof BaseVolumeViewport) {
+            const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
             const actors = viewport.getActors();
             const isStackViewport = viewport instanceof StackViewport;
             if (isStackViewport) {
@@ -220,7 +224,7 @@ class BrushTool extends BaseTool {
                 eventTarget.dispatchEvent(event);
                 return null;
             }
-            const volumes = actors.map((actorEntry) => cache.getVolume(actorEntry.referencedId));
+            const volumes = actors.map((actorEntry) => cache.getVolume(actorEntry.referencedId ?? actorEntry.uid));
             const segmentationVolume = cache.getVolume(volumeId);
             const referencedVolumeIdToThreshold = volumes.find((volume) => csUtils.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
             return {
@@ -282,7 +286,7 @@ class BrushTool extends BaseTool {
         const camera = viewport.getCamera();
         const { viewPlaneNormal, viewUp } = camera;
         const viewportIdsToRender = [viewport.id];
-        const { segmentIndex, segmentationId, segmentationRepresentationUID, segmentColor, } = this.getActiveSegmentationData(viewport) || {};
+        const { segmentIndex, segmentationId, segmentColor } = this.getActiveSegmentationData(viewport) || {};
         const brushCursor = {
             metadata: {
                 viewPlaneNormal: [...viewPlaneNormal],
@@ -300,25 +304,23 @@ class BrushTool extends BaseTool {
             segmentIndex,
             viewport,
             segmentationId,
-            segmentationRepresentationUID,
             segmentColor,
             viewportIdsToRender,
         };
     }
     getActiveSegmentationData(viewport) {
         const viewportId = viewport.id;
-        const activeRepresentation = getActiveSegmentationRepresentation(viewportId);
+        const activeRepresentation = getActiveSegmentation(viewportId);
         if (!activeRepresentation) {
             console.warn('No active segmentation detected, create one before using the brush tool');
             return;
         }
-        const { segmentationId, segmentationRepresentationUID } = activeRepresentation;
+        const { segmentationId } = activeRepresentation;
         const segmentIndex = getActiveSegmentIndex(segmentationId);
-        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
         return {
             segmentIndex,
             segmentationId,
-            segmentationRepresentationUID,
             segmentColor,
         };
     }
@@ -336,7 +338,7 @@ class BrushTool extends BaseTool {
     }
     getOperationData(element) {
         const editData = this._editData || this.createEditData(element);
-        const { segmentIndex, segmentationId, segmentationRepresentationUID, brushCursor, } = this._hoverData || this.createHoverData(element);
+        const { segmentIndex, segmentationId, brushCursor } = this._hoverData || this.createHoverData(element);
         const { data, metadata = {} } = brushCursor || {};
         const { viewPlaneNormal, viewUp } = metadata;
         const operationData = {
@@ -349,7 +351,6 @@ class BrushTool extends BaseTool {
             viewPlaneNormal,
             toolGroupId: this.toolGroupId,
             segmentationId,
-            segmentationRepresentationUID,
             viewUp,
             strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
             preview: this._previewData?.preview,
@@ -486,4 +487,3 @@ class BrushTool extends BaseTool {
 }
 BrushTool.toolName = 'Brush';
 export default BrushTool;
-//# sourceMappingURL=BrushTool.js.map

package/dist/esm/tools/segmentation/CircleROIStartEndThresholdTool.js

@@ -332,10 +332,10 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
     _computePointsInsideVolume(annotation, imageVolume, targetId, enabledElement) {
         const { data, metadata } = annotation;
         const { viewPlaneNormal, viewUp } = metadata;
-        const { viewport, renderingEngine } = enabledElement;
+        const { viewport } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
-        const image = this.getTargetIdImage(targetId, renderingEngine);
+        const image = this.getTargetImageData(targetId);
         const canvasCoordinates = data.handles.points.map((p) => viewport.worldToCanvas(p));
         const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners(canvasCoordinates));
         const pos1 = viewport.canvasToWorld(topLeftCanvas);
@@ -477,4 +477,3 @@ function defaultGetTextLines(data) {
 }
 CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';
 export default CircleROIStartEndThresholdTool;
-//# sourceMappingURL=CircleROIStartEndThresholdTool.js.map

package/dist/esm/tools/segmentation/CircleScissorsTool.d.ts

@@ -16,8 +16,8 @@ declare class CircleScissorsTool extends BaseTool {
         movingTextBox: boolean;
         newAnnotation?: boolean;
         hasMoved?: boolean;
+        imageId: string;
         centerCanvas?: Array<number>;
-        segmentationRepresentationUID?: string;
     } | null;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;

package/dist/esm/tools/segmentation/CircleScissorsTool.js

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideCircle } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
@@ -7,8 +7,7 @@ import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, config as segmentationConfig, } from '../../stateManagement/segmentation';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 class CircleScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -35,16 +34,16 @@ class CircleScissorsTool extends BaseTool {
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
-            if (!activeSegmentationRepresentation) {
+            const activeLabelmapSegmentation = activeSegmentation.getActiveSegmentation(viewport.id);
+            if (!activeLabelmapSegmentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationRepresentationUID, segmentationId, type } = activeSegmentationRepresentation;
+            const { segmentationId } = activeLabelmapSegmentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
-            const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(viewport.id, segmentationId, segmentIndex);
             const { representationData } = getSegmentation(segmentationId);
-            const labelmapData = representationData[type];
+            const labelmapData = representationData.Labelmap;
             if (!labelmapData) {
                 throw new Error('No labelmap data found for the active segmentation, create one before using scissors tool');
             }
@@ -86,11 +85,11 @@ class CircleScissorsTool extends BaseTool {
                 movingTextBox: false,
                 newAnnotation: true,
                 hasMoved: false,
-                segmentationRepresentationUID,
                 volumeId: null,
                 referencedVolumeId: null,
+                imageId: null,
             };
-            if (isVolumeSegmentation(labelmapData, viewport)) {
+            if (viewport instanceof BaseVolumeViewport) {
                 const { volumeId } = labelmapData;
                 const segmentation = cache.getVolume(volumeId);
                 this.editData = {
@@ -100,8 +99,10 @@ class CircleScissorsTool extends BaseTool {
                 };
             }
             else {
+                const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
                 this.editData = {
                     ...this.editData,
+                    imageId: segmentationImageId,
                 };
             }
             this._activateDraw(element);
@@ -228,4 +229,3 @@ class CircleScissorsTool extends BaseTool {
 }
 CircleScissorsTool.toolName = 'CircleScissor';
 export default CircleScissorsTool;
-//# sourceMappingURL=CircleScissorsTool.js.map

package/dist/esm/tools/segmentation/PaintFillTool.js

@@ -1,11 +1,10 @@
-import { cache, getEnabledElement, utilities as csUtils, } from '@cornerstonejs/core';
+import { cache, getEnabledElement, utilities as csUtils, BaseVolumeViewport, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, } from '../../stateManagement/segmentation';
 import floodFill from '../../utilities/segmentation/floodFill';
 import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 const { transformWorldToIndex, isEqual } = csUtils;
 class PaintFillTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -20,22 +19,21 @@ class PaintFillTool extends BaseTool {
             const { viewport } = enabledElement;
             const camera = viewport.getCamera();
             const { viewPlaneNormal } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationId, type } = activeSegmentationRepresentation;
+            const { segmentationId } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
             const { representationData } = getSegmentation(segmentationId);
-            const labelmapData = representationData[SegmentationRepresentations.Labelmap];
             let dimensions;
             let direction;
             let scalarData;
             let index;
             let voxelManager;
-            if (isVolumeSegmentation(labelmapData, viewport)) {
-                const { volumeId } = representationData[type];
+            if (viewport instanceof BaseVolumeViewport) {
+                const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
                 const segmentation = cache.getVolume(volumeId);
                 ({ dimensions, direction } = segmentation);
                 voxelManager = segmentation.voxelManager;
@@ -231,4 +229,3 @@ class PaintFillTool extends BaseTool {
 }
 PaintFillTool.toolName = 'PaintFill';
 export default PaintFillTool;
-//# sourceMappingURL=PaintFillTool.js.map

package/dist/esm/tools/segmentation/RectangleROIStartEndThresholdTool.js

@@ -308,10 +308,10 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
     _computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement) {
         const { data, metadata } = annotation;
         const { viewPlaneNormal, viewUp } = metadata;
-        const { viewport, renderingEngine } = enabledElement;
+        const { viewport } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
-        const image = this.getTargetIdImage(targetId, renderingEngine);
+        const image = this.getTargetImageData(targetId);
         const worldPos1 = data.handles.points[0];
         const worldPos2 = data.handles.points[3];
         const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, worldPos1, worldPos2);
@@ -435,4 +435,3 @@ function defaultGetTextLines(data) {
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
 export default RectangleROIStartEndThresholdTool;
-//# sourceMappingURL=RectangleROIStartEndThresholdTool.js.map

package/dist/esm/tools/segmentation/RectangleROIThresholdTool.js

@@ -143,4 +143,3 @@ class RectangleROIThresholdTool extends RectangleROITool {
 }
 RectangleROIThresholdTool.toolName = 'RectangleROIThreshold';
 export default RectangleROIThresholdTool;
-//# sourceMappingURL=RectangleROIThresholdTool.js.map

package/dist/esm/tools/segmentation/RectangleScissorsTool.d.ts

@@ -12,7 +12,6 @@ declare class RectangleScissorsTool extends BaseTool {
         segmentationId: string;
         segmentIndex: number;
         segmentsLocked: number[];
-        segmentationRepresentationUID: string;
         segmentColor: [number, number, number, number];
         viewportIdsToRender: string[];
         handleIndex?: number;

package/dist/esm/tools/segmentation/RectangleScissorsTool.js

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideRectangle } from './strategies/fillRectangle';
 import { eraseInsideRectangle } from './strategies/eraseRectangle';
@@ -8,8 +8,7 @@ import { drawRect as drawRectSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 class RectangleScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -35,14 +34,14 @@ class RectangleScissorsTool extends BaseTool {
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
-            if (!activeSegmentationRepresentation) {
+            const activeLabelmapSegmentation = activeSegmentation.getActiveSegmentation(viewport.id);
+            if (!activeLabelmapSegmentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationRepresentationUID, segmentationId } = activeSegmentationRepresentation;
+            const { segmentationId } = activeLabelmapSegmentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
-            const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(viewport.id, segmentationId, segmentIndex);
             const { representationData } = getSegmentation(segmentationId);
             const labelmapData = representationData[SegmentationRepresentations.Labelmap];
             const annotation = {
@@ -80,12 +79,11 @@ class RectangleScissorsTool extends BaseTool {
                 movingTextBox: false,
                 newAnnotation: true,
                 hasMoved: false,
-                segmentationRepresentationUID,
                 volumeId: null,
                 referencedVolumeId: null,
                 imageId: null,
             };
-            if (isVolumeSegmentation(labelmapData, viewport)) {
+            if (viewport instanceof BaseVolumeViewport) {
                 const { volumeId } = labelmapData;
                 const segmentation = cache.getVolume(volumeId);
                 this.editData = {
@@ -95,8 +93,10 @@ class RectangleScissorsTool extends BaseTool {
                 };
             }
             else {
+                const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
                 this.editData = {
                     ...this.editData,
+                    imageId: segmentationImageId,
                 };
             }
             this._activateDraw(element);
@@ -154,7 +154,6 @@ class RectangleScissorsTool extends BaseTool {
             }
             annotation.invalidated = true;
             this.editData.hasMoved = true;
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._endCallback = (evt) => {
@@ -223,4 +222,3 @@ class RectangleScissorsTool extends BaseTool {
 }
 RectangleScissorsTool.toolName = 'RectangleScissor';
 export default RectangleScissorsTool;
-//# sourceMappingURL=RectangleScissorsTool.js.map

package/dist/esm/tools/segmentation/SegmentSelectTool.d.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import type { PublicToolProps, ToolProps, EventTypes } from '../../types';
-import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+import type { Segmentation } from '../../types/SegmentationStateTypes';
 declare class SegmentSelectTool extends BaseTool {
     static toolName: any;
     private hoverTimer;
@@ -15,6 +15,6 @@ declare class SegmentSelectTool extends BaseTool {
     onSetToolActive: () => void;
     onSetToolDisabled: () => void;
     _setActiveSegment(evt?: EventTypes.InteractionEventType): void;
-    _setActiveSegmentForType(activeSegmentationReps: SegmentationRepresentation, worldPoint: Types.Point3, viewport: Types.IStackViewport | Types.IVolumeViewport): void;
+    _setActiveSegmentForType(activeSegmentation: Segmentation, worldPoint: Types.Point3, viewport: Types.IStackViewport | Types.IVolumeViewport): void;
 }
 export default SegmentSelectTool;

package/dist/esm/tools/segmentation/SegmentSelectTool.js

@@ -2,7 +2,7 @@ import { getEnabledElement } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getActiveSegmentationRepresentation } from '../../stateManagement/segmentation/activeSegmentation';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/activeSegmentation';
 import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
 import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorder, getSegmentIndexAtWorldPoint, } from '../../utilities/segmentation';
@@ -54,27 +54,18 @@ class SegmentSelectTool extends BaseTool {
             return;
         }
         const { viewport } = enabledElement;
-        const activeSegmentationReps = getActiveSegmentationRepresentation(viewport.id);
-        if (!activeSegmentationReps) {
+        const activeSegmentation = getActiveSegmentation(viewport.id);
+        if (!activeSegmentation) {
             return;
         }
-        const supportedTypes = [
-            RepresentationTypes.Labelmap,
-            RepresentationTypes.Contour,
-        ];
-        if (supportedTypes.includes(activeSegmentationReps.type)) {
-            this._setActiveSegmentForType(activeSegmentationReps, worldPoint, viewport);
-        }
-        else {
-            console.warn('SegmentSelectTool does not support the current segmentation type.');
-        }
+        this._setActiveSegmentForType(activeSegmentation, worldPoint, viewport);
     }
-    _setActiveSegmentForType(activeSegmentationReps, worldPoint, viewport) {
+    _setActiveSegmentForType(activeSegmentation, worldPoint, viewport) {
         const imageDataInfo = viewport.getImageData();
         if (!imageDataInfo) {
             return;
         }
-        const { segmentationId, type } = activeSegmentationReps;
+        const { segmentationId, representationData } = activeSegmentation;
         let hoveredSegmentIndex;
         if (this.configuration.mode === SegmentSelectTool.SelectMode.Inside) {
             hoveredSegmentIndex = getSegmentIndexAtWorldPoint(segmentationId, worldPoint, {
@@ -82,17 +73,17 @@ class SegmentSelectTool extends BaseTool {
             });
         }
         else {
-            switch (type) {
-                case SegmentationRepresentations.Labelmap:
-                    hoveredSegmentIndex = getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, {
-                        viewport,
-                        searchRadius: this.configuration.searchRadius,
-                    });
-                    break;
-                case SegmentationRepresentations.Contour:
-                    hoveredSegmentIndex =
-                        getHoveredContourSegmentationAnnotation(segmentationId);
-                    break;
+            if (representationData.Labelmap) {
+                hoveredSegmentIndex = getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, {
+                    viewport,
+                    searchRadius: this.configuration.searchRadius,
+                });
+            }
+            else if (representationData.Contour) {
+                hoveredSegmentIndex =
+                    getHoveredContourSegmentationAnnotation(segmentationId);
+            }
+            else if (representationData.Surface) {
             }
         }
         if (!hoveredSegmentIndex || hoveredSegmentIndex === 0) {
@@ -107,4 +98,3 @@ class SegmentSelectTool extends BaseTool {
 }
 SegmentSelectTool.toolName = 'SegmentSelectTool';
 export default SegmentSelectTool;
-//# sourceMappingURL=SegmentSelectTool.js.map

package/dist/esm/tools/segmentation/SphereScissorsTool.d.ts

@@ -7,7 +7,6 @@ declare class SphereScissorsTool extends BaseTool {
         annotation: Annotation;
         segmentIndex: number;
         segmentsLocked: number[];
-        segmentationRepresentationUID: string;
         segmentationId: string;
         volumeId: string;
         referencedVolumeId: string;

package/dist/esm/tools/segmentation/SphereScissorsTool.js

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideSphere } from './strategies/fillSphere';
 import { eraseInsideSphere } from './strategies/eraseSphere';
@@ -8,7 +8,6 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
 import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 class SphereScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -35,14 +34,14 @@ class SphereScissorsTool extends BaseTool {
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationRepresentationUID, segmentationId } = activeSegmentationRepresentation;
+            const { segmentationId } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
-            const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(viewport.id, segmentationId, segmentIndex);
             this.isDrawing = true;
             const annotation = {
                 metadata: {
@@ -72,7 +71,6 @@ class SphereScissorsTool extends BaseTool {
             this.editData = {
                 annotation,
                 centerCanvas: canvasPos,
-                segmentationRepresentationUID,
                 segmentIndex,
                 segmentationId,
                 segmentsLocked,
@@ -89,7 +87,7 @@ class SphereScissorsTool extends BaseTool {
             };
             const { representationData } = getSegmentation(segmentationId);
             const labelmapData = representationData[SegmentationRepresentations.Labelmap];
-            if (isVolumeSegmentation(labelmapData, viewport)) {
+            if (viewport instanceof BaseVolumeViewport) {
                 const { volumeId } = labelmapData;
                 const segmentation = cache.getVolume(volumeId);
                 this.editData = {
@@ -149,7 +147,7 @@ class SphereScissorsTool extends BaseTool {
         this._endCallback = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, newAnnotation, hasMoved, segmentIndex, segmentationRepresentationUID, segmentsLocked, } = this.editData;
+            const { annotation, newAnnotation, hasMoved, segmentIndex, segmentsLocked, } = this.editData;
             const { data } = annotation;
             const { viewPlaneNormal, viewUp } = annotation.metadata;
             if (newAnnotation && !hasMoved) {
@@ -164,7 +162,6 @@ class SphereScissorsTool extends BaseTool {
                 ...this.editData,
                 points: data.handles.points,
                 segmentIndex,
-                segmentationRepresentationUID,
                 segmentsLocked,
                 viewPlaneNormal,
                 viewUp,
@@ -230,4 +227,3 @@ class SphereScissorsTool extends BaseTool {
 }
 SphereScissorsTool.toolName = 'SphereScissor';
 export default SphereScissorsTool;
-//# sourceMappingURL=SphereScissorsTool.js.map

package/dist/esm/tools/segmentation/strategies/BrushStrategy.d.ts

@@ -7,6 +7,8 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
     enabledElement: Types.IEnabledElement;
     centerIJK?: Types.Point3;
     centerWorld: Types.Point3;
+    isInObject: (point: Types.Point3) => boolean;
+    isInObjectBoundsIJK: Types.BoundsIJK;
     viewport: Types.IViewport;
     imageVoxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
     segmentationVoxelManager: Types.IVoxelManager<number>;

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -104,6 +104,8 @@ export default class BrushStrategy {
             previewVoxelManager,
             viewport,
             centerWorld: null,
+            isInObject: null,
+            isInObjectBoundsIJK: null,
             brushStrategy: this,
         };
         this._initialize.forEach((func) => func(initializedData));
@@ -138,4 +140,3 @@ function addSingletonMethod(name, isInitialized = true) {
             };
     };
 }
-//# sourceMappingURL=BrushStrategy.js.map

package/dist/esm/tools/segmentation/strategies/compositions/determineSegmentIndex.js

@@ -24,8 +24,7 @@ export default {
         };
         imageVoxelManager.forEach(callback, {
             imageData: segmentationImageData,
-            isInObject: imageVoxelManager.isInObject,
-            boundsIJK: segmentationVoxelManager.boundsIJK,
+            isInObject: operationData.isInObject,
         });
         if (!hasSegmentIndex && !hasPreviewIndex) {
             return;
@@ -48,4 +47,3 @@ export default {
         };
     },
 };
-//# sourceMappingURL=determineSegmentIndex.js.map

package/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.js

@@ -11,7 +11,7 @@ export default {
             operationName === StrategyCallbacks.OnInteractionEnd) {
             return;
         }
-        const { boundsIJK } = segmentationVoxelManager;
+        const boundsIJK = segmentationVoxelManager.getBoundsIJK();
         const { threshold: oldThreshold, dynamicRadius = 0 } = THRESHOLD;
         const useDelta = oldThreshold ? 0 : dynamicRadius;
         const nestedBounds = boundsIJK.map((ijk, idx) => {
@@ -65,4 +65,3 @@ export default {
             dynamicRadiusInCanvas;
     },
 };
-//# sourceMappingURL=dynamicThreshold.js.map

package/dist/esm/tools/segmentation/strategies/compositions/erase.js

@@ -4,4 +4,3 @@ export default {
         operationData.segmentIndex = 0;
     },
 };
-//# sourceMappingURL=erase.js.map

package/dist/esm/tools/segmentation/strategies/compositions/index.js

@@ -16,4 +16,3 @@ export default {
     setValue,
     threshold,
 };
-//# sourceMappingURL=index.js.map

package/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js

@@ -121,4 +121,3 @@ export default {
         triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
     },
 };
-//# sourceMappingURL=islandRemoval.js.map