@ohif/app 3.8.0-beta.73 → 3.8.0-beta.75

package/dist/{595.bundle.e8ff2d0672cb195d4ab8.js → 896.bundle.2635ab03af0b472f6e39.js}

@@ -1,5 +1,5 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[595],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[896],{
 
 /***/ 76255:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -12,7 +12,7 @@
 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(41766);
 /* harmony import */ var prop_types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(11374);
 /* harmony import */ var prop_types__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(prop_types__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _ohif_ui__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(48804);
+/* harmony import */ var _ohif_ui__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5085);
 /* harmony import */ var _services_ViewportActionCornersService_ViewportActionCornersService__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(77954);
 
 
@@ -141,7 +141,7 @@ const useViewportActionCornersContext = () => (0,react__WEBPACK_IMPORTED_MODULE_
 
 /***/ }),
 
-/***/ 92595:
+/***/ 72896:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -175,14 +175,14 @@ __webpack_require__.r(types_namespaceObject);
 
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
 var react = __webpack_require__(41766);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 383 modules
-var esm = __webpack_require__(50719);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js + 16 modules
-var dist_esm = __webpack_require__(20767);
-// EXTERNAL MODULE: ../../core/src/index.ts + 68 modules
-var src = __webpack_require__(85073);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 327 modules
+var esm = __webpack_require__(44656);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js + 18 modules
+var dist_esm = __webpack_require__(24542);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/index.js + 13 modules
 var streaming_image_volume_loader_dist_esm = __webpack_require__(23722);
+// EXTERNAL MODULE: ../../core/src/index.ts + 70 modules
+var src = __webpack_require__(55411);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/dynamic-import/cornerstoneDICOMImageLoader.min.js
 var cornerstoneDICOMImageLoader_min = __webpack_require__(54578);
 var cornerstoneDICOMImageLoader_min_default = /*#__PURE__*/__webpack_require__.n(cornerstoneDICOMImageLoader_min);
@@ -221,6 +221,7 @@ function initWADOImageLoader(userAuthenticationService, appConfig, extensionMana
   (cornerstoneDICOMImageLoader_min_default()).external.cornerstone = esm;
   (cornerstoneDICOMImageLoader_min_default()).external.dicomParser = (dicomParser_min_default());
   registerVolumeLoader('cornerstoneStreamingImageVolume', streaming_image_volume_loader_dist_esm/* cornerstoneStreamingImageVolumeLoader */.FC);
+  registerVolumeLoader('cornerstoneStreamingDynamicImageVolume', streaming_image_volume_loader_dist_esm/* cornerstoneStreamingDynamicImageVolumeLoader */.Mr);
   cornerstoneDICOMImageLoader_min_default().configure({
     decodeConfig: {
       // !! IMPORTANT !!
@@ -259,8 +260,8 @@ function destroy() {
   }
   webWorkers.length = 0;
 }
-// EXTERNAL MODULE: ../../ui/src/index.js + 542 modules
-var ui_src = __webpack_require__(48804);
+// EXTERNAL MODULE: ../../ui/src/index.js + 785 modules
+var ui_src = __webpack_require__(5085);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/utils/callInputDialog.tsx
 
 
@@ -836,6 +837,7 @@ function initCornerstoneTools(configuration = {}) {
   (0,dist_esm.addTool)(dist_esm.MIPJumpToClickTool);
   (0,dist_esm.addTool)(dist_esm.LengthTool);
   (0,dist_esm.addTool)(dist_esm.RectangleROITool);
+  (0,dist_esm.addTool)(dist_esm.RectangleROIThresholdTool);
   (0,dist_esm.addTool)(dist_esm.EllipticalROITool);
   (0,dist_esm.addTool)(dist_esm.CircleROITool);
   (0,dist_esm.addTool)(dist_esm.BidirectionalTool);
@@ -846,12 +848,14 @@ function initCornerstoneTools(configuration = {}) {
   (0,dist_esm.addTool)(dist_esm.MagnifyTool);
   (0,dist_esm.addTool)(dist_esm.CrosshairsTool);
   (0,dist_esm.addTool)(dist_esm.SegmentationDisplayTool);
+  (0,dist_esm.addTool)(dist_esm.RectangleScissorsTool);
+  (0,dist_esm.addTool)(dist_esm.SphereScissorsTool);
+  (0,dist_esm.addTool)(dist_esm.CircleScissorsTool);
+  (0,dist_esm.addTool)(dist_esm.BrushTool);
+  (0,dist_esm.addTool)(dist_esm.PaintFillTool);
   (0,dist_esm.addTool)(dist_esm.ReferenceLinesTool);
   (0,dist_esm.addTool)(tools_CalibrationLineTool);
   (0,dist_esm.addTool)(dist_esm.TrackballRotateTool);
-  (0,dist_esm.addTool)(dist_esm.CircleScissorsTool);
-  (0,dist_esm.addTool)(dist_esm.RectangleScissorsTool);
-  (0,dist_esm.addTool)(dist_esm.SphereScissorsTool);
   (0,dist_esm.addTool)(tools_ImageOverlayViewerTool);
   (0,dist_esm.addTool)(dist_esm.AdvancedMagnifyTool);
   (0,dist_esm.addTool)(dist_esm.UltrasoundDirectionalTool);
@@ -885,6 +889,7 @@ const toolNames = {
   DragProbe: dist_esm.DragProbeTool.toolName,
   Probe: dist_esm.ProbeTool.toolName,
   RectangleROI: dist_esm.RectangleROITool.toolName,
+  RectangleROIThreshold: dist_esm.RectangleROIThresholdTool.toolName,
   EllipticalROI: dist_esm.EllipticalROITool.toolName,
   CircleROI: dist_esm.CircleROITool.toolName,
   Bidirectional: dist_esm.BidirectionalTool.toolName,
@@ -893,6 +898,8 @@ const toolNames = {
   Magnify: dist_esm.MagnifyTool.toolName,
   Crosshairs: dist_esm.CrosshairsTool.toolName,
   SegmentationDisplay: dist_esm.SegmentationDisplayTool.toolName,
+  Brush: dist_esm.BrushTool.toolName,
+  PaintFill: dist_esm.PaintFillTool.toolName,
   ReferenceLines: dist_esm.ReferenceLinesTool.toolName,
   CalibrationLine: tools_CalibrationLineTool.toolName,
   TrackballRotateTool: dist_esm.TrackballRotateTool.toolName,
@@ -2841,6 +2848,13 @@ const initMeasurementService = (measurementService, displaySetService, cornersto
 
   /* Mappings */
   measurementService.addMapping(csTools3DVer1MeasurementSource, 'Length', Length.matchingCriteria, Length.toAnnotation, Length.toMeasurement);
+  measurementService.addMapping(csTools3DVer1MeasurementSource, 'Crosshairs', Length.matchingCriteria, () => {
+    console.warn('Crosshairs mapping not implemented.');
+    return {};
+  }, () => {
+    console.warn('Crosshairs mapping not implemented.');
+    return {};
+  });
   measurementService.addMapping(csTools3DVer1MeasurementSource, 'Bidirectional', Bidirectional.matchingCriteria, Bidirectional.toAnnotation, Bidirectional.toMeasurement);
   measurementService.addMapping(csTools3DVer1MeasurementSource, 'EllipticalROI', EllipticalROI.matchingCriteria, EllipticalROI.toAnnotation, EllipticalROI.toMeasurement);
   measurementService.addMapping(csTools3DVer1MeasurementSource, 'CircleROI', CircleROI.matchingCriteria, CircleROI.toAnnotation, CircleROI.toMeasurement);
@@ -3124,7 +3138,61 @@ const connectMeasurementServiceToTools = (measurementService, cornerstoneViewpor
 
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/initCineService.ts
 
-function initCineService(cineService) {
+
+function _getVolumesFromViewport(viewport) {
+  return viewport ? viewport.getActors().map(actor => esm.cache.getVolume(actor.uid)) : [];
+}
+function _getVolumeFromViewport(viewport) {
+  const volumes = _getVolumesFromViewport(viewport);
+  const dynamicVolume = volumes.find(volume => volume.isDynamicVolume());
+  return dynamicVolume ?? volumes[0];
+}
+
+/**
+ * Return all viewports that needs to be synchronized with the source
+ * viewport passed as parameter when cine is updated.
+ * @param servicesManager ServiceManager
+ * @param srcViewportIndex Source viewport index
+ * @returns array with viewport information.
+ */
+function _getSyncedViewports(servicesManager, srcViewportId) {
+  const {
+    viewportGridService,
+    cornerstoneViewportService
+  } = servicesManager.services;
+  const {
+    viewports: viewportsStates
+  } = viewportGridService.getState();
+  const srcViewportState = viewportsStates.get(srcViewportId);
+  if (srcViewportState?.viewportOptions?.viewportType !== 'volume') {
+    return [];
+  }
+  const srcViewport = cornerstoneViewportService.getCornerstoneViewport(srcViewportId);
+  const srcVolume = srcViewport ? _getVolumeFromViewport(srcViewport) : null;
+  if (!srcVolume?.isDynamicVolume()) {
+    return [];
+  }
+  const {
+    volumeId: srcVolumeId
+  } = srcVolume;
+  return Array.from(viewportsStates.values()).filter(({
+    viewportId
+  }) => {
+    const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+    return viewportId !== srcViewportId && viewport?.hasVolumeId(srcVolumeId);
+  }).map(({
+    viewportId
+  }) => ({
+    viewportId
+  }));
+}
+function initCineService(servicesManager) {
+  const {
+    cineService
+  } = servicesManager.services;
+  const getSyncedViewports = viewportId => {
+    return _getSyncedViewports(servicesManager, viewportId);
+  };
   const playClip = (element, playClipOptions) => {
     return dist_esm.utilities.cine.playClip(element, playClipOptions);
   };
@@ -3132,6 +3200,7 @@ function initCineService(cineService) {
     return dist_esm.utilities.cine.stopClip(element);
   };
   cineService.setServiceImplementation({
+    getSyncedViewports,
     playClip,
     stopClip
   });
@@ -3525,6 +3594,33 @@ function interleaveTopToBottom({
       interleaveTopToBottom_volumeIdMapsToLoad.set(volumeId, metadata.SeriesInstanceUID);
     }
   }
+  const filteredMatchDetails = [];
+  const displaySetsToLoad = new Set();
+
+  // Check all viewports that have a displaySet to be loaded. In some cases
+  // (eg: line chart viewports which is not a Cornerstone viewport) the
+  // displaySet is created on the client and there are no instances to be
+  // downloaded. For those viewports the displaySet may have the `skipLoading`
+  // option set to true otherwise it may block the download of all other
+  // instances resulting in blank viewports.
+  Array.from(matchDetails.values()).forEach(curMatchDetails => {
+    const {
+      displaySetsInfo
+    } = curMatchDetails;
+    let numDisplaySetsToLoad = 0;
+    displaySetsInfo.forEach(({
+      displaySetInstanceUID,
+      displaySetOptions
+    }) => {
+      if (!displaySetOptions?.options?.skipLoading) {
+        numDisplaySetsToLoad++;
+        displaySetsToLoad.add(displaySetInstanceUID);
+      }
+    });
+    if (numDisplaySetsToLoad) {
+      filteredMatchDetails.push(curMatchDetails);
+    }
+  });
 
   /**
    * The following is checking if all the viewports that were matched in the HP has been
@@ -3539,18 +3635,19 @@ function interleaveTopToBottom({
    * listen to it and as the other viewports are created we can set the volumes for them
    * since volumes are already started loading.
    */
-  if (matchDetails.size !== interleaveTopToBottom_viewportIdVolumeInputArrayMap.size) {
+  if (filteredMatchDetails.length !== interleaveTopToBottom_viewportIdVolumeInputArrayMap.size) {
     return;
   }
 
   // Check if all the matched volumes are loaded
   for (const [_, details] of displaySetsMatchDetails.entries()) {
     const {
-      SeriesInstanceUID
+      SeriesInstanceUID,
+      displaySetInstanceUID
     } = details;
 
     // HangingProtocol has matched, but don't have all the volumes created yet, so return
-    if (!Array.from(interleaveTopToBottom_volumeIdMapsToLoad.values()).includes(SeriesInstanceUID)) {
+    if (displaySetsToLoad.has(displaySetInstanceUID) && !Array.from(interleaveTopToBottom_volumeIdMapsToLoad.values()).includes(SeriesInstanceUID)) {
       return;
     }
   }
@@ -3949,7 +4046,6 @@ const colormaps = [{
 
 
 
-
 const {
   registerColormap
 } = esm.utilities.colormap;
@@ -4009,7 +4105,6 @@ async function init({
     customizationService,
     uiModalService,
     uiNotificationService,
-    cineService,
     cornerstoneViewportService,
     hangingProtocolService,
     toolbarService,
@@ -4065,6 +4160,7 @@ async function init({
   });
   const metadataProvider = src/* default.classes */.Ay.classes.MetadataProvider;
   esm.volumeLoader.registerVolumeLoader('cornerstoneStreamingImageVolume', streaming_image_volume_loader_dist_esm/* cornerstoneStreamingImageVolumeLoader */.FC);
+  esm.volumeLoader.registerVolumeLoader('cornerstoneStreamingDynamicImageVolume', streaming_image_volume_loader_dist_esm/* cornerstoneStreamingDynamicImageVolumeLoader */.Mr);
   hangingProtocolService.registerImageLoadStrategy('interleaveCenter', interleaveCenterLoader);
   hangingProtocolService.registerImageLoadStrategy('interleaveTopToBottom', interleaveTopToBottom);
   hangingProtocolService.registerImageLoadStrategy('nth', interleaveNthLoader);
@@ -4081,7 +4177,7 @@ async function init({
 
   /* Measurement Service */
   this.measurementServiceSource = connectToolsToMeasurementService(servicesManager);
-  src_initCineService(cineService);
+  src_initCineService(servicesManager);
 
   // When a custom image load is performed, update the relevant viewports
   hangingProtocolService.subscribe(hangingProtocolService.EVENTS.CUSTOM_IMAGE_LOAD_PERFORMED, volumeInputArrayMap => {
@@ -4928,8 +5024,8 @@ function getCustomizationModule() {
   }];
 }
 /* harmony default export */ const src_getCustomizationModule = (getCustomizationModule);
-// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 10 modules
-var gl_matrix_esm = __webpack_require__(83636);
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
+var gl_matrix_esm = __webpack_require__(44753);
 // EXTERNAL MODULE: ../../../node_modules/html2canvas/dist/html2canvas.esm.js
 var html2canvas_esm = __webpack_require__(90445);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/utils/CornerstoneViewportDownloadForm.tsx
@@ -5457,8 +5553,6 @@ function commandsModule({
       };
       return nearbyToolData?.metadata?.toolName && isAnnotation(nearbyToolData.metadata.toolName) ? nearbyToolData : null;
     },
-    // Measurement tool commands:
-
     /** Delete the given measurement */
     deleteMeasurement: ({
       uid
@@ -5651,6 +5745,51 @@ function commandsModule({
       const renderingEngine = cornerstoneViewportService.getRenderingEngine();
       renderingEngine.render();
     },
+    toggleEnabledDisabledToolbar({
+      value,
+      itemId,
+      toolGroupIds = []
+    }) {
+      const toolName = itemId || value;
+      toolGroupIds = toolGroupIds.length ? toolGroupIds : toolGroupService.getToolGroupIds();
+      toolGroupIds.forEach(toolGroupId => {
+        const toolGroup = toolGroupService.getToolGroup(toolGroupId);
+        if (!toolGroup || !toolGroup.hasTool(toolName)) {
+          return;
+        }
+        const toolIsEnabled = toolGroup.getToolOptions(toolName).mode === dist_esm.Enums.ToolModes.Enabled;
+        toolIsEnabled ? toolGroup.setToolDisabled(toolName) : toolGroup.setToolEnabled(toolName);
+      });
+    },
+    toggleActiveDisabledToolbar({
+      value,
+      itemId,
+      toolGroupIds = []
+    }) {
+      const toolName = itemId || value;
+      toolGroupIds = toolGroupIds.length ? toolGroupIds : toolGroupService.getToolGroupIds();
+      toolGroupIds.forEach(toolGroupId => {
+        const toolGroup = toolGroupService.getToolGroup(toolGroupId);
+        if (!toolGroup || !toolGroup.hasTool(toolName)) {
+          return;
+        }
+        const toolIsActive = toolGroup.getToolOptions(toolName).mode === dist_esm.Enums.ToolModes.Active;
+        toolIsActive ? toolGroup.setToolDisabled(toolName) : actions.setToolActive({
+          toolName,
+          toolGroupId
+        });
+
+        // we should set the previously active tool to active after we set the
+        // current tool disabled
+        if (toolIsActive) {
+          const prevToolName = toolGroup.getPrevActivePrimaryToolName();
+          actions.setToolActive({
+            toolName: prevToolName,
+            toolGroupId
+          });
+        }
+      });
+    },
     setToolActiveToolbar: ({
       value,
       itemId,
@@ -6026,6 +6165,21 @@ function commandsModule({
         viewportId
       });
     },
+    updateVolumeData: ({
+      volume
+    }) => {
+      // update vtkOpenGLTexture and imageData of computed volume
+      const {
+        imageData,
+        vtkOpenGLTexture
+      } = volume;
+      const numSlices = imageData.getDimensions()[2];
+      const slicesToUpdate = [...Array(numSlices).keys()];
+      slicesToUpdate.forEach(i => {
+        vtkOpenGLTexture.setUpdatedFrame(i);
+      });
+      imageData.modified();
+    },
     attachProtocolViewportDataListener: ({
       protocol,
       stageIndex
@@ -6338,6 +6492,15 @@ function commandsModule({
     },
     toggleSynchronizer: {
       commandFn: actions.toggleSynchronizer
+    },
+    updateVolumeData: {
+      commandFn: actions.updateVolumeData
+    },
+    toggleEnabledDisabledToolbar: {
+      commandFn: actions.toggleEnabledDisabledToolbar
+    },
+    toggleActiveDisabledToolbar: {
+      commandFn: actions.toggleActiveDisabledToolbar
     }
   };
   return {
@@ -7398,7 +7561,7 @@ function getToolbarModule({
         return;
       }
       const displaySets = displaySetUIDs.map(displaySetService.getDisplaySetByUID);
-      const isUS = displaySets.some(displaySet => displaySet.Modality === 'US');
+      const isUS = displaySets.some(displaySet => displaySet?.Modality === 'US');
       if (!isUS) {
         return {
           disabled: true,
@@ -7483,13 +7646,16 @@ function getToolNameForButton(button) {
   return props?.id ?? button.id;
 }
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ToolGroupService/ToolGroupService.ts
-var _class;
+var _ToolGroupService;
+
 
 
 
 const ToolGroupService_EVENTS = {
   VIEWPORT_ADDED: 'event::cornerstone::toolgroupservice:viewportadded',
-  TOOLGROUP_CREATED: 'event::cornerstone::toolgroupservice:toolgroupcreated'
+  TOOLGROUP_CREATED: 'event::cornerstone::toolgroupservice:toolgroupcreated',
+  TOOL_ACTIVATED: 'event::cornerstone::toolgroupservice:toolactivated',
+  PRIMARY_TOOL_ACTIVATED: 'event::cornerstone::toolgroupservice:primarytoolactivated'
 };
 class ToolGroupService {
   constructor(serviceManager) {
@@ -7500,19 +7666,42 @@ class ToolGroupService {
      */
     this.listeners = void 0;
     this.EVENTS = void 0;
+    this._onToolActivated = evt => {
+      const {
+        toolGroupId,
+        toolName,
+        toolBindingsOptions
+      } = evt.detail;
+      const isPrimaryTool = toolBindingsOptions.bindings?.some(binding => binding.mouseButton === dist_esm.Enums.MouseBindings.Primary);
+      const callbackProps = {
+        toolGroupId,
+        toolName,
+        toolBindingsOptions
+      };
+      this._broadcastEvent(ToolGroupService_EVENTS.TOOL_ACTIVATED, callbackProps);
+      if (isPrimaryTool) {
+        this._broadcastEvent(ToolGroupService_EVENTS.PRIMARY_TOOL_ACTIVATED, callbackProps);
+      }
+    };
     const {
       cornerstoneViewportService,
-      viewportGridService
+      viewportGridService,
+      uiNotificationService
     } = serviceManager.services;
     this.cornerstoneViewportService = cornerstoneViewportService;
     this.viewportGridService = viewportGridService;
+    this.uiNotificationService = uiNotificationService;
     this.listeners = {};
     this.EVENTS = ToolGroupService_EVENTS;
     Object.assign(this, src/* pubSubServiceInterface */.Ml);
+    this._init();
   }
   onModeExit() {
     this.destroy();
   }
+  _init() {
+    esm.eventTarget.addEventListener(dist_esm.Enums.Events.TOOL_ACTIVATED, this._onToolActivated);
+  }
 
   /**
    * Retrieves a tool group from the ToolGroupManager by tool group ID.
@@ -7559,6 +7748,7 @@ class ToolGroupService {
   destroy() {
     dist_esm.ToolGroupManager.destroy();
     this.toolGroupIds = new Set();
+    esm.eventTarget.removeEventListener(dist_esm.Enums.Events.TOOL_ACTIVATED, this._onToolActivated);
   }
   destroyToolGroup(toolGroupId) {
     dist_esm.ToolGroupManager.destroyToolGroup(toolGroupId);
@@ -7648,6 +7838,9 @@ class ToolGroupService {
     const toolInstance = toolGroup.getToolInstance(toolName);
     toolInstance.configuration = config;
   }
+  getActivePrimaryMouseButtonTool(toolGroupId) {
+    return this.getToolGroup(toolGroupId)?.getActivePrimaryMouseButtonTool();
+  }
   _setToolsMode(toolGroup, tools) {
     const {
       active,
@@ -7719,21 +7912,21 @@ class ToolGroupService {
     }
   }
 }
-_class = ToolGroupService;
+_ToolGroupService = ToolGroupService;
 ToolGroupService.REGISTRATION = {
   name: 'toolGroupService',
   altName: 'ToolGroupService',
   create: ({
     servicesManager
   }) => {
-    return new _class(servicesManager);
+    return new _ToolGroupService(servicesManager);
   }
 };
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ToolGroupService/index.js
 
 /* harmony default export */ const services_ToolGroupService = (ToolGroupService);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/SyncGroupService/SyncGroupService.ts
-var SyncGroupService_class;
+var _SyncGroupService;
 
 
 
@@ -7881,14 +8074,14 @@ class SyncGroupService {
     });
   }
 }
-SyncGroupService_class = SyncGroupService;
+_SyncGroupService = SyncGroupService;
 SyncGroupService.REGISTRATION = {
   name: 'syncGroupService',
   altName: 'SyncGroupService',
   create: ({
     servicesManager
   }) => {
-    return new SyncGroupService_class(servicesManager);
+    return new _SyncGroupService(servicesManager);
   }
 };
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/SyncGroupService/index.js
@@ -7978,7 +8171,7 @@ function mapROIContoursToRTStructData(structureSet, rtDisplaySetUID) {
   });
 }
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
-var SegmentationService_class;
+var _SegmentationService;
 
 
 
@@ -9195,7 +9388,9 @@ class SegmentationService extends src/* PubSubService */.Rc {
     const {
       colorLUTIndex
     } = segmentation;
-    this._removeSegmentationFromCornerstone(segmentationId);
+    const {
+      updatedToolGroupIds
+    } = this._removeSegmentationFromCornerstone(segmentationId);
 
     // Delete associated colormap
     // Todo: bring this back
@@ -9211,7 +9406,9 @@ class SegmentationService extends src/* PubSubService */.Rc {
         const {
           id
         } = remainingHydratedSegmentations[0];
-        this._setActiveSegmentationForToolGroup(id, this._getApplicableToolGroupId(), false);
+        updatedToolGroupIds.forEach(toolGroupId => {
+          this._setActiveSegmentationForToolGroup(id, toolGroupId, false);
+        });
       }
     }
     this._setDisplaySetIsHydrated(segmentationId, false);
@@ -9438,6 +9635,7 @@ class SegmentationService extends src/* PubSubService */.Rc {
     const removeFromCache = true;
     const segmentationState = dist_esm.segmentation.state;
     const sourceSegState = segmentationState.getSegmentation(segmentationId);
+    const updatedToolGroupIds = new Set();
     if (!sourceSegState) {
       return;
     }
@@ -9448,6 +9646,7 @@ class SegmentationService extends src/* PubSubService */.Rc {
       segmentationRepresentations.forEach(representation => {
         if (representation.segmentationId === segmentationId) {
           UIDsToRemove.push(representation.segmentationRepresentationUID);
+          updatedToolGroupIds.add(toolGroupId);
         }
       });
 
@@ -9461,6 +9660,9 @@ class SegmentationService extends src/* PubSubService */.Rc {
     if (removeFromCache && esm.cache.getVolumeLoadObject(segmentationId)) {
       esm.cache.removeVolumeLoadObject(segmentationId);
     }
+    return {
+      updatedToolGroupIds: Array.from(updatedToolGroupIds)
+    };
   }
   _updateCornerstoneSegmentations({
     segmentationId,
@@ -9503,14 +9705,14 @@ class SegmentationService extends src/* PubSubService */.Rc {
     }
   }
 }
-SegmentationService_class = SegmentationService;
+_SegmentationService = SegmentationService;
 SegmentationService.REGISTRATION = {
   name: 'segmentationService',
   altName: 'SegmentationService',
   create: ({
     servicesManager
   }) => {
-    return new SegmentationService_class({
+    return new _SegmentationService({
       servicesManager
     });
   }
@@ -9540,7 +9742,7 @@ function getCornerstoneViewportType(viewportType) {
   throw new Error(`Invalid viewport type: ${viewportType}. Valid types are: stack, volume`);
 }
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/CornerstoneCacheService/CornerstoneCacheService.ts
-var CornerstoneCacheService_class;
+var _CornerstoneCacheService;
 
 
 const CornerstoneCacheService_VOLUME_LOADER_SCHEME = 'cornerstoneStreamingImageVolume';
@@ -9670,7 +9872,8 @@ class CornerstoneCacheService {
         displaySetInstanceUID: displaySet.displaySetInstanceUID,
         volume,
         volumeId,
-        imageIds: volumeImageIds
+        imageIds: volumeImageIds,
+        isDynamicVolume: displaySet.isDynamicVolume
       });
     }
     return {
@@ -9694,7 +9897,7 @@ class CornerstoneCacheService {
       const segDisplaySetInstanceUID = segmentation.displaySetInstanceUID;
       const segDisplaySet = displaySetService.getDisplaySetByUID(segDisplaySetInstanceUID);
       const instance = segDisplaySet.instances?.[0] || segDisplaySet.instance;
-      const shouldDisplaySeg = segmentationService.shouldRenderSegmentation(viewportDisplaySetInstanceUIDs, instance.FrameOfReferenceUID);
+      const shouldDisplaySeg = segmentationService.shouldRenderSegmentation(viewportDisplaySetInstanceUIDs, instance?.FrameOfReferenceUID || segDisplaySet.FrameOfReferenceUID);
       if (shouldDisplaySeg) {
         return true;
       }
@@ -9708,14 +9911,14 @@ class CornerstoneCacheService {
     return stackImageIds;
   }
 }
-CornerstoneCacheService_class = CornerstoneCacheService;
+_CornerstoneCacheService = CornerstoneCacheService;
 CornerstoneCacheService.REGISTRATION = {
   name: 'cornerstoneCacheService',
   altName: 'CornerstoneCacheService',
   create: ({
     servicesManager
   }) => {
-    return new CornerstoneCacheService_class(servicesManager);
+    return new _CornerstoneCacheService(servicesManager);
   }
 };
 /* harmony default export */ const CornerstoneCacheService_CornerstoneCacheService = (CornerstoneCacheService);
@@ -9965,7 +10168,7 @@ var JumpPresets = /*#__PURE__*/function (JumpPresets) {
 }(JumpPresets || {});
 /* harmony default export */ const utils_JumpPresets = (JumpPresets);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts
-var CornerstoneViewportService_class;
+var _CornerstoneViewportService;
 
 
 
@@ -9973,7 +10176,8 @@ var CornerstoneViewportService_class;
 
 
 const CornerstoneViewportService_EVENTS = {
-  VIEWPORT_DATA_CHANGED: 'event::cornerstoneViewportService:viewportDataChanged'
+  VIEWPORT_DATA_CHANGED: 'event::cornerstoneViewportService:viewportDataChanged',
+  VIEWPORT_VOLUMES_CHANGED: 'event::cornerstoneViewportService:viewportVolumesChanged'
 };
 
 /**
@@ -10672,6 +10876,9 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
       });
     }
     viewport.render();
+    this._broadcastEvent(this.EVENTS.VIEWPORT_VOLUMES_CHANGED, {
+      viewportInfo
+    });
   }
   _addSegmentationRepresentationToToolGroupIfNecessary(displaySetInstanceUIDs, viewport) {
     const {
@@ -10889,14 +11096,14 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
     }, this.gridResizeDelay);
   }
 }
-CornerstoneViewportService_class = CornerstoneViewportService;
+_CornerstoneViewportService = CornerstoneViewportService;
 CornerstoneViewportService.REGISTRATION = {
   name: 'cornerstoneViewportService',
   altName: 'CornerstoneViewportService',
   create: ({
     servicesManager
   }) => {
-    return new CornerstoneViewportService_class(servicesManager);
+    return new _CornerstoneViewportService(servicesManager);
   }
 };
 /* harmony default export */ const ViewportService_CornerstoneViewportService = (CornerstoneViewportService);
@@ -10908,7 +11115,7 @@ let ChangeTypes = /*#__PURE__*/function (ChangeTypes) {
   return ChangeTypes;
 }({});
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ColorbarService/ColorbarService.ts
-var ColorbarService_class;
+var _ColorbarService;
 
 
 
@@ -11137,7 +11344,7 @@ class ColorbarService extends src/* PubSubService */.Rc {
     return containers;
   }
 }
-ColorbarService_class = ColorbarService;
+_ColorbarService = ColorbarService;
 ColorbarService.EVENTS = {
   STATE_CHANGED: 'event::ColorbarService:stateChanged'
 };
@@ -11175,7 +11382,7 @@ ColorbarService.defaultTickStyles = {
 ColorbarService.REGISTRATION = {
   name: 'colorbarService',
   create: () => {
-    return new ColorbarService_class();
+    return new _ColorbarService();
   }
 };
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ColorbarService/index.ts
@@ -11368,6 +11575,403 @@ const id = package_namespaceObject.UU;
 var ViewportActionCornersService = __webpack_require__(77954);
 // EXTERNAL MODULE: ../../../extensions/cornerstone/src/contextProviders/ViewportActionCornersProvider.tsx
 var ViewportActionCornersProvider = __webpack_require__(76255);
+// EXTERNAL MODULE: ../../../node_modules/lodash.debounce/index.js
+var lodash_debounce = __webpack_require__(14771);
+var lodash_debounce_default = /*#__PURE__*/__webpack_require__.n(lodash_debounce);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps.js + 1 modules
+var ColorMaps = __webpack_require__(12882);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/components/ViewportWindowLevel/getViewportVolumeHistogram.ts
+
+const workerManager = (0,esm.getWebWorkerManager)();
+const options = {
+  // maxWorkerInstances: 1,
+  // overwrite: false
+  autoTerminationOnIdle: 1000
+};
+
+// Register the task
+const workerFn = () => {
+  return new Worker(new URL(/* worker import */ __webpack_require__.p + __webpack_require__.u(54), __webpack_require__.b), {
+    name: 'histogram-worker' // name used by the browser to name the worker
+  });
+};
+workerManager.registerWorker('histogram-worker', workerFn, options);
+const getViewportVolumeHistogram = async (viewport, volume, options) => {
+  if (!volume?.loadStatus.loaded) {
+    return undefined;
+  }
+  const volumeImageData = viewport.getImageData(volume.volumeId);
+  if (!volumeImageData) {
+    return undefined;
+  }
+  let scalarData = volume.scalarData;
+  let prevTimePoint;
+  if (volume.numTimePoints > 1) {
+    prevTimePoint = volume.timePointIndex;
+    const middleTimePoint = Math.round(volume.numTimePoints / 2);
+    volume.timePointIndex = middleTimePoint;
+    scalarData = volume.getScalarData(middleTimePoint);
+  }
+  const {
+    dimensions,
+    origin,
+    direction,
+    spacing
+  } = volume;
+  const range = await workerManager.executeTask('histogram-worker', 'getRange', {
+    dimensions,
+    origin,
+    direction,
+    spacing,
+    scalarData
+  });
+
+  // after we calculate the range let's reset the timePointIndex
+  if (volume.numTimePoints > 1) {
+    volume.timePointIndex = prevTimePoint;
+  }
+  const {
+    minimum: min,
+    maximum: max
+  } = range;
+  const calcHistOptions = {
+    numBins: 256,
+    min: Math.max(min, options?.min ?? min),
+    max: Math.min(max, options?.max ?? max)
+  };
+  const histogram = await workerManager.executeTask('histogram-worker', 'calcHistogram', {
+    data: scalarData,
+    options: calcHistOptions
+  });
+  return histogram;
+};
+
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/components/ViewportWindowLevel/ViewportWindowLevel.tsx
+
+
+
+
+
+
+
+
+const {
+  Events
+} = esm.Enums;
+const ViewportWindowLevel = ({
+  servicesManager,
+  viewportId
+}) => {
+  const {
+    cornerstoneViewportService
+  } = servicesManager.services;
+  const [windowLevels, setWindowLevels] = (0,react.useState)([]);
+  const [cachedHistograms, setCachedHistograms] = (0,react.useState)({});
+
+  /**
+   * Looks for all viewports that has exactly all volumeIds passed as parameter.
+   */
+  const getViewportsWithVolumeIds = (0,react.useCallback)(volumeIds => {
+    const renderingEngine = cornerstoneViewportService.getRenderingEngine();
+    const viewports = renderingEngine.getVolumeViewports();
+    return viewports.filter(vp => {
+      const viewportVolumeIds = vp.getActors().map(actor => actor.uid);
+      return volumeIds.length === viewportVolumeIds.length && volumeIds.every(volumeId => viewportVolumeIds.includes(volumeId));
+    });
+  }, [cornerstoneViewportService]);
+  const getNodeOpacity = (volumeActor, nodeIndex) => {
+    const volumeOpacity = volumeActor.getProperty().getScalarOpacity(0);
+    const nodeValue = [];
+    volumeOpacity.getNodeValue(nodeIndex, nodeValue);
+    return nodeValue[1];
+  };
+
+  /**
+   * Checks if the opacity applied to the PET volume is something like
+   * [{x: 0, y: 0}, {x: 0.1, y: [C]}, {x: [ANY], y: [C]}] where C is a
+   * constant opacity value for all x's greater than 0.1
+   */
+  const isPetVolumeWithDefaultOpacity = (volumeId, volumeActor) => {
+    const volume = esm.cache.getVolume(volumeId);
+    if (!volume) {
+      return false;
+    }
+    const modality = volume.metadata.Modality;
+    if (modality !== 'PT') {
+      return false;
+    }
+    const volumeOpacity = volumeActor.getProperty().getScalarOpacity(0);
+
+    // It must have at least two points (0 and 0.1)
+    if (volumeOpacity.getSize() < 2) {
+      return false;
+    }
+    const node1Value = [];
+    const node2Value = [];
+    volumeOpacity.getNodeValue(0, node1Value);
+    volumeOpacity.getNodeValue(1, node2Value);
+
+    // First node must be (x:0, y:0} and the second one {x:0.1, y:any}
+    if (node1Value[0] !== 0 || node1Value[1] !== 0 || node2Value[0] !== 0.1) {
+      return false;
+    }
+    const expectedOpacity = node2Value[1];
+    const opacitySize = volumeOpacity.getSize();
+    const currentNodeValue = [];
+
+    // Any point after 0.1 must have the same opacity
+    for (let i = 2; i < opacitySize; i++) {
+      volumeOpacity.getNodeValue(i, currentNodeValue);
+      if (currentNodeValue[1] !== expectedOpacity) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  /**
+   * Checks if the opacity function has a constance opacity value for all x's
+   */
+  const isVolumeWithConstantOpacity = volumeActor => {
+    const volumeOpacity = volumeActor.getProperty().getScalarOpacity(0);
+    const opacitySize = volumeOpacity.getSize();
+    const firstNodeValue = [];
+    volumeOpacity.getNodeValue(0, firstNodeValue);
+    const firstNodeOpacity = firstNodeValue[1];
+    for (let i = 0; i < opacitySize; i++) {
+      const currentNodeValue = [];
+      volumeOpacity.getNodeValue(0, currentNodeValue);
+      if (currentNodeValue[1] !== firstNodeOpacity) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const getVolumeOpacity = (0,react.useCallback)((viewport, volumeId) => {
+    const volumeActor = viewport.getActor(volumeId).actor;
+    if (isPetVolumeWithDefaultOpacity(volumeId, volumeActor)) {
+      // Get the opacity from the second node at 0.1
+      return getNodeOpacity(volumeActor, 1);
+    } else if (isVolumeWithConstantOpacity(volumeActor)) {
+      return getNodeOpacity(volumeActor, 0);
+    }
+    return undefined;
+  }, []);
+  const getWindowLevelsData = (0,react.useCallback)(async viewportId => {
+    const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+    if (!viewport) {
+      return [];
+    }
+    const viewportInfo = cornerstoneViewportService.getViewportInfo(viewportId);
+    const volumeIds = viewport.getActors().map(actor => actor.uid);
+    const viewportProperties = viewport.getProperties();
+    const {
+      voiRange
+    } = viewportProperties;
+    const viewportVoi = voiRange ? {
+      windowWidth: voiRange.upper - voiRange.lower,
+      windowCenter: voiRange.lower + (voiRange.upper - voiRange.lower) / 2
+    } : undefined;
+    const windowLevels = await Promise.all(volumeIds.map(async (volumeId, volumeIndex) => {
+      const volume = esm.cache.getVolume(volumeId);
+      if (!volume) {
+        return null;
+      }
+      const opacity = getVolumeOpacity(viewport, volumeId);
+      const {
+        metadata,
+        scaling
+      } = volume;
+      const modality = metadata.Modality;
+
+      // TODO: find a proper way to fix the histogram
+      const options = {
+        min: modality === 'PT' ? 0.1 : -999,
+        max: modality === 'PT' ? 5 : 10000
+      };
+      const histogram = cachedHistograms[volumeId] ?? (await getViewportVolumeHistogram(viewport, volume, options));
+      const {
+        voi: displaySetVOI,
+        colormap: displaySetColormap
+      } = viewportInfo.displaySetOptions[volumeIndex];
+      let colormap;
+      if (displaySetColormap) {
+        colormap = esm.utilities.colormap.getColormap(displaySetColormap.name) ?? ColorMaps/* default */.A.getPresetByName(displaySetColormap.name);
+      }
+      const voi = !volumeIndex ? viewportVoi ?? displaySetVOI : displaySetVOI;
+      return {
+        viewportId,
+        modality,
+        volumeId,
+        volumeIndex,
+        voi,
+        histogram,
+        colormap,
+        step: scaling?.PT ? 0.05 : 1,
+        opacity,
+        showOpacitySlider: volumeIndex === 1 && opacity !== undefined
+      };
+    }));
+    const data = windowLevels.filter(Boolean);
+    return data;
+  }, [cachedHistograms, cornerstoneViewportService, getVolumeOpacity]);
+  const updateViewportHistograms = (0,react.useCallback)(() => {
+    getWindowLevelsData(viewportId).then(windowLevels => {
+      setWindowLevels(windowLevels);
+    });
+  }, [viewportId, getWindowLevelsData]);
+  const handleCornerstoneVOIModified = (0,react.useCallback)(e => {
+    const {
+      detail
+    } = e;
+    const {
+      volumeId,
+      range
+    } = detail;
+    const oldWindowLevel = windowLevels.find(wl => wl.volumeId === volumeId);
+    if (!oldWindowLevel) {
+      return;
+    }
+    const oldVOI = oldWindowLevel.voi;
+    const windowWidth = range.upper - range.lower;
+    const windowCenter = range.lower + windowWidth / 2;
+    if (windowWidth === oldVOI.windowWidth && windowCenter === oldVOI.windowCenter) {
+      return;
+    }
+    const newWindowLevel = {
+      ...oldWindowLevel,
+      voi: {
+        windowWidth,
+        windowCenter
+      }
+    };
+    setWindowLevels(windowLevels.map(windowLevel => windowLevel === oldWindowLevel ? newWindowLevel : windowLevel));
+  }, [windowLevels]);
+  const debouncedHandleCornerstoneVOIModified = (0,react.useCallback)(lodash_debounce_default()(handleCornerstoneVOIModified, 100), [handleCornerstoneVOIModified]);
+  const handleVOIChange = (0,react.useCallback)((volumeId, voi) => {
+    const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+    const newRange = {
+      lower: voi.windowCenter - voi.windowWidth / 2,
+      upper: voi.windowCenter + voi.windowWidth / 2
+    };
+    viewport.setProperties({
+      voiRange: newRange
+    }, volumeId);
+    viewport.render();
+  }, [cornerstoneViewportService, viewportId]);
+  const handleOpacityChange = (0,react.useCallback)((viewportId, _volumeIndex, volumeId, opacity) => {
+    const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+    if (!viewport) {
+      return;
+    }
+    const viewportVolumeIds = viewport.getActors().map(actor => actor.uid);
+    const viewports = getViewportsWithVolumeIds(viewportVolumeIds);
+    viewports.forEach(vp => {
+      vp.setProperties({
+        colormap: {
+          opacity
+        }
+      }, volumeId);
+      vp.render();
+    });
+  }, [getViewportsWithVolumeIds, cornerstoneViewportService]);
+
+  // Listen to windowLevels changes and caches all the new ones
+  (0,react.useEffect)(() => {
+    const newVolumeHistograms = windowLevels.filter(windowLevel => !cachedHistograms[windowLevel.volumeId] && windowLevel.histogram).reduce((volumeHistograms, windowLevel) => {
+      // If the histogram exists, add it to the volumeHistograms object
+      if (windowLevel?.histogram) {
+        volumeHistograms[windowLevel.volumeId] = windowLevel.histogram;
+      }
+      return volumeHistograms;
+    }, {});
+    if (Object.keys(newVolumeHistograms).length) {
+      setCachedHistograms(prev => ({
+        ...prev,
+        ...newVolumeHistograms
+      }));
+    }
+  }, [windowLevels, cachedHistograms]);
+
+  // Updates the histogram when the viewport index prop has changed
+  (0,react.useEffect)(() => updateViewportHistograms(), [viewportId, updateViewportHistograms]);
+
+  // Listen to cornerstone events on "eventTarget" and at the document level
+  (0,react.useEffect)(() => {
+    esm.eventTarget.addEventListener(Events.IMAGE_VOLUME_LOADING_COMPLETED, updateViewportHistograms);
+    document.addEventListener(Events.VOI_MODIFIED, debouncedHandleCornerstoneVOIModified, true);
+    return () => {
+      esm.eventTarget.removeEventListener(Events.IMAGE_VOLUME_LOADING_COMPLETED, updateViewportHistograms);
+      document.removeEventListener(Events.VOI_MODIFIED, debouncedHandleCornerstoneVOIModified, true);
+    };
+  }, [updateViewportHistograms, debouncedHandleCornerstoneVOIModified]);
+
+  // Updates the viewport when the context of the viewport has changed. This is
+  // necessary when moving across different stages because the viewport index
+  // may not change but the volumes loaded on it may change.
+  (0,react.useEffect)(() => {
+    const {
+      unsubscribe
+    } = cornerstoneViewportService.subscribe(cornerstoneViewportService.EVENTS.VIEWPORT_VOLUMES_CHANGED, ({
+      viewportInfo
+    }) => {
+      if (viewportInfo.viewportId === viewportId) {
+        updateViewportHistograms();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [viewportId, cornerstoneViewportService, updateViewportHistograms]);
+  return /*#__PURE__*/react.createElement(ui_src/* PanelSection */.aU, {
+    title: "Window Level"
+  }, windowLevels.map((windowLevel, i) => {
+    if (!windowLevel.histogram) {
+      return null;
+    }
+    return /*#__PURE__*/react.createElement(ui_src/* WindowLevel */.bL, {
+      key: windowLevel.volumeId,
+      title: `${windowLevel.modality}`,
+      histogram: windowLevel.histogram,
+      voi: windowLevel.voi,
+      step: windowLevel.step,
+      showOpacitySlider: windowLevel.showOpacitySlider,
+      colormap: windowLevel.colormap,
+      onVOIChange: voi => handleVOIChange(windowLevel.volumeId, voi),
+      opacity: windowLevel.opacity,
+      onOpacityChange: opacity => handleOpacityChange(windowLevel.viewportId, i, windowLevel.volumeId, opacity)
+    });
+  }));
+};
+ViewportWindowLevel.propTypes = {
+  servicesManager: prop_types_default().instanceOf(src/* ServicesManager */.CS),
+  viewportId: (prop_types_default()).string.isRequired
+};
+/* harmony default export */ const ViewportWindowLevel_ViewportWindowLevel = (ViewportWindowLevel);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/components/ActiveViewportWindowLevel/ActiveViewportWindowLevel.tsx
+
+
+
+
+
+const ActiveViewportWindowLevel = ({
+  servicesManager
+}) => {
+  const [viewportGrid] = (0,ui_src/* useViewportGrid */.ih)();
+  const {
+    activeViewportId
+  } = viewportGrid;
+  return /*#__PURE__*/react.createElement(react.Fragment, null, activeViewportId && /*#__PURE__*/react.createElement(ViewportWindowLevel_ViewportWindowLevel, {
+    servicesManager: servicesManager,
+    viewportId: activeViewportId
+  }));
+};
+ActiveViewportWindowLevel.propTypes = {
+  servicesManager: prop_types_default().instanceOf(src/* ServicesManager */.CS)
+};
+/* harmony default export */ const ActiveViewportWindowLevel_ActiveViewportWindowLevel = (ActiveViewportWindowLevel);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/components/ActiveViewportWindowLevel/index.js
+
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/index.tsx
 function src_extends() { src_extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return src_extends.apply(this, arguments); }
 
@@ -11397,6 +12001,14 @@ function src_extends() { src_extends = Object.assign ? Object.assign.bind() : fu
 
 
 
+
+
+const {
+  helpers: volumeLoaderHelpers
+} = streaming_image_volume_loader_dist_esm;
+const {
+  getDynamicVolumeInfo
+} = volumeLoaderHelpers ?? {};
 const Component = /*#__PURE__*/react.lazy(() => {
   return __webpack_require__.e(/* import() */ 574).then(__webpack_require__.bind(__webpack_require__, 71574));
 });
@@ -11444,6 +12056,18 @@ const cornerstoneExtension = {
     return init.call(this, props);
   },
   getToolbarModule: getToolbarModule,
+  getPanelModule({
+    servicesManager
+  }) {
+    return [{
+      name: 'activeViewportWindowLevel',
+      component: () => {
+        return /*#__PURE__*/react.createElement(ActiveViewportWindowLevel_ActiveViewportWindowLevel, {
+          servicesManager: servicesManager
+        });
+      }
+    }];
+  },
   getHangingProtocolModule: src_getHangingProtocolModule,
   getViewportModule({
     servicesManager,
@@ -11496,6 +12120,11 @@ const cornerstoneExtension = {
         toolNames: toolNames,
         Enums: dist_esm.Enums
       }
+    }, {
+      name: 'volumeLoader',
+      exports: {
+        getDynamicVolumeInfo
+      }
     }];
   }
 };
@@ -11510,9 +12139,9 @@ const cornerstoneExtension = {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _ohif_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(85073);
-/* harmony import */ var _ohif_ui__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(48804);
-var _class;
+/* harmony import */ var _ohif_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55411);
+/* harmony import */ var _ohif_ui__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5085);
+var _ViewportActionCornersService;
 
 
 class ViewportActionCornersService extends _ohif_core__WEBPACK_IMPORTED_MODULE_0__/* .PubSubService */ .Rc {
@@ -11554,7 +12183,7 @@ class ViewportActionCornersService extends _ohif_core__WEBPACK_IMPORTED_MODULE_0
     this.serviceImplementation._clear(viewportId);
   }
 }
-_class = ViewportActionCornersService;
+_ViewportActionCornersService = ViewportActionCornersService;
 ViewportActionCornersService.EVENTS = {};
 ViewportActionCornersService.LOCATIONS = _ohif_ui__WEBPACK_IMPORTED_MODULE_1__/* .ViewportActionCornersLocations */ .ld;
 ViewportActionCornersService.REGISTRATION = {
@@ -11563,7 +12192,7 @@ ViewportActionCornersService.REGISTRATION = {
   create: ({
     configuration = {}
   }) => {
-    return new _class();
+    return new _ViewportActionCornersService();
   }
 };
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ViewportActionCornersService);
@@ -11618,7 +12247,7 @@ const reset = () => {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getSOPInstanceAttributes)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(50719);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(44656);
 
 
 /**