@ohif/app 3.9.0 → 3.9.2

package/dist/{3200.bundle.45b19ea468d6208f0e7e.js → 3200.bundle.ccb809fb554332d9a0f5.js}

@@ -22,8 +22,8 @@ var es = __webpack_require__(70574);
 var react_es = __webpack_require__(95261);
 // EXTERNAL MODULE: ../../ui/src/index.js + 690 modules
 var src = __webpack_require__(35647);
-// 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/measurement-tracking/src/contexts/TrackedMeasurementsContext/measurementTrackingMachine.js
 
 const RESPONSE = {
@@ -1159,8 +1159,8 @@ var src = __webpack_require__(29463);
 var ui_src = __webpack_require__(35647);
 // EXTERNAL MODULE: ../../ui-next/src/index.ts + 2483 modules
 var ui_next_src = __webpack_require__(35570);
-// 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/measurement-tracking/src/panels/PanelStudyBrowserTracking/constants/actionIcons.ts
 const defaultActionIcons = [{
   id: 'settings',
@@ -1222,6 +1222,12 @@ function PanelStudyBrowserTracking({
     customizationService
   } = servicesManager.services;
   const navigate = (0,dist/* useNavigate */.Zp)();
+  const {
+    mode: studyMode
+  } = customizationService.getCustomization('PanelStudyBrowser.studyMode', {
+    id: 'default',
+    mode: 'all'
+  });
   const {
     t
   } = (0,es/* useTranslation */.Bd)('Common');
@@ -1238,7 +1244,7 @@ function PanelStudyBrowserTracking({
     isHangingProtocolLayout
   }, viewportGridService] = (0,ui_src/* useViewportGrid */.ih)();
   const [trackedMeasurements, sendTrackedMeasurementsEvent] = (0,getContextModule/* useTrackedMeasurements */.B)();
-  const [activeTabName, setActiveTabName] = (0,react.useState)('all');
+  const [activeTabName, setActiveTabName] = (0,react.useState)(studyMode);
   const [expandedStudyInstanceUIDs, setExpandedStudyInstanceUIDs] = (0,react.useState)([...StudyInstanceUIDs]);
   const [studyDisplayList, setStudyDisplayList] = (0,react.useState)([]);
   const [hasLoadedViewports, setHasLoadedViewports] = (0,react.useState)(false);
@@ -1283,6 +1289,9 @@ function PanelStudyBrowserTracking({
   const {
     trackedSeries
   } = trackedMeasurements.context;
+  (0,react.useEffect)(() => {
+    setActiveTabName(studyMode);
+  }, [studyMode]);
 
   // ~~ studyDisplayList
   (0,react.useEffect)(() => {
@@ -1604,7 +1613,6 @@ PanelStudyBrowserTracking.propTypes = {
   getStudiesForPatientByMRN: (prop_types_default()).func.isRequired,
   requestDisplaySetCreationForStudy: (prop_types_default()).func.isRequired
 };
-/* harmony default export */ const PanelStudyBrowserTracking_PanelStudyBrowserTracking = (PanelStudyBrowserTracking);
 function getImageIdForThumbnail(displaySet, imageIds) {
   let imageId;
   if (displaySet.isDynamicVolume) {
@@ -1841,7 +1849,7 @@ function WrappedPanelStudyBrowserTracking({
   const _getStudiesForPatientByMRN = getStudiesForPatientByMRN.bind(null, dataSource);
   const _getImageSrcFromImageId = (0,react.useCallback)(_createGetImageSrcFromImageIdFn(extensionManager), []);
   const _requestDisplaySetCreationForStudy = PanelStudyBrowserTracking_requestDisplaySetCreationForStudy.bind(null, dataSource);
-  return /*#__PURE__*/react.createElement(PanelStudyBrowserTracking_PanelStudyBrowserTracking, {
+  return /*#__PURE__*/react.createElement(PanelStudyBrowserTracking, {
     servicesManager: servicesManager,
     commandsManager: commandsManager,
     dataSource: dataSource,
@@ -1912,7 +1920,8 @@ function PanelMeasurementTableTracking({
   } = (0,es/* useTranslation */.Bd)('MeasurementTable');
   const {
     measurementService,
-    customizationService
+    customizationService,
+    uiDialogService
   } = servicesManager.services;
   const [trackedMeasurements, sendTrackedMeasurementsEvent] = (0,getContextModule/* useTrackedMeasurements */.B)();
   const {
@@ -2011,7 +2020,51 @@ function PanelMeasurementTableTracking({
         variant: "ghost",
         className: "pl-0.5",
         onClick: () => {
-          measurementService.clearMeasurements();
+          uiDialogService.create({
+            id: 'delete-all-measurements',
+            centralize: true,
+            isDraggable: false,
+            showOverlay: true,
+            content: ui_src/* Dialog */.lG,
+            contentProps: {
+              title: 'Delete All Measurements',
+              body: () => /*#__PURE__*/react.createElement("div", {
+                className: "bg-primary-dark text-white"
+              }, /*#__PURE__*/react.createElement("p", null, "Are you sure you want to delete all measurements?"), /*#__PURE__*/react.createElement("p", {
+                className: "mt-2"
+              }, "This action cannot be undone.")),
+              actions: [{
+                id: 'cancel',
+                text: 'Cancel',
+                type: ui_src/* ButtonEnums.type */.Ny.NW.secondary
+              }, {
+                id: 'yes',
+                text: 'Delete All',
+                type: ui_src/* ButtonEnums.type */.Ny.NW.primary,
+                classes: ['delete-all-yes-button']
+              }],
+              onClose: () => uiDialogService.dismiss({
+                id: 'delete-all-measurements'
+              }),
+              onSubmit: async ({
+                action
+              }) => {
+                switch (action.id) {
+                  case 'yes':
+                    measurementService.clearMeasurements();
+                    uiDialogService.dismiss({
+                      id: 'delete-all-measurements'
+                    });
+                    break;
+                  case 'cancel':
+                    uiDialogService.dismiss({
+                      id: 'delete-all-measurements'
+                    });
+                    break;
+                }
+              }
+            }
+          });
         }
       }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI.Delete, null), "Delete All")));
     }

package/dist/{149.bundle.b8d177954628f4631fc0.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:
@@ -8053,12 +8087,14 @@ function _stopClip(element, options = { stopDynamicCine: true, viewportId: undef
 }
 function _stopDynamicVolumeCine(element) {
     const { viewport } = (0,dist_esm.getEnabledElement)(element);
-    const volume = _getVolumeFromViewport(viewport);
-    if (volume?.isDynamicVolume()) {
-        const dynamicCineElement = dynamicVolumesPlayingMap.get(volume.volumeId);
-        dynamicVolumesPlayingMap.delete(volume.volumeId);
-        if (dynamicCineElement && dynamicCineElement !== element) {
-            stopClip(dynamicCineElement);
+    if (viewport instanceof dist_esm.VolumeViewport) {
+        const volume = _getVolumeFromViewport(viewport);
+        if (volume?.isDynamicVolume()) {
+            const dynamicCineElement = dynamicVolumesPlayingMap.get(volume.volumeId);
+            dynamicVolumesPlayingMap.delete(volume.volumeId);
+            if (dynamicCineElement && dynamicCineElement !== element) {
+                stopClip(dynamicCineElement);
+            }
         }
     }
 }
@@ -8108,6 +8144,9 @@ function _stopClipWithData(playClipData) {
     }
 }
 function _getVolumeFromViewport(viewport) {
+    if (!(viewport instanceof dist_esm.VolumeViewport)) {
+        return undefined;
+    }
     const volumeIds = viewport.getAllVolumeIds();
     if (!volumeIds?.length) {
         return undefined;

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.03fa8aac71d4e597d708.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];