@cornerstonejs/core 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -0,0 +1,340 @@
+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 = this.isDynamicVolume()
+                ? this
+                : 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/Contour.d.ts

@@ -1,12 +1,12 @@
-import { Point3, ContourData, IContour } from '../../types';
-import { ContourType } from '../../enums';
-declare type ContourProps = {
+import type { Point3, ContourData } from '../../types';
+import type { ContourType } from '../../enums';
+interface ContourProps {
     id: string;
     data: ContourData;
     color: Point3;
     segmentIndex: number;
-};
-export declare class Contour implements IContour {
+}
+export declare class Contour {
     readonly id: string;
     readonly sizeInBytes: number;
     points: Point3[];

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

@@ -27,4 +27,3 @@ export class Contour {
     }
 }
 export default Contour;
-//# sourceMappingURL=Contour.js.map

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

@@ -1,13 +1,13 @@
-import { Point3, IContourSet, IContour, ContourData } from '../../types';
+import type { Point3, IContour, ContourData } from '../../types';
 import Contour from './Contour';
-declare type ContourSetProps = {
+interface ContourSetProps {
     id: string;
     data: ContourData[];
     frameOfReferenceUID: string;
     segmentIndex: number;
     color?: Point3;
-};
-export declare class ContourSet implements IContourSet {
+}
+export declare class ContourSet {
     readonly id: string;
     readonly sizeInBytes: number;
     readonly frameOfReferenceUID: string;

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

@@ -101,4 +101,3 @@ export class ContourSet {
     }
 }
 export default Contour;
-//# sourceMappingURL=ContourSet.js.map

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

@@ -1,10 +1,18 @@
-import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { IVolume, VolumeScalarData, Metadata, Point3, IImageVolume, Mat3 } from '../../types';
-export declare class ImageVolume implements IImageVolume {
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { Metadata, Point3, Mat3, ImageVolumeProps, IImage, PixelDataTypedArrayString, RGB, IVoxelManager } from '../../types';
+import type vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
+export interface vtkStreamingOpenGLTexture extends vtkOpenGLTexture {
+    setUpdatedFrame: (frame: number) => void;
+    setVolumeId: (volumeId: string) => void;
+    releaseGraphicsResources: () => void;
+}
+export declare class ImageVolume {
     private _imageIds;
     private _imageIdsIndexMap;
     private _imageURIsIndexMap;
-    protected scalarData: VolumeScalarData | Array<VolumeScalarData>;
+    protected numFrames: number;
+    protected totalNumFrames: number;
+    protected cornerstoneImageMetaData: any;
     readonly volumeId: string;
     isPreScaled: boolean;
     dimensions: Point3;
@@ -19,23 +27,35 @@ export declare class ImageVolume implements IImageVolume {
             suvbwToSuvbsa?: number;
         };
     };
-    sizeInBytes?: number;
     spacing: Point3;
     numVoxels: number;
     imageData?: vtkImageData;
-    vtkOpenGLTexture: any;
-    loadStatus?: Record<string, any>;
+    vtkOpenGLTexture: vtkStreamingOpenGLTexture;
+    loadStatus?: Record<string, unknown>;
     referencedVolumeId?: string;
+    referencedImageIds?: string[];
     hasPixelSpacing: boolean;
-    constructor(props: IVolume);
-    get imageIds(): Array<string>;
-    set imageIds(newImageIds: Array<string>);
+    additionalDetails?: Record<string, unknown>;
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+    dataType?: PixelDataTypedArrayString;
+    numTimePoints?: number;
+    constructor(props: ImageVolumeProps);
+    get sizeInBytes(): number;
+    get imageIds(): string[];
+    set imageIds(newImageIds: string[]);
     private _reprocessImageIds;
     cancelLoading: () => void;
     isDynamicVolume(): boolean;
-    getScalarData(): VolumeScalarData;
     getImageIdIndex(imageId: string): number;
+    getImageIdByIndex(imageIdIndex: number): string;
     getImageURIIndex(imageURI: string): number;
     destroy(): void;
+    invalidate(): void;
+    modified(): void;
+    removeFromCache(): void;
+    getScalarDataLength(): number;
+    private _getNumFrames;
+    protected imageIdIndexToFrameIndex(imageIdIndex: number): number;
+    getCornerstoneImages(): IImage[];
 }
 export default ImageVolume;

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

@@ -1,29 +1,73 @@
-import isTypedArray from '../../utilities/isTypedArray';
-import { imageIdToURI } from '../../utilities';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import imageIdToURI from '../../utilities/imageIdToURI';
+import VoxelManager from '../../utilities/VoxelManager';
 import { vtkStreamingOpenGLTexture } from '../../RenderingEngine/vtkClasses';
+import cache from '../cache';
 export class ImageVolume {
     constructor(props) {
         this._imageIdsIndexMap = new Map();
         this._imageURIsIndexMap = new Map();
+        this.cornerstoneImageMetaData = null;
         this.isPreScaled = false;
-        this.volumeId = props.volumeId;
-        this.metadata = props.metadata;
-        this.dimensions = props.dimensions;
-        this.spacing = props.spacing;
-        this.origin = props.origin;
-        this.direction = props.direction;
-        this.imageData = props.imageData;
-        this.scalarData = props.scalarData;
-        this.sizeInBytes = props.sizeInBytes;
+        this.numTimePoints = null;
+        const { imageIds, scaling, dimensions, spacing, origin, direction, dataType, volumeId, referencedVolumeId, metadata, referencedImageIds, additionalDetails, voxelManager, numberOfComponents, } = props;
+        if (!dataType) {
+            throw new Error('Data type is required, please provide a data type as string such as "Uint8Array", "Float32Array", etc.');
+        }
+        let { imageData } = props;
+        this.imageIds = imageIds;
+        this.volumeId = volumeId;
+        this.metadata = metadata;
+        this.dimensions = dimensions;
+        this.spacing = spacing;
+        this.origin = origin;
+        this.direction = direction;
+        this.dataType = dataType;
         this.vtkOpenGLTexture = vtkStreamingOpenGLTexture.newInstance();
+        this.vtkOpenGLTexture.setVolumeId(volumeId);
+        this.voxelManager =
+            voxelManager ??
+                VoxelManager.createImageVolumeVoxelManager({
+                    dimensions,
+                    imageIds,
+                    numberOfComponents,
+                });
         this.numVoxels =
             this.dimensions[0] * this.dimensions[1] * this.dimensions[2];
-        if (props.scaling) {
-            this.scaling = props.scaling;
+        if (!imageData) {
+            imageData = vtkImageData.newInstance();
+            imageData.setDimensions(dimensions);
+            imageData.setSpacing(spacing);
+            imageData.setDirection(direction);
+            imageData.setOrigin(origin);
+        }
+        imageData.set({
+            dataType: dataType,
+            voxelManager: this.voxelManager,
+            id: volumeId,
+            numberOfComponents: numberOfComponents || 1,
+        });
+        imageData.set({
+            hasScalarVolume: false,
+        });
+        this.imageData = imageData;
+        this.numFrames = this._getNumFrames();
+        this._reprocessImageIds();
+        if (scaling) {
+            this.scaling = scaling;
+        }
+        if (referencedVolumeId) {
+            this.referencedVolumeId = referencedVolumeId;
         }
-        if (props.referencedVolumeId) {
-            this.referencedVolumeId = props.referencedVolumeId;
+        if (referencedImageIds) {
+            this.referencedImageIds = referencedImageIds;
         }
+        if (additionalDetails) {
+            this.additionalDetails = additionalDetails;
+        }
+    }
+    get sizeInBytes() {
+        return this.voxelManager.sizeInBytes;
     }
     get imageIds() {
         return this._imageIds;
@@ -42,27 +86,55 @@ export class ImageVolume {
         });
     }
     isDynamicVolume() {
-        return false;
-    }
-    getScalarData() {
-        if (isTypedArray(this.scalarData)) {
-            return this.scalarData;
-        }
-        throw new Error('Unknow scalar data type');
+        return this.numTimePoints > 1;
     }
     getImageIdIndex(imageId) {
         return this._imageIdsIndexMap.get(imageId);
     }
+    getImageIdByIndex(imageIdIndex) {
+        return this._imageIds[imageIdIndex];
+    }
     getImageURIIndex(imageURI) {
         return this._imageURIsIndexMap.get(imageURI);
     }
     destroy() {
         this.imageData.delete();
         this.imageData = null;
-        this.scalarData = null;
+        this.voxelManager.clear();
         this.vtkOpenGLTexture.releaseGraphicsResources();
         this.vtkOpenGLTexture.delete();
     }
+    invalidate() {
+        for (let i = 0; i < this.imageIds.length; i++) {
+            this.vtkOpenGLTexture.setUpdatedFrame(i);
+        }
+        this.imageData.modified();
+    }
+    modified() {
+        this.imageData.modified();
+        this.vtkOpenGLTexture.modified();
+        this.numFrames = this._getNumFrames();
+    }
+    removeFromCache() {
+        cache.removeVolumeLoadObject(this.volumeId);
+    }
+    getScalarDataLength() {
+        return this.voxelManager.getScalarDataLength();
+    }
+    _getNumFrames() {
+        if (!this.isDynamicVolume()) {
+            return this.imageIds.length;
+        }
+        return this.numTimePoints;
+    }
+    imageIdIndexToFrameIndex(imageIdIndex) {
+        return imageIdIndex % this.numFrames;
+    }
+    getCornerstoneImages() {
+        const { imageIds } = this;
+        return imageIds.map((imageId) => {
+            return cache.getImage(imageId);
+        });
+    }
 }
 export default ImageVolume;
-//# sourceMappingURL=ImageVolume.js.map

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;
+        };
+    }[];
+}