@ohif/app 3.13.0-beta.63 → 3.13.0-beta.65

package/dist/{2851.bundle.82a96cdcc6fc18c73030.js → 2851.bundle.ffc5656f20a4159d591d.js}

@@ -7329,8 +7329,14 @@ function configureViewportForLayerAddition(params) {
 
   // If a viewport type was already set do not reset it.
   if (!viewport.viewportOptions.viewportType) {
-    // Special handling for overlay display sets
-    if (requestedLayerDisplaySet.isOverlayDisplaySet) {
+    // If the live Cornerstone viewport is already orthographic (volume), keep it as
+    // 'volume'. Prevents accidentally downgrading a volume viewport to 'stack' when
+    // viewportOptions arrives without a viewportType (e.g. from the HP overlay path).
+    const csViewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+    if (csViewport?.type === 'orthographic') {
+      viewport.viewportOptions.viewportType = 'volume';
+      // Special handling for overlay display sets
+    } else if (requestedLayerDisplaySet.isOverlayDisplaySet) {
       // Do not force volume for SEG and RTSTRUCT if it and all the current display sets are for the same display set
       const isSameDisplaySet = currentDisplaySetUIDs.every(uid => {
         const currentDisplaySet = displaySetService.getDisplaySetByUID(uid);
@@ -7386,7 +7392,8 @@ function configureViewportForLayerRemoval(params) {
   if (!viewport.viewportOptions) {
     viewport.viewportOptions = {};
   }
-  viewport.viewportOptions.viewportType = 'volume';
+  const csViewportOrthographic = cornerstoneViewportService.getCornerstoneViewport(viewportId)?.type === 'orthographic';
+  viewport.viewportOptions.viewportType = csViewportOrthographic ? 'volume' : 'stack';
 
   // orientation
   if (!viewport.viewportOptions.orientation) {
@@ -10607,8 +10614,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.63";
-  const commitHash = "f3cca21e49729fbf4bab85aa1de64b9dcfebd0ce";
+  const versionNumber = "3.13.0-beta.65";
+  const commitHash = "62620afb9b7d8d0302584f125704509d65ae6a2d";
   const [main, beta] = versionNumber.split('-');
   return /*#__PURE__*/react.createElement(ui_next_src/* AboutModal */.VTU, {
     className: "w-[400px]"

package/dist/{7166.bundle.775a8ac234701c028acf.js → 7166.bundle.bd50b3917b5ee6166971.js}

@@ -9950,6 +9950,51 @@ function generateSegmentationCSVReport(segmentationData, info) {
   });
 }
 ;// ../../../extensions/cornerstone/src/utils/hydrationUtils.ts
+/**
+ * After SEG hydration we must refresh every viewport that shows the referenced volume so
+ * presentations (including segmentation) apply to all MPR/3D tiles. Hanging-protocol matching
+ * can return only the active viewport when protocol definitions omit viewportId (e.g. 3D four-up)
+ * or when layout state diverges from the protocol; this merges in all grid panes that already
+ * list that volume in `displaySetInstanceUIDs`.
+ *
+ * Only exact displaySetInstanceUID matches are used (no Frame-of-Reference inference): sibling
+ * MPR planes must already share the same referenced volume UID in grid state, or HP matching
+ * must list them; otherwise forcing a different UID onto a volume viewport can leave it blank.
+ */
+function mergeVolumeSharingViewports(hangingProtocolUpdates, volumeUid, viewports) {
+  if (!volumeUid) {
+    return hangingProtocolUpdates ?? [];
+  }
+  const byId = new Map();
+  const add = (viewportId, uids) => {
+    if (!viewportId) {
+      return;
+    }
+    byId.set(viewportId, {
+      viewportId,
+      displaySetInstanceUIDs: uids
+    });
+  };
+  if (Array.isArray(hangingProtocolUpdates)) {
+    for (const entry of hangingProtocolUpdates) {
+      const vid = entry.viewportId ?? entry.viewportOptions?.viewportId;
+      if (vid) {
+        add(vid, entry.displaySetInstanceUIDs?.length ? entry.displaySetInstanceUIDs : [volumeUid]);
+      }
+    }
+  }
+  viewports.forEach(vp => {
+    const uids = vp.displaySetInstanceUIDs || [];
+    if (uids.includes(volumeUid)) {
+      add(vp.viewportId, [volumeUid]);
+    }
+  });
+  const merged = Array.from(byId.values());
+  if (merged.length === 0 && Array.isArray(hangingProtocolUpdates) && hangingProtocolUpdates.length > 0) {
+    return hangingProtocolUpdates;
+  }
+  return merged;
+}
 function getUpdatedViewportsForSegmentation({
   viewportId,
   servicesManager,
@@ -9960,7 +10005,8 @@ function getUpdatedViewportsForSegmentation({
     viewportGridService
   } = servicesManager.services;
   const {
-    isHangingProtocolLayout
+    isHangingProtocolLayout,
+    viewports
   } = viewportGridService.getState();
   const viewport = getTargetViewport({
     viewportId,
@@ -9968,7 +10014,10 @@ function getUpdatedViewportsForSegmentation({
   });
   const targetViewportId = viewport.viewportOptions.viewportId;
   const updatedViewports = hangingProtocolService.getViewportsRequireUpdate(targetViewportId, displaySetInstanceUIDs[0], isHangingProtocolLayout);
-  return updatedViewports;
+  if (updatedViewports == null) {
+    return updatedViewports;
+  }
+  return mergeVolumeSharingViewports(updatedViewports, displaySetInstanceUIDs[0], viewports);
 }
 const getTargetViewport = ({
   viewportId,
@@ -12572,6 +12621,15 @@ function commandsModule({
         servicesManager,
         displaySetInstanceUIDs
       });
+      if (!updatedViewports?.length) {
+        return;
+      }
+      updatedViewports.forEach(({
+        viewportId: csViewportId
+      }) => {
+        const csViewport = cornerstoneViewportService.getCornerstoneViewport(csViewportId);
+        csViewport?.setNeedsRender?.();
+      });
       actions.setDisplaySetsForViewports({
         viewportsToUpdate: updatedViewports.map(viewport => ({
           viewportId: viewport.viewportId,
@@ -21503,6 +21561,32 @@ const CornerstoneViewportService_EVENTS = {
 };
 const MIN_STACK_VIEWPORTS_TO_ENQUEUE_RESIZE = 12;
 const MIN_VOLUME_VIEWPORTS_TO_ENQUEUE_RESIZE = 6;
+function getVolumeActorReferencedIds(viewport) {
+  const actors = viewport.getActors?.() ?? [];
+  return actors.filter(ac => ac.actor?.getClassName?.() === 'vtkVolume').map(ac => ac.referencedId).filter(Boolean);
+}
+function volumeIdPrefixesMatch(existingIds, prefixLen, targetIds) {
+  if (prefixLen > targetIds.length) {
+    return false;
+  }
+  for (let i = 0; i < prefixLen; i++) {
+    if (existingIds[i] !== targetIds[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Returns true when the viewport type matches a volume-based presentation (ORTHOGRAPHIC or VOLUME_3D).
+ */
+function viewportMatchesDesiredVolumePresentation(viewport, desiredViewportInfo) {
+  const desiredType = desiredViewportInfo.getViewportType();
+  if (viewport.type !== desiredType) {
+    return false;
+  }
+  return desiredType === esm.Enums.ViewportType.ORTHOGRAPHIC || desiredType === esm.Enums.ViewportType.VOLUME_3D;
+}
 const WITH_NAVIGATION = {
   withNavigation: true,
   withOrientation: false
@@ -22508,7 +22592,33 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
         }
       });
     }
-    await viewport.setVolumes(volumeInputArray);
+    const baseVolumeInputs = filteredVolumeInputArray.map(({
+      volumeInput
+    }) => volumeInput);
+    const nextBaseVolumeIds = baseVolumeInputs.map(v => v.volumeId);
+    const existingVolumeIds = getVolumeActorReferencedIds(viewport);
+    let skippedIdenticalBaseVolumes = false;
+    if (baseVolumeInputs.length) {
+      const singleBaseViewport = nextBaseVolumeIds.length === 1;
+
+      // Only skip setVolumes() when the viewport type already matches the desired OHIF type
+      // (ORTHOGRAPHIC / VOLUME_3D); otherwise a stack → MPR switch with the same volumeId
+      // would incorrectly skip rebuilding the viewport.
+      if (singleBaseViewport && existingVolumeIds.length >= nextBaseVolumeIds.length && volumeIdPrefixesMatch(existingVolumeIds, nextBaseVolumeIds.length, nextBaseVolumeIds) && viewportMatchesDesiredVolumePresentation(viewport, viewportInfo)) {
+        // Same primary volume already loaded (e.g. labelmap / extra actors after it) — avoid
+        // setVolumes(), which tears down all actors and blanks MPR during SEG hydrate.
+        skippedIdenticalBaseVolumes = true;
+      } else if (existingVolumeIds.length && nextBaseVolumeIds.length > existingVolumeIds.length && volumeIdPrefixesMatch(existingVolumeIds, existingVolumeIds.length, nextBaseVolumeIds) && typeof viewport.addVolumes === 'function') {
+        const toAdd = baseVolumeInputs.slice(existingVolumeIds.length);
+        if (toAdd.length) {
+          await viewport.addVolumes(toAdd);
+        }
+      } else {
+        await viewport.setVolumes(baseVolumeInputs);
+      }
+    } else if (volumeInputArray.length) {
+      await viewport.setVolumes(volumeInputArray);
+    }
     await this._addOverlayRepresentations(overlayProcessingResults);
     viewport.render();
     volumesProperties.forEach(({
@@ -22521,7 +22631,10 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
       });
     });
     this.setPresentations(viewport.id, presentations);
-    if (!presentations.positionPresentation) {
+    // Presentations apply segmentation (hydrated labelmap etc.) after the render above — redraw so
+    // every orthographic/3D tile shows the updated scene (fixes MPR siblings blank after SEG hydrate).
+    viewport.render();
+    if (!presentations.positionPresentation && !skippedIdenticalBaseVolumes) {
       const imageIndex = this._getInitialImageIndexForViewport(viewportInfo);
       if (imageIndex !== undefined) {
         esm.utilities.jumpToSlice(viewport.element, {
@@ -26815,20 +26928,34 @@ const _getSegmentationPresentationId = ({
   if (!viewport?.viewportOptions || !viewport.displaySetInstanceUIDs?.length) {
     return;
   }
+  const {
+    displaySetService
+  } = servicesManager.services;
   const {
     displaySetInstanceUIDs,
     viewportOptions
   } = viewport;
+
+  // Match keys used by updateStoredSegmentationPresentation (referenced volume only).
+  // Including overlay UIDs (e.g. SEG) produced ids like "MR&SEG" while the store
+  // entry is under "MR", so hydrated segmentations never applied and viewports could mis-render.
+  const nonOverlayUIDs = displaySetInstanceUIDs.filter(uid => {
+    const ds = displaySetService.getDisplaySetByUID(uid);
+    return ds && !ds.isOverlayDisplaySet;
+  });
+  if (!nonOverlayUIDs.length) {
+    return;
+  }
   let orientation = viewportOptions.orientation;
   if (!orientation) {
     // Calculate orientation from the viewport sample image
-    const displaySet = servicesManager.services.displaySetService.getDisplaySetByUID(displaySetInstanceUIDs[0]);
-    const sampleImage = displaySet.images?.[0];
+    const displaySet = displaySetService.getDisplaySetByUID(nonOverlayUIDs[0]);
+    const sampleImage = displaySet?.images?.[0];
     const imageOrientationPatient = sampleImage?.ImageOrientationPatient;
     orientation = getViewportOrientationFromImageOrientationPatient(imageOrientationPatient);
   }
   const segmentationPresentationArr = [];
-  segmentationPresentationArr.push(...displaySetInstanceUIDs);
+  segmentationPresentationArr.push(...nonOverlayUIDs);
 
   // Uncomment if unique indexing is needed
   // addUniqueIndex(

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)));