@cornerstonejs/tools 2.7.4 → 2.8.0

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

@@ -138,7 +138,7 @@ class VideoRedactionTool extends AnnotationTool {
             triggerAnnotationRenderForViewportIds(viewportUIDsToRender);
             evt.preventDefault();
         };
-        this._mouseUpCallback = (evt) => {
+        this._endCallback = (evt) => {
             const eventData = evt.detail;
             const { element } = eventData;
             const { annotation, viewportUIDsToRender, newAnnotation, hasMoved } = this.editData;
@@ -146,12 +146,12 @@ class VideoRedactionTool extends AnnotationTool {
             if (newAnnotation && !hasMoved) {
                 return;
             }
+            this.doneEditMemo();
             data.active = false;
             data.handles.activeHandleIndex = null;
             this._deactivateModify(element);
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const enabledElement = getEnabledElement(element);
             this.editData = null;
             this.isDrawing = false;
             if (this.isHandleOutsideImage &&
@@ -160,11 +160,12 @@ class VideoRedactionTool extends AnnotationTool {
             }
             triggerAnnotationRenderForViewportIds(viewportUIDsToRender);
         };
-        this._mouseDragCallback = (evt) => {
+        this._dragCallback = (evt) => {
             this.isDrawing = true;
             const eventData = evt.detail;
             const { element } = eventData;
-            const { annotation, viewportUIDsToRender, handleIndex } = this.editData;
+            const { annotation, viewportUIDsToRender, handleIndex, newAnnotation } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             if (handleIndex === undefined) {
                 const { deltaPoints } = eventData;
@@ -230,37 +231,37 @@ class VideoRedactionTool extends AnnotationTool {
         };
         this._activateDraw = (element) => {
             state.isInteractingWithTool = true;
-            element.addEventListener(Events.MOUSE_UP, this._mouseUpCallback);
-            element.addEventListener(Events.MOUSE_DRAG, this._mouseDragCallback);
-            element.addEventListener(Events.MOUSE_MOVE, this._mouseDragCallback);
-            element.addEventListener(Events.MOUSE_CLICK, this._mouseUpCallback);
-            element.addEventListener(Events.TOUCH_END, this._mouseUpCallback);
-            element.addEventListener(Events.TOUCH_DRAG, this._mouseDragCallback);
+            element.addEventListener(Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
         };
         this._deactivateDraw = (element) => {
             state.isInteractingWithTool = false;
-            element.removeEventListener(Events.MOUSE_UP, this._mouseUpCallback);
-            element.removeEventListener(Events.MOUSE_DRAG, this._mouseDragCallback);
-            element.removeEventListener(Events.MOUSE_MOVE, this._mouseDragCallback);
-            element.removeEventListener(Events.MOUSE_CLICK, this._mouseUpCallback);
-            element.removeEventListener(Events.TOUCH_END, this._mouseUpCallback);
-            element.removeEventListener(Events.TOUCH_DRAG, this._mouseDragCallback);
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
         };
         this._activateModify = (element) => {
             state.isInteractingWithTool = true;
-            element.addEventListener(Events.MOUSE_UP, this._mouseUpCallback);
-            element.addEventListener(Events.MOUSE_DRAG, this._mouseDragCallback);
-            element.addEventListener(Events.MOUSE_CLICK, this._mouseUpCallback);
-            element.addEventListener(Events.TOUCH_END, this._mouseUpCallback);
-            element.addEventListener(Events.TOUCH_DRAG, this._mouseDragCallback);
+            element.addEventListener(Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
         };
         this._deactivateModify = (element) => {
             state.isInteractingWithTool = false;
-            element.removeEventListener(Events.MOUSE_UP, this._mouseUpCallback);
-            element.removeEventListener(Events.MOUSE_DRAG, this._mouseDragCallback);
-            element.removeEventListener(Events.MOUSE_CLICK, this._mouseUpCallback);
-            element.removeEventListener(Events.TOUCH_END, this._mouseUpCallback);
-            element.removeEventListener(Events.TOUCH_DRAG, this._mouseDragCallback);
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
         };
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
             const renderStatus = false;
@@ -274,8 +275,6 @@ class VideoRedactionTool extends AnnotationTool {
             if (!annotations?.length) {
                 return renderStatus;
             }
-            const targetId = this.getTargetId(viewport);
-            const renderingEngine = viewport.getRenderingEngine();
             const styleSpecifier = {
                 toolGroupId: this.toolGroupId,
                 toolName: this.getToolName(),
@@ -284,7 +283,6 @@ class VideoRedactionTool extends AnnotationTool {
             for (let i = 0; i < annotations.length; i++) {
                 const annotation = annotations[i];
                 const { annotationUID } = annotation;
-                const toolMetadata = annotation.metadata;
                 const data = annotation.data;
                 const { points, activeHandleIndex } = data.handles;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));

package/dist/esm/tools/annotation/planarFreehandROITool/closedContourEditLoop.js

@@ -27,6 +27,7 @@ function activateClosedContourEdit(evt, annotation, viewportIdsToRender) {
         editCanvasPoints: [canvasPos],
         startCrossingIndex: undefined,
         editIndex: 0,
+        annotation,
     };
     this.commonData = {
         annotation,
@@ -61,9 +62,10 @@ function mouseDragClosedContourEditCallback(evt) {
     const worldPos = currentPoints.world;
     const canvasPos = currentPoints.canvas;
     const enabledElement = getEnabledElement(element);
-    const { renderingEngine, viewport } = enabledElement;
+    const { viewport } = enabledElement;
     const { viewportIdsToRender, xDir, yDir, spacing } = this.commonData;
-    const { editIndex, editCanvasPoints, startCrossingIndex } = this.editData;
+    const { editIndex, editCanvasPoints, startCrossingIndex, annotation } = this.editData;
+    this.createMemo(element, annotation);
     const lastCanvasPoint = editCanvasPoints[editCanvasPoints.length - 1];
     const lastWorldPoint = viewport.canvasToWorld(lastCanvasPoint);
     const worldPosDiff = vec3.create();
@@ -118,6 +120,7 @@ function finishEditAndStartNewEdit(evt) {
         startCrossingIndex: undefined,
         editIndex: 0,
         snapIndex: undefined,
+        annotation,
     };
     triggerAnnotationRenderForViewportIds(viewportIdsToRender);
 }
@@ -203,8 +206,9 @@ function mouseUpClosedContourEditCallback(evt) {
 }
 function completeClosedContourEdit(element) {
     const enabledElement = getEnabledElement(element);
-    const { viewport, renderingEngine } = enabledElement;
+    const { viewport } = enabledElement;
     const { annotation, viewportIdsToRender } = this.commonData;
+    this.doneEditMemo();
     const { fusedCanvasPoints, prevCanvasPoints } = this.editData;
     if (fusedCanvasPoints) {
         const updatedPoints = shouldSmooth(this.configuration, annotation)

package/dist/esm/tools/annotation/planarFreehandROITool/drawLoop.js

@@ -26,6 +26,7 @@ function activateDraw(evt, annotation, viewportIdsToRender) {
         canvasPoints: [canvasPos],
         polylineIndex: 0,
         contourHoleProcessingEnabled,
+        newAnnotation: true,
     };
     this.commonData = {
         annotation,
@@ -60,9 +61,10 @@ function mouseDragDrawCallback(evt) {
     const worldPos = currentPoints.world;
     const canvasPos = currentPoints.canvas;
     const enabledElement = getEnabledElement(element);
-    const { renderingEngine, viewport } = enabledElement;
+    const { viewport } = enabledElement;
     const { annotation, viewportIdsToRender, xDir, yDir, spacing, movingTextBox, } = this.commonData;
-    const { polylineIndex, canvasPoints } = this.drawData;
+    const { polylineIndex, canvasPoints, newAnnotation } = this.drawData;
+    this.createMemo(element, annotation, { newAnnotation });
     const lastCanvasPoint = canvasPoints[canvasPoints.length - 1];
     const lastWorldPoint = viewport.canvasToWorld(lastCanvasPoint);
     const worldPosDiff = vec3.create();
@@ -102,6 +104,8 @@ function mouseUpDrawCallback(evt) {
     const lastPoint = canvasPoints[canvasPoints.length - 1];
     const eventDetail = evt.detail;
     const { element } = eventDetail;
+    this.doneEditMemo();
+    this.drawData.newAnnotation = false;
     if (allowOpenContours &&
         !pointsAreWithinCloseContourProximity(firstPoint, lastPoint, this.configuration.closeContourProximity)) {
         this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });

package/dist/esm/tools/annotation/planarFreehandROITool/openContourEditLoop.js

@@ -17,6 +17,7 @@ function activateOpenContourEdit(evt, annotation, viewportIdsToRender) {
     const canvasPos = currentPoints.canvas;
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
+    this.doneEditMemo();
     const prevCanvasPoints = annotation.data.contour.polyline.map(viewport.worldToCanvas);
     const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(viewport, this.configuration.subPixelResolution);
     this.editData = {
@@ -58,12 +59,13 @@ function mouseDragOpenContourEditCallback(evt) {
     const worldPos = currentPoints.world;
     const canvasPos = currentPoints.canvas;
     const enabledElement = getEnabledElement(element);
-    const { renderingEngine, viewport } = enabledElement;
+    const { viewport } = enabledElement;
     const { viewportIdsToRender, xDir, yDir, spacing } = this.commonData;
     const { editIndex, editCanvasPoints, startCrossingIndex } = this.editData;
     const lastCanvasPoint = editCanvasPoints[editCanvasPoints.length - 1];
     const lastWorldPoint = viewport.canvasToWorld(lastCanvasPoint);
     const worldPosDiff = vec3.create();
+    this.createMemo(element, this.commonData.annotation);
     vec3.subtract(worldPosDiff, worldPos, lastWorldPoint);
     const xDist = Math.abs(vec3.dot(worldPosDiff, xDir));
     const yDist = Math.abs(vec3.dot(worldPosDiff, yDir));
@@ -112,6 +114,7 @@ function openContourEditOverwriteEnd(evt) {
     this.isEditingOpen = false;
     this.editData = undefined;
     this.commonData = undefined;
+    this.doneEditMemo();
     this.deactivateOpenContourEdit(element);
     this.activateOpenContourEndEdit(evt, annotation, viewportIdsToRender, null);
 }
@@ -262,8 +265,9 @@ function mouseUpOpenContourEditCallback(evt) {
 }
 function completeOpenContourEdit(element) {
     const enabledElement = getEnabledElement(element);
-    const { viewport, renderingEngine } = enabledElement;
+    const { viewport } = enabledElement;
     const { annotation, viewportIdsToRender } = this.commonData;
+    this.doneEditMemo();
     const { fusedCanvasPoints, prevCanvasPoints } = this.editData;
     if (fusedCanvasPoints) {
         const updatedPoints = shouldSmooth(this.configuration)

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

@@ -5,7 +5,7 @@ import type { StyleSpecifier } from '../../types/AnnotationStyle';
 declare abstract class AnnotationDisplayTool extends BaseTool {
     static toolName: any;
     abstract renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): any;
-    filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations | undefined;
+    filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations;
     onImageSpacingCalibrated: (evt: Types.EventTypes.ImageSpacingCalibratedEvent) => void;
     protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
     protected getReferencedImageId(viewport: Types.IViewport, worldPos: Types.Point3, viewPlaneNormal: Types.Point3, viewUp?: Types.Point3): string;

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

@@ -34,8 +34,8 @@ class AnnotationDisplayTool extends BaseTool {
         };
     }
     filterInteractableAnnotationsForElement(element, annotations) {
-        if (!annotations || !annotations.length) {
-            return;
+        if (!annotations?.length) {
+            return [];
         }
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;

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

@@ -22,5 +22,35 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
         styleSpecifier: StyleSpecifier;
     }): AnnotationStyle;
     private _imagePointNearToolOrHandle;
+    protected static createAnnotationState(annotation: Annotation, deleting?: boolean): {
+        annotationUID: string;
+        data: {
+            [key: string]: unknown;
+            handles?: {
+                points?: Types.Point3[];
+                activeHandleIndex?: number | null;
+                textBox?: {
+                    hasMoved?: boolean;
+                    worldPosition?: Types.Point3;
+                    worldBoundingBox?: {
+                        topLeft: Types.Point3;
+                        topRight: Types.Point3;
+                        bottomLeft: Types.Point3;
+                        bottomRight: Types.Point3;
+                    };
+                };
+                [key: string]: unknown;
+            };
+            cachedStats?: Record<string, unknown>;
+        };
+        deleting: boolean;
+    };
+    static createAnnotationMemo(element: any, annotation: Annotation, options?: {
+        newAnnotation?: boolean;
+        deleting?: boolean;
+    }): {
+        restoreMemo: () => void;
+    };
+    protected createMemo(element: any, annotation: any, options?: any): void;
 }
 export default AnnotationTool;

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

@@ -3,8 +3,13 @@ import { vec2 } from 'gl-matrix';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
-import { addAnnotation } from '../../stateManagement/annotation/annotationState';
+import { addAnnotation, removeAnnotation, getAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
+import ChangeTypes from '../../enums/ChangeTypes';
+import { setAnnotationSelected } from '../../stateManagement/annotation/annotationSelection';
+import { addContourSegmentationAnnotation } from '../../utilities/contourSegmentation';
+const { DefaultHistoryMemo } = csUtils.HistoryMemo;
+const { PointsManager } = csUtils;
 class AnnotationTool extends AnnotationDisplayTool {
     static createAnnotation(...annotationBaseData) {
         let annotation = {
@@ -177,6 +182,85 @@ class AnnotationTool extends AnnotationDisplayTool {
             return true;
         }
     }
+    static createAnnotationState(annotation, deleting) {
+        const { data, annotationUID } = annotation;
+        const cloneData = {
+            ...data,
+            cachedStats: {},
+        };
+        delete cloneData.contour;
+        delete cloneData.spline;
+        const state = {
+            annotationUID,
+            data: structuredClone(cloneData),
+            deleting,
+        };
+        const contour = data.contour;
+        if (contour) {
+            state.data.contour = {
+                ...contour,
+                polyline: null,
+                pointsManager: PointsManager.create3(contour.polyline.length, contour.polyline),
+            };
+        }
+        return state;
+    }
+    static createAnnotationMemo(element, annotation, options) {
+        if (!annotation) {
+            return;
+        }
+        const { newAnnotation, deleting = newAnnotation ? false : undefined } = options || {};
+        const { annotationUID } = annotation;
+        const state = AnnotationTool.createAnnotationState(annotation, deleting);
+        const annotationMemo = {
+            restoreMemo: () => {
+                const newState = AnnotationTool.createAnnotationState(annotation, deleting);
+                if (state.deleting === true) {
+                    state.deleting = false;
+                    Object.assign(annotation.data, state.data);
+                    if (annotation.data.contour) {
+                        const annotationData = annotation.data;
+                        annotationData.contour.polyline = state.data.contour.pointsManager.points;
+                        delete state.data.contour.pointsManager;
+                        if (annotationData.segmentation) {
+                            addContourSegmentationAnnotation(annotation);
+                        }
+                    }
+                    state.data = newState.data;
+                    addAnnotation(annotation, element);
+                    setAnnotationSelected(annotation.annotationUID, true);
+                    getEnabledElement(element)?.viewport.render();
+                    return;
+                }
+                if (state.deleting === false) {
+                    state.deleting = true;
+                    state.data = newState.data;
+                    setAnnotationSelected(annotation.annotationUID);
+                    removeAnnotation(annotation.annotationUID);
+                    getEnabledElement(element)?.viewport.render();
+                    return;
+                }
+                const currentAnnotation = getAnnotation(annotationUID);
+                if (!currentAnnotation) {
+                    console.warn('No current annotation');
+                    return;
+                }
+                Object.assign(currentAnnotation.data, state.data);
+                if (currentAnnotation.data.contour) {
+                    currentAnnotation.data
+                        .contour.polyline = state.data.contour.pointsManager.points;
+                }
+                state.data = newState.data;
+                currentAnnotation.invalidated = true;
+                triggerAnnotationModified(currentAnnotation, element, ChangeTypes.History);
+            },
+        };
+        DefaultHistoryMemo.push(annotationMemo);
+        return annotationMemo;
+    }
+    createMemo(element, annotation, options) {
+        this.memo ||= AnnotationTool.createAnnotationMemo(element, annotation, options);
+    }
 }
 AnnotationTool.toolName = 'AnnotationTool';
 export default AnnotationTool;

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

@@ -33,5 +33,6 @@ declare abstract class BaseTool {
     static createZoomPanMemo(viewport: any): {
         restoreMemo: () => void;
     };
+    doneEditMemo(): void;
 }
 export default BaseTool;

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

@@ -92,8 +92,8 @@ class BaseTool {
         throw new Error('getTargetId: viewport must have a getViewReferenceId method');
     }
     undo() {
+        this.doneEditMemo();
         DefaultHistoryMemo.undo();
-        this.memo = null;
     }
     redo() {
         DefaultHistoryMemo.redo();
@@ -117,6 +117,12 @@ class BaseTool {
         DefaultHistoryMemo.push(zoomPanMemo);
         return zoomPanMemo;
     }
+    doneEditMemo() {
+        if (this.memo?.commitMemo?.()) {
+            DefaultHistoryMemo.push(this.memo);
+        }
+        this.memo = null;
+    }
 }
 BaseTool.toolName = 'BaseTool';
 export default BaseTool;

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

@@ -6,15 +6,11 @@ import InterpolationManager from '../../utilities/segmentation/InterpolationMana
 import { addContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../utilities/contourSegmentation';
 import { triggerAnnotationRenderForToolGroupIds } from '../../utilities/triggerAnnotationRenderForToolGroupIds';
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
-import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentation';
 import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
-import { getSegmentationRepresentationVisibility } from '../../stateManagement/segmentation/getSegmentationRepresentationVisibility';
 import { getViewportIdsWithSegmentation } from '../../stateManagement/segmentation/getViewportIdsWithSegmentation';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
-import { segmentationStyle } from '../../stateManagement/segmentation/SegmentationStyle';
-import { internalGetHiddenSegmentIndices } from '../../stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices';
 import { getSVGStyleForSegment } from '../../utilities/segmentation/getSVGStyleForSegment';
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {

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

@@ -146,6 +146,7 @@ class BrushTool extends LabelmapBaseTool {
             if (!this._previewData.preview && !this._previewData.isDrag) {
                 this.applyActiveStrategy(enabledElement, operationData);
             }
+            this.doneEditMemo();
             this._deactivateDraw(element);
             resetElementCursor(element);
             this.updateCursor(evt);

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

@@ -1,7 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
-import { BaseTool } from '../base';
 import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
-declare class CircleScissorsTool extends BaseTool {
+import LabelmapBaseTool from './LabelmapBaseTool';
+import type { LabelmapMemo } from '../../utilities/segmentation/createLabelmapMemo';
+declare class CircleScissorsTool extends LabelmapBaseTool {
     static toolName: any;
     editData: {
         annotation: Annotation;
@@ -18,6 +19,7 @@ declare class CircleScissorsTool extends BaseTool {
         hasMoved?: boolean;
         imageId: string;
         centerCanvas?: Array<number>;
+        memo?: LabelmapMemo;
     } | null;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;

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

@@ -8,7 +8,8 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, config as segmentationConfig, } from '../../stateManagement/segmentation';
 import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
-class CircleScissorsTool extends BaseTool {
+import LabelmapBaseTool from './LabelmapBaseTool';
+class CircleScissorsTool extends LabelmapBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -167,10 +168,12 @@ class CircleScissorsTool extends BaseTool {
                 viewPlaneNormal,
                 viewUp,
                 strategySpecificConfiguration: {},
+                createMemo: this.createMemo.bind(this),
             };
             this.editData = null;
             this.isDrawing = false;
             this.applyActiveStrategy(enabledElement, operationData);
+            this.doneEditMemo();
         };
         this._activateDraw = (element) => {
             element.addEventListener(Events.MOUSE_UP, this._endCallback);

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

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import * as LabelmapMemo from '../../utilities/segmentation/createLabelmapMemo';
 export type PreviewData = {
     preview: unknown;
     timer?: number;
@@ -32,7 +33,7 @@ export default class LabelmapBaseTool extends BaseTool {
     };
     protected _previewData?: PreviewData;
     constructor(toolProps: any, defaultToolProps: any);
-    createMemo(segmentId: string, segmentationVoxelManager: any, preview: any): void;
+    createMemo(segmentId: string, segmentationVoxelManager: any, preview: any): LabelmapMemo.LabelmapMemo;
     createEditData(element: any): {
         volumeId: string;
         referencedVolumeId: any;
@@ -89,6 +90,7 @@ export default class LabelmapBaseTool extends BaseTool {
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
+        createMemo: (segmentId: string, segmentationVoxelManager: any, preview: any) => LabelmapMemo.LabelmapMemo;
         override: {
             voxelManager: Types.IVoxelManager<number>;
             imageData: vtkImageData;
@@ -108,6 +110,7 @@ export default class LabelmapBaseTool extends BaseTool {
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
+        createMemo: (segmentId: string, segmentationVoxelManager: any, preview: any) => LabelmapMemo.LabelmapMemo;
         volumeId: string;
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
@@ -123,6 +126,7 @@ export default class LabelmapBaseTool extends BaseTool {
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
+        createMemo: (segmentId: string, segmentationVoxelManager: any, preview: any) => LabelmapMemo.LabelmapMemo;
         imageId: string;
         segmentsLocked: number[] | [];
         override: {
@@ -141,6 +145,7 @@ export default class LabelmapBaseTool extends BaseTool {
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
+        createMemo: (segmentId: string, segmentationVoxelManager: any, preview: any) => LabelmapMemo.LabelmapMemo;
         imageId: string;
         segmentsLocked: number[] | [];
         volumeId?: undefined;

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

@@ -10,6 +10,7 @@ import { getStackSegmentationImageIdsForViewport } from '../../stateManagement/s
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { StrategyCallbacks } from '../../enums';
+import * as LabelmapMemo from '../../utilities/segmentation/createLabelmapMemo';
 export default class LabelmapBaseTool extends BaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -23,7 +24,8 @@ export default class LabelmapBaseTool extends BaseTool {
         };
     }
     createMemo(segmentId, segmentationVoxelManager, preview) {
-        console.warn('LabelmapBaseTool.createMemo not implemented yet');
+        this.memo ||= LabelmapMemo.createLabelmapMemo(segmentId, segmentationVoxelManager, preview);
+        return this.memo;
     }
     createEditData(element) {
         const enabledElement = getEnabledElement(element);
@@ -181,6 +183,7 @@ export default class LabelmapBaseTool extends BaseTool {
             viewUp,
             strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
             preview: this._previewData?.preview,
+            createMemo: this.createMemo.bind(this),
         };
         return operationData;
     }
@@ -210,9 +213,11 @@ export default class LabelmapBaseTool extends BaseTool {
         if (!element) {
             return;
         }
+        this.doneEditMemo();
         const enabledElement = getEnabledElement(element);
         this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AcceptPreview);
         this._previewData.isDrag = false;
         this._previewData.preview = null;
+        this.doneEditMemo();
     }
 }

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

@@ -29,9 +29,9 @@ class PaintFillTool extends BaseTool {
             const { representationData } = getSegmentation(segmentationId);
             let dimensions;
             let direction;
-            let scalarData;
             let index;
             let voxelManager;
+            this.doneEditMemo();
             if (viewport instanceof BaseVolumeViewport) {
                 const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
                 const segmentation = cache.getVolume(volumeId);

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

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
-import { BaseTool } from '../base';
 import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
-declare class RectangleScissorsTool extends BaseTool {
+import LabelmapBaseTool from './LabelmapBaseTool';
+declare class RectangleScissorsTool extends LabelmapBaseTool {
     static toolName: any;
     _throttledCalculateCachedStats: Function;
     editData: {

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

@@ -8,8 +8,9 @@ import { drawRect as drawRectSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
-import { getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
-class RectangleScissorsTool extends BaseTool {
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import LabelmapBaseTool from './LabelmapBaseTool';
+class RectangleScissorsTool extends LabelmapBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -171,10 +172,13 @@ class RectangleScissorsTool extends BaseTool {
             const operationData = {
                 ...this.editData,
                 points: data.handles.points,
+                strategySpecificConfiguration: {},
+                createMemo: this.createMemo.bind(this),
             };
             this.editData = null;
             this.isDrawing = false;
             this.applyActiveStrategy(enabledElement, operationData);
+            this.doneEditMemo();
         };
         this._activateDraw = (element) => {
             element.addEventListener(Events.MOUSE_UP, this._endCallback);

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

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
-import { BaseTool } from '../base';
 import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
-declare class SphereScissorsTool extends BaseTool {
+import LabelmapBaseTool from './LabelmapBaseTool';
+declare class SphereScissorsTool extends LabelmapBaseTool {
     static toolName: any;
     editData: {
         annotation: Annotation;