@cornerstonejs/tools 2.7.4 → 2.8.0

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

@@ -4,6 +4,7 @@ declare enum ChangeTypes {
     StatsUpdated = "StatsUpdated",
     InitialSetup = "InitialSetup",
     Completed = "Completed",
-    InterpolationUpdated = "InterpolationUpdated"
+    InterpolationUpdated = "InterpolationUpdated",
+    History = "History"
 }
 export default ChangeTypes;

package/dist/esm/enums/ChangeTypes.js

@@ -6,5 +6,6 @@ var ChangeTypes;
     ChangeTypes["InitialSetup"] = "InitialSetup";
     ChangeTypes["Completed"] = "Completed";
     ChangeTypes["InterpolationUpdated"] = "InterpolationUpdated";
+    ChangeTypes["History"] = "History";
 })(ChangeTypes || (ChangeTypes = {}));
 export default ChangeTypes;

package/dist/esm/store/filterToolsWithAnnotationsForElement.js

@@ -14,7 +14,7 @@ export default function filterToolsWithAnnotationsForElement(element, tools) {
         if (typeof tool.filterInteractableAnnotationsForElement === 'function') {
             annotations = tool.filterInteractableAnnotationsForElement(element, annotations);
         }
-        if (annotations.length > 0) {
+        if (annotations?.length > 0) {
             result.push({ tool, annotations });
         }
     }

package/dist/esm/tools/AnnotationEraserTool.js

@@ -1,5 +1,5 @@
-import { BaseTool } from './base';
-import { getAnnotations, removeAnnotation, } from '../stateManagement/annotation/annotationState';
+import { BaseTool, AnnotationTool } from './base';
+import { getAnnotations, getAnnotation, removeAnnotation, } from '../stateManagement/annotation/annotationState';
 import { setAnnotationSelected } from '../stateManagement/annotation/annotationSelection';
 import { getToolGroupForViewport } from '../store/ToolGroupManager';
 class AnnotationEraserTool extends BaseTool {
@@ -30,10 +30,10 @@ class AnnotationEraserTool extends BaseTool {
                 continue;
             }
             const annotations = getAnnotations(toolName, element);
-            if (!annotations.length) {
+            const interactableAnnotations = toolInstance.filterInteractableAnnotationsForElement(element, annotations);
+            if (!interactableAnnotations) {
                 continue;
             }
-            const interactableAnnotations = toolInstance.filterInteractableAnnotationsForElement(element, annotations) || [];
             for (const annotation of interactableAnnotations) {
                 if (toolInstance.isPointNearTool(element, annotation, currentPoints.canvas, 10, interactionType)) {
                     annotationsToRemove.push(annotation.annotationUID);
@@ -42,6 +42,10 @@ class AnnotationEraserTool extends BaseTool {
         }
         for (const annotationUID of annotationsToRemove) {
             setAnnotationSelected(annotationUID);
+            const annotation = getAnnotation(annotationUID);
+            AnnotationTool.createAnnotationMemo(element, annotation, {
+                deleting: true,
+            });
             removeAnnotation(annotationUID);
         }
         evt.preventDefault();

package/dist/esm/tools/CrosshairsTool.js

@@ -67,7 +67,7 @@ class CrosshairsTool extends AnnotationTool {
             const { position, focalPoint, viewPlaneNormal } = viewport.getCamera();
             let annotations = this._getAnnotations(enabledElement);
             annotations = this.filterInteractableAnnotationsForElement(element, annotations);
-            if (annotations.length) {
+            if (annotations?.length) {
                 removeAnnotation(annotations[0].annotationUID);
             }
             const annotation = {

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

@@ -5,7 +5,6 @@ declare class PanTool extends BaseTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     touchDragCallback(evt: EventTypes.InteractionEventType): void;
     mouseDragCallback(evt: EventTypes.InteractionEventType): void;
-    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
     _dragCallback(evt: EventTypes.InteractionEventType): void;
 }
 export default PanTool;

package/dist/esm/tools/PanTool.js

@@ -5,10 +5,6 @@ class PanTool extends BaseTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
     }) {
         super(toolProps, defaultToolProps);
-        this.preMouseDownCallback = (evt) => {
-            this.memo = null;
-            return false;
-        };
     }
     touchDragCallback(evt) {
         this._dragCallback(evt);
@@ -19,7 +15,6 @@ class PanTool extends BaseTool {
     _dragCallback(evt) {
         const { element, deltaPoints } = evt.detail;
         const enabledElement = getEnabledElement(element);
-        this.memo ||= PanTool.createZoomPanMemo(enabledElement.viewport);
         const deltaPointsWorld = deltaPoints.world;
         if (deltaPointsWorld[0] === 0 &&
             deltaPointsWorld[1] === 0 &&

package/dist/esm/tools/ZoomTool.js

@@ -23,7 +23,6 @@ class ZoomTool extends BaseTool {
             const camera = enabledElement.viewport.getCamera();
             const { focalPoint } = camera;
             this.initialMousePosWorld = worldPos;
-            this.memo = null;
             let dirVec = vec3.fromValues(focalPoint[0] - worldPos[0], focalPoint[1] - worldPos[1], focalPoint[2] - worldPos[2]);
             dirVec = vec3.normalize(vec3.create(), dirVec);
             this.dirVec = dirVec;
@@ -146,7 +145,6 @@ class ZoomTool extends BaseTool {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
         const camera = viewport.getCamera();
-        this.memo ||= ZoomTool.createZoomPanMemo(viewport);
         if (camera.parallelProjection) {
             this._dragParallelProjection(evt, viewport, camera);
         }

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

@@ -148,12 +148,14 @@ class ArrowAnnotateTool extends AnnotationTool {
                     }
                     annotation.data.text = text;
                     triggerAnnotationCompleted(annotation);
+                    this.createMemo(element, annotation, { newAnnotation: !!this.memo });
                     triggerAnnotationRenderForViewportIds(viewportIdsToRender);
                 });
             }
             else {
                 triggerAnnotationModified(annotation, element);
             }
+            this.doneEditMemo();
             this.editData = null;
             this.isDrawing = false;
         };
@@ -161,7 +163,8 @@ class ArrowAnnotateTool extends AnnotationTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;

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

@@ -116,6 +116,7 @@ class BidirectionalTool extends AnnotationTool {
             if (newAnnotation && !hasMoved) {
                 return;
             }
+            this.doneEditMemo();
             data.handles.activeHandleIndex = null;
             this._deactivateModify(element);
             this._deactivateDraw(element);
@@ -166,9 +167,10 @@ class BidirectionalTool extends AnnotationTool {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const enabledElement = getEnabledElement(element);
-            const { renderingEngine, viewport } = enabledElement;
+            const { viewport } = enabledElement;
             const { worldToCanvas } = viewport;
-            const { annotation, viewportIdsToRender, handleIndex } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, newAnnotation } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             const worldPos = currentPoints.world;
             data.handles.points[handleIndex] = [...worldPos];
@@ -222,9 +224,8 @@ class BidirectionalTool extends AnnotationTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;

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

@@ -158,6 +158,7 @@ class CircleROITool extends AnnotationTool {
             if (newAnnotation && !hasMoved) {
                 return;
             }
+            this.doneEditMemo();
             annotation.highlighted = false;
             data.handles.activeHandleIndex = null;
             this._deactivateModify(element);
@@ -182,9 +183,10 @@ class CircleROITool extends AnnotationTool {
             const { currentPoints } = eventDetail;
             const currentCanvasPoints = currentPoints.canvas;
             const enabledElement = getEnabledElement(element);
-            const { renderingEngine, viewport } = enabledElement;
+            const { viewport } = enabledElement;
             const { canvasToWorld } = viewport;
-            const { annotation, viewportIdsToRender } = this.editData;
+            const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             data.handles.points = [
                 data.handles.points[0],
@@ -198,7 +200,8 @@ class CircleROITool extends AnnotationTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;

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

@@ -23,9 +23,9 @@ declare class CobbAngleTool extends AnnotationTool {
     isPointNearTool: (element: HTMLDivElement, annotation: CobbAngleAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
     toolSelectedCallback: (evt: EventTypes.MouseDownEventType, annotation: CobbAngleAnnotation, interactionType: InteractionTypes, canvasCoords: Types.Point2, proximity?: number) => void;
     handleSelectedCallback(evt: EventTypes.MouseDownEventType, annotation: CobbAngleAnnotation, handle: ToolHandle, interactionType?: string): void;
-    _mouseUpCallback: (evt: EventTypes.MouseUpEventType | EventTypes.MouseClickEventType) => void;
+    _endCallback: (evt: EventTypes.MouseUpEventType | EventTypes.MouseClickEventType) => void;
     _mouseDownCallback: (evt: EventTypes.MouseUpEventType | EventTypes.MouseClickEventType) => void;
-    _mouseDragCallback: (evt: EventTypes.MouseDragEventType | EventTypes.MouseMoveEventType) => void;
+    _dragCallback: (evt: EventTypes.MouseDragEventType | EventTypes.MouseMoveEventType) => void;
     cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: HTMLDivElement) => void;
     _deactivateModify: (element: HTMLDivElement) => void;

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

@@ -127,7 +127,7 @@ class CobbAngleTool extends AnnotationTool {
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
-        this._mouseUpCallback = (evt) => {
+        this._endCallback = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             const { annotation, viewportIdsToRender, newAnnotation, hasMoved } = this.editData;
@@ -135,6 +135,7 @@ class CobbAngleTool extends AnnotationTool {
             if (newAnnotation && !hasMoved) {
                 return;
             }
+            this.doneEditMemo();
             if (this.angleStartedNotYetCompleted && data.handles.points.length < 4) {
                 resetElementCursor(element);
                 this.editData.handleIndex = data.handles.points.length;
@@ -184,11 +185,12 @@ class CobbAngleTool extends AnnotationTool {
             data.handles.points[2] = data.handles.points[3] = worldPos;
             this.editData.handleIndex = data.handles.points.length - 1;
         };
-        this._mouseDragCallback = (evt) => {
+        this._dragCallback = (evt) => {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, isNearFirstLine, isNearSecondLine, } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, isNearFirstLine, isNearSecondLine, newAnnotation, } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;
@@ -261,30 +263,30 @@ class CobbAngleTool extends AnnotationTool {
         };
         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.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
         };
         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.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
         };
         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.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.MOUSE_DOWN, this._mouseDownCallback);
         };
         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.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.MOUSE_DOWN, this._mouseDownCallback);
         };
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
@@ -604,8 +606,6 @@ class CobbAngleTool extends AnnotationTool {
         };
         this._activateModify(element);
         hideElementCursor(element);
-        const enabledElement = getEnabledElement(element);
-        const { renderingEngine } = enabledElement;
         triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         evt.preventDefault();
     }

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

@@ -183,8 +183,6 @@ class EllipticalROITool extends AnnotationTool {
             };
             this._activateModify(element);
             hideElementCursor(element);
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
@@ -196,12 +194,12 @@ class EllipticalROITool extends AnnotationTool {
             if (newAnnotation && !hasMoved) {
                 return;
             }
+            this.doneEditMemo();
             annotation.highlighted = false;
             data.handles.activeHandleIndex = null;
             this._deactivateModify(element);
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const { renderingEngine } = getEnabledElement(element);
             this.editData = null;
             this.isDrawing = false;
             if (this.isHandleOutsideImage &&
@@ -220,9 +218,10 @@ class EllipticalROITool extends AnnotationTool {
             const { currentPoints } = eventDetail;
             const currentCanvasPoints = currentPoints.canvas;
             const enabledElement = getEnabledElement(element);
-            const { renderingEngine, viewport } = enabledElement;
+            const { viewport } = enabledElement;
             const { canvasToWorld } = viewport;
-            const { annotation, viewportIdsToRender, centerWorld } = this.editData;
+            const { annotation, viewportIdsToRender, centerWorld, newAnnotation } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const centerCanvas = viewport.worldToCanvas(centerWorld);
             const { data } = annotation;
             const dX = Math.abs(currentCanvasPoints[0] - centerCanvas[0]);
@@ -245,7 +244,8 @@ class EllipticalROITool extends AnnotationTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;

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

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

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

@@ -24,7 +24,7 @@ class KeyImageTool extends AnnotationTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
             const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
@@ -46,6 +46,7 @@ class KeyImageTool extends AnnotationTool {
                 triggerAnnotationCompleted(annotation);
                 triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             });
+            this.createMemo(element, annotation, { newAnnotation: true });
             return annotation;
         };
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
@@ -71,6 +72,7 @@ class KeyImageTool extends AnnotationTool {
         this._endCallback = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
+            this.doneEditMemo();
             this._deactivateModify(element);
             resetElementCursor(element);
         };
@@ -87,8 +89,10 @@ class KeyImageTool extends AnnotationTool {
                 return;
             }
             const annotation = clickedAnnotation;
+            this.createMemo(element, annotation);
             this.configuration.changeTextCallback(clickedAnnotation, evt.detail, this._doneChangingTextCallback.bind(this, element, annotation));
             this.isDrawing = false;
+            this.doneEditMemo();
             evt.stopImmediatePropagation();
             evt.preventDefault();
         };

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

@@ -143,6 +143,7 @@ class LengthTool extends AnnotationTool {
                 removeAnnotation(annotation.annotationUID);
             }
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            this.doneEditMemo();
             if (newAnnotation) {
                 triggerAnnotationCompleted(annotation);
             }
@@ -152,8 +153,10 @@ class LengthTool extends AnnotationTool {
         this._dragCallback = (evt) => {
             this.isDrawing = true;
             const eventDetail = evt.detail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
             const { data } = annotation;
+            this.createMemo(element, annotation, { newAnnotation });
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;
                 const worldPosDelta = deltaPoints.world;

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

@@ -114,6 +114,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             const { element } = eventDetail;
             const { annotation, viewportIdsToRender, newAnnotation, contourHoleProcessingEnabled, } = this.editData;
             const { data } = annotation;
+            this.doneEditMemo();
             data.handles.activeHandleIndex = null;
             this._deactivateModify(element);
             this._deactivateDraw(element);
@@ -144,7 +145,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         };
         this._mouseDownCallback = (evt) => {
             const doubleClick = evt.type === Events.MOUSE_DOUBLE_CLICK;
-            const { annotation, viewportIdsToRender, worldToSlice, sliceToWorld } = this.editData;
+            const { annotation, viewportIdsToRender, worldToSlice, sliceToWorld, newAnnotation, } = this.editData;
             if (this.editData.closed) {
                 return;
             }
@@ -157,6 +158,10 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             const { viewport, renderingEngine } = enabledElement;
             const controlPoints = this.editData.currentPath.getControlPoints();
             let closePath = controlPoints.length >= 2 && doubleClick;
+            this.doneEditMemo();
+            this.createMemo(element, annotation, {
+                newAnnotation: newAnnotation && controlPoints.length === 1,
+            });
             if (controlPoints.length >= 2) {
                 const closestHandlePoint = {
                     index: -1,
@@ -228,7 +233,8 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { annotation, viewportIdsToRender, movingTextBox, handleIndex, newAnnotation, } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;
@@ -265,10 +271,8 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             if (newAnnotation) {
                 removeAnnotation(annotation.annotationUID);
             }
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
-            this.editData = null;
+            this.doneEditMemo();
             this.scissors = null;
             return annotation.annotationUID;
         };

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

@@ -75,8 +75,12 @@ class ProbeTool extends AnnotationTool {
             };
             this._deactivateModify(element);
             resetElementCursor(element);
+            if (newAnnotation) {
+                this.createMemo(element, annotation, { newAnnotation });
+            }
             this.editData = null;
             this.isDrawing = false;
+            this.doneEditMemo();
             if (this.isHandleOutsideImage &&
                 this.configuration.preventHandleOutsideImage) {
                 removeAnnotation(annotation.annotationUID);
@@ -91,12 +95,11 @@ class ProbeTool extends AnnotationTool {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const { annotation, viewportIdsToRender } = this.editData;
+            const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
             const { data } = annotation;
+            this.createMemo(element, annotation, { newAnnotation });
             data.handles.points[0] = [...worldPos];
             annotation.invalidated = true;
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this.cancel = (element) => {
@@ -276,8 +279,6 @@ class ProbeTool extends AnnotationTool {
         };
         this._activateModify(element);
         hideElementCursor(element);
-        const enabledElement = getEnabledElement(element);
-        const { renderingEngine } = enabledElement;
         triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         evt.preventDefault();
     }

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

@@ -168,7 +168,7 @@ class RectangleROITool extends AnnotationTool {
             this._deactivateModify(element);
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const { renderingEngine } = getEnabledElement(element);
+            this.doneEditMemo();
             this.editData = null;
             this.isDrawing = false;
             if (this.isHandleOutsideImage &&
@@ -184,7 +184,8 @@ class RectangleROITool extends AnnotationTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
             const { data } = annotation;
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;

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

@@ -142,8 +142,6 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 movingTextBox,
             };
             this._activateModify(element);
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
@@ -182,6 +180,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 this.fireChangeOnUpdate.changeType = changeType;
             }
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            this.doneEditMemo();
             this.editData = null;
             this.isDrawing = false;
         };
@@ -225,8 +224,8 @@ class SplineROITool extends ContourSegmentationBaseTool {
             if (data.contour.closed) {
                 return;
             }
+            this.doneEditMemo();
             const eventDetail = evt.detail;
-            const { element } = eventDetail;
             const { currentPoints } = eventDetail;
             const { canvas: canvasPoint, world: worldPoint } = currentPoints;
             let closeContour = data.handles.points.length >= 2 && doubleClick;
@@ -254,8 +253,9 @@ class SplineROITool extends ContourSegmentationBaseTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
             const { data } = annotation;
+            this.createMemo(element, annotation, { newAnnotation });
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;
                 const worldPosDelta = deltaPoints.world;

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

@@ -19,8 +19,8 @@ declare class VideoRedactionTool extends AnnotationTool {
     isPointNearTool: (element: any, annotation: any, canvasCoords: any, proximity: any) => boolean;
     toolSelectedCallback: (evt: any, annotation: any, interactionType?: string) => void;
     handleSelectedCallback: (evt: any, annotation: any, handle: any, interactionType?: string) => void;
-    _mouseUpCallback: (evt: any) => void;
-    _mouseDragCallback: (evt: any) => void;
+    _endCallback: (evt: any) => void;
+    _dragCallback: (evt: any) => void;
     cancel(element: any): any;
     _activateDraw: (element: any) => void;
     _deactivateDraw: (element: any) => void;