@cornerstonejs/core 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/esm/cache/classes/BaseStreamingImageVolume.js

@@ -0,0 +1,339 @@
+import * as metaData from '../../metaData';
+import { Events, ImageQualityStatus, RequestType } from '../../enums';
+import eventTarget from '../../eventTarget';
+import imageLoadPoolManager from '../../requestPool/imageLoadPoolManager';
+import { ProgressiveIterator, imageRetrieveMetadataProvider, hasFloatScalingParameters, autoLoad, triggerEvent, } from '../../utilities';
+import ImageVolume from './ImageVolume';
+import ProgressiveRetrieveImages from '../../loaders/ProgressiveRetrieveImages';
+import { canRenderFloatTextures } from '../../init';
+import { loadAndCacheImage } from '../../loaders/imageLoader';
+import StreamingImageVolume from './StreamingImageVolume';
+const requestTypeDefault = RequestType.Prefetch;
+export default class BaseStreamingImageVolume extends ImageVolume {
+    constructor(imageVolumeProperties, streamingProperties) {
+        super(imageVolumeProperties);
+        this.framesLoaded = 0;
+        this.framesProcessed = 0;
+        this.framesUpdated = 0;
+        this.autoRenderOnLoad = true;
+        this.cachedFrames = [];
+        this.reRenderTarget = 0;
+        this.reRenderFraction = 2;
+        this.imagesLoader = this;
+        this.cancelLoading = () => {
+            const { loadStatus } = this;
+            if (!loadStatus || !loadStatus.loading) {
+                return;
+            }
+            loadStatus.loading = false;
+            loadStatus.cancelled = true;
+            this.clearLoadCallbacks();
+            const filterFunction = ({ additionalDetails }) => {
+                return additionalDetails.volumeId !== this.volumeId;
+            };
+            imageLoadPoolManager.filterRequests(filterFunction);
+        };
+        this.load = (callback) => {
+            const { imageIds, loadStatus, numFrames } = this;
+            const { transferSyntaxUID } = metaData.get('transferSyntax', imageIds[0]) || {};
+            const imageRetrieveConfiguration = metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, this.volumeId, transferSyntaxUID, 'volume');
+            this.imagesLoader = imageRetrieveConfiguration
+                ? (imageRetrieveConfiguration.create ||
+                    ProgressiveRetrieveImages.createProgressive)(imageRetrieveConfiguration)
+                : this;
+            if (loadStatus.loading === true) {
+                return;
+            }
+            const { loaded } = this.loadStatus;
+            const totalNumFrames = imageIds.length;
+            if (loaded) {
+                if (callback) {
+                    callback({
+                        success: true,
+                        framesLoaded: totalNumFrames,
+                        framesProcessed: totalNumFrames,
+                        numFrames,
+                        totalNumFrames,
+                    });
+                }
+                return;
+            }
+            if (callback) {
+                this.loadStatus.callbacks.push(callback);
+            }
+            this._prefetchImageIds();
+        };
+        this.loadStatus = streamingProperties.loadStatus;
+    }
+    invalidateVolume(immediate) {
+        const { vtkOpenGLTexture } = this;
+        const { numFrames } = this;
+        for (let i = 0; i < numFrames; i++) {
+            vtkOpenGLTexture.setUpdatedFrame(i);
+        }
+        this.modified();
+        if (immediate) {
+            autoLoad(this.volumeId);
+        }
+    }
+    clearLoadCallbacks() {
+        this.loadStatus.callbacks = [];
+    }
+    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;
+                autoLoad(volumeId);
+            }
+        }
+        if (framesProcessed === totalNumFrames) {
+            loadStatus.callbacks.forEach((callback) => callback(evt));
+            const eventDetail = {
+                FrameOfReferenceUID,
+                volumeId: volumeId,
+            };
+            triggerEvent(eventTarget, 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++;
+        }
+        const eventDetail = {
+            FrameOfReferenceUID,
+            volumeId: this.volumeId,
+            numberOfFrames: numFrames,
+            framesProcessed: this.framesProcessed,
+        };
+        triggerEvent(eventTarget, 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,
+        });
+        this.vtkOpenGLTexture.setUpdatedFrame(frameIndex);
+        if (this.loadStatus.loaded) {
+            this.loadStatus.callbacks = [];
+        }
+    }
+    successCallback(imageId, image) {
+        const imageIdIndex = this.getImageIdIndex(imageId);
+        const { imageQualityStatus } = image;
+        if (this.loadStatus.cancelled) {
+            console.warn('volume load cancelled, returning for imageIdIndex: ', imageIdIndex);
+            return;
+        }
+        return this.updateTextureAndTriggerEvents(imageIdIndex, imageId, imageQualityStatus);
+    }
+    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,
+        };
+        triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
+    }
+    getLoaderImageOptions(imageId) {
+        const { transferSyntaxUID: transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
+        const imagePlaneModule = metaData.get('imagePlaneModule', imageId) || {};
+        const { rows, columns } = imagePlaneModule;
+        const imageIdIndex = this.getImageIdIndex(imageId);
+        const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
+        const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+        const scalingParameters = {
+            rescaleSlope: modalityLutModule.rescaleSlope,
+            rescaleIntercept: modalityLutModule.rescaleIntercept,
+            modality: generalSeriesModule.modality,
+        };
+        if (scalingParameters.modality === 'PT') {
+            const suvFactor = metaData.get('scalingModule', imageId);
+            if (suvFactor) {
+                this._addScalingToVolume(suvFactor);
+                scalingParameters.suvbw = suvFactor.suvbw;
+            }
+        }
+        const floatAfterScale = hasFloatScalingParameters(scalingParameters);
+        const allowFloatRendering = canRenderFloatTextures();
+        this.isPreScaled = true;
+        if (scalingParameters &&
+            scalingParameters.rescaleSlope !== undefined &&
+            scalingParameters.rescaleIntercept !== undefined) {
+            const { rescaleSlope, rescaleIntercept } = scalingParameters;
+            this.isPreScaled =
+                typeof rescaleSlope === 'number' &&
+                    typeof rescaleIntercept === 'number';
+        }
+        if (!allowFloatRendering && floatAfterScale) {
+            this.isPreScaled = false;
+        }
+        const targetBuffer = {
+            type: this.dataType,
+            rows,
+            columns,
+        };
+        return {
+            targetBuffer,
+            allowFloatRendering,
+            preScale: {
+                enabled: this.isPreScaled,
+                scalingParameters,
+            },
+            transferPixelData: true,
+            requestType: requestTypeDefault,
+            transferSyntaxUID,
+            additionalDetails: {
+                imageId,
+                imageIdIndex,
+                volumeId: this.volumeId,
+            },
+        };
+    }
+    callLoadImage(imageId, imageIdIndex, options) {
+        const { cachedFrames } = this;
+        if (cachedFrames[imageIdIndex] === ImageQualityStatus.FULL_RESOLUTION) {
+            return;
+        }
+        const handleImageCacheAdded = (event) => {
+            const { image } = event.detail;
+            if (image.imageId === imageId) {
+                this.vtkOpenGLTexture.setUpdatedFrame(imageIdIndex);
+                eventTarget.removeEventListener(Events.IMAGE_CACHE_IMAGE_ADDED, handleImageCacheAdded);
+            }
+        };
+        eventTarget.addEventListener(Events.IMAGE_CACHE_IMAGE_ADDED, handleImageCacheAdded);
+        const uncompressedIterator = ProgressiveIterator.as(loadAndCacheImage(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;
+    }
+    getImageLoadRequests(priority) {
+        throw new Error('Abstract method');
+    }
+    getImageIdsToLoad() {
+        throw new Error('Abstract method');
+    }
+    loadImages() {
+        this.loadStatus.loading = true;
+        const requests = this.getImageLoadRequests(5);
+        requests.reverse().forEach((request) => {
+            if (!request) {
+                return;
+            }
+            const { callLoadImage, imageId, imageIdIndex, options, priority, requestType, additionalDetails, } = request;
+            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);
+        });
+    }
+    _addScalingToVolume(suvFactor) {
+        if (this.scaling) {
+            return;
+        }
+        const { suvbw, suvlbm, suvbsa } = suvFactor;
+        const petScaling = {};
+        if (suvlbm) {
+            petScaling.suvbwToSuvlbm = suvlbm / suvbw;
+        }
+        if (suvbsa) {
+            petScaling.suvbwToSuvbsa = suvbsa / suvbw;
+        }
+        if (suvbw) {
+            petScaling.suvbw = suvbw;
+        }
+        this.scaling = { PT: petScaling };
+    }
+}

package/dist/esm/cache/classes/ImageVolume.js

@@ -1,5 +1,6 @@
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { imageIdToURI, VoxelManager } from '../../utilities';
+import imageIdToURI from '../../utilities/imageIdToURI';
+import VoxelManager from '../../utilities/VoxelManager';
 import { vtkStreamingOpenGLTexture } from '../../RenderingEngine/vtkClasses';
 import cache from '../cache';
 export class ImageVolume {

package/dist/esm/cache/classes/StreamingDynamicImageVolume.d.ts

@@ -0,0 +1,52 @@
+import type { IDynamicImageVolume, ImageVolumeProps, IStreamingVolumeProperties } from '../../types';
+import BaseStreamingImageVolume from './BaseStreamingImageVolume';
+export default class StreamingDynamicImageVolume extends BaseStreamingImageVolume implements IDynamicImageVolume {
+    private _timePointIndex;
+    private _splittingTag;
+    private _imageIdGroups;
+    numTimePoints: number;
+    constructor(imageVolumeProperties: ImageVolumeProps & {
+        splittingTag: string;
+        imageIdGroups: string[][];
+    }, streamingProperties: IStreamingVolumeProperties);
+    private _getImageIdsToLoad;
+    private _getImageIdRequests;
+    getImageIdsToLoad(): string[];
+    get timePointIndex(): number;
+    set timePointIndex(index: number);
+    scroll(delta: number): void;
+    getCurrentTimePointImageIds(): string[];
+    flatImageIdIndexToTimePointIndex(flatImageIdIndex: number): number;
+    flatImageIdIndexToImageIdIndex(flatImageIdIndex: number): number;
+    get splittingTag(): string;
+    getImageLoadRequests: (priority: number) => {
+        callLoadImage: (imageId: any, imageIdIndex: any, options: any) => any;
+        imageId: string;
+        imageIdIndex: number;
+        options: {
+            targetBuffer: {
+                type: import("../../types").PixelDataTypedArrayString;
+                rows: any;
+                columns: any;
+            };
+            allowFloatRendering: boolean;
+            preScale: {
+                enabled: boolean;
+                scalingParameters: import("../../types").ScalingParameters;
+            };
+            transferPixelData: boolean;
+            requestType: import("../../enums").RequestType;
+            transferSyntaxUID: any;
+            additionalDetails: {
+                imageId: string;
+                imageIdIndex: number;
+                volumeId: string;
+            };
+        };
+        priority: number;
+        requestType: import("../../enums").RequestType;
+        additionalDetails: {
+            volumeId: string;
+        };
+    }[];
+}

package/dist/esm/cache/classes/StreamingDynamicImageVolume.js

@@ -0,0 +1,81 @@
+import { Events } from '../../enums';
+import eventTarget from '../../eventTarget';
+import { triggerEvent } from '../../utilities';
+import BaseStreamingImageVolume from './BaseStreamingImageVolume';
+export default class StreamingDynamicImageVolume extends BaseStreamingImageVolume {
+    constructor(imageVolumeProperties, streamingProperties) {
+        super(imageVolumeProperties, streamingProperties);
+        this._timePointIndex = 0;
+        this._getImageIdRequests = (imageIds, priority) => {
+            return this.getImageIdsRequests(imageIds, priority);
+        };
+        this.getImageLoadRequests = (priority) => {
+            const imageIds = this.getImageIdsToLoad();
+            return this._getImageIdRequests(imageIds, priority);
+        };
+        const { imageIdGroups, splittingTag } = imageVolumeProperties;
+        this._splittingTag = splittingTag;
+        this._imageIdGroups = imageIdGroups;
+        this.numTimePoints = this._imageIdGroups.length;
+    }
+    _getImageIdsToLoad() {
+        const imageIdGroups = this._imageIdGroups;
+        const initialImageIdGroupIndex = this._timePointIndex;
+        const imageIds = [...imageIdGroups[initialImageIdGroupIndex]];
+        let leftIndex = initialImageIdGroupIndex - 1;
+        let rightIndex = initialImageIdGroupIndex + 1;
+        while (leftIndex >= 0 || rightIndex < imageIdGroups.length) {
+            if (leftIndex >= 0) {
+                imageIds.push(...imageIdGroups[leftIndex--]);
+            }
+            if (rightIndex < imageIdGroups.length) {
+                imageIds.push(...imageIdGroups[rightIndex++]);
+            }
+        }
+        return imageIds;
+    }
+    getImageIdsToLoad() {
+        return this._getImageIdsToLoad();
+    }
+    get timePointIndex() {
+        return this._timePointIndex;
+    }
+    set timePointIndex(index) {
+        if (this._timePointIndex === index) {
+            return;
+        }
+        this._timePointIndex = index;
+        this.voxelManager.setTimePoint(index);
+        this.invalidateVolume(true);
+        triggerEvent(eventTarget, Events.DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED, {
+            volumeId: this.volumeId,
+            imageIdGroupIndex: index,
+            numImageIdGroups: this.numTimePoints,
+            splittingTag: this.splittingTag,
+        });
+    }
+    scroll(delta) {
+        const newIndex = this._timePointIndex + delta;
+        if (newIndex < 0) {
+            this.timePointIndex = this.numTimePoints - 1;
+        }
+        else if (newIndex >= this.numTimePoints) {
+            this.timePointIndex = 0;
+        }
+        else {
+            this.timePointIndex = newIndex;
+        }
+    }
+    getCurrentTimePointImageIds() {
+        return this._imageIdGroups[this._timePointIndex];
+    }
+    flatImageIdIndexToTimePointIndex(flatImageIdIndex) {
+        return Math.floor(flatImageIdIndex / this._imageIdGroups[0].length);
+    }
+    flatImageIdIndexToImageIdIndex(flatImageIdIndex) {
+        return flatImageIdIndex % this._imageIdGroups[0].length;
+    }
+    get splittingTag() {
+        return this._splittingTag;
+    }
+}

package/dist/esm/cache/classes/StreamingImageVolume.d.ts

@@ -0,0 +1,8 @@
+import type { ImageLoadRequests, ImageVolumeProps, IStreamingVolumeProperties, PixelDataTypedArray } from '../../types';
+import BaseStreamingImageVolume from './BaseStreamingImageVolume';
+export default class StreamingImageVolume extends BaseStreamingImageVolume {
+    constructor(imageVolumeProperties: ImageVolumeProps, streamingProperties: IStreamingVolumeProperties);
+    getScalarData(): PixelDataTypedArray;
+    getImageLoadRequests(priority: number): ImageLoadRequests[];
+    getImageIdsToLoad: () => string[];
+}

package/dist/esm/cache/classes/StreamingImageVolume.js

@@ -0,0 +1,21 @@
+import BaseStreamingImageVolume from './BaseStreamingImageVolume';
+export default class StreamingImageVolume extends BaseStreamingImageVolume {
+    constructor(imageVolumeProperties, streamingProperties) {
+        if (!imageVolumeProperties.imageIds) {
+            imageVolumeProperties.imageIds = streamingProperties.imageIds;
+        }
+        super(imageVolumeProperties, streamingProperties);
+        this.getImageIdsToLoad = () => {
+            const { imageIds } = this;
+            this.numFrames = imageIds.length;
+            return imageIds;
+        };
+    }
+    getScalarData() {
+        return this.voxelManager.getScalarData();
+    }
+    getImageLoadRequests(priority) {
+        const { imageIds } = this;
+        return this.getImageIdsRequests(imageIds, priority);
+    }
+}

package/dist/esm/cache/index.d.ts

@@ -1,5 +1,6 @@
-import cache, { Cache } from './cache';
+import { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
 import { Surface } from './classes/Surface';
-export { ImageVolume, Cache, Surface };
-export default cache;
+import StreamingImageVolume from './classes/StreamingImageVolume';
+import StreamingDynamicImageVolume from './classes/StreamingDynamicImageVolume';
+export { ImageVolume, Cache, Surface, StreamingImageVolume, StreamingDynamicImageVolume, };

package/dist/esm/cache/index.js

@@ -1,5 +1,6 @@
-import cache, { Cache } from './cache';
+import { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
 import { Surface } from './classes/Surface';
-export { ImageVolume, Cache, Surface };
-export default cache;
+import StreamingImageVolume from './classes/StreamingImageVolume';
+import StreamingDynamicImageVolume from './classes/StreamingDynamicImageVolume';
+export { ImageVolume, Cache, Surface, StreamingImageVolume, StreamingDynamicImageVolume, };

package/dist/esm/enums/Events.d.ts

@@ -33,6 +33,7 @@ declare enum Events {
     VOLUME_VIEWPORT_SCROLL = "VOLUME_VIEWPORT_SCROLL",
     CLIPPING_PLANES_UPDATED = "CORNERSTONE_CLIPPING_PLANES_UPDATED",
     WEB_WORKER_PROGRESS = "CORNERSTONE_WEB_WORKER_PROGRESS",
-    COLORMAP_MODIFIED = "CORNERSTONE_COLORMAP_MODIFIED"
+    COLORMAP_MODIFIED = "CORNERSTONE_COLORMAP_MODIFIED",
+    DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED = "DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED"
 }
 export default Events;

package/dist/esm/enums/Events.js

@@ -35,5 +35,6 @@ var Events;
     Events["CLIPPING_PLANES_UPDATED"] = "CORNERSTONE_CLIPPING_PLANES_UPDATED";
     Events["WEB_WORKER_PROGRESS"] = "CORNERSTONE_WEB_WORKER_PROGRESS";
     Events["COLORMAP_MODIFIED"] = "CORNERSTONE_COLORMAP_MODIFIED";
+    Events["DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED"] = "DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED";
 })(Events || (Events = {}));
 export default Events;

package/dist/esm/index.d.ts

@@ -1,8 +1,10 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import { createVolumeActor, createVolumeMapper, getOrCreateCanvas } from './RenderingEngine';
 import RenderingEngine from './RenderingEngine';
+import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
+import createVolumeMapper from './RenderingEngine/helpers/createVolumeMapper';
+import getOrCreateCanvas from './RenderingEngine/helpers/getOrCreateCanvas';
 import VolumeViewport from './RenderingEngine/VolumeViewport';
 import VolumeViewport3D from './RenderingEngine/VolumeViewport3D';
 import BaseVolumeViewport from './RenderingEngine/BaseVolumeViewport';
@@ -12,7 +14,8 @@ import WSIViewport from './RenderingEngine/WSIViewport';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { getRenderingEngine, getRenderingEngines } from './RenderingEngine/getRenderingEngine';
-import cache, { ImageVolume, Surface } from './cache';
+import { ImageVolume, Surface } from './cache';
+import cache from './cache/cache';
 import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements } from './getEnabledElement';
@@ -28,6 +31,8 @@ import type { IRetrieveConfiguration, IImagesLoader, RetrieveOptions, RetrieveSt
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
+import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
+import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, };
+export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, };

package/dist/esm/index.js

@@ -1,8 +1,10 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import { createVolumeActor, createVolumeMapper, getOrCreateCanvas, } from './RenderingEngine';
 import RenderingEngine from './RenderingEngine';
+import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
+import createVolumeMapper from './RenderingEngine/helpers/createVolumeMapper';
+import getOrCreateCanvas from './RenderingEngine/helpers/getOrCreateCanvas';
 import VolumeViewport from './RenderingEngine/VolumeViewport';
 import VolumeViewport3D from './RenderingEngine/VolumeViewport3D';
 import BaseVolumeViewport from './RenderingEngine/BaseVolumeViewport';
@@ -12,7 +14,8 @@ import WSIViewport from './RenderingEngine/WSIViewport';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { getRenderingEngine, getRenderingEngines, } from './RenderingEngine/getRenderingEngine';
-import cache, { ImageVolume, Surface } from './cache';
+import { ImageVolume, Surface } from './cache';
+import cache from './cache/cache';
 import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements, } from './getEnabledElement';
@@ -26,5 +29,7 @@ import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
+import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
+import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, };
+export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, };

package/dist/esm/init.js

@@ -1,6 +1,6 @@
 import { getRenderingEngines } from './RenderingEngine/getRenderingEngine';
 let csRenderInitialized = false;
-import { deepMerge } from './utilities';
+import deepMerge from './utilities/deepMerge';
 import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager';
 const defaultConfig = {
     gpuTier: { tier: 2 },

package/dist/esm/loaders/ProgressiveRetrieveImages.js

@@ -2,10 +2,12 @@ import singleRetrieveStages from './configuration/singleRetrieve';
 import sequentialRetrieveStages from './configuration/sequentialRetrieve';
 import interleavedRetrieveStages from './configuration/interleavedRetrieve';
 import { loadAndCacheImage } from './imageLoader';
-import { triggerEvent, ProgressiveIterator, decimate } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
+import ProgressiveIterator from '../utilities/ProgressiveIterator';
+import decimate from '../utilities/decimate';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import { ImageQualityStatus, RequestType, Events } from '../enums';
-import cache from '../cache';
+import cache from '../cache/cache';
 import eventTarget from '../eventTarget';
 import { fillNearbyFrames } from './fillNearbyFrames';
 export { sequentialRetrieveStages, interleavedRetrieveStages, singleRetrieveStages, };

package/dist/esm/loaders/cornerstoneStreamingDynamicImageVolumeLoader.d.ts

@@ -0,0 +1,10 @@
+import { StreamingDynamicImageVolume } from '../cache';
+interface IVolumeLoader {
+    promise: Promise<StreamingDynamicImageVolume>;
+    cancel: () => void;
+    decache: () => void;
+}
+declare function cornerstoneStreamingDynamicImageVolumeLoader(volumeId: string, options: {
+    imageIds: string[];
+}): IVolumeLoader;
+export { cornerstoneStreamingDynamicImageVolumeLoader };