@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

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]);

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

@@ -1,4 +1,4 @@
-import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
+import { BaseVolumeViewport, getEnabledElement } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideRectangle } from './strategies/fillRectangle';
 import { eraseInsideRectangle } from './strategies/eraseRectangle';
@@ -9,7 +9,9 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } 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';
 class RectangleScissorsTool extends LabelmapBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -84,13 +86,18 @@ class RectangleScissorsTool 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/SegmentBidirectionalTool.js

@@ -1,3 +1,4 @@
+var _a;
 import { getEnabledElement, utilities as csUtils, getEnabledElementByViewportId, utilities, } from '@cornerstonejs/core';
 import { addAnnotation, getAllAnnotations, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
@@ -9,7 +10,6 @@ import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnota
 import BidirectionalTool from '../annotation/BidirectionalTool';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 class SegmentBidirectionalTool extends BidirectionalTool {
-    static { this.toolName = 'SegmentBidirectional'; }
     constructor(toolProps = {}) {
         super(toolProps);
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
@@ -173,68 +173,70 @@ class SegmentBidirectionalTool extends BidirectionalTool {
         triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         return annotation;
     }
-    static { this.hydrate = (viewportId, axis, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { viewport } = enabledElement;
-        const existingAnnotations = getAllAnnotations();
-        const toolAnnotations = existingAnnotations.filter((annotation) => annotation.metadata.toolName === 'SegmentBidirectional');
-        const existingAnnotation = toolAnnotations.find((annotation) => {
-            const { metadata } = annotation;
-            if (metadata.segmentIndex === options?.segmentIndex &&
-                metadata.segmentationId === options?.segmentationId) {
-                return true;
-            }
-            return false;
-        });
-        if (existingAnnotation) {
-            removeAnnotation(existingAnnotation.annotationUID);
+}
+_a = SegmentBidirectionalTool;
+SegmentBidirectionalTool.toolName = 'SegmentBidirectional';
+SegmentBidirectionalTool.hydrate = (viewportId, axis, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    const existingAnnotations = getAllAnnotations();
+    const toolAnnotations = existingAnnotations.filter((annotation) => annotation.metadata.toolName === 'SegmentBidirectional');
+    const existingAnnotation = toolAnnotations.find((annotation) => {
+        const { metadata } = annotation;
+        if (metadata.segmentIndex === options?.segmentIndex &&
+            metadata.segmentationId === options?.segmentationId) {
+            return true;
         }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, } = this.hydrateBase(SegmentBidirectionalTool, enabledElement, axis[0], options);
-        const [majorAxis, minorAxis] = axis;
-        const [major0, major1] = majorAxis;
-        const [minor0, minor1] = minorAxis;
-        const points = [major0, major1, minor0, minor1];
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || utilities.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                    activeHandleIndex: null,
-                    textBox: {
-                        hasMoved: false,
-                        worldPosition: [0, 0, 0],
-                        worldBoundingBox: {
-                            topLeft: [0, 0, 0],
-                            topRight: [0, 0, 0],
-                            bottomLeft: [0, 0, 0],
-                            bottomRight: [0, 0, 0],
-                        },
+        return false;
+    });
+    if (existingAnnotation) {
+        removeAnnotation(existingAnnotation.annotationUID);
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, } = _a.hydrateBase(_a, enabledElement, axis[0], options);
+    const [majorAxis, minorAxis] = axis;
+    const [major0, major1] = majorAxis;
+    const [minor0, minor1] = minorAxis;
+    const points = [major0, major1, minor0, minor1];
+    const { toolInstance, ...serializableOptions } = options || {};
+    const annotation = {
+        annotationUID: options?.annotationUID || utilities.uuidv4(),
+        data: {
+            handles: {
+                points,
+                activeHandleIndex: null,
+                textBox: {
+                    hasMoved: false,
+                    worldPosition: [0, 0, 0],
+                    worldBoundingBox: {
+                        topLeft: [0, 0, 0],
+                        topRight: [0, 0, 0],
+                        bottomLeft: [0, 0, 0],
+                        bottomRight: [0, 0, 0],
                     },
                 },
-                cachedStats: {},
             },
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                segmentIndex: options?.segmentIndex,
-                segmentationId: options?.segmentationId,
-                toolName: instance.getToolName(),
-                viewPlaneNormal,
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...serializableOptions,
-            },
-        };
-        addAnnotation(annotation, viewport.element);
-        triggerAnnotationRenderForViewportIds([viewport.id]);
-        return annotation;
-    }; }
-}
+            cachedStats: {},
+        },
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            segmentIndex: options?.segmentIndex,
+            segmentationId: options?.segmentationId,
+            toolName: instance.getToolName(),
+            viewPlaneNormal,
+            FrameOfReferenceUID,
+            referencedImageId,
+            ...serializableOptions,
+        },
+    };
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationRenderForViewportIds([viewport.id]);
+    return annotation;
+};
 export default SegmentBidirectionalTool;

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

@@ -8,10 +8,6 @@ import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorde
 import { state } from '../../store/state';
 import { ToolModes } from '../../enums';
 class SegmentSelectTool extends BaseTool {
-    static { this.SelectMode = {
-        Inside: 'Inside',
-        Border: 'Border',
-    }; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -98,5 +94,9 @@ class SegmentSelectTool extends BaseTool {
         triggerAnnotationRenderForViewportIds(viewportIds);
     }
 }
+SegmentSelectTool.SelectMode = {
+    Inside: 'Inside',
+    Border: 'Border',
+};
 SegmentSelectTool.toolName = 'SegmentSelectTool';
 export default SegmentSelectTool;

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

@@ -8,6 +8,9 @@ import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnota
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
 import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
 import LabelmapBaseTool from './LabelmapBaseTool';
+import getViewportICamera from '../../utilities/getViewportICamera';
+import getEllipseWorldCoordinates from '../../utilities/getEllipseWorldCoordinates';
+import { getCenterAndRadiusInCanvas } from '../../utilities/getCenterAndRadiusInCanvas';
 class SphereScissorsTool extends LabelmapBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -33,8 +36,11 @@ class SphereScissorsTool extends LabelmapBaseTool {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;
+            if (!viewPlaneNormal || !viewUp) {
+                throw new Error('Unable to resolve viewport view plane for scissors tool');
+            }
             const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
@@ -114,28 +120,9 @@ class SphereScissorsTool 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);
@@ -201,14 +188,7 @@ class SphereScissorsTool 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/strategies/BrushStrategy.d.ts

@@ -3,6 +3,7 @@ import { StrategyCallbacks } from '../../../enums';
 import type { LabelmapToolOperationDataAny } from '../../../types/LabelmapToolOperationData';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type { LabelmapMemo } from '../../../utilities/segmentation/createLabelmapMemo';
+import type { LabelmapEditTransaction } from '../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
 export type InitializedOperationData = LabelmapToolOperationDataAny & {
     operationName?: string;
     centerSegmentIndexInfo: {
@@ -48,6 +49,12 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
     };
     memo?: LabelmapMemo;
     modified?: boolean;
+    previewOnHover?: boolean;
+    labelValue?: number;
+    labelmapId?: string;
+    overwriteSegmentIndices?: number[];
+    imageId?: string;
+    labelmapEditTransaction?: LabelmapEditTransaction;
 };
 export type StrategyFunction = (operationData: InitializedOperationData, ...args: any[]) => unknown;
 export type CompositionInstance = {

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

@@ -1,30 +1,10 @@
-import { utilities as csUtils } from '@cornerstonejs/core';
 import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
 import compositions from './compositions';
 import { getStrategyData } from './utils/getStrategyData';
 import { StrategyCallbacks } from '../../../enums';
-export default class BrushStrategy {
-    static { this.COMPOSITIONS = compositions; }
-    static { this.childFunctions = {
-        [StrategyCallbacks.OnInteractionStart]: addListMethod(StrategyCallbacks.OnInteractionStart, StrategyCallbacks.Initialize),
-        [StrategyCallbacks.OnInteractionEnd]: addListMethod(StrategyCallbacks.OnInteractionEnd, StrategyCallbacks.Initialize),
-        [StrategyCallbacks.Fill]: addListMethod(StrategyCallbacks.Fill),
-        [StrategyCallbacks.Initialize]: addListMethod(StrategyCallbacks.Initialize),
-        [StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(StrategyCallbacks.CreateIsInThreshold),
-        [StrategyCallbacks.Interpolate]: addListMethod(StrategyCallbacks.Interpolate, StrategyCallbacks.Initialize),
-        [StrategyCallbacks.AcceptPreview]: addListMethod(StrategyCallbacks.AcceptPreview, StrategyCallbacks.Initialize),
-        [StrategyCallbacks.RejectPreview]: addListMethod(StrategyCallbacks.RejectPreview, StrategyCallbacks.Initialize),
-        [StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(StrategyCallbacks.INTERNAL_setValue),
-        [StrategyCallbacks.Preview]: addSingletonMethod(StrategyCallbacks.Preview, false),
-        [StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(StrategyCallbacks.ComputeInnerCircleRadius),
-        [StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation]: addListMethod(StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation),
-        [StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: addListMethod(StrategyCallbacks.EnsureImageVolumeFor3DManipulation),
-        [StrategyCallbacks.AddPreview]: addListMethod(StrategyCallbacks.AddPreview),
-        [StrategyCallbacks.GetStatistics]: addSingletonMethod(StrategyCallbacks.GetStatistics),
-        [StrategyCallbacks.CalculateCursorGeometry]: addSingletonMethod(StrategyCallbacks.CalculateCursorGeometry, true),
-        [StrategyCallbacks.RenderCursor]: addSingletonMethod(StrategyCallbacks.RenderCursor, true),
-        compositions: null,
-    }; }
+import { eraseCrossLayerOverwrites, prepareOverlapOperationData, } from './utils/labelmapOverlap';
+import { shouldUseLazyLabelmapEditing } from '../utils/shouldUseLazyLabelmapEditing';
+class BrushStrategy {
     constructor(name, ...initializers) {
         this._initialize = [];
         this._fill = [];
@@ -34,9 +14,30 @@ export default class BrushStrategy {
             if (!initializedData) {
                 return;
             }
+            const isLazyLabelmapEditing = shouldUseLazyLabelmapEditing(initializedData.viewport);
+            const shouldPrepareOverlap = !isLazyLabelmapEditing || !initializedData.previewOnHover;
+            const originalSegmentationVoxelManager = initializedData.segmentationVoxelManager;
+            const originalSegmentationImageData = initializedData.segmentationImageData;
+            if (shouldPrepareOverlap) {
+                prepareOverlapOperationData(initializedData);
+            }
+            if (initializedData.memo?.segmentationVoxelManager !==
+                initializedData.segmentationVoxelManager) {
+                initializedData.memo = initializedData.createMemo(initializedData.segmentationId, initializedData.segmentationVoxelManager);
+            }
+            if (initializedData.segmentationVoxelManager !==
+                originalSegmentationVoxelManager ||
+                initializedData.segmentationImageData !== originalSegmentationImageData) {
+                this._initialize.forEach((func) => func(initializedData));
+            }
             this._fill.forEach((func) => func(initializedData));
             const { segmentationVoxelManager, segmentIndex } = initializedData;
-            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices(), segmentIndex);
+            const crossLayerModifiedSlices = eraseCrossLayerOverwrites(initializedData);
+            const modifiedSlices = new Set([
+                ...(segmentationVoxelManager.getArrayOfModifiedSlices() ?? []),
+                ...crossLayerModifiedSlices,
+            ]);
+            triggerSegmentationDataModified(initializedData.segmentationId, Array.from(modifiedSlices), segmentIndex);
             return initializedData;
         };
         this.onInteractionStart = (enabledElement, operationData) => {
@@ -116,6 +117,28 @@ export default class BrushStrategy {
         return initializedData;
     }
 }
+BrushStrategy.COMPOSITIONS = compositions;
+BrushStrategy.childFunctions = {
+    [StrategyCallbacks.OnInteractionStart]: addListMethod(StrategyCallbacks.OnInteractionStart, StrategyCallbacks.Initialize),
+    [StrategyCallbacks.OnInteractionEnd]: addListMethod(StrategyCallbacks.OnInteractionEnd, StrategyCallbacks.Initialize),
+    [StrategyCallbacks.Fill]: addListMethod(StrategyCallbacks.Fill),
+    [StrategyCallbacks.Initialize]: addListMethod(StrategyCallbacks.Initialize),
+    [StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(StrategyCallbacks.CreateIsInThreshold),
+    [StrategyCallbacks.Interpolate]: addListMethod(StrategyCallbacks.Interpolate, StrategyCallbacks.Initialize),
+    [StrategyCallbacks.AcceptPreview]: addListMethod(StrategyCallbacks.AcceptPreview, StrategyCallbacks.Initialize),
+    [StrategyCallbacks.RejectPreview]: addListMethod(StrategyCallbacks.RejectPreview, StrategyCallbacks.Initialize),
+    [StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(StrategyCallbacks.INTERNAL_setValue),
+    [StrategyCallbacks.Preview]: addSingletonMethod(StrategyCallbacks.Preview, false),
+    [StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(StrategyCallbacks.ComputeInnerCircleRadius),
+    [StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation]: addListMethod(StrategyCallbacks.EnsureSegmentationVolumeFor3DManipulation),
+    [StrategyCallbacks.EnsureImageVolumeFor3DManipulation]: addListMethod(StrategyCallbacks.EnsureImageVolumeFor3DManipulation),
+    [StrategyCallbacks.AddPreview]: addListMethod(StrategyCallbacks.AddPreview),
+    [StrategyCallbacks.GetStatistics]: addSingletonMethod(StrategyCallbacks.GetStatistics),
+    [StrategyCallbacks.CalculateCursorGeometry]: addSingletonMethod(StrategyCallbacks.CalculateCursorGeometry, true),
+    [StrategyCallbacks.RenderCursor]: addSingletonMethod(StrategyCallbacks.RenderCursor, true),
+    compositions: null,
+};
+export default BrushStrategy;
 function addListMethod(name, createInitialized) {
     const listName = `_${name}`;
     return (brushStrategy, func) => {

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

@@ -1,6 +1,7 @@
 import { vec3 } from 'gl-matrix';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
-import { drawCircle as drawCircleSvg } from '../../../../drawingSvg';
+import { drawCircle as drawCircleSvg, drawPath as drawPathSvg, } from '../../../../drawingSvg';
+import getViewportICamera from '../../../../utilities/getViewportICamera';
 export default {
     [StrategyCallbacks.CalculateCursorGeometry]: function (enabledElement, operationData) {
         if (!operationData) {
@@ -8,8 +9,11 @@ export default {
         }
         const { configuration, activeStrategy, hoverData } = operationData;
         const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const { brushSize } = configuration;
+        if (!camera.viewUp || !camera.viewPlaneNormal) {
+            return;
+        }
         const viewUp = vec3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
         const viewPlaneNormal = vec3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
         const viewRight = vec3.create();
@@ -44,6 +48,7 @@ export default {
             leftCursorInWorld,
             rightCursorInWorld,
         ];
+        data.editPoints = [...data.handles.points];
         const strategy = configuration.strategies[activeStrategy];
         if (typeof strategy?.computeInnerCircleRadius === 'function') {
             strategy.computeInnerCircleRadius({
@@ -64,35 +69,58 @@ export default {
         if (!toolMetadata) {
             return;
         }
-        const annotationUID = toolMetadata.brushCursorUID;
+        const annotationUID = toolMetadata.brushCursorUID || 'brushCursor';
         const data = brushCursor.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 color = `rgb(${toolMetadata.segmentColor?.slice(0, 3) || [0, 0, 0]})`;
         if (!viewport.getRenderingEngine()) {
             console.warn('Rendering Engine has been destroyed');
             return;
         }
-        const circleUID = '0';
-        drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
-            color,
-            lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? [1, 2] : null,
-        });
+        const points = data.handles?.points || [];
+        const totalCircles = Math.floor((points?.length || 0) / 4);
+        const circleGeometries = [];
+        for (let i = 0; i < points.length; i += 4) {
+            const circlePoints = points.slice(i, i + 4);
+            if (circlePoints.length < 2) {
+                continue;
+            }
+            const canvasCoordinates = circlePoints.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.round(Math.abs(bottom[1] - center[1]));
+            circleGeometries.push({ center, radius });
+        }
+        const currentCircle = circleGeometries[circleGeometries.length - 1];
+        if (circleGeometries.length > 1) {
+            drawPathSvg(svgDrawingHelper, annotationUID, 'stroke-preview', circleGeometries.map((circle) => circle.center), {
+                color,
+                lineWidth: currentCircle.radius * 2,
+                strokeOpacity: 0.35,
+                lineCap: 'round',
+                lineJoin: 'round',
+                lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? '6,4' : undefined,
+            });
+        }
+        if (currentCircle) {
+            drawCircleSvg(svgDrawingHelper, annotationUID, 'current-circle', currentCircle.center, currentCircle.radius, {
+                color,
+                lineWidth: 2,
+                strokeOpacity: 1,
+                lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? [1, 2] : null,
+            }, 'brush-cursor');
+        }
         const { dynamicRadiusInCanvas } = configuration?.threshold || {
             dynamicRadiusInCanvas: 0,
         };
-        if (dynamicRadiusInCanvas) {
-            const circleUID1 = '1';
-            drawCircleSvg(svgDrawingHelper, annotationUID, circleUID1, center, dynamicRadiusInCanvas, {
+        if (dynamicRadiusInCanvas && currentCircle) {
+            const circleUID1 = 'dynamic-radius';
+            drawCircleSvg(svgDrawingHelper, annotationUID, circleUID1, currentCircle.center, dynamicRadiusInCanvas, {
                 color,
-            });
+            }, 'brush-cursor');
         }
     },
 };

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

@@ -1,7 +1,7 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.OnInteractionStart]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, viewPlaneNormal, segmentationImageData, configuration, } = operationData;
+        const { segmentIndex, labelValue, previewSegmentIndex, segmentationVoxelManager, centerIJK, viewPlaneNormal, segmentationImageData, configuration, } = operationData;
         if (!configuration?.useCenterSegmentIndex) {
             operationData.centerSegmentIndexInfo.segmentIndex = null;
             operationData.centerSegmentIndexInfo.hasSegmentIndex = false;
@@ -23,7 +23,7 @@ export default {
             nestedBounds[2] = [centerIJK[2], centerIJK[2]];
         }
         const callback = ({ value }) => {
-            hasSegmentIndex ||= value === segmentIndex;
+            hasSegmentIndex ||= value === (labelValue ?? segmentIndex);
             hasPreviewIndex ||= value === previewSegmentIndex;
         };
         segmentationVoxelManager.forEach(callback, {

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

@@ -1,5 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import getViewportICamera from '../../../../utilities/getViewportICamera';
 export default {
     [StrategyCallbacks.Initialize]: (operationData) => {
         const { operationName, centerIJK, segmentationVoxelManager, imageVoxelManager, configuration, segmentIndex, viewport, } = operationData;
@@ -13,7 +14,10 @@ export default {
         const boundsIJK = segmentationVoxelManager.getBoundsIJK();
         const { range: oldThreshold, dynamicRadius = 0 } = configuration.threshold;
         const useDelta = oldThreshold ? 0 : dynamicRadius;
-        const { viewPlaneNormal } = viewport.getCamera();
+        const { viewPlaneNormal } = getViewportICamera(viewport);
+        if (!viewPlaneNormal) {
+            return;
+        }
         const nestedBounds = boundsIJK.map((ijk, idx) => {
             const [min, max] = ijk;
             return [