@ohif/app 3.8.0-beta.42 → 3.8.0-beta.43

package/dist/{95.bundle.830304446bffa705883c.js → 95.bundle.644c927d99988ff60b36.js}

@@ -12,8 +12,8 @@ __webpack_require__.d(__webpack_exports__, {
 
 // UNUSED EXPORTS: Enums, StreamingDynamicImageVolume, StreamingImageVolume, cornerstoneStreamingDynamicImageVolumeLoader, helpers
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 368 modules
-var esm = __webpack_require__(62881);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 375 modules
+var esm = __webpack_require__(56846);
 // 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/getVolumeInfo.js
@@ -185,7 +185,7 @@ function scaleArray(array, scalingParameters) {
 
 
 const requestTypeDefault = esm.Enums.RequestType.Prefetch;
-const { getMinMax, ProgressiveIterator } = esm.utilities;
+const { ProgressiveIterator } = esm.utilities;
 const { ImageQualityStatus } = esm.Enums;
 const { imageRetrieveMetadataProvider } = esm.utilities;
 class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume {
@@ -194,7 +194,6 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
         this.framesLoaded = 0;
         this.framesProcessed = 0;
         this.framesUpdated = 0;
-        this.cornerstoneImageMetaData = null;
         this.autoRenderOnLoad = true;
         this.cachedFrames = [];
         this.reRenderTarget = 0;
@@ -243,73 +242,7 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
             }
             this._prefetchImageIds();
         };
-        this.imageIds = streamingProperties.imageIds;
         this.loadStatus = streamingProperties.loadStatus;
-        this.numFrames = this._getNumFrames();
-        this._createCornerstoneImageMetaData();
-    }
-    _getNumFrames() {
-        const { imageIds, scalarData } = this;
-        const scalarDataCount = this.isDynamicVolume() ? scalarData.length : 1;
-        return imageIds.length / scalarDataCount;
-    }
-    _getScalarDataLength() {
-        const { scalarData } = this;
-        return this.isDynamicVolume()
-            ? scalarData[0].length
-            : scalarData.length;
-    }
-    _createCornerstoneImageMetaData() {
-        const { numFrames } = this;
-        if (numFrames === 0) {
-            return;
-        }
-        const bytesPerImage = this.sizeInBytes / numFrames;
-        const scalarDataLength = this._getScalarDataLength();
-        const numComponents = scalarDataLength / this.numVoxels;
-        const pixelsPerImage = this.dimensions[0] * this.dimensions[1] * numComponents;
-        const { PhotometricInterpretation, voiLut, VOILUTFunction } = this.metadata;
-        let windowCenter = [];
-        let windowWidth = [];
-        if (voiLut && voiLut.length) {
-            windowCenter = voiLut.map((voi) => {
-                return voi.windowCenter;
-            });
-            windowWidth = voiLut.map((voi) => {
-                return voi.windowWidth;
-            });
-        }
-        const color = numComponents > 1 ? true : false;
-        this.cornerstoneImageMetaData = {
-            bytesPerImage,
-            numComponents,
-            pixelsPerImage,
-            windowCenter,
-            windowWidth,
-            color,
-            rgba: false,
-            spacing: this.spacing,
-            dimensions: this.dimensions,
-            photometricInterpretation: PhotometricInterpretation,
-            voiLUTFunction: VOILUTFunction,
-            invert: PhotometricInterpretation === 'MONOCHROME1',
-        };
-    }
-    _imageIdIndexToFrameIndex(imageIdIndex) {
-        return imageIdIndex % this.numFrames;
-    }
-    getScalarDataArrays() {
-        return this.isDynamicVolume()
-            ? this.scalarData
-            : [this.scalarData];
-    }
-    _getScalarDataByImageIdIndex(imageIdIndex) {
-        if (imageIdIndex < 0 || imageIdIndex >= this.imageIds.length) {
-            throw new Error('imageIdIndex out of range');
-        }
-        const scalarDataArrays = this.getScalarDataArrays();
-        const scalarDataIndex = Math.floor(imageIdIndex / this.numFrames);
-        return scalarDataArrays[scalarDataIndex];
     }
     invalidateVolume(immediate) {
         const { imageData, vtkOpenGLTexture } = this;
@@ -346,7 +279,7 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
         }
     }
     updateTextureAndTriggerEvents(imageIdIndex, imageId, imageQualityStatus = ImageQualityStatus.FULL_RESOLUTION) {
-        const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
+        const frameIndex = this.imageIdIndexToFrameIndex(imageIdIndex);
         const { cachedFrames, numFrames, totalNumFrames } = this;
         const { FrameOfReferenceUID } = this.metadata;
         const currentStatus = cachedFrames[frameIndex];
@@ -393,11 +326,11 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
     successCallback(imageId, image) {
         const imageIdIndex = this.getImageIdIndex(imageId);
         const options = this.getLoaderImageOptions(imageId);
-        const scalarData = this._getScalarDataByImageIdIndex(imageIdIndex);
+        const scalarData = this.getScalarDataByImageIdIndex(imageIdIndex);
         handleArrayBufferLoad(scalarData, image, options);
         const { scalingParameters } = image.preScale || {};
         const { imageQualityStatus } = image;
-        const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
+        const frameIndex = this.imageIdIndexToFrameIndex(imageIdIndex);
         const cachedImage = esm.cache.getCachedImageBasedOnImageURI(imageId);
         const cachedVolume = esm.cache.getVolumeContainingImageId(imageId);
         if (this.loadStatus.cancelled) {
@@ -408,6 +341,14 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
             return this.updateTextureAndTriggerEvents(imageIdIndex, imageId, imageQualityStatus);
         }
         const isFromImageCache = !!cachedImage;
+        if (isFromImageCache && options.targetBuffer) {
+            this.imageCacheOffsetMap.set(imageId, {
+                imageIdIndex,
+                frameIndex,
+                offset: options.targetBuffer?.offset || 0,
+                length: options.targetBuffer?.length,
+            });
+        }
         const cachedImageOrVolume = cachedImage || cachedVolume.volume;
         this.handleImageComingFromCache(cachedImageOrVolume, isFromImageCache, scalingParameters, scalarData, frameIndex, scalarData.buffer, imageIdIndex, imageId);
     }
@@ -448,7 +389,7 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
         const imagePlaneModule = esm.metaData.get('imagePlaneModule', imageId) || {};
         const { rows, columns } = imagePlaneModule;
         const imageIdIndex = this.getImageIdIndex(imageId);
-        const scalarData = this._getScalarDataByImageIdIndex(imageIdIndex);
+        const scalarData = this.getScalarDataByImageIdIndex(imageIdIndex);
         if (!scalarData) {
             return null;
         }
@@ -471,7 +412,7 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
         const isSlopeAndInterceptNumbers = typeof scalingParameters.rescaleSlope === 'number' &&
             typeof scalingParameters.rescaleIntercept === 'number';
         this.isPreScaled = isSlopeAndInterceptNumbers;
-        const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
+        const frameIndex = this.imageIdIndexToFrameIndex(imageIdIndex);
         return {
             targetBuffer: {
                 arrayBuffer: arrayBuffer instanceof ArrayBuffer ? undefined : arrayBuffer,
@@ -642,101 +583,6 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
         }
         this.scaling = { PT: petScaling };
     }
-    _removeFromCache() {
-        esm.cache.removeVolumeLoadObject(this.volumeId);
-    }
-    getCornerstoneImage(imageId, imageIdIndex) {
-        const { imageIds } = this;
-        const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
-        const { bytesPerImage, pixelsPerImage, windowCenter, windowWidth, numComponents, color, dimensions, spacing, invert, voiLUTFunction, photometricInterpretation, } = this.cornerstoneImageMetaData;
-        const scalarData = this._getScalarDataByImageIdIndex(imageIdIndex);
-        const volumeBuffer = scalarData.buffer;
-        const TypedArray = scalarData.constructor;
-        const bytePerPixel = bytesPerImage / pixelsPerImage;
-        let byteOffset = bytesPerImage * frameIndex;
-        if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
-            byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
-        }
-        const imageScalarData = new TypedArray(pixelsPerImage);
-        const volumeBufferView = new TypedArray(volumeBuffer, byteOffset, pixelsPerImage);
-        imageScalarData.set(volumeBufferView);
-        const volumeImageId = imageIds[imageIdIndex];
-        const modalityLutModule = esm.metaData.get('modalityLutModule', volumeImageId) || {};
-        const minMax = getMinMax(imageScalarData);
-        const intercept = modalityLutModule.rescaleIntercept
-            ? modalityLutModule.rescaleIntercept
-            : 0;
-        return {
-            imageId,
-            intercept,
-            windowCenter,
-            windowWidth,
-            voiLUTFunction,
-            color,
-            rgba: false,
-            numComps: numComponents,
-            rows: dimensions[1],
-            columns: dimensions[0],
-            sizeInBytes: imageScalarData.byteLength,
-            getPixelData: () => imageScalarData,
-            minPixelValue: minMax.min,
-            maxPixelValue: minMax.max,
-            slope: modalityLutModule.rescaleSlope
-                ? modalityLutModule.rescaleSlope
-                : 1,
-            getCanvas: undefined,
-            height: dimensions[0],
-            width: dimensions[1],
-            columnPixelSpacing: spacing[0],
-            rowPixelSpacing: spacing[1],
-            invert,
-            photometricInterpretation,
-        };
-    }
-    convertToCornerstoneImage(imageId, imageIdIndex) {
-        return this.getCornerstoneImageLoadObject(imageId, imageIdIndex);
-    }
-    getCornerstoneImageLoadObject(imageId, imageIdIndex) {
-        const image = this.getCornerstoneImage(imageId, imageIdIndex);
-        const imageLoadObject = {
-            promise: Promise.resolve(image),
-        };
-        return imageLoadObject;
-    }
-    getCornerstoneImages() {
-        const { imageIds } = this;
-        return imageIds.map((imageId, imageIdIndex) => {
-            return this.getCornerstoneImage(imageId, imageIdIndex);
-        });
-    }
-    _convertToImages() {
-        const byteLength = this.sizeInBytes;
-        const numImages = this.imageIds.length;
-        const { bytesPerImage } = this.cornerstoneImageMetaData;
-        let bytesRemaining = esm.cache.decacheIfNecessaryUntilBytesAvailable(byteLength, this.imageIds);
-        for (let imageIdIndex = 0; imageIdIndex < numImages; imageIdIndex++) {
-            const imageId = this.imageIds[imageIdIndex];
-            bytesRemaining = bytesRemaining - bytesPerImage;
-            const imageLoadObject = this.convertToCornerstoneImage(imageId, imageIdIndex);
-            if (!esm.cache.getImageLoadObject(imageId)) {
-                esm.cache.putImageLoadObject(imageId, imageLoadObject).catch((err) => {
-                    console.error(err);
-                });
-            }
-            if (bytesRemaining <= bytesPerImage) {
-                break;
-            }
-        }
-        this._removeFromCache();
-    }
-    decache(completelyRemove = false) {
-        if (completelyRemove) {
-            this._removeFromCache();
-        }
-        else {
-            this._convertToImages();
-        }
-    }
 }
 function getScalarDataType(scalarData, numFrames) {
     let type, byteSize;
@@ -813,6 +659,9 @@ function handleArrayBufferLoad(scalarData, image, options) {
 
 class StreamingImageVolume extends BaseStreamingImageVolume_BaseStreamingImageVolume {
     constructor(imageVolumeProperties, streamingProperties) {
+        if (!imageVolumeProperties.imageIds) {
+            imageVolumeProperties.imageIds = streamingProperties.imageIds;
+        }
         super(imageVolumeProperties, streamingProperties);
         this.getImageIdsToLoad = () => {
             const { imageIds } = this;
@@ -832,14 +681,10 @@ class StreamingImageVolume extends BaseStreamingImageVolume_BaseStreamingImageVo
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/cornerstoneStreamingImageVolumeLoader.js
 
 
-
-const { createUint8SharedArray: cornerstoneStreamingImageVolumeLoader_createUint8SharedArray, createFloat32SharedArray: cornerstoneStreamingImageVolumeLoader_createFloat32SharedArray, createUint16SharedArray, createInt16SharedArray, } = esm.utilities;
 function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
     if (!options || !options.imageIds || !options.imageIds.length) {
         throw new Error('ImageIds must be provided to create a streaming image volume');
     }
-    const { useNorm16Texture, preferSizeOverAccuracy } = (0,esm.getConfiguration)().rendering;
-    const use16BitDataType = useNorm16Texture || preferSizeOverAccuracy;
     async function getStreamingImageVolume() {
         if (options.imageIds[0].split(':')[0] === 'wadouri') {
             const [middleImageIndex, lastImageIndex] = [
@@ -863,99 +708,19 @@ function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
                 });
             })).catch(console.error);
         }
-        const { imageIds, progressiveRendering } = options;
-        const volumeMetadata = esm.utilities.makeVolumeMetadata(imageIds);
-        const imageIdIndex = Math.floor(imageIds.length / 2);
-        const imageId = imageIds[imageIdIndex];
-        const scalingParameters = esm.utilities.getScalingParameters(imageId);
-        const hasNegativeRescale = scalingParameters.rescaleIntercept < 0 ||
-            scalingParameters.rescaleSlope < 0;
-        const hasFloatRescale = scalingParameters.rescaleIntercept % 1 !== 0 ||
-            scalingParameters.rescaleSlope % 1 !== 0;
-        const { BitsAllocated, PixelRepresentation, PhotometricInterpretation, ImageOrientationPatient, PixelSpacing, Columns, Rows, } = volumeMetadata;
-        const rowCosineVec = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(ImageOrientationPatient[0], ImageOrientationPatient[1], ImageOrientationPatient[2]);
-        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 } = esm.utilities.sortImageIdsAndGetSpacing(imageIds, scanAxisNormal);
-        const numFrames = imageIds.length;
-        const spacing = [PixelSpacing[1], PixelSpacing[0], zSpacing];
-        const dimensions = [Columns, Rows, numFrames];
-        const direction = [
-            ...rowCosineVec,
-            ...colCosineVec,
-            ...scanAxisNormal,
-        ];
-        const signed = PixelRepresentation === 1;
-        const numComponents = PhotometricInterpretation === 'RGB' ? 3 : 1;
-        const useSharedArrayBuffer = (0,esm.getShouldUseSharedArrayBuffer)();
-        const length = dimensions[0] * dimensions[1] * dimensions[2];
-        const handleCache = (sizeInBytes) => {
-            if (!esm.cache.isCacheable(sizeInBytes)) {
-                throw new Error(esm.Enums.Events.CACHE_SIZE_EXCEEDED);
-            }
-            esm.cache.decacheIfNecessaryUntilBytesAvailable(sizeInBytes);
-        };
-        let scalarData, sizeInBytes;
-        switch (BitsAllocated) {
-            case 8:
-                if (signed) {
-                    throw new Error('8 Bit signed images are not yet supported by this plugin.');
-                }
-                sizeInBytes = length * numComponents;
-                handleCache(sizeInBytes);
-                scalarData = useSharedArrayBuffer
-                    ? cornerstoneStreamingImageVolumeLoader_createUint8SharedArray(length * numComponents)
-                    : new Uint8Array(length * numComponents);
-                break;
-            case 16:
-                if (!use16BitDataType || hasFloatRescale) {
-                    sizeInBytes = length * 4;
-                    scalarData = useSharedArrayBuffer
-                        ? cornerstoneStreamingImageVolumeLoader_createFloat32SharedArray(length)
-                        : new Float32Array(length);
-                    break;
-                }
-                sizeInBytes = length * 2;
-                if (signed || hasNegativeRescale) {
-                    handleCache(sizeInBytes);
-                    scalarData = useSharedArrayBuffer
-                        ? createInt16SharedArray(length)
-                        : new Int16Array(length);
-                    break;
-                }
-                if (!signed && !hasNegativeRescale) {
-                    handleCache(sizeInBytes);
-                    scalarData = useSharedArrayBuffer
-                        ? createUint16SharedArray(length)
-                        : new Uint16Array(length);
-                    break;
-                }
-                sizeInBytes = length * 4;
-                handleCache(sizeInBytes);
-                scalarData = useSharedArrayBuffer
-                    ? cornerstoneStreamingImageVolumeLoader_createFloat32SharedArray(length)
-                    : new Float32Array(length);
-                break;
-            case 24:
-                sizeInBytes = length * numComponents;
-                handleCache(sizeInBytes);
-                scalarData = useSharedArrayBuffer
-                    ? cornerstoneStreamingImageVolumeLoader_createUint8SharedArray(length * numComponents)
-                    : new Uint8Array(length * numComponents);
-                break;
-        }
+        const { dimensions, spacing, origin, scalarData, direction, sizeInBytes, metadata, imageIds, } = esm.utilities.generateVolumePropsFromImageIds(options.imageIds, volumeId);
         const streamingImageVolume = new StreamingImageVolume({
             volumeId,
-            metadata: volumeMetadata,
+            metadata,
             dimensions,
             spacing,
             origin,
             direction,
             scalarData,
             sizeInBytes,
+            imageIds,
         }, {
-            imageIds: sortedImageIds,
+            imageIds,
             loadStatus: {
                 loaded: false,
                 loading: false,
@@ -1121,6 +886,7 @@ function cornerstoneStreamingDynamicImageVolumeLoader(volumeId, options) {
         sortedImageIdsArrays.push(volumeInfo.sortedImageIds);
         scalarDataArrays.push(volumeInfo.scalarData);
     });
+    const sortedImageIds = sortedImageIdsArrays.flat();
     let streamingImageVolume = new StreamingDynamicImageVolume({
         volumeId,
         metadata: volumeMetadata,
@@ -1130,8 +896,9 @@ function cornerstoneStreamingDynamicImageVolumeLoader(volumeId, options) {
         direction,
         scalarData: scalarDataArrays,
         sizeInBytes,
+        imageIds: sortedImageIds,
     }, {
-        imageIds: sortedImageIdsArrays.flat(),
+        imageIds: sortedImageIds,
         loadStatus: {
             loaded: false,
             loading: false,

package/dist/{965.bundle.f8680a6f67d5473d1184.js → 965.bundle.254019aafbf9c9d3d800.js}

@@ -20,8 +20,8 @@ const id = package_namespaceObject.u2;
 
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
 var react = __webpack_require__(43001);
-// EXTERNAL MODULE: ../../ui/src/index.js + 486 modules
-var src = __webpack_require__(22582);
+// EXTERNAL MODULE: ../../ui/src/index.js + 487 modules
+var src = __webpack_require__(89556);
 // EXTERNAL MODULE: ../../core/src/index.ts + 65 modules
 var core_src = __webpack_require__(71771);
 // EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules