@ohif/app 3.9.1 → 3.9.2

package/dist/{149.bundle.ce5596fc563276036744.js → 3900.bundle.3937999d1ee1f391647a.js}

@@ -1,4 +1,4 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[149],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[3900],{
 
 /***/ 97181:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -2123,6 +2123,40 @@ function triggerSegmentationRepresentationRemoved(viewportId, segmentationId, ty
 }
 
 
+/***/ }),
+
+/***/ 50409:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   B: () => (/* binding */ getColorLUT)
+/* harmony export */ });
+/* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
+
+function getColorLUT(index) {
+    const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
+    return segmentationStateManager.getColorLUT(index);
+}
+
+
+/***/ }),
+
+/***/ 70906:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   u: () => (/* binding */ getNextColorLUTIndex)
+/* harmony export */ });
+/* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
+
+function getNextColorLUTIndex() {
+    const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
+    return segmentationStateManager.getNextColorLUTIndex();
+}
+
+
 /***/ }),
 
 /***/ 33283:

package/dist/{4571.bundle.3b1691730b3c57bf4d35.js → 4571.bundle.a37be49663df2f4a2c8a.js}

@@ -1213,6 +1213,10 @@ function getPixelDataTypeFromMinMax(min, max) {
     }
     return pixelDataType || Float32Array;
 }
+function validatePixelDataType(min, max, type) {
+    const pixelDataType = getPixelDataTypeFromMinMax(min, max);
+    return pixelDataType === type;
+}
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/isColorImage.js
 /* harmony default export */ function isColorImage(photoMetricInterpretation) {
@@ -1247,87 +1251,12 @@ const imageUtils = {
     bilinear: bilinear,
     replicate: replicate,
 };
-async function decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn) {
-    const start = new Date().getTime();
-    let decodePromise = null;
-    let opts;
-    switch (transferSyntax) {
-        case '1.2.840.10008.1.2':
-        case '1.2.840.10008.1.2.1':
-            decodePromise = decoders_decodeLittleEndian(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.2':
-            decodePromise = decoders_decodeBigEndian(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.1.99':
-            decodePromise = decoders_decodeLittleEndian(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.5':
-            decodePromise = decoders_decodeRLE(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.4.50':
-            opts = {
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEGBaseline8Bit(pixelData, opts);
-            break;
-        case '1.2.840.10008.1.2.4.51':
-            decodePromise = decodeJPEGBaseline12Bit_js(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.4.57':
-            decodePromise = decoders_decodeJPEGLossless(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.4.70':
-            decodePromise = decoders_decodeJPEGLossless(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.4.80':
-            opts = {
-                signed: imageFrame.pixelRepresentation === 1,
-                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEGLS(pixelData, opts);
-            break;
-        case '1.2.840.10008.1.2.4.81':
-            opts = {
-                signed: imageFrame.pixelRepresentation === 1,
-                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEGLS(pixelData, opts);
-            break;
-        case '1.2.840.10008.1.2.4.90':
-            opts = {
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEG2000(pixelData, opts);
-            break;
-        case '1.2.840.10008.1.2.4.91':
-            opts = {
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEG2000(pixelData, opts);
-            break;
-        case '3.2.840.10008.1.2.4.96':
-        case '1.2.840.10008.1.2.4.201':
-        case '1.2.840.10008.1.2.4.202':
-        case '1.2.840.10008.1.2.4.203':
-            opts = {
-                ...imageFrame,
-            };
-            decodePromise = decodeHTJ2K(pixelData, opts);
-            break;
-        default:
-            throw new Error(`no decoder for transfer syntax ${transferSyntax}`);
-    }
-    if (!decodePromise) {
-        throw new Error('decodePromise not defined');
-    }
-    const decodedFrame = await decodePromise;
-    const postProcessed = postProcessDecodedPixels(decodedFrame, options, start, decodeConfig);
-    callbackFn?.(postProcessed);
-    return postProcessed;
-}
+const typedArrayConstructors = {
+    Uint8Array,
+    Uint16Array,
+    Int16Array,
+    Float32Array,
+};
 function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
     const shouldShift = imageFrame.pixelRepresentation !== undefined &&
         imageFrame.pixelRepresentation === 1;
@@ -1342,22 +1271,22 @@ function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
     let pixelDataArray = imageFrame.pixelData;
     imageFrame.pixelDataLength = imageFrame.pixelData.length;
     const { min: minBeforeScale, max: maxBeforeScale } = shared_getMinMax(imageFrame.pixelData);
-    const typedArrayConstructors = {
-        Uint8Array,
-        Uint16Array,
-        Int16Array,
-        Float32Array,
-    };
-    const type = options.targetBuffer?.type;
     const canRenderFloat = typeof options.allowFloatRendering !== 'undefined'
         ? options.allowFloatRendering
         : true;
-    const invalidType = isColorImage(imageFrame.photometricInterpretation) &&
+    let invalidType = isColorImage(imageFrame.photometricInterpretation) &&
         options.targetBuffer?.offset === undefined;
     const willScale = options.preScale?.enabled;
     const hasFloatRescale = willScale &&
         Object.values(options.preScale.scalingParameters).some((v) => typeof v === 'number' && !Number.isInteger(v));
     const disableScale = !options.preScale.enabled || (!canRenderFloat && hasFloatRescale);
+    const type = options.targetBuffer?.type;
+    if (type && options.preScale.enabled && !disableScale) {
+        const { rescaleSlope, rescaleIntercept } = options.preScale.scalingParameters;
+        const minAfterScale = rescaleSlope * minBeforeScale + rescaleIntercept;
+        const maxAfterScale = rescaleSlope * maxBeforeScale + rescaleIntercept;
+        invalidType = !validatePixelDataType(minAfterScale, maxAfterScale, type);
+    }
     if (type && !invalidType) {
         pixelDataArray = _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelDataArray);
     }
@@ -1484,6 +1413,87 @@ function scaleImageFrame(imageFrame, targetBuffer, TypedArrayConstructor) {
     imageFrame.pixelDataLength = imageFrame.pixelData.length;
     return imageFrame;
 }
+async function decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn) {
+    const start = new Date().getTime();
+    let decodePromise = null;
+    let opts;
+    switch (transferSyntax) {
+        case '1.2.840.10008.1.2':
+        case '1.2.840.10008.1.2.1':
+            decodePromise = decoders_decodeLittleEndian(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.2':
+            decodePromise = decoders_decodeBigEndian(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.1.99':
+            decodePromise = decoders_decodeLittleEndian(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.5':
+            decodePromise = decoders_decodeRLE(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.50':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEGBaseline8Bit(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.51':
+            decodePromise = decodeJPEGBaseline12Bit_js(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.57':
+            decodePromise = decoders_decodeJPEGLossless(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.70':
+            decodePromise = decoders_decodeJPEGLossless(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.80':
+            opts = {
+                signed: imageFrame.pixelRepresentation === 1,
+                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEGLS(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.81':
+            opts = {
+                signed: imageFrame.pixelRepresentation === 1,
+                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEGLS(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.90':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEG2000(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.91':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEG2000(pixelData, opts);
+            break;
+        case '3.2.840.10008.1.2.4.96':
+        case '1.2.840.10008.1.2.4.201':
+        case '1.2.840.10008.1.2.4.202':
+        case '1.2.840.10008.1.2.4.203':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = decodeHTJ2K(pixelData, opts);
+            break;
+        default:
+            throw new Error(`no decoder for transfer syntax ${transferSyntax}`);
+    }
+    if (!decodePromise) {
+        throw new Error('decodePromise not defined');
+    }
+    const decodedFrame = await decodePromise;
+    const postProcessed = postProcessDecodedPixels(decodedFrame, options, start, decodeConfig);
+    callbackFn?.(postProcessed);
+    return postProcessed;
+}
 const obj = {
     decodeTask({ imageFrame, transferSyntax, decodeConfig, options, pixelData, callbackFn, }) {
         return decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn);

package/dist/{5247.bundle.6dc2a50f21821b2ffdf5.js → 5247.bundle.1a1d7c27de482e4a73f3.js}

@@ -1379,8 +1379,8 @@ MicroscopyService.REGISTRATION = servicesManager => {
 
 // EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
 var dcmjs_es = __webpack_require__(5842);
-// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 114 modules
-var default_src = __webpack_require__(71520);
+// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 115 modules
+var default_src = __webpack_require__(55630);
 ;// CONCATENATED MODULE: ../../../extensions/dicom-microscopy/src/utils/DEVICE_OBSERVER_UID.js
 // We need to define a UID for this extension as a device, and it should be the same for all saves:
 

package/dist/{5252.bundle.5ec502c53a9cc877ed8d.js → 5252.bundle.f2675336275573a288d5.js}

@@ -2709,6 +2709,15 @@ const imageRetrieveMetadataProvider = {
     add: (key, payload) => {
         retrieveConfigurationState.set(key, payload);
     },
+    clone: () => {
+        return new Map(retrieveConfigurationState);
+    },
+    restore: (state) => {
+        retrieveConfigurationState.clear();
+        state.forEach((value, key) => {
+            retrieveConfigurationState.set(key, value);
+        });
+    },
     get: (type, ...queries) => {
         if (type === IMAGE_RETRIEVE_CONFIGURATION) {
             return queries
@@ -3633,7 +3642,10 @@ function calculateViewportsSpatialRegistration(viewport1, viewport2) {
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/getViewportImageCornersInWorld.js
 function getViewportImageCornersInWorld(viewport) {
-    const { imageData, dimensions } = viewport.getImageData();
+    const { imageData, dimensions } = viewport.getImageData() || {};
+    if (!imageData || !dimensions) {
+        return [];
+    }
     const { canvas } = viewport;
     const ratio = window.devicePixelRatio;
     const topLeftCanvas = [0, 0];

package/dist/{1520.bundle.97dbd9bfa83148e5334d.js → 5630.bundle.1bd2402f37597078c1a1.js}

@@ -1,7 +1,7 @@
 "use strict";
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[1520],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[5630],{
 
-/***/ 71520:
+/***/ 55630:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -29,7 +29,7 @@ __webpack_require__.d(__webpack_exports__, {
   useHangingProtocolStageIndexStore: () => (/* reexport */ useHangingProtocolStageIndexStore),
   usePatientInfo: () => (/* reexport */ hooks_usePatientInfo),
   useToggleHangingProtocolStore: () => (/* reexport */ useToggleHangingProtocolStore),
-  useToggleOneUpViewportGridStore: () => (/* reexport */ useToggleOneUpViewportGridStore/* useToggleOneUpViewportGridStore */.Y),
+  useToggleOneUpViewportGridStore: () => (/* reexport */ useToggleOneUpViewportGridStore),
   useUIStateStore: () => (/* reexport */ useUIStateStore),
   useViewportGridStore: () => (/* reexport */ useViewportGridStore),
   useViewportsByPositionStore: () => (/* reexport */ useViewportsByPositionStore),
@@ -1726,23 +1726,35 @@ function createDicomWebApi(dicomWebConfig, servicesManager) {
         naturalizedInstances.forEach(instance => {
           instance.wadoRoot = dicomWebConfig.wadoRoot;
           instance.wadoUri = dicomWebConfig.wadoUri;
-          const imageId = implementation.getImageIdsForInstance({
-            instance
-          });
+          const {
+            StudyInstanceUID,
+            SeriesInstanceUID,
+            SOPInstanceUID
+          } = instance;
+          const numberOfFrames = instance.NumberOfFrames || 1;
+          // Process all frames consistently, whether single or multiframe
+          for (let i = 0; i < numberOfFrames; i++) {
+            const frameNumber = i + 1;
+            const frameImageId = implementation.getImageIdsForInstance({
+              instance,
+              frame: frameNumber
+            });
+            // Add imageId specific mapping to this data as the URL isn't necessarily WADO-URI.
+            metadataProvider.addImageIdToUIDs(frameImageId, {
+              StudyInstanceUID,
+              SeriesInstanceUID,
+              SOPInstanceUID,
+              frameNumber: numberOfFrames > 1 ? frameNumber : undefined
+            });
+          }
 
           // Adding imageId to each instance
           // Todo: This is not the best way I can think of to let external
           // metadata handlers know about the imageId that is stored in the store
-          instance.imageId = imageId;
-
-          // Adding UIDs to metadataProvider
-          // Note: storing imageURI in metadataProvider since stack viewports
-          // will use the same imageURI
-          metadataProvider.addImageIdToUIDs(imageId, {
-            StudyInstanceUID,
-            SeriesInstanceUID: instance.SeriesInstanceUID,
-            SOPInstanceUID: instance.SOPInstanceUID
+          const imageId = implementation.getImageIdsForInstance({
+            instance
           });
+          instance.imageId = imageId;
         });
         src/* DicomMetadataStore */.H8.addInstances(naturalizedInstances, madeInClient);
       }
@@ -1964,7 +1976,7 @@ function createDicomJSONApi(dicomJsonConfig) {
               query
             } = query_string.parseUrl(instance.url);
 
-            // Add imageId specific mapping to this data as the URL isn't necessarliy WADO-URI.
+            // Add imageId specific mapping to this data as the URL isn't necessarily WADO-URI.
             DicomJSONDataSource_metadataProvider.addImageIdToUIDs(imageId, {
               StudyInstanceUID,
               SeriesInstanceUID,
@@ -2322,8 +2334,7 @@ function createDicomLocalApi(dicomLocalConfig) {
             const {
               SeriesInstanceUID
             } = aSeries;
-            const isMultiframe = aSeries.instances[0].NumberOfFrames > 1;
-            aSeries.instances.forEach((instance, index) => {
+            aSeries.instances.forEach(instance => {
               const {
                 url: imageId,
                 StudyInstanceUID,
@@ -2331,14 +2342,22 @@ function createDicomLocalApi(dicomLocalConfig) {
                 SOPInstanceUID
               } = instance;
               instance.imageId = imageId;
-
-              // Add imageId specific mapping to this data as the URL isn't necessarily WADO-URI.
-              DicomLocalDataSource_metadataProvider.addImageIdToUIDs(imageId, {
-                StudyInstanceUID,
-                SeriesInstanceUID,
-                SOPInstanceUID,
-                frameIndex: isMultiframe ? index : 1
-              });
+              const numberOfFrames = instance.NumberOfFrames || 1;
+              // Process all frames consistently, whether single or multiframe
+              for (let i = 0; i < numberOfFrames; i++) {
+                const frameNumber = i + 1;
+                const frameImageId = implementation.getImageIdsForInstance({
+                  instance,
+                  frame: frameNumber
+                });
+                // Add imageId specific mapping to this data as the URL isn't necessarily WADO-URI.
+                DicomLocalDataSource_metadataProvider.addImageIdToUIDs(frameImageId, {
+                  StudyInstanceUID,
+                  SeriesInstanceUID,
+                  SOPInstanceUID,
+                  frameNumber: numberOfFrames > 1 ? frameNumber : undefined
+                });
+              }
             });
             src/* DicomMetadataStore */.H8._broadcastEvent(EVENTS.INSTANCES_ADDED, {
               StudyInstanceUID,
@@ -2388,9 +2407,12 @@ function createDicomLocalApi(dicomLocalConfig) {
       instance,
       frame
     }) {
-      if (instance.imageId) {
-        return instance.imageId;
-      }
+      // Important: Never use instance.imageId because it might be multiframe,
+      // which would make it an invalid imageId.
+      // if (instance.imageId) {
+      //   return instance.imageId;
+      // }
+
       const {
         StudyInstanceUID,
         SeriesInstanceUID,
@@ -3056,8 +3078,8 @@ function ViewerHeader({
     hotkeyDefinitions,
     hotkeyDefaults
   } = hotkeysManager;
-  const versionNumber = "3.9.1";
-  const commitHash = "610faa5a2738da5eabc40e57e338c359f481e852";
+  const versionNumber = "3.9.2";
+  const commitHash = "e5286d9fc2449da50b738e7e6208d489cce1633e";
   const menuOptions = [{
     title: t('Header:About'),
     icon: 'info',
@@ -6495,8 +6517,21 @@ const createToggleHangingProtocolStore = set => ({
 const useToggleHangingProtocolStore = (0,zustand_esm/* create */.vt)()(useToggleHangingProtocolStore_DEBUG_STORE ? (0,middleware/* devtools */.lt)(createToggleHangingProtocolStore, {
   name: 'ToggleHangingProtocolStore'
 }) : createToggleHangingProtocolStore);
-// EXTERNAL MODULE: ../../../extensions/default/src/stores/useToggleOneUpViewportGridStore.ts
-var useToggleOneUpViewportGridStore = __webpack_require__(73325);
+;// CONCATENATED MODULE: ../../../extensions/default/src/stores/useToggleOneUpViewportGridStore.ts
+
+const useToggleOneUpViewportGridStore_PRESENTATION_TYPE_ID = 'toggleOneUpViewportGridId';
+// Stores the entire ViewportGridService getState when toggling to one up
+// (e.g. via a double click) so that it can be restored when toggling back.
+const useToggleOneUpViewportGridStore = (0,zustand_esm/* create */.vt)(set => ({
+  toggleOneUpViewportGridStore: null,
+  type: useToggleOneUpViewportGridStore_PRESENTATION_TYPE_ID,
+  setToggleOneUpViewportGridStore: state => set({
+    toggleOneUpViewportGridStore: state
+  }),
+  clearToggleOneUpViewportGridStore: () => set({
+    toggleOneUpViewportGridStore: null
+  })
+}));
 ;// CONCATENATED MODULE: ../../../extensions/default/src/commandsModule.ts
 
 
@@ -6798,7 +6833,7 @@ const commandsModule = ({
         // The viewer is in one-up. Check if there is a state to restore/toggle back to.
         const {
           toggleOneUpViewportGridStore
-        } = useToggleOneUpViewportGridStore/* useToggleOneUpViewportGridStore */.Y.getState();
+        } = useToggleOneUpViewportGridStore.getState();
         if (!toggleOneUpViewportGridStore) {
           return;
         }
@@ -6854,7 +6889,7 @@ const commandsModule = ({
         // Store the current viewport grid state so we can toggle it back later.
         const {
           setToggleOneUpViewportGridStore
-        } = useToggleOneUpViewportGridStore/* useToggleOneUpViewportGridStore */.Y.getState();
+        } = useToggleOneUpViewportGridStore.getState();
         setToggleOneUpViewportGridStore(viewportGridState);
 
         // one being toggled to one up.
@@ -9620,30 +9655,6 @@ const defaultExtension = {
 /* harmony default export */ const default_src = (defaultExtension);
 
 
-/***/ }),
-
-/***/ 73325:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Y: () => (/* binding */ useToggleOneUpViewportGridStore)
-/* harmony export */ });
-/* harmony import */ var zustand__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(95759);
-
-const PRESENTATION_TYPE_ID = 'toggleOneUpViewportGridId';
-// Stores the entire ViewportGridService getState when toggling to one up
-// (e.g. via a double click) so that it can be restored when toggling back.
-const useToggleOneUpViewportGridStore = (0,zustand__WEBPACK_IMPORTED_MODULE_0__/* .create */ .vt)(set => ({
-  toggleOneUpViewportGridStore: null,
-  type: PRESENTATION_TYPE_ID,
-  setToggleOneUpViewportGridStore: state => set({
-    toggleOneUpViewportGridStore: state
-  }),
-  clearToggleOneUpViewportGridStore: () => set({
-    toggleOneUpViewportGridStore: null
-  })
-}));
-
 /***/ })
 
 }]);