@ohif/app 3.8.0-beta.23 → 3.8.0-beta.24

package/dist/{47.bundle.01d2751a9fd67b3d5390.js → 47.bundle.3217b1b873983a6aaa43.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 + 344 modules
-var esm = __webpack_require__(62231);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 356 modules
+var esm = __webpack_require__(63442);
 // 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
@@ -315,14 +315,22 @@ function scaleArray(array, scalingParameters) {
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/BaseStreamingImageVolume.js
 
 
-const requestType = esm.Enums.RequestType.Prefetch;
-const { getMinMax } = esm.utilities;
+const requestTypeDefault = esm.Enums.RequestType.Prefetch;
+const { getMinMax, ProgressiveIterator } = esm.utilities;
+const { ImageQualityStatus } = esm.Enums;
+const { imageRetrieveMetadataProvider } = esm.utilities;
 class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume {
     constructor(imageVolumeProperties, streamingProperties) {
         super(imageVolumeProperties);
         this.framesLoaded = 0;
         this.framesProcessed = 0;
+        this.framesUpdated = 0;
         this.cornerstoneImageMetaData = null;
+        this.autoRenderOnLoad = true;
+        this.cachedFrames = [];
+        this.reRenderTarget = 0;
+        this.reRenderFraction = 2;
+        this.imagesLoader = this;
         this.cancelLoading = () => {
             const { loadStatus } = this;
             if (!loadStatus || !loadStatus.loading) {
@@ -336,10 +344,15 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
             };
             esm.imageLoadPoolManager.filterRequests(filterFunction);
         };
-        this.load = (callback, priority = 5) => {
+        this.load = (callback) => {
             const { imageIds, loadStatus, numFrames } = this;
+            const { transferSyntaxUID } = esm.metaData.get('transferSyntax', imageIds[0]) || {};
+            const imageRetrieveConfiguration = esm.metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, this.volumeId, transferSyntaxUID, 'volume');
+            this.imagesLoader = imageRetrieveConfiguration
+                ? (imageRetrieveConfiguration.create ||
+                    esm.ProgressiveRetrieveImages.createProgressive)(imageRetrieveConfiguration)
+                : this;
             if (loadStatus.loading === true) {
-                console.log(`loadVolume: Loading is already in progress for ${this.volumeId}`);
                 return;
             }
             const { loaded } = this.loadStatus;
@@ -359,255 +372,7 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
             if (callback) {
                 this.loadStatus.callbacks.push(callback);
             }
-            this._prefetchImageIds(priority);
-        };
-        this.getImageIdsRequests = (imageIds, scalarData, priority) => {
-            const { loadStatus } = this;
-            const { cachedFrames } = loadStatus;
-            const { vtkOpenGLTexture, imageData, metadata, volumeId } = this;
-            const { FrameOfReferenceUID } = metadata;
-            const arrayBuffer = scalarData.buffer;
-            const numFrames = imageIds.length;
-            const length = scalarData.length / numFrames;
-            const lengthInBytes = arrayBuffer.byteLength / numFrames;
-            let type;
-            if (scalarData instanceof Uint8Array) {
-                type = 'Uint8Array';
-            }
-            else if (scalarData instanceof Float32Array) {
-                type = 'Float32Array';
-            }
-            else if (scalarData instanceof Uint16Array) {
-                type = 'Uint16Array';
-            }
-            else if (scalarData instanceof Int16Array) {
-                type = 'Int16Array';
-            }
-            else {
-                throw new Error('Unsupported array type');
-            }
-            const totalNumFrames = this.imageIds.length;
-            const autoRenderOnLoad = true;
-            const autoRenderPercentage = 2;
-            let reRenderFraction;
-            let reRenderTarget;
-            if (autoRenderOnLoad) {
-                reRenderFraction = totalNumFrames * (autoRenderPercentage / 100);
-                reRenderTarget = reRenderFraction;
-            }
-            function callLoadStatusCallback(evt) {
-                if (autoRenderOnLoad) {
-                    if (evt.framesProcessed > reRenderTarget ||
-                        evt.framesProcessed === evt.totalNumFrames) {
-                        reRenderTarget += reRenderFraction;
-                        helpers_autoLoad(volumeId);
-                    }
-                }
-                if (evt.framesProcessed === evt.totalNumFrames) {
-                    loadStatus.callbacks.forEach((callback) => callback(evt));
-                    const eventDetail = {
-                        FrameOfReferenceUID,
-                        volumeId: volumeId,
-                    };
-                    (0,esm.triggerEvent)(esm.eventTarget, esm.Enums.Events.IMAGE_VOLUME_LOADING_COMPLETED, eventDetail);
-                }
-            }
-            const updateTextureAndTriggerEvents = (volume, imageIdIndex, imageId) => {
-                const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
-                cachedFrames[imageIdIndex] = true;
-                this.framesLoaded++;
-                this.framesProcessed++;
-                vtkOpenGLTexture.setUpdatedFrame(frameIndex);
-                imageData.modified();
-                const eventDetail = {
-                    FrameOfReferenceUID,
-                    imageVolume: volume,
-                };
-                (0,esm.triggerEvent)(esm.eventTarget, esm.Enums.Events.IMAGE_VOLUME_MODIFIED, eventDetail);
-                if (this.framesProcessed === totalNumFrames) {
-                    loadStatus.loaded = true;
-                    loadStatus.loading = false;
-                    callLoadStatusCallback({
-                        success: true,
-                        imageIdIndex,
-                        imageId,
-                        framesLoaded: this.framesLoaded,
-                        framesProcessed: this.framesProcessed,
-                        numFrames,
-                        totalNumFrames,
-                    });
-                    loadStatus.callbacks = [];
-                }
-                else {
-                    callLoadStatusCallback({
-                        success: true,
-                        imageIdIndex,
-                        imageId,
-                        framesLoaded: this.framesLoaded,
-                        framesProcessed: this.framesProcessed,
-                        numFrames,
-                        totalNumFrames,
-                    });
-                }
-            };
-            const successCallback = (imageIdIndex, imageId, scalingParameters) => {
-                const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
-                const cachedImage = esm.cache.getCachedImageBasedOnImageURI(imageId);
-                const cachedVolume = esm.cache.getVolumeContainingImageId(imageId);
-                if (loadStatus.cancelled) {
-                    console.warn('volume load cancelled, returning for imageIdIndex: ', imageIdIndex);
-                    return;
-                }
-                if (!cachedImage?.image &&
-                    !(cachedVolume && cachedVolume.volume !== this)) {
-                    return updateTextureAndTriggerEvents(this, imageIdIndex, imageId);
-                }
-                const isFromImageCache = !!cachedImage;
-                const cachedImageOrVolume = cachedImage || cachedVolume.volume;
-                this.handleImageComingFromCache(cachedImageOrVolume, isFromImageCache, scalingParameters, scalarData, frameIndex, arrayBuffer, updateTextureAndTriggerEvents, imageIdIndex, imageId, errorCallback);
-            };
-            function errorCallback(error, imageIdIndex, imageId) {
-                this.framesProcessed++;
-                if (this.framesProcessed === totalNumFrames) {
-                    loadStatus.loaded = true;
-                    loadStatus.loading = false;
-                    callLoadStatusCallback({
-                        success: false,
-                        imageId,
-                        imageIdIndex,
-                        error,
-                        framesLoaded: this.framesLoaded,
-                        framesProcessed: this.framesProcessed,
-                        numFrames,
-                        totalNumFrames,
-                    });
-                    loadStatus.callbacks = [];
-                }
-                else {
-                    callLoadStatusCallback({
-                        success: false,
-                        imageId,
-                        imageIdIndex,
-                        error,
-                        framesLoaded: this.framesLoaded,
-                        framesProcessed: this.framesProcessed,
-                        numFrames,
-                        totalNumFrames,
-                    });
-                }
-                const eventDetail = {
-                    error,
-                    imageIdIndex,
-                    imageId,
-                };
-                (0,esm.triggerEvent)(esm.eventTarget, esm.Enums.Events.IMAGE_LOAD_ERROR, eventDetail);
-            }
-            function handleArrayBufferLoad(scalarData, image, options) {
-                if (!(scalarData.buffer instanceof ArrayBuffer)) {
-                    return;
-                }
-                const offset = options.targetBuffer.offset;
-                const length = options.targetBuffer.length;
-                const pixelData = image.pixelData
-                    ? image.pixelData
-                    : image.getPixelData();
-                try {
-                    if (scalarData instanceof Float32Array) {
-                        const bytesInFloat = 4;
-                        const floatView = new Float32Array(pixelData);
-                        if (floatView.length !== length) {
-                            throw 'Error pixelData length does not match frame length';
-                        }
-                        scalarData.set(floatView, offset / bytesInFloat);
-                    }
-                    if (scalarData instanceof Int16Array) {
-                        const bytesInInt16 = 2;
-                        const intView = new Int16Array(pixelData);
-                        if (intView.length !== length) {
-                            throw 'Error pixelData length does not match frame length';
-                        }
-                        scalarData.set(intView, offset / bytesInInt16);
-                    }
-                    if (scalarData instanceof Uint16Array) {
-                        const bytesInUint16 = 2;
-                        const intView = new Uint16Array(pixelData);
-                        if (intView.length !== length) {
-                            throw 'Error pixelData length does not match frame length';
-                        }
-                        scalarData.set(intView, offset / bytesInUint16);
-                    }
-                    if (scalarData instanceof Uint8Array) {
-                        const bytesInUint8 = 1;
-                        const intView = new Uint8Array(pixelData);
-                        if (intView.length !== length) {
-                            throw 'Error pixelData length does not match frame length';
-                        }
-                        scalarData.set(intView, offset / bytesInUint8);
-                    }
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
-            const requests = imageIds.map((imageId, frameIndex) => {
-                const imageIdIndex = this.getImageIdIndex(imageId);
-                if (cachedFrames[imageIdIndex]) {
-                    this.framesLoaded++;
-                    this.framesProcessed++;
-                    return;
-                }
-                const modalityLutModule = esm.metaData.get('modalityLutModule', imageId) || {};
-                const generalSeriesModule = esm.metaData.get('generalSeriesModule', imageId) || {};
-                const scalingParameters = {
-                    rescaleSlope: modalityLutModule.rescaleSlope,
-                    rescaleIntercept: modalityLutModule.rescaleIntercept,
-                    modality: generalSeriesModule.modality,
-                };
-                if (scalingParameters.modality === 'PT') {
-                    const suvFactor = esm.metaData.get('scalingModule', imageId);
-                    if (suvFactor) {
-                        this._addScalingToVolume(suvFactor);
-                        scalingParameters.suvbw = suvFactor.suvbw;
-                    }
-                }
-                const isSlopeAndInterceptNumbers = typeof scalingParameters.rescaleSlope === 'number' &&
-                    typeof scalingParameters.rescaleIntercept === 'number';
-                this.isPreScaled = isSlopeAndInterceptNumbers;
-                const options = {
-                    targetBuffer: {
-                        arrayBuffer: arrayBuffer instanceof ArrayBuffer ? undefined : arrayBuffer,
-                        offset: frameIndex * lengthInBytes,
-                        length,
-                        type,
-                    },
-                    skipCreateImage: true,
-                    preScale: {
-                        enabled: true,
-                        scalingParameters,
-                    },
-                    transferPixelData: true,
-                };
-                const callLoadImage = (imageId, imageIdIndex, options) => {
-                    return esm.imageLoader.loadImage(imageId, options).then((image) => {
-                        handleArrayBufferLoad(scalarData, image, options);
-                        successCallback(imageIdIndex, imageId, scalingParameters);
-                    }, (error) => {
-                        errorCallback.call(this, error, imageIdIndex, imageId);
-                    });
-                };
-                return {
-                    callLoadImage,
-                    imageId,
-                    imageIdIndex,
-                    options,
-                    priority,
-                    requestType,
-                    additionalDetails: {
-                        volumeId: this.volumeId,
-                    },
-                };
-            });
-            return requests;
+            this._prefetchImageIds();
         };
         this.imageIds = streamingProperties.imageIds;
         this.loadStatus = streamingProperties.loadStatus;
@@ -691,7 +456,215 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
     clearLoadCallbacks() {
         this.loadStatus.callbacks = [];
     }
-    handleImageComingFromCache(cachedImageOrVolume, isFromImageCache, scalingParameters, scalarData, frameIndex, arrayBuffer, updateTextureAndTriggerEvents, imageIdIndex, imageId, errorCallback) {
+    callLoadStatusCallback(evt) {
+        const { framesUpdated, framesProcessed, totalNumFrames } = evt;
+        const { volumeId, reRenderFraction, loadStatus, metadata } = this;
+        const { FrameOfReferenceUID } = metadata;
+        if (this.autoRenderOnLoad) {
+            if (framesUpdated > this.reRenderTarget ||
+                framesProcessed === totalNumFrames) {
+                this.reRenderTarget += reRenderFraction;
+                helpers_autoLoad(volumeId);
+            }
+        }
+        if (framesProcessed === totalNumFrames) {
+            loadStatus.callbacks.forEach((callback) => callback(evt));
+            const eventDetail = {
+                FrameOfReferenceUID,
+                volumeId: volumeId,
+            };
+            (0,esm.triggerEvent)(esm.eventTarget, esm.Enums.Events.IMAGE_VOLUME_LOADING_COMPLETED, eventDetail);
+        }
+    }
+    updateTextureAndTriggerEvents(imageIdIndex, imageId, imageQualityStatus = ImageQualityStatus.FULL_RESOLUTION) {
+        const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
+        const { cachedFrames, numFrames, totalNumFrames } = this;
+        const { FrameOfReferenceUID } = this.metadata;
+        const currentStatus = cachedFrames[frameIndex];
+        if (currentStatus > imageQualityStatus) {
+            return;
+        }
+        if (cachedFrames[frameIndex] === ImageQualityStatus.FULL_RESOLUTION) {
+            return;
+        }
+        const complete = imageQualityStatus === ImageQualityStatus.FULL_RESOLUTION;
+        cachedFrames[imageIdIndex] = imageQualityStatus;
+        this.framesUpdated++;
+        if (complete) {
+            this.framesLoaded++;
+            this.framesProcessed++;
+        }
+        this.vtkOpenGLTexture.setUpdatedFrame(frameIndex);
+        this.imageData.modified();
+        const eventDetail = {
+            FrameOfReferenceUID,
+            imageVolume: this,
+        };
+        (0,esm.triggerEvent)(esm.eventTarget, esm.Enums.Events.IMAGE_VOLUME_MODIFIED, eventDetail);
+        if (complete && this.framesProcessed === this.totalNumFrames) {
+            this.loadStatus.loaded = true;
+            this.loadStatus.loading = false;
+        }
+        this.callLoadStatusCallback({
+            success: true,
+            imageIdIndex,
+            imageId,
+            framesLoaded: this.framesLoaded,
+            framesProcessed: this.framesProcessed,
+            framesUpdated: this.framesUpdated,
+            numFrames,
+            totalNumFrames,
+            complete,
+            imageQualityStatus,
+        });
+        if (this.loadStatus.loaded) {
+            this.loadStatus.callbacks = [];
+        }
+    }
+    successCallback(imageId, image) {
+        const imageIdIndex = this.getImageIdIndex(imageId);
+        const options = this.getLoaderImageOptions(imageId);
+        const scalarData = this._getScalarDataByImageIdIndex(imageIdIndex);
+        handleArrayBufferLoad(scalarData, image, options);
+        const { scalingParameters } = image.preScale || {};
+        const { imageQualityStatus } = image;
+        const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
+        const cachedImage = esm.cache.getCachedImageBasedOnImageURI(imageId);
+        const cachedVolume = esm.cache.getVolumeContainingImageId(imageId);
+        if (this.loadStatus.cancelled) {
+            console.warn('volume load cancelled, returning for imageIdIndex: ', imageIdIndex);
+            return;
+        }
+        if (!cachedImage && !(cachedVolume && cachedVolume.volume !== this)) {
+            return this.updateTextureAndTriggerEvents(imageIdIndex, imageId, imageQualityStatus);
+        }
+        const isFromImageCache = !!cachedImage;
+        const cachedImageOrVolume = cachedImage || cachedVolume.volume;
+        this.handleImageComingFromCache(cachedImageOrVolume, isFromImageCache, scalingParameters, scalarData, frameIndex, scalarData.buffer, imageIdIndex, imageId);
+    }
+    errorCallback(imageId, permanent, error) {
+        if (!permanent) {
+            return;
+        }
+        const { totalNumFrames, numFrames } = this;
+        const imageIdIndex = this.getImageIdIndex(imageId);
+        this.framesProcessed++;
+        if (this.framesProcessed === totalNumFrames) {
+            this.loadStatus.loaded = true;
+            this.loadStatus.loading = false;
+        }
+        this.callLoadStatusCallback({
+            success: false,
+            imageId,
+            imageIdIndex,
+            error,
+            framesLoaded: this.framesLoaded,
+            framesProcessed: this.framesProcessed,
+            framesUpdated: this.framesUpdated,
+            numFrames,
+            totalNumFrames,
+        });
+        if (this.loadStatus.loaded) {
+            this.loadStatus.callbacks = [];
+        }
+        const eventDetail = {
+            error,
+            imageIdIndex,
+            imageId,
+        };
+        (0,esm.triggerEvent)(esm.eventTarget, esm.Enums.Events.IMAGE_LOAD_ERROR, eventDetail);
+    }
+    getLoaderImageOptions(imageId) {
+        const { transferSyntaxUID: transferSyntaxUID } = esm.metaData.get('transferSyntax', imageId) || {};
+        const imagePlaneModule = esm.metaData.get('imagePlaneModule', imageId) || {};
+        const { rows, columns } = imagePlaneModule;
+        const imageIdIndex = this.getImageIdIndex(imageId);
+        const scalarData = this._getScalarDataByImageIdIndex(imageIdIndex);
+        if (!scalarData) {
+            return null;
+        }
+        const arrayBuffer = scalarData.buffer;
+        const { type, length, lengthInBytes } = getScalarDataType(scalarData, this.numFrames);
+        const modalityLutModule = esm.metaData.get('modalityLutModule', imageId) || {};
+        const generalSeriesModule = esm.metaData.get('generalSeriesModule', imageId) || {};
+        const scalingParameters = {
+            rescaleSlope: modalityLutModule.rescaleSlope,
+            rescaleIntercept: modalityLutModule.rescaleIntercept,
+            modality: generalSeriesModule.modality,
+        };
+        if (scalingParameters.modality === 'PT') {
+            const suvFactor = esm.metaData.get('scalingModule', imageId);
+            if (suvFactor) {
+                this._addScalingToVolume(suvFactor);
+                scalingParameters.suvbw = suvFactor.suvbw;
+            }
+        }
+        const isSlopeAndInterceptNumbers = typeof scalingParameters.rescaleSlope === 'number' &&
+            typeof scalingParameters.rescaleIntercept === 'number';
+        this.isPreScaled = isSlopeAndInterceptNumbers;
+        const frameIndex = this._imageIdIndexToFrameIndex(imageIdIndex);
+        return {
+            targetBuffer: {
+                arrayBuffer: arrayBuffer instanceof ArrayBuffer ? undefined : arrayBuffer,
+                offset: frameIndex * lengthInBytes,
+                length,
+                type,
+                rows,
+                columns,
+            },
+            skipCreateImage: true,
+            preScale: {
+                enabled: true,
+                scalingParameters,
+            },
+            transferPixelData: true,
+            transferSyntaxUID,
+            loader: esm.imageLoader.loadImage,
+            additionalDetails: {
+                imageId,
+                imageIdIndex,
+                volumeId: this.volumeId,
+            },
+        };
+    }
+    callLoadImage(imageId, imageIdIndex, options) {
+        const { cachedFrames } = this;
+        if (cachedFrames[imageIdIndex] === ImageQualityStatus.FULL_RESOLUTION) {
+            return;
+        }
+        const uncompressedIterator = ProgressiveIterator.as(esm.imageLoader.loadImage(imageId, options));
+        return uncompressedIterator.forEach((image) => {
+            this.successCallback(imageId, image);
+        }, this.errorCallback.bind(this, imageIdIndex, imageId));
+    }
+    getImageIdsRequests(imageIds, priorityDefault) {
+        this.totalNumFrames = this.imageIds.length;
+        const autoRenderPercentage = 2;
+        if (this.autoRenderOnLoad) {
+            this.reRenderFraction =
+                this.totalNumFrames * (autoRenderPercentage / 100);
+            this.reRenderTarget = this.reRenderFraction;
+        }
+        const requests = imageIds.map((imageId) => {
+            const imageIdIndex = this.getImageIdIndex(imageId);
+            const requestType = requestTypeDefault;
+            const priority = priorityDefault;
+            const options = this.getLoaderImageOptions(imageId);
+            return {
+                callLoadImage: this.callLoadImage.bind(this),
+                imageId,
+                imageIdIndex,
+                options,
+                priority,
+                requestType,
+                additionalDetails: {
+                    volumeId: this.volumeId,
+                },
+            };
+        });
+        return requests;
+    }
+    handleImageComingFromCache(cachedImageOrVolume, isFromImageCache, scalingParameters, scalarData, frameIndex, arrayBuffer, imageIdIndex, imageId) {
         const imageLoadObject = isFromImageCache
             ? cachedImageOrVolume.imageLoadObject
             : cachedImageOrVolume.convertToCornerstoneImage(imageId, imageIdIndex);
@@ -707,18 +680,21 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
             }
             const volumeBufferView = new TypedArray(arrayBuffer, byteOffset, pixelsPerImage);
             volumeBufferView.set(imageScalarData);
-            updateTextureAndTriggerEvents(this, imageIdIndex, imageId);
+            this.updateTextureAndTriggerEvents(imageIdIndex, imageId, cachedImage.imageQualityStatus);
         })
             .catch((err) => {
-            errorCallback.call(this, err, imageIdIndex, imageId);
+            this.errorCallback(imageId, true, err);
         });
     }
     getImageLoadRequests(_priority) {
         throw new Error('Abstract method');
     }
-    _prefetchImageIds(priority) {
+    getImageIdsToLoad() {
+        throw new Error('Abstract method');
+    }
+    loadImages(imageIds, listener) {
         this.loadStatus.loading = true;
-        const requests = this.getImageLoadRequests(priority);
+        const requests = this.getImageLoadRequests(5);
         requests.reverse().forEach((request) => {
             if (!request) {
                 return;
@@ -726,6 +702,22 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
             const { callLoadImage, imageId, imageIdIndex, options, priority, requestType, additionalDetails, } = request;
             esm.imageLoadPoolManager.addRequest(callLoadImage.bind(this, imageId, imageIdIndex, options), requestType, additionalDetails, priority);
         });
+        return Promise.resolve(true);
+    }
+    _prefetchImageIds() {
+        this.loadStatus.loading = true;
+        const imageIds = [...this.getImageIdsToLoad()];
+        imageIds.reverse();
+        this.totalNumFrames = this.imageIds.length;
+        const autoRenderPercentage = 2;
+        if (this.autoRenderOnLoad) {
+            this.reRenderFraction =
+                this.totalNumFrames * (autoRenderPercentage / 100);
+            this.reRenderTarget = this.reRenderFraction;
+        }
+        return this.imagesLoader.loadImages(imageIds, this).catch((e) => {
+            console.debug('progressive loading failed to complete', e);
+        });
     }
     _scaleIfNecessary(image, scalingParametersToUse) {
         const imageIsAlreadyScaled = image.preScale?.scaled;
@@ -877,20 +869,94 @@ class BaseStreamingImageVolume_BaseStreamingImageVolume extends esm.ImageVolume
         }
     }
 }
+function getScalarDataType(scalarData, numFrames) {
+    let type, byteSize;
+    if (scalarData instanceof Uint8Array) {
+        type = 'Uint8Array';
+        byteSize = 1;
+    }
+    else if (scalarData instanceof Float32Array) {
+        type = 'Float32Array';
+        byteSize = 4;
+    }
+    else if (scalarData instanceof Uint16Array) {
+        type = 'Uint16Array';
+        byteSize = 2;
+    }
+    else if (scalarData instanceof Int16Array) {
+        type = 'Int16Array';
+        byteSize = 2;
+    }
+    else {
+        throw new Error('Unsupported array type');
+    }
+    const length = scalarData.length / numFrames;
+    const lengthInBytes = length * byteSize;
+    return { type, byteSize, length, lengthInBytes };
+}
+function handleArrayBufferLoad(scalarData, image, options) {
+    if (!(scalarData.buffer instanceof ArrayBuffer)) {
+        return;
+    }
+    const offset = options.targetBuffer.offset;
+    const length = options.targetBuffer.length;
+    const pixelData = image.pixelData ? image.pixelData : image.getPixelData();
+    try {
+        if (scalarData instanceof Float32Array) {
+            const bytesInFloat = 4;
+            const floatView = new Float32Array(pixelData);
+            if (floatView.length !== length) {
+                throw 'Error pixelData length does not match frame length';
+            }
+            scalarData.set(floatView, offset / bytesInFloat);
+        }
+        if (scalarData instanceof Int16Array) {
+            const bytesInInt16 = 2;
+            const intView = new Int16Array(pixelData);
+            if (intView.length !== length) {
+                throw 'Error pixelData length does not match frame length';
+            }
+            scalarData.set(intView, offset / bytesInInt16);
+        }
+        if (scalarData instanceof Uint16Array) {
+            const bytesInUint16 = 2;
+            const intView = new Uint16Array(pixelData);
+            if (intView.length !== length) {
+                throw 'Error pixelData length does not match frame length';
+            }
+            scalarData.set(intView, offset / bytesInUint16);
+        }
+        if (scalarData instanceof Uint8Array) {
+            const bytesInUint8 = 1;
+            const intView = new Uint8Array(pixelData);
+            if (intView.length !== length) {
+                throw 'Error pixelData length does not match frame length';
+            }
+            scalarData.set(intView, offset / bytesInUint8);
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+}
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/StreamingImageVolume.js
 
 class StreamingImageVolume extends BaseStreamingImageVolume_BaseStreamingImageVolume {
     constructor(imageVolumeProperties, streamingProperties) {
         super(imageVolumeProperties, streamingProperties);
+        this.getImageIdsToLoad = () => {
+            const { imageIds } = this;
+            this.numFrames = imageIds.length;
+            return imageIds;
+        };
     }
     getScalarData() {
         return this.scalarData;
     }
     getImageLoadRequests(priority) {
         const { imageIds } = this;
-        const scalarData = this.scalarData;
-        return this.getImageIdsRequests(imageIds, scalarData, priority);
+        return this.getImageIdsRequests(imageIds, priority);
     }
 }
 
@@ -929,7 +995,7 @@ function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
                 });
             })).catch(console.error);
         }
-        const { imageIds } = options;
+        const { imageIds, progressiveRendering } = options;
         const volumeMetadata = makeVolumeMetadata_makeVolumeMetadata(imageIds);
         const imageIdIndex = Math.floor(imageIds.length / 2);
         const imageId = imageIds[imageIdIndex];
@@ -1071,8 +1137,8 @@ class StreamingDynamicImageVolume_StreamingDynamicImageVolume extends (/* unused
         super(imageVolumeProperties, streamingProperties);
         this._timePointIndex = 0;
         this._getTimePointRequests = (timePoint, priority) => {
-            const { imageIds, scalarData } = timePoint;
-            return this.getImageIdsRequests(imageIds, scalarData, priority);
+            const { imageIds } = timePoint;
+            return this.getImageIdsRequests(imageIds, priority);
         };
         this._getTimePointsRequests = (priority) => {
             const timePoints = this._getTimePointsToLoad();
@@ -1084,7 +1150,7 @@ class StreamingDynamicImageVolume_StreamingDynamicImageVolume extends (/* unused
             return timePointsRequests;
         };
         this.getImageLoadRequests = (priority) => {
-            return this._getTimePointsRequests(priority).reverse();
+            return this._getTimePointsRequests(priority);
         };
         this._numTimePoints = this.scalarData.length;
         this._timePoints = this._getTimePointsData();
@@ -1128,6 +1194,15 @@ class StreamingDynamicImageVolume_StreamingDynamicImageVolume extends (/* unused
         }
         return timePointsToLoad;
     }
+    getImageIdsToLoad() {
+        const timePoints = this._getTimePointsToLoad();
+        let imageIds = [];
+        timePoints.forEach((timePoint) => {
+            const { imageIds: timePointIds } = timePoint;
+            imageIds = imageIds.concat(timePointIds);
+        });
+        return imageIds;
+    }
     isDynamicVolume() {
         return true;
     }