@cornerstonejs/tools 5.4.11 → 5.4.13

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

@@ -0,0 +1,4 @@
+export declare const CIRCLE_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%2300dc82'%20stroke-width='2'/%3E%3C/svg%3E\") 12 12, crosshair";
+export declare const PLUS_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%2300dc82'%20stroke-width='2'/%3E%3Cpath%20d='M12%208v8M8%2012h8'%20stroke='%2300dc82'%20stroke-width='2'%20stroke-linecap='round'/%3E%3C/svg%3E\") 12 12, copy";
+export declare const BLOCKED_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%23ff5a5a'%20stroke-width='2'/%3E%3Cpath%20d='M5.7%205.7L18.3%2018.3'%20stroke='%23ff5a5a'%20stroke-width='2'%20stroke-linecap='round'/%3E%3C/svg%3E\") 12 12, not-allowed";
+export declare const PENDING_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%23a0a6ad'%20stroke-width='2'%20stroke-dasharray='4%203'/%3E%3C/svg%3E\") 12 12, progress";

package/dist/esm/tools/annotation/regionSegmentHoverCursors.js

@@ -0,0 +1,4 @@
+export const CIRCLE_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%2300dc82'%20stroke-width='2'/%3E%3C/svg%3E\") 12 12, crosshair";
+export const PLUS_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%2300dc82'%20stroke-width='2'/%3E%3Cpath%20d='M12%208v8M8%2012h8'%20stroke='%2300dc82'%20stroke-width='2'%20stroke-linecap='round'/%3E%3C/svg%3E\") 12 12, copy";
+export const BLOCKED_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%23ff5a5a'%20stroke-width='2'/%3E%3Cpath%20d='M5.7%205.7L18.3%2018.3'%20stroke='%23ff5a5a'%20stroke-width='2'%20stroke-linecap='round'/%3E%3C/svg%3E\") 12 12, not-allowed";
+export const PENDING_CURSOR = "url(\"data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='24'%20height='24'%3E%3Ccircle%20cx='12'%20cy='12'%20r='9'%20fill='none'%20stroke='%23a0a6ad'%20stroke-width='2'%20stroke-dasharray='4%203'/%3E%3C/svg%3E\") 12 12, progress";

package/dist/esm/tools/displayTools/Labelmap/syncStackLabelmapActors.js

@@ -3,6 +3,8 @@ import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData.js';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction.js';
 import { ActorRenderMode, cache, utilities, } from '@cornerstonejs/core';
 import { triggerSegmentationRender } from '../../../stateManagement/segmentation/SegmentationRenderingEngine.js';
+import { isSegmentationOverlayCompatible } from '../../../stateManagement/segmentation/helpers/isSegmentationOverlayCompatible.js';
+import { SegmentationRepresentations } from '../../../enums/index.js';
 import { updateLabelmapSegmentationImageReferences } from '../../../stateManagement/segmentation/updateLabelmapSegmentationImageReferences.js';
 import { getCurrentLabelmapImageIdsForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport.js';
 import { getLabelmapActorEntries } from '../../../stateManagement/segmentation/helpers/getSegmentationActor.js';
@@ -18,6 +20,9 @@ export function syncStackLabelmapActors(viewport, segmentationId) {
     if (!currentImageId) {
         return;
     }
+    if (!isSegmentationOverlayCompatible(viewport, segmentationId, SegmentationRepresentations.Labelmap)) {
+        return;
+    }
     updateLabelmapSegmentationImageReferences(viewport.id, segmentationId);
     const derivedImageIds = getCurrentLabelmapImageIdsForViewport(viewport.id, segmentationId) ?? [];
     const derivedImageIdSet = new Set(derivedImageIds);

package/dist/esm/tools/index.d.ts

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

package/dist/esm/tools/index.js

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

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

@@ -111,9 +111,6 @@ class BrushTool extends LabelmapBaseTool {
                 return false;
             }
             this._editData = this.createEditData(element);
-            this._activateDraw(element);
-            hideElementCursor(element);
-            evt.preventDefault();
             this._previewData.isDrag = false;
             this._previewData.timerStart = Date.now();
             const canvasPoint = vec2.clone(currentPoints.canvas);
@@ -126,6 +123,10 @@ class BrushTool extends LabelmapBaseTool {
                 world: vec3.clone(worldPoint),
             };
             this._hoverData = this.createHoverData(element, canvasPoint);
+            if (!this._hoverData) {
+                this._editData = null;
+                return false;
+            }
             this._calculateCursor(element, canvasPoint);
             this._resetLazyEditState();
             if (this._isLazyLabelmapEditingEnabled(this._hoverData.viewport)) {
@@ -137,6 +138,9 @@ class BrushTool extends LabelmapBaseTool {
             if (!operationData) {
                 return false;
             }
+            this._activateDraw(element);
+            hideElementCursor(element);
+            evt.preventDefault();
             this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionStart);
             return true;
         };

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

@@ -2,6 +2,7 @@ import { triggerSegmentationDataModified } from '../../../stateManagement/segmen
 import compositions from './compositions/index.js';
 import { getStrategyData } from './utils/getStrategyData.js';
 import { StrategyCallbacks } from '../../../enums/index.js';
+import { memoAsStep } from '../../../utilities/segmentation/createLabelmapMemo.js';
 import { eraseCrossLayerOverwrites, prepareOverlapOperationData, } from './utils/labelmapOverlap.js';
 import { shouldUseLazyLabelmapEditing } from '../utils/shouldUseLazyLabelmapEditing.js';
 class BrushStrategy {
@@ -23,7 +24,27 @@ class BrushStrategy {
             }
             if (initializedData.memo?.segmentationVoxelManager !==
                 initializedData.segmentationVoxelManager) {
+                const previousMemo = initializedData.memo;
                 initializedData.memo = initializedData.createMemo(initializedData.segmentationId, initializedData.segmentationVoxelManager);
+                if (previousMemo &&
+                    previousMemo !== initializedData.memo &&
+                    previousMemo.commitMemo?.()) {
+                    (initializedData.memo.priorSteps ||= []).push(memoAsStep(previousMemo));
+                }
+            }
+            const moveStep = initializedData.labelmapEditTransaction?.moveStep;
+            if (moveStep && initializedData.memo) {
+                const { segmentationId } = initializedData;
+                (initializedData.memo.priorSteps ||= []).push({
+                    undo: () => {
+                        moveStep.undo();
+                        triggerSegmentationDataModified(segmentationId);
+                    },
+                    redo: () => {
+                        moveStep.redo();
+                        triggerSegmentationDataModified(segmentationId);
+                    },
+                });
             }
             if (initializedData.segmentationVoxelManager !==
                 originalSegmentationVoxelManager ||

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

@@ -1,4 +1,5 @@
 import { getSegmentation } from '../../../../stateManagement/segmentation/getSegmentation.js';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents.js';
 import { collectCrossLayerEraseBindings, eraseLabelmapEditTransactionOverwrites, } from '../../../../stateManagement/segmentation/helpers/labelmapSegmentationState.js';
 function collectCrossLayerEraseBindingsForOperation(operationData) {
     const { segmentationId, labelmapId, overwriteSegmentIndices } = operationData;
@@ -12,12 +13,31 @@ function eraseCrossLayerOverwrites(operationData) {
     if (!segmentation) {
         return [];
     }
+    const { memo } = operationData;
     return eraseLabelmapEditTransactionOverwrites(segmentation, operationData.labelmapEditTransaction, {
         viewport: operationData.viewport,
         referenceImageData: operationData.segmentationImageData,
         isInObject: operationData.isInObject,
         isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
         imageId: operationData.imageId,
+        crossLayerEraseCallback: memo
+            ? ({ voxelManager, labelValue, indices }) => {
+                (memo.postSteps ||= []).push({
+                    undo: () => {
+                        for (const index of indices) {
+                            voxelManager.setAtIndex(index, labelValue);
+                        }
+                        triggerSegmentationDataModified(operationData.segmentationId);
+                    },
+                    redo: () => {
+                        for (const index of indices) {
+                            voxelManager.setAtIndex(index, 0);
+                        }
+                        triggerSegmentationDataModified(operationData.segmentationId);
+                    },
+                });
+            }
+            : undefined,
     });
 }
 export { collectCrossLayerEraseBindingsForOperation as collectCrossLayerEraseBindings, eraseCrossLayerOverwrites, };

package/dist/esm/utilities/segmentation/commitSliceMasksToLabelmap.d.ts

@@ -0,0 +1,12 @@
+import { type Types } from '@cornerstonejs/core';
+export declare function commitSliceMasksToLabelmapVolume({ labelmapVolume, sliceMasks, width: w, height: h, paintIndex, historyVoxelManager, }: {
+    labelmapVolume: Types.IImageVolume;
+    sliceMasks: Map<number, Uint8Array>;
+    width: number;
+    height: number;
+    paintIndex: number;
+    historyVoxelManager?: Types.IVoxelManager<number>;
+}): {
+    floodedPoints: Types.Point3[];
+    voxelCount: number;
+};

package/dist/esm/utilities/segmentation/commitSliceMasksToLabelmap.js

@@ -0,0 +1,128 @@
+import { cache, utilities } from '@cornerstonejs/core';
+import { FLOOD_SLICE_FLAG_VISITED } from './floodFillSliceLazy.js';
+const { VoxelManager } = utilities;
+export function commitSliceMasksToLabelmapVolume({ labelmapVolume, sliceMasks, width: w, height: h, paintIndex, historyVoxelManager, }) {
+    const floodedPoints = [];
+    let voxelCount = 0;
+    const vm = labelmapVolume.voxelManager;
+    const historyWriter = historyVoxelManager;
+    const [labelmapWidth, labelmapHeight, depth] = labelmapVolume.dimensions;
+    if (labelmapWidth !== w || labelmapHeight !== h) {
+        throw new Error(`commitSliceMasksToLabelmapVolume: labelmap in-plane dimensions ` +
+            `${labelmapWidth}x${labelmapHeight} do not match mask dimensions ${w}x${h}`);
+    }
+    const frameSize = w * h;
+    const expectedLen = frameSize * depth;
+    const zs = Array.from(sliceMasks.keys()).sort((a, b) => a - b);
+    for (let zi = 0; zi < zs.length; zi++) {
+        const z = zs[zi];
+        if (z < 0 || z >= depth) {
+            continue;
+        }
+        const flags = sliceMasks.get(z);
+        if (!flags || flags.length !== frameSize) {
+            continue;
+        }
+        let sliceTouched = false;
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        const appendRunFlooded = (y, x0, x1) => {
+            for (let xi = x0; xi < x1; xi++) {
+                floodedPoints.push([xi, y, z]);
+            }
+            voxelCount += x1 - x0;
+            sliceTouched = true;
+            minX = Math.min(minX, x0);
+            maxX = Math.max(maxX, x1 - 1);
+            minY = Math.min(minY, y);
+            maxY = Math.max(maxY, y);
+        };
+        const denseScalar = !historyWriter &&
+            vm.scalarData &&
+            vm.scalarData.length >= expectedLen &&
+            typeof vm.scalarData.fill === 'function';
+        if (denseScalar) {
+            const base = z * frameSize;
+            const data = vm.scalarData;
+            for (let y = 0; y < h; y++) {
+                const row = y * w;
+                for (let x = 0; x < w;) {
+                    const li = row + x;
+                    if (!(flags[li] & FLOOD_SLICE_FLAG_VISITED)) {
+                        x++;
+                        continue;
+                    }
+                    const x0 = x;
+                    while (x < w && flags[row + x] & FLOOD_SLICE_FLAG_VISITED) {
+                        x++;
+                    }
+                    data.fill(paintIndex, base + row + x0, base + row + x);
+                    appendRunFlooded(y, x0, x);
+                }
+            }
+        }
+        else {
+            const imageIds = labelmapVolume.imageIds;
+            const image = imageIds?.length && z < imageIds.length
+                ? cache.getImage(imageIds[z])
+                : null;
+            const svm = image?.voxelManager;
+            if (!historyWriter &&
+                svm?.scalarData &&
+                svm.scalarData.length >= frameSize &&
+                typeof svm.scalarData.fill === 'function') {
+                const data = svm.scalarData;
+                for (let y = 0; y < h; y++) {
+                    const row = y * w;
+                    for (let x = 0; x < w;) {
+                        const li = row + x;
+                        if (!(flags[li] & FLOOD_SLICE_FLAG_VISITED)) {
+                            x++;
+                            continue;
+                        }
+                        const x0 = x;
+                        while (x < w && flags[row + x] & FLOOD_SLICE_FLAG_VISITED) {
+                            x++;
+                        }
+                        data.fill(paintIndex, row + x0, row + x);
+                        appendRunFlooded(y, x0, x);
+                    }
+                }
+                svm.modifiedSlices.add(z);
+            }
+            else {
+                const writer = historyWriter ?? vm;
+                for (let y = 0; y < h; y++) {
+                    const row = y * w;
+                    for (let x = 0; x < w; x++) {
+                        if (!(flags[row + x] & FLOOD_SLICE_FLAG_VISITED)) {
+                            continue;
+                        }
+                        const index = z * frameSize + row + x;
+                        writer.setAtIndex(index, paintIndex);
+                        floodedPoints.push([x, y, z]);
+                        voxelCount++;
+                        sliceTouched = true;
+                        minX = Math.min(minX, x);
+                        maxX = Math.max(maxX, x);
+                        minY = Math.min(minY, y);
+                        maxY = Math.max(maxY, y);
+                    }
+                }
+            }
+        }
+        if (sliceTouched) {
+            vm.modifiedSlices.add(z);
+            if (Number.isFinite(minX) &&
+                Number.isFinite(minY) &&
+                Number.isFinite(maxX) &&
+                Number.isFinite(maxY)) {
+                VoxelManager.addBounds(vm.boundsIJK, [minX, minY, z]);
+                VoxelManager.addBounds(vm.boundsIJK, [maxX, maxY, z]);
+            }
+        }
+    }
+    return { floodedPoints, voxelCount };
+}

package/dist/esm/utilities/segmentation/createEnsureSliceLoadedForVolume.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function createEnsureSliceLoadedForVolume(volume: Types.IImageVolume): (z: number) => Promise<void>;

package/dist/esm/utilities/segmentation/createEnsureSliceLoadedForVolume.js

@@ -0,0 +1,36 @@
+import { imageLoader } from '@cornerstonejs/core';
+export function createEnsureSliceLoadedForVolume(volume) {
+    const numSlices = volume.dimensions[2];
+    const imageIds = volume.imageIds;
+    if (!imageIds?.length) {
+        return async () => undefined;
+    }
+    const loadedSlices = new Set();
+    const inFlight = new Map();
+    return async function ensureSliceLoaded(z) {
+        if (!Number.isFinite(z) || z < 0 || z >= numSlices) {
+            return;
+        }
+        if (loadedSlices.has(z)) {
+            return;
+        }
+        const existing = inFlight.get(z);
+        if (existing) {
+            return existing;
+        }
+        const imageId = imageIds[z];
+        if (!imageId) {
+            return;
+        }
+        const promise = imageLoader
+            .loadImage(imageId)
+            .then(() => {
+            loadedSlices.add(z);
+        })
+            .finally(() => {
+            inFlight.delete(z);
+        });
+        inFlight.set(z, promise);
+        return promise;
+    };
+}

package/dist/esm/utilities/segmentation/createLabelmapMemo.d.ts

@@ -1,5 +1,9 @@
 import { utilities } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
+export type LabelmapRestoreStep = {
+    undo: () => void;
+    redo: () => void;
+};
 export type LabelmapMemo = Types.Memo & {
     segmentationVoxelManager: Types.IVoxelManager<number>;
     voxelManager: Types.IVoxelManager<number>;
@@ -7,6 +11,8 @@ export type LabelmapMemo = Types.Memo & {
     undoVoxelManager?: Types.IVoxelManager<number>;
     memo?: LabelmapMemo;
     id: string;
+    priorSteps?: LabelmapRestoreStep[];
+    postSteps?: LabelmapRestoreStep[];
 };
 export declare function createLabelmapMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>): {
     segmentationId: string;
@@ -17,6 +23,7 @@ export declare function createLabelmapMemo<T>(segmentationId: string, segmentati
     id: string;
     operationType: string;
 };
+export declare function memoAsStep(memo: LabelmapMemo): LabelmapRestoreStep;
 export declare function restoreMemo(isUndo?: boolean): void;
 export declare function createRleMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>): {
     segmentationId: string;

package/dist/esm/utilities/segmentation/createLabelmapMemo.js

@@ -4,14 +4,46 @@ const { VoxelManager, RLEVoxelMap } = utilities;
 export function createLabelmapMemo(segmentationId, segmentationVoxelManager) {
     return createRleMemo(segmentationId, segmentationVoxelManager);
 }
+export function memoAsStep(memo) {
+    return {
+        undo: () => memo.restoreMemo(true),
+        redo: () => memo.restoreMemo(false),
+    };
+}
 export function restoreMemo(isUndo) {
-    const { segmentationVoxelManager, undoVoxelManager, redoVoxelManager } = this;
-    const useVoxelManager = isUndo === false ? redoVoxelManager : undoVoxelManager;
-    useVoxelManager.forEach(({ value, pointIJK }) => {
-        segmentationVoxelManager.setAtIJKPoint(pointIJK, value);
-    });
-    const slices = useVoxelManager.getArrayOfModifiedSlices();
-    triggerSegmentationDataModified(this.segmentationId, slices);
+    const undo = isUndo !== false;
+    const priorSteps = this.priorSteps ?? [];
+    const postSteps = this.postSteps ?? [];
+    const restoreVoxelChanges = () => {
+        const { segmentationVoxelManager, undoVoxelManager, redoVoxelManager } = this;
+        const useVoxelManager = undo ? undoVoxelManager : redoVoxelManager;
+        if (!useVoxelManager) {
+            return;
+        }
+        useVoxelManager.forEach(({ value, pointIJK }) => {
+            segmentationVoxelManager.setAtIJKPoint(pointIJK, value);
+        });
+        const slices = useVoxelManager.getArrayOfModifiedSlices();
+        triggerSegmentationDataModified(this.segmentationId, slices);
+    };
+    if (undo) {
+        for (let i = postSteps.length - 1; i >= 0; i--) {
+            postSteps[i].undo();
+        }
+        restoreVoxelChanges();
+        for (let i = priorSteps.length - 1; i >= 0; i--) {
+            priorSteps[i].undo();
+        }
+    }
+    else {
+        for (const step of priorSteps) {
+            step.redo();
+        }
+        restoreVoxelChanges();
+        for (const step of postSteps) {
+            step.redo();
+        }
+    }
 }
 export function createRleMemo(segmentationId, segmentationVoxelManager) {
     const voxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
@@ -30,8 +62,9 @@ function commitMemo() {
     if (this.redoVoxelManager) {
         return true;
     }
+    const hasSteps = !!(this.priorSteps?.length || this.postSteps?.length);
     if (!this.voxelManager.modifiedSlices.size) {
-        return false;
+        return hasSteps;
     }
     const { segmentationVoxelManager } = this;
     const undoVoxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);

package/dist/esm/utilities/segmentation/floodFillIslandRemoval.d.ts

@@ -0,0 +1,20 @@
+import type { Types } from '@cornerstonejs/core';
+import IslandRemoval, { SegmentationEnum } from './islandRemoval.js';
+export { SegmentationEnum };
+export default class FloodFillIslandRemoval extends IslandRemoval {
+    private verboseLogging;
+    private usingPreviewLayer;
+    private internalFilledPoints;
+    constructor(options?: {
+        maxInternalRemove?: number;
+        fillInternalEdge?: boolean;
+        verboseLogging?: boolean;
+    });
+    initialize(viewport: any, segmentationVoxels: any, options: any): boolean;
+    private static countRleValueVolume;
+    floodFillSegmentIsland(): number;
+    removeExternalIslands(): number;
+    removeInternalIslands(): number[];
+    protected onInternalPointFilled(point: Types.Point3): void;
+    getInternalFilledPoints(): Types.Point3[];
+}

package/dist/esm/utilities/segmentation/floodFillIslandRemoval.js

@@ -0,0 +1,118 @@
+import { utilities } from '@cornerstonejs/core';
+import IslandRemoval, { SegmentationEnum } from './islandRemoval.js';
+const { logger } = utilities;
+const { growCutLog: islandRemovalLog } = logger;
+export { SegmentationEnum };
+export default class FloodFillIslandRemoval extends IslandRemoval {
+    constructor(options) {
+        super(options);
+        this.verboseLogging = false;
+        this.usingPreviewLayer = false;
+        this.internalFilledPoints = [];
+        this.verboseLogging = options?.verboseLogging ?? this.verboseLogging;
+    }
+    initialize(viewport, segmentationVoxels, options) {
+        this.usingPreviewLayer = !!segmentationVoxels.sourceVoxelManager;
+        const initialized = super.initialize(viewport, segmentationVoxels, options);
+        if (initialized && this.verboseLogging) {
+            const { segmentSet } = this;
+            islandRemovalLog.info('islandRemoval: initialize', {
+                segmentIndex: this.segmentIndex,
+                previewSegmentIndex: this.previewSegmentIndex,
+                segmentSetDimensions: {
+                    width: segmentSet.width,
+                    height: segmentSet.height,
+                    depth: segmentSet.depth,
+                },
+                boundsIJKPrime: segmentSet.normalizer.boundsIJKPrime,
+                clickedPoints: this.selectedPoints,
+                segmentVoxelsInPlaneGrid: FloodFillIslandRemoval.countRleValueVolume(segmentSet, SegmentationEnum.SEGMENT),
+            });
+        }
+        return initialized;
+    }
+    static countRleValueVolume(segmentSet, value) {
+        let n = 0;
+        segmentSet.forEach((_baseIndex, rle) => {
+            if (rle.value === value) {
+                n += rle.end - rle.start;
+            }
+        });
+        return n;
+    }
+    floodFillSegmentIsland() {
+        if (this.verboseLogging) {
+            const { selectedPoints, segmentSet } = this;
+            const { fromIJK } = segmentSet.normalizer;
+            for (const clickedPoint of selectedPoints) {
+                const ijkPrime = fromIJK(clickedPoint);
+                const atClick = segmentSet.get(segmentSet.toIndex(ijkPrime));
+                if (atClick !== SegmentationEnum.SEGMENT) {
+                    islandRemovalLog.info('islandRemoval: floodFillSegmentIsland click skipped (not SEGMENT)', {
+                        clickedPointVolumeIJK: clickedPoint,
+                        ijkPrime,
+                        segmentSetAtIndex: atClick,
+                    });
+                }
+            }
+        }
+        const floodedCount = super.floodFillSegmentIsland();
+        if (this.verboseLogging) {
+            islandRemovalLog.info('islandRemoval: floodFillSegmentIsland done', {
+                totalIslandVoxels: floodedCount,
+                islandVoxelsAfterFlood: FloodFillIslandRemoval.countRleValueVolume(this.segmentSet, SegmentationEnum.ISLAND),
+            });
+        }
+        return floodedCount;
+    }
+    removeExternalIslands() {
+        const { previewVoxelManager, segmentSet } = this;
+        const { toIJK } = segmentSet.normalizer;
+        const sourceVoxelManager = previewVoxelManager.sourceVoxelManager ?? previewVoxelManager;
+        if (!this.usingPreviewLayer) {
+            islandRemovalLog.warn('islandRemoval: removeExternalIslands has no preview layer; ' +
+                'external island cleanup of accepted voxels is skipped. ' +
+                'Run island removal through a preview layer to clear external islands.');
+            return 0;
+        }
+        let clearedVoxels = 0;
+        const callback = (index, rle) => {
+            const [, jPrime, kPrime] = segmentSet.toIJK(index);
+            if (rle.value !== SegmentationEnum.ISLAND) {
+                for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                    const clearPoint = toIJK([iPrime, jPrime, kPrime]);
+                    const sourceVal = sourceVoxelManager.getAtIJKPoint(clearPoint);
+                    if (sourceVal === this.previewSegmentIndex) {
+                        previewVoxelManager.setAtIJKPoint(clearPoint, null);
+                        clearedVoxels += 1;
+                    }
+                }
+            }
+        };
+        segmentSet.forEach(callback, { rowModified: true });
+        if (this.verboseLogging) {
+            islandRemovalLog.info('islandRemoval: removeExternalIslands', {
+                clearedVoxels,
+            });
+        }
+        return clearedVoxels;
+    }
+    removeInternalIslands() {
+        this.internalFilledPoints = [];
+        const modifiedSlices = super.removeInternalIslands();
+        if (this.verboseLogging) {
+            islandRemovalLog.info('islandRemoval: removeInternalIslands', {
+                modifiedSliceCount: modifiedSlices?.length,
+                internalFilledPoints: this.internalFilledPoints.length,
+                maxInternalRemove: this.maxInternalRemove,
+            });
+        }
+        return modifiedSlices;
+    }
+    onInternalPointFilled(point) {
+        this.internalFilledPoints.push(point);
+    }
+    getInternalFilledPoints() {
+        return this.internalFilledPoints;
+    }
+}

package/dist/esm/utilities/segmentation/floodFillSliceLazy.d.ts

@@ -0,0 +1,33 @@
+import type { Types } from '@cornerstonejs/core';
+export declare const FLOOD_SLICE_FLAG_VISITED = 1;
+export type FloodFillSliceLazyOptions = {
+    width: number;
+    height: number;
+    depth: number;
+    equals: (node: unknown, startNode: unknown) => boolean;
+    ensureSliceLoaded?: (z: number) => Promise<void>;
+    yieldEvery?: number;
+    planar?: boolean;
+    maxDeltaK?: number;
+    maxDeltaIJ?: number;
+    isCancelled?: () => boolean;
+    maxVoxels?: number;
+    shouldContinue?: (stats: {
+        voxelCount: number;
+        bbox: {
+            min: Types.Point3;
+            max: Types.Point3;
+        };
+    }) => boolean;
+    validateEvery?: number;
+};
+export type FloodFillSliceLazyResult = {
+    sliceMasks: Map<number, Uint8Array>;
+    voxelCount: number;
+    truncated: boolean;
+    bbox: {
+        min: Types.Point3;
+        max: Types.Point3;
+    } | null;
+};
+export declare function floodFill3dSliceLazy(getter: (x: number, y: number, z: number) => number | undefined, seed: Types.Point3, options: FloodFillSliceLazyOptions): Promise<FloodFillSliceLazyResult>;