@cornerstonejs/tools 4.22.13 → 5.0.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,7 @@ 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 {
@@ -35,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');

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,7 +1,7 @@
 import { vec3 } from 'gl-matrix';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
-import { drawCircle as drawCircleSvg } from '../../../../drawingSvg';
-import { getCenterAndRadiusInCanvas } from '../../../../utilities/getCenterAndRadiusInCanvas';
+import { drawCircle as drawCircleSvg, drawPath as drawPathSvg, } from '../../../../drawingSvg';
+import getViewportICamera from '../../../../utilities/getViewportICamera';
 export default {
     [StrategyCallbacks.CalculateCursorGeometry]: function (enabledElement, operationData) {
         if (!operationData) {
@@ -9,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();
@@ -45,6 +48,7 @@ export default {
             leftCursorInWorld,
             rightCursorInWorld,
         ];
+        data.editPoints = [...data.handles.points];
         const strategy = configuration.strategies[activeStrategy];
         if (typeof strategy?.computeInnerCircleRadius === 'function') {
             strategy.computeInnerCircleRadius({
@@ -65,28 +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 { center, radius } = getCenterAndRadiusInCanvas(points, viewport);
         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 [

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

@@ -3,7 +3,7 @@ import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 import IslandRemoval from '../../../../utilities/segmentation/islandRemoval';
 export default {
     [StrategyCallbacks.OnInteractionEnd]: (operationData) => {
-        const { previewSegmentIndex, segmentIndex, viewport, segmentationVoxelManager, activeStrategy, memo, } = operationData;
+        const { previewSegmentIndex, segmentIndex, labelValue, viewport, segmentationVoxelManager, activeStrategy, memo, } = operationData;
         if (activeStrategy !== 'THRESHOLD_INSIDE_SPHERE_WITH_ISLAND_REMOVAL' ||
             segmentIndex === null) {
             return;
@@ -12,7 +12,7 @@ export default {
         const voxelManager = memo?.voxelManager || segmentationVoxelManager;
         if (!islandRemoval.initialize(viewport, voxelManager, {
             previewSegmentIndex,
-            segmentIndex,
+            segmentIndex: labelValue ?? segmentIndex,
         })) {
             return;
         }

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

@@ -29,7 +29,7 @@ export default {
         operationData.modified = true;
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
-        const { previewSegmentIndex, segmentationVoxelManager, memo, segmentIndex, centerSegmentIndexInfo, } = operationData || {};
+        const { previewSegmentIndex, segmentationVoxelManager, memo, segmentIndex, labelValue, centerSegmentIndexInfo, } = operationData || {};
         const { changedIndices } = centerSegmentIndexInfo || {};
         const labelmapMemo = memo;
         const callback = ({ index }) => {
@@ -41,7 +41,7 @@ export default {
             }
             else {
                 if (oldValue === previewSegmentIndex) {
-                    labelmapMemo.voxelManager.setAtIndex(index, segmentIndex);
+                    labelmapMemo.voxelManager.setAtIndex(index, labelValue ?? segmentIndex);
                 }
             }
         };

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

@@ -1,25 +1,33 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 import { handleUseSegmentCenterIndex } from '../utils/handleUseSegmentCenterIndex';
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { getSegmentIndexForLabelValue } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, previewSegmentIndex, memo, segmentationVoxelManager, centerSegmentIndexInfo, segmentIndex, } = operationData;
+        const { segmentsLocked, previewSegmentIndex, memo, segmentationVoxelManager, centerSegmentIndexInfo, segmentIndex, labelValue, labelmapId, segmentationId, } = operationData;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
-        if (segmentsLocked.includes(value)) {
+        const segmentation = getSegmentation(segmentationId);
+        const existingSegmentIndex = segmentation && labelmapId
+            ? getSegmentIndexForLabelValue(segmentation, labelmapId, existingValue)
+            : existingValue;
+        const writeValue = previewSegmentIndex ?? labelValue ?? segmentIndex;
+        if (segmentsLocked.includes(existingSegmentIndex)) {
             return;
         }
-        if (!centerSegmentIndexInfo && existingValue === segmentIndex) {
+        if (!centerSegmentIndexInfo &&
+            existingValue === (labelValue ?? segmentIndex)) {
             return;
         }
         if (centerSegmentIndexInfo?.segmentIndex !== 0 &&
-            existingValue === segmentIndex) {
+            existingValue === (labelValue ?? segmentIndex)) {
             return;
         }
         if (centerSegmentIndexInfo?.segmentIndex === null) {
-            memo.voxelManager.setAtIndex(index, previewSegmentIndex ?? segmentIndex);
+            memo.voxelManager.setAtIndex(index, writeValue);
             return;
         }
         if (!previewSegmentIndex) {
-            let useSegmentIndex = segmentIndex;
+            let useSegmentIndex = labelValue ?? segmentIndex;
             if (centerSegmentIndexInfo) {
                 useSegmentIndex = centerSegmentIndexInfo.segmentIndex;
             }

package/dist/esm/tools/segmentation/strategies/utils/crossLayerErase.d.ts

@@ -0,0 +1,4 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare function collectCrossLayerEraseBindingsForOperation(operationData: InitializedOperationData): void;
+declare function eraseCrossLayerOverwrites(operationData: InitializedOperationData): number[];
+export { collectCrossLayerEraseBindingsForOperation as collectCrossLayerEraseBindings, eraseCrossLayerOverwrites, };

package/dist/esm/tools/segmentation/strategies/utils/crossLayerErase.js

@@ -0,0 +1,23 @@
+import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation';
+import { collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+function collectCrossLayerEraseBindingsForOperation(operationData) {
+    const { segmentationId, labelmapId, overwriteSegmentIndices } = operationData;
+    const segmentation = getSegmentation(segmentationId);
+    operationData.crossLayerEraseBindings = segmentation
+        ? collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices)
+        : [];
+}
+function eraseCrossLayerOverwrites(operationData) {
+    const segmentation = getSegmentation(operationData.segmentationId);
+    if (!segmentation) {
+        return [];
+    }
+    return eraseLabelmapEditTransactionOverwrites(segmentation, operationData.labelmapEditTransaction, {
+        viewport: operationData.viewport,
+        referenceImageData: operationData.segmentationImageData,
+        isInObject: operationData.isInObject,
+        isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
+        imageId: operationData.imageId,
+    });
+}
+export { collectCrossLayerEraseBindingsForOperation as collectCrossLayerEraseBindings, eraseCrossLayerOverwrites, };

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js

@@ -54,7 +54,7 @@ function getStrategyDataForStackViewport({ operationData, viewport, strategy, })
         if (!labelmapImageId) {
             return null;
         }
-        const actorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+        const actorEntry = getLabelmapActorEntry(viewport.id, segmentationId, labelmapImageId);
         if (!actorEntry) {
             return null;
         }