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

package/dist/{6280.bundle.828ccda61aa5c83408a5.js → 6280.bundle.081861b7e685b28616c8.js}

@@ -338,6 +338,7 @@ var RenderingEngineModeEnum = __webpack_require__(8128);
 __webpack_require__.d(__webpack_exports__, {
   BaseVolumeViewport: () => (/* reexport */ BaseVolumeViewport/* default */.A),
   CONSTANTS: () => (/* reexport */ constants),
+  ECGViewport: () => (/* reexport */ ECGViewport/* default */.A),
   EPSILON: () => (/* reexport */ getOrCreateCanvas/* EPSILON */.p8),
   Enums: () => (/* reexport */ enums),
   ImageVolume: () => (/* reexport */ cache/* ImageVolume */.QV),
@@ -365,7 +366,7 @@ __webpack_require__.d(__webpack_exports__, {
   volumeLoader: () => (/* reexport */ volumeLoader)
 });
 
-// UNUSED EXPORTS: BaseRenderingEngine, ContextPoolRenderingEngine, EVENTS, ProgressiveRetrieveImages, RenderingEngine, StreamingDynamicImageVolume, StreamingImageVolume, Surface, TiledRenderingEngine, VideoViewport, Viewport, VolumeViewport3D, WSIViewport, canRenderFloatTextures, cornerstoneMeshLoader, cornerstoneStreamingDynamicImageVolumeLoader, cornerstoneStreamingImageVolumeLoader, createCanvas, createViewportElement, createVolumeActor, createVolumeMapper, decimatedVolumeLoader, geometryLoader, getOrCreateCanvas, getShouldUseCPURendering, imageRetrievalPoolManager, init, isCornerstoneInitialized, peerImport, registerImageLoader, requestPoolManager, resetInitialization, resetUseCPURendering, setCanvasCreator, setConfiguration, setPreferSizeOverAccuracy, setUseCPURendering, setVolumesForViewports, version
+// UNUSED EXPORTS: BaseRenderingEngine, ContextPoolRenderingEngine, EVENTS, ProgressiveRetrieveImages, RenderingEngine, StreamingDynamicImageVolume, StreamingImageVolume, Surface, TiledRenderingEngine, VideoViewport, Viewport, VolumeViewport3D, WSIViewport, canRenderFloatTextures, cornerstoneMeshLoader, cornerstoneStreamingDynamicImageVolumeLoader, cornerstoneStreamingImageVolumeLoader, createCanvas, createViewportElement, createVolumeActor, createVolumeMapper, decimatedVolumeLoader, geometryLoader, getOrCreateCanvas, getShouldUseCPURendering, imageRetrievalPoolManager, init, isCornerstoneInitialized, peerImport, registerImageLoader, requestPoolManager, resetInitialization, resetUseCPURendering, setCanvasCreator, setConfiguration, setPreferSizeOverAccuracy, setUseCPURendering, setVolumesForViewports, updateCanvasSizeAndAspectRatio, version
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js + 1 modules
 var enums = __webpack_require__(71851);
@@ -391,6 +392,8 @@ var StackViewport = __webpack_require__(4785);
 var VideoViewport = __webpack_require__(32501);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/WSIViewport.js + 1 modules
 var WSIViewport = __webpack_require__(81466);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/ECGViewport.js
+var ECGViewport = __webpack_require__(95307);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/Viewport.js
 var Viewport = __webpack_require__(10056);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/eventTarget.js
@@ -671,6 +674,7 @@ var helpers = __webpack_require__(40661);
 
 
 
+
 
 
 /***/ },
@@ -7294,7 +7298,7 @@ var COLOR_LUT = __webpack_require__(93952);
 
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '4.17.2';
+const version = '4.18.2';
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/synchronizers/callbacks/cameraSyncCallback.js
 /* unused harmony import specifier */ var cameraSyncCallback_getRenderingEngine;
@@ -14507,6 +14511,10 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
     }) {
         super(toolProps, defaultToolProps);
         this.toolCenter = [0, 0, 0];
+        this._volumeViewportNewVolumeListeners = new Map();
+        this._toolGroupViewportAddedListener = null;
+        this._toolGroupViewportRemovedListener = null;
+        this._ignoreFiredEvents = false;
         this.initializeViewport = ({ renderingEngineId, viewportId, }) => {
             const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
             if (!enabledElement) {
@@ -14552,11 +14560,21 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             const viewports = (0,ToolGroupManager.getToolGroup)(this.toolGroupId).viewportsInfo;
             return viewports;
         };
+        this._reinitializeListenersAndCenter = () => {
+            this._unbindToolGroupViewportListeners();
+            this._clearAllVolumeListenersAndViewportState();
+            this._bindToolGroupViewportListeners();
+            this._syncVolumeListenersWithToolGroup();
+            this._computeToolCenter(this._getViewportsInfo());
+        };
         this.resetCrosshairs = () => {
             const viewportsInfo = this._getViewportsInfo();
             for (const viewportInfo of viewportsInfo) {
                 const { viewportId, renderingEngineId } = viewportInfo;
                 const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+                if (!enabledElement) {
+                    continue;
+                }
                 const viewport = enabledElement.viewport;
                 const resetPan = true;
                 const resetZoom = true;
@@ -14590,31 +14608,24 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
                 console.warn('For crosshairs to operate, at least two viewports must be given.');
                 return;
             }
-            const [firstViewport, secondViewport, thirdViewport] = viewportsInfo;
-            const { normal: normal1, point: point1 } = this.initializeViewport(firstViewport);
-            const { normal: normal2, point: point2 } = this.initializeViewport(secondViewport);
-            let normal3 = [0, 0, 0];
-            let point3 = gl_matrix_esm/* vec3.create */.eR.create();
-            if (thirdViewport) {
-                ({ normal: normal3, point: point3 } =
-                    this.initializeViewport(thirdViewport));
-            }
-            else {
-                gl_matrix_esm/* vec3.add */.eR.add(point3, point1, point2);
-                gl_matrix_esm/* vec3.scale */.eR.scale(point3, point3, 0.5);
-                gl_matrix_esm/* vec3.cross */.eR.cross(normal3, normal1, normal2);
-            }
-            const firstPlane = esm.utilities.planar.planeEquation(normal1, point1);
-            const secondPlane = esm.utilities.planar.planeEquation(normal2, point2);
-            const thirdPlane = esm.utilities.planar.planeEquation(normal3, point3);
-            const toolCenter = esm.utilities.planar.threePlaneIntersection(firstPlane, secondPlane, thirdPlane);
-            this.setToolCenter(toolCenter);
+            viewportsInfo.forEach((viewportInfo) => {
+                this.initializeViewport(viewportInfo);
+            });
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: true,
+                updateViewportCameras: true,
+            });
         };
         this.addNewAnnotation = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             const { currentPoints } = eventDetail;
             const jumpWorld = currentPoints.world;
+            this._syncVolumeListenersWithToolGroup();
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: false,
+                updateViewportCameras: false,
+            });
             const enabledElement = (0,esm.getEnabledElement)(element);
             const { viewport } = enabledElement;
             this._jump(enabledElement, jumpWorld);
@@ -14669,46 +14680,33 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             const enabledElement = (0,esm.getEnabledElement)(element);
+            if (!enabledElement) {
+                return;
+            }
             const { renderingEngine } = enabledElement;
             const viewport = enabledElement.viewport;
+            this._syncVolumeListenersWithToolGroup();
+            if (this._ignoreFiredEvents) {
+                return;
+            }
+            const isSourceInToolGroup = this._getViewportsInfo().some(({ viewportId, renderingEngineId }) => viewportId === viewport.id && renderingEngineId === renderingEngine.id);
+            if (!isSourceInToolGroup) {
+                return;
+            }
             const annotations = this._getAnnotations(enabledElement);
             const filteredToolAnnotations = this.filterInteractableAnnotationsForElement(element, annotations);
             const viewportAnnotation = filteredToolAnnotations[0];
-            if (!viewportAnnotation) {
-                return;
-            }
             const currentCamera = viewport.getCamera();
-            const oldCameraPosition = viewportAnnotation.metadata.cameraPosition;
-            const deltaCameraPosition = [0, 0, 0];
-            Core_Math/* default.subtract */.Ay.subtract(currentCamera.position, oldCameraPosition, deltaCameraPosition);
-            const oldCameraFocalPoint = viewportAnnotation.metadata.cameraFocalPoint;
-            const deltaCameraFocalPoint = [0, 0, 0];
-            Core_Math/* default.subtract */.Ay.subtract(currentCamera.focalPoint, oldCameraFocalPoint, deltaCameraFocalPoint);
-            viewportAnnotation.metadata.cameraPosition = [...currentCamera.position];
-            viewportAnnotation.metadata.cameraFocalPoint = [
-                ...currentCamera.focalPoint,
-            ];
-            const viewportControllable = this._getReferenceLineControllable(viewport.id);
-            const viewportDraggableRotatable = this._getReferenceLineDraggableRotatable(viewport.id);
-            if (!esm.utilities.isEqual(currentCamera.position, oldCameraPosition, 1e-3) &&
-                viewportControllable &&
-                viewportDraggableRotatable) {
-                let isRotation = false;
-                const cameraModifiedSameForPosAndFocalPoint = esm.utilities.isEqual(deltaCameraPosition, deltaCameraFocalPoint, 1e-3);
-                if (!cameraModifiedSameForPosAndFocalPoint) {
-                    isRotation = true;
-                }
-                const cameraModifiedInPlane = Math.abs(Core_Math/* default.dot */.Ay.dot(deltaCameraPosition, currentCamera.viewPlaneNormal)) < 1e-2;
-                if (!isRotation && !cameraModifiedInPlane) {
-                    this.toolCenter[0] += deltaCameraPosition[0];
-                    this.toolCenter[1] += deltaCameraPosition[1];
-                    this.toolCenter[2] += deltaCameraPosition[2];
-                    (0,esm.triggerEvent)(esm.eventTarget, enums.Events.CROSSHAIR_TOOL_CENTER_CHANGED, {
-                        toolGroupId: this.toolGroupId,
-                        toolCenter: this.toolCenter,
-                    });
-                }
+            if (viewportAnnotation) {
+                viewportAnnotation.metadata.cameraPosition = [...currentCamera.position];
+                viewportAnnotation.metadata.cameraFocalPoint = [
+                    ...currentCamera.focalPoint,
+                ];
             }
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: true,
+                updateViewportCameras: false,
+            });
             if (this.configuration.autoPan?.enabled) {
                 const toolGroup = (0,ToolGroupManager.getToolGroupForViewport)(viewport.id, renderingEngine.id);
                 const otherViewportIds = toolGroup
@@ -15146,15 +15144,19 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             });
             return toolGroupAnnotations;
         };
-        this._onNewVolume = () => {
-            const viewportsInfo = this._getViewportsInfo();
-            this._computeToolCenter(viewportsInfo);
+        this._onNewVolume = (_evt) => {
+            this._syncVolumeListenersWithToolGroup();
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: true,
+                updateViewportCameras: false,
+            });
         };
         this._areViewportIdArraysEqual = (viewportIdArrayOne, viewportIdArrayTwo) => {
             if (viewportIdArrayOne.length !== viewportIdArrayTwo.length) {
                 return false;
             }
-            viewportIdArrayOne.forEach((id) => {
+            for (let index = 0; index < viewportIdArrayOne.length; index++) {
+                const id = viewportIdArrayOne[index];
                 let itemFound = false;
                 for (let i = 0; i < viewportIdArrayTwo.length; ++i) {
                     if (id === viewportIdArrayTwo[i]) {
@@ -15165,7 +15167,7 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
                 if (itemFound === false) {
                     return false;
                 }
-            });
+            }
             return true;
         };
         this._getAnnotationsForViewportsWithDifferentCameras = (enabledElement, annotations) => {
@@ -15341,10 +15343,19 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
                 return false;
             }
             this._applyDeltaShiftToSelectedViewportCameras(renderingEngine, viewportsAnnotationsToUpdate, delta);
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: true,
+                updateViewportCameras: false,
+            });
             state/* state */.wk.isInteractingWithTool = false;
             return true;
         };
         this._activateModify = (element) => {
+            this._syncVolumeListenersWithToolGroup();
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: false,
+                updateViewportCameras: false,
+            });
             state/* state */.wk.isInteractingWithTool = !this.configuration.mobile?.enabled;
             element.addEventListener(enums.Events.MOUSE_UP, this._endCallback);
             element.addEventListener(enums.Events.MOUSE_DRAG, this._dragCallback);
@@ -15365,9 +15376,15 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
         this._endCallback = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            this.editData.annotation.data.handles.activeOperation = null;
-            this.editData.annotation.data.activeViewportIds = [];
+            if (this.editData?.annotation?.data) {
+                this.editData.annotation.data.handles.activeOperation = null;
+                this.editData.annotation.data.activeViewportIds = [];
+            }
             this._deactivateModify(element);
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: true,
+                updateViewportCameras: false,
+            });
             (0,elementCursor.resetElementCursor)(element);
             this.editData = null;
             const requireSameOrientation = false;
@@ -15406,6 +15423,10 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
                         viewportAnnotation.data.activeViewportIds.find((id) => id === otherViewport.id));
                 });
                 this._applyDeltaShiftToSelectedViewportCameras(renderingEngine, viewportsAnnotationsToUpdate, delta);
+                this._recomputeToolCenterFromAbsoluteCameras({
+                    emitEvent: true,
+                    updateViewportCameras: false,
+                });
             }
             else if (handles.activeOperation === CrosshairsTool_OPERATION.ROTATE) {
                 const otherViewportAnnotations = this._getAnnotationsForViewportsWithDifferentCameras(enabledElement, annotations);
@@ -15442,29 +15463,40 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
                     .rotate(angle, rotationAxis)
                     .translate(-center[0], -center[1], -center[2]);
                 const otherViewportsIds = [];
-                viewportsAnnotationsToUpdate.forEach((annotation) => {
-                    const { data } = annotation;
-                    data.handles.toolCenter = center;
-                    const otherViewport = renderingEngine.getViewport(data.viewportId);
-                    const camera = otherViewport.getCamera();
-                    const { viewUp, position, focalPoint } = camera;
-                    viewUp[0] += position[0];
-                    viewUp[1] += position[1];
-                    viewUp[2] += position[2];
-                    gl_matrix_esm/* vec3.transformMat4 */.eR.transformMat4(focalPoint, focalPoint, matrix);
-                    gl_matrix_esm/* vec3.transformMat4 */.eR.transformMat4(position, position, matrix);
-                    gl_matrix_esm/* vec3.transformMat4 */.eR.transformMat4(viewUp, viewUp, matrix);
-                    viewUp[0] -= position[0];
-                    viewUp[1] -= position[1];
-                    viewUp[2] -= position[2];
-                    otherViewport.setCamera({
-                        position,
-                        viewUp,
-                        focalPoint,
+                const previousIgnoreFiredEvents = this._ignoreFiredEvents;
+                this._ignoreFiredEvents = true;
+                try {
+                    viewportsAnnotationsToUpdate.forEach((annotation) => {
+                        const { data } = annotation;
+                        data.handles.toolCenter = center;
+                        const otherViewport = renderingEngine.getViewport(data.viewportId);
+                        const camera = otherViewport.getCamera();
+                        const { viewUp, position, focalPoint } = camera;
+                        viewUp[0] += position[0];
+                        viewUp[1] += position[1];
+                        viewUp[2] += position[2];
+                        gl_matrix_esm/* vec3.transformMat4 */.eR.transformMat4(focalPoint, focalPoint, matrix);
+                        gl_matrix_esm/* vec3.transformMat4 */.eR.transformMat4(position, position, matrix);
+                        gl_matrix_esm/* vec3.transformMat4 */.eR.transformMat4(viewUp, viewUp, matrix);
+                        viewUp[0] -= position[0];
+                        viewUp[1] -= position[1];
+                        viewUp[2] -= position[2];
+                        otherViewport.setCamera({
+                            position,
+                            viewUp,
+                            focalPoint,
+                        });
+                        otherViewportsIds.push(otherViewport.id);
                     });
-                    otherViewportsIds.push(otherViewport.id);
-                });
+                }
+                finally {
+                    this._ignoreFiredEvents = previousIgnoreFiredEvents;
+                }
                 renderingEngine.renderViewports(otherViewportsIds);
+                this._recomputeToolCenterFromAbsoluteCameras({
+                    emitEvent: true,
+                    updateViewportCameras: false,
+                });
             }
             else if (handles.activeOperation === CrosshairsTool_OPERATION.SLAB) {
                 const otherViewportAnnotations = this._getAnnotationsForViewportsWithDifferentCameras(enabledElement, annotations);
@@ -15551,7 +15583,14 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
                     }
                 });
                 renderingEngine.renderViewports(viewportsIds);
+                this._recomputeToolCenterFromAbsoluteCameras({
+                    emitEvent: true,
+                    updateViewportCameras: false,
+                });
             }
+            const requireSameOrientation = false;
+            const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName(), requireSameOrientation);
+            (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
         };
         this._pointNearReferenceLine = (annotation, canvasCoords, proximity, lineViewport) => {
             const { data } = annotation;
@@ -15594,6 +15633,170 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             }
             return false;
         };
+        this._toViewportKey = (renderingEngineId, viewportId) => {
+            return `${renderingEngineId}::${viewportId}`;
+        };
+        this._isFinitePoint3 = (point) => {
+            if (!point || point.length !== 3) {
+                return false;
+            }
+            return (Number.isFinite(point[0]) &&
+                Number.isFinite(point[1]) &&
+                Number.isFinite(point[2]));
+        };
+        this._bindToolGroupViewportListeners = () => {
+            if (!this._toolGroupViewportAddedListener) {
+                this._toolGroupViewportAddedListener = ((evt) => {
+                    if (evt.detail?.toolGroupId !== this.toolGroupId) {
+                        return;
+                    }
+                    this._syncVolumeListenersWithToolGroup();
+                    this._computeToolCenter(this._getViewportsInfo());
+                });
+                esm.eventTarget.addEventListener(enums.Events.TOOLGROUP_VIEWPORT_ADDED, this._toolGroupViewportAddedListener);
+            }
+            if (!this._toolGroupViewportRemovedListener) {
+                this._toolGroupViewportRemovedListener = ((evt) => {
+                    if (evt.detail?.toolGroupId !== this.toolGroupId) {
+                        return;
+                    }
+                    this._syncVolumeListenersWithToolGroup();
+                    this._recomputeToolCenterFromAbsoluteCameras({
+                        emitEvent: true,
+                        updateViewportCameras: false,
+                    });
+                });
+                esm.eventTarget.addEventListener(enums.Events.TOOLGROUP_VIEWPORT_REMOVED, this._toolGroupViewportRemovedListener);
+            }
+        };
+        this._unbindToolGroupViewportListeners = () => {
+            if (this._toolGroupViewportAddedListener) {
+                esm.eventTarget.removeEventListener(enums.Events.TOOLGROUP_VIEWPORT_ADDED, this._toolGroupViewportAddedListener);
+                this._toolGroupViewportAddedListener = null;
+            }
+            if (this._toolGroupViewportRemovedListener) {
+                esm.eventTarget.removeEventListener(enums.Events.TOOLGROUP_VIEWPORT_REMOVED, this._toolGroupViewportRemovedListener);
+                this._toolGroupViewportRemovedListener = null;
+            }
+        };
+        this._syncVolumeListenersWithToolGroup = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            const activeViewportKeys = new Set();
+            viewportsInfo.forEach((viewportInfo) => {
+                const { viewportId, renderingEngineId } = viewportInfo;
+                const viewportKey = this._toViewportKey(renderingEngineId, viewportId);
+                activeViewportKeys.add(viewportKey);
+                const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+                const existingListenerInfo = this._volumeViewportNewVolumeListeners.get(viewportKey);
+                if (!enabledElement) {
+                    if (existingListenerInfo) {
+                        existingListenerInfo.element.removeEventListener(esm.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, existingListenerInfo.handler);
+                        this._volumeViewportNewVolumeListeners.delete(viewportKey);
+                    }
+                    return;
+                }
+                const { viewport } = enabledElement;
+                const { element } = viewport;
+                if (existingListenerInfo && existingListenerInfo.element !== element) {
+                    existingListenerInfo.element.removeEventListener(esm.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, existingListenerInfo.handler);
+                    this._volumeViewportNewVolumeListeners.delete(viewportKey);
+                }
+                if (this._volumeViewportNewVolumeListeners.has(viewportKey)) {
+                    return;
+                }
+                const handler = ((evt) => this._onNewVolume(evt));
+                element.addEventListener(esm.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, handler);
+                this._volumeViewportNewVolumeListeners.set(viewportKey, {
+                    element,
+                    handler,
+                });
+            });
+            Array.from(this._volumeViewportNewVolumeListeners.entries()).forEach(([viewportKey, listenerInfo]) => {
+                if (activeViewportKeys.has(viewportKey)) {
+                    return;
+                }
+                listenerInfo.element.removeEventListener(esm.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, listenerInfo.handler);
+                this._volumeViewportNewVolumeListeners.delete(viewportKey);
+            });
+        };
+        this._clearAllVolumeListenersAndViewportState = () => {
+            this._volumeViewportNewVolumeListeners.forEach((listenerInfo) => {
+                listenerInfo.element.removeEventListener(esm.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, listenerInfo.handler);
+            });
+            this._volumeViewportNewVolumeListeners.clear();
+        };
+        this._calculateToolCenterFromAbsoluteCameras = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            const uniquePlanes = [];
+            viewportsInfo.forEach((viewportInfo) => {
+                const enabledElement = (0,esm.getEnabledElementByIds)(viewportInfo.viewportId, viewportInfo.renderingEngineId);
+                if (!enabledElement) {
+                    return;
+                }
+                const camera = enabledElement.viewport.getCamera();
+                const normal = [...camera.viewPlaneNormal];
+                const point = [...camera.focalPoint];
+                if (!this._isFinitePoint3(normal) || !this._isFinitePoint3(point)) {
+                    return;
+                }
+                gl_matrix_esm/* vec3.normalize */.eR.normalize(normal, normal);
+                const alreadyTracked = uniquePlanes.some((plane) => esm.utilities.isEqual(plane.normal, normal, 1e-3) ||
+                    esm.utilities.isOpposite(plane.normal, normal, 1e-3));
+                if (!alreadyTracked) {
+                    uniquePlanes.push({ normal, point });
+                }
+            });
+            if (uniquePlanes.length < 2) {
+                return null;
+            }
+            const firstPlane = esm.utilities.planar.planeEquation(uniquePlanes[0].normal, uniquePlanes[0].point);
+            const secondPlane = esm.utilities.planar.planeEquation(uniquePlanes[1].normal, uniquePlanes[1].point);
+            let thirdPlane;
+            if (uniquePlanes.length >= 3) {
+                thirdPlane = esm.utilities.planar.planeEquation(uniquePlanes[2].normal, uniquePlanes[2].point);
+            }
+            else {
+                const thirdNormal = gl_matrix_esm/* vec3.create */.eR.create();
+                gl_matrix_esm/* vec3.cross */.eR.cross(thirdNormal, uniquePlanes[0].normal, uniquePlanes[1].normal);
+                if (gl_matrix_esm/* vec3.length */.eR.length(thirdNormal) < 1e-6) {
+                    return null;
+                }
+                gl_matrix_esm/* vec3.normalize */.eR.normalize(thirdNormal, thirdNormal);
+                const thirdPoint = this._isFinitePoint3(this.toolCenter)
+                    ? [...this.toolCenter]
+                    : [
+                        (uniquePlanes[0].point[0] + uniquePlanes[1].point[0]) * 0.5,
+                        (uniquePlanes[0].point[1] + uniquePlanes[1].point[1]) * 0.5,
+                        (uniquePlanes[0].point[2] + uniquePlanes[1].point[2]) * 0.5,
+                    ];
+                thirdPlane = esm.utilities.planar.planeEquation(thirdNormal, thirdPoint);
+            }
+            const center = esm.utilities.planar.threePlaneIntersection(firstPlane, secondPlane, thirdPlane);
+            return this._isFinitePoint3(center) ? center : null;
+        };
+        this._recomputeToolCenterFromAbsoluteCameras = ({ emitEvent = true, updateViewportCameras = false, } = {}) => {
+            const toolCenter = this._calculateToolCenterFromAbsoluteCameras();
+            if (!toolCenter) {
+                return null;
+            }
+            const hasChanged = !esm.utilities.isEqual(this.toolCenter, toolCenter, 1e-3);
+            if (!hasChanged) {
+                return toolCenter;
+            }
+            if (updateViewportCameras) {
+                this.setToolCenter(toolCenter, !emitEvent);
+            }
+            else {
+                this.toolCenter = toolCenter;
+                if (emitEvent) {
+                    (0,esm.triggerEvent)(esm.eventTarget, enums.Events.CROSSHAIR_TOOL_CENTER_CHANGED, {
+                        toolGroupId: this.toolGroupId,
+                        toolCenter: this.toolCenter,
+                    });
+                }
+            }
+            return toolCenter;
+        };
         this._getReferenceLineColor =
             toolProps.configuration?.getReferenceLineColor ||
                 CrosshairsTool_defaultReferenceLineColor;
@@ -15608,22 +15811,21 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
                 defaultReferenceLineSlabThicknessControlsOn;
     }
     onSetToolActive() {
-        const viewportsInfo = this._getViewportsInfo();
-        this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
-        this._subscribeToViewportNewVolumeSet(viewportsInfo);
-        this._computeToolCenter(viewportsInfo);
+        this._reinitializeListenersAndCenter();
     }
     onSetToolPassive() {
-        const viewportsInfo = this._getViewportsInfo();
-        this._computeToolCenter(viewportsInfo);
+        this._reinitializeListenersAndCenter();
     }
     onSetToolEnabled() {
-        const viewportsInfo = this._getViewportsInfo();
-        this._computeToolCenter(viewportsInfo);
+        this._reinitializeListenersAndCenter();
     }
     onSetToolDisabled() {
         const viewportsInfo = this._getViewportsInfo();
-        this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
+        this._unbindToolGroupViewportListeners();
+        this._clearAllVolumeListenersAndViewportState();
+        this._ignoreFiredEvents = false;
+        this.editData = null;
+        state/* state */.wk.isInteractingWithTool = false;
         viewportsInfo.forEach(({ renderingEngineId, viewportId }) => {
             const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
             if (!enabledElement) {
@@ -15639,40 +15841,53 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
     }
     setToolCenter(toolCenter, suppressEvents = false) {
         const viewportsInfo = this._getViewportsInfo();
-        viewportsInfo.map(({ renderingEngineId, viewportId }) => {
-            const renderingEngine = (0,esm.getRenderingEngine)(renderingEngineId);
-            const viewport = renderingEngine.getViewport(viewportId);
-            const camera = viewport.getCamera();
-            const { focalPoint, position, viewPlaneNormal } = camera;
-            const delta = [
-                toolCenter[0] - focalPoint[0],
-                toolCenter[1] - focalPoint[1],
-                toolCenter[2] - focalPoint[2],
-            ];
-            const scroll = delta[0] * viewPlaneNormal[0] +
-                delta[1] * viewPlaneNormal[1] +
-                delta[2] * viewPlaneNormal[2];
-            const scrollDelta = [
-                scroll * viewPlaneNormal[0],
-                scroll * viewPlaneNormal[1],
-                scroll * viewPlaneNormal[2],
-            ];
-            const newFocalPoint = [
-                focalPoint[0] + scrollDelta[0],
-                focalPoint[1] + scrollDelta[1],
-                focalPoint[2] + scrollDelta[2],
-            ];
-            const newPosition = [
-                position[0] + scrollDelta[0],
-                position[1] + scrollDelta[1],
-                position[2] + scrollDelta[2],
-            ];
-            viewport.setCamera({
-                focalPoint: newFocalPoint,
-                position: newPosition,
+        const previousIgnoreFiredEvents = this._ignoreFiredEvents;
+        this._ignoreFiredEvents = true;
+        try {
+            viewportsInfo.forEach(({ renderingEngineId, viewportId }) => {
+                const renderingEngine = (0,esm.getRenderingEngine)(renderingEngineId);
+                if (!renderingEngine) {
+                    return;
+                }
+                const viewport = renderingEngine.getViewport(viewportId);
+                if (!viewport) {
+                    return;
+                }
+                const camera = viewport.getCamera();
+                const { focalPoint, position, viewPlaneNormal } = camera;
+                const delta = [
+                    toolCenter[0] - focalPoint[0],
+                    toolCenter[1] - focalPoint[1],
+                    toolCenter[2] - focalPoint[2],
+                ];
+                const scroll = delta[0] * viewPlaneNormal[0] +
+                    delta[1] * viewPlaneNormal[1] +
+                    delta[2] * viewPlaneNormal[2];
+                const scrollDelta = [
+                    scroll * viewPlaneNormal[0],
+                    scroll * viewPlaneNormal[1],
+                    scroll * viewPlaneNormal[2],
+                ];
+                const newFocalPoint = [
+                    focalPoint[0] + scrollDelta[0],
+                    focalPoint[1] + scrollDelta[1],
+                    focalPoint[2] + scrollDelta[2],
+                ];
+                const newPosition = [
+                    position[0] + scrollDelta[0],
+                    position[1] + scrollDelta[1],
+                    position[2] + scrollDelta[2],
+                ];
+                viewport.setCamera({
+                    focalPoint: newFocalPoint,
+                    position: newPosition,
+                });
+                viewport.render();
             });
-            viewport.render();
-        });
+        }
+        finally {
+            this._ignoreFiredEvents = previousIgnoreFiredEvents;
+        }
         this.toolCenter = toolCenter;
         if (!suppressEvents) {
             (0,esm.triggerEvent)(esm.eventTarget, enums.Events.CROSSHAIR_TOOL_CENTER_CHANGED, {
@@ -15693,19 +15908,11 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             return point;
         }
     }
-    _unsubscribeToViewportNewVolumeSet(viewportsInfo) {
-        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-            const { viewport } = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
-            const { element } = viewport;
-            element.removeEventListener(esm.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
-        });
+    _unsubscribeToViewportNewVolumeSet(_viewportsInfo) {
+        this._syncVolumeListenersWithToolGroup();
     }
-    _subscribeToViewportNewVolumeSet(viewports) {
-        viewports.forEach(({ viewportId, renderingEngineId }) => {
-            const { viewport } = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
-            const { element } = viewport;
-            element.addEventListener(esm.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
-        });
+    _subscribeToViewportNewVolumeSet(_viewports) {
+        this._syncVolumeListenersWithToolGroup();
     }
     _autoPanViewportIfNecessary(viewportId, renderingEngine) {
         const viewport = renderingEngine.getViewport(viewportId);
@@ -15750,10 +15957,17 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             focalPoint[1] - deltaPointsWorld[1],
             focalPoint[2] - deltaPointsWorld[2],
         ];
-        viewport.setCamera({
-            focalPoint: updatedFocalPoint,
-            position: updatedPosition,
-        });
+        const previousIgnoreFiredEvents = this._ignoreFiredEvents;
+        this._ignoreFiredEvents = true;
+        try {
+            viewport.setCamera({
+                focalPoint: updatedFocalPoint,
+                position: updatedPosition,
+            });
+        }
+        finally {
+            this._ignoreFiredEvents = previousIgnoreFiredEvents;
+        }
         viewport.render();
     }
     setSlabThickness(viewport, slabThickness) {
@@ -15794,10 +16008,17 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             const newPosition = [0, 0, 0];
             Core_Math/* default.add */.Ay.add(camera.focalPoint, projectedDelta, newFocalPoint);
             Core_Math/* default.add */.Ay.add(camera.position, projectedDelta, newPosition);
-            viewport.setCamera({
-                focalPoint: newFocalPoint,
-                position: newPosition,
-            });
+            const previousIgnoreFiredEvents = this._ignoreFiredEvents;
+            this._ignoreFiredEvents = true;
+            try {
+                viewport.setCamera({
+                    focalPoint: newFocalPoint,
+                    position: newPosition,
+                });
+            }
+            finally {
+                this._ignoreFiredEvents = previousIgnoreFiredEvents;
+            }
             viewport.render();
         }
     }
@@ -20383,31 +20604,40 @@ class ProbeTool extends base/* AnnotationTool */.EC {
                 continue;
             }
             const { dimensions, imageData, metadata, voxelManager } = image;
-            const modality = metadata.Modality;
+            const modality = metadata?.Modality;
             let ijk = ProbeTool_transformWorldToIndex(imageData, worldPos);
             ijk = gl_matrix_esm/* vec3.round */.eR.round(ijk, ijk);
             if (esm.utilities.indexWithinDimensions(ijk, dimensions)) {
                 this.isHandleOutsideImage = false;
-                let value = voxelManager.getAtIJKPoint(ijk);
-                if (targetId.startsWith('imageId:')) {
+                if (targetId.startsWith('imageId:') && modality !== 'ECG') {
                     const imageId = targetId.split('imageId:')[1];
                     const imageURI = esm.utilities.imageIdToURI(imageId);
                     const viewports = esm.utilities.getViewportsWithImageURI(imageURI);
                     const viewport = viewports[0];
                     ijk[2] = viewport.getCurrentImageIdIndex();
                 }
+                let value;
                 let modalityUnit;
-                if (modality === 'US') {
+                if (modality === 'ECG') {
+                    const calibratedResults = (0,getCalibratedUnits/* getCalibratedProbeUnitsAndValue */.Xw)(image, [
+                        ijk,
+                    ]);
+                    value = calibratedResults.values;
+                    modalityUnit = calibratedResults.units;
+                }
+                else if (modality === 'US') {
+                    value = voxelManager?.getAtIJKPoint(ijk);
                     const calibratedResults = (0,getCalibratedUnits/* getCalibratedProbeUnitsAndValue */.Xw)(image, [
                         ijk,
                     ]);
-                    const hasEnhancedRegionValues = calibratedResults.values.every((value) => value !== null);
+                    const hasEnhancedRegionValues = calibratedResults.values.every((v) => v !== null);
                     value = (hasEnhancedRegionValues ? calibratedResults.values : value);
                     modalityUnit = hasEnhancedRegionValues
                         ? calibratedResults.units
                         : 'raw';
                 }
                 else {
+                    value = voxelManager?.getAtIJKPoint(ijk);
                     modalityUnit = (0,getPixelValueUnits/* getPixelValueUnits */.j)(modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 }
                 cachedStats[targetId] = {
@@ -25551,8 +25781,9 @@ class UltrasoundDirectionalTool extends base/* AnnotationTool */.EC {
             const worldPos = currentPoints.world;
             const enabledElement = (0,esm.getEnabledElement)(element);
             const { viewport } = enabledElement;
-            if (!(viewport instanceof esm.StackViewport)) {
-                throw new Error('UltrasoundDirectionalTool can only be used on a StackViewport');
+            if (!(viewport instanceof esm.StackViewport) &&
+                !(viewport instanceof esm.ECGViewport)) {
+                throw new Error('UltrasoundDirectionalTool can only be used on a StackViewport or ECGViewport');
             }
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
@@ -39419,6 +39650,7 @@ const SUPPORTED_REGION_DATA_TYPES = [
 const SUPPORTED_PROBE_VARIANT = [
     '4,3',
     '4,7',
+    '4,-1',
 ];
 const UNIT_MAPPING = {
     0: 'px',
@@ -39432,6 +39664,7 @@ const UNIT_MAPPING = {
     8: 'cm\xb2',
     9: 'cm\xb2/s',
     0xc: 'degrees',
+    [-1]: 'mV',
 };
 const EPS = 1e-3;
 const SQUARE = '\xb2';
@@ -39474,7 +39707,9 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
         const region = calibration.sequenceOfUltrasoundRegions.find((region) => handles.every((handle) => handle[0] >= region.regionLocationMinX0 &&
             handle[0] <= region.regionLocationMaxX1 &&
             handle[1] >= region.regionLocationMinY0 &&
-            handle[1] <= region.regionLocationMaxY1) && SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType));
+            handle[1] <= region.regionLocationMaxY1) &&
+            (SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) ||
+                SUPPORTED_PROBE_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`)));
         if (region &&
             region.physicalUnitsXDirection === region.physicalUnitsYDirection) {
             const physicalDeltaX = Math.abs(region.physicalDeltaX);
@@ -39485,6 +39720,19 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
             unit = UNIT_MAPPING[region.physicalUnitsXDirection] || 'unknown';
             areaUnit = unit + SQUARE;
         }
+        else if (region && region.physicalUnitsYDirection === -1) {
+            const physicalDeltaX = Math.abs(region.physicalDeltaX);
+            const physicalDeltaY = Math.abs(region.physicalDeltaY);
+            scale = 1 / physicalDeltaX;
+            scaleY = 1 / physicalDeltaY;
+            calibrationType = 'ECG Region';
+            unit =
+                UNIT_MAPPING[region.physicalUnitsXDirection] ||
+                    UNIT_MAPPING[region.physicalUnitsYDirection] ||
+                    'unknown';
+            areaUnit =
+                (UNIT_MAPPING[region.physicalUnitsYDirection] || 'px') + SQUARE;
+        }
     }
     else if (calibration.scale) {
         scale = calibration.scale;
@@ -39509,7 +39757,8 @@ const getCalibratedProbeUnitsAndValue = (image, handles) => {
         return { units, values };
     }
     if (calibration.sequenceOfUltrasoundRegions) {
-        const supportedRegionsMetadata = calibration.sequenceOfUltrasoundRegions.filter((region) => SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) &&
+        const supportedRegionsMetadata = calibration.sequenceOfUltrasoundRegions.filter((region) => (SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) ||
+            SUPPORTED_PROBE_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`)) &&
             SUPPORTED_PROBE_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`));
         if (!supportedRegionsMetadata?.length) {
             return { units, values };
@@ -39527,11 +39776,12 @@ const getCalibratedProbeUnitsAndValue = (image, handles) => {
             physicalDeltaY;
         const xValue = (imageIndex[0] - region.regionLocationMinX0 - referencePixelX0) *
             physicalDeltaX;
-        calibrationType = 'US Region';
+        calibrationType =
+            region.physicalUnitsYDirection === -1 ? 'ECG Region' : 'US Region';
         values = [xValue, yValue];
         units = [
-            UNIT_MAPPING[region.physicalUnitsXDirection],
-            UNIT_MAPPING[region.physicalUnitsYDirection],
+            UNIT_MAPPING[region.physicalUnitsXDirection] ?? 'unknown',
+            UNIT_MAPPING[region.physicalUnitsYDirection] ?? 'unknown',
         ];
     }
     return {