@cornerstonejs/tools 4.17.4 → 4.18.0

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

@@ -21,12 +21,20 @@ declare class CrosshairsTool extends AnnotationTool {
     _getReferenceLineControllable?: (viewportId: string) => boolean;
     _getReferenceLineDraggableRotatable?: (viewportId: string) => boolean;
     _getReferenceLineSlabThicknessControlsOn?: (viewportId: string) => boolean;
+    _volumeViewportNewVolumeListeners: Map<string, {
+        element: HTMLDivElement;
+        handler: EventListener;
+    }>;
+    _toolGroupViewportAddedListener: EventListener | null;
+    _toolGroupViewportRemovedListener: EventListener | null;
+    _ignoreFiredEvents: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     initializeViewport: ({ renderingEngineId, viewportId, }: Types.IViewportId) => {
         normal: Types.Point3;
         point: Types.Point3;
     };
     _getViewportsInfo: () => any[];
+    _reinitializeListenersAndCenter: () => void;
     onSetToolActive(): void;
     onSetToolPassive(): void;
     onSetToolEnabled(): void;
@@ -47,9 +55,9 @@ declare class CrosshairsTool extends AnnotationTool {
     filterInteractableAnnotationsForElement: (element: any, annotations: any) => any;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     _getAnnotations: (enabledElement: Types.IEnabledElement) => Annotation[];
-    _onNewVolume: () => void;
-    _unsubscribeToViewportNewVolumeSet(viewportsInfo: any): void;
-    _subscribeToViewportNewVolumeSet(viewports: any): void;
+    _onNewVolume: (_evt?: Event) => void;
+    _unsubscribeToViewportNewVolumeSet(_viewportsInfo: any): void;
+    _subscribeToViewportNewVolumeSet(_viewports: any): void;
     _autoPanViewportIfNecessary(viewportId: string, renderingEngine: Types.IRenderingEngine): void;
     _areViewportIdArraysEqual: (viewportIdArrayOne: any, viewportIdArrayTwo: any) => boolean;
     _getAnnotationsForViewportsWithDifferentCameras: (enabledElement: any, annotations: any) => any;
@@ -69,5 +77,16 @@ declare class CrosshairsTool extends AnnotationTool {
     _getRotationHandleNearImagePoint(viewport: any, annotation: any, canvasCoords: any, proximity: any): any;
     _getSlabThicknessHandleNearImagePoint(viewport: any, annotation: any, canvasCoords: any, proximity: any): any;
     _pointNearTool(element: any, annotation: any, canvasCoords: any, proximity: any): boolean;
+    _toViewportKey: (renderingEngineId: string, viewportId: string) => string;
+    _isFinitePoint3: (point: Types.Point3) => boolean;
+    _bindToolGroupViewportListeners: () => void;
+    _unbindToolGroupViewportListeners: () => void;
+    _syncVolumeListenersWithToolGroup: () => void;
+    _clearAllVolumeListenersAndViewportState: () => void;
+    _calculateToolCenterFromAbsoluteCameras: () => Types.Point3 | null;
+    _recomputeToolCenterFromAbsoluteCameras: ({ emitEvent, updateViewportCameras, }?: {
+        emitEvent?: boolean;
+        updateViewportCameras?: boolean;
+    }) => Types.Point3 | null;
 }
 export default CrosshairsTool;

package/dist/esm/tools/CrosshairsTool.js

@@ -69,6 +69,10 @@ class CrosshairsTool extends AnnotationTool {
     }) {
         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 = getEnabledElementByIds(viewportId, renderingEngineId);
             if (!enabledElement) {
@@ -114,11 +118,21 @@ class CrosshairsTool extends AnnotationTool {
             const viewports = 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 = getEnabledElementByIds(viewportId, renderingEngineId);
+                if (!enabledElement) {
+                    continue;
+                }
                 const viewport = enabledElement.viewport;
                 const resetPan = true;
                 const resetZoom = true;
@@ -152,31 +166,24 @@ class CrosshairsTool extends AnnotationTool {
                 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 = vec3.create();
-            if (thirdViewport) {
-                ({ normal: normal3, point: point3 } =
-                    this.initializeViewport(thirdViewport));
-            }
-            else {
-                vec3.add(point3, point1, point2);
-                vec3.scale(point3, point3, 0.5);
-                vec3.cross(normal3, normal1, normal2);
-            }
-            const firstPlane = csUtils.planar.planeEquation(normal1, point1);
-            const secondPlane = csUtils.planar.planeEquation(normal2, point2);
-            const thirdPlane = csUtils.planar.planeEquation(normal3, point3);
-            const toolCenter = csUtils.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 = getEnabledElement(element);
             const { viewport } = enabledElement;
             this._jump(enabledElement, jumpWorld);
@@ -231,46 +238,33 @@ class CrosshairsTool extends AnnotationTool {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             const enabledElement = 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];
-            vtkMath.subtract(currentCamera.position, oldCameraPosition, deltaCameraPosition);
-            const oldCameraFocalPoint = viewportAnnotation.metadata.cameraFocalPoint;
-            const deltaCameraFocalPoint = [0, 0, 0];
-            vtkMath.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 (!csUtils.isEqual(currentCamera.position, oldCameraPosition, 1e-3) &&
-                viewportControllable &&
-                viewportDraggableRotatable) {
-                let isRotation = false;
-                const cameraModifiedSameForPosAndFocalPoint = csUtils.isEqual(deltaCameraPosition, deltaCameraFocalPoint, 1e-3);
-                if (!cameraModifiedSameForPosAndFocalPoint) {
-                    isRotation = true;
-                }
-                const cameraModifiedInPlane = Math.abs(vtkMath.dot(deltaCameraPosition, currentCamera.viewPlaneNormal)) < 1e-2;
-                if (!isRotation && !cameraModifiedInPlane) {
-                    this.toolCenter[0] += deltaCameraPosition[0];
-                    this.toolCenter[1] += deltaCameraPosition[1];
-                    this.toolCenter[2] += deltaCameraPosition[2];
-                    triggerEvent(eventTarget, 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 = getToolGroupForViewport(viewport.id, renderingEngine.id);
                 const otherViewportIds = toolGroup
@@ -708,15 +702,19 @@ class CrosshairsTool extends AnnotationTool {
             });
             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]) {
@@ -727,7 +725,7 @@ class CrosshairsTool extends AnnotationTool {
                 if (itemFound === false) {
                     return false;
                 }
-            });
+            }
             return true;
         };
         this._getAnnotationsForViewportsWithDifferentCameras = (enabledElement, annotations) => {
@@ -903,10 +901,19 @@ class CrosshairsTool extends AnnotationTool {
                 return false;
             }
             this._applyDeltaShiftToSelectedViewportCameras(renderingEngine, viewportsAnnotationsToUpdate, delta);
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: true,
+                updateViewportCameras: false,
+            });
             state.isInteractingWithTool = false;
             return true;
         };
         this._activateModify = (element) => {
+            this._syncVolumeListenersWithToolGroup();
+            this._recomputeToolCenterFromAbsoluteCameras({
+                emitEvent: false,
+                updateViewportCameras: false,
+            });
             state.isInteractingWithTool = !this.configuration.mobile?.enabled;
             element.addEventListener(Events.MOUSE_UP, this._endCallback);
             element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
@@ -927,9 +934,15 @@ class CrosshairsTool extends AnnotationTool {
         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,
+            });
             resetElementCursor(element);
             this.editData = null;
             const requireSameOrientation = false;
@@ -968,6 +981,10 @@ class CrosshairsTool extends AnnotationTool {
                         viewportAnnotation.data.activeViewportIds.find((id) => id === otherViewport.id));
                 });
                 this._applyDeltaShiftToSelectedViewportCameras(renderingEngine, viewportsAnnotationsToUpdate, delta);
+                this._recomputeToolCenterFromAbsoluteCameras({
+                    emitEvent: true,
+                    updateViewportCameras: false,
+                });
             }
             else if (handles.activeOperation === OPERATION.ROTATE) {
                 const otherViewportAnnotations = this._getAnnotationsForViewportsWithDifferentCameras(enabledElement, annotations);
@@ -1004,29 +1021,40 @@ class CrosshairsTool extends AnnotationTool {
                     .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];
-                    vec3.transformMat4(focalPoint, focalPoint, matrix);
-                    vec3.transformMat4(position, position, matrix);
-                    vec3.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];
+                        vec3.transformMat4(focalPoint, focalPoint, matrix);
+                        vec3.transformMat4(position, position, matrix);
+                        vec3.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 === OPERATION.SLAB) {
                 const otherViewportAnnotations = this._getAnnotationsForViewportsWithDifferentCameras(enabledElement, annotations);
@@ -1113,7 +1141,14 @@ class CrosshairsTool extends AnnotationTool {
                     }
                 });
                 renderingEngine.renderViewports(viewportsIds);
+                this._recomputeToolCenterFromAbsoluteCameras({
+                    emitEvent: true,
+                    updateViewportCameras: false,
+                });
             }
+            const requireSameOrientation = false;
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), requireSameOrientation);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._pointNearReferenceLine = (annotation, canvasCoords, proximity, lineViewport) => {
             const { data } = annotation;
@@ -1156,6 +1191,170 @@ class CrosshairsTool extends AnnotationTool {
             }
             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());
+                });
+                eventTarget.addEventListener(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,
+                    });
+                });
+                eventTarget.addEventListener(Events.TOOLGROUP_VIEWPORT_REMOVED, this._toolGroupViewportRemovedListener);
+            }
+        };
+        this._unbindToolGroupViewportListeners = () => {
+            if (this._toolGroupViewportAddedListener) {
+                eventTarget.removeEventListener(Events.TOOLGROUP_VIEWPORT_ADDED, this._toolGroupViewportAddedListener);
+                this._toolGroupViewportAddedListener = null;
+            }
+            if (this._toolGroupViewportRemovedListener) {
+                eventTarget.removeEventListener(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 = getEnabledElementByIds(viewportId, renderingEngineId);
+                const existingListenerInfo = this._volumeViewportNewVolumeListeners.get(viewportKey);
+                if (!enabledElement) {
+                    if (existingListenerInfo) {
+                        existingListenerInfo.element.removeEventListener(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(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(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(Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, listenerInfo.handler);
+                this._volumeViewportNewVolumeListeners.delete(viewportKey);
+            });
+        };
+        this._clearAllVolumeListenersAndViewportState = () => {
+            this._volumeViewportNewVolumeListeners.forEach((listenerInfo) => {
+                listenerInfo.element.removeEventListener(Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, listenerInfo.handler);
+            });
+            this._volumeViewportNewVolumeListeners.clear();
+        };
+        this._calculateToolCenterFromAbsoluteCameras = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            const uniquePlanes = [];
+            viewportsInfo.forEach((viewportInfo) => {
+                const enabledElement = 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;
+                }
+                vec3.normalize(normal, normal);
+                const alreadyTracked = uniquePlanes.some((plane) => csUtils.isEqual(plane.normal, normal, 1e-3) ||
+                    csUtils.isOpposite(plane.normal, normal, 1e-3));
+                if (!alreadyTracked) {
+                    uniquePlanes.push({ normal, point });
+                }
+            });
+            if (uniquePlanes.length < 2) {
+                return null;
+            }
+            const firstPlane = csUtils.planar.planeEquation(uniquePlanes[0].normal, uniquePlanes[0].point);
+            const secondPlane = csUtils.planar.planeEquation(uniquePlanes[1].normal, uniquePlanes[1].point);
+            let thirdPlane;
+            if (uniquePlanes.length >= 3) {
+                thirdPlane = csUtils.planar.planeEquation(uniquePlanes[2].normal, uniquePlanes[2].point);
+            }
+            else {
+                const thirdNormal = vec3.create();
+                vec3.cross(thirdNormal, uniquePlanes[0].normal, uniquePlanes[1].normal);
+                if (vec3.length(thirdNormal) < 1e-6) {
+                    return null;
+                }
+                vec3.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 = csUtils.planar.planeEquation(thirdNormal, thirdPoint);
+            }
+            const center = csUtils.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 = !csUtils.isEqual(this.toolCenter, toolCenter, 1e-3);
+            if (!hasChanged) {
+                return toolCenter;
+            }
+            if (updateViewportCameras) {
+                this.setToolCenter(toolCenter, !emitEvent);
+            }
+            else {
+                this.toolCenter = toolCenter;
+                if (emitEvent) {
+                    triggerEvent(eventTarget, Events.CROSSHAIR_TOOL_CENTER_CHANGED, {
+                        toolGroupId: this.toolGroupId,
+                        toolCenter: this.toolCenter,
+                    });
+                }
+            }
+            return toolCenter;
+        };
         this._getReferenceLineColor =
             toolProps.configuration?.getReferenceLineColor ||
                 defaultReferenceLineColor;
@@ -1170,22 +1369,21 @@ class CrosshairsTool extends AnnotationTool {
                 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.isInteractingWithTool = false;
         viewportsInfo.forEach(({ renderingEngineId, viewportId }) => {
             const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
             if (!enabledElement) {
@@ -1201,40 +1399,53 @@ class CrosshairsTool extends AnnotationTool {
     }
     setToolCenter(toolCenter, suppressEvents = false) {
         const viewportsInfo = this._getViewportsInfo();
-        viewportsInfo.map(({ renderingEngineId, viewportId }) => {
-            const renderingEngine = 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 = 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) {
             triggerEvent(eventTarget, Events.CROSSHAIR_TOOL_CENTER_CHANGED, {
@@ -1255,19 +1466,11 @@ class CrosshairsTool extends AnnotationTool {
             return point;
         }
     }
-    _unsubscribeToViewportNewVolumeSet(viewportsInfo) {
-        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-            const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-            const { element } = viewport;
-            element.removeEventListener(Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
-        });
+    _unsubscribeToViewportNewVolumeSet(_viewportsInfo) {
+        this._syncVolumeListenersWithToolGroup();
     }
-    _subscribeToViewportNewVolumeSet(viewports) {
-        viewports.forEach(({ viewportId, renderingEngineId }) => {
-            const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-            const { element } = viewport;
-            element.addEventListener(Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
-        });
+    _subscribeToViewportNewVolumeSet(_viewports) {
+        this._syncVolumeListenersWithToolGroup();
     }
     _autoPanViewportIfNecessary(viewportId, renderingEngine) {
         const viewport = renderingEngine.getViewport(viewportId);
@@ -1312,10 +1515,17 @@ class CrosshairsTool extends AnnotationTool {
             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) {
@@ -1356,10 +1566,17 @@ class CrosshairsTool extends AnnotationTool {
             const newPosition = [0, 0, 0];
             vtkMath.add(camera.focalPoint, projectedDelta, newFocalPoint);
             vtkMath.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();
         }
     }

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

@@ -298,31 +298,40 @@ class ProbeTool extends AnnotationTool {
                 continue;
             }
             const { dimensions, imageData, metadata, voxelManager } = image;
-            const modality = metadata.Modality;
+            const modality = metadata?.Modality;
             let ijk = transformWorldToIndex(imageData, worldPos);
             ijk = vec3.round(ijk, ijk);
             if (csUtils.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 = csUtils.imageIdToURI(imageId);
                     const viewports = csUtils.getViewportsWithImageURI(imageURI);
                     const viewport = viewports[0];
                     ijk[2] = viewport.getCurrentImageIdIndex();
                 }
+                let value;
                 let modalityUnit;
-                if (modality === 'US') {
+                if (modality === 'ECG') {
                     const calibratedResults = getCalibratedProbeUnitsAndValue(image, [
                         ijk,
                     ]);
-                    const hasEnhancedRegionValues = calibratedResults.values.every((value) => value !== null);
+                    value = calibratedResults.values;
+                    modalityUnit = calibratedResults.units;
+                }
+                else if (modality === 'US') {
+                    value = voxelManager?.getAtIJKPoint(ijk);
+                    const calibratedResults = getCalibratedProbeUnitsAndValue(image, [
+                        ijk,
+                    ]);
+                    const hasEnhancedRegionValues = calibratedResults.values.every((v) => v !== null);
                     value = (hasEnhancedRegionValues ? calibratedResults.values : value);
                     modalityUnit = hasEnhancedRegionValues
                         ? calibratedResults.units
                         : 'raw';
                 }
                 else {
+                    value = voxelManager?.getAtIJKPoint(ijk);
                     modalityUnit = getPixelValueUnits(modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 }
                 cachedStats[targetId] = {

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

@@ -1,5 +1,5 @@
 import { ChangeTypes, Events } from '../../enums';
-import { getEnabledElement, utilities as csUtils, StackViewport, } from '@cornerstonejs/core';
+import { getEnabledElement, utilities as csUtils, StackViewport, ECGViewport, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
@@ -35,8 +35,9 @@ class UltrasoundDirectionalTool extends AnnotationTool {
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
-            if (!(viewport instanceof StackViewport)) {
-                throw new Error('UltrasoundDirectionalTool can only be used on a StackViewport');
+            if (!(viewport instanceof StackViewport) &&
+                !(viewport instanceof ECGViewport)) {
+                throw new Error('UltrasoundDirectionalTool can only be used on a StackViewport or ECGViewport');
             }
             hideElementCursor(element);
             this.isDrawing = true;

package/dist/esm/utilities/getCalibratedUnits.js

@@ -11,6 +11,7 @@ const SUPPORTED_REGION_DATA_TYPES = [
 const SUPPORTED_PROBE_VARIANT = [
     '4,3',
     '4,7',
+    '4,-1',
 ];
 const UNIT_MAPPING = {
     0: 'px',
@@ -24,6 +25,7 @@ const UNIT_MAPPING = {
     8: 'cm\xb2',
     9: 'cm\xb2/s',
     0xc: 'degrees',
+    [-1]: 'mV',
 };
 const EPS = 1e-3;
 const SQUARE = '\xb2';
@@ -66,7 +68,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);
@@ -77,6 +81,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;
@@ -101,7 +118,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 };
@@ -119,11 +137,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 {

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.17.4";
+export declare const version = "4.18.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.17.4';
+export const version = '4.18.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.17.4",
+  "version": "4.18.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.17.4",
+    "@cornerstonejs/core": "4.18.0",
     "@kitware/vtk.js": "34.15.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "3664bf4622c54d790aa3684f42967448a1bddea3"
+  "gitHead": "7f4a99858ac39083fb1aeab650002ec7d33e3d58"
 }