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

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

@@ -0,0 +1,85 @@
+import { ImageQualityStatus, RequestType } from '../../enums';
+import type { IImagesLoader, ImageLoadRequests, ImageVolumeProps, IStreamingVolumeProperties, PixelDataTypedArrayString, ScalingParameters } from '../../types';
+import ImageVolume from './ImageVolume';
+export default class BaseStreamingImageVolume extends ImageVolume implements IImagesLoader {
+    private framesLoaded;
+    private framesProcessed;
+    private framesUpdated;
+    protected autoRenderOnLoad: boolean;
+    protected cachedFrames: any[];
+    protected reRenderTarget: number;
+    protected reRenderFraction: number;
+    dataType: PixelDataTypedArrayString;
+    loadStatus: {
+        loaded: boolean;
+        loading: boolean;
+        cancelled: boolean;
+        callbacks: Array<(...args: unknown[]) => void>;
+    };
+    imagesLoader: IImagesLoader;
+    constructor(imageVolumeProperties: ImageVolumeProps, streamingProperties: IStreamingVolumeProperties);
+    protected invalidateVolume(immediate: boolean): void;
+    cancelLoading: () => void;
+    clearLoadCallbacks(): void;
+    protected callLoadStatusCallback(evt: any): void;
+    protected updateTextureAndTriggerEvents(imageIdIndex: any, imageId: any, imageQualityStatus?: ImageQualityStatus): void;
+    successCallback(imageId: string, image: any): void;
+    errorCallback(imageId: any, permanent: any, error: any): void;
+    load: (callback: (...args: unknown[]) => void) => void;
+    getLoaderImageOptions(imageId: string): {
+        targetBuffer: {
+            type: PixelDataTypedArrayString;
+            rows: any;
+            columns: any;
+        };
+        allowFloatRendering: boolean;
+        preScale: {
+            enabled: boolean;
+            scalingParameters: ScalingParameters;
+        };
+        transferPixelData: boolean;
+        requestType: RequestType;
+        transferSyntaxUID: any;
+        additionalDetails: {
+            imageId: string;
+            imageIdIndex: number;
+            volumeId: string;
+        };
+    };
+    callLoadImage(imageId: any, imageIdIndex: any, options: any): any;
+    protected getImageIdsRequests(imageIds: string[], priorityDefault: number): {
+        callLoadImage: (imageId: any, imageIdIndex: any, options: any) => any;
+        imageId: string;
+        imageIdIndex: number;
+        options: {
+            targetBuffer: {
+                type: PixelDataTypedArrayString;
+                rows: any;
+                columns: any;
+            };
+            allowFloatRendering: boolean;
+            preScale: {
+                enabled: boolean;
+                scalingParameters: ScalingParameters;
+            };
+            transferPixelData: boolean;
+            requestType: RequestType;
+            transferSyntaxUID: any;
+            additionalDetails: {
+                imageId: string;
+                imageIdIndex: number;
+                volumeId: string;
+            };
+        };
+        priority: number;
+        requestType: RequestType;
+        additionalDetails: {
+            volumeId: string;
+        };
+    }[];
+    getImageLoadRequests(priority: number): ImageLoadRequests[];
+    getImageIdsToLoad(): string[];
+    loadImages(): Promise<boolean>;
+    private _prefetchImageIds;
+    private _addScalingToVolume;
+}

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/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,4 +1,6 @@
 import { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
 import { Surface } from './classes/Surface';
-export { ImageVolume, Cache, Surface };
+import StreamingImageVolume from './classes/StreamingImageVolume';
+import StreamingDynamicImageVolume from './classes/StreamingDynamicImageVolume';
+export { ImageVolume, Cache, Surface, StreamingImageVolume, StreamingDynamicImageVolume, };

package/dist/esm/cache/index.js

@@ -1,4 +1,6 @@
 import { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
 import { Surface } from './classes/Surface';
-export { ImageVolume, Cache, Surface };
+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

@@ -31,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

@@ -29,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/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 };