@ohif/app 3.12.0-beta.105 → 3.12.0-beta.106

package/dist/{5549.bundle.d5def6a3124a3a481b7c.js → 5549.bundle.4d086f8682a317140e65.js}

@@ -2092,8 +2092,40 @@ function buildMetadata(image) {
 
 
 
+const DEFAULT_THICKNESS_SINGLE_SLICE = 1;
+function getPixelSpacingForCubicVoxel(metadata) {
+    if (metadata.columnPixelSpacing !== undefined) {
+        return metadata.columnPixelSpacing;
+    }
+    if (metadata.rowPixelSpacing !== undefined) {
+        return metadata.rowPixelSpacing;
+    }
+    if (metadata.pixelSpacing?.[1] !== undefined) {
+        return metadata.pixelSpacing[1];
+    }
+    if (metadata.pixelSpacing?.[0] !== undefined) {
+        return metadata.pixelSpacing[0];
+    }
+    return undefined;
+}
 function calculateSpacingBetweenImageIds(imageIds) {
     const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageIds[0]);
+    if (imageIds.length === 1) {
+        const { sliceThickness, spacingBetweenSlices, columnPixelSpacing, rowPixelSpacing, pixelSpacing, } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageIds[0]);
+        if (sliceThickness)
+            return sliceThickness;
+        if (spacingBetweenSlices)
+            return spacingBetweenSlices;
+        const pixelSpacingValue = getPixelSpacingForCubicVoxel({
+            columnPixelSpacing,
+            rowPixelSpacing,
+            pixelSpacing,
+        });
+        if (pixelSpacingValue !== undefined) {
+            return pixelSpacingValue;
+        }
+        return DEFAULT_THICKNESS_SINGLE_SLICE;
+    }
     const rowCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
     const colCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
     const scanAxisNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
@@ -2128,8 +2160,6 @@ function calculateSpacingBetweenImageIds(imageIds) {
             imageIds[0],
             imageIds[Math.floor(imageIds.length / 2)],
         ];
-        const firstImageDistance = getDistance(prefetchedImageIds[0]);
-        const middleImageDistance = getDistance(prefetchedImageIds[1]);
         const metadataForMiddleImage = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', prefetchedImageIds[1]);
         if (!metadataForMiddleImage) {
             throw new Error('Incomplete metadata required for volume construction.');
@@ -2142,7 +2172,7 @@ function calculateSpacingBetweenImageIds(imageIds) {
             Math.abs(distanceBetweenFirstAndMiddleImages) /
                 Math.floor(imageIds.length / 2);
     }
-    const { sliceThickness, spacingBetweenSlices } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageIds[0]);
+    const { sliceThickness, spacingBetweenSlices, columnPixelSpacing, rowPixelSpacing, pixelSpacing, } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('imagePlaneModule', imageIds[0]);
     const { strictZSpacingForVolumeViewport } = (0,_init__WEBPACK_IMPORTED_MODULE_2__/* .getConfiguration */ .D0)().rendering;
     if ((spacing === 0 || isNaN(spacing)) && !strictZSpacingForVolumeViewport) {
         if (spacingBetweenSlices) {
@@ -2154,8 +2184,18 @@ function calculateSpacingBetweenImageIds(imageIds) {
             spacing = sliceThickness;
         }
         else {
-            console.debug('Could not calculate spacing. The VolumeViewport visualization is compromised. Setting spacing to 1 to render');
-            spacing = 1;
+            const pixelSpacingValue = getPixelSpacingForCubicVoxel({
+                columnPixelSpacing,
+                rowPixelSpacing,
+                pixelSpacing,
+            });
+            if (pixelSpacingValue) {
+                spacing = pixelSpacingValue;
+            }
+            else {
+                console.debug(`Could not calculate spacing and no pixel spacing found. Using default thickness (${DEFAULT_THICKNESS_SINGLE_SLICE} mm)`);
+                spacing = DEFAULT_THICKNESS_SINGLE_SLICE;
+            }
         }
     }
     return spacing;
@@ -4339,7 +4379,7 @@ var isEqual = __webpack_require__(74638);
 
 
 function isValidVolume(imageIds) {
-    if (imageIds.length <= 1) {
+    if (!imageIds.length) {
         return false;
     }
     const imageId0 = imageIds[0];
@@ -4937,6 +4977,8 @@ function scroll_scroll(viewport, options) {
 function scrollVolume(viewport, volumeId, delta, scrollSlabs = false) {
     const useSlabThickness = scrollSlabs;
     const { numScrollSteps, currentStepIndex, sliceRangeInfo } = (0,getVolumeViewportScrollInfo/* default */.A)(viewport, volumeId, useSlabThickness);
+    if (numScrollSteps === 0)
+        return;
     if (!sliceRangeInfo) {
         return;
     }
@@ -6933,7 +6975,7 @@ var COLOR_LUT = __webpack_require__(93952);
 
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '4.12.6';
+const version = '4.14.4';
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/synchronizers/callbacks/cameraSyncCallback.js
 
@@ -10434,6 +10476,9 @@ class PanTool extends base/* BaseTool */.oS {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             limitToViewport: false,
+            ignoreX: false,
+            ignoreY: false,
+            ignoreZ: false
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -10508,6 +10553,15 @@ class PanTool extends base/* BaseTool */.oS {
             deltaPointsWorld[2] === 0) {
             return;
         }
+        if (this.configuration.ignoreX) {
+            deltaPointsWorld[0] = 0;
+        }
+        if (this.configuration.ignoreY) {
+            deltaPointsWorld[1] = 0;
+        }
+        if (this.configuration.ignoreZ) {
+            deltaPointsWorld[2] = 0;
+        }
         const viewport = enabledElement.viewport;
         const camera = viewport.getCamera();
         const { focalPoint, position } = camera;
@@ -15686,7 +15740,7 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
             const canvasPos = currentPoints.canvas;
             const { magnifyingGlass: config } = this.configuration;
             const { radius, zoomFactor, autoPan } = config;
-            const canvasHandlePoints = this._getCanvasHandlePoints(canvasPos, radius);
+            const worldHandlePoints = this._getWorldHandlePoints(viewport, canvasPos, radius);
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
             const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
@@ -15708,9 +15762,9 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
                     sourceViewportId: viewport.id,
                     magnifyViewportId,
                     zoomFactor,
-                    isCanvasAnnotation: true,
+                    isCanvasAnnotation: false,
                     handles: {
-                        points: canvasHandlePoints,
+                        points: worldHandlePoints,
                         activeHandleIndex: null,
                     },
                 },
@@ -15726,13 +15780,14 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
                     padding: autoPan.padding,
                     callback: (data) => {
                         const annotationPoints = annotation.data.handles.points;
-                        const { canvas: canvasDelta } = data.delta;
+                        const { world: worldDelta } = data.delta;
                         for (let i = 0, len = annotationPoints.length; i < len; i++) {
                             const point = annotationPoints[i];
-                            point[0] += canvasDelta[0];
-                            point[1] += canvasDelta[1];
-                            annotation.invalidated = true;
+                            point[0] += worldDelta[0];
+                            point[1] += worldDelta[1];
+                            point[2] += worldDelta[2];
                         }
+                        annotation.invalidated = true;
                     },
                 },
             });
@@ -15752,17 +15807,9 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
             });
         };
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
-            const { data } = annotation;
-            const { points } = data.handles;
-            const canvasCoordinates = points;
-            const canvasTop = canvasCoordinates[0];
-            const canvasBottom = canvasCoordinates[2];
-            const canvasLeft = canvasCoordinates[3];
-            const radius = Math.abs(canvasBottom[1] - canvasTop[1]) * 0.5;
-            const center = [
-                canvasLeft[0] + radius,
-                canvasTop[1] + radius,
-            ];
+            const { viewport } = (0,esm.getEnabledElement)(element);
+            const { points } = annotation.data.handles;
+            const { radius, center } = this._getCanvasCircleData(viewport, points);
             const radiusPoint = (0,circle.getCanvasCircleRadius)([center, canvasCoords]);
             if (Math.abs(radiusPoint - radius) < proximity * 2) {
                 return true;
@@ -15819,14 +15866,14 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
         this._dragDrawCallback = (evt) => {
             this.isDrawing = true;
             const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { viewport } = (0,esm.getEnabledElement)(element);
             const { deltaPoints } = eventDetail;
             const canvasDelta = deltaPoints?.canvas ?? [0, 0, 0];
             const { annotation, viewportIdsToRender } = this.editData;
             const { points } = annotation.data.handles;
-            points.forEach((point) => {
-                point[0] += canvasDelta[0];
-                point[1] += canvasDelta[1];
-            });
+            const worldDelta = this._getWorldDeltaFromCanvasDelta(viewport, points, canvasDelta);
+            this._applyWorldDelta(points, worldDelta);
             annotation.invalidated = true;
             this.editData.hasMoved = true;
             (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
@@ -15839,12 +15886,10 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
             const { data } = annotation;
             if (handleIndex === undefined) {
                 const { deltaPoints } = eventDetail;
-                const canvasDelta = deltaPoints.canvas;
+                const canvasDelta = deltaPoints.canvas ?? [0, 0, 0];
                 const points = data.handles.points;
-                points.forEach((point) => {
-                    point[0] += canvasDelta[0];
-                    point[1] += canvasDelta[1];
-                });
+                const worldDelta = this._getWorldDeltaFromCanvasDelta((0,esm.getEnabledElement)(element).viewport, points, canvasDelta);
+                this._applyWorldDelta(points, worldDelta);
                 annotation.invalidated = true;
             }
             else {
@@ -15855,18 +15900,12 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
         };
         this._dragHandle = (evt) => {
             const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { viewport } = (0,esm.getEnabledElement)(element);
             const { annotation } = this.editData;
             const { data } = annotation;
             const { points } = data.handles;
-            const canvasCoordinates = points;
-            const canvasTop = canvasCoordinates[0];
-            const canvasBottom = canvasCoordinates[2];
-            const canvasLeft = canvasCoordinates[3];
-            const radius = Math.abs(canvasBottom[1] - canvasTop[1]) * 0.5;
-            const canvasCenter = [
-                canvasLeft[0] + radius,
-                canvasTop[1] + radius,
-            ];
+            const { center: canvasCenter } = this._getCanvasCircleData(viewport, points);
             const { currentPoints } = eventDetail;
             const currentCanvasPoints = currentPoints.canvas;
             const newRadius = (0,circle.getCanvasCircleRadius)([
@@ -15874,10 +15913,11 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
                 currentCanvasPoints,
             ]);
             const newCanvasHandlePoints = this._getCanvasHandlePoints(canvasCenter, newRadius);
-            points[0] = newCanvasHandlePoints[0];
-            points[1] = newCanvasHandlePoints[1];
-            points[2] = newCanvasHandlePoints[2];
-            points[3] = newCanvasHandlePoints[3];
+            const newWorldHandlePoints = newCanvasHandlePoints.map((handle) => viewport.canvasToWorld(handle));
+            points[0] = newWorldHandlePoints[0];
+            points[1] = newWorldHandlePoints[1];
+            points[2] = newWorldHandlePoints[2];
+            points[3] = newWorldHandlePoints[3];
         };
         this.cancel = (element) => {
             if (!this.isDrawing) {
@@ -15939,19 +15979,11 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
                 const { annotationUID, data } = annotation;
                 const { magnifyViewportId, zoomFactor, handles } = data;
                 const { points, activeHandleIndex } = handles;
+                const { center, radius, canvasPoints } = this._getCanvasCircleData(viewport, points);
                 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 canvasCoordinates = points;
-                const canvasTop = canvasCoordinates[0];
-                const canvasBottom = canvasCoordinates[2];
-                const canvasLeft = canvasCoordinates[3];
-                const radius = Math.abs(canvasBottom[1] - canvasTop[1]) * 0.5;
-                const center = [
-                    canvasLeft[0] + radius,
-                    canvasTop[1] + radius,
-                ];
                 if (!viewport.getRenderingEngine()) {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
@@ -15963,7 +15995,10 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
                 if (!(0,annotationLocking.isAnnotationLocked)(annotationUID) &&
                     !this.editData &&
                     activeHandleIndex !== null) {
-                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                    const activeHandle = canvasPoints[activeHandleIndex];
+                    activeHandleCanvasCoords = [
+                        [activeHandle[0], activeHandle[1], 0],
+                    ];
                 }
                 if (activeHandleCanvasCoords) {
                     const handleGroupUID = '0';
@@ -15986,6 +16021,22 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
             }
             return renderStatus;
         };
+        this._getWorldHandlePoints = (viewport, canvasCenterPos, canvasRadius) => {
+            const canvasHandlePoints = this._getCanvasHandlePoints(canvasCenterPos, canvasRadius);
+            return canvasHandlePoints.map((handlePoint) => viewport.canvasToWorld(handlePoint));
+        };
+        this._getCanvasCircleData = (viewport, points) => {
+            const canvasPoints = points.map((point) => viewport.worldToCanvas(point));
+            const canvasTop = canvasPoints[0];
+            const canvasBottom = canvasPoints[2];
+            const canvasLeft = canvasPoints[3];
+            const radius = Math.abs(canvasBottom[1] - canvasTop[1]) * 0.5;
+            const center = [
+                canvasLeft[0] + radius,
+                canvasTop[1] + radius,
+            ];
+            return { canvasPoints, center, radius };
+        };
         this._getCanvasHandlePoints = (canvasCenterPos, canvasRadius) => {
             return [
                 [canvasCenterPos[0], canvasCenterPos[1] - canvasRadius, 0],
@@ -16052,6 +16103,33 @@ class AdvancedMagnifyTool extends base/* AnnotationTool */.EC {
         });
         return dropdown;
     }
+    _getWorldDeltaFromCanvasDelta(viewport, points, canvasDelta) {
+        if (!canvasDelta) {
+            return [0, 0, 0];
+        }
+        const referencePoint = points[0];
+        const referenceCanvasPoint = viewport.worldToCanvas(referencePoint);
+        const movedWorldPoint = viewport.canvasToWorld([
+            referenceCanvasPoint[0] + canvasDelta[0],
+            referenceCanvasPoint[1] + canvasDelta[1],
+        ]);
+        return [
+            movedWorldPoint[0] - referencePoint[0],
+            movedWorldPoint[1] - referencePoint[1],
+            movedWorldPoint[2] - referencePoint[2],
+        ];
+    }
+    _applyWorldDelta(points, worldDelta) {
+        if (!worldDelta) {
+            return;
+        }
+        for (let i = 0, len = points.length; i < len; i++) {
+            const point = points[i];
+            point[0] += worldDelta[0];
+            point[1] += worldDelta[1];
+            point[2] += worldDelta[2];
+        }
+    }
 }
 class AdvancedMagnifyViewportManager {
     constructor() {
@@ -17484,7 +17562,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool/* default */.A {
             let annotation = this.editData?.annotation;
             const annotations = (0,annotationState.getAnnotations)(this.getToolName(), viewport.element);
             if (annotations.length) {
-                annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
+                annotation = annotations.filter((thisAnnotation) => thisAnnotation.data?.viewportId == viewport.id)[0];
             }
             enabledElements.forEach((element) => {
                 const { viewport } = element;
@@ -17730,10 +17808,10 @@ class ScaleOverlayTool extends AnnotationDisplayTool/* default */.A {
         const location = this.configuration.scaleLocation;
         const { viewport } = enabledElement;
         const annotations = (0,annotationState.getAnnotations)(this.getToolName(), viewport.element);
-        const annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
+        const annotation = annotations.filter((thisAnnotation) => thisAnnotation.data?.viewportId == viewport.id)[0];
         const canvas = enabledElement.viewport.canvas;
         const renderStatus = false;
-        if (!viewport) {
+        if (!viewport || !annotation) {
             return renderStatus;
         }
         const styleSpecifier = {
@@ -36791,12 +36869,10 @@ function defaultGetTextLines(data, targetId) {
 /* harmony import */ var _strategies_eraseSphere__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(1989);
 /* harmony import */ var _strategies_fillCircle__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(56789);
 /* harmony import */ var _strategies_eraseCircle__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(33852);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(74347);
-/* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(7001);
-/* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(58640);
-/* harmony import */ var _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(23631);
-/* harmony import */ var _strategies_utils_getStrategyData__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(40905);
-
+/* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(7001);
+/* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(58640);
+/* harmony import */ var _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(23631);
+/* harmony import */ var _strategies_utils_getStrategyData__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(40905);
 
 
 
@@ -36808,7 +36884,7 @@ function defaultGetTextLines(data, targetId) {
 
 
 
-class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["default"] */ .A {
+class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -36895,7 +36971,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
             const { viewport } = enabledElement;
             this._editData = this.createEditData(element);
             this._activateDraw(element);
-            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_8__.hideElementCursor)(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_7__.hideElementCursor)(element);
             evt.preventDefault();
             this._previewData.isDrag = false;
             this._previewData.timerStart = Date.now();
@@ -36909,7 +36985,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
                 world: gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.clone */ .eR.clone(worldPoint),
             };
             const hoverData = this._hoverData || this.createHoverData(element);
-            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(hoverData.viewportIdsToRender);
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)(hoverData.viewportIdsToRender);
             const operationData = this.getOperationData(element);
             if (!operationData) {
                 return false;
@@ -36918,6 +36994,9 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
             return true;
         };
         this.mouseMoveCallback = (evt) => {
+            if (!this.isPrimary) {
+                return;
+            }
             if (this.mode === _enums__WEBPACK_IMPORTED_MODULE_2__.ToolModes.Active) {
                 this.updateCursor(evt);
                 if (!this.configuration.preview.enabled) {
@@ -36966,7 +37045,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
             }
             const { viewport } = enabledElement;
             const activeStrategy = this.configuration.activeStrategy;
-            const strategyData = (0,_strategies_utils_getStrategyData__WEBPACK_IMPORTED_MODULE_11__/* .getStrategyData */ .S)({
+            const strategyData = (0,_strategies_utils_getStrategyData__WEBPACK_IMPORTED_MODULE_10__/* .getStrategyData */ .S)({
                 operationData,
                 viewport,
                 strategy: activeStrategy,
@@ -36988,7 +37067,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
             const { viewport } = enabledElement;
             this.updateCursor(evt);
             const { viewportIdsToRender } = this._hoverData;
-            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(viewportIdsToRender);
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)(viewportIdsToRender);
             const delta = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec2.distance */ .Zc.distance(currentPoints.canvas, this._previewData.startPoint);
             const { dragTimeMs, dragMoveDistance } = this.configuration.preview;
             if (!this._previewData.isDrag &&
@@ -37050,7 +37129,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
             }
             this.doneEditMemo();
             this._deactivateDraw(element);
-            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_8__.resetElementCursor)(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_7__.resetElementCursor)(element);
             this.updateCursor(evt);
             this._editData = null;
             this._lastDragInfo = null;
@@ -37084,55 +37163,12 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
         if (!this._hoverData) {
             return;
         }
-        (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(this._hoverData.viewportIdsToRender);
+        BrushTool.activeCursorTool = this;
+        (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)(this._hoverData.viewportIdsToRender);
     }
     _calculateCursor(element, centerCanvas) {
         const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
-        const { viewport } = enabledElement;
-        const { canvasToWorld } = viewport;
-        const camera = viewport.getCamera();
-        const { brushSize } = this.configuration;
-        const viewUp = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.fromValues */ .eR.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
-        const viewPlaneNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.fromValues */ .eR.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
-        const viewRight = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
-        gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.cross */ .eR.cross(viewRight, viewUp, viewPlaneNormal);
-        const centerCursorInWorld = canvasToWorld([
-            centerCanvas[0],
-            centerCanvas[1],
-        ]);
-        const bottomCursorInWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
-        const topCursorInWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
-        const leftCursorInWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
-        const rightCursorInWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
-        for (let i = 0; i <= 2; i++) {
-            bottomCursorInWorld[i] = centerCursorInWorld[i] - viewUp[i] * brushSize;
-            topCursorInWorld[i] = centerCursorInWorld[i] + viewUp[i] * brushSize;
-            leftCursorInWorld[i] = centerCursorInWorld[i] - viewRight[i] * brushSize;
-            rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
-        }
-        if (!this._hoverData) {
-            return;
-        }
-        const { brushCursor } = this._hoverData;
-        const { data } = brushCursor;
-        if (data.handles === undefined) {
-            data.handles = {};
-        }
-        data.handles.points = [
-            bottomCursorInWorld,
-            topCursorInWorld,
-            leftCursorInWorld,
-            rightCursorInWorld,
-        ];
-        const activeStrategy = this.configuration.activeStrategy;
-        const strategy = this.configuration.strategies[activeStrategy];
-        if (typeof strategy?.computeInnerCircleRadius === 'function') {
-            strategy.computeInnerCircleRadius({
-                configuration: this.configuration,
-                viewport,
-            });
-        }
-        data.invalidated = false;
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), _enums__WEBPACK_IMPORTED_MODULE_2__.StrategyCallbacks.CalculateCursorGeometry);
     }
     getStatistics(element, segmentIndices) {
         if (!element) {
@@ -37180,7 +37216,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
         this._hoverData.brushCursor.metadata.segmentColor = segmentColor;
     }
     renderAnnotation(enabledElement, svgDrawingHelper) {
-        if (!this._hoverData) {
+        if (!this._hoverData || BrushTool.activeCursorTool !== this) {
             return;
         }
         const { viewport } = enabledElement;
@@ -37194,40 +37230,7 @@ class BrushTool extends _LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_10__/* ["defa
             const { element } = viewport;
             this._calculateCursor(element, centerCanvas);
         }
-        const toolMetadata = brushCursor.metadata;
-        if (!toolMetadata) {
-            return;
-        }
-        const annotationUID = toolMetadata.brushCursorUID;
-        const data = brushCursor.data;
-        const { points } = data.handles;
-        const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-        const bottom = canvasCoordinates[0];
-        const top = canvasCoordinates[1];
-        const center = [
-            Math.floor((bottom[0] + top[0]) / 2),
-            Math.floor((bottom[1] + top[1]) / 2),
-        ];
-        const radius = Math.abs(bottom[1] - Math.floor((bottom[1] + top[1]) / 2));
-        const color = `rgb(${toolMetadata.segmentColor?.slice(0, 3) || [0, 0, 0]})`;
-        if (!viewport.getRenderingEngine()) {
-            console.warn('Rendering Engine has been destroyed');
-            return;
-        }
-        const circleUID = '0';
-        (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_7__.drawCircle)(svgDrawingHelper, annotationUID, circleUID, center, radius, {
-            color,
-            lineDash: this.centerSegmentIndexInfo.segmentIndex === 0 ? [1, 2] : null,
-        });
-        const { dynamicRadiusInCanvas } = this.configuration?.threshold || {
-            dynamicRadiusInCanvas: 0,
-        };
-        if (dynamicRadiusInCanvas) {
-            const circleUID1 = '1';
-            (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_7__.drawCircle)(svgDrawingHelper, annotationUID, circleUID1, center, dynamicRadiusInCanvas, {
-                color,
-            });
-        }
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(viewport.element), _enums__WEBPACK_IMPORTED_MODULE_2__.StrategyCallbacks.RenderCursor, svgDrawingHelper);
     }
 }
 BrushTool.toolName = 'Brush';
@@ -37482,6 +37485,7 @@ class LabelmapBaseTool extends _base__WEBPACK_IMPORTED_MODULE_1__/* .BaseTool */
             previewColor,
             previewSegmentIndex,
             createMemo: this.createMemo.bind(this),
+            hoverData: this._hoverData,
         };
         return operationData;
     }
@@ -37646,7 +37650,7 @@ function lightenColor(r, g, b, a, factor = 0.4) {
 /* harmony import */ var _utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(72282);
 /* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(55887);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29857);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(11990);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(64664);
 /* harmony import */ var _utilities_math_sphere__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(62783);
 
 
@@ -37873,7 +37877,7 @@ function fillOutsideCircle() {
 /* harmony import */ var _utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(72282);
 /* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(55887);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29857);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(11990);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(64664);
 
 
 

package/dist/{6163.bundle.8145a6c7394d0ffa60f4.js → 6163.bundle.e0d7dbf2a795589d1ba0.js}

@@ -109,6 +109,8 @@ var SegmentationRepresentations;
 /* harmony export */ });
 var StrategyCallbacks;
 (function (StrategyCallbacks) {
+    StrategyCallbacks["CalculateCursorGeometry"] = "calculateCursorGeometry";
+    StrategyCallbacks["RenderCursor"] = "renderCursor";
     StrategyCallbacks["OnInteractionStart"] = "onInteractionStart";
     StrategyCallbacks["OnInteractionEnd"] = "onInteractionEnd";
     StrategyCallbacks["Preview"] = "preview";