@cornerstonejs/tools 2.4.0 → 2.5.1

package/dist/esm/stateManagement/annotation/annotationLocking.js

@@ -1,6 +1,6 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import { Events } from '../../enums';
-import { getAnnotation } from './getAnnotation';
+import { getAnnotation } from './annotationState';
 const globalLockedAnnotationUIDsSet = new Set();
 function setAnnotationLocked(annotationUID, locked = true) {
     const detail = makeEventDetail();

package/dist/esm/stateManagement/annotation/annotationSelection.js

@@ -1,6 +1,6 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import { Events } from '../../enums';
-import { getAnnotation } from './getAnnotation';
+import { getAnnotation } from './annotationState';
 const selectedAnnotationUIDs = new Set();
 function setAnnotationSelected(annotationUID, selected = true, preserveSelected = false) {
     if (selected) {

package/dist/esm/stateManagement/annotation/annotationState.d.ts

@@ -1,10 +1,9 @@
 import type { Annotations, Annotation } from '../../types/AnnotationTypes';
-import type { AnnotationGroupSelector } from '../../types';
-import { getAnnotation } from './getAnnotation';
-declare function getAnnotationManager(): import("./FrameOfReferenceSpecificAnnotationManager").default;
-declare function setAnnotationManager(annotationManager: any): void;
-declare function resetAnnotationManager(): void;
+import type { AnnotationGroupSelector, IAnnotationManager } from '../../types';
+declare function getAnnotationManager(): any;
+declare function setAnnotationManager(annotationManager: IAnnotationManager): void;
 declare function getAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): Annotations;
+declare function getAnnotation(annotationUID: string): Annotation;
 declare function getAllAnnotations(): Annotations;
 declare function clearParentAnnotation(annotation: Annotation): void;
 declare function addChildAnnotation(parentAnnotation: Annotation, childAnnotation: Annotation): void;
@@ -16,4 +15,4 @@ declare function removeAnnotation(annotationUID: string): void;
 declare function removeAllAnnotations(): void;
 declare function removeAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): void;
 declare function invalidateAnnotation(annotation: Annotation): void;
-export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, getAnnotation, };
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, invalidateAnnotation, getAnnotation, };

package/dist/esm/stateManagement/annotation/annotationState.js

@@ -1,36 +1,21 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
-import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
-import { getAnnotation } from './getAnnotation';
 import { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, triggerAnnotationRemoved, } from './helpers/state';
-import { checkAndSetAnnotationLocked } from './annotationLocking';
-import { checkAndDefineCachedStatsProperty, checkAndDefineTextBoxProperty, } from './utilities/defineProperties';
-import { checkAndSetAnnotationVisibility } from './annotationVisibility';
-let defaultManager = defaultFrameOfReferenceSpecificAnnotationManager;
-const preprocessingFn = (annotation) => {
-    annotation = checkAndDefineTextBoxProperty(annotation);
-    annotation = checkAndDefineCachedStatsProperty(annotation);
-    const uid = annotation.annotationUID;
-    const isLocked = checkAndSetAnnotationLocked(uid);
-    annotation.isLocked = isLocked;
-    const isVisible = checkAndSetAnnotationVisibility(uid);
-    annotation.isVisible = isVisible;
-    return annotation;
-};
-defaultManager.setPreprocessingFn(preprocessingFn);
+let defaultManager;
 function getAnnotationManager() {
     return defaultManager;
 }
 function setAnnotationManager(annotationManager) {
     defaultManager = annotationManager;
 }
-function resetAnnotationManager() {
-    defaultManager = defaultFrameOfReferenceSpecificAnnotationManager;
-}
 function getAnnotations(toolName, annotationGroupSelector) {
     const manager = getAnnotationManager();
     const groupKey = manager.getGroupKey(annotationGroupSelector);
     return manager.getAnnotations(groupKey, toolName);
 }
+function getAnnotation(annotationUID) {
+    const manager = getAnnotationManager();
+    return manager.getAnnotation(annotationUID);
+}
 function getAllAnnotations() {
     const manager = getAnnotationManager();
     return manager.getAllAnnotations();
@@ -130,4 +115,4 @@ function invalidateAnnotation(annotation) {
             : undefined;
     }
 }
-export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, getAnnotation, };
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, invalidateAnnotation, getAnnotation, };

package/dist/esm/stateManagement/annotation/annotationVisibility.js

@@ -1,7 +1,7 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import { Events } from '../../enums';
 import { isAnnotationSelected, deselectAnnotation, } from './annotationSelection';
-import { getAnnotation } from './getAnnotation';
+import { getAnnotation } from './annotationState';
 const globalHiddenAnnotationUIDsSet = new Set();
 function setAnnotationVisibility(annotationUID, visible = true) {
     const detail = makeEventDetail();

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

@@ -1,8 +1,27 @@
 import * as config from './config';
 import * as locking from './annotationLocking';
 import * as selection from './annotationSelection';
-import * as state from './annotationState';
+import * as annotationState from './annotationState';
 import * as visibility from './annotationVisibility';
 import FrameOfReferenceSpecificAnnotationManager from './FrameOfReferenceSpecificAnnotationManager';
 import AnnotationGroup from './AnnotationGroup';
+import { resetAnnotationManager } from './resetAnnotationManager';
+declare const state: {
+    resetAnnotationManager: typeof resetAnnotationManager;
+    getAllAnnotations: typeof annotationState.getAllAnnotations;
+    getAnnotations: typeof annotationState.getAnnotations;
+    getParentAnnotation: typeof annotationState.getParentAnnotation;
+    getChildAnnotations: typeof annotationState.getChildAnnotations;
+    clearParentAnnotation: typeof annotationState.clearParentAnnotation;
+    addChildAnnotation: typeof annotationState.addChildAnnotation;
+    getNumberOfAnnotations: typeof annotationState.getNumberOfAnnotations;
+    addAnnotation: typeof annotationState.addAnnotation;
+    removeAnnotation: typeof annotationState.removeAnnotation;
+    removeAnnotations: typeof annotationState.removeAnnotations;
+    removeAllAnnotations: typeof annotationState.removeAllAnnotations;
+    setAnnotationManager: typeof annotationState.setAnnotationManager;
+    getAnnotationManager: typeof annotationState.getAnnotationManager;
+    invalidateAnnotation: typeof annotationState.invalidateAnnotation;
+    getAnnotation: typeof annotationState.getAnnotation;
+};
 export { config, locking, selection, state, visibility, FrameOfReferenceSpecificAnnotationManager, AnnotationGroup, };

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

@@ -1,8 +1,13 @@
 import * as config from './config';
 import * as locking from './annotationLocking';
 import * as selection from './annotationSelection';
-import * as state from './annotationState';
+import * as annotationState from './annotationState';
 import * as visibility from './annotationVisibility';
 import FrameOfReferenceSpecificAnnotationManager from './FrameOfReferenceSpecificAnnotationManager';
 import AnnotationGroup from './AnnotationGroup';
+import { resetAnnotationManager } from './resetAnnotationManager';
+const state = {
+    ...annotationState,
+    resetAnnotationManager,
+};
 export { config, locking, selection, state, visibility, FrameOfReferenceSpecificAnnotationManager, AnnotationGroup, };

package/dist/esm/stateManagement/annotation/resetAnnotationManager.d.ts

@@ -0,0 +1 @@
+export declare function resetAnnotationManager(): void;

package/dist/esm/stateManagement/annotation/resetAnnotationManager.js

@@ -0,0 +1,21 @@
+import { checkAndDefineCachedStatsProperty, checkAndDefineTextBoxProperty, } from './utilities/defineProperties';
+import { checkAndSetAnnotationLocked } from './annotationLocking';
+import { checkAndSetAnnotationVisibility } from './annotationVisibility';
+import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
+import { setAnnotationManager } from './annotationState';
+const defaultManager = defaultFrameOfReferenceSpecificAnnotationManager;
+const preprocessingFn = (annotation) => {
+    annotation = checkAndDefineTextBoxProperty(annotation);
+    annotation = checkAndDefineCachedStatsProperty(annotation);
+    const uid = annotation.annotationUID;
+    const isLocked = checkAndSetAnnotationLocked(uid);
+    annotation.isLocked = isLocked;
+    const isVisible = checkAndSetAnnotationVisibility(uid);
+    annotation.isVisible = isVisible;
+    return annotation;
+};
+defaultManager.setPreprocessingFn(preprocessingFn);
+setAnnotationManager(defaultManager);
+export function resetAnnotationManager() {
+    setAnnotationManager(defaultManager);
+}

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

@@ -13,6 +13,6 @@ import { clearParentAnnotation } from './annotation/annotationState';
 import { addChildAnnotation } from './annotation/annotationState';
 import { setAnnotationManager } from './annotation/annotationState';
 import { getAnnotationManager } from './annotation/annotationState';
-import { resetAnnotationManager } from './annotation/annotationState';
+import { resetAnnotationManager } from './annotation/resetAnnotationManager';
 import { invalidateAnnotation } from './annotation/annotationState';
 export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation };

package/dist/esm/stateManagement/index.js

@@ -1,5 +1,6 @@
 import FrameOfReferenceSpecificAnnotationManager, { defaultFrameOfReferenceSpecificAnnotationManager, } from './annotation/FrameOfReferenceSpecificAnnotationManager';
 import * as annotationLocking from './annotation/annotationLocking';
 import * as annotationSelection from './annotation/annotationSelection';
-import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
+import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
+import { resetAnnotationManager } from './annotation/resetAnnotationManager';
 export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, };

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

@@ -5,6 +5,7 @@ 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,6 +5,10 @@ class PanTool extends BaseTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
     }) {
         super(toolProps, defaultToolProps);
+        this.preMouseDownCallback = (evt) => {
+            this.memo = null;
+            return false;
+        };
     }
     touchDragCallback(evt) {
         this._dragCallback(evt);
@@ -15,6 +19,7 @@ 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,6 +23,7 @@ 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;
@@ -145,6 +146,7 @@ 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/LengthTool.js

@@ -21,6 +21,16 @@ class LengthTool extends AnnotationTool {
         configuration: {
             preventHandleOutsideImage: false,
             getTextLines: defaultGetTextLines,
+            actions: {
+                undo: {
+                    method: 'undo',
+                    bindings: [{ key: 'z' }],
+                },
+                redo: {
+                    method: 'redo',
+                    bindings: [{ key: 'y' }],
+                },
+            },
         },
     }) {
         super(toolProps, defaultToolProps);

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

@@ -51,7 +51,7 @@ declare class LivewireContourTool extends ContourSegmentationBaseTool {
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;
     protected isContourSegmentationTool(): boolean;
     protected createAnnotation(evt: EventTypes.InteractionEventType): import("../../types").ContourAnnotation;
-    undo(element: any, config: any, evt: any): void;
+    cancelInProgress(element: any, config: any, evt: any): void;
     protected renderAnnotationInstance(renderContext: {
         enabledElement: Types.IEnabledElement;
         targetId: string;

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

@@ -37,8 +37,8 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
                 epsilon: 0.1,
             },
             actions: {
-                undo: {
-                    method: 'undo',
+                cancelInProgress: {
+                    method: 'cancelInProgress',
                     bindings: [
                         {
                             key: 'Escape',
@@ -576,8 +576,9 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         });
         return annotation;
     }
-    undo(element, config, evt) {
+    cancelInProgress(element, config, evt) {
         if (!this.editData) {
+            this.undo();
             return;
         }
         this._endCallback(evt, true);

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

@@ -1,3 +1,4 @@
+import { utilities } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
 import type StrategyCallbacks from '../../enums/StrategyCallbacks';
@@ -8,6 +9,7 @@ declare abstract class BaseTool {
     configuration: Record<string, any>;
     toolGroupId: string;
     mode: ToolModes;
+    protected memo: utilities.HistoryMemo.Memo;
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     getToolName(): string;
     applyActiveStrategy(enabledElement: Types.IEnabledElement, operationData: unknown): any;
@@ -16,5 +18,10 @@ declare abstract class BaseTool {
     setActiveStrategy(strategyName: string): void;
     protected getTargetImageData(targetId: string): Types.IImageData | Types.CPUIImageData;
     protected getTargetId(viewport: Types.IViewport): string | undefined;
+    undo(): void;
+    redo(): void;
+    static createZoomPanMemo(viewport: any): {
+        restoreMemo: () => void;
+    };
 }
 export default BaseTool;

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

@@ -1,5 +1,6 @@
 import { utilities, BaseVolumeViewport } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
+const { DefaultHistoryMemo } = utilities.HistoryMemo;
 class BaseTool {
     constructor(toolProps, defaultToolProps) {
         const initialProps = utilities.deepMerge(defaultToolProps, toolProps);
@@ -78,6 +79,32 @@ class BaseTool {
         }
         throw new Error('getTargetId: viewport must have a getViewReferenceId method');
     }
+    undo() {
+        DefaultHistoryMemo.undo();
+        this.memo = null;
+    }
+    redo() {
+        DefaultHistoryMemo.redo();
+    }
+    static createZoomPanMemo(viewport) {
+        const state = {
+            pan: viewport.getPan(),
+            zoom: viewport.getZoom(),
+        };
+        const zoomPanMemo = {
+            restoreMemo: () => {
+                const currentPan = viewport.getPan();
+                const currentZoom = viewport.getZoom();
+                viewport.setZoom(state.zoom);
+                viewport.setPan(state.pan);
+                viewport.render();
+                state.pan = currentPan;
+                state.zoom = currentZoom;
+            },
+        };
+        DefaultHistoryMemo.push(zoomPanMemo);
+        return zoomPanMemo;
+    }
 }
 BaseTool.toolName = 'BaseTool';
 export default BaseTool;

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

@@ -30,7 +30,7 @@ const sphereComposition = {
 };
 const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
 const fillInsideSphere = SPHERE_STRATEGY.strategyFunction;
-const SPHERE_THRESHOLD_STRATEGY = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.islandRemoval);
+const SPHERE_THRESHOLD_STRATEGY = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold);
 const SPHERE_THRESHOLD_STRATEGY_ISLAND = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.islandRemoval);
 const thresholdInsideSphere = SPHERE_THRESHOLD_STRATEGY.strategyFunction;
 const thresholdInsideSphereIsland = SPHERE_THRESHOLD_STRATEGY_ISLAND.strategyFunction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -104,7 +104,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^2.4.0",
+    "@cornerstonejs/core": "^2.5.1",
     "@kitware/vtk.js": "32.1.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -123,5 +123,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "70fc2826230875c1c5f3533953fac9a3025833c0"
+  "gitHead": "e7fb3e73be741795eb832b885b98de9a03fbaffd"
 }

package/dist/esm/stateManagement/annotation/getAnnotation.d.ts

@@ -1,2 +0,0 @@
-import type { Annotation } from '../../types';
-export declare function getAnnotation(annotationUID: string): Annotation;

package/dist/esm/stateManagement/annotation/getAnnotation.js

@@ -1,6 +0,0 @@
-import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
-export function getAnnotation(annotationUID) {
-    const manager = defaultFrameOfReferenceSpecificAnnotationManager;
-    const annotation = manager.getAnnotation(annotationUID);
-    return annotation;
-}