@ohif/app 3.8.0-beta.26 → 3.8.0-beta.28

package/dist/{47.bundle.3217b1b873983a6aaa43.js → 95.bundle.db9d2d504abc5dd4fdfa.js}

@@ -1,7 +1,7 @@
 "use strict";
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[47],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[95],{
 
-/***/ 32483:
+/***/ 15793:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
@@ -12,151 +12,22 @@ __webpack_require__.d(__webpack_exports__, {
 
 // UNUSED EXPORTS: Enums, StreamingDynamicImageVolume, StreamingImageVolume, cornerstoneStreamingDynamicImageVolumeLoader, helpers
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 356 modules
-var esm = __webpack_require__(63442);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 363 modules
+var esm = __webpack_require__(56959);
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 10 modules
 var gl_matrix_esm = __webpack_require__(45451);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/helpers/makeVolumeMetadata.js
-
-function makeVolumeMetadata_makeVolumeMetadata(imageIds) {
-    const imageId0 = imageIds[0];
-    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = esm.metaData.get('imagePixelModule', imageId0);
-    const voiLut = [];
-    const voiLutModule = esm.metaData.get('voiLutModule', imageId0);
-    let voiLUTFunction;
-    if (voiLutModule) {
-        const { windowWidth, windowCenter } = voiLutModule;
-        voiLUTFunction = voiLutModule?.voiLUTFunction;
-        if (Array.isArray(windowWidth)) {
-            for (let i = 0; i < windowWidth.length; i++) {
-                voiLut.push({
-                    windowWidth: windowWidth[i],
-                    windowCenter: windowCenter[i],
-                });
-            }
-        }
-        else {
-            voiLut.push({
-                windowWidth: windowWidth,
-                windowCenter: windowCenter,
-            });
-        }
-    }
-    else {
-        voiLut.push({
-            windowWidth: undefined,
-            windowCenter: undefined,
-        });
-    }
-    const { modality, seriesInstanceUID } = esm.metaData.get('generalSeriesModule', imageId0);
-    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, } = esm.metaData.get('imagePlaneModule', imageId0);
-    return {
-        BitsAllocated: bitsAllocated,
-        BitsStored: bitsStored,
-        SamplesPerPixel: samplesPerPixel,
-        HighBit: highBit,
-        PhotometricInterpretation: photometricInterpretation,
-        PixelRepresentation: pixelRepresentation,
-        Modality: modality,
-        ImageOrientationPatient: imageOrientationPatient,
-        PixelSpacing: pixelSpacing,
-        FrameOfReferenceUID: frameOfReferenceUID,
-        Columns: columns,
-        Rows: rows,
-        voiLut,
-        VOILUTFunction: voiLUTFunction,
-        SeriesInstanceUID: seriesInstanceUID,
-    };
-}
-
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/helpers/sortImageIdsAndGetSpacing.js
-
-
-function sortImageIdsAndGetSpacing_sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
-    const { imagePositionPatient: referenceImagePositionPatient } = esm.metaData.get('imagePlaneModule', imageIds[0]);
-    const refIppVec = gl_matrix_esm/* vec3.create */.R3.create();
-    const usingWadoUri = imageIds[0].split(':')[0] === 'wadouri';
-    gl_matrix_esm/* vec3.set */.R3.set(refIppVec, referenceImagePositionPatient[0], referenceImagePositionPatient[1], referenceImagePositionPatient[2]);
-    let sortedImageIds;
-    let zSpacing;
-    function getDistance(imageId) {
-        const { imagePositionPatient } = esm.metaData.get('imagePlaneModule', imageId);
-        const positionVector = gl_matrix_esm/* vec3.create */.R3.create();
-        gl_matrix_esm/* vec3.sub */.R3.sub(positionVector, referenceImagePositionPatient, imagePositionPatient);
-        return gl_matrix_esm/* vec3.dot */.R3.dot(positionVector, scanAxisNormal);
-    }
-    if (!usingWadoUri) {
-        const distanceImagePairs = imageIds.map((imageId) => {
-            const distance = getDistance(imageId);
-            return {
-                distance,
-                imageId,
-            };
-        });
-        distanceImagePairs.sort((a, b) => b.distance - a.distance);
-        sortedImageIds = distanceImagePairs.map((a) => a.imageId);
-        const numImages = distanceImagePairs.length;
-        zSpacing =
-            Math.abs(distanceImagePairs[numImages - 1].distance -
-                distanceImagePairs[0].distance) /
-                (numImages - 1);
-    }
-    else {
-        const prefetchedImageIds = [
-            imageIds[0],
-            imageIds[Math.floor(imageIds.length / 2)],
-        ];
-        sortedImageIds = imageIds;
-        const firstImageDistance = getDistance(prefetchedImageIds[0]);
-        const middleImageDistance = getDistance(prefetchedImageIds[1]);
-        if (firstImageDistance - middleImageDistance < 0) {
-            sortedImageIds.reverse();
-        }
-        const metadataForMiddleImage = esm.metaData.get('imagePlaneModule', prefetchedImageIds[1]);
-        if (!metadataForMiddleImage) {
-            throw new Error('Incomplete metadata required for volume construction.');
-        }
-        const positionVector = gl_matrix_esm/* vec3.create */.R3.create();
-        gl_matrix_esm/* vec3.sub */.R3.sub(positionVector, referenceImagePositionPatient, metadataForMiddleImage.imagePositionPatient);
-        const distanceBetweenFirstAndMiddleImages = gl_matrix_esm/* vec3.dot */.R3.dot(positionVector, scanAxisNormal);
-        zSpacing =
-            Math.abs(distanceBetweenFirstAndMiddleImages) /
-                Math.floor(imageIds.length / 2);
-    }
-    const { imagePositionPatient: origin, sliceThickness } = esm.metaData.get('imagePlaneModule', sortedImageIds[0]);
-    const { strictZSpacingForVolumeViewport } = (0,esm.getConfiguration)().rendering;
-    if (zSpacing === 0 && !strictZSpacingForVolumeViewport) {
-        if (sliceThickness) {
-            console.log('Could not calculate zSpacing. Using sliceThickness');
-            zSpacing = sliceThickness;
-        }
-        else {
-            console.log('Could not calculate zSpacing. The VolumeViewport visualization is compromised. Setting zSpacing to 1 to render');
-            zSpacing = 1;
-        }
-    }
-    const result = {
-        zSpacing,
-        origin,
-        sortedImageIds,
-    };
-    return result;
-}
-
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/helpers/getVolumeInfo.js
 
 
-
-
 const { createUint8SharedArray, createFloat32SharedArray } = esm.utilities;
 function getVolumeInfo_getVolumeInfo(imageIds) {
-    const volumeMetadata = makeVolumeMetadata(imageIds);
+    const volumeMetadata = utilities.makeVolumeMetadata(imageIds);
     const { BitsAllocated, PixelRepresentation, PhotometricInterpretation, ImageOrientationPatient, PixelSpacing, Columns, Rows, } = volumeMetadata;
     const rowCosineVec = vec3.fromValues(ImageOrientationPatient[0], ImageOrientationPatient[1], ImageOrientationPatient[2]);
     const colCosineVec = vec3.fromValues(ImageOrientationPatient[3], ImageOrientationPatient[4], ImageOrientationPatient[5]);
     const scanAxisNormal = vec3.create();
     vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
-    const { zSpacing, origin, sortedImageIds } = sortImageIdsAndGetSpacing(imageIds, scanAxisNormal);
+    const { zSpacing, origin, sortedImageIds } = utilities.sortImageIdsAndGetSpacing(imageIds, scanAxisNormal);
     const numFrames = imageIds.length;
     const spacing = [PixelSpacing[1], PixelSpacing[0], zSpacing];
     const dimensions = [Columns, Rows, numFrames];
@@ -310,8 +181,6 @@ function scaleArray(array, scalingParameters) {
 
 
 
-
-
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/BaseStreamingImageVolume.js
 
 
@@ -964,7 +833,6 @@ class StreamingImageVolume extends BaseStreamingImageVolume_BaseStreamingImageVo
 
 
 
-
 const { createUint8SharedArray: cornerstoneStreamingImageVolumeLoader_createUint8SharedArray, createFloat32SharedArray: cornerstoneStreamingImageVolumeLoader_createFloat32SharedArray, createUint16SharedArray, createInt16SharedArray, } = esm.utilities;
 function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
     if (!options || !options.imageIds || !options.imageIds.length) {
@@ -996,7 +864,7 @@ function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
             })).catch(console.error);
         }
         const { imageIds, progressiveRendering } = options;
-        const volumeMetadata = makeVolumeMetadata_makeVolumeMetadata(imageIds);
+        const volumeMetadata = esm.utilities.makeVolumeMetadata(imageIds);
         const imageIdIndex = Math.floor(imageIds.length / 2);
         const imageId = imageIds[imageIdIndex];
         const scalingParameters = esm.utilities.getScalingParameters(imageId);
@@ -1009,7 +877,7 @@ function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
         const colCosineVec = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(ImageOrientationPatient[3], ImageOrientationPatient[4], ImageOrientationPatient[5]);
         const scanAxisNormal = gl_matrix_esm/* vec3.create */.R3.create();
         gl_matrix_esm/* vec3.cross */.R3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
-        const { zSpacing, origin, sortedImageIds } = sortImageIdsAndGetSpacing_sortImageIdsAndGetSpacing(imageIds, scanAxisNormal);
+        const { zSpacing, origin, sortedImageIds } = esm.utilities.sortImageIdsAndGetSpacing(imageIds, scanAxisNormal);
         const numFrames = imageIds.length;
         const spacing = [PixelSpacing[1], PixelSpacing[0], zSpacing];
         const dimensions = [Columns, Rows, numFrames];
@@ -1292,10 +1160,8 @@ function cornerstoneStreamingDynamicImageVolumeLoader(volumeId, options) {
 
 
 
-
 const helpers = {
     getDynamicVolumeInfo: helpers_getDynamicVolumeInfo,
-    sortImageIdsAndGetSpacing: sortImageIdsAndGetSpacing_sortImageIdsAndGetSpacing,
 };