@cornerstonejs/tools 5.4.12 → 5.4.14

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/addVolumesAsIndependentComponents.js

@@ -1,4 +1,4 @@
-import { cache, Enums, convertMapperToNotSharedMapper, volumeLoader, eventTarget, createVolumeActor, } from '@cornerstonejs/core';
+import { cache, Enums, convertMapperToNotSharedMapper, volumeLoader, eventTarget, } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../../enums/index.js';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation.js';
 const internalCache = new Map();
@@ -52,6 +52,8 @@ export async function addVolumesAsIndependentComponents({ viewport, volumeInputs
     }
     viewport.removeActors([uid]);
     const oldMapper = actor.getMapper();
+    const sharedImageData = oldMapper.getInputData();
+    const originalScalars = sharedImageData.getPointData().getScalars() ?? null;
     const mapper = convertMapperToNotSharedMapper(oldMapper);
     actor.setMapper(mapper);
     mapper.setBlendMode(Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND);
@@ -68,9 +70,16 @@ export async function addVolumesAsIndependentComponents({ viewport, volumeInputs
         .getProperty()
         .getIndependentComponents();
     actor.getProperty().setIndependentComponents(true);
+    const oldUseLabelOutline = actor.getProperty().getUseLabelOutline();
+    const oldLabelOutlineOpacity = actor.getProperty().getLabelOutlineOpacity();
+    const oldLabelOutlineThickness = actor
+        .getProperty()
+        .getLabelOutlineThickness();
+    const representationUID = volumeInputArray[0].representationUID ??
+        `${segmentationId}-${SegmentationRepresentations.Labelmap}`;
     viewport.addActor({
         ...defaultActor,
-        representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
+        representationUID,
     });
     internalCache.set(uid, {
         added: true,
@@ -82,7 +91,7 @@ export async function addVolumesAsIndependentComponents({ viewport, volumeInputs
         preLoad: load,
     });
     function onSegmentationDataModified(evt) {
-        const { segmentationId } = evt.detail;
+        const { segmentationId, modifiedSlicesToUse } = evt.detail;
         const { representationData } = getSegmentation(segmentationId);
         const { volumeId: segVolumeId } = representationData.Labelmap;
         if (segVolumeId !== segImageVolume.volumeId) {
@@ -92,19 +101,30 @@ export async function addVolumesAsIndependentComponents({ viewport, volumeInputs
         const segVoxelManager = segmentationVolume.voxelManager;
         const imageData = mapper.getInputData();
         const array = imageData.getPointData().getArray(0);
-        const baseData = array.getData();
+        const combinedData = array.getData();
         const newComp = 2;
         const dims = segImageData.getDimensions();
-        const slices = Array.from({ length: dims[2] }, (_, i) => i);
+        const sliceSize = dims[0] * dims[1];
+        const slices = modifiedSlicesToUse?.length
+            ? modifiedSlicesToUse
+            : Array.from({ length: dims[2] }, (_, i) => i);
         for (const z of slices) {
-            for (let y = 0; y < dims[1]; ++y) {
-                for (let x = 0; x < dims[0]; ++x) {
-                    const iTuple = x + dims[0] * (y + dims[1] * z);
-                    baseData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
+            const sliceStart = z * sliceSize;
+            const sliceImage = cache.getImage(segmentationVolume.imageIds?.[z]);
+            const sliceData = sliceImage?.voxelManager?.getScalarData?.();
+            if (sliceData?.length === sliceSize) {
+                for (let i = 0; i < sliceSize; ++i) {
+                    combinedData[(sliceStart + i) * newComp + 1] = sliceData[i];
+                }
+            }
+            else {
+                for (let i = 0; i < sliceSize; ++i) {
+                    const iTuple = sliceStart + i;
+                    combinedData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
                 }
             }
         }
-        array.setData(baseData);
+        array.setData(combinedData);
         imageData.modified();
         viewport.render();
     }
@@ -113,7 +133,7 @@ export async function addVolumesAsIndependentComponents({ viewport, volumeInputs
         if (evt.detail.viewportId !== viewport.id) {
             return;
         }
-        eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
+        eventTarget.removeEventListenerDebounced(Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
         eventTarget.removeEventListener(Events.SEGMENTATION_REPRESENTATION_REMOVED, onSegmentationRepresentationRemoved);
         const actorEntry = viewport.getActor(uid);
         if (actorEntry) {
@@ -124,11 +144,22 @@ export async function addVolumesAsIndependentComponents({ viewport, volumeInputs
             return;
         }
         actor.setMapper(oldMapper);
+        const pointData = sharedImageData.getPointData();
+        if (originalScalars) {
+            pointData.setScalars(originalScalars);
+        }
+        else {
+            pointData.removeArray('Pixels');
+        }
+        sharedImageData.modified();
         actor.getProperty().setColorMixPreset(oldColorMixPreset);
         actor
             .getProperty()
             .setForceNearestInterpolation(1, oldForceNearestInterpolation);
         actor.getProperty().setIndependentComponents(oldIndependentComponents);
+        actor.getProperty().setUseLabelOutline(oldUseLabelOutline);
+        actor.getProperty().setLabelOutlineOpacity(oldLabelOutlineOpacity);
+        actor.getProperty().setLabelOutlineThickness(oldLabelOutlineThickness);
         viewport.addActor({
             ...defaultActor,
         });

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

@@ -124,6 +124,7 @@ class BrushTool extends LabelmapBaseTool {
             };
             this._hoverData = this.createHoverData(element, canvasPoint);
             if (!this._hoverData) {
+                this._editData = null;
                 return false;
             }
             this._calculateCursor(element, canvasPoint);

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[];
+}