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

package/dist/esm/RenderingEngine/BaseVolumeViewport.d.ts

@@ -1,11 +1,11 @@
 import type { mat4 } from 'gl-matrix';
 import type { BlendModes, InterpolationType, OrientationAxis } from '../enums';
-import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, IVolumeViewport } from '../types';
+import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, IBaseVolumeViewport } from '../types';
 import type { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { ViewportInput } from '../types/IViewport';
 import type { TransferFunctionNodes } from '../types/ITransferFunctionNode';
 import Viewport from './Viewport';
-declare abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
+declare abstract class BaseVolumeViewport extends Viewport implements IBaseVolumeViewport {
     useCPURendering: boolean;
     private _FrameOfReferenceUID;
     protected initialTransferFunctionNodes: TransferFunctionNodes;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -419,6 +419,7 @@ class BaseVolumeViewport extends Viewport {
         const volumeIdToUse = applicableVolumeActorInfo.volumeId;
         let voiRangeToUse = voiRange;
         if (typeof voiRangeToUse === 'undefined') {
+            throw new Error('voiRangeToUse is undefined, need to implement this in the new volume model');
             const imageData = volumeActor.getMapper().getInputData();
             const range = imageData.getPointData().getScalars().getRange();
             const maxVoiRange = { lower: range[0], upper: range[1] };

package/dist/esm/RenderingEngine/StackViewport.js

@@ -1663,9 +1663,10 @@ class StackViewport extends Viewport {
             return options.asVolume;
         }
         let testIndex = this.getCurrentImageIdIndex();
-        const currentImageId = this.imageIds[testIndex];
+        let currentImageId = this.imageIds[testIndex];
         if (options.withNavigation && typeof sliceIndex === 'number') {
             testIndex = sliceIndex;
+            currentImageId = this.imageIds[testIndex];
         }
         if (!currentImageId) {
             return false;
@@ -1822,17 +1823,17 @@ class StackViewport extends Viewport {
     }
     _getImagePlaneModule(imageId) {
         const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+        this.hasPixelSpacing =
+            !imagePlaneModule.usingDefaultValues || this.calibration?.scale > 0;
         this.calibration ||= imagePlaneModule.calibration;
         const newImagePlaneModule = {
             ...imagePlaneModule,
         };
         if (!newImagePlaneModule.columnPixelSpacing) {
             newImagePlaneModule.columnPixelSpacing = 1;
-            this.hasPixelSpacing = this.calibration?.scale > 0;
         }
         if (!newImagePlaneModule.rowPixelSpacing) {
             newImagePlaneModule.rowPixelSpacing = 1;
-            this.hasPixelSpacing = this.calibration?.scale > 0;
         }
         if (!newImagePlaneModule.columnCosines) {
             newImagePlaneModule.columnCosines = [0, 1, 0];

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

@@ -42,4 +42,4 @@ declare class Cache implements ICache {
 }
 declare const cache: Cache;
 export default cache;
-export { Cache };
+export { Cache, cache };

package/dist/esm/cache/cache.js

@@ -498,4 +498,4 @@ class Cache {
 }
 const cache = new Cache();
 export default cache;
-export { Cache };
+export { Cache, cache };

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,338 @@
+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';
+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, };