@cornerstonejs/tools 4.22.13 → 5.0.0

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

@@ -9,6 +9,8 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
 import LabelmapBaseTool from './LabelmapBaseTool';
 import { getStrategyData } from './strategies/utils/getStrategyData';
+import LazyBrushEditController from './utils/LazyBrushEditController';
+import { shouldUseLazyLabelmapEditing } from './utils/shouldUseLazyLabelmapEditing';
 import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
 class BrushTool extends LabelmapBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -81,13 +83,14 @@ class BrushTool extends LabelmapBaseTool {
     }) {
         super(toolProps, defaultToolProps);
         this._lastDragInfo = null;
-        this.onSetToolPassive = (evt) => {
+        this._lazyEdit = new LazyBrushEditController();
+        this.onSetToolPassive = (_evt) => {
             this.disableCursor();
         };
         this.onSetToolEnabled = () => {
             this.disableCursor();
         };
-        this.onSetToolDisabled = (evt) => {
+        this.onSetToolDisabled = (_evt) => {
             this.disableCursor();
         };
         this.preMouseDownCallback = (evt) => {
@@ -122,8 +125,14 @@ class BrushTool extends LabelmapBaseTool {
                 canvas: canvasPoint,
                 world: vec3.clone(worldPoint),
             };
-            const hoverData = this._hoverData || this.createHoverData(element);
-            triggerAnnotationRenderForViewportUIDs(hoverData.viewportIdsToRender);
+            this._hoverData = this.createHoverData(element, canvasPoint);
+            this._calculateCursor(element, canvasPoint);
+            this._resetLazyEditState();
+            if (this._isLazyLabelmapEditingEnabled(this._hoverData.viewport)) {
+                this._lazyEdit.appendStrokePoint(worldPoint);
+                this._captureLazyPreviewCircle();
+            }
+            triggerAnnotationRenderForViewportUIDs(this._hoverData.viewportIdsToRender);
             const operationData = this.getOperationData(element);
             if (!operationData) {
                 return false;
@@ -177,6 +186,9 @@ class BrushTool extends LabelmapBaseTool {
             }
             this._previewData.timer = null;
             const operationData = this.getOperationData(this._previewData.element);
+            if (!operationData) {
+                return;
+            }
             const enabledElement = getEnabledElement(this._previewData.element);
             if (!enabledElement) {
                 return;
@@ -204,6 +216,9 @@ class BrushTool extends LabelmapBaseTool {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             this.updateCursor(evt);
+            if (!this._hoverData) {
+                return;
+            }
             const { viewportIdsToRender } = this._hoverData;
             triggerAnnotationRenderForViewportUIDs(viewportIdsToRender);
             const delta = vec2.distance(currentPoints.canvas, this._previewData.startPoint);
@@ -234,16 +249,26 @@ class BrushTool extends LabelmapBaseTool {
                 currentCanvas[1],
             ]);
             this._hoverData = this.createHoverData(element, currentCanvas);
-            this._calculateCursor(element, currentCanvas);
-            const operationData = this.getOperationData(element);
-            if (!operationData) {
+            if (!this._hoverData) {
                 return;
             }
-            operationData.strokePointsWorld = [
-                vec3.clone(this._lastDragInfo.world),
-                vec3.clone(currentWorld),
-            ];
-            this._previewData.preview = this.applyActiveStrategy(enabledElement, operationData);
+            this._calculateCursor(element, currentCanvas);
+            if (this._isLazyLabelmapEditingEnabled(this._hoverData.viewport)) {
+                this._lazyEdit.appendStrokePoint(currentWorld);
+                this._captureLazyPreviewCircle();
+                this._previewData.preview = null;
+            }
+            else {
+                const operationData = this.getOperationData(element);
+                if (!operationData) {
+                    return;
+                }
+                operationData.strokePointsWorld = [
+                    vec3.clone(this._lastDragInfo.world),
+                    vec3.clone(currentWorld),
+                ];
+                this._previewData.preview = this.applyActiveStrategy(enabledElement, operationData);
+            }
             const currentCanvasClone = vec2.clone(currentCanvas);
             this._lastDragInfo = {
                 canvas: currentCanvasClone,
@@ -262,15 +287,29 @@ class BrushTool extends LabelmapBaseTool {
             if (!operationData) {
                 return;
             }
-            if (!this._previewData.preview && !this._previewData.isDrag) {
+            const isLazyLabelmapEditing = this._isLazyLabelmapEditingEnabled(this._hoverData?.viewport);
+            if (isLazyLabelmapEditing && this._previewData.isDrag) {
+                operationData.strokePointsWorld = this._lazyEdit
+                    .getStrokePointsWorld()
+                    .map((point) => vec3.clone(point));
+                this.applyActiveStrategy(enabledElement, operationData);
+            }
+            else if (!this._previewData.preview && !this._previewData.isDrag) {
                 this.applyActiveStrategy(enabledElement, operationData);
             }
             this.doneEditMemo();
             this._deactivateDraw(element);
             resetElementCursor(element);
-            this.updateCursor(evt);
             this._editData = null;
             this._lastDragInfo = null;
+            if (isLazyLabelmapEditing && this._previewData.isDrag) {
+                this._scheduleLazyPreviewCleanup(element, evt.detail.currentPoints.canvas, enabledElement.viewport.id, operationData.segmentationId);
+                triggerAnnotationRenderForViewportUIDs(this._hoverData.viewportIdsToRender);
+            }
+            else {
+                this._resetLazyEditState();
+                this.updateCursor(evt);
+            }
             this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionEnd);
             if (!this._previewData.isDrag) {
                 this.acceptPreview(element);
@@ -288,32 +327,69 @@ class BrushTool extends LabelmapBaseTool {
         };
     }
     disableCursor() {
+        this._clearPendingLazyPreviewCleanup();
         this._hoverData = undefined;
+        this._resetLazyEditState();
         this.rejectPreview();
     }
-    updateCursor(evt) {
-        const eventData = evt.detail;
-        const { element } = eventData;
-        const { currentPoints } = eventData;
-        const centerCanvas = currentPoints.canvas;
+    _isLazyLabelmapEditingEnabled(viewport) {
+        return shouldUseLazyLabelmapEditing(viewport ?? this._hoverData?.viewport);
+    }
+    _resetLazyEditState() {
+        this._lazyEdit.reset();
+    }
+    _clearPendingLazyPreviewCleanup() {
+        this._lazyEdit.clearPendingCleanup();
+    }
+    _refreshCursor(element, centerCanvas) {
         this._hoverData = this.createHoverData(element, centerCanvas);
-        this._calculateCursor(element, centerCanvas);
         if (!this._hoverData) {
             return;
         }
+        this._calculateCursor(element, centerCanvas);
         BrushTool.activeCursorTool = this;
         triggerAnnotationRenderForViewportUIDs(this._hoverData.viewportIdsToRender);
     }
-    _calculateCursor(element, centerCanvas) {
+    _scheduleLazyPreviewCleanup(element, centerCanvas, viewportId, segmentationId) {
+        this._lazyEdit.scheduleCleanup({
+            element,
+            centerCanvas,
+            viewportId,
+            segmentationId,
+            refreshCursor: this._refreshCursor.bind(this),
+        });
+    }
+    _captureLazyPreviewCircle() {
+        if (!this._isLazyLabelmapEditingEnabled() || !this._hoverData) {
+            return;
+        }
+        this._lazyEdit.capturePreviewCircle(this._hoverData);
+    }
+    updateCursor(evt) {
+        const eventData = evt.detail;
+        const { element } = eventData;
+        const { currentPoints } = eventData;
+        const centerCanvas = currentPoints.canvas;
+        this._refreshCursor(element, centerCanvas);
+    }
+    _calculateCursor(element, _centerCanvas) {
         const enabledElement = getEnabledElement(element);
-        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.CalculateCursorGeometry);
+        const operationData = this.getOperationData(element);
+        if (!enabledElement || !operationData) {
+            return;
+        }
+        this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.CalculateCursorGeometry);
     }
     getStatistics(element, segmentIndices) {
         if (!element) {
             return;
         }
         const enabledElement = getEnabledElement(element);
-        const stats = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.GetStatistics, segmentIndices);
+        const operationData = this.getOperationData(element);
+        if (!enabledElement || !operationData) {
+            return;
+        }
+        const stats = this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.GetStatistics, segmentIndices);
         return stats;
     }
     rejectPreview(element = this._previewData.element) {
@@ -325,7 +401,11 @@ class BrushTool extends LabelmapBaseTool {
         if (!enabledElement) {
             return;
         }
-        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
+        const operationData = this.getOperationData(element);
+        if (!operationData) {
+            return;
+        }
+        this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.RejectPreview);
         this._previewData.preview = null;
         this._previewData.isDrag = false;
     }
@@ -340,7 +420,11 @@ class BrushTool extends LabelmapBaseTool {
             return;
         }
         const enabledElement = getEnabledElement(element);
-        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.Interpolate, config.configuration);
+        const operationData = this.getOperationData(element);
+        if (!enabledElement || !operationData) {
+            return;
+        }
+        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.Interpolate, config.configuration);
         this._previewData.isDrag = true;
     }
     invalidateBrushCursor() {

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

@@ -1,4 +1,4 @@
-import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
+import { BaseVolumeViewport, getEnabledElement } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideCircle } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
@@ -8,7 +8,9 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, config as segmentationConfig, } from '../../stateManagement/segmentation';
 import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
 import LabelmapBaseTool from './LabelmapBaseTool';
+import { getOrCreateLabelmapVolume, resolveLabelmapForSegment, } from '../../stateManagement/segmentation/helpers/labelmapSegmentationState';
 import getEllipseWorldCoordinates from '../../utilities/getEllipseWorldCoordinates';
 import getCenterAndRadiusInCanvas from '../../utilities/getCenterAndRadiusInCanvas';
 class CircleScissorsTool extends LabelmapBaseTool {
@@ -92,13 +94,18 @@ class CircleScissorsTool extends LabelmapBaseTool {
                 referencedVolumeId: null,
                 imageId: null,
             };
-            if (viewport instanceof BaseVolumeViewport) {
-                const { volumeId } = labelmapData;
-                const segmentation = cache.getVolume(volumeId);
+            const viewportRenderMode = getViewportLabelmapRenderMode(viewport);
+            if (viewportRenderMode === 'volume' ||
+                viewport instanceof BaseVolumeViewport) {
+                const layer = resolveLabelmapForSegment(getSegmentation(segmentationId), segmentIndex);
+                const segmentation = layer ? getOrCreateLabelmapVolume(layer) : undefined;
+                if (!segmentation) {
+                    return;
+                }
                 this.editData = {
                     ...this.editData,
-                    volumeId,
-                    referencedVolumeId: segmentation.referencedVolumeId,
+                    volumeId: segmentation.volumeId,
+                    referencedVolumeId: layer?.referencedVolumeId ?? segmentation.referencedVolumeId,
                 };
             }
             else {

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

@@ -1,4 +1,3 @@
-import { StackViewport } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
@@ -92,7 +91,7 @@ export default class LabelmapBaseTool extends BaseTool {
         };
         centerCanvas: any;
         segmentIndex: number;
-        viewport: StackViewport | import("@cornerstonejs/core").VolumeViewport;
+        viewport: Types.IStackViewport | import("@cornerstonejs/core").VolumeViewport;
         segmentationId: string;
         segmentColor: Types.Color;
         viewportIdsToRender: string[];
@@ -102,7 +101,7 @@ export default class LabelmapBaseTool extends BaseTool {
         segmentationId: string;
         segmentColor: Types.Color;
     };
-    protected getOperationData(element?: any): ModifiedLabelmapToolOperationData;
+    protected getOperationData(element?: any): ModifiedLabelmapToolOperationData | undefined;
     addPreview(element?: HTMLDivElement, options?: {
         acceptReject: boolean;
     }): any;

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

@@ -1,4 +1,4 @@
-import { getEnabledElement, cache, utilities as csUtils, Enums, eventTarget, BaseVolumeViewport, StackViewport, } from '@cornerstonejs/core';
+import { getEnabledElement, cache, utilities as csUtils, Enums, eventTarget, BaseVolumeViewport, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
@@ -14,15 +14,10 @@ import { filterAnnotationsForDisplay } from '../../utilities/planar';
 import { isPointInsidePolyline3D } from '../../utilities/math/polyline';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { fillInsideCircle } from './strategies';
-export default class LabelmapBaseTool extends BaseTool {
-    static { this.previewData = {
-        preview: null,
-        element: null,
-        timerStart: 0,
-        timer: null,
-        startPoint: [NaN, NaN],
-        isDrag: false,
-    }; }
+import getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import { getOrCreateLabelmapVolume, resolveLabelmapForSegment, } from '../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+import getViewportICamera from '../../utilities/getViewportICamera';
+class LabelmapBaseTool extends BaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
         this.memoMap = new Map();
@@ -44,6 +39,9 @@ export default class LabelmapBaseTool extends BaseTool {
             const memoData = this.acceptedMemoIds.get(id);
             const element = memoData?.element;
             const operationData = this.getOperationData(element);
+            if (!operationData) {
+                return;
+            }
             operationData.segmentIndex = memoData?.segmentIndex;
             if (element) {
                 this.applyActiveStrategyCallback(getEnabledElement(element), operationData, StrategyCallbacks.AcceptPreview);
@@ -100,40 +98,37 @@ export default class LabelmapBaseTool extends BaseTool {
         return editData;
     }
     getEditData({ viewport, representationData, segmentsLocked, segmentationId, }) {
-        if (viewport instanceof BaseVolumeViewport) {
-            if (!representationData[SegmentationRepresentations.Labelmap]) {
-                return;
-            }
-            const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
-            if (!volumeId) {
+        const viewportRenderMode = getViewportLabelmapRenderMode(viewport);
+        const activeSegmentIndex = getActiveSegmentIndex(segmentationId);
+        const segmentation = getSegmentation(segmentationId);
+        const layerForEdit = activeSegmentIndex
+            ? resolveLabelmapForSegment(segmentation, activeSegmentIndex)
+            : undefined;
+        if (viewportRenderMode === 'volume' ||
+            viewport instanceof BaseVolumeViewport) {
+            const segmentationVolume = layerForEdit
+                ? getOrCreateLabelmapVolume(layerForEdit)
+                : undefined;
+            const volumeId = layerForEdit?.volumeId ?? segmentationVolume?.volumeId;
+            if (!segmentationVolume || !volumeId) {
                 return;
             }
             const actors = viewport.getActors();
-            const isStackViewport = viewport instanceof StackViewport;
-            if (isStackViewport) {
-                const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
-                    detail: {
-                        type: 'Segmentation',
-                        message: 'Cannot perform brush operation on the selected viewport',
-                    },
-                    cancelable: true,
-                });
-                eventTarget.dispatchEvent(event);
-                return null;
-            }
             const volumes = actors
                 .filter((actorEntry) => actorEntry.referencedId)
-                .map((actorEntry) => cache.getVolume(actorEntry.referencedId));
-            const segmentationVolume = cache.getVolume(volumeId);
+                .map((actorEntry) => cache.getVolume(actorEntry.referencedId))
+                .filter((volume) => !!volume);
             const referencedVolumeIdToThreshold = volumes.find((volume) => csUtils.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
             return {
                 volumeId,
                 referencedVolumeId: this.configuration.threshold?.volumeId ??
+                    layerForEdit?.referencedVolumeId ??
+                    segmentationVolume.referencedVolumeId ??
                     referencedVolumeIdToThreshold,
                 segmentsLocked,
             };
         }
-        else {
+        if (viewportRenderMode === 'image') {
             const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
             if (!segmentationImageId) {
                 return;
@@ -143,14 +138,30 @@ export default class LabelmapBaseTool extends BaseTool {
                 segmentsLocked,
             };
         }
+        const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+            detail: {
+                type: 'Segmentation',
+                message: 'Cannot perform brush operation on the selected viewport',
+            },
+            cancelable: true,
+        });
+        eventTarget.dispatchEvent(event);
+        return null;
     }
     createHoverData(element, centerCanvas) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const { viewPlaneNormal, viewUp } = camera;
+        if (!viewPlaneNormal || !viewUp) {
+            return;
+        }
         const viewportIdsToRender = [viewport.id];
-        const { segmentIndex, segmentationId, segmentColor } = this.getActiveSegmentationData(viewport) || {};
+        const activeSegmentationData = this.getActiveSegmentationData(viewport);
+        if (!activeSegmentationData) {
+            return;
+        }
+        const { segmentIndex, segmentationId, segmentColor } = activeSegmentationData;
         const brushCursor = {
             metadata: {
                 viewPlaneNormal: [...viewPlaneNormal],
@@ -192,11 +203,19 @@ export default class LabelmapBaseTool extends BaseTool {
     }
     getOperationData(element) {
         const editData = this._editData || this.createEditData(element);
-        const { segmentIndex, segmentationId, brushCursor } = this._hoverData || this.createHoverData(element);
+        const hoverData = this._hoverData || this.createHoverData(element);
+        if (!editData || !hoverData) {
+            return;
+        }
+        const { segmentIndex, segmentationId, brushCursor } = hoverData;
         const { data, metadata = {} } = brushCursor || {};
         const { viewPlaneNormal, viewUp } = metadata;
+        const points = data?.editPoints || data?.handles?.points;
         const configColor = this.configuration.preview?.previewColors?.[segmentIndex];
-        const { viewport } = getEnabledElement(element);
+        const { viewport } = getEnabledElement(element) || {};
+        if (!viewport || !segmentIndex || !segmentationId) {
+            return;
+        }
         const segmentColor = getSegmentIndexColor(viewport.id, segmentationId, segmentIndex);
         if (!configColor && !segmentColor) {
             return;
@@ -208,7 +227,7 @@ export default class LabelmapBaseTool extends BaseTool {
         }
         const operationData = {
             ...editData,
-            points: data?.handles?.points,
+            points,
             segmentIndex,
             viewPlaneNormal,
             previewOnHover: !this._previewData.isDrag,
@@ -235,7 +254,11 @@ export default class LabelmapBaseTool extends BaseTool {
             this.rejectPreview(element);
         }
         const enabledElement = getEnabledElement(element);
-        const results = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
+        const operationData = this.getOperationData(element);
+        if (!enabledElement || !operationData) {
+            return;
+        }
+        const results = this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.AddPreview);
         _previewData.isDrag = true;
         if (results?.modified) {
             _previewData.preview = results;
@@ -249,7 +272,11 @@ export default class LabelmapBaseTool extends BaseTool {
         }
         this.doneEditMemo();
         const enabledElement = getEnabledElement(element);
-        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
+        const operationData = this.getOperationData(element);
+        if (!enabledElement || !operationData) {
+            return;
+        }
+        this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.RejectPreview);
         this._previewData.preview = null;
         this._previewData.isDrag = false;
     }
@@ -258,6 +285,9 @@ export default class LabelmapBaseTool extends BaseTool {
             return;
         }
         const operationData = this.getOperationData(element);
+        if (!operationData) {
+            return;
+        }
         if (this.memo && this.memo.id) {
             this.acceptedMemoIds.set(this.memo.id, {
                 element,
@@ -357,6 +387,15 @@ export default class LabelmapBaseTool extends BaseTool {
         triggerSegmentationDataModified(segmentationId, slices);
     }
 }
+LabelmapBaseTool.previewData = {
+    preview: null,
+    element: null,
+    timerStart: 0,
+    timer: null,
+    startPoint: [NaN, NaN],
+    isDrag: false,
+};
+export default LabelmapBaseTool;
 function lightenColor(r, g, b, a, factor = 0.4) {
     return [
         Math.round(r + (255 - r) * factor),

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

@@ -5,9 +5,6 @@ import BrushTool from './BrushTool';
 import * as segmentation from '../../stateManagement/segmentation';
 import { getSegmentationRepresentationsBySegmentationId } from '../../stateManagement/segmentation/getSegmentationRepresentation';
 class LabelMapEditWithContourTool extends PlanarFreehandContourSegmentationTool {
-    static { this.toolName = 'LabelMapEditWithContour'; }
-    static { this.annotationsToViewportMap = new Map(); }
-    static { this.viewportIdsChecked = []; }
     constructor(toolProps = {}) {
         const initialProps = utilities.deepMerge({
             configuration: {
@@ -119,4 +116,7 @@ class LabelMapEditWithContourTool extends PlanarFreehandContourSegmentationTool
         }
     }
 }
+LabelMapEditWithContourTool.toolName = 'LabelMapEditWithContour';
+LabelMapEditWithContourTool.annotationsToViewportMap = new Map();
+LabelMapEditWithContourTool.viewportIdsChecked = [];
 export default LabelMapEditWithContourTool;

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

@@ -1,10 +1,12 @@
-import { cache, getEnabledElement, utilities as csUtils, BaseVolumeViewport, } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, utilities as csUtils, } 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 getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import { getOrCreateLabelmapVolume, resolveLabelmapForSegment, } from '../../stateManagement/segmentation/helpers/labelmapSegmentationState';
 const { transformWorldToIndex, isEqual } = csUtils;
 class PaintFillTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -32,9 +34,14 @@ class PaintFillTool extends BaseTool {
             let index;
             let voxelManager;
             this.doneEditMemo();
-            if (viewport instanceof BaseVolumeViewport) {
-                const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
-                const segmentation = cache.getVolume(volumeId);
+            const viewportRenderMode = getViewportLabelmapRenderMode(viewport);
+            if (viewportRenderMode === 'volume' ||
+                viewport instanceof BaseVolumeViewport) {
+                const layer = resolveLabelmapForSegment(getSegmentation(segmentationId), segmentIndex);
+                const segmentation = layer ? getOrCreateLabelmapVolume(layer) : undefined;
+                if (!segmentation) {
+                    return;
+                }
                 ({ dimensions, direction } = segmentation);
                 voxelManager = segmentation.voxelManager;
                 index = transformWorldToIndex(segmentation.imageData, worldPos);

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

@@ -16,6 +16,8 @@ declare class RectangleROIStartEndThresholdTool extends RectangleROITool {
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    private _isCoordinateTuple;
+    private _resolveViewPlaneCoordinate;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => {
         highlighted: boolean;
         invalidated: boolean;

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

@@ -137,6 +137,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             }
             const targetId = this.getTargetId(enabledElement.viewport);
             const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
+            this._computeProjectionPoints(annotation, imageVolume);
             this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             if (newAnnotation) {
@@ -172,19 +173,16 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 const color = this.getStyle('color', styleSpecifier, annotation);
                 const focalPoint = viewport.getCamera().focalPoint;
                 const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
-                let startCoord = startCoordinate;
-                let endCoord = endCoordinate;
-                if (Array.isArray(startCoordinate)) {
-                    startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                let startCoord = this._resolveViewPlaneCoordinate(startCoordinate, viewplaneNormal);
+                let endCoord = this._resolveViewPlaneCoordinate(endCoordinate, viewplaneNormal);
+                if (this._isCoordinateTuple(startCoordinate)) {
                     const indexOfDirection = this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal);
                     data.handles.points.forEach((point) => {
                         point[indexOfDirection] = startCoord;
                     });
                     data.startCoordinate = startCoord;
                 }
-                if (Array.isArray(endCoordinate)) {
-                    endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
-                    data.endCoordinate = endCoord;
+                if (this._isCoordinateTuple(endCoordinate)) {
                     data.endCoordinate = endCoord;
                 }
                 const roundedStartCoord = csUtils.roundToPrecision(startCoord);
@@ -264,11 +262,21 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             this._throttledCalculateCachedStats = debounce(this._calculateCachedStatsTool, this.configuration.throttleTimeout);
         }
     }
+    _isCoordinateTuple(value) {
+        return Array.isArray(value) || ArrayBuffer.isView(value);
+    }
+    _resolveViewPlaneCoordinate(coordinate, viewPlaneNormal) {
+        if (this._isCoordinateTuple(coordinate)) {
+            return this._getCoordinateForViewplaneNormal(coordinate, viewPlaneNormal);
+        }
+        return coordinate;
+    }
     _computeProjectionPoints(annotation, imageVolume) {
         const { data, metadata } = annotation;
         const { viewPlaneNormal, spacingInNormal } = metadata;
         const { imageData } = imageVolume;
-        const { startCoordinate, endCoordinate } = data;
+        const startCoordinate = this._resolveViewPlaneCoordinate(data.startCoordinate, viewPlaneNormal);
+        const endCoordinate = this._resolveViewPlaneCoordinate(data.endCoordinate, viewPlaneNormal);
         const { points } = data.handles;
         const startIJK = transformWorldToIndex(imageData, points[0]);
         const endIJK = transformWorldToIndex(imageData, points[0]);