@cornerstonejs/tools 3.7.17 → 3.8.1

package/dist/esm/enums/Events.d.ts

@@ -22,6 +22,8 @@ declare enum Events {
     SEGMENTATION_REMOVED = "CORNERSTONE_TOOLS_SEGMENTATION_REMOVED",
     SEGMENTATION_REPRESENTATION_REMOVED = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_REMOVED",
     SEGMENTATION_DATA_MODIFIED = "CORNERSTONE_TOOLS_SEGMENTATION_DATA_MODIFIED",
+    HISTORY_UNDO = "CORNERSTONE_TOOLS_HISTORY_UNDO",
+    HISTORY_REDO = "CORNERSTONE_TOOLS_HISTORY_REDO",
     KEY_DOWN = "CORNERSTONE_TOOLS_KEY_DOWN",
     KEY_UP = "CORNERSTONE_TOOLS_KEY_UP",
     MOUSE_DOWN = "CORNERSTONE_TOOLS_MOUSE_DOWN",

package/dist/esm/enums/Events.js

@@ -23,6 +23,8 @@ var Events;
     Events["SEGMENTATION_REMOVED"] = "CORNERSTONE_TOOLS_SEGMENTATION_REMOVED";
     Events["SEGMENTATION_REPRESENTATION_REMOVED"] = "CORNERSTONE_TOOLS_SEGMENTATION_REPRESENTATION_REMOVED";
     Events["SEGMENTATION_DATA_MODIFIED"] = "CORNERSTONE_TOOLS_SEGMENTATION_DATA_MODIFIED";
+    Events["HISTORY_UNDO"] = "CORNERSTONE_TOOLS_HISTORY_UNDO";
+    Events["HISTORY_REDO"] = "CORNERSTONE_TOOLS_HISTORY_REDO";
     Events["KEY_DOWN"] = "CORNERSTONE_TOOLS_KEY_DOWN";
     Events["KEY_UP"] = "CORNERSTONE_TOOLS_KEY_UP";
     Events["MOUSE_DOWN"] = "CORNERSTONE_TOOLS_MOUSE_DOWN";

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

@@ -24,6 +24,7 @@ export default class SegmentationStateManager {
     updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
     _updateAllLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): void;
     getLabelmapImageIds(representationData: RepresentationsData): any;
+    getLabelmapImageIdsForImageId(imageId: string, segmentationId: string): string[];
     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/SegmentationStateManager.js

@@ -253,6 +253,13 @@ export default class SegmentationStateManager {
         }
         return labelmapImageIds;
     }
+    getLabelmapImageIdsForImageId(imageId, segmentationId) {
+        const key = this._generateMapKey({
+            segmentationId,
+            referenceImageId: imageId,
+        });
+        return this._labelmapImageIdReferenceMap.get(key);
+    }
     getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
         if (!enabledElement) {
@@ -260,11 +267,7 @@ export default class SegmentationStateManager {
         }
         const stackViewport = enabledElement.viewport;
         const referenceImageId = stackViewport.getCurrentImageId();
-        const key = this._generateMapKey({
-            segmentationId,
-            referenceImageId,
-        });
-        return this._labelmapImageIdReferenceMap.get(key);
+        return this.getLabelmapImageIdsForImageId(referenceImageId, segmentationId);
     }
     getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
         const enabledElement = getEnabledElementByViewportId(viewportId);

package/dist/esm/stateManagement/segmentation/config/segmentationColor.js

@@ -34,7 +34,8 @@ function getSegmentIndexColor(viewportId, segmentationId, segmentIndex) {
     let colorValue = colorLUT[segmentIndex];
     if (!colorValue) {
         if (typeof segmentIndex !== 'number') {
-            throw new Error(`Can't create colour for LUT index ${segmentIndex}`);
+            console.warn(`Can't create colour for LUT index ${segmentIndex}`);
+            return null;
         }
         colorValue = colorLUT[segmentIndex] = [0, 0, 0, 0];
     }

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

@@ -1,2 +1,3 @@
 export declare function getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string;
 export declare function getCurrentLabelmapImageIdsForViewport(viewportId: string, segmentationId: string): string[];
+export declare function getLabelmapImageIdsForImageId(imageId: string, segmentationId: string): string[];

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

@@ -7,3 +7,7 @@ export function getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId
     const segmentationStateManager = defaultSegmentationStateManager;
     return segmentationStateManager.getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
 }
+export function getLabelmapImageIdsForImageId(imageId, segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getLabelmapImageIdsForImageId(imageId, segmentationId);
+}

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

@@ -19,10 +19,12 @@ import * as strategies from './../../tools/segmentation/strategies';
 import { removeAllSegmentations, removeSegmentation } from './removeSegmentation';
 import { segmentationStyle } from './SegmentationStyle';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId } from './getCurrentLabelmapImageIdForViewport';
+import { getActiveSegmentation } from './getActiveSegmentation';
 declare const helpers: {
     clearSegmentValue: typeof clearSegmentValue;
     convertStackToVolumeLabelmap: typeof convertStackToVolumeLabelmap;
     computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
     convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };

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

@@ -19,10 +19,12 @@ import * as strategies from './../../tools/segmentation/strategies';
 import { removeAllSegmentations, removeSegmentation, } from './removeSegmentation';
 import { segmentationStyle } from './SegmentationStyle';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, } from './getCurrentLabelmapImageIdForViewport';
+import { getActiveSegmentation } from './getActiveSegmentation';
 const helpers = {
     clearSegmentValue,
     convertStackToVolumeLabelmap,
     computeVolumeLabelmapFromStack,
     convertVolumeToStackLabelmap,
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, segmentationStyle, defaultSegmentationStateManager, getCurrentLabelmapImageIdsForViewport, getLabelmapImageIdsForImageId, getActiveSegmentation, };

package/dist/esm/tools/base/AnnotationTool.d.ts

@@ -53,6 +53,8 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
         deleting?: boolean;
     }): {
         restoreMemo: () => void;
+        id: string;
+        operationType: string;
     };
     protected createMemo(element: any, annotation: any, options?: any): void;
     protected static hydrateBase<T extends AnnotationTool>(ToolClass: new () => T, enabledElement: Types.IEnabledElement, points: Types.Point3[], options?: {

package/dist/esm/tools/base/AnnotationTool.js

@@ -259,6 +259,8 @@ class AnnotationTool extends AnnotationDisplayTool {
                 currentAnnotation.invalidated = true;
                 triggerAnnotationModified(currentAnnotation, element, ChangeTypes.History);
             },
+            id: annotationUID,
+            operationType: 'annotation',
         };
         DefaultHistoryMemo.push(annotationMemo);
         return annotationMemo;

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -17,8 +17,8 @@ declare class BrushTool extends LabelmapBaseTool {
     private _endCallback;
     getStatistics(element: any, segmentIndices?: any): any;
     rejectPreview(element?: HTMLDivElement): void;
-    interpolate(element: any, config: any): void;
     acceptPreview(element?: HTMLDivElement): void;
+    interpolate(element: any, config: any): void;
     private _activateDraw;
     private _deactivateDraw;
     invalidateBrushCursor(): void;

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

@@ -1,14 +1,15 @@
-import { getEnabledElement } from '@cornerstonejs/core';
+import { getEnabledElement, eventTarget } from '@cornerstonejs/core';
 import { vec3, vec2 } from 'gl-matrix';
+import { Events, ToolModes, StrategyCallbacks } from '../../enums';
 import { fillInsideSphere, thresholdInsideSphere, thresholdInsideSphereIsland, } from './strategies/fillSphere';
 import { eraseInsideSphere } from './strategies/eraseSphere';
 import { thresholdInsideCircle, fillInsideCircle, } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
-import { Events, ToolModes, StrategyCallbacks } from '../../enums';
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
 import LabelmapBaseTool from './LabelmapBaseTool';
+import { getStrategyData } from './strategies/utils/getStrategyData';
 class BrushTool extends LabelmapBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -25,6 +26,7 @@ class BrushTool extends LabelmapBaseTool {
             defaultStrategy: 'FILL_INSIDE_CIRCLE',
             activeStrategy: 'FILL_INSIDE_CIRCLE',
             brushSize: 25,
+            useCenterSegmentIndex: false,
             preview: {
                 enabled: false,
                 previewColors: {
@@ -112,7 +114,10 @@ class BrushTool extends LabelmapBaseTool {
                 const { previewTimeMs, previewMoveDistance, dragMoveDistance } = this.configuration.preview;
                 const { currentPoints, element } = evt.detail;
                 const { canvas } = currentPoints;
-                const { preview, startPoint, timer, timerStart, isDrag } = this._previewData;
+                const { startPoint, timer, timerStart, isDrag } = this._previewData;
+                if (isDrag) {
+                    return;
+                }
                 const delta = vec2.distance(canvas, startPoint);
                 const time = Date.now() - timerStart;
                 if (delta > previewMoveDistance ||
@@ -121,7 +126,7 @@ class BrushTool extends LabelmapBaseTool {
                         window.clearTimeout(timer);
                         this._previewData.timer = null;
                     }
-                    if (preview && !isDrag) {
+                    if (!isDrag) {
                         this.rejectPreview(element);
                     }
                 }
@@ -137,11 +142,32 @@ class BrushTool extends LabelmapBaseTool {
             }
         };
         this.previewCallback = () => {
+            if (this._previewData.isDrag) {
+                this._previewData.timer = null;
+                return;
+            }
             this._previewData.timer = null;
-            if (this._previewData.preview) {
+            const operationData = this.getOperationData(this._previewData.element);
+            const enabledElement = getEnabledElement(this._previewData.element);
+            if (!enabledElement) {
                 return;
             }
-            this._previewData.preview = this.applyActiveStrategyCallback(getEnabledElement(this._previewData.element), this.getOperationData(this._previewData.element), StrategyCallbacks.Preview);
+            const { viewport } = enabledElement;
+            const activeStrategy = this.configuration.activeStrategy;
+            const strategyData = getStrategyData({
+                operationData,
+                viewport,
+                strategy: activeStrategy,
+            });
+            if (!operationData) {
+                return;
+            }
+            const memo = this.createMemo(operationData.segmentationId, strategyData.segmentationVoxelManager);
+            this._previewData.preview = this.applyActiveStrategyCallback(getEnabledElement(this._previewData.element), {
+                ...operationData,
+                ...strategyData,
+                memo,
+            }, StrategyCallbacks.Preview);
         };
         this._dragCallback = (evt) => {
             const eventData = evt.detail;
@@ -153,11 +179,14 @@ class BrushTool extends LabelmapBaseTool {
             const delta = vec2.distance(currentPoints.canvas, this._previewData.startPoint);
             const { dragTimeMs, dragMoveDistance } = this.configuration.preview;
             if (!this._previewData.isDrag &&
-                this._previewData.preview &&
                 Date.now() - this._previewData.timerStart < dragTimeMs &&
                 delta < dragMoveDistance) {
                 return;
             }
+            if (this._previewData.timer) {
+                window.clearTimeout(this._previewData.timer);
+                this._previewData.timer = null;
+            }
             this._previewData.preview = this.applyActiveStrategy(enabledElement, this.getOperationData(element));
             this._previewData.element = element;
             this._previewData.timerStart = Date.now() + dragTimeMs;
@@ -171,8 +200,8 @@ class BrushTool extends LabelmapBaseTool {
             const operationData = this.getOperationData(element);
             if (!this._previewData.preview && !this._previewData.isDrag) {
                 this.applyActiveStrategy(enabledElement, operationData);
+                this.doneEditMemo();
             }
-            this.doneEditMemo();
             this._deactivateDraw(element);
             resetElementCursor(element);
             this.updateCursor(evt);
@@ -266,30 +295,28 @@ class BrushTool extends LabelmapBaseTool {
         return stats;
     }
     rejectPreview(element = this._previewData.element) {
-        if (!element || !this._previewData.preview) {
+        if (!element) {
             return;
         }
+        this.doneEditMemo();
         const enabledElement = getEnabledElement(element);
         this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
         this._previewData.preview = null;
         this._previewData.isDrag = false;
     }
-    interpolate(element, config) {
+    acceptPreview(element = this._previewData.element) {
         if (!element) {
             return;
         }
-        const enabledElement = getEnabledElement(element);
-        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.Interpolate, config.configuration);
-        this._previewData.isDrag = true;
+        super.acceptPreview(element);
     }
-    acceptPreview(element = this._previewData.element) {
+    interpolate(element, config) {
         if (!element) {
             return;
         }
         const enabledElement = getEnabledElement(element);
-        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AcceptPreview);
-        this._previewData.isDrag = false;
-        this._previewData.preview = null;
+        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.Interpolate, config.configuration);
+        this._previewData.isDrag = true;
     }
     invalidateBrushCursor() {
         if (this._hoverData === undefined) {
@@ -339,6 +366,7 @@ class BrushTool extends LabelmapBaseTool {
         const circleUID = '0';
         drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
             color,
+            lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? [1, 2] : null,
         });
         const { dynamicRadiusInCanvas } = this.configuration?.threshold || {
             dynamicRadiusInCanvas: 0,

package/dist/esm/tools/segmentation/LabelmapBaseTool.d.ts

@@ -42,6 +42,12 @@ export default class LabelmapBaseTool extends BaseTool {
         volumeId?: string;
         referencedVolumeId?: string;
     } | null;
+    protected centerSegmentIndexInfo: {
+        segmentIndex: number;
+        hasSegmentIndex: boolean;
+        hasPreviewIndex: boolean;
+        changedIndices: number[];
+    };
     protected _hoverData?: {
         brushCursor: any;
         segmentationId: string;
@@ -52,9 +58,16 @@ export default class LabelmapBaseTool extends BaseTool {
         viewport: Types.IViewport;
     };
     static previewData?: PreviewData;
+    protected memoMap: Map<string, LabelmapMemo.LabelmapMemo>;
+    protected acceptedMemoIds: Map<string, {
+        element: HTMLDivElement;
+        segmentIndex: number;
+    }>;
+    protected memo: LabelmapMemo.LabelmapMemo;
     constructor(toolProps: any, defaultToolProps: any);
+    protected _historyRedoHandler(evt: any): void;
     protected get _previewData(): PreviewData;
-    createMemo(segmentId: string, segmentationVoxelManager: any, preview: any): LabelmapMemo.LabelmapMemo;
+    createMemo(segmentationId: string, segmentationVoxelManager: any): LabelmapMemo.LabelmapMemo;
     protected createEditData(element: any): EditDataReturnType;
     protected getEditData({ viewport, representationData, segmentsLocked, segmentationId, }: {
         viewport: any;
@@ -89,7 +102,7 @@ export default class LabelmapBaseTool extends BaseTool {
     protected getOperationData(element?: any): ModifiedLabelmapToolOperationData;
     addPreview(element?: HTMLDivElement, options?: {
         acceptReject: boolean;
-    }): unknown;
+    }): any;
     rejectPreview(element?: HTMLDivElement): void;
     acceptPreview(element?: HTMLDivElement): void;
     static viewportContoursToLabelmap(viewport: Types.IViewport, options?: {

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

@@ -8,7 +8,7 @@ import { getClosestImageIdForStackViewport } from '../../utilities/annotationHyd
 import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
-import { StrategyCallbacks } from '../../enums';
+import { StrategyCallbacks, Events } from '../../enums';
 import * as LabelmapMemo from '../../utilities/segmentation/createLabelmapMemo';
 import { getAllAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { filterAnnotationsForDisplay } from '../../utilities/planar';
@@ -26,13 +26,54 @@ export default class LabelmapBaseTool extends BaseTool {
     }; }
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
+        this.memoMap = new Map();
+        this.acceptedMemoIds = new Map();
+        this.centerSegmentIndexInfo = {
+            segmentIndex: null,
+            hasSegmentIndex: false,
+            hasPreviewIndex: false,
+            changedIndices: [],
+        };
+    }
+    _historyRedoHandler(evt) {
+        const { id, operationType } = evt.detail;
+        if (operationType !== 'labelmap') {
+            return;
+        }
+        if (this.acceptedMemoIds.has(id)) {
+            this._hoverData = null;
+            const memoData = this.acceptedMemoIds.get(id);
+            const element = memoData?.element;
+            const operationData = this.getOperationData(element);
+            operationData.segmentIndex = memoData?.segmentIndex;
+            if (element) {
+                this.applyActiveStrategyCallback(getEnabledElement(element), operationData, StrategyCallbacks.AcceptPreview);
+            }
+        }
+        this._previewData.isDrag = true;
     }
     get _previewData() {
         return LabelmapBaseTool.previewData;
     }
-    createMemo(segmentId, segmentationVoxelManager, preview) {
-        this.memo ||= LabelmapMemo.createLabelmapMemo(segmentId, segmentationVoxelManager, preview);
-        return this.memo;
+    createMemo(segmentationId, segmentationVoxelManager) {
+        const voxelManagerId = segmentationVoxelManager.id;
+        if (this.memo &&
+            this.memo.segmentationVoxelManager === segmentationVoxelManager) {
+            return this.memo;
+        }
+        let memo = this.memoMap.get(voxelManagerId);
+        if (!memo) {
+            memo = LabelmapMemo.createLabelmapMemo(segmentationId, segmentationVoxelManager);
+            this.memoMap.set(voxelManagerId, memo);
+        }
+        else {
+            if (memo.redoVoxelManager) {
+                memo = LabelmapMemo.createLabelmapMemo(segmentationId, segmentationVoxelManager);
+                this.memoMap.set(voxelManagerId, memo);
+            }
+        }
+        this.memo = memo;
+        return memo;
     }
     createEditData(element) {
         const enabledElement = getEnabledElement(element);
@@ -154,20 +195,25 @@ export default class LabelmapBaseTool extends BaseTool {
         if (!configColor && !segmentColor) {
             return;
         }
+        let previewColor = null, previewSegmentIndex = null;
+        if (this.configuration.preview.enabled) {
+            previewColor = configColor || lightenColor(...segmentColor);
+            previewSegmentIndex = 255;
+        }
         const operationData = {
             ...editData,
             points: data?.handles?.points,
             segmentIndex,
             viewPlaneNormal,
+            previewOnHover: !this._previewData.isDrag,
             toolGroupId: this.toolGroupId,
             segmentationId,
             viewUp,
+            centerSegmentIndexInfo: this.centerSegmentIndexInfo,
             activeStrategy: this.configuration.activeStrategy,
             configuration: this.configuration,
-            previewColor: this.configuration.preview.enabled
-                ? configColor || lightenColor(...segmentColor)
-                : null,
-            preview: this._previewData?.preview,
+            previewColor,
+            previewSegmentIndex,
             createMemo: this.createMemo.bind(this),
         };
         return operationData;
@@ -182,14 +228,15 @@ export default class LabelmapBaseTool extends BaseTool {
             this.rejectPreview(element);
         }
         const enabledElement = getEnabledElement(element);
-        _previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
+        const results = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
         _previewData.isDrag = true;
-        return _previewData.preview;
+        return results;
     }
     rejectPreview(element = this._previewData.element) {
-        if (!element || !this._previewData.preview) {
+        if (!element) {
             return;
         }
+        this.doneEditMemo();
         const enabledElement = getEnabledElement(element);
         this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
         this._previewData.preview = null;
@@ -199,12 +246,18 @@ export default class LabelmapBaseTool extends BaseTool {
         if (!element) {
             return;
         }
-        this.doneEditMemo();
+        const operationData = this.getOperationData(element);
+        if (this.memo && this.memo.id) {
+            this.acceptedMemoIds.set(this.memo.id, {
+                element,
+                segmentIndex: operationData.segmentIndex,
+            });
+        }
         const enabledElement = getEnabledElement(element);
-        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AcceptPreview);
-        this._previewData.isDrag = false;
-        this._previewData.preview = null;
+        this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.AcceptPreview);
         this.doneEditMemo();
+        this._previewData.preview = null;
+        this._previewData.isDrag = false;
     }
     static viewportContoursToLabelmap(viewport, options) {
         const removeContours = options?.removeContours ?? true;
@@ -227,7 +280,7 @@ export default class LabelmapBaseTool extends BaseTool {
         });
         const preview = brushInstance.addPreview(viewport.element);
         const { memo, segmentationId } = preview;
-        const previewVoxels = memo?.voxelManager || preview.previewVoxelManager;
+        const previewVoxels = memo?.voxelManager;
         const segmentationVoxels = previewVoxels.sourceVoxelManager || previewVoxels;
         const { dimensions } = previewVoxels;
         const imageData = viewport

package/dist/esm/tools/segmentation/strategies/BrushStrategy.d.ts

@@ -5,6 +5,12 @@ import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type { LabelmapMemo } from '../../../utilities/segmentation/createLabelmapMemo';
 export type InitializedOperationData = LabelmapToolOperationDataAny & {
     operationName?: string;
+    centerSegmentIndexInfo: {
+        segmentIndex: number;
+        hasSegmentIndex: boolean;
+        hasPreviewIndex: boolean;
+        changedIndices: number[];
+    };
     enabledElement: Types.IEnabledElement;
     centerIJK?: Types.Point3;
     centerWorld: Types.Point3;
@@ -14,7 +20,6 @@ export type InitializedOperationData = LabelmapToolOperationDataAny & {
     imageVoxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
     segmentationVoxelManager: Types.IVoxelManager<number>;
     segmentationImageData: vtkImageData;
-    previewVoxelManager: Types.IVoxelManager<number>;
     previewSegmentIndex?: number;
     previewColor?: [number, number, number, number];
     brushStrategy: BrushStrategy;
@@ -42,7 +47,6 @@ export type Composition = CompositionFunction | CompositionInstance;
 export default class BrushStrategy {
     static COMPOSITIONS: {
         determineSegmentIndex: {
-            initialize: (operationData: InitializedOperationData) => void;
             onInteractionStart: (operationData: InitializedOperationData) => void;
         };
         dynamicThreshold: {
@@ -112,12 +116,12 @@ export default class BrushStrategy {
     protected _acceptPreview: [];
     protected _onInteractionStart: any[];
     constructor(name: any, ...initializers: Composition[]);
-    fill: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => any;
+    fill: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => InitializedOperationData;
     protected initialize(enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny, operationName?: string): InitializedOperationData;
     onInteractionStart: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
     onInteractionEnd: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
     rejectPreview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
-    addPreview: (enabledElement: any, operationData: LabelmapToolOperationDataAny) => any;
+    addPreview: (enabledElement: any, operationData: LabelmapToolOperationDataAny) => InitializedOperationData;
     acceptPreview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
     preview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => unknown;
     interpolate: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => unknown;

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

@@ -3,7 +3,6 @@ import { triggerSegmentationDataModified } from '../../../stateManagement/segmen
 import compositions from './compositions';
 import { getStrategyData } from './utils/getStrategyData';
 import { StrategyCallbacks } from '../../../enums';
-const { VoxelManager } = csUtils;
 export default class BrushStrategy {
     static { this.COMPOSITIONS = compositions; }
     static { this.childFunctions = {
@@ -33,29 +32,12 @@ export default class BrushStrategy {
             if (!initializedData) {
                 return;
             }
-            const { configuration = {}, centerIJK } = initializedData;
-            if (csUtils.isEqual(centerIJK, configuration.centerIJK)) {
-                return operationData.preview;
-            }
-            else {
-                configuration.centerIJK = centerIJK;
-            }
             this._fill.forEach((func) => func(initializedData));
-            const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, segmentIndex, } = initializedData;
-            const isPreview = previewSegmentIndex && previewVoxelManager.modifiedSlices.size;
-            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices(), isPreview ? previewSegmentIndex : segmentIndex);
-            if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
-                segmentationVoxelManager.resetModifiedSlices();
-                return null;
-            }
-            return initializedData.preview || initializedData;
+            const { segmentationVoxelManager, segmentIndex } = initializedData;
+            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices(), segmentIndex);
+            return initializedData;
         };
         this.onInteractionStart = (enabledElement, operationData) => {
-            const { preview } = operationData;
-            if (preview?.isPreviewFromHover) {
-                preview.isPreviewFromHover = false;
-                return;
-            }
             const initializedData = this.initialize(enabledElement, operationData);
             if (!initializedData) {
                 return;
@@ -67,7 +49,7 @@ export default class BrushStrategy {
             if (!initializedData) {
                 return;
             }
-            return initializedData.preview || initializedData;
+            return initializedData;
         };
         this.configurationName = name;
         this.compositions = initializers;
@@ -94,28 +76,24 @@ export default class BrushStrategy {
         const { viewport } = enabledElement;
         const data = getStrategyData({ operationData, viewport, strategy: this });
         if (!data) {
-            console.warn('No data found for BrushStrategy');
-            return operationData.preview;
+            return null;
         }
         const { imageVoxelManager, segmentationVoxelManager, segmentationImageData, } = data;
-        const previewVoxelManager = operationData.preview?.previewVoxelManager ||
-            VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
-        const previewEnabled = !!operationData.previewColor;
-        const previewSegmentIndex = previewEnabled ? 255 : undefined;
+        const memo = operationData.createMemo(operationData.segmentationId, segmentationVoxelManager);
         const initializedData = {
             operationName,
-            previewSegmentIndex,
             ...operationData,
+            segmentIndex: operationData.segmentIndex,
             enabledElement,
             imageVoxelManager,
             segmentationVoxelManager,
             segmentationImageData,
-            previewVoxelManager,
             viewport,
             centerWorld: null,
             isInObject: null,
             isInObjectBoundsIJK: null,
             brushStrategy: this,
+            memo,
         };
         this._initialize.forEach((func) => func(initializedData));
         return initializedData;

package/dist/esm/tools/segmentation/strategies/compositions/determineSegmentIndex.d.ts

@@ -1,6 +1,5 @@
 import type { InitializedOperationData } from '../BrushStrategy';
 declare const _default: {
-    initialize: (operationData: InitializedOperationData) => void;
     onInteractionStart: (operationData: InitializedOperationData) => void;
 };
 export default _default;

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

@@ -1,18 +1,10 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
-    [StrategyCallbacks.Initialize]: (operationData) => {
-        const { centerSegmentIndex } = operationData.configuration || {};
-        if (!centerSegmentIndex) {
-            return;
-        }
-        operationData.segmentIndex = centerSegmentIndex.segmentIndex;
-    },
     [StrategyCallbacks.OnInteractionStart]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, viewPlaneNormal, segmentationImageData, preview, configuration, } = operationData;
+        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, viewPlaneNormal, segmentationImageData, configuration, } = operationData;
         if (!configuration?.useCenterSegmentIndex) {
             return;
         }
-        delete configuration.centerSegmentIndex;
         let hasSegmentIndex = false;
         let hasPreviewIndex = false;
         const nestedBounds = [
@@ -37,23 +29,12 @@ export default {
             boundsIJK: nestedBounds,
         });
         if (!hasSegmentIndex && !hasPreviewIndex) {
+            operationData.centerSegmentIndexInfo.segmentIndex = null;
             return;
         }
-        let existingValue = segmentationVoxelManager.getAtIJKPoint(centerIJK);
-        if (existingValue === previewSegmentIndex) {
-            if (preview) {
-                existingValue = preview.segmentIndex;
-            }
-            else {
-                return;
-            }
-        }
-        else if (hasPreviewIndex) {
-            existingValue = null;
-        }
-        operationData.segmentIndex = existingValue;
-        configuration.centerSegmentIndex = {
-            segmentIndex: existingValue,
-        };
+        const existingValue = segmentationVoxelManager.getAtIJKPoint(centerIJK);
+        operationData.centerSegmentIndexInfo.segmentIndex = existingValue;
+        operationData.centerSegmentIndexInfo.hasSegmentIndex = hasSegmentIndex;
+        operationData.centerSegmentIndexInfo.hasPreviewIndex = hasPreviewIndex;
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/index.d.ts

@@ -1,6 +1,5 @@
 declare const _default: {
     determineSegmentIndex: {
-        initialize: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
         onInteractionStart: (operationData: import("../BrushStrategy").InitializedOperationData) => void;
     };
     dynamicThreshold: {

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

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

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

@@ -1,38 +1,24 @@
+import { utilities } from '@cornerstonejs/core';
 import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/events/triggerSegmentationDataModified';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
-import { getSegmentIndexColor, setSegmentIndexColor, } from '../../../../stateManagement/segmentation/config/segmentationColor';
+import { setSegmentIndexColor } from '../../../../stateManagement/segmentation/config/segmentationColor';
 import { getViewportIdsWithSegmentation } from '../../../../stateManagement/segmentation/getViewportIdsWithSegmentation';
 export default {
     [StrategyCallbacks.Preview]: function (operationData) {
-        const { previewColor, configuration, enabledElement } = operationData;
-        if (!previewColor || !configuration) {
+        const { previewSegmentIndex, configuration, enabledElement } = operationData;
+        if (!previewSegmentIndex || !configuration) {
             return;
         }
-        if (operationData.preview) {
-            delete operationData.preview;
-        }
-        delete configuration.centerSegmentIndex;
         this.onInteractionStart?.(enabledElement, operationData);
         const preview = this.fill(enabledElement, operationData);
         if (preview) {
-            preview.isPreviewFromHover = true;
-            operationData.preview = preview;
             this.onInteractionEnd?.(enabledElement, operationData);
         }
         return preview;
     },
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, previewColor, preview, segmentationId, segmentationVoxelManager, } = operationData;
-        if (previewColor === undefined || !previewSegmentIndex) {
-            operationData.memo = operationData.createMemo(segmentationId, segmentationVoxelManager);
-            return;
-        }
-        if (preview) {
-            preview.previewVoxelManager.sourceVoxelManager =
-                operationData.segmentationVoxelManager;
-            operationData.previewVoxelManager = preview.previewVoxelManager;
-        }
-        if (segmentIndex === null) {
+        const { segmentIndex, previewColor, previewSegmentIndex } = operationData;
+        if (previewSegmentIndex == null || segmentIndex == null) {
             return;
         }
         const viewportIds = getViewportIdsWithSegmentation(operationData.segmentationId);
@@ -41,38 +27,44 @@ export default {
         });
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
-        const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, segmentationId, preview, } = operationData || {};
-        if (previewSegmentIndex === undefined) {
-            return;
-        }
-        const segmentIndex = preview?.segmentIndex ?? operationData.segmentIndex;
-        if (!previewVoxelManager || previewVoxelManager.modifiedSlices.size === 0) {
-            return;
-        }
-        const memo = operationData.createMemo(segmentationId, segmentationVoxelManager);
-        operationData.memo = memo;
-        const { voxelManager } = memo;
-        const callback = ({ index, value }) => {
+        const { previewSegmentIndex, segmentationVoxelManager, memo, segmentIndex, centerSegmentIndexInfo, } = operationData || {};
+        const { changedIndices } = centerSegmentIndexInfo || {};
+        const labelmapMemo = memo;
+        const callback = ({ index }) => {
             const oldValue = segmentationVoxelManager.getAtIndex(index);
-            if (oldValue === previewSegmentIndex) {
-                segmentationVoxelManager.setAtIndex(index, value);
-                voxelManager.setAtIndex(index, segmentIndex);
+            if (changedIndices?.length > 0) {
+                if (changedIndices.includes(index)) {
+                    labelmapMemo.voxelManager.setAtIndex(index, 0);
+                }
+            }
+            else {
+                if (oldValue === previewSegmentIndex) {
+                    labelmapMemo.voxelManager.setAtIndex(index, segmentIndex);
+                }
             }
         };
-        previewVoxelManager.forEach(callback, {});
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), preview.segmentIndex);
-        previewVoxelManager.clear();
+        segmentationVoxelManager.forEach(callback);
+        triggerSegmentationDataModified(operationData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices(), segmentIndex);
+        operationData.centerSegmentIndexInfo.changedIndices = [];
     },
     [StrategyCallbacks.RejectPreview]: (operationData) => {
-        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, } = operationData;
-        if (previewVoxelManager.modifiedSlices.size === 0) {
+        if (!operationData) {
             return;
         }
-        const callback = ({ index, value }) => {
-            segmentationVoxelManager.setAtIndex(index, value);
-        };
-        previewVoxelManager.forEach(callback);
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), 0);
-        previewVoxelManager.clear();
+        utilities.HistoryMemo.DefaultHistoryMemo.undoIf((memo) => {
+            const labelmapMemo = memo;
+            if (!labelmapMemo?.voxelManager) {
+                return false;
+            }
+            const { segmentationVoxelManager } = labelmapMemo;
+            let hasPreviewSegmentIndex = false;
+            const callback = ({ value }) => {
+                if (value === operationData.previewSegmentIndex) {
+                    hasPreviewSegmentIndex = true;
+                }
+            };
+            segmentationVoxelManager.forEach(callback);
+            return hasPreviewSegmentIndex;
+        });
     },
 };

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

@@ -1,7 +1,7 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
 export default {
     [StrategyCallbacks.Fill]: (operationData) => {
-        const { segmentsLocked, segmentationImageData, segmentationVoxelManager, previewVoxelManager, brushStrategy, centerIJK, } = operationData;
+        const { segmentsLocked, segmentationImageData, segmentationVoxelManager, brushStrategy, centerIJK, } = operationData;
         const isWithinThreshold = brushStrategy.createIsInThreshold?.(operationData);
         const { setValue } = brushStrategy;
         const callback = isWithinThreshold
@@ -18,6 +18,6 @@ export default {
             isInObject: operationData.isInObject,
             boundsIJK: operationData.isInObjectBoundsIJK,
         });
-        previewVoxelManager.addPoint(centerIJK);
+        segmentationVoxelManager.addPoint(centerIJK);
     },
 };

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

@@ -1,29 +1,35 @@
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { handleUseSegmentCenterIndex } from '../utils/handleUseSegmentCenterIndex';
 export default {
     [StrategyCallbacks.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, segmentIndex, previewSegmentIndex, segmentationVoxelManager, memo, } = operationData;
-        const previewVoxelManager = memo?.voxelManager || operationData.previewVoxelManager;
+        const { segmentsLocked, previewSegmentIndex, memo, segmentationVoxelManager, centerSegmentIndexInfo, segmentIndex, } = operationData;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
-        let changed = false;
-        if (segmentIndex === null) {
-            const oldValue = previewVoxelManager.getAtIndex(index);
-            if (oldValue !== undefined) {
-                changed = previewVoxelManager.setAtIndex(index, oldValue);
-            }
+        if (segmentsLocked.includes(value)) {
             return;
         }
-        if (existingValue === segmentIndex || segmentsLocked.includes(value)) {
+        if (!centerSegmentIndexInfo && existingValue === segmentIndex) {
             return;
         }
-        if (existingValue === previewSegmentIndex) {
-            if (previewVoxelManager.getAtIndex(index) === undefined) {
-                changed = segmentationVoxelManager.setAtIndex(index, segmentIndex);
-            }
-            else {
-                return;
+        if (centerSegmentIndexInfo?.segmentIndex !== 0 &&
+            existingValue === segmentIndex) {
+            return;
+        }
+        if (centerSegmentIndexInfo?.segmentIndex === null) {
+            memo.voxelManager.setAtIndex(index, previewSegmentIndex ?? segmentIndex);
+            return;
+        }
+        if (!previewSegmentIndex) {
+            let useSegmentIndex = segmentIndex;
+            if (centerSegmentIndexInfo) {
+                useSegmentIndex = centerSegmentIndexInfo.segmentIndex;
             }
+            memo.voxelManager.setAtIndex(index, useSegmentIndex);
+            return;
         }
-        const useSegmentIndex = previewSegmentIndex ?? segmentIndex;
-        changed = previewVoxelManager.setAtIndex(index, useSegmentIndex);
+        handleUseSegmentCenterIndex({
+            operationData,
+            existingValue,
+            index,
+        });
     },
 };

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

@@ -97,6 +97,9 @@ function getStrategyDataForStackViewport({ operationData, viewport, strategy, })
     };
 }
 function getStrategyData({ operationData, viewport, strategy, }) {
+    if (!operationData) {
+        return null;
+    }
     if (('volumeId' in operationData && operationData.volumeId != null) ||
         ('referencedVolumeId' in operationData &&
             operationData.referencedVolumeId != null)) {

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

@@ -0,0 +1,5 @@
+export declare function handleUseSegmentCenterIndex({ operationData, existingValue, index, }: {
+    operationData: any;
+    existingValue: any;
+    index: any;
+}): void;

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

@@ -0,0 +1,84 @@
+export function handleUseSegmentCenterIndex({ operationData, existingValue, index, }) {
+    const { previewSegmentIndex, memo, centerSegmentIndexInfo, previewOnHover, segmentIndex, } = operationData;
+    const { hasPreviewIndex, hasSegmentIndex, segmentIndex: centerSegmentIndex, } = centerSegmentIndexInfo;
+    if (centerSegmentIndex === 0 && hasSegmentIndex && hasPreviewIndex) {
+        if (existingValue === segmentIndex) {
+            return;
+        }
+        if (previewOnHover) {
+            return;
+        }
+        if (existingValue === previewSegmentIndex) {
+            memo.voxelManager.setAtIndex(index, 0);
+            return;
+        }
+        return;
+    }
+    if (centerSegmentIndex === 0 && hasSegmentIndex && !hasPreviewIndex) {
+        if (existingValue === 0 || existingValue !== segmentIndex) {
+            return;
+        }
+        memo.voxelManager.setAtIndex(index, previewSegmentIndex);
+        centerSegmentIndexInfo.changedIndices.push(index);
+        return;
+    }
+    if (centerSegmentIndex === 0 && !hasSegmentIndex && hasPreviewIndex) {
+        if (existingValue === segmentIndex) {
+            return;
+        }
+        if (previewOnHover) {
+            return;
+        }
+        if (existingValue === previewSegmentIndex) {
+            memo.voxelManager.setAtIndex(index, 0);
+            return;
+        }
+        return;
+    }
+    if (centerSegmentIndex === 0 && !hasSegmentIndex && !hasPreviewIndex) {
+        if (existingValue === segmentIndex) {
+            return;
+        }
+        if (existingValue === previewSegmentIndex) {
+            memo.voxelManager.setAtIndex(index, previewSegmentIndex);
+            return;
+        }
+        return;
+    }
+    if (centerSegmentIndex === previewSegmentIndex &&
+        hasSegmentIndex &&
+        hasPreviewIndex) {
+        if (existingValue === segmentIndex) {
+            return;
+        }
+        memo.voxelManager.setAtIndex(index, previewSegmentIndex);
+        return;
+    }
+    if (centerSegmentIndex === previewSegmentIndex &&
+        !hasSegmentIndex &&
+        hasPreviewIndex) {
+        if (existingValue === segmentIndex) {
+            return;
+        }
+        memo.voxelManager.setAtIndex(index, previewSegmentIndex);
+        return;
+    }
+    if (centerSegmentIndex === segmentIndex &&
+        hasSegmentIndex &&
+        hasPreviewIndex) {
+        if (existingValue === segmentIndex) {
+            return;
+        }
+        memo.voxelManager.setAtIndex(index, previewSegmentIndex);
+        return;
+    }
+    if (centerSegmentIndex === segmentIndex &&
+        hasSegmentIndex &&
+        !hasPreviewIndex) {
+        if (existingValue === segmentIndex) {
+            return;
+        }
+        memo.voxelManager.setAtIndex(index, previewSegmentIndex);
+        return;
+    }
+}

package/dist/esm/types/LabelmapToolOperationData.d.ts

@@ -6,6 +6,7 @@ type LabelmapToolOperationData = {
     segmentationId: string;
     segmentIndex: number;
     previewColor?: [number, number, number, number];
+    previewSegmentIndex?: number;
     segmentsLocked: number[];
     viewPlaneNormal: number[];
     viewUp: number[];
@@ -16,7 +17,6 @@ type LabelmapToolOperationData = {
         voxelManager: Types.IVoxelManager<number>;
         imageData: vtkImageData;
     };
-    preview: any;
     toolGroupId: string;
     createMemo: (segmentId: any, segmentVoxels: any, previewVoxels?: any, previewMemo?: any) => LabelmapMemo;
 };

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

@@ -1,27 +1,21 @@
 import { utilities } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
-import type { InitializedOperationData } from '../../tools/segmentation/strategies/BrushStrategy';
 export type LabelmapMemo = Types.Memo & {
     segmentationVoxelManager: Types.IVoxelManager<number>;
     voxelManager: Types.IVoxelManager<number>;
     redoVoxelManager?: Types.IVoxelManager<number>;
     undoVoxelManager?: Types.IVoxelManager<number>;
     memo?: LabelmapMemo;
+    id: string;
 };
-export declare function createLabelmapMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>, preview?: InitializedOperationData): {
-    segmentationId: string;
-    restoreMemo: typeof restoreMemo;
-    commitMemo: typeof commitMemo;
-    segmentationVoxelManager: Types.IVoxelManager<number>;
-    voxelManager: Types.IVoxelManager<number>;
-    memo: LabelmapMemo;
-    preview: InitializedOperationData;
-} | {
+export declare function createLabelmapMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>): {
     segmentationId: string;
     restoreMemo: typeof restoreMemo;
     commitMemo: typeof commitMemo;
     segmentationVoxelManager: Types.IVoxelManager<T>;
     voxelManager: utilities.VoxelManager<T>;
+    id: string;
+    operationType: string;
 };
 export declare function restoreMemo(isUndo?: boolean): void;
 export declare function createRleMemo<T>(segmentationId: string, segmentationVoxelManager: Types.IVoxelManager<T>): {
@@ -30,15 +24,8 @@ export declare function createRleMemo<T>(segmentationId: string, segmentationVox
     commitMemo: typeof commitMemo;
     segmentationVoxelManager: Types.IVoxelManager<T>;
     voxelManager: utilities.VoxelManager<T>;
-};
-export declare function createPreviewMemo(segmentationId: string, preview: InitializedOperationData): {
-    segmentationId: string;
-    restoreMemo: typeof restoreMemo;
-    commitMemo: typeof commitMemo;
-    segmentationVoxelManager: Types.IVoxelManager<number>;
-    voxelManager: Types.IVoxelManager<number>;
-    memo: LabelmapMemo;
-    preview: InitializedOperationData;
+    id: string;
+    operationType: string;
 };
 declare function commitMemo(): boolean;
 export {};

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

@@ -1,10 +1,9 @@
-import { utilities } from '@cornerstonejs/core';
+import { utilities, eventTarget } from '@cornerstonejs/core';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import Events from '../../enums/Events';
 const { VoxelManager, RLEVoxelMap } = utilities;
-export function createLabelmapMemo(segmentationId, segmentationVoxelManager, preview) {
-    return preview
-        ? createPreviewMemo(segmentationId, preview)
-        : createRleMemo(segmentationId, segmentationVoxelManager);
+export function createLabelmapMemo(segmentationId, segmentationVoxelManager) {
+    return createRleMemo(segmentationId, segmentationVoxelManager);
 }
 export function restoreMemo(isUndo) {
     const { segmentationVoxelManager, undoVoxelManager, redoVoxelManager } = this;
@@ -23,19 +22,8 @@ export function createRleMemo(segmentationId, segmentationVoxelManager) {
         commitMemo,
         segmentationVoxelManager,
         voxelManager,
-    };
-    return state;
-}
-export function createPreviewMemo(segmentationId, preview) {
-    const { memo: previewMemo, segmentationVoxelManager, previewVoxelManager, } = preview;
-    const state = {
-        segmentationId,
-        restoreMemo,
-        commitMemo,
-        segmentationVoxelManager,
-        voxelManager: previewVoxelManager,
-        memo: previewMemo,
-        preview,
+        id: utilities.uuidv4(),
+        operationType: 'labelmap',
     };
     return state;
 }

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

@@ -28,11 +28,11 @@ export default class IslandRemoval {
             ? segmentationVoxels
             : VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
         const { segmentIndex = 1, previewSegmentIndex = 1 } = options;
-        const clickedPoints = options.points || previewVoxelManager.getPoints();
+        const clickedPoints = options.points || segmentationVoxelManager.getPoints();
         if (!clickedPoints?.length) {
             return;
         }
-        const boundsIJK = previewVoxelManager
+        const boundsIJK = segmentationVoxelManager
             .getBoundsIJK()
             .map((bound, i) => [
             Math.min(bound[0], ...clickedPoints.map((point) => point[i])),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.7.17",
+  "version": "3.8.1",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.7.17",
+    "@cornerstonejs/core": "^3.8.1",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "9a5dc66176f5172fd3bb11ebcf37f9b8667ab3c4"
+  "gitHead": "1f45d352ecb6e239cb418f085cdabeca2a4520a9"
 }