@ohif/app 3.8.0-beta.23 → 3.8.0-beta.25

package/dist/{82.bundle.122d1b58bc3e22439dd9.js → 544.bundle.b2b65dd140e9854cb129.js}

@@ -1,6 +1,6 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[82],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[544],{
 
-/***/ 28082:
+/***/ 91544:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -25,6 +25,7 @@ __webpack_require__.d(__webpack_exports__, {
   DragProbeTool: () => (/* reexport */ annotation_DragProbeTool),
   EllipticalROITool: () => (/* reexport */ annotation_EllipticalROITool),
   Enums: () => (/* reexport */ enums_namespaceObject),
+  KeyImageTool: () => (/* reexport */ annotation_KeyImageTool),
   LengthTool: () => (/* reexport */ annotation_LengthTool),
   MIPJumpToClickTool: () => (/* reexport */ tools_MIPJumpToClickTool),
   MagnifyTool: () => (/* reexport */ tools_MagnifyTool),
@@ -321,6 +322,7 @@ __webpack_require__.d(elementCursor_namespaceObject, {
 var annotation_namespaceObject = {};
 __webpack_require__.r(annotation_namespaceObject);
 __webpack_require__.d(annotation_namespaceObject, {
+  AnnotationGroup: () => (AnnotationGroup),
   FrameOfReferenceSpecificAnnotationManager: () => (annotation_FrameOfReferenceSpecificAnnotationManager),
   config: () => (annotation_config_namespaceObject),
   locking: () => (annotationLocking_namespaceObject),
@@ -528,6 +530,7 @@ __webpack_require__.d(voi_namespaceObject, {
 var esm_utilities_namespaceObject = {};
 __webpack_require__.r(esm_utilities_namespaceObject);
 __webpack_require__.d(esm_utilities_namespaceObject, {
+  annotationFrameRange: () => (AnnotationFrameRange),
   boundingBox: () => (boundingBox_namespaceObject),
   calibrateImageSpacing: () => (calibrateImageSpacing),
   cine: () => (cine_namespaceObject),
@@ -537,6 +540,8 @@ __webpack_require__.d(esm_utilities_namespaceObject, {
   dynamicVolume: () => (dynamicVolume_namespaceObject),
   getAnnotationNearPoint: () => (getAnnotationNearPoint),
   getAnnotationNearPointOnEnabledElement: () => (getAnnotationNearPointOnEnabledElement),
+  getCalibratedLengthUnits: () => (getCalibratedUnits),
+  getCalibratedScale: () => (getCalibratedScale),
   isObject: () => (utilities_isObject),
   jumpToSlice: () => (viewport_jumpToSlice),
   math: () => (math_namespaceObject),
@@ -624,8 +629,8 @@ __webpack_require__.d(synchronizers_namespaceObject, {
 var types_namespaceObject = {};
 __webpack_require__.r(types_namespaceObject);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 344 modules
-var esm = __webpack_require__(62231);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 356 modules
+var esm = __webpack_require__(63442);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/ToolBindings.js
 var MouseBindings;
 (function (MouseBindings) {
@@ -9432,6 +9437,14 @@ class BaseTool {
             }
             return viewports[0].getImageData();
         }
+        else if (targetId.startsWith('videoId:')) {
+            const imageURI = esm.utilities.imageIdToURI(targetId);
+            const viewports = esm.utilities.getViewportsWithImageURI(imageURI, renderingEngine.id);
+            if (!viewports || !viewports.length) {
+                return;
+            }
+            return viewports[0].getImageData();
+        }
         else {
             throw new Error('getTargetIdImage: targetId must start with "imageId:" or "volumeId:"');
         }
@@ -9444,7 +9457,7 @@ class BaseTool {
             return `volumeId:${this.getTargetVolumeId(viewport)}`;
         }
         else if (viewport instanceof esm.VideoViewport) {
-            return '';
+            return `videoId:${viewport.getCurrentImageId()}`;
         }
         else {
             throw new Error('getTargetId: viewport must be a StackViewport or VolumeViewport');
@@ -10331,9 +10344,55 @@ function filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirect
     return annotationsWithinSlice;
 }
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/annotationFrameRange.js
+
+
+class AnnotationFrameRange {
+    static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
+    static imageIdToFrames(imageId) {
+        const match = imageId.match(this.frameRangeExtractor);
+        if (!match || !match[2]) {
+            return null;
+        }
+        const range = match[2].split('-').map((it) => Number(it));
+        if (range.length === 1) {
+            return range[0];
+        }
+        return range;
+    }
+    static framesToString(range) {
+        if (Array.isArray(range)) {
+            return `${range[0]}-${range[1]}`;
+        }
+        return String(range);
+    }
+    static framesToImageId(imageId, range) {
+        const match = imageId.match(this.frameRangeExtractor);
+        if (!match || !match[2]) {
+            return null;
+        }
+        const newRangeString = this.framesToString(range);
+        return imageId.replace(this.frameRangeExtractor, `${match[1]}${newRangeString}`);
+    }
+    static setFrameRange(annotation, range, eventBase) {
+        const { referencedImageId } = annotation.metadata;
+        annotation.metadata.referencedImageId = this.framesToImageId(referencedImageId, range);
+        const eventDetail = {
+            ...eventBase,
+            annotation,
+        };
+        (0,esm.triggerEvent)(esm.eventTarget, enums_Events.ANNOTATION_MODIFIED, eventDetail);
+    }
+    static getFrameRange(annotation) {
+        return this.imageIdToFrames(annotation.metadata.referencedImageId);
+    }
+}
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planar/filterAnnotationsForDisplay.js
 
 
+
+const baseUrlExtractor = /(videoId:|imageId:|volumeId:)([a-zA-Z]*:)/;
 function filterAnnotationsForDisplay(viewport, annotations) {
     if (viewport instanceof esm.StackViewport) {
         const imageId = viewport.getCurrentImageId();
@@ -10354,8 +10413,23 @@ function filterAnnotationsForDisplay(viewport, annotations) {
     }
     else if (viewport instanceof esm.VideoViewport) {
         const frameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        return annotations.filter((toolData) => {
-            return toolData.metadata.FrameOfReferenceUID === frameOfReferenceUID;
+        return annotations.filter((annotation) => {
+            if (!annotation.isVisible) {
+                return false;
+            }
+            if (annotation.metadata.FrameOfReferenceUID !== frameOfReferenceUID) {
+                return false;
+            }
+            const testURI = annotation.metadata.referencedImageId.replace(baseUrlExtractor, '');
+            if (!viewport.hasImageURI(testURI)) {
+                return false;
+            }
+            const range = AnnotationFrameRange.getFrameRange(annotation);
+            const frameNumber = viewport.getFrameNumber();
+            if (Array.isArray(range)) {
+                return frameNumber >= range[0] && frameNumber <= range[1];
+            }
+            return Math.abs(frameNumber - range) <= 5;
         });
     }
     else if (viewport instanceof esm.VolumeViewport) {
@@ -10447,40 +10521,45 @@ class ToolStyle {
     }
     _getToolStyle(property, annotationUID, viewportId, toolGroupId, toolName) {
         if (annotationUID) {
-            const styles = this.getAnnotationToolStyles(annotationUID);
-            if (styles) {
-                if (styles[property]) {
-                    return styles[property];
+            const annotationToolStyles = this.getAnnotationToolStyles(annotationUID);
+            if (annotationToolStyles) {
+                if (annotationToolStyles[property] !== undefined) {
+                    return annotationToolStyles[property];
                 }
             }
         }
         if (viewportId) {
-            const styles = this.getViewportToolStyles(viewportId);
-            if (styles) {
-                if (styles[toolName] && styles[toolName][property]) {
-                    return styles[toolName][property];
+            const viewportToolStyles = this.getViewportToolStyles(viewportId);
+            if (viewportToolStyles) {
+                if (viewportToolStyles[toolName] &&
+                    viewportToolStyles[toolName][property] !== undefined) {
+                    return viewportToolStyles[toolName][property];
                 }
-                if (styles.global && styles.global[property]) {
-                    return styles.global[property];
+                if (viewportToolStyles.global &&
+                    viewportToolStyles.global[property] !== undefined) {
+                    return viewportToolStyles.global[property];
                 }
             }
         }
         if (toolGroupId) {
-            const styles = this.getToolGroupToolStyles(toolGroupId);
-            if (styles) {
-                if (styles[toolName] && styles[toolName][property]) {
-                    return styles[toolName][property];
+            const toolGroupToolStyles = this.getToolGroupToolStyles(toolGroupId);
+            if (toolGroupToolStyles) {
+                if (toolGroupToolStyles[toolName] &&
+                    toolGroupToolStyles[toolName][property] !== undefined) {
+                    return toolGroupToolStyles[toolName][property];
                 }
-                if (styles.global && styles.global[property]) {
-                    return styles.global[property];
+                if (toolGroupToolStyles.global &&
+                    toolGroupToolStyles.global[property] !== undefined) {
+                    return toolGroupToolStyles.global[property];
                 }
             }
         }
         const globalStyles = this.getDefaultToolStyles();
-        if (globalStyles[toolName] && globalStyles[toolName][property]) {
+        if (globalStyles[toolName] &&
+            globalStyles[toolName][property] !== undefined) {
             return globalStyles[toolName][property];
         }
-        if (globalStyles.global && globalStyles.global[property]) {
+        if (globalStyles.global && globalStyles.global[property] !== undefined) {
             return globalStyles.global[property];
         }
     }
@@ -10604,10 +10683,12 @@ class AnnotationDisplayTool extends base_BaseTool {
     getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp) {
         const targetId = this.getTargetId(viewport);
         let referencedImageId;
-        if (viewport instanceof esm.StackViewport ||
-            viewport instanceof esm.VideoViewport) {
+        if (viewport instanceof esm.StackViewport) {
             referencedImageId = targetId.split('imageId:')[1];
         }
+        else if (viewport instanceof esm.VideoViewport) {
+            referencedImageId = targetId.split('videoId:')[1];
+        }
         else {
             const volumeId = targetId.split('volumeId:')[1];
             const imageVolume = esm.cache.getVolume(volumeId);
@@ -10721,13 +10802,8 @@ class AnnotationTool extends base_AnnotationDisplayTool {
             const volume = esm.cache.getVolume(volumeId);
             return volume.scaling?.PT !== undefined;
         }
-        else if (viewport instanceof esm.StackViewport) {
-            const scalingModule = imageId && esm.metaData.get('scalingModule', imageId);
-            return typeof scalingModule?.suvbw === 'number';
-        }
-        else {
-            throw new Error('Viewport is not a valid type');
-        }
+        const scalingModule = imageId && esm.metaData.get('scalingModule', imageId);
+        return typeof scalingModule?.suvbw === 'number';
     }
     _imagePointNearToolOrHandle(element, annotation, canvasCoords, proximity) {
         const handleNearImagePoint = this.getHandleNearImagePoint(element, annotation, canvasCoords, proximity);
@@ -11242,6 +11318,41 @@ function calibrateImageSpacing(imageId, renderingEngine, calibrationOrScale) {
     });
 }
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getCalibratedUnits.js
+
+const { CalibrationTypes } = esm.Enums;
+const PIXEL_UNITS = 'px';
+const getCalibratedLengthUnits = (handles, image) => {
+    const { calibration, hasPixelSpacing } = image;
+    const units = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
+    if (!calibration || !calibration.type) {
+        return units;
+    }
+    if (calibration.type === CalibrationTypes.UNCALIBRATED) {
+        return PIXEL_UNITS;
+    }
+    if (calibration.SequenceOfUltrasoundRegions) {
+        return 'US Region';
+    }
+    return `${units} ${calibration.type}`;
+};
+const SQUARE = '\xb2';
+const getCalibratedAreaUnits = (handles, image) => {
+    const { calibration, hasPixelSpacing } = image;
+    const units = (hasPixelSpacing ? 'mm' : PIXEL_UNITS) + SQUARE;
+    if (!calibration || !calibration.type) {
+        return units;
+    }
+    if (calibration.SequenceOfUltrasoundRegions) {
+        return 'US Region';
+    }
+    return `${units} ${calibration.type}`;
+};
+const getCalibratedScale = (image) => image.calibration?.scale || 1;
+const getCalibratedAspect = (image) => image.calibration?.aspect || 1;
+/* harmony default export */ const getCalibratedUnits = (getCalibratedLengthUnits);
+
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/triggerAnnotationRenderForViewportIds.js
 
 function triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender) {
@@ -11385,41 +11496,42 @@ function pointInShapeCallback(imageData, pointInShapeFn, callback, boundsIJK) {
     const rowStep = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(rowCosines[0] * rowSpacing, rowCosines[1] * rowSpacing, rowCosines[2] * rowSpacing);
     const columnStep = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(columnCosines[0] * columnSpacing, columnCosines[1] * columnSpacing, columnCosines[2] * columnSpacing);
     const scanAxisStep = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(scanAxisNormal[0] * scanAxisSpacing, scanAxisNormal[1] * scanAxisSpacing, scanAxisNormal[2] * scanAxisSpacing);
-    const yMultiple = dimensions[0];
-    const zMultiple = dimensions[0] * dimensions[1];
+    const xMultiple = scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
+    const yMultiple = dimensions[0] * xMultiple;
+    const zMultiple = dimensions[1] * yMultiple;
     const pointsInShape = [];
+    const currentPos = gl_matrix_esm/* vec3.clone */.R3.clone(worldPosStart);
     for (let k = kMin; k <= kMax; k++) {
+        const startPosJ = gl_matrix_esm/* vec3.clone */.R3.clone(currentPos);
         for (let j = jMin; j <= jMax; j++) {
+            const startPosI = gl_matrix_esm/* vec3.clone */.R3.clone(currentPos);
             for (let i = iMin; i <= iMax; i++) {
                 const pointIJK = [i, j, k];
-                const dI = i - iMin;
-                const dJ = j - jMin;
-                const dK = k - kMin;
-                const startWorld = worldPosStart;
-                const pointLPS = [
-                    startWorld[0] +
-                        dI * rowStep[0] +
-                        dJ * columnStep[0] +
-                        dK * scanAxisStep[0],
-                    startWorld[1] +
-                        dI * rowStep[1] +
-                        dJ * columnStep[1] +
-                        dK * scanAxisStep[1],
-                    startWorld[2] +
-                        dI * rowStep[2] +
-                        dJ * columnStep[2] +
-                        dK * scanAxisStep[2],
-                ];
-                if (pointInShapeFn(pointLPS, pointIJK)) {
-                    const index = k * zMultiple + j * yMultiple + i;
-                    const value = scalarData[index];
-                    pointsInShape.push({ value, index, pointIJK, pointLPS });
-                    if (callback !== null) {
-                        callback({ value, index, pointIJK, pointLPS });
+                if (pointInShapeFn(currentPos, currentPos)) {
+                    const index = k * zMultiple + j * yMultiple + i * xMultiple;
+                    let value;
+                    if (xMultiple > 2) {
+                        value = [
+                            scalarData[index],
+                            scalarData[index + 1],
+                            scalarData[index + 2],
+                        ];
+                    }
+                    else {
+                        value = scalarData[index];
+                    }
+                    pointsInShape.push({ value, index, pointIJK, pointLPS: currentPos });
+                    if (callback) {
+                        callback({ value, index, pointIJK, pointLPS: currentPos });
                     }
                 }
+                gl_matrix_esm/* vec3.add */.R3.add(currentPos, currentPos, rowStep);
             }
+            gl_matrix_esm/* vec3.copy */.R3.copy(currentPos, startPosI);
+            gl_matrix_esm/* vec3.add */.R3.add(currentPos, currentPos, columnStep);
         }
+        gl_matrix_esm/* vec3.copy */.R3.copy(currentPos, startPosJ);
+        gl_matrix_esm/* vec3.add */.R3.add(currentPos, currentPos, scanAxisStep);
     }
     return pointsInShape;
 }
@@ -11427,9 +11539,9 @@ function pointInShapeCallback(imageData, pointInShapeFn, callback, boundsIJK) {
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/sphere/pointInSphere.js
 function pointInSphere(sphere, pointLPS) {
     const { center, radius } = sphere;
-    return ((pointLPS[0] - center[0]) ** 2 +
-        (pointLPS[1] - center[1]) ** 2 +
-        (pointLPS[2] - center[2]) ** 2 <=
+    return ((pointLPS[0] - center[0]) * (pointLPS[0] - center[0]) +
+        (pointLPS[1] - center[1]) * (pointLPS[1] - center[1]) +
+        (pointLPS[2] - center[2]) * (pointLPS[2] - center[2]) <=
         radius ** 2);
 }
 
@@ -11560,6 +11672,9 @@ function _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWo
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/roundNumber.js
 function roundNumber(value, precision = 2) {
+    if (Array.isArray(value)) {
+        return value.map((v) => roundNumber(v, precision)).join(', ');
+    }
     if (value === undefined || value === null || value === '') {
         return 'NaN';
     }
@@ -12845,6 +12960,77 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
 }
 /* harmony default export */ const segmentation_thresholdVolumeByRange = (thresholdVolumeByRange);
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/AnnotationGroup.js
+
+
+
+class AnnotationGroup {
+    constructor() {
+        this.annotationUIDs = new Set();
+        this._isVisible = true;
+        this.visibleFilter = this.unboundVisibleFilter.bind(this);
+    }
+    unboundVisibleFilter(uid) {
+        return !this._isVisible || !this.annotationUIDs.has(uid);
+    }
+    has(uid) {
+        return this.annotationUIDs.has(uid);
+    }
+    setVisible(isVisible = true, baseEvent, filter) {
+        if (this._isVisible === isVisible) {
+            return;
+        }
+        this._isVisible = isVisible;
+        this.annotationUIDs.forEach((uid) => {
+            const annotation = getAnnotation(uid);
+            if (!annotation) {
+                this.annotationUIDs.delete(uid);
+                return;
+            }
+            if (annotation.isVisible === isVisible) {
+                return;
+            }
+            if (!isVisible && filter?.(uid) === false) {
+                return;
+            }
+            annotation.isVisible = isVisible;
+            const eventDetail = {
+                ...baseEvent,
+                annotation,
+            };
+            (0,esm.triggerEvent)(esm.eventTarget, enums_Events.ANNOTATION_MODIFIED, eventDetail);
+        });
+    }
+    get isVisible() {
+        return this._isVisible;
+    }
+    findNearby(uid, direction) {
+        const uids = [...this.annotationUIDs];
+        if (uids.length === 0) {
+            return null;
+        }
+        if (!uid) {
+            return uids[direction === 1 ? 0 : uids.length - 1];
+        }
+        const index = uids.indexOf(uid);
+        if (index === -1 ||
+            index + direction < 0 ||
+            index + direction >= uids.length) {
+            return null;
+        }
+        return uids[index + direction];
+    }
+    add(...annotationUIDs) {
+        annotationUIDs.forEach((annotationUID) => this.annotationUIDs.add(annotationUID));
+    }
+    remove(...annotationUIDs) {
+        annotationUIDs.forEach((annotationUID) => this.annotationUIDs.delete(annotationUID));
+    }
+    clear() {
+        this.annotationUIDs.clear();
+    }
+}
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/index.js
 
 
@@ -12854,6 +13040,7 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
 
 
 
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/PanTool.js
 
 
@@ -13046,21 +13233,23 @@ class WindowLevelTool extends base_BaseTool {
         const { renderingEngine, viewport } = enabledElement;
         let volumeId, lower, upper, modality, newRange, viewportsContainingVolumeUID;
         let isPreScaled = false;
+        const properties = viewport.getProperties();
         if (viewport instanceof esm.VolumeViewport) {
             const targetId = this.getTargetId(viewport);
             volumeId = targetId.split('volumeId:')[1];
             viewportsContainingVolumeUID = esm.utilities.getViewportsWithVolumeId(volumeId, renderingEngine.id);
-            const properties = viewport.getProperties();
             ({ lower, upper } = properties.voiRange);
             const volume = esm.cache.getVolume(volumeId);
+            if (!volume) {
+                throw new Error('Volume not found ' + volumeId);
+            }
             modality = volume.metadata.Modality;
             isPreScaled = volume.scaling && Object.keys(volume.scaling).length > 0;
         }
-        else if (viewport instanceof esm.StackViewport) {
-            const properties = viewport.getProperties();
+        else if (properties.voiRange) {
             modality = viewport.modality;
             ({ lower, upper } = properties.voiRange);
-            const { preScale } = viewport.getImageData();
+            const { preScale = { scaled: false } } = viewport.getImageData?.() || {};
             isPreScaled =
                 preScale.scaled && preScale.scalingParameters?.suvbw !== undefined;
         }
@@ -13087,19 +13276,15 @@ class WindowLevelTool extends base_BaseTool {
                 upper,
             });
         }
-        if (viewport instanceof esm.StackViewport) {
-            viewport.setProperties({
-                voiRange: newRange,
-            });
-            viewport.render();
-            return;
-        }
+        viewport.setProperties({
+            voiRange: newRange,
+        });
+        viewport.render();
         if (viewport instanceof esm.VolumeViewport) {
-            viewport.setProperties({
-                voiRange: newRange,
-            });
             viewportsContainingVolumeUID.forEach((vp) => {
-                vp.render();
+                if (viewport !== vp) {
+                    vp.render();
+                }
             });
             return;
         }
@@ -13155,6 +13340,9 @@ class WindowLevelTool extends base_BaseTool {
     _getImageDynamicRangeFromViewport(viewport) {
         const { imageData } = viewport.getImageData();
         const dimensions = imageData.getDimensions();
+        if (imageData.getRange) {
+            return imageData.getRange();
+        }
         let scalarData;
         if (imageData.getScalarData) {
             scalarData = imageData.getScalarData();
@@ -13246,18 +13434,9 @@ class StackScrollTool extends base_BaseTool {
     }
     _getPixelPerImage(viewport) {
         const { element } = viewport;
-        const numberOfSlices = this._getNumberOfSlices(viewport);
+        const numberOfSlices = viewport.getNumberOfSlices();
         return Math.max(2, element.offsetHeight / Math.max(numberOfSlices, 8));
     }
-    _getNumberOfSlices(viewport) {
-        if (viewport instanceof esm.VolumeViewport) {
-            const { numberOfSlices } = esm.utilities.getImageSliceDataForVolumeViewport(viewport);
-            return numberOfSlices;
-        }
-        else if (viewport instanceof esm.StackViewport) {
-            return viewport.getImageIds().length;
-        }
-    }
 }
 StackScrollTool.toolName = 'StackScroll';
 /* harmony default export */ const tools_StackScrollTool = (StackScrollTool);
@@ -14646,7 +14825,13 @@ class CrosshairsTool extends base_AnnotationTool {
         };
         this._getAnnotations = (enabledElement) => {
             const { viewport } = enabledElement;
-            return getAnnotations(this.getToolName(), viewport.element);
+            const annotations = getAnnotations(this.getToolName(), viewport.element) || [];
+            const viewportIds = this._getViewportsInfo().map(({ viewportId }) => viewportId);
+            const toolGroupAnnotations = annotations.filter((annotation) => {
+                const { data } = annotation;
+                return viewportIds.includes(data.viewportId);
+            });
+            return toolGroupAnnotations;
         };
         this._onNewVolume = (e) => {
             const viewportsInfo = this._getViewportsInfo();
@@ -17114,41 +17299,712 @@ function removeExtraPoints(viewport, worldPointsSet) {
 SegmentationIntersectionTool.toolName = 'SegmentationIntersection';
 /* harmony default export */ const tools_SegmentationIntersectionTool = (SegmentationIntersectionTool);
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getCalibratedUnits.js
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/ReferenceCursors.js
 
-const { CalibrationTypes } = esm.Enums;
-const PIXEL_UNITS = 'px';
-const getCalibratedLengthUnits = (handles, image) => {
-    const { calibration, hasPixelSpacing } = image;
-    const units = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
-    if (!calibration || !calibration.type) {
-        return units;
+
+
+
+
+
+
+
+
+
+
+class ReferenceCursors extends base_AnnotationDisplayTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            shadow: true,
+            preventHandleOutsideImage: false,
+            displayThreshold: 5,
+            positionSync: true,
+            disableCursor: false,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.isDrawing = false;
+        this.isHandleOutsideImage = false;
+        this._elementWithCursor = null;
+        this._currentCursorWorldPosition = null;
+        this._currentCanvasPosition = null;
+        this._disableCursorEnabled = false;
+        this.mouseMoveCallback = (evt) => {
+            const { detail } = evt;
+            const { element, currentPoints } = detail;
+            this._currentCursorWorldPosition = currentPoints.world;
+            this._currentCanvasPosition = currentPoints.canvas;
+            this._elementWithCursor = element;
+            const annotation = this.getActiveAnnotation(element);
+            if (annotation === null) {
+                this.createInitialAnnotation(currentPoints.world, element);
+                return false;
+            }
+            this.updateAnnotationPosition(element, annotation);
+            return false;
+        };
+        this.createInitialAnnotation = (worldPos, element) => {
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            if (!enabledElement) {
+                throw new Error('No enabled element found');
+            }
+            const { viewport, renderingEngine } = enabledElement;
+            this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            if (!viewPlaneNormal || !viewUp) {
+                throw new Error('Camera not found');
+            }
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            const annotation = {
+                highlighted: true,
+                invalidated: true,
+                metadata: {
+                    toolName: this.getToolName(),
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID,
+                    referencedImageId,
+                },
+                data: {
+                    label: '',
+                    handles: {
+                        points: [[...worldPos]],
+                        activeHandleIndex: null,
+                        textBox: {
+                            hasMoved: false,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
+                        },
+                    },
+                },
+            };
+            const annotations = getAnnotations(this.getToolName(), element);
+            if (annotations.length > 0) {
+                return null;
+            }
+            const annotationId = addAnnotation(annotation, element);
+            if (annotationId === null) {
+                return;
+            }
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), false);
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+        };
+        this.onCameraModified = (evt) => {
+            const eventDetail = evt.detail;
+            const { element, previousCamera, camera } = eventDetail;
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const viewport = enabledElement.viewport;
+            if (element !== this._elementWithCursor) {
+                return;
+            }
+            const oldFocalPoint = previousCamera.focalPoint;
+            const cameraNormal = camera.viewPlaneNormal;
+            const newFocalPoint = camera.focalPoint;
+            const deltaCameraFocalPoint = [0, 0, 0];
+            Common_Core_Math/* default.subtract */.ZP.subtract(newFocalPoint, oldFocalPoint, deltaCameraFocalPoint);
+            if (deltaCameraFocalPoint.reduce((a, b) => a + b, 0) === 0) {
+                return;
+            }
+            const dotProduct = Common_Core_Math/* default.dot */.ZP.dot(deltaCameraFocalPoint, cameraNormal);
+            if (Math.abs(dotProduct) < 1e-2) {
+                return;
+            }
+            if (!this._currentCanvasPosition) {
+                return;
+            }
+            const newWorldPos = viewport.canvasToWorld(this._currentCanvasPosition);
+            this._currentCursorWorldPosition = newWorldPos;
+            this.updateAnnotationPosition(element, this.getActiveAnnotation(element));
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport, FrameOfReferenceUID } = enabledElement;
+            const isElementWithCursor = this._elementWithCursor === viewport.element;
+            if (this.configuration.positionSync && !isElementWithCursor) {
+                this.updateViewportImage(viewport);
+            }
+            const { element } = viewport;
+            let annotations = getAnnotations(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID, data } = annotation;
+                const { handles } = data;
+                const { points } = handles;
+                if (!annotationUID) {
+                    return renderStatus;
+                }
+                styleSpecifier.annotationUID = annotationUID;
+                const lineWidthBase = parseFloat(this.getStyle('lineWidth', styleSpecifier, annotation));
+                const lineWidth = typeof lineWidthBase === 'number' && isElementWithCursor
+                    ? lineWidthBase
+                    : lineWidthBase;
+                const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
+                const color = this.getStyle('color', styleSpecifier, annotation);
+                if (points[0].some((e) => isNaN(e))) {
+                    return renderStatus;
+                }
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                if (!isAnnotationVisible(annotationUID)) {
+                    continue;
+                }
+                const crosshairUIDs = {
+                    upper: 'upper',
+                    right: 'right',
+                    lower: 'lower',
+                    left: 'left',
+                };
+                const [x, y] = canvasCoordinates[0];
+                const centerSpace = isElementWithCursor ? 20 : 7;
+                const lineLength = isElementWithCursor ? 5 : 7;
+                drawLine(svgDrawingHelper, annotationUID, crosshairUIDs.upper, [x, y - (centerSpace / 2 + lineLength)], [x, y - centerSpace / 2], { color, lineDash, lineWidth });
+                drawLine(svgDrawingHelper, annotationUID, crosshairUIDs.lower, [x, y + (centerSpace / 2 + lineLength)], [x, y + centerSpace / 2], { color, lineDash, lineWidth });
+                drawLine(svgDrawingHelper, annotationUID, crosshairUIDs.right, [x + (centerSpace / 2 + lineLength), y], [x + centerSpace / 2, y], { color, lineDash, lineWidth });
+                drawLine(svgDrawingHelper, annotationUID, crosshairUIDs.left, [x - (centerSpace / 2 + lineLength), y], [x - centerSpace / 2, y], { color, lineDash, lineWidth });
+                renderStatus = true;
+            }
+            return renderStatus;
+        };
+        this._disableCursorEnabled = this.configuration.disableCursor;
     }
-    if (calibration.type === CalibrationTypes.UNCALIBRATED) {
-        return PIXEL_UNITS;
+    onSetToolActive() {
+        this._disableCursorEnabled = this.configuration.disableCursor;
+        if (!this._disableCursorEnabled) {
+            return;
+        }
+        const viewportIds = ToolGroupManager_getToolGroup(this.toolGroupId).viewportsInfo;
+        if (!viewportIds) {
+            return;
+        }
+        const enabledElements = viewportIds.map((e) => (0,esm.getEnabledElementByIds)(e.viewportId, e.renderingEngineId));
+        enabledElements.forEach((element) => {
+            if (element) {
+                hideElementCursor(element.viewport.element);
+            }
+        });
     }
-    if (calibration.SequenceOfUltrasoundRegions) {
-        return 'US Region';
+    onSetToolDisabled() {
+        if (!this._disableCursorEnabled) {
+            return;
+        }
+        const viewportIds = ToolGroupManager_getToolGroup(this.toolGroupId).viewportsInfo;
+        if (!viewportIds) {
+            return;
+        }
+        const enabledElements = viewportIds.map((e) => (0,esm.getEnabledElementByIds)(e.viewportId, e.renderingEngineId));
+        enabledElements.forEach((element) => {
+            if (element) {
+                resetElementCursor(element.viewport.element);
+            }
+        });
     }
-    return `${units} ${calibration.type}`;
-};
-const SQUARE = '\xb2';
-const getCalibratedAreaUnits = (handles, image) => {
-    const { calibration, hasPixelSpacing } = image;
-    const units = (hasPixelSpacing ? 'mm' : PIXEL_UNITS) + SQUARE;
-    if (!calibration || !calibration.type) {
-        return units;
+    getActiveAnnotation(element) {
+        const annotations = getAnnotations(this.getToolName(), element);
+        if (!annotations.length) {
+            return null;
+        }
+        const targetAnnotation = annotations[0];
+        return targetAnnotation;
     }
-    if (calibration.SequenceOfUltrasoundRegions) {
-        return 'US Region';
+    updateAnnotationPosition(element, annotation) {
+        const worldPos = this._currentCursorWorldPosition;
+        if (!worldPos) {
+            return;
+        }
+        if (!annotation.data?.handles?.points) {
+            return;
+        }
+        annotation.data.handles.points = [[...worldPos]];
+        annotation.invalidated = true;
+        const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), false);
+        const enabledElement = (0,esm.getEnabledElement)(element);
+        if (!enabledElement) {
+            return;
+        }
+        const { renderingEngine } = enabledElement;
+        utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
     }
-    return `${units} ${calibration.type}`;
-};
-const getCalibratedScale = (image) => image.calibration?.scale || 1;
-const getCalibratedAspect = (image) => image.calibration?.aspect || 1;
-/* harmony default export */ const getCalibratedUnits = ((/* unused pure expression or super */ null && (getCalibratedLengthUnits)));
+    filterInteractableAnnotationsForElement(element, annotations) {
+        if (!(annotations instanceof Array) || annotations.length === 0) {
+            return [];
+        }
+        const annotation = annotations[0];
+        const viewport = (0,esm.getEnabledElement)(element)?.viewport;
+        if (!viewport) {
+            return [];
+        }
+        const camera = viewport.getCamera();
+        const { viewPlaneNormal, focalPoint } = camera;
+        if (!viewPlaneNormal || !focalPoint) {
+            return [];
+        }
+        const points = annotation.data?.handles?.points;
+        if (!(points instanceof Array) || points.length !== 1) {
+            return [];
+        }
+        const worldPos = points[0];
+        const plane = esm.utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
+        const distance = esm.utilities.planar.planeDistanceToPoint(plane, worldPos);
+        return distance < this.configuration.displayThreshold ? [annotation] : [];
+    }
+    updateViewportImage(viewport) {
+        const currentMousePosition = this._currentCursorWorldPosition;
+        if (!currentMousePosition || currentMousePosition.some((e) => isNaN(e))) {
+            return;
+        }
+        if (viewport instanceof esm.StackViewport) {
+            const closestIndex = esm.utilities.getClosestStackImageIndexForPoint(currentMousePosition, viewport);
+            if (closestIndex === null) {
+                return;
+            }
+            if (closestIndex !== viewport.getCurrentImageIdIndex()) {
+                viewport.setImageIdIndex(closestIndex);
+            }
+        }
+        else if (viewport instanceof esm.VolumeViewport) {
+            const { focalPoint, viewPlaneNormal } = viewport.getCamera();
+            if (!focalPoint || !viewPlaneNormal) {
+                return;
+            }
+            const plane = esm.utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
+            const currentDistance = esm.utilities.planar.planeDistanceToPoint(plane, currentMousePosition, true);
+            if (Math.abs(currentDistance) < 0.5) {
+                return;
+            }
+            const normalizedViewPlane = gl_matrix_esm/* vec3.normalize */.R3.normalize(gl_matrix_esm/* vec3.create */.R3.create(), gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...viewPlaneNormal));
+            const scaledPlaneNormal = gl_matrix_esm/* vec3.scale */.R3.scale(gl_matrix_esm/* vec3.create */.R3.create(), normalizedViewPlane, currentDistance);
+            const newFocalPoint = gl_matrix_esm/* vec3.add */.R3.add(gl_matrix_esm/* vec3.create */.R3.create(), gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...focalPoint), scaledPlaneNormal);
+            const isInBounds = true;
+            if (isInBounds) {
+                viewport.setCamera({ focalPoint: newFocalPoint });
+                const renderingEngine = viewport.getRenderingEngine();
+                if (renderingEngine) {
+                    renderingEngine.renderViewport(viewport.id);
+                }
+            }
+        }
+    }
+}
+ReferenceCursors.toolName = 'ReferenceCursors';
+/* harmony default export */ const tools_ReferenceCursors = (ReferenceCursors);
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/ScaleOverlayTool.js
+
+
+
 
 
+
+const SCALEOVERLAYTOOL_ID = 'scaleoverlay-viewport';
+const viewportsWithAnnotations = [];
+class ScaleOverlayTool extends base_AnnotationDisplayTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        configuration: {
+            viewportId: '',
+            scaleLocation: 'bottom',
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.editData = {};
+        this._init = () => {
+            const renderingEngines = (0,esm.getRenderingEngines)();
+            const renderingEngine = renderingEngines[0];
+            if (!renderingEngine) {
+                return;
+            }
+            const viewportIds = ToolGroupManager_getToolGroup(this.toolGroupId).viewportsInfo;
+            if (!viewportIds) {
+                return;
+            }
+            const enabledElements = viewportIds.map((e) => (0,esm.getEnabledElementByIds)(e.viewportId, e.renderingEngineId));
+            let { viewport } = enabledElements[0];
+            const { FrameOfReferenceUID } = enabledElements[0];
+            if (this.configuration.viewportId) {
+                enabledElements.forEach((element) => {
+                    if (element.viewport.id == this.configuration.viewportId) {
+                        viewport = element.viewport;
+                    }
+                });
+            }
+            if (!viewport) {
+                return;
+            }
+            const { viewUp, viewPlaneNormal } = viewport.getCamera();
+            const viewportCanvasCornersInWorld = esm.utilities.getViewportImageCornersInWorld(viewport);
+            let annotation = this.editData.annotation;
+            const annotations = getAnnotations(this.getToolName(), viewport.element);
+            if (annotations.length) {
+                annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
+            }
+            if (!viewportsWithAnnotations.includes(viewport.id)) {
+                const newAnnotation = {
+                    metadata: {
+                        toolName: this.getToolName(),
+                        viewPlaneNormal: [...viewPlaneNormal],
+                        viewUp: [...viewUp],
+                        FrameOfReferenceUID,
+                        referencedImageId: null,
+                    },
+                    data: {
+                        handles: {
+                            points: viewportCanvasCornersInWorld,
+                        },
+                        viewportId: viewport.id,
+                    },
+                };
+                viewportsWithAnnotations.push(viewport.id);
+                addAnnotation(newAnnotation, viewport.element);
+                annotation = newAnnotation;
+            }
+            else if (this.editData.annotation.data.viewportId == viewport.id) {
+                this.editData.annotation.data.handles.points =
+                    viewportCanvasCornersInWorld;
+                this.editData.annotation.data.viewportId = viewport.id;
+            }
+            this.editData = {
+                viewport,
+                renderingEngine,
+                annotation,
+            };
+        };
+        this.onSetToolEnabled = () => {
+            this._init();
+        };
+        this.onCameraModified = (evt) => {
+            this.configuration.viewportId = evt.detail.viewportId;
+            this._init();
+        };
+        this.computeScaleSize = (worldWidthViewport, worldHeightViewport, location) => {
+            const scaleSizes = [
+                16000, 8000, 4000, 2000, 1000, 500, 250, 100, 50, 25, 10, 5, 2,
+            ];
+            let currentScaleSize;
+            if (location == 'top' || location == 'bottom') {
+                currentScaleSize = scaleSizes.filter((scaleSize) => scaleSize < worldWidthViewport * 0.6 &&
+                    scaleSize > worldWidthViewport * 0.2);
+            }
+            else {
+                currentScaleSize = scaleSizes.filter((scaleSize) => scaleSize < worldHeightViewport * 0.6 &&
+                    scaleSize > worldHeightViewport * 0.2);
+            }
+            return currentScaleSize[0];
+        };
+        this.computeEndScaleTicks = (canvasCoordinates, location) => {
+            const locationTickOffset = {
+                bottom: [
+                    [0, -10],
+                    [0, -10],
+                ],
+                top: [
+                    [0, 10],
+                    [0, 10],
+                ],
+                left: [
+                    [0, 0],
+                    [10, 0],
+                ],
+                right: [
+                    [0, 0],
+                    [-10, 0],
+                ],
+            };
+            const endTick1 = [
+                [
+                    canvasCoordinates[1][0] + locationTickOffset[location][0][0],
+                    canvasCoordinates[1][1] + locationTickOffset[location][0][0],
+                ],
+                [
+                    canvasCoordinates[1][0] + locationTickOffset[location][1][0],
+                    canvasCoordinates[1][1] + locationTickOffset[location][1][1],
+                ],
+            ];
+            const endTick2 = [
+                [
+                    canvasCoordinates[0][0] + locationTickOffset[location][0][0],
+                    canvasCoordinates[0][1] + locationTickOffset[location][0][0],
+                ],
+                [
+                    canvasCoordinates[0][0] + locationTickOffset[location][1][0],
+                    canvasCoordinates[0][1] + locationTickOffset[location][1][1],
+                ],
+            ];
+            return {
+                endTick1: endTick1,
+                endTick2: endTick2,
+            };
+        };
+        this.computeInnerScaleTicks = (scaleSize, location, annotationUID, leftTick, rightTick) => {
+            let canvasScaleSize;
+            if (location == 'bottom' || location == 'top') {
+                canvasScaleSize = rightTick[0][0] - leftTick[0][0];
+            }
+            else if (location == 'left' || location == 'right') {
+                canvasScaleSize = rightTick[0][1] - leftTick[0][1];
+            }
+            const tickIds = [];
+            const tickUIDs = [];
+            const tickCoordinates = [];
+            let numberSmallTicks = scaleSize;
+            if (scaleSize >= 50) {
+                numberSmallTicks = scaleSize / 10;
+            }
+            const tickSpacing = canvasScaleSize / numberSmallTicks;
+            for (let i = 0; i < numberSmallTicks - 1; i++) {
+                const locationOffset = {
+                    bottom: [
+                        [tickSpacing * (i + 1), 0],
+                        [tickSpacing * (i + 1), 5],
+                    ],
+                    top: [
+                        [tickSpacing * (i + 1), 0],
+                        [tickSpacing * (i + 1), -5],
+                    ],
+                    left: [
+                        [0, tickSpacing * (i + 1)],
+                        [-5, tickSpacing * (i + 1)],
+                    ],
+                    right: [
+                        [0, tickSpacing * (i + 1)],
+                        [5, tickSpacing * (i + 1)],
+                    ],
+                };
+                tickIds.push(`${annotationUID}-tick${i}`);
+                tickUIDs.push(`tick${i}`);
+                if ((i + 1) % 5 == 0) {
+                    tickCoordinates.push([
+                        [
+                            leftTick[0][0] + locationOffset[location][0][0],
+                            leftTick[0][1] + locationOffset[location][0][1],
+                        ],
+                        [
+                            leftTick[1][0] + locationOffset[location][0][0],
+                            leftTick[1][1] + locationOffset[location][0][1],
+                        ],
+                    ]);
+                }
+                else {
+                    tickCoordinates.push([
+                        [
+                            leftTick[0][0] + locationOffset[location][0][0],
+                            leftTick[0][1] + locationOffset[location][0][1],
+                        ],
+                        [
+                            leftTick[1][0] + locationOffset[location][1][0],
+                            leftTick[1][1] + locationOffset[location][1][1],
+                        ],
+                    ]);
+                }
+            }
+            return { tickIds, tickUIDs, tickCoordinates };
+        };
+        this.computeWorldScaleCoordinates = (scaleSize, location, pointSet) => {
+            let worldCoordinates;
+            let topBottomVec = gl_matrix_esm/* vec3.subtract */.R3.subtract(gl_matrix_esm/* vec3.create */.R3.create(), pointSet[0], pointSet[1]);
+            topBottomVec = gl_matrix_esm/* vec3.normalize */.R3.normalize(gl_matrix_esm/* vec3.create */.R3.create(), topBottomVec);
+            let topRightVec = gl_matrix_esm/* vec3.subtract */.R3.subtract(gl_matrix_esm/* vec3.create */.R3.create(), pointSet[2], pointSet[0]);
+            topRightVec = gl_matrix_esm/* vec3.normalize */.R3.normalize(gl_matrix_esm/* vec3.create */.R3.create(), topRightVec);
+            const midpointLocation = {
+                bottom: [pointSet[1], pointSet[2]],
+                top: [pointSet[0], pointSet[3]],
+                right: [pointSet[2], pointSet[3]],
+                left: [pointSet[0], pointSet[1]],
+            };
+            const midpoint = gl_matrix_esm/* vec3.add */.R3.add(gl_matrix_esm/* vec3.create */.R3.create(), midpointLocation[location][0], midpointLocation[location][0])
+                .map((i) => i / 2);
+            const offset = scaleSize /
+                2 /
+                Math.sqrt(Math.pow(topBottomVec[0], 2) +
+                    Math.pow(topBottomVec[1], 2) +
+                    Math.pow(topBottomVec[2], 2));
+            if (location == 'top' || location == 'bottom') {
+                worldCoordinates = [
+                    gl_matrix_esm/* vec3.subtract */.R3.subtract(gl_matrix_esm/* vec3.create */.R3.create(), midpoint, topRightVec.map((i) => i * offset)),
+                    gl_matrix_esm/* vec3.add */.R3.add(gl_matrix_esm/* vec3.create */.R3.create(), midpoint, topRightVec.map((i) => i * offset)),
+                ];
+            }
+            else if (location == 'left' || location == 'right') {
+                worldCoordinates = [
+                    gl_matrix_esm/* vec3.add */.R3.add(gl_matrix_esm/* vec3.create */.R3.create(), midpoint, topBottomVec.map((i) => i * offset)),
+                    gl_matrix_esm/* vec3.subtract */.R3.subtract(gl_matrix_esm/* vec3.create */.R3.create(), midpoint, topBottomVec.map((i) => i * offset)),
+                ];
+            }
+            return worldCoordinates;
+        };
+        this.computeCanvasScaleCoordinates = (canvasSize, canvasCoordinates, vscaleBounds, hscaleBounds, location) => {
+            let scaleCanvasCoordinates;
+            if (location == 'top' || location == 'bottom') {
+                const worldDistanceOnCanvas = canvasCoordinates[0][0] - canvasCoordinates[1][0];
+                scaleCanvasCoordinates = [
+                    [canvasSize.width / 2 - worldDistanceOnCanvas / 2, vscaleBounds.height],
+                    [canvasSize.width / 2 + worldDistanceOnCanvas / 2, vscaleBounds.height],
+                ];
+            }
+            else if (location == 'left' || location == 'right') {
+                const worldDistanceOnCanvas = canvasCoordinates[0][1] - canvasCoordinates[1][1];
+                scaleCanvasCoordinates = [
+                    [hscaleBounds.width, canvasSize.height / 2 - worldDistanceOnCanvas / 2],
+                    [hscaleBounds.width, canvasSize.height / 2 + worldDistanceOnCanvas / 2],
+                ];
+            }
+            return scaleCanvasCoordinates;
+        };
+        this.computeScaleBounds = (canvasSize, horizontalReduction, verticalReduction, location) => {
+            const hReduction = horizontalReduction * Math.min(1000, canvasSize.width);
+            const vReduction = verticalReduction * Math.min(1000, canvasSize.height);
+            const locationBounds = {
+                bottom: [-vReduction, -hReduction],
+                top: [vReduction, hReduction],
+                left: [vReduction, hReduction],
+                right: [-vReduction, -hReduction],
+            };
+            const canvasBounds = {
+                bottom: [canvasSize.height, canvasSize.width],
+                top: [0, canvasSize.width],
+                left: [canvasSize.height, 0],
+                right: [canvasSize.height, canvasSize.width],
+            };
+            return {
+                height: canvasBounds[location][0] + locationBounds[location][0],
+                width: canvasBounds[location][1] + locationBounds[location][1],
+            };
+        };
+    }
+    renderAnnotation(enabledElement, svgDrawingHelper) {
+        if (!this.editData.viewport) {
+            return;
+        }
+        const location = this.configuration.scaleLocation;
+        const { viewport } = enabledElement;
+        const annotations = getAnnotations(this.getToolName(), viewport.element);
+        const annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
+        const canvas = enabledElement.viewport.canvas;
+        const renderStatus = false;
+        if (!viewport) {
+            return renderStatus;
+        }
+        const styleSpecifier = {
+            toolGroupId: this.toolGroupId,
+            toolName: this.getToolName(),
+            viewportId: enabledElement.viewport.id,
+        };
+        const canvasSize = {
+            width: canvas.width,
+            height: canvas.height,
+        };
+        const topLeft = annotation.data.handles.points[0];
+        const topRight = annotation.data.handles.points[1];
+        const bottomLeft = annotation.data.handles.points[2];
+        const bottomRight = annotation.data.handles.points[3];
+        const pointSet1 = [topLeft, bottomLeft, topRight, bottomRight];
+        const worldWidthViewport = gl_matrix_esm/* vec3.distance */.R3.distance(bottomLeft, bottomRight);
+        const worldHeightViewport = gl_matrix_esm/* vec3.distance */.R3.distance(topLeft, bottomLeft);
+        const hscaleBounds = this.computeScaleBounds(canvasSize, 0.05, 0.05, location);
+        const vscaleBounds = this.computeScaleBounds(canvasSize, 0.05, 0.05, location);
+        const scaleSize = this.computeScaleSize(worldWidthViewport, worldHeightViewport, location);
+        const canvasCoordinates = this.computeWorldScaleCoordinates(scaleSize, location, pointSet1).map((world) => viewport.worldToCanvas(world));
+        const scaleCanvasCoordinates = this.computeCanvasScaleCoordinates(canvasSize, canvasCoordinates, vscaleBounds, hscaleBounds, location);
+        const scaleTicks = this.computeEndScaleTicks(scaleCanvasCoordinates, location);
+        const { annotationUID } = annotation;
+        styleSpecifier.annotationUID = annotationUID;
+        const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
+        const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
+        const color = this.getStyle('color', styleSpecifier, annotation);
+        const shadow = this.getStyle('shadow', styleSpecifier, annotation);
+        const scaleId = `${annotationUID}-scaleline`;
+        const scaleLineUID = '1';
+        drawLine(svgDrawingHelper, annotationUID, scaleLineUID, scaleCanvasCoordinates[0], scaleCanvasCoordinates[1], {
+            color,
+            width: lineWidth,
+            lineDash,
+            shadow,
+        }, scaleId);
+        const leftTickId = `${annotationUID}-left`;
+        const leftTickUID = '2';
+        drawLine(svgDrawingHelper, annotationUID, leftTickUID, scaleTicks.endTick1[0], scaleTicks.endTick1[1], {
+            color,
+            width: lineWidth,
+            lineDash,
+            shadow,
+        }, leftTickId);
+        const rightTickId = `${annotationUID}-right`;
+        const rightTickUID = '3';
+        drawLine(svgDrawingHelper, annotationUID, rightTickUID, scaleTicks.endTick2[0], scaleTicks.endTick2[1], {
+            color,
+            width: lineWidth,
+            lineDash,
+            shadow,
+        }, rightTickId);
+        const locationTextOffest = {
+            bottom: [-10, -42],
+            top: [-12, -35],
+            left: [-40, -20],
+            right: [-50, -20],
+        };
+        const textCanvasCoordinates = [
+            scaleCanvasCoordinates[0][0] + locationTextOffest[location][0],
+            scaleCanvasCoordinates[0][1] + locationTextOffest[location][1],
+        ];
+        const textBoxLines = this._getTextLines(scaleSize);
+        const { tickIds, tickUIDs, tickCoordinates } = this.computeInnerScaleTicks(scaleSize, location, annotationUID, scaleTicks.endTick1, scaleTicks.endTick2);
+        for (let i = 0; i < tickUIDs.length; i++) {
+            drawLine(svgDrawingHelper, annotationUID, tickUIDs[i], tickCoordinates[i][0], tickCoordinates[i][1], {
+                color,
+                width: lineWidth,
+                lineDash,
+                shadow,
+            }, tickIds[i]);
+        }
+        const textUID = 'text0';
+        drawingSvg_drawTextBox(svgDrawingHelper, annotationUID, textUID, textBoxLines, [textCanvasCoordinates[0], textCanvasCoordinates[1]], {
+            fontFamily: 'Helvetica Neue, Helvetica, Arial, sans-serif',
+            fontSize: '14px',
+            lineDash: '2,3',
+            lineWidth: '1',
+            shadow: true,
+            color: color,
+        });
+        return renderStatus;
+    }
+    _getTextLines(scaleSize) {
+        let scaleSizeDisplayValue;
+        let scaleSizeUnits;
+        if (scaleSize >= 50) {
+            scaleSizeDisplayValue = scaleSize / 10;
+            scaleSizeUnits = ' cm';
+        }
+        else {
+            scaleSizeDisplayValue = scaleSize;
+            scaleSizeUnits = ' mm';
+        }
+        const textLines = [scaleSizeDisplayValue.toString().concat(scaleSizeUnits)];
+        return textLines;
+    }
+}
+ScaleOverlayTool.toolName = 'ScaleOverlay';
+/* harmony default export */ const tools_ScaleOverlayTool = (ScaleOverlayTool);
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/drawing/getTextBoxCoordsCanvas.js
 function getTextBoxCoordsCanvas(annotationCanvasPoints) {
     const corners = _determineCorners(annotationCanvasPoints);
@@ -18402,7 +19258,7 @@ function isViewportPreScaled(viewport, targetId) {
         return !!preScale?.scaled;
     }
     else {
-        throw new Error('Viewport is not a valid type');
+        return false;
     }
 }
 
@@ -18420,6 +19276,7 @@ function isViewportPreScaled(viewport, targetId) {
 
 
 
+
 const { transformWorldToIndex: ProbeTool_transformWorldToIndex } = esm.utilities;
 class ProbeTool extends base_AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -18687,11 +19544,21 @@ class ProbeTool extends base_AnnotationTool {
             index[0] = Math.round(index[0]);
             index[1] = Math.round(index[1]);
             index[2] = Math.round(index[2]);
+            const samplesPerPixel = scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
             if (esm.utilities.indexWithinDimensions(index, dimensions)) {
                 this.isHandleOutsideImage = false;
-                const yMultiple = dimensions[0];
-                const zMultiple = dimensions[0] * dimensions[1];
-                const value = scalarData[index[2] * zMultiple + index[1] * yMultiple + index[0]];
+                const yMultiple = dimensions[0] * samplesPerPixel;
+                const zMultiple = dimensions[0] * dimensions[1] * samplesPerPixel;
+                const baseIndex = index[2] * zMultiple +
+                    index[1] * yMultiple +
+                    index[0] * samplesPerPixel;
+                const value = samplesPerPixel > 2
+                    ? [
+                        scalarData[baseIndex],
+                        scalarData[baseIndex + 1],
+                        scalarData[baseIndex + 2],
+                    ]
+                    : scalarData[baseIndex];
                 if (targetId.startsWith('imageId:')) {
                     const imageId = targetId.split('imageId:')[1];
                     const imageURI = esm.utilities.imageIdToURI(imageId);
@@ -18734,7 +19601,7 @@ function ProbeTool_defaultGetTextLines(data, targetId) {
     }
     const textLines = [];
     textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-    textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
+    textLines.push(`${utilities_roundNumber(value)} ${modalityUnit}`);
     return textLines;
 }
 ProbeTool.toolName = 'Probe';
@@ -18930,39 +19797,52 @@ class Calculator {
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/BasicStatsCalculator.js
 
 class BasicStatsCalculator extends basic_Calculator {
-    static { this.max = -Infinity; }
-    static { this.currentMax = 0; }
-    static { this.sum = 0; }
-    static { this.sumSquares = 0; }
-    static { this.squaredDiffSum = 0; }
+    static { this.max = [-Infinity]; }
+    static { this.sum = [0]; }
+    static { this.sumSquares = [0]; }
+    static { this.squaredDiffSum = [0]; }
     static { this.count = 0; }
     static { this.statsCallback = ({ value: newValue }) => {
-        if (newValue > this.max) {
-            this.max = newValue;
-            this.currentMax = newValue;
-        }
+        if (Array.isArray(newValue) &&
+            newValue.length > 1 &&
+            this.max.length === 1) {
+            this.max.push(this.max[0], this.max[0]);
+            this.sum.push(this.sum[0], this.sum[0]);
+            this.sumSquares.push(this.sumSquares[0], this.sumSquares[0]);
+            this.squaredDiffSum.push(this.squaredDiffSum[0], this.squaredDiffSum[0]);
+        }
+        const newArray = Array.isArray(newValue) ? newValue : [newValue];
         this.count += 1;
-        this.sum += newValue;
-        this.sumSquares += newValue ** 2;
-        this.squaredDiffSum += Math.pow(newValue - this.sum / this.count, 2);
+        this.max.forEach((it, idx) => (this.max[idx] = Math.max(it, newArray[idx])));
+        this.sum.map((it, idx) => (this.sum[idx] += newArray[idx]));
+        this.sumSquares.map((it, idx) => (this.sumSquares[idx] += newArray[idx] ** 2));
+        this.squaredDiffSum.map((it, idx) => (this.squaredDiffSum[idx] += Math.pow(newArray[idx] - this.sum[idx] / this.count, 2)));
     }; }
     static { this.getStatistics = () => {
-        const mean = this.sum / this.count;
-        const stdDev = Math.sqrt(this.squaredDiffSum / this.count);
-        const stdDevWithSumSquare = Math.sqrt(this.sumSquares / this.count - mean ** 2);
-        this.max = -Infinity;
-        this.sum = 0;
-        this.sumSquares = 0;
-        this.squaredDiffSum = 0;
+        const mean = this.sum.map((sum) => sum / this.count);
+        const stdDev = this.squaredDiffSum.map((squaredDiffSum) => Math.sqrt(squaredDiffSum / this.count));
+        const stdDevWithSumSquare = this.sumSquares.map((it, idx) => Math.sqrt(this.sumSquares[idx] / this.count - mean[idx] ** 2));
+        const currentMax = this.max;
+        this.max = [-Infinity];
+        this.sum = [0];
+        this.sumSquares = [0];
+        this.squaredDiffSum = [0];
         this.count = 0;
         return [
-            { name: 'max', value: this.currentMax, unit: null },
-            { name: 'mean', value: mean, unit: null },
-            { name: 'stdDev', value: stdDev, unit: null },
-            { name: 'stdDevWithSumSquare', value: stdDevWithSumSquare, unit: null },
+            { name: 'max', value: singleArrayAsNumber(currentMax), unit: null },
+            { name: 'mean', value: singleArrayAsNumber(mean), unit: null },
+            { name: 'stdDev', value: singleArrayAsNumber(stdDev), unit: null },
+            {
+                name: 'stdDevWithSumSquare',
+                value: singleArrayAsNumber(stdDevWithSumSquare),
+                unit: null,
+            },
         ];
     }; }
 }
+function singleArrayAsNumber(val) {
+    return val.length === 1 ? val[0] : val;
+}
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/index.js
 
@@ -22987,16 +23867,13 @@ class PlanarFreehandROITool extends base_AnnotationTool {
         const enabledElement = (0,esm.getEnabledElement)(element);
         const { viewport } = enabledElement;
         let annotationsToDisplay;
-        if (viewport instanceof esm.StackViewport) {
-            annotationsToDisplay = filterAnnotationsForDisplay(viewport, annotations);
-        }
-        else if (viewport instanceof esm.VolumeViewport) {
+        if (viewport instanceof esm.VolumeViewport) {
             const camera = viewport.getCamera();
             const { spacingInNormalDirection } = esm.utilities.getTargetVolumeAndSpacingInNormalDir(viewport, camera);
             annotationsToDisplay = this.filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirection);
         }
         else {
-            throw new Error(`Viewport Type ${viewport.type} not supported`);
+            annotationsToDisplay = filterAnnotationsForDisplay(viewport, annotations);
         }
         return annotationsToDisplay;
     }
@@ -24662,711 +25539,213 @@ function CobbAngleTool_defaultGetTextLines(data, targetId) {
 CobbAngleTool.toolName = 'CobbAngle';
 /* harmony default export */ const annotation_CobbAngleTool = (CobbAngleTool);
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/ReferenceCursors.js
-
-
-
-
-
-
-
-
-
-
-
-class ReferenceCursors extends base_AnnotationDisplayTool {
-    constructor(toolProps = {}, defaultToolProps = {
-        supportedInteractionTypes: ['Mouse', 'Touch'],
-        configuration: {
-            shadow: true,
-            preventHandleOutsideImage: false,
-            displayThreshold: 5,
-            positionSync: true,
-            disableCursor: false,
-        },
-    }) {
-        super(toolProps, defaultToolProps);
-        this.isDrawing = false;
-        this.isHandleOutsideImage = false;
-        this._elementWithCursor = null;
-        this._currentCursorWorldPosition = null;
-        this._currentCanvasPosition = null;
-        this._disableCursorEnabled = false;
-        this.mouseMoveCallback = (evt) => {
-            const { detail } = evt;
-            const { element, currentPoints } = detail;
-            this._currentCursorWorldPosition = currentPoints.world;
-            this._currentCanvasPosition = currentPoints.canvas;
-            this._elementWithCursor = element;
-            const annotation = this.getActiveAnnotation(element);
-            if (annotation === null) {
-                this.createInitialAnnotation(currentPoints.world, element);
-                return false;
-            }
-            this.updateAnnotationPosition(element, annotation);
-            return false;
-        };
-        this.createInitialAnnotation = (worldPos, element) => {
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            if (!enabledElement) {
-                throw new Error('No enabled element found');
-            }
-            const { viewport, renderingEngine } = enabledElement;
-            this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            if (!viewPlaneNormal || !viewUp) {
-                throw new Error('Camera not found');
-            }
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                },
-                data: {
-                    label: '',
-                    handles: {
-                        points: [[...worldPos]],
-                        activeHandleIndex: null,
-                        textBox: {
-                            hasMoved: false,
-                            worldPosition: [0, 0, 0],
-                            worldBoundingBox: {
-                                topLeft: [0, 0, 0],
-                                topRight: [0, 0, 0],
-                                bottomLeft: [0, 0, 0],
-                                bottomRight: [0, 0, 0],
-                            },
-                        },
-                    },
-                },
-            };
-            const annotations = getAnnotations(this.getToolName(), element);
-            if (annotations.length > 0) {
-                return null;
-            }
-            const annotationId = addAnnotation(annotation, element);
-            if (annotationId === null) {
-                return;
-            }
-            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), false);
-            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
-        };
-        this.onCameraModified = (evt) => {
-            const eventDetail = evt.detail;
-            const { element, previousCamera, camera } = eventDetail;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const viewport = enabledElement.viewport;
-            if (element !== this._elementWithCursor) {
-                return;
-            }
-            const oldFocalPoint = previousCamera.focalPoint;
-            const cameraNormal = camera.viewPlaneNormal;
-            const newFocalPoint = camera.focalPoint;
-            const deltaCameraFocalPoint = [0, 0, 0];
-            Common_Core_Math/* default.subtract */.ZP.subtract(newFocalPoint, oldFocalPoint, deltaCameraFocalPoint);
-            if (deltaCameraFocalPoint.reduce((a, b) => a + b, 0) === 0) {
-                return;
-            }
-            const dotProduct = Common_Core_Math/* default.dot */.ZP.dot(deltaCameraFocalPoint, cameraNormal);
-            if (Math.abs(dotProduct) < 1e-2) {
-                return;
-            }
-            if (!this._currentCanvasPosition) {
-                return;
-            }
-            const newWorldPos = viewport.canvasToWorld(this._currentCanvasPosition);
-            this._currentCursorWorldPosition = newWorldPos;
-            this.updateAnnotationPosition(element, this.getActiveAnnotation(element));
-        };
-        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
-            let renderStatus = false;
-            const { viewport, FrameOfReferenceUID } = enabledElement;
-            const isElementWithCursor = this._elementWithCursor === viewport.element;
-            if (this.configuration.positionSync && !isElementWithCursor) {
-                this.updateViewportImage(viewport);
-            }
-            const { element } = viewport;
-            let annotations = getAnnotations(this.getToolName(), element);
-            if (!annotations?.length) {
-                return renderStatus;
-            }
-            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
-            if (!annotations?.length) {
-                return renderStatus;
-            }
-            const styleSpecifier = {
-                toolGroupId: this.toolGroupId,
-                toolName: this.getToolName(),
-                viewportId: enabledElement.viewport.id,
-            };
-            for (let i = 0; i < annotations.length; i++) {
-                const annotation = annotations[i];
-                const { annotationUID, data } = annotation;
-                const { handles } = data;
-                const { points } = handles;
-                if (!annotationUID) {
-                    return renderStatus;
-                }
-                styleSpecifier.annotationUID = annotationUID;
-                const lineWidthBase = parseFloat(this.getStyle('lineWidth', styleSpecifier, annotation));
-                const lineWidth = typeof lineWidthBase === 'number' && isElementWithCursor
-                    ? lineWidthBase
-                    : lineWidthBase;
-                const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-                const color = this.getStyle('color', styleSpecifier, annotation);
-                if (points[0].some((e) => isNaN(e))) {
-                    return renderStatus;
-                }
-                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-                if (!viewport.getRenderingEngine()) {
-                    console.warn('Rendering Engine has been destroyed');
-                    return renderStatus;
-                }
-                if (!isAnnotationVisible(annotationUID)) {
-                    continue;
-                }
-                const crosshairUIDs = {
-                    upper: 'upper',
-                    right: 'right',
-                    lower: 'lower',
-                    left: 'left',
-                };
-                const [x, y] = canvasCoordinates[0];
-                const centerSpace = isElementWithCursor ? 20 : 7;
-                const lineLength = isElementWithCursor ? 5 : 7;
-                drawLine(svgDrawingHelper, annotationUID, crosshairUIDs.upper, [x, y - (centerSpace / 2 + lineLength)], [x, y - centerSpace / 2], { color, lineDash, lineWidth });
-                drawLine(svgDrawingHelper, annotationUID, crosshairUIDs.lower, [x, y + (centerSpace / 2 + lineLength)], [x, y + centerSpace / 2], { color, lineDash, lineWidth });
-                drawLine(svgDrawingHelper, annotationUID, crosshairUIDs.right, [x + (centerSpace / 2 + lineLength), y], [x + centerSpace / 2, y], { color, lineDash, lineWidth });
-                drawLine(svgDrawingHelper, annotationUID, crosshairUIDs.left, [x - (centerSpace / 2 + lineLength), y], [x - centerSpace / 2, y], { color, lineDash, lineWidth });
-                renderStatus = true;
-            }
-            return renderStatus;
-        };
-        this._disableCursorEnabled = this.configuration.disableCursor;
-    }
-    onSetToolActive() {
-        this._disableCursorEnabled = this.configuration.disableCursor;
-        if (!this._disableCursorEnabled) {
-            return;
-        }
-        const viewportIds = ToolGroupManager_getToolGroup(this.toolGroupId).viewportsInfo;
-        if (!viewportIds) {
-            return;
-        }
-        const enabledElements = viewportIds.map((e) => (0,esm.getEnabledElementByIds)(e.viewportId, e.renderingEngineId));
-        enabledElements.forEach((element) => {
-            if (element) {
-                hideElementCursor(element.viewport.element);
-            }
-        });
-    }
-    onSetToolDisabled() {
-        if (!this._disableCursorEnabled) {
-            return;
-        }
-        const viewportIds = ToolGroupManager_getToolGroup(this.toolGroupId).viewportsInfo;
-        if (!viewportIds) {
-            return;
-        }
-        const enabledElements = viewportIds.map((e) => (0,esm.getEnabledElementByIds)(e.viewportId, e.renderingEngineId));
-        enabledElements.forEach((element) => {
-            if (element) {
-                resetElementCursor(element.viewport.element);
-            }
-        });
-    }
-    getActiveAnnotation(element) {
-        const annotations = getAnnotations(this.getToolName(), element);
-        if (!annotations.length) {
-            return null;
-        }
-        const targetAnnotation = annotations[0];
-        return targetAnnotation;
-    }
-    updateAnnotationPosition(element, annotation) {
-        const worldPos = this._currentCursorWorldPosition;
-        if (!worldPos) {
-            return;
-        }
-        if (!annotation.data?.handles?.points) {
-            return;
-        }
-        annotation.data.handles.points = [[...worldPos]];
-        annotation.invalidated = true;
-        const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), false);
-        const enabledElement = (0,esm.getEnabledElement)(element);
-        if (!enabledElement) {
-            return;
-        }
-        const { renderingEngine } = enabledElement;
-        utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
-    }
-    filterInteractableAnnotationsForElement(element, annotations) {
-        if (!(annotations instanceof Array) || annotations.length === 0) {
-            return [];
-        }
-        const annotation = annotations[0];
-        const viewport = (0,esm.getEnabledElement)(element)?.viewport;
-        if (!viewport) {
-            return [];
-        }
-        const camera = viewport.getCamera();
-        const { viewPlaneNormal, focalPoint } = camera;
-        if (!viewPlaneNormal || !focalPoint) {
-            return [];
-        }
-        const points = annotation.data?.handles?.points;
-        if (!(points instanceof Array) || points.length !== 1) {
-            return [];
-        }
-        const worldPos = points[0];
-        const plane = esm.utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
-        const distance = esm.utilities.planar.planeDistanceToPoint(plane, worldPos);
-        return distance < this.configuration.displayThreshold ? [annotation] : [];
-    }
-    updateViewportImage(viewport) {
-        const currentMousePosition = this._currentCursorWorldPosition;
-        if (!currentMousePosition || currentMousePosition.some((e) => isNaN(e))) {
-            return;
-        }
-        if (viewport instanceof esm.StackViewport) {
-            const closestIndex = esm.utilities.getClosestStackImageIndexForPoint(currentMousePosition, viewport);
-            if (closestIndex === null) {
-                return;
-            }
-            if (closestIndex !== viewport.getCurrentImageIdIndex()) {
-                viewport.setImageIdIndex(closestIndex);
-            }
-        }
-        else if (viewport instanceof esm.VolumeViewport) {
-            const { focalPoint, viewPlaneNormal } = viewport.getCamera();
-            if (!focalPoint || !viewPlaneNormal) {
-                return;
-            }
-            const plane = esm.utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
-            const currentDistance = esm.utilities.planar.planeDistanceToPoint(plane, currentMousePosition, true);
-            if (Math.abs(currentDistance) < 0.5) {
-                return;
-            }
-            const normalizedViewPlane = gl_matrix_esm/* vec3.normalize */.R3.normalize(gl_matrix_esm/* vec3.create */.R3.create(), gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...viewPlaneNormal));
-            const scaledPlaneNormal = gl_matrix_esm/* vec3.scale */.R3.scale(gl_matrix_esm/* vec3.create */.R3.create(), normalizedViewPlane, currentDistance);
-            const newFocalPoint = gl_matrix_esm/* vec3.add */.R3.add(gl_matrix_esm/* vec3.create */.R3.create(), gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...focalPoint), scaledPlaneNormal);
-            const isInBounds = true;
-            if (isInBounds) {
-                viewport.setCamera({ focalPoint: newFocalPoint });
-                const renderingEngine = viewport.getRenderingEngine();
-                if (renderingEngine) {
-                    renderingEngine.renderViewport(viewport.id);
-                }
-            }
-        }
-    }
-}
-ReferenceCursors.toolName = 'ReferenceCursors';
-/* harmony default export */ const tools_ReferenceCursors = (ReferenceCursors);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/KeyImageTool.js
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/ScaleOverlayTool.js
 
 
 
 
 
 
-const SCALEOVERLAYTOOL_ID = 'scaleoverlay-viewport';
-const viewportsWithAnnotations = [];
-class ScaleOverlayTool extends base_AnnotationDisplayTool {
+
+
+class KeyImageTool extends base_AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
-            viewportId: '',
-            scaleLocation: 'bottom',
+            getTextCallback: KeyImageTool_getTextCallback,
+            changeTextCallback: KeyImageTool_changeTextCallback,
+            canvasPosition: [10, 10],
+            canvasSize: 10,
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.editData = {};
-        this._init = () => {
-            const renderingEngines = (0,esm.getRenderingEngines)();
-            const renderingEngine = renderingEngines[0];
-            if (!renderingEngine) {
-                return;
-            }
-            const viewportIds = ToolGroupManager_getToolGroup(this.toolGroupId).viewportsInfo;
-            if (!viewportIds) {
-                return;
-            }
-            const enabledElements = viewportIds.map((e) => (0,esm.getEnabledElementByIds)(e.viewportId, e.renderingEngineId));
-            let { viewport } = enabledElements[0];
-            const { FrameOfReferenceUID } = enabledElements[0];
-            if (this.configuration.viewportId) {
-                enabledElements.forEach((element) => {
-                    if (element.viewport.id == this.configuration.viewportId) {
-                        viewport = element.viewport;
-                    }
-                });
-            }
-            if (!viewport) {
-                return;
-            }
-            const { viewUp, viewPlaneNormal } = viewport.getCamera();
-            const viewportCanvasCornersInWorld = esm.utilities.getViewportImageCornersInWorld(viewport);
-            let annotation = this.editData.annotation;
-            const annotations = getAnnotations(this.getToolName(), viewport.element);
-            if (annotations.length) {
-                annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
-            }
-            if (!viewportsWithAnnotations.includes(viewport.id)) {
-                const newAnnotation = {
-                    metadata: {
-                        toolName: this.getToolName(),
-                        viewPlaneNormal: [...viewPlaneNormal],
-                        viewUp: [...viewUp],
-                        FrameOfReferenceUID,
-                        referencedImageId: null,
-                    },
-                    data: {
-                        handles: {
-                            points: viewportCanvasCornersInWorld,
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { viewport, renderingEngine } = enabledElement;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            const annotation = {
+                annotationUID: null,
+                highlighted: true,
+                invalidated: true,
+                metadata: {
+                    toolName: this.getToolName(),
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID,
+                    referencedImageId,
+                },
+                data: {
+                    text: '',
+                    handles: {
+                        points: new Array(),
+                        textBox: {
+                            hasMoved: false,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
                         },
-                        viewportId: viewport.id,
                     },
+                    label: '',
+                },
+            };
+            addAnnotation(annotation, element);
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            evt.preventDefault();
+            utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            this.configuration.getTextCallback((text) => {
+                if (!text) {
+                    annotationState_removeAnnotation(annotation.annotationUID);
+                    utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+                    this.isDrawing = false;
+                    return;
+                }
+                annotation.data.text = text;
+                const eventType = enums_Events.ANNOTATION_COMPLETED;
+                const eventDetail = {
+                    annotation,
                 };
-                viewportsWithAnnotations.push(viewport.id);
-                addAnnotation(newAnnotation, viewport.element);
-                annotation = newAnnotation;
+                (0,esm.triggerEvent)(esm.eventTarget, eventType, eventDetail);
+                utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            });
+            return annotation;
+        };
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const { data } = annotation;
+            const { canvasPosition, canvasSize } = this.configuration;
+            if (!canvasPosition?.length) {
+                return false;
             }
-            else if (this.editData.annotation.data.viewportId == viewport.id) {
-                this.editData.annotation.data.handles.points =
-                    viewportCanvasCornersInWorld;
-                this.editData.annotation.data.viewportId = viewport.id;
+            if (Math.abs(canvasCoords[0] - canvasPosition[0] + canvasSize / 2) <=
+                canvasSize / 2 &&
+                Math.abs(canvasCoords[1] - canvasPosition[1] + canvasSize / 2) <=
+                    canvasSize / 2) {
+                return true;
             }
-            this.editData = {
-                viewport,
-                renderingEngine,
-                annotation,
-            };
+            return false;
         };
-        this.onSetToolEnabled = () => {
-            this._init();
+        this.toolSelectedCallback = (evt, annotation) => {
+            annotation.highlighted = true;
+            evt.preventDefault();
         };
-        this.onCameraModified = (evt) => {
-            this.configuration.viewportId = evt.detail.viewportId;
-            this._init();
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            this._deactivateModify(element);
+            resetElementCursor(element);
         };
-        this.computeScaleSize = (worldWidthViewport, worldHeightViewport, location) => {
-            const scaleSizes = [
-                16000, 8000, 4000, 2000, 1000, 500, 250, 100, 50, 25, 10, 5, 2,
-            ];
-            let currentScaleSize;
-            if (location == 'top' || location == 'bottom') {
-                currentScaleSize = scaleSizes.filter((scaleSize) => scaleSize < worldWidthViewport * 0.6 &&
-                    scaleSize > worldWidthViewport * 0.2);
+        this.doubleClickCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            let annotations = getAnnotations(this.getToolName(), element);
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return;
             }
-            else {
-                currentScaleSize = scaleSizes.filter((scaleSize) => scaleSize < worldHeightViewport * 0.6 &&
-                    scaleSize > worldHeightViewport * 0.2);
+            const clickedAnnotation = annotations.find((annotation) => this.isPointNearTool(element, annotation, eventDetail.currentPoints.canvas, 6));
+            if (!clickedAnnotation) {
+                return;
             }
-            return currentScaleSize[0];
+            const annotation = clickedAnnotation;
+            this.configuration.changeTextCallback(clickedAnnotation, evt.detail, this._doneChangingTextCallback.bind(this, element, annotation));
+            this.isDrawing = false;
+            evt.stopImmediatePropagation();
+            evt.preventDefault();
         };
-        this.computeEndScaleTicks = (canvasCoordinates, location) => {
-            const locationTickOffset = {
-                bottom: [
-                    [0, -10],
-                    [0, -10],
-                ],
-                top: [
-                    [0, 10],
-                    [0, 10],
-                ],
-                left: [
-                    [0, 0],
-                    [10, 0],
-                ],
-                right: [
-                    [0, 0],
-                    [-10, 0],
-                ],
-            };
-            const endTick1 = [
-                [
-                    canvasCoordinates[1][0] + locationTickOffset[location][0][0],
-                    canvasCoordinates[1][1] + locationTickOffset[location][0][0],
-                ],
-                [
-                    canvasCoordinates[1][0] + locationTickOffset[location][1][0],
-                    canvasCoordinates[1][1] + locationTickOffset[location][1][1],
-                ],
-            ];
-            const endTick2 = [
-                [
-                    canvasCoordinates[0][0] + locationTickOffset[location][0][0],
-                    canvasCoordinates[0][1] + locationTickOffset[location][0][0],
-                ],
-                [
-                    canvasCoordinates[0][0] + locationTickOffset[location][1][0],
-                    canvasCoordinates[0][1] + locationTickOffset[location][1][1],
-                ],
-            ];
-            return {
-                endTick1: endTick1,
-                endTick2: endTick2,
-            };
+        this._activateModify = (element) => {
+            state.isInteractingWithTool = true;
+            element.addEventListener(enums_Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(enums_Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(enums_Events.TOUCH_TAP, this._endCallback);
+            element.addEventListener(enums_Events.TOUCH_END, this._endCallback);
         };
-        this.computeInnerScaleTicks = (scaleSize, location, annotationUID, leftTick, rightTick) => {
-            let canvasScaleSize;
-            if (location == 'bottom' || location == 'top') {
-                canvasScaleSize = rightTick[0][0] - leftTick[0][0];
-            }
-            else if (location == 'left' || location == 'right') {
-                canvasScaleSize = rightTick[0][1] - leftTick[0][1];
+        this._deactivateModify = (element) => {
+            state.isInteractingWithTool = false;
+            element.removeEventListener(enums_Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(enums_Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(enums_Events.TOUCH_TAP, this._endCallback);
+            element.removeEventListener(enums_Events.TOUCH_END, this._endCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport } = enabledElement;
+            const { element } = viewport;
+            let annotations = getAnnotations(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
             }
-            const tickIds = [];
-            const tickUIDs = [];
-            const tickCoordinates = [];
-            let numberSmallTicks = scaleSize;
-            if (scaleSize >= 50) {
-                numberSmallTicks = scaleSize / 10;
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
             }
-            const tickSpacing = canvasScaleSize / numberSmallTicks;
-            for (let i = 0; i < numberSmallTicks - 1; i++) {
-                const locationOffset = {
-                    bottom: [
-                        [tickSpacing * (i + 1), 0],
-                        [tickSpacing * (i + 1), 5],
-                    ],
-                    top: [
-                        [tickSpacing * (i + 1), 0],
-                        [tickSpacing * (i + 1), -5],
-                    ],
-                    left: [
-                        [0, tickSpacing * (i + 1)],
-                        [-5, tickSpacing * (i + 1)],
-                    ],
-                    right: [
-                        [0, tickSpacing * (i + 1)],
-                        [5, tickSpacing * (i + 1)],
-                    ],
-                };
-                tickIds.push(`${annotationUID}-tick${i}`);
-                tickUIDs.push(`tick${i}`);
-                if ((i + 1) % 5 == 0) {
-                    tickCoordinates.push([
-                        [
-                            leftTick[0][0] + locationOffset[location][0][0],
-                            leftTick[0][1] + locationOffset[location][0][1],
-                        ],
-                        [
-                            leftTick[1][0] + locationOffset[location][0][0],
-                            leftTick[1][1] + locationOffset[location][0][1],
-                        ],
-                    ]);
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID } = annotation;
+                styleSpecifier.annotationUID = annotationUID;
+                const color = this.getStyle('color', styleSpecifier, annotation);
+                const { canvasPosition, canvasSize } = this.configuration;
+                if (canvasPosition?.length) {
+                    const arrowUID = '1';
+                    drawArrow(svgDrawingHelper, annotationUID, arrowUID, canvasPosition.map((it) => it + canvasSize), canvasPosition, {
+                        color,
+                        width: 1,
+                    });
                 }
-                else {
-                    tickCoordinates.push([
-                        [
-                            leftTick[0][0] + locationOffset[location][0][0],
-                            leftTick[0][1] + locationOffset[location][0][1],
-                        ],
-                        [
-                            leftTick[1][0] + locationOffset[location][1][0],
-                            leftTick[1][1] + locationOffset[location][1][1],
-                        ],
-                    ]);
+                renderStatus = true;
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
                 }
             }
-            return { tickIds, tickUIDs, tickCoordinates };
-        };
-        this.computeWorldScaleCoordinates = (scaleSize, location, pointSet) => {
-            let worldCoordinates;
-            let topBottomVec = gl_matrix_esm/* vec3.subtract */.R3.subtract(gl_matrix_esm/* vec3.create */.R3.create(), pointSet[0], pointSet[1]);
-            topBottomVec = gl_matrix_esm/* vec3.normalize */.R3.normalize(gl_matrix_esm/* vec3.create */.R3.create(), topBottomVec);
-            let topRightVec = gl_matrix_esm/* vec3.subtract */.R3.subtract(gl_matrix_esm/* vec3.create */.R3.create(), pointSet[2], pointSet[0]);
-            topRightVec = gl_matrix_esm/* vec3.normalize */.R3.normalize(gl_matrix_esm/* vec3.create */.R3.create(), topRightVec);
-            const midpointLocation = {
-                bottom: [pointSet[1], pointSet[2]],
-                top: [pointSet[0], pointSet[3]],
-                right: [pointSet[2], pointSet[3]],
-                left: [pointSet[0], pointSet[1]],
-            };
-            const midpoint = gl_matrix_esm/* vec3.add */.R3.add(gl_matrix_esm/* vec3.create */.R3.create(), midpointLocation[location][0], midpointLocation[location][0])
-                .map((i) => i / 2);
-            const offset = scaleSize /
-                2 /
-                Math.sqrt(Math.pow(topBottomVec[0], 2) +
-                    Math.pow(topBottomVec[1], 2) +
-                    Math.pow(topBottomVec[2], 2));
-            if (location == 'top' || location == 'bottom') {
-                worldCoordinates = [
-                    gl_matrix_esm/* vec3.subtract */.R3.subtract(gl_matrix_esm/* vec3.create */.R3.create(), midpoint, topRightVec.map((i) => i * offset)),
-                    gl_matrix_esm/* vec3.add */.R3.add(gl_matrix_esm/* vec3.create */.R3.create(), midpoint, topRightVec.map((i) => i * offset)),
-                ];
-            }
-            else if (location == 'left' || location == 'right') {
-                worldCoordinates = [
-                    gl_matrix_esm/* vec3.add */.R3.add(gl_matrix_esm/* vec3.create */.R3.create(), midpoint, topBottomVec.map((i) => i * offset)),
-                    gl_matrix_esm/* vec3.subtract */.R3.subtract(gl_matrix_esm/* vec3.create */.R3.create(), midpoint, topBottomVec.map((i) => i * offset)),
-                ];
-            }
-            return worldCoordinates;
-        };
-        this.computeCanvasScaleCoordinates = (canvasSize, canvasCoordinates, vscaleBounds, hscaleBounds, location) => {
-            let scaleCanvasCoordinates;
-            if (location == 'top' || location == 'bottom') {
-                const worldDistanceOnCanvas = canvasCoordinates[0][0] - canvasCoordinates[1][0];
-                scaleCanvasCoordinates = [
-                    [canvasSize.width / 2 - worldDistanceOnCanvas / 2, vscaleBounds.height],
-                    [canvasSize.width / 2 + worldDistanceOnCanvas / 2, vscaleBounds.height],
-                ];
-            }
-            else if (location == 'left' || location == 'right') {
-                const worldDistanceOnCanvas = canvasCoordinates[0][1] - canvasCoordinates[1][1];
-                scaleCanvasCoordinates = [
-                    [hscaleBounds.width, canvasSize.height / 2 - worldDistanceOnCanvas / 2],
-                    [hscaleBounds.width, canvasSize.height / 2 + worldDistanceOnCanvas / 2],
-                ];
-            }
-            return scaleCanvasCoordinates;
-        };
-        this.computeScaleBounds = (canvasSize, horizontalReduction, verticalReduction, location) => {
-            const hReduction = horizontalReduction * Math.min(1000, canvasSize.width);
-            const vReduction = verticalReduction * Math.min(1000, canvasSize.height);
-            const locationBounds = {
-                bottom: [-vReduction, -hReduction],
-                top: [vReduction, hReduction],
-                left: [vReduction, hReduction],
-                right: [-vReduction, -hReduction],
-            };
-            const canvasBounds = {
-                bottom: [canvasSize.height, canvasSize.width],
-                top: [0, canvasSize.width],
-                left: [canvasSize.height, 0],
-                right: [canvasSize.height, canvasSize.width],
-            };
-            return {
-                height: canvasBounds[location][0] + locationBounds[location][0],
-                width: canvasBounds[location][1] + locationBounds[location][1],
-            };
-        };
-    }
-    renderAnnotation(enabledElement, svgDrawingHelper) {
-        if (!this.editData.viewport) {
-            return;
-        }
-        const location = this.configuration.scaleLocation;
-        const { viewport } = enabledElement;
-        const annotations = getAnnotations(this.getToolName(), viewport.element);
-        const annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
-        const canvas = enabledElement.viewport.canvas;
-        const renderStatus = false;
-        if (!viewport) {
             return renderStatus;
-        }
-        const styleSpecifier = {
-            toolGroupId: this.toolGroupId,
-            toolName: this.getToolName(),
-            viewportId: enabledElement.viewport.id,
-        };
-        const canvasSize = {
-            width: canvas.width,
-            height: canvas.height,
-        };
-        const topLeft = annotation.data.handles.points[0];
-        const topRight = annotation.data.handles.points[1];
-        const bottomLeft = annotation.data.handles.points[2];
-        const bottomRight = annotation.data.handles.points[3];
-        const pointSet1 = [topLeft, bottomLeft, topRight, bottomRight];
-        const worldWidthViewport = gl_matrix_esm/* vec3.distance */.R3.distance(bottomLeft, bottomRight);
-        const worldHeightViewport = gl_matrix_esm/* vec3.distance */.R3.distance(topLeft, bottomLeft);
-        const hscaleBounds = this.computeScaleBounds(canvasSize, 0.05, 0.05, location);
-        const vscaleBounds = this.computeScaleBounds(canvasSize, 0.05, 0.05, location);
-        const scaleSize = this.computeScaleSize(worldWidthViewport, worldHeightViewport, location);
-        const canvasCoordinates = this.computeWorldScaleCoordinates(scaleSize, location, pointSet1).map((world) => viewport.worldToCanvas(world));
-        const scaleCanvasCoordinates = this.computeCanvasScaleCoordinates(canvasSize, canvasCoordinates, vscaleBounds, hscaleBounds, location);
-        const scaleTicks = this.computeEndScaleTicks(scaleCanvasCoordinates, location);
-        const { annotationUID } = annotation;
-        styleSpecifier.annotationUID = annotationUID;
-        const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
-        const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-        const color = this.getStyle('color', styleSpecifier, annotation);
-        const shadow = this.getStyle('shadow', styleSpecifier, annotation);
-        const scaleId = `${annotationUID}-scaleline`;
-        const scaleLineUID = '1';
-        drawLine(svgDrawingHelper, annotationUID, scaleLineUID, scaleCanvasCoordinates[0], scaleCanvasCoordinates[1], {
-            color,
-            width: lineWidth,
-            lineDash,
-            shadow,
-        }, scaleId);
-        const leftTickId = `${annotationUID}-left`;
-        const leftTickUID = '2';
-        drawLine(svgDrawingHelper, annotationUID, leftTickUID, scaleTicks.endTick1[0], scaleTicks.endTick1[1], {
-            color,
-            width: lineWidth,
-            lineDash,
-            shadow,
-        }, leftTickId);
-        const rightTickId = `${annotationUID}-right`;
-        const rightTickUID = '3';
-        drawLine(svgDrawingHelper, annotationUID, rightTickUID, scaleTicks.endTick2[0], scaleTicks.endTick2[1], {
-            color,
-            width: lineWidth,
-            lineDash,
-            shadow,
-        }, rightTickId);
-        const locationTextOffest = {
-            bottom: [-10, -42],
-            top: [-12, -35],
-            left: [-40, -20],
-            right: [-50, -20],
         };
-        const textCanvasCoordinates = [
-            scaleCanvasCoordinates[0][0] + locationTextOffest[location][0],
-            scaleCanvasCoordinates[0][1] + locationTextOffest[location][1],
-        ];
-        const textBoxLines = this._getTextLines(scaleSize);
-        const { tickIds, tickUIDs, tickCoordinates } = this.computeInnerScaleTicks(scaleSize, location, annotationUID, scaleTicks.endTick1, scaleTicks.endTick2);
-        for (let i = 0; i < tickUIDs.length; i++) {
-            drawLine(svgDrawingHelper, annotationUID, tickUIDs[i], tickCoordinates[i][0], tickCoordinates[i][1], {
-                color,
-                width: lineWidth,
-                lineDash,
-                shadow,
-            }, tickIds[i]);
-        }
-        const textUID = 'text0';
-        drawingSvg_drawTextBox(svgDrawingHelper, annotationUID, textUID, textBoxLines, [textCanvasCoordinates[0], textCanvasCoordinates[1]], {
-            fontFamily: 'Helvetica Neue, Helvetica, Arial, sans-serif',
-            fontSize: '14px',
-            lineDash: '2,3',
-            lineWidth: '1',
-            shadow: true,
-            color: color,
+    }
+    cancel() {
+    }
+    handleSelectedCallback(evt, annotation, handle) {
+    }
+    _doneChangingTextCallback(element, annotation, updatedText) {
+        annotation.data.text = updatedText;
+        const { renderingEngine, viewportId, renderingEngineId } = (0,esm.getEnabledElement)(element);
+        const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+        utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+        const eventType = enums_Events.ANNOTATION_MODIFIED;
+        (0,esm.triggerEvent)(esm.eventTarget, eventType, {
+            annotation,
+            viewportId,
+            renderingEngineId,
         });
-        return renderStatus;
     }
-    _getTextLines(scaleSize) {
-        let scaleSizeDisplayValue;
-        let scaleSizeUnits;
-        if (scaleSize >= 50) {
-            scaleSizeDisplayValue = scaleSize / 10;
-            scaleSizeUnits = ' cm';
-        }
-        else {
-            scaleSizeDisplayValue = scaleSize;
-            scaleSizeUnits = ' mm';
-        }
-        const textLines = [scaleSizeDisplayValue.toString().concat(scaleSizeUnits)];
-        return textLines;
+    _isInsideVolume(index1, index2, dimensions) {
+        return (esm.utilities.indexWithinDimensions(index1, dimensions) &&
+            esm.utilities.indexWithinDimensions(index2, dimensions));
     }
 }
-ScaleOverlayTool.toolName = 'ScaleOverlay';
-/* harmony default export */ const tools_ScaleOverlayTool = (ScaleOverlayTool);
+function KeyImageTool_getTextCallback(doneChangingTextCallback) {
+    return doneChangingTextCallback(prompt('Enter your annotation:'));
+}
+function KeyImageTool_changeTextCallback(data, eventData, doneChangingTextCallback) {
+    return doneChangingTextCallback(prompt('Enter your annotation:'));
+}
+KeyImageTool.toolName = 'KeyImage';
+/* harmony default export */ const annotation_KeyImageTool = (KeyImageTool);
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/fillRectangle.js
 
@@ -32082,6 +32461,7 @@ OrientationMarkerTool.toolName = 'OrientationMarker';
 
 
 
+
 
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/rectangleROITool/getBoundsIJKFromRectangleAnnotations.js
@@ -33329,8 +33709,8 @@ function getDataInTime(dynamicVolume, options) {
     }
     if (options.maskVolumeId) {
         const segmentationVolume = esm.cache.getVolume(options.maskVolumeId);
-        const dataInTime = _getTimePointDataMask(frames, dynamicVolume, segmentationVolume);
-        return dataInTime;
+        const [dataInTime, ijkCoords] = _getTimePointDataMask(frames, dynamicVolume, segmentationVolume);
+        return [dataInTime, ijkCoords];
     }
     if (options.imageCoordinate) {
         const dataInTime = _getTimePointDataCoordinate(frames, options.imageCoordinate, dynamicVolume);
@@ -33364,9 +33744,16 @@ function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
     const len = segScalarData.length;
     const nonZeroVoxelIndices = [];
     nonZeroVoxelIndices.length = len;
+    const ijkCoords = [];
+    const dimensions = segmentationVolume.dimensions;
     let actualLen = 0;
     for (let i = 0, len = segScalarData.length; i < len; i++) {
         if (segScalarData[i] !== 0) {
+            ijkCoords.push([
+                i % dimensions[0],
+                Math.floor((i / dimensions[0]) % dimensions[1]),
+                Math.floor(i / (dimensions[0] * dimensions[1])),
+            ]);
             nonZeroVoxelIndices[actualLen++] = i;
         }
     }
@@ -33385,9 +33772,9 @@ function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
             });
             values.push(indexValues);
         }
-        return values;
+        return [values, ijkCoords];
     }
-    const callback = ({ pointLPS: segPointLPS, value: segValue }) => {
+    const callback = ({ pointLPS: segPointLPS, value: segValue, pointIJK: segPointIJK, }) => {
         if (segValue === 0) {
             return;
         }
@@ -33408,10 +33795,11 @@ function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
         perFrameSum.forEach((sum) => {
             averageValues.push(sum / count);
         });
+        ijkCoords.push(segPointIJK);
         values.push(averageValues);
     };
     pointInShapeCallback(maskImageData, () => true, callback);
-    return values;
+    return [values, ijkCoords];
 }
 /* harmony default export */ const dynamicVolume_getDataInTime = (getDataInTime);
 
@@ -34539,6 +34927,9 @@ class ViewportColorbar extends Colorbar {
 
 
 
+
+
+
 
 
 
@@ -35771,7 +36162,10 @@ class Synchronizer {
                 if (targetIsSource) {
                     continue;
                 }
-                promises.push(this._eventHandler(this, sourceViewport, targetViewport, sourceEvent, this._options));
+                const result = this._eventHandler(this, sourceViewport, targetViewport, sourceEvent, this._options);
+                if (result instanceof Promise) {
+                    promises.push(result);
+                }
             }
         }
         catch (ex) {
@@ -35925,6 +36319,7 @@ class ToolGroup {
     constructor(id) {
         this.viewportsInfo = [];
         this.toolOptions = {};
+        this.restoreToolOptions = {};
         this._toolInstances = {};
         this.id = id;
     }
@@ -36035,7 +36430,7 @@ class ToolGroup {
             return;
         }
         if (mode === enums_ToolModes.Active) {
-            this.setToolActive(toolName, options);
+            this.setToolActive(toolName, options || this.restoreToolOptions[toolName]);
             return;
         }
         if (mode === enums_ToolModes.Passive) {
@@ -36162,6 +36557,7 @@ class ToolGroup {
             bindings: [],
             mode: Disabled,
         };
+        this.restoreToolOptions[toolName] = this.toolOptions[toolName];
         this.toolOptions[toolName] = toolOptions;
         toolInstance.mode = Disabled;
         if (typeof toolInstance.onSetToolDisabled === 'function') {
@@ -36450,7 +36846,7 @@ function getAnnotations(toolName, annotationGroupSelector) {
     return manager.getAnnotations(groupKey, toolName);
 }
 function addAnnotation(annotation, annotationGroupSelector) {
-    if (annotation.annotationUID === undefined) {
+    if (!annotation.annotationUID) {
         annotation.annotationUID = esm.utilities.uuidv4();
     }
     const manager = getAnnotationManager();
@@ -36666,7 +37062,7 @@ function areViewportsCoplanar(viewport1, viewport2) {
 
 
 
-const getSpatialRegistration = (targetId, sourceId) => esm.utilities.spatialRegistrationMetadataProvider.get('spatialRegistrationModule', [targetId, sourceId]);
+const getSpatialRegistration = (targetId, sourceId) => esm.utilities.spatialRegistrationMetadataProvider.get('spatialRegistrationModule', targetId, sourceId);
 async function stackImageSyncCallback(synchronizerInstance, sourceViewport, targetViewport) {
     const renderingEngine = (0,esm.getRenderingEngine)(targetViewport.renderingEngineId);
     if (!renderingEngine) {
@@ -36774,12 +37170,15 @@ class VideoRedactionTool extends base_AnnotationTool {
             const enabledElement = (0,esm.getEnabledElement)(element);
             const { viewport, renderingEngine } = enabledElement;
             this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
             const annotation = {
                 metadata: {
                     viewPlaneNormal: [0, 0, 1],
                     viewUp: [0, 1, 0],
                     FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
-                    referencedImageId: viewport.getFrameOfReferenceUID(),
+                    referencedImageId,
                     toolName: this.getToolName(),
                 },
                 data: {