@ohif/app 3.13.0-beta.64 → 3.13.0-beta.66

package/dist/{2851.bundle.f4f60fab803d915d29c9.js → 2851.bundle.8757dd07775645121b52.js}

@@ -2779,14 +2779,12 @@ function resolveConfigFetchPolicy(rawUrl, policy = {}) {
 }
 async function fetchConfigJson(normalizedPolicy) {
   const {
-    normalizedUrl,
-    isAuthenticated,
-    isSameOrigin
+    normalizedUrl
   } = normalizedPolicy;
-  const response = isAuthenticated || isSameOrigin ? await fetch(normalizedUrl) : await fetch(normalizedUrl, {
+  const response = await fetch(normalizedUrl, {
     method: 'GET',
     mode: 'cors',
-    credentials: 'omit',
+    credentials: 'same-origin',
     redirect: 'error',
     referrerPolicy: 'no-referrer'
   });
@@ -10614,8 +10612,8 @@ function AboutModalDefault() {
     name
   } = (0,browser_detect_es5/* default */.A)();
   const browser = `${name[0].toUpperCase()}${name.substr(1)} ${version}`;
-  const versionNumber = "3.13.0-beta.64";
-  const commitHash = "f8ccf9ff2ea9ab7c38bd427514a8ae87902822a3";
+  const versionNumber = "3.13.0-beta.66";
+  const commitHash = "468e5734a9ab02516430cc0dab5d7f2106dea950";
   const [main, beta] = versionNumber.split('-');
   return /*#__PURE__*/react.createElement(ui_next_src/* AboutModal */.VTU, {
     className: "w-[400px]"

package/dist/{7537.bundle.1726a7f7a4c378296085.js → 7537.bundle.889ba5f2707418c6fd88.js}

@@ -36341,7 +36341,7 @@ function uuidv4() {
 
 "use strict";
 /* unused harmony export version */
-const version = '4.21.7';
+const version = '4.22.3';
 
 
 /***/ },

package/dist/{9039.bundle.7afa93b103c3b26d4855.js → 9039.bundle.f72736f47fedeff521e2.js}

@@ -7309,7 +7309,7 @@ var COLOR_LUT = __webpack_require__(93952);
 
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '4.21.7';
+const version = '4.22.3';
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/synchronizers/callbacks/cameraSyncCallback.js
 /* unused harmony import specifier */ var cameraSyncCallback_getRenderingEngine;
@@ -11343,6 +11343,8 @@ var SphereSource = __webpack_require__(73435);
 var Plane = __webpack_require__(49794);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/index.js + 8 modules
 var volumeCropping = __webpack_require__(88380);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/interactionDragCoordinator.js
+var interactionDragCoordinator = __webpack_require__(51970);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/VolumeCroppingTool.js
 
 
@@ -11357,6 +11359,7 @@ var volumeCropping = __webpack_require__(88380);
 
 
 
+
 class VolumeCroppingTool extends base/* BaseTool */.oS {
     constructor(toolProps = {}, defaultToolProps = {
         configuration: {
@@ -11387,6 +11390,7 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
         this.originalClippingPlanes = [];
         this.draggingSphereIndex = null;
         this.rotatePlanesOnDrag = false;
+        this.suppressPlaneRotationForCurrentDrag = false;
         this.cornerDragOffset = null;
         this.faceDragOffset = null;
         this.volumeDirectionVectors = null;
@@ -11409,8 +11413,11 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             const { element } = eventDetail;
             const enabledElement = (0,esm.getEnabledElement)(element);
             const { viewport } = enabledElement;
-            const actorEntry = viewport.getDefaultActor();
-            const actor = actorEntry.actor;
+            this.suppressPlaneRotationForCurrentDrag = (0,interactionDragCoordinator/* isDragOwnedBy */.lq)(viewport.id, 'orientation-controller');
+            const actor = this._getVolumeActor(viewport);
+            if (!actor) {
+                return false;
+            }
             const mapper = actor.getMapper();
             const mouseCanvas = [
                 evt.detail.currentPoints.canvas[0],
@@ -11481,6 +11488,7 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
                     this.draggingSphereIndex = null;
                     this.cornerDragOffset = null;
                     this.faceDragOffset = null;
+                    this.suppressPlaneRotationForCurrentDrag = false;
                     viewport.render();
                     this._hasResolutionChanged = false;
                 };
@@ -11638,12 +11646,12 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             if (!viewport) {
                 return;
             }
-            const volumeActors = viewport.getActors();
-            if (!volumeActors || volumeActors.length === 0) {
+            const volumeActor = this._getVolumeActor(viewport);
+            if (!volumeActor) {
                 console.warn('VolumeCroppingTool: No volume actors found in the viewport.');
                 return;
             }
-            const imageData = volumeActors[0].actor.getMapper().getInputData();
+            const imageData = volumeActor.getMapper().getInputData();
             if (!imageData) {
                 console.warn('VolumeCroppingTool: No image data found for volume actor.');
                 return;
@@ -11765,9 +11773,7 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
                     this.edgeLines[uid] = { actor, source, key1, key2 };
                 }
             });
-            const mapper = viewport
-                .getDefaultActor()
-                .actor.getMapper();
+            const mapper = volumeActor.getMapper();
             mapper.addClippingPlane(planeXMin);
             mapper.addClippingPlane(planeXMax);
             mapper.addClippingPlane(planeYMin);
@@ -12114,6 +12120,23 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
     getHandlesVisible() {
         return this.configuration.showHandles;
     }
+    setHandleRadius(radius) {
+        this.configuration.sphereRadius = radius;
+        this.sphereStates.forEach((state) => {
+            if (state?.sphereSource?.setRadius) {
+                state.sphereSource.setRadius(radius);
+                state.sphereSource.modified();
+            }
+        });
+        const viewportsInfo = this._getViewportsInfo();
+        const [viewport3D] = viewportsInfo;
+        if (!viewport3D) {
+            return;
+        }
+        const renderingEngine = (0,esm.getRenderingEngine)(viewport3D.renderingEngineId);
+        const viewport = renderingEngine?.getViewport(viewport3D.viewportId);
+        viewport?.render();
+    }
     getClippingPlanesVisible() {
         return this.configuration.showClippingPlanes;
     }
@@ -12149,7 +12172,8 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
         }
         else {
             const shiftKey = evt.detail.event?.shiftKey ?? false;
-            if (this.rotatePlanesOnDrag === true || shiftKey) {
+            if ((this.rotatePlanesOnDrag === true || shiftKey) &&
+                !this.suppressPlaneRotationForCurrentDrag) {
                 this._rotateClippingPlanes(evt);
                 return;
             }
@@ -12207,9 +12231,11 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
         }
     }
     _updateClippingPlanes(viewport) {
-        const actorEntry = viewport.getDefaultActor();
-        const actor = actorEntry.actor;
-        const mapper = actor.getMapper();
+        const actor = this._getVolumeActor(viewport);
+        const mapper = this._getVolumeMapper(viewport);
+        if (!actor || !mapper) {
+            return;
+        }
         const matrix = actor.getMatrix();
         if (!this.configuration.showClippingPlanes) {
             mapper.removeAllClippingPlanes();
@@ -12346,7 +12372,10 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
     }
     _getVolumeActor(viewport) {
         const vp = viewport || this._getViewport();
-        return vp?.getDefaultActor()?.actor;
+        return vp
+            ?.getActors?.()
+            ?.find((entry) => entry.actor?.getClassName?.() === 'vtkVolume')
+            ?.actor;
     }
     _getVolumeMapper(viewport) {
         const actor = this._getVolumeActor(viewport);
@@ -12363,7 +12392,10 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
         }
     }
     _updateClippingPlanesFromFaceSpheres(viewport) {
-        const mapper = viewport.getDefaultActor().actor.getMapper();
+        const mapper = this._getVolumeMapper(viewport);
+        if (!mapper) {
+            return;
+        }
         this.originalClippingPlanes[volumeCropping.PLANEINDEX.XMIN].origin = [
             ...this.sphereStates[volumeCropping.SPHEREINDEX.XMIN].point,
         ];
@@ -16081,7 +16113,7 @@ class MagnifyTool extends base/* BaseTool */.oS {
             const { viewport } = enabledElement;
             const { element } = viewport;
             const viewportProperties = viewport.getProperties();
-            const { rotation: originalViewportRotation } = viewport.getViewPresentation();
+            const { rotation: originalViewportRotation, flipHorizontal: originalViewportFlipHorizontal, flipVertical: originalViewportFlipVertical, } = viewport.getViewPresentation();
             const { canvas: canvasPos, world: worldPos } = currentPoints;
             let magnifyToolElement;
             magnifyToolElement = element.querySelector('.magnifyTool');
@@ -16112,6 +16144,8 @@ class MagnifyTool extends base/* BaseTool */.oS {
                 magnifyViewport.setProperties(viewportProperties);
                 magnifyViewport.setViewPresentation({
                     rotation: originalViewportRotation,
+                    flipHorizontal: originalViewportFlipHorizontal,
+                    flipVertical: originalViewportFlipVertical,
                 });
                 const { parallelScale } = viewport.getCamera();
                 const { focalPoint, position, viewPlaneNormal } = magnifyViewport.getCamera();
@@ -17134,6 +17168,7 @@ class AdvancedMagnifyViewport {
     _syncViewportsCameras(sourceViewport, magnifyViewport) {
         const worldPos = sourceViewport.canvasToWorld(this.position);
         const parallelScale = this._convertZoomFactorToParallelScale(sourceViewport, magnifyViewport, this.zoomFactor);
+        const { flipHorizontal, flipVertical } = sourceViewport.getCamera();
         const { focalPoint, position, viewPlaneNormal } = magnifyViewport.getCamera();
         const distance = Math.sqrt(Math.pow(focalPoint[0] - position[0], 2) +
             Math.pow(focalPoint[1] - position[1], 2) +
@@ -17152,6 +17187,8 @@ class AdvancedMagnifyViewport {
             parallelScale,
             focalPoint: updatedFocalPoint,
             position: updatedPosition,
+            flipHorizontal,
+            flipVertical,
         });
     }
     _syncStackViewports(sourceViewport, magnifyViewport) {
@@ -29447,12 +29484,19 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
             showEdgeFaces: true,
             showCornerFaces: true,
             keepOrientationUp: true,
+            highlightColor: [255, 255, 255],
+            edgeColor: [200, 200, 200],
+            cornerColor: [150, 150, 150],
+            restingAmbient: 1.0,
+            hoverAmbient: 1.0,
         },
     }) {
         super(toolProps, defaultToolProps);
         this.widget = new OrientationControllerWidget/* vtkOrientationControllerWidget */.C();
         this.resizeObservers = new Map();
         this.cameraHandlers = new Map();
+        this.animationFrameHandles = new Map();
+        this.animationTokens = new Map();
         this._getViewportsInfo = () => {
             const viewports = (0,ToolGroupManager.getToolGroup)(this.toolGroupId)?.viewportsInfo;
             return viewports || [];
@@ -29546,6 +29590,7 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
             }
             const volumeViewport = viewport;
             this.widget.positionActors(volumeViewport, actors, this.getPositionConfig());
+            this.widget.syncOverlayViewport(viewportId, volumeViewport);
             viewport.render();
         };
     }
@@ -29611,6 +29656,9 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
         this.resizeObservers.forEach((observer) => observer.disconnect());
         this.resizeObservers.clear();
         this.cameraHandlers.clear();
+        this.animationFrameHandles.forEach((handle) => cancelAnimationFrame(handle));
+        this.animationFrameHandles.clear();
+        this.animationTokens.clear();
     }
     createAnnotatedRhombActor() {
         const faceColors = this.getFaceColors();
@@ -29621,9 +29669,17 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
             opacity: this.configuration.opacity ?? 1.0,
             showEdgeFaces: this.configuration.showEdgeFaces !== false,
             showCornerFaces: this.configuration.showCornerFaces !== false,
+            highlightColor: this.configuration.highlightColor ?? [255, 255, 255],
+            edgeColor: this.configuration.edgeColor ?? [200, 200, 200],
+            cornerColor: this.configuration.cornerColor ?? [150, 150, 150],
+            restingAmbient: this.configuration.restingAmbient ?? 1.0,
+            hoverAmbient: this.configuration.hoverAmbient ?? 1.0,
         });
     }
     addMarkerToViewport(viewportId, renderingEngineId) {
+        if (this.widget.getActors(viewportId)) {
+            return;
+        }
         const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
         if (!enabledElement) {
             console.warn('OrientationControllerTool: No enabled element found');
@@ -29664,8 +29720,8 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
                 }
             },
             onFaceHover: (result) => {
-                if (result && result.actorIndex !== 0) {
-                    this.widget.highlightFace(result.pickedActor, result.cellId, volumeViewport, false);
+                if (result) {
+                    this.widget.highlightFace(result.pickedActor, result.cellId, volumeViewport, result.actorIndex === 0);
                 }
                 else {
                     this.widget.clearHighlight();
@@ -29704,6 +29760,14 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
         viewport.render();
     }
     animateCameraToOrientation(viewport, targetViewPlaneNormal, targetViewUp) {
+        const viewportId = viewport.id;
+        const existingHandle = this.animationFrameHandles.get(viewportId);
+        if (existingHandle !== undefined) {
+            cancelAnimationFrame(existingHandle);
+            this.animationFrameHandles.delete(viewportId);
+        }
+        const nextToken = (this.animationTokens.get(viewportId) ?? 0) + 1;
+        this.animationTokens.set(viewportId, nextToken);
         const keepOrientationUp = this.configuration.keepOrientationUp !== false;
         const renderer = viewport.getRenderer();
         const camera = renderer.getActiveCamera();
@@ -29715,34 +29779,33 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
         gl_matrix_esm/* vec3.cross */.eR.cross(startRight, startUp, startForward);
         gl_matrix_esm/* vec3.normalize */.eR.normalize(startRight, startRight);
         const startMatrix = gl_matrix_esm/* mat4.fromValues */.pB.fromValues(startRight[0], startRight[1], startRight[2], 0, startUp[0], startUp[1], startUp[2], 0, startForward[0], startForward[1], startForward[2], 0, 0, 0, 0, 1);
+        const targetForward = gl_matrix_esm/* vec3.normalize */.eR.normalize(gl_matrix_esm/* vec3.create */.eR.create(), targetViewPlaneNormal);
         let targetUp;
         if (keepOrientationUp) {
             targetUp = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(targetViewUp[0], targetViewUp[1], targetViewUp[2]);
         }
         else {
-            const currentUp = gl_matrix_esm/* vec3.normalize */.eR.normalize(gl_matrix_esm/* vec3.create */.eR.create(), startUp);
-            const normalizedForward = gl_matrix_esm/* vec3.create */.eR.create();
-            gl_matrix_esm/* vec3.normalize */.eR.normalize(normalizedForward, targetViewPlaneNormal);
-            const dot = gl_matrix_esm/* vec3.dot */.eR.dot(currentUp, normalizedForward);
+            const currentFwd = gl_matrix_esm/* vec3.normalize */.eR.normalize(gl_matrix_esm/* vec3.create */.eR.create(), startForward);
+            const rotQuat = gl_matrix_esm/* quat.create */.Yu.create();
+            gl_matrix_esm/* quat.rotationTo */.Yu.rotationTo(rotQuat, currentFwd, targetForward);
             targetUp = gl_matrix_esm/* vec3.create */.eR.create();
-            gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(targetUp, currentUp, normalizedForward, -dot);
+            gl_matrix_esm/* vec3.transformQuat */.eR.transformQuat(targetUp, startUp, rotQuat);
             gl_matrix_esm/* vec3.normalize */.eR.normalize(targetUp, targetUp);
-            if (gl_matrix_esm/* vec3.length */.eR.length(targetUp) < 0.001) {
-                if (Math.abs(normalizedForward[2]) < 0.9) {
-                    targetUp = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(0, 0, 1);
-                }
-                else {
-                    targetUp = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(0, 1, 0);
-                }
-                const dot2 = gl_matrix_esm/* vec3.dot */.eR.dot(targetUp, normalizedForward);
-                gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(targetUp, targetUp, normalizedForward, -dot2);
-                gl_matrix_esm/* vec3.normalize */.eR.normalize(targetUp, targetUp);
-            }
         }
+        const upDotForward = gl_matrix_esm/* vec3.dot */.eR.dot(targetUp, targetForward);
+        gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(targetUp, targetUp, targetForward, -upDotForward);
+        if (gl_matrix_esm/* vec3.length */.eR.length(targetUp) < 0.0001) {
+            targetUp = gl_matrix_esm/* vec3.clone */.eR.clone(startUp);
+            const fallbackDot = gl_matrix_esm/* vec3.dot */.eR.dot(targetUp, targetForward);
+            gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(targetUp, targetUp, targetForward, -fallbackDot);
+        }
+        gl_matrix_esm/* vec3.normalize */.eR.normalize(targetUp, targetUp);
         const targetRight = gl_matrix_esm/* vec3.create */.eR.create();
-        gl_matrix_esm/* vec3.cross */.eR.cross(targetRight, targetUp, targetViewPlaneNormal);
+        gl_matrix_esm/* vec3.cross */.eR.cross(targetRight, targetUp, targetForward);
         gl_matrix_esm/* vec3.normalize */.eR.normalize(targetRight, targetRight);
-        const targetMatrix = gl_matrix_esm/* mat4.fromValues */.pB.fromValues(targetRight[0], targetRight[1], targetRight[2], 0, targetUp[0], targetUp[1], targetUp[2], 0, targetViewPlaneNormal[0], targetViewPlaneNormal[1], targetViewPlaneNormal[2], 0, 0, 0, 0, 1);
+        gl_matrix_esm/* vec3.cross */.eR.cross(targetUp, targetForward, targetRight);
+        gl_matrix_esm/* vec3.normalize */.eR.normalize(targetUp, targetUp);
+        const targetMatrix = gl_matrix_esm/* mat4.fromValues */.pB.fromValues(targetRight[0], targetRight[1], targetRight[2], 0, targetUp[0], targetUp[1], targetUp[2], 0, targetForward[0], targetForward[1], targetForward[2], 0, 0, 0, 0, 1);
         const startQuat = gl_matrix_esm/* mat4.getRotation */.pB.getRotation(gl_matrix_esm/* quat.create */.Yu.create(), startMatrix);
         const targetQuat = gl_matrix_esm/* mat4.getRotation */.pB.getRotation(gl_matrix_esm/* quat.create */.Yu.create(), targetMatrix);
         let dotProduct = gl_matrix_esm/* quat.dot */.Yu.dot(startQuat, targetQuat);
@@ -29754,13 +29817,21 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
         if (dotProduct > threshold) {
             return;
         }
-        const steps = 10;
         const duration = 150;
-        const stepDuration = duration / steps;
-        let currentStep = 0;
-        const animate = () => {
-            currentStep++;
-            const t = currentStep / steps;
+        const animationStart = performance.now();
+        const finalNormal = [
+            targetForward[0],
+            targetForward[1],
+            targetForward[2],
+        ];
+        const finalUp = [targetUp[0], targetUp[1], targetUp[2]];
+        const animate = (now) => {
+            if (this.animationTokens.get(viewportId) !== nextToken) {
+                return;
+            }
+            const elapsed = now - animationStart;
+            const t = Math.min(1, elapsed / duration);
+            const isLastStep = t >= 1;
             const easedT = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
             const interpolatedQuat = gl_matrix_esm/* quat.create */.Yu.create();
             gl_matrix_esm/* quat.slerp */.Yu.slerp(interpolatedQuat, startQuat, targetQuat, easedT);
@@ -29769,16 +29840,21 @@ class OrientationControllerTool extends base/* BaseTool */.oS {
             const interpolatedForward = interpolatedMatrix.slice(8, 11);
             const interpolatedUp = interpolatedMatrix.slice(4, 7);
             viewport.setCamera({
-                viewPlaneNormal: interpolatedForward,
-                viewUp: interpolatedUp,
+                viewPlaneNormal: isLastStep ? finalNormal : interpolatedForward,
+                viewUp: isLastStep ? finalUp : interpolatedUp,
             });
             viewport.resetCamera(ANIMATE_RESET_CAMERA_OPTIONS);
             viewport.render();
-            if (currentStep < steps) {
-                setTimeout(animate, stepDuration);
+            if (!isLastStep) {
+                const handle = requestAnimationFrame(animate);
+                this.animationFrameHandles.set(viewportId, handle);
+            }
+            else {
+                this.animationFrameHandles.delete(viewportId);
             }
         };
-        animate();
+        const handle = requestAnimationFrame(animate);
+        this.animationFrameHandles.set(viewportId, handle);
     }
 }
 /* harmony default export */ const tools_OrientationControllerTool = ((/* unused pure expression or super */ null && (OrientationControllerTool)));