@cornerstonejs/tools 5.4.12 → 5.4.14

package/dist/esm/eventListeners/segmentation/segmentationDataModifiedEventListener.js

@@ -1,4 +1,4 @@
-import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine.js';
+import { triggerSegmentationRenderForModified } from '../../stateManagement/segmentation/SegmentationRenderingEngine.js';
 import onLabelmapSegmentationDataModified from './labelmap/onLabelmapSegmentationDataModified.js';
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation.js';
 const onSegmentationDataModified = function (evt) {
@@ -7,6 +7,6 @@ const onSegmentationDataModified = function (evt) {
     if (representationData.Labelmap) {
         onLabelmapSegmentationDataModified(evt);
     }
-    triggerSegmentationRenderBySegmentationId(segmentationId);
+    triggerSegmentationRenderForModified(segmentationId);
 };
 export default onSegmentationDataModified;

package/dist/esm/index.d.ts

@@ -12,7 +12,7 @@ import * as Types from './types/index.js';
 import * as annotation from './stateManagement/annotation/index.js';
 import * as segmentation from './stateManagement/segmentation/index.js';
 import * as splines from './tools/annotation/splines/index.js';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool } from './tools/index.js';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool } from './tools/index.js';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool.js';
 import * as Enums from './enums/index.js';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };

package/dist/esm/index.js

@@ -12,7 +12,7 @@ import * as Types from './types/index.js';
 import * as annotation from './stateManagement/annotation/index.js';
 import * as segmentation from './stateManagement/segmentation/index.js';
 import * as splines from './tools/annotation/splines/index.js';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool, } from './tools/index.js';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool, } from './tools/index.js';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool.js';
 import * as Enums from './enums/index.js';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };

package/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.d.ts

@@ -17,5 +17,6 @@ declare class SegmentationRenderingEngine {
 }
 declare function triggerSegmentationRender(viewportId?: string): void;
 declare function triggerSegmentationRenderBySegmentationId(segmentationId?: string): void;
+declare function triggerSegmentationRenderForModified(segmentationId?: string): void;
 declare const segmentationRenderingEngine: SegmentationRenderingEngine;
-export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, triggerSegmentationRenderForModified, segmentationRenderingEngine, };

package/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.js

@@ -169,5 +169,49 @@ function triggerSegmentationRender(viewportId) {
 function triggerSegmentationRenderBySegmentationId(segmentationId) {
     segmentationRenderingEngine.renderSegmentation(segmentationId);
 }
+const DEFERRED_SEGMENTATION_RENDER_DELAY_MS = 240;
+const deferredSegmentationRenderTimers = new Map();
+function isProjectionHeavySegmentationViewport(viewport) {
+    const blendMode = viewport.getBlendMode?.();
+    if (blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND) {
+        return true;
+    }
+    const planarViewport = viewport;
+    if (typeof planarViewport.getDisplaySetPresentation !== 'function') {
+        return false;
+    }
+    const dataIds = [];
+    const sourceDataId = planarViewport.getSourceDataId?.();
+    if (sourceDataId) {
+        dataIds.push(sourceDataId);
+    }
+    planarViewport.getActors?.().forEach((actorEntry) => {
+        if (actorEntry.representationUID) {
+            dataIds.push(String(actorEntry.representationUID));
+        }
+    });
+    return dataIds.some((dataId) => (planarViewport.getDisplaySetPresentation(dataId)?.slabThickness ?? 0) > 0);
+}
+function triggerSegmentationRenderForModified(segmentationId) {
+    const viewportIds = segmentationRenderingEngine._getViewportIdsForSegmentation(segmentationId);
+    viewportIds.forEach((viewportId) => {
+        const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+        if (!viewport) {
+            return;
+        }
+        if (!isProjectionHeavySegmentationViewport(viewport)) {
+            segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
+            return;
+        }
+        const existingTimer = deferredSegmentationRenderTimers.get(viewportId);
+        if (existingTimer !== undefined) {
+            clearTimeout(existingTimer);
+        }
+        deferredSegmentationRenderTimers.set(viewportId, setTimeout(() => {
+            deferredSegmentationRenderTimers.delete(viewportId);
+            segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
+        }, DEFERRED_SEGMENTATION_RENDER_DELAY_MS));
+    });
+}
 const segmentationRenderingEngine = new SegmentationRenderingEngine();
-export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, triggerSegmentationRenderForModified, segmentationRenderingEngine, };

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapEditTransaction.d.ts

@@ -2,7 +2,15 @@ import type { Types } from '@cornerstonejs/core';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type { Segmentation } from '../../../types/SegmentationStateTypes.js';
 import type { LabelmapLayer, SegmentLabelmapBindingState } from '../../../types/LabelmapTypes.js';
-type MoveSegmentToPrivateLabelmap = (segmentation: Segmentation, segmentIndex: number) => LabelmapLayer | undefined;
+import type { LabelmapRestoreStep } from '../../../utilities/segmentation/createLabelmapMemo.js';
+type CrossLayerEraseRecord = {
+    voxelManager: Types.IVoxelManager<number>;
+    labelValue: number;
+    indices: number[];
+};
+type MoveSegmentToPrivateLabelmap = (segmentation: Segmentation, segmentIndex: number, options?: {
+    moveStepCallback?: (step: LabelmapRestoreStep) => void;
+}) => LabelmapLayer | undefined;
 type BeginLabelmapEditTransactionOptions = {
     segmentIndex: number;
     overwriteSegmentIndices?: number[];
@@ -22,6 +30,7 @@ type LabelmapEditTransaction = {
     protectedSegmentIndices: number[];
     crossLayerEraseBindings: SegmentLabelmapBindingState[];
     movedSegment: boolean;
+    moveStep?: LabelmapRestoreStep;
 };
 type ResolveLabelmapLayerEditTargetOptions = {
     viewport?: Types.IViewport;
@@ -42,6 +51,7 @@ type EraseLabelmapEditTransactionOptions = {
     isInObject: (point: Types.Point3) => boolean;
     isInObjectBoundsIJK?: Types.BoundsIJK;
     imageId?: string;
+    crossLayerEraseCallback?: (record: CrossLayerEraseRecord) => void;
 };
 declare function getProtectedSegmentIndicesForLayer(segmentation: Segmentation, labelmapId: string, segmentIndex: number, overwriteSegmentIndices?: number[]): number[];
 declare function hasProtectedSegmentOverwrite(segmentation: Segmentation, labelmapId: string, protectedSegmentIndices: number[], voxelManager?: Types.IVoxelManager<number>, options?: Pick<BeginLabelmapEditTransactionOptions, 'segmentationImageData' | 'isInObject' | 'isInObjectBoundsIJK'>): boolean;
@@ -51,4 +61,4 @@ declare function getLabelmapLayerImageId(layer: LabelmapLayer, options?: Resolve
 declare function resolveLabelmapLayerEditTarget(layer: LabelmapLayer, options?: ResolveLabelmapLayerEditTargetOptions): LabelmapLayerEditTarget;
 declare function eraseLabelmapEditTransactionOverwrites(segmentation: Segmentation, transaction: LabelmapEditTransaction | undefined, options: EraseLabelmapEditTransactionOptions): number[];
 export { beginLabelmapEditTransaction, collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, getLabelmapLayerImageId, getProtectedSegmentIndicesForLayer, hasProtectedSegmentOverwrite, resolveLabelmapLayerEditTarget, };
-export type { BeginLabelmapEditTransactionOptions, EraseLabelmapEditTransactionOptions, LabelmapEditTransaction, LabelmapLayerEditTarget, ResolveLabelmapLayerEditTargetOptions, };
+export type { BeginLabelmapEditTransactionOptions, CrossLayerEraseRecord, EraseLabelmapEditTransactionOptions, LabelmapEditTransaction, LabelmapLayerEditTarget, ResolveLabelmapLayerEditTargetOptions, };

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapEditTransaction.js

@@ -72,10 +72,11 @@ function beginLabelmapEditTransaction(segmentation, options) {
         isInObject: options.isInObject,
         isInObjectBoundsIJK: options.isInObjectBoundsIJK,
     });
+    let moveStep;
     if (shouldMoveSegment) {
         const moveSegmentToPrivateLabelmap = options.moveSegmentToPrivateLabelmap ??
             defaultMoveSegmentToPrivateLabelmap;
-        const privateLayer = moveSegmentToPrivateLabelmap(segmentation, segmentIndex);
+        const privateLayer = moveSegmentToPrivateLabelmap(segmentation, segmentIndex, { moveStepCallback: (step) => (moveStep = step) });
         const privateBinding = getSegmentBinding(segmentation, segmentIndex);
         if (privateLayer && privateBinding) {
             activeLayer = privateLayer;
@@ -100,6 +101,7 @@ function beginLabelmapEditTransaction(segmentation, options) {
         protectedSegmentIndices,
         crossLayerEraseBindings: collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices),
         movedSegment,
+        moveStep,
     };
 }
 function getViewportImageIds(viewport) {
@@ -158,6 +160,7 @@ function eraseVolumeLayer(layer, binding, options, modifiedSlices) {
     if (!volume) {
         return;
     }
+    const erasedIndices = [];
     volume.voxelManager.forEach(({ value, index, pointIJK }) => {
         if (value !== binding.labelValue) {
             return;
@@ -167,10 +170,18 @@ function eraseVolumeLayer(layer, binding, options, modifiedSlices) {
             return;
         }
         volume.voxelManager.setAtIndex(index, 0);
+        erasedIndices.push(index);
     }, {
         imageData: volume.imageData,
         boundsIJK: options.isInObjectBoundsIJK,
     });
+    if (erasedIndices.length) {
+        options.crossLayerEraseCallback?.({
+            voxelManager: volume.voxelManager,
+            labelValue: binding.labelValue,
+            indices: erasedIndices,
+        });
+    }
     volume.voxelManager
         ?.getArrayOfModifiedSlices?.()
         ?.forEach((sliceIndex) => modifiedSlices.add(sliceIndex));
@@ -185,6 +196,7 @@ function eraseStackLayer(layer, binding, options, modifiedSlices) {
     if (!image || !voxelManager) {
         return;
     }
+    const erasedIndices = [];
     voxelManager.forEach(({ value, index, pointIJK }) => {
         if (value !== binding.labelValue) {
             return;
@@ -194,10 +206,18 @@ function eraseStackLayer(layer, binding, options, modifiedSlices) {
             return;
         }
         voxelManager.setAtIndex(index, 0);
+        erasedIndices.push(index);
     }, {
         imageData: options.referenceImageData,
         boundsIJK: options.isInObjectBoundsIJK,
     });
+    if (erasedIndices.length) {
+        options.crossLayerEraseCallback?.({
+            voxelManager,
+            labelValue: binding.labelValue,
+            indices: erasedIndices,
+        });
+    }
     const currentSlice = stackViewport.getCurrentImageIdIndex?.();
     if (typeof currentSlice === 'number') {
         modifiedSlices.add(currentSlice);

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapImageReferenceResolver.d.ts

@@ -5,6 +5,7 @@ declare class LabelmapImageReferenceResolver {
     private readonly stackLabelmapImageIdReferenceMap;
     private readonly labelmapImageIdReferenceMap;
     private readonly keysBySegmentationId;
+    private readonly completedScanResultsBySegmentationId;
     constructor(getSegmentation: GetSegmentation);
     reset(): void;
     removeSegmentation(segmentationId: string): void;
@@ -12,6 +13,10 @@ declare class LabelmapImageReferenceResolver {
     getLabelmapImageIds(representationData: RepresentationsData): any;
     getLabelmapImageIdsForImageId(imageId: string, segmentationId: string): string[];
     updateLabelmapSegmentationImageReferences(viewportId: string, segmentationId: string): string | undefined;
+    private generateScanKey;
+    private hasCompletedScan;
+    private getCompletedScanResult;
+    private markCompletedScan;
     getCurrentLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string[] | undefined;
     getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
     getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];

package/dist/esm/stateManagement/segmentation/labelmapModel/labelmapImageReferenceResolver.js

@@ -10,15 +10,18 @@ class LabelmapImageReferenceResolver {
         this.stackLabelmapImageIdReferenceMap = new Map();
         this.labelmapImageIdReferenceMap = new Map();
         this.keysBySegmentationId = new Map();
+        this.completedScanResultsBySegmentationId = new Map();
         this.getSegmentation = getSegmentation;
     }
     reset() {
         this.stackLabelmapImageIdReferenceMap.clear();
         this.labelmapImageIdReferenceMap.clear();
         this.keysBySegmentationId.clear();
+        this.completedScanResultsBySegmentationId.clear();
     }
     removeSegmentation(segmentationId) {
         this.stackLabelmapImageIdReferenceMap.delete(segmentationId);
+        this.completedScanResultsBySegmentationId.delete(segmentationId);
         const keys = this.keysBySegmentationId.get(segmentationId);
         if (keys) {
             for (const key of keys) {
@@ -92,7 +95,43 @@ class LabelmapImageReferenceResolver {
         if (!enabledElement || !labelmapImageIds?.length) {
             return;
         }
-        return this.updateLabelmapSegmentationReferences(segmentationId, enabledElement.viewport, labelmapImageIds);
+        const viewport = enabledElement.viewport;
+        const scanKey = this.generateScanKey('current', viewport, labelmapImageIds);
+        if (scanKey && this.hasCompletedScan(segmentationId, scanKey)) {
+            return this.getCompletedScanResult(segmentationId, scanKey);
+        }
+        const result = this.updateLabelmapSegmentationReferences(segmentationId, viewport, labelmapImageIds);
+        if (scanKey) {
+            this.markCompletedScan(segmentationId, scanKey, result);
+        }
+        return result;
+    }
+    generateScanKey(kind, viewport, labelmapImageIds) {
+        const referenceImageId = typeof viewport.getCurrentImageId === 'function'
+            ? viewport.getCurrentImageId()
+            : undefined;
+        if (!referenceImageId) {
+            return;
+        }
+        return `${kind}|${viewport.id}|${referenceImageId}|${labelmapImageIds.length}|${labelmapImageIds[0]}|${labelmapImageIds[labelmapImageIds.length - 1]}`;
+    }
+    hasCompletedScan(segmentationId, scanKey) {
+        return !!this.completedScanResultsBySegmentationId
+            .get(segmentationId)
+            ?.has(scanKey);
+    }
+    getCompletedScanResult(segmentationId, scanKey) {
+        return this.completedScanResultsBySegmentationId
+            .get(segmentationId)
+            ?.get(scanKey);
+    }
+    markCompletedScan(segmentationId, scanKey, result) {
+        let results = this.completedScanResultsBySegmentationId.get(segmentationId);
+        if (!results) {
+            results = new Map();
+            this.completedScanResultsBySegmentationId.set(segmentationId, results);
+        }
+        results.set(scanKey, result);
     }
     getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
@@ -233,6 +272,13 @@ class LabelmapImageReferenceResolver {
             return;
         }
         const stackViewport = enabledElement.viewport;
+        const scanKey = this.generateScanKey('all', stackViewport, labelmapImageIds);
+        if (scanKey && this.hasCompletedScan(segmentationId, scanKey)) {
+            return;
+        }
+        if (scanKey) {
+            this.markCompletedScan(segmentationId, scanKey);
+        }
         this.updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, (stackViewport, segmentationId, labelmapImageIds) => {
             const imageIds = stackViewport.getImageIds();
             imageIds.forEach((referenceImageId, index) => {

package/dist/esm/stateManagement/segmentation/labelmapModel/privateLabelmap.d.ts

@@ -1,5 +1,9 @@
 import type { Segmentation } from '../../../types/SegmentationStateTypes.js';
 import type { LabelmapLayer } from '../../../types/LabelmapTypes.js';
+import type { LabelmapRestoreStep } from '../../../utilities/segmentation/createLabelmapMemo.js';
+type MoveSegmentToPrivateLabelmapOptions = {
+    moveStepCallback?: (step: LabelmapRestoreStep) => void;
+};
 declare function createPrivateLabelmap(segmentation: Segmentation, sourceLabelmap: LabelmapLayer): LabelmapLayer;
-declare function moveSegmentToPrivateLabelmap(segmentation: Segmentation, segmentIndex: number): LabelmapLayer | undefined;
+declare function moveSegmentToPrivateLabelmap(segmentation: Segmentation, segmentIndex: number, options?: MoveSegmentToPrivateLabelmapOptions): LabelmapLayer | undefined;
 export { createPrivateLabelmap, moveSegmentToPrivateLabelmap };

package/dist/esm/stateManagement/segmentation/labelmapModel/privateLabelmap.js

@@ -1,5 +1,5 @@
 import { cache, imageLoader, utilities as csUtils, volumeLoader, } from '@cornerstonejs/core';
-import { getLabelmap, registerLabelmap } from './labelmapLayerStore.js';
+import { getLabelmap, registerLabelmap, removeLabelmap, } from './labelmapLayerStore.js';
 import { getSegmentBinding, getSegmentsOnLabelmap, setSegmentBinding, } from './labelmapSegmentBindings.js';
 import { syncLegacyLabelmapData } from './labelmapLegacyAdapter.js';
 function createPrivateVolumeLabelmap(segmentation, sourceLabelmap) {
@@ -53,7 +53,7 @@ function createPrivateLabelmap(segmentation, sourceLabelmap) {
     }
     return createPrivateStackLabelmap(segmentation, sourceLabelmap);
 }
-function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
+function moveSegmentToPrivateLabelmap(segmentation, segmentIndex, options = {}) {
     const binding = getSegmentBinding(segmentation, segmentIndex);
     if (!binding) {
         return;
@@ -67,16 +67,26 @@ function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
     }
     const privateLabelmap = createPrivateLabelmap(segmentation, sourceLabelmap);
     registerLabelmap(segmentation, privateLabelmap);
+    const movedVoxels = [];
     if (sourceLabelmap.volumeId && privateLabelmap.volumeId) {
         const sourceVolume = cache.getVolume(sourceLabelmap.volumeId);
         const targetVolume = cache.getVolume(privateLabelmap.volumeId);
+        const indices = [];
         sourceVolume.voxelManager.forEach(({ value, index }) => {
             if (value !== binding.labelValue) {
                 return;
             }
             targetVolume.voxelManager.setAtIndex(index, 1);
             sourceVolume.voxelManager.setAtIndex(index, 0);
+            indices.push(index);
         });
+        if (indices.length) {
+            movedVoxels.push({
+                source: sourceVolume.voxelManager,
+                target: targetVolume.voxelManager,
+                indices,
+            });
+        }
     }
     else {
         const sourceImageIds = sourceLabelmap.imageIds ?? [];
@@ -87,20 +97,55 @@ function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
             if (!sourceImage || !targetImage) {
                 return;
             }
+            const indices = [];
             sourceImage.voxelManager.forEach(({ value, index }) => {
                 if (value !== binding.labelValue) {
                     return;
                 }
                 targetImage.voxelManager.setAtIndex(index, 1);
                 sourceImage.voxelManager.setAtIndex(index, 0);
+                indices.push(index);
             });
+            if (indices.length) {
+                movedVoxels.push({
+                    source: sourceImage.voxelManager,
+                    target: targetImage.voxelManager,
+                    indices,
+                });
+            }
         });
     }
-    setSegmentBinding(segmentation, segmentIndex, {
+    const previousBinding = { ...binding };
+    const newBinding = {
         labelmapId: privateLabelmap.labelmapId,
         labelValue: 1,
-    });
+    };
+    setSegmentBinding(segmentation, segmentIndex, { ...newBinding });
     syncLegacyLabelmapData(segmentation);
+    options.moveStepCallback?.({
+        undo: () => {
+            for (const { source, target, indices } of movedVoxels) {
+                for (const index of indices) {
+                    target.setAtIndex(index, 0);
+                    source.setAtIndex(index, previousBinding.labelValue);
+                }
+            }
+            setSegmentBinding(segmentation, segmentIndex, { ...previousBinding });
+            removeLabelmap(segmentation, privateLabelmap.labelmapId);
+            syncLegacyLabelmapData(segmentation);
+        },
+        redo: () => {
+            registerLabelmap(segmentation, privateLabelmap);
+            for (const { source, target, indices } of movedVoxels) {
+                for (const index of indices) {
+                    source.setAtIndex(index, 0);
+                    target.setAtIndex(index, 1);
+                }
+            }
+            setSegmentBinding(segmentation, segmentIndex, { ...newBinding });
+            syncLegacyLabelmapData(segmentation);
+        },
+    });
     return privateLabelmap;
 }
 export { createPrivateLabelmap, moveSegmentToPrivateLabelmap };

package/dist/esm/tools/annotation/ClickSegmentTool.d.ts

@@ -0,0 +1,51 @@
+import type { EventTypes, PublicToolProps, ToolProps } from '../../types/index.js';
+import GrowCutBaseTool from '../base/GrowCutBaseTool.js';
+declare class ClickSegmentTool extends GrowCutBaseTool {
+    static toolName: string;
+    private segmentationInProgress;
+    private hoverThrottleTimer;
+    private pendingHoverEvent;
+    private lastHoverElement;
+    private lastProbe;
+    private lastClick;
+    private clickAbortController;
+    private dryRunToken;
+    private confirmedRegion;
+    private rejectedRegions;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    private notifySegmentationError;
+    cancelInProgress(): boolean;
+    cancelActiveOperation(): boolean;
+    private clearHoverState;
+    private pointerOnConfirmedRegion;
+    private static bandsAreSimilar;
+    private matchesRejectedRegion;
+    private rememberRejectedRegion;
+    private safeSpacing;
+    private computeVoxelBudget;
+    private makeRegionShapeGate;
+    onSetToolPassive(): void;
+    onSetToolDisabled(): void;
+    private buildProbeOptions;
+    mouseMoveCallback(evt: EventTypes.MouseMoveEventType): void;
+    private queueHoverProbe;
+    private flushHoverProbe;
+    private getViewportSliceIndex;
+    private runHoverProbe;
+    private neighborsAgree;
+    private runConfinementDryRun;
+    private probeAppliesToClick;
+    preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
+    private runClick;
+    private fillWithRange;
+    private indexToWorld;
+    private beginLabelmapMemo;
+    private curveSizeAt;
+    private pickNextTolerance;
+    expand(): void;
+    shrink(): void;
+    refresh(): void;
+    private stepTolerance;
+    private refillAtTolerance;
+}
+export default ClickSegmentTool;