@cornerstonejs/tools 5.0.0-beta.1 → 5.0.1

package/dist/esm/tools/index.js

@@ -55,9 +55,10 @@ import CircleROIStartEndThresholdTool from './segmentation/CircleROIStartEndThre
 import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
+import OrientationControllerTool from './OrientationControllerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
 import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
 import LabelMapEditWithContourTool from './segmentation/LabelmapEditWithContour';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };

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

@@ -4,11 +4,18 @@ import LabelmapBaseTool from './LabelmapBaseTool';
 declare class BrushTool extends LabelmapBaseTool {
     static toolName: any;
     private _lastDragInfo;
+    private _lazyEdit;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    onSetToolPassive: (evt: any) => void;
+    onSetToolPassive: (_evt: any) => void;
     onSetToolEnabled: () => void;
-    onSetToolDisabled: (evt: any) => void;
+    onSetToolDisabled: (_evt: any) => void;
     private disableCursor;
+    private _isLazyLabelmapEditingEnabled;
+    private _resetLazyEditState;
+    private _clearPendingLazyPreviewCleanup;
+    private _refreshCursor;
+    private _scheduleLazyPreviewCleanup;
+    private _captureLazyPreviewCircle;
     preMouseDownCallback: (evt: EventTypes.MouseDownActivateEventType) => boolean;
     mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
     previewCallback: () => void;

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

@@ -1,4 +1,4 @@
-import { getEnabledElement, eventTarget } from '@cornerstonejs/core';
+import { getEnabledElement, eventTarget, Enums } from '@cornerstonejs/core';
 import { vec3, vec2 } from 'gl-matrix';
 import { Events, ToolModes, StrategyCallbacks } from '../../enums';
 import { fillInsideSphere, thresholdInsideSphere, thresholdInsideSphereIsland, } from './strategies/fillSphere';
@@ -9,6 +9,9 @@ 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 = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -80,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) => {
@@ -94,6 +98,18 @@ class BrushTool extends LabelmapBaseTool {
             const { element, currentPoints } = eventData;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
+            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 false;
+            }
             this._editData = this.createEditData(element);
             this._activateDraw(element);
             hideElementCursor(element);
@@ -109,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;
@@ -164,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;
@@ -191,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);
@@ -221,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,
@@ -249,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);
@@ -275,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) {
@@ -312,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;
     }
@@ -327,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,11 @@ 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 {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -90,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 {
@@ -123,28 +132,9 @@ class CircleScissorsTool extends LabelmapBaseTool {
             const { canvasToWorld } = viewport;
             const { annotation, viewportIdsToRender, centerCanvas } = this.editData;
             const { data } = annotation;
-            const dX = Math.abs(currentCanvasPoints[0] - centerCanvas[0]);
-            const dY = Math.abs(currentCanvasPoints[1] - centerCanvas[1]);
-            const radius = Math.sqrt(dX * dX + dY * dY);
-            const bottomCanvas = [
-                centerCanvas[0],
-                centerCanvas[1] + radius,
-            ];
-            const topCanvas = [centerCanvas[0], centerCanvas[1] - radius];
-            const leftCanvas = [
-                centerCanvas[0] - radius,
-                centerCanvas[1],
-            ];
-            const rightCanvas = [
-                centerCanvas[0] + radius,
-                centerCanvas[1],
-            ];
-            data.handles.points = [
-                canvasToWorld(bottomCanvas),
-                canvasToWorld(topCanvas),
-                canvasToWorld(leftCanvas),
-                canvasToWorld(rightCanvas),
-            ];
+            const centerWorld = canvasToWorld(centerCanvas);
+            const currentWorld = canvasToWorld(currentCanvasPoints);
+            data.handles.points = getEllipseWorldCoordinates([centerWorld, currentWorld], viewport);
             annotation.invalidated = true;
             this.editData.hasMoved = true;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
@@ -207,14 +197,7 @@ class CircleScissorsTool extends LabelmapBaseTool {
             const annotationUID = annotation.annotationUID;
             const data = annotation.data;
             const { points } = data.handles;
-            const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-            const bottom = canvasCoordinates[0];
-            const top = canvasCoordinates[1];
-            const center = [
-                Math.floor((bottom[0] + top[0]) / 2),
-                Math.floor((bottom[1] + top[1]) / 2),
-            ];
-            const radius = Math.abs(bottom[1] - Math.floor((bottom[1] + top[1]) / 2));
+            const { center, radius } = getCenterAndRadiusInCanvas(points, viewport);
             const color = `rgb(${toolMetadata.segmentColor.slice(0, 3)})`;
             if (!viewport.getRenderingEngine()) {
                 console.warn('Rendering Engine has been destroyed');

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);
@@ -86,14 +84,6 @@ export default class LabelmapBaseTool extends BaseTool {
         const { viewport } = enabledElement;
         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;
@@ -108,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;
@@ -151,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],
@@ -200,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;
@@ -216,7 +227,7 @@ export default class LabelmapBaseTool extends BaseTool {
         }
         const operationData = {
             ...editData,
-            points: data?.handles?.points,
+            points,
             segmentIndex,
             viewPlaneNormal,
             previewOnHover: !this._previewData.isDrag,
@@ -243,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;
@@ -257,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;
     }
@@ -266,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,
@@ -365,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;