@cornerstonejs/core 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/cjs/utilities/ProgressiveIterator.js

@@ -0,0 +1,236 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseIterator = void 0;
+class PromiseIterator extends Promise {
+}
+exports.PromiseIterator = PromiseIterator;
+class ProgressiveIterator {
+    constructor(name) {
+        this.name = name || 'unknown';
+    }
+    static as(promise) {
+        if (promise.iterator) {
+            return promise.iterator;
+        }
+        const iterator = new ProgressiveIterator('as iterator');
+        promise.then((v) => {
+            try {
+                iterator.add(v, true);
+            }
+            catch (e) {
+                iterator.reject(e);
+            }
+        }, (reason) => iterator.reject(reason));
+        return iterator;
+    }
+    add(x, done = false) {
+        this.nextValue = x;
+        this.done || (this.done = done);
+        if (this.waiting) {
+            this.waiting.resolve(x);
+            this.waiting = undefined;
+        }
+    }
+    resolve() {
+        this.done = true;
+        if (this.waiting) {
+            this.waiting.resolve(this.nextValue);
+            this.waiting = undefined;
+        }
+    }
+    reject(reason) {
+        var _a;
+        this.rejectReason = reason;
+        (_a = this.waiting) === null || _a === void 0 ? void 0 : _a.reject(reason);
+    }
+    getRecent() {
+        if (this.rejectReason) {
+            throw this.rejectReason;
+        }
+        return this.nextValue;
+    }
+    [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+            while (!this.done) {
+                if (this.rejectReason) {
+                    throw this.rejectReason;
+                }
+                if (this.nextValue !== undefined) {
+                    yield yield __await(this.nextValue);
+                    if (this.done) {
+                        break;
+                    }
+                }
+                if (!this.waiting) {
+                    this.waiting = {};
+                    this.waiting.promise = new Promise((resolve, reject) => {
+                        this.waiting.resolve = resolve;
+                        this.waiting.reject = reject;
+                    });
+                }
+                yield __await(this.waiting.promise);
+            }
+            yield yield __await(this.nextValue);
+        });
+    }
+    forEach(callback, errorCallback) {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let index = 0;
+            try {
+                try {
+                    for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const value = _c;
+                            const { done } = this;
+                            try {
+                                yield callback(value, done, index);
+                                index++;
+                            }
+                            catch (e) {
+                                if (!done) {
+                                    console.warn('Caught exception in intermediate value', e);
+                                    continue;
+                                }
+                                if (errorCallback) {
+                                    errorCallback(e, done);
+                                }
+                                else {
+                                    throw e;
+                                }
+                            }
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (e) {
+                if (errorCallback) {
+                    errorCallback(e, true);
+                }
+                else {
+                    throw e;
+                }
+            }
+        });
+    }
+    generate(processFunction, errorCallback) {
+        return processFunction(this, this.reject.bind(this)).then(() => {
+            if (!this.done) {
+                this.resolve();
+            }
+        }, (reason) => {
+            this.reject(reason);
+            if (errorCallback) {
+                errorCallback(reason);
+            }
+            else {
+                console.warn("Couldn't process because", reason);
+            }
+        });
+    }
+    nextPromise() {
+        var _a, e_2, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+                    _c = _f.value;
+                    _d = false;
+                    try {
+                        const i = _c;
+                        if (i) {
+                            return i;
+                        }
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return this.nextValue;
+        });
+    }
+    donePromise() {
+        var _a, e_3, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+                    _c = _f.value;
+                    _d = false;
+                    try {
+                        const i = _c;
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            return this.nextValue;
+        });
+    }
+    getNextPromise() {
+        const promise = this.nextPromise();
+        promise.iterator = this;
+        return promise;
+    }
+    getDonePromise() {
+        const promise = this.donePromise();
+        promise.iterator = this;
+        return promise;
+    }
+}
+exports.default = ProgressiveIterator;
+//# sourceMappingURL=ProgressiveIterator.js.map

package/dist/cjs/utilities/ProgressiveIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgressiveIterator.js","sourceRoot":"","sources":["../../../src/utilities/ProgressiveIterator.ts"],"names":[],"mappings":"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"}

package/dist/cjs/utilities/decimate.d.ts

@@ -0,0 +1 @@
+export default function decimate(list: Array<unknown>, interleave: number, offset?: number): number[];

package/dist/cjs/utilities/decimate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function decimate(list, interleave, offset = 0) {
+    const interleaveIndices = [];
+    for (let i = offset; i < list.length; i += interleave) {
+        interleaveIndices.push(i);
+    }
+    return interleaveIndices;
+}
+exports.default = decimate;
+//# sourceMappingURL=decimate.js.map

package/dist/cjs/utilities/decimate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimate.js","sourceRoot":"","sources":["../../../src/utilities/decimate.ts"],"names":[],"mappings":";;AAMA,SAAwB,QAAQ,CAC9B,IAAoB,EACpB,UAAkB,EAClB,MAAM,GAAG,CAAC;IAEV,MAAM,iBAAiB,GAAG,EAAE,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,UAAU,EAAE;QACrD,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;KAC3B;IACD,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAVD,2BAUC"}

package/dist/cjs/utilities/imageRetrieveMetadataProvider.d.ts

@@ -0,0 +1,7 @@
+declare const imageRetrieveMetadataProvider: {
+    IMAGE_RETRIEVE_CONFIGURATION: string;
+    clear: () => void;
+    add: (key: string, payload: any) => void;
+    get: (type: string, queriesOrQuery: string | string[]) => any;
+};
+export default imageRetrieveMetadataProvider;

package/dist/cjs/utilities/imageRetrieveMetadataProvider.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metaData_1 = require("../metaData");
+const retrieveConfigurationState = new Map();
+const IMAGE_RETRIEVE_CONFIGURATION = 'imageRetrieveConfiguration';
+const imageRetrieveMetadataProvider = {
+    IMAGE_RETRIEVE_CONFIGURATION,
+    clear: () => {
+        retrieveConfigurationState.clear();
+    },
+    add: (key, payload) => {
+        retrieveConfigurationState.set(key, payload);
+    },
+    get: (type, queriesOrQuery) => {
+        const queries = Array.isArray(queriesOrQuery)
+            ? queriesOrQuery
+            : [queriesOrQuery];
+        if (type === IMAGE_RETRIEVE_CONFIGURATION) {
+            return queries
+                .map((query) => retrieveConfigurationState.get(query))
+                .find((it) => it !== undefined);
+        }
+    },
+};
+(0, metaData_1.addProvider)(imageRetrieveMetadataProvider.get.bind(imageRetrieveMetadataProvider));
+exports.default = imageRetrieveMetadataProvider;
+//# sourceMappingURL=imageRetrieveMetadataProvider.js.map

package/dist/cjs/utilities/imageRetrieveMetadataProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageRetrieveMetadataProvider.js","sourceRoot":"","sources":["../../../src/utilities/imageRetrieveMetadataProvider.ts"],"names":[],"mappings":";;AAAA,0CAA0C;AAE1C,MAAM,0BAA0B,GAAG,IAAI,GAAG,EAAe,CAAC;AAE1D,MAAM,4BAA4B,GAAG,4BAA4B,CAAC;AAKlE,MAAM,6BAA6B,GAAG;IACpC,4BAA4B;IAG5B,KAAK,EAAE,GAAG,EAAE;QACV,0BAA0B,CAAC,KAAK,EAAE,CAAC;IACrC,CAAC;IAGD,GAAG,EAAE,CAAC,GAAW,EAAE,OAAO,EAAQ,EAAE;QAClC,0BAA0B,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED,GAAG,EAAE,CAAC,IAAY,EAAE,cAAiC,EAAE,EAAE;QACvD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC;YAC3C,CAAC,CAAC,cAAc;YAChB,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;QACrB,IAAI,IAAI,KAAK,4BAA4B,EAAE;YACzC,OAAO,OAAO;iBACX,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,0BAA0B,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;iBACrD,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC;SACnC;IACH,CAAC;CACF,CAAC;AAEF,IAAA,sBAAW,EACT,6BAA6B,CAAC,GAAG,CAAC,IAAI,CAAC,6BAA6B,CAAC,CACtE,CAAC;AAEF,kBAAe,6BAA6B,CAAC"}

package/dist/cjs/utilities/index.d.ts

@@ -46,7 +46,10 @@ import getScalingParameters from './getScalingParameters';
 import getScalarDataType from './getScalarDataType';
 import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
 import getImageLegacy from './getImageLegacy';
+import ProgressiveIterator from './ProgressiveIterator';
+import decimate from './decimate';
+import imageRetrieveMetadataProvider from './imageRetrieveMetadataProvider';
 import * as planar from './planar';
 import * as windowLevel from './windowLevel';
 import * as colormap from './colormap';
-export { csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isOpposite, createFloat32SharedArray, createUint8SharedArray, createUint16SharedArray, createInt16SharedArray, windowLevel, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, getScalingParameters, getScalarDataType, colormap, getImageLegacy, };
+export { csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, calibratedPixelSpacingMetadataProvider, uuidv4, planar, getMinMax, getRuntimeId, isEqual, isOpposite, createFloat32SharedArray, createUint8SharedArray, createUint16SharedArray, createInt16SharedArray, windowLevel, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, getScalingParameters, getScalarDataType, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, };

package/dist/cjs/utilities/index.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getScalarDataType = exports.getScalingParameters = exports.deepMerge = exports.applyPreset = exports.hasNaNValues = exports.getViewportImageCornersInWorld = exports.spatialRegistrationMetadataProvider = exports.calculateViewportsSpatialRegistration = exports.getClosestStackImageIndexForPoint = exports.getViewportsWithImageURI = exports.actorIsA = exports.isPTPrescaledWithSUV = exports.isImageActor = exports.getImageSliceDataForVolumeViewport = exports.snapFocalPointToSlice = exports.getSliceRange = exports.getVolumeViewportScrollInfo = exports.getVolumeSliceRangeInfo = exports.imageToWorldCoords = exports.worldToImageCoords = exports.renderToCanvasGPU = exports.renderToCanvasCPU = exports.loadImageToCanvas = exports.transformWorldToIndex = exports.getViewportsWithVolumeId = exports.getVolumeViewportsContainingSameVolumes = exports.indexWithinDimensions = exports.getVolumeActorCorners = exports.getTargetVolumeAndSpacingInNormalDir = exports.getSpacingInNormalDirection = exports.getClosestImageId = exports.windowLevel = exports.createInt16SharedArray = exports.createUint16SharedArray = exports.createUint8SharedArray = exports.createFloat32SharedArray = exports.isOpposite = exports.isEqual = exports.getRuntimeId = exports.getMinMax = exports.planar = exports.uuidv4 = exports.calibratedPixelSpacingMetadataProvider = exports.imageIdToURI = exports.triggerEvent = exports.scaleRgbTransferFunction = exports.createLinearRGBTransferFunction = exports.getVoiFromSigmoidRGBTransferFunction = exports.createSigmoidRGBTransferFunction = exports.invertRgbTransferFunction = void 0;
-exports.getImageLegacy = exports.colormap = void 0;
+exports.imageRetrieveMetadataProvider = exports.decimate = exports.ProgressiveIterator = exports.getImageLegacy = exports.colormap = void 0;
 const invertRgbTransferFunction_1 = __importDefault(require("./invertRgbTransferFunction"));
 exports.invertRgbTransferFunction = invertRgbTransferFunction_1.default;
 const createSigmoidRGBTransferFunction_1 = __importDefault(require("./createSigmoidRGBTransferFunction"));
@@ -125,6 +125,12 @@ const isPTPrescaledWithSUV_1 = __importDefault(require("./isPTPrescaledWithSUV")
 exports.isPTPrescaledWithSUV = isPTPrescaledWithSUV_1.default;
 const getImageLegacy_1 = __importDefault(require("./getImageLegacy"));
 exports.getImageLegacy = getImageLegacy_1.default;
+const ProgressiveIterator_1 = __importDefault(require("./ProgressiveIterator"));
+exports.ProgressiveIterator = ProgressiveIterator_1.default;
+const decimate_1 = __importDefault(require("./decimate"));
+exports.decimate = decimate_1.default;
+const imageRetrieveMetadataProvider_1 = __importDefault(require("./imageRetrieveMetadataProvider"));
+exports.imageRetrieveMetadataProvider = imageRetrieveMetadataProvider_1.default;
 const planar = __importStar(require("./planar"));
 exports.planar = planar;
 const windowLevel = __importStar(require("./windowLevel"));

package/dist/cjs/utilities/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utilities/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utilities/index.ts"],"names":[],"mappings":"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"}

package/dist/esm/RenderingEngine/StackViewport.js

@@ -8,12 +8,12 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import * as metaData from '../metaData';
 import Viewport from './Viewport';
 import eventTarget from '../eventTarget';
-import { triggerEvent, isEqual, invertRgbTransferFunction, createSigmoidRGBTransferFunction, windowLevel as windowLevelUtil, imageIdToURI, isImageActor, actorIsA, } from '../utilities';
+import { triggerEvent, isEqual, invertRgbTransferFunction, createSigmoidRGBTransferFunction, windowLevel as windowLevelUtil, imageIdToURI, isImageActor, actorIsA, imageRetrieveMetadataProvider, } from '../utilities';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
 import { getColormap } from './helpers/cpuFallback/colors/index';
 import { loadAndCacheImage } from '../loaders/imageLoader';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
-import { InterpolationType, RequestType, Events, VOILUTFunctionType, } from '../enums';
+import { InterpolationType, RequestType, Events, VOILUTFunctionType, ViewportStatus, } from '../enums';
 import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
 import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
 import getDefaultViewport from './helpers/cpuFallback/rendering/getDefaultViewport';
@@ -25,11 +25,12 @@ import { getConfiguration, getShouldUseCPURendering } from '../init';
 import cache from '../cache';
 import correctShift from './helpers/cpuFallback/rendering/correctShift';
 import createLinearRGBTransferFunction from '../utilities/createLinearRGBTransferFunction';
-import ViewportStatus from '../enums/ViewportStatus';
+import { createProgressive } from '../loaders/ProgressiveRetrieveImages';
 const EPSILON = 1;
 class StackViewport extends Viewport {
     constructor(props) {
         super(props);
+        this.imagesLoader = this;
         this.voiUpdatedWithSetProperties = false;
         this.invert = false;
         this.initialInvert = false;
@@ -335,14 +336,14 @@ class StackViewport extends Viewport {
     }
     setUseCPURendering(value) {
         this.useCPURendering = value;
-        this._configureRenderingPipeline();
+        this._configureRenderingPipeline(value);
     }
     static get useCustomRenderingPipeline() {
         return getShouldUseCPURendering();
     }
-    _configureRenderingPipeline() {
+    _configureRenderingPipeline(value) {
         this.useNativeDataType = this._shouldUseNativeDataType();
-        this.useCPURendering = getShouldUseCPURendering();
+        this.useCPURendering = value ?? getShouldUseCPURendering();
         for (const [funcName, functions] of Object.entries(this.renderingPipelineFunctions)) {
             this[funcName] = this.useCPURendering ? functions.cpu : functions.gpu;
         }
@@ -918,6 +919,10 @@ class StackViewport extends Viewport {
         this.imageIds = imageIds;
         this.currentImageIdIndex = currentImageIdIndex;
         this.targetImageIdIndex = currentImageIdIndex;
+        const imageRetrieveConfiguration = metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, imageIds[currentImageIdIndex], 'stack');
+        this.imagesLoader = imageRetrieveConfiguration
+            ? (imageRetrieveConfiguration.create || createProgressive)(imageRetrieveConfiguration)
+            : this;
         this.stackInvalidated = true;
         this.flipVertical = false;
         this.flipHorizontal = false;
@@ -1000,11 +1005,10 @@ class StackViewport extends Viewport {
         }
         this._imageData.modified();
     }
-    async _loadAndDisplayImage(imageId, imageIdIndex) {
-        await (this.useCPURendering
+    _loadAndDisplayImage(imageId, imageIdIndex) {
+        return this.useCPURendering
             ? this._loadAndDisplayImageCPU(imageId, imageIdIndex)
-            : this._loadAndDisplayImageGPU(imageId, imageIdIndex));
-        return imageId;
+            : this._loadAndDisplayImageGPU(imageId, imageIdIndex);
     }
     _loadAndDisplayImageCPU(imageId, imageIdIndex) {
         return new Promise((resolve, reject) => {
@@ -1081,7 +1085,7 @@ class StackViewport extends Viewport {
             }
             const priority = -5;
             const requestType = RequestType.Interaction;
-            const additionalDetails = { imageId };
+            const additionalDetails = { imageId, imageIdIndex };
             const options = {
                 preScale: {
                     enabled: true,
@@ -1098,70 +1102,85 @@ class StackViewport extends Viewport {
             imageLoadPoolManager.addRequest(sendRequest.bind(this, imageId, imageIdIndex, options), requestType, additionalDetails, priority);
         });
     }
+    successCallback(imageId, image) {
+        const imageIdIndex = this.imageIds.indexOf(imageId);
+        if (this.currentImageIdIndex !== imageIdIndex) {
+            return;
+        }
+        const csImgFrame = this.csImage?.imageFrame;
+        const imgFrame = image?.imageFrame;
+        if (csImgFrame?.photometricInterpretation !==
+            imgFrame?.photometricInterpretation ||
+            this.csImage?.photometricInterpretation !==
+                image?.photometricInterpretation) {
+            this.stackInvalidated = true;
+        }
+        this._setCSImage(image);
+        const eventDetail = {
+            image,
+            imageId,
+            imageIdIndex,
+            viewportId: this.id,
+            renderingEngineId: this.renderingEngineId,
+        };
+        triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
+        this._updateActorToDisplayImageId(image);
+        this.render();
+        this.currentImageIdIndex = imageIdIndex;
+    }
+    errorCallback(imageId, permanent, error) {
+        if (!permanent) {
+            return;
+        }
+        const imageIdIndex = this.imageIds.indexOf(imageId);
+        const eventDetail = {
+            error,
+            imageIdIndex,
+            imageId,
+        };
+        triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
+    }
+    getLoaderImageOptions(imageId) {
+        const imageIdIndex = this.imageIds.indexOf(imageId);
+        const { transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
+        const additionalDetails = { imageId, imageIdIndex };
+        const options = {
+            targetBuffer: {
+                type: this.useNativeDataType ? undefined : 'Float32Array',
+            },
+            preScale: {
+                enabled: true,
+            },
+            useRGBA: false,
+            transferSyntaxUID,
+            priority: 5,
+            requestType: RequestType.Interaction,
+            additionalDetails,
+        };
+        return options;
+    }
+    loadImages(imageIds, listener) {
+        return Promise.allSettled(imageIds.map((imageId) => {
+            const options = this.getLoaderImageOptions(imageId);
+            return loadAndCacheImage(imageId, options).then((image) => {
+                listener.successCallback(imageId, image);
+                return imageId;
+            }, (error) => {
+                listener.errorCallback(imageId, true, error);
+                return imageId;
+            });
+        }));
+    }
     _loadAndDisplayImageGPU(imageId, imageIdIndex) {
-        return new Promise((resolve, reject) => {
-            function successCallback(image, imageIdIndex, imageId) {
-                if (this.currentImageIdIndex !== imageIdIndex) {
-                    return;
-                }
-                const csImgFrame = this.csImage?.imageFrame;
-                const imgFrame = image?.imageFrame;
-                if (csImgFrame?.photometricInterpretation !==
-                    imgFrame?.photometricInterpretation ||
-                    this.csImage?.photometricInterpretation !==
-                        image?.photometricInterpretation) {
-                    this.stackInvalidated = true;
-                }
-                this._setCSImage(image);
-                const eventDetail = {
-                    image,
-                    imageId,
-                    imageIdIndex,
-                    viewportId: this.id,
-                    renderingEngineId: this.renderingEngineId,
-                };
-                triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
-                this._updateActorToDisplayImageId(image);
-                this.render();
-                this.currentImageIdIndex = imageIdIndex;
-                resolve(imageId);
-            }
-            function errorCallback(error, imageIdIndex, imageId) {
-                const eventDetail = {
-                    error,
-                    imageIdIndex,
-                    imageId,
-                };
-                triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
-                reject(error);
-            }
-            function sendRequest(imageId, imageIdIndex, options) {
-                return loadAndCacheImage(imageId, options).then((image) => {
-                    successCallback.call(this, image, imageIdIndex, imageId);
-                }, (error) => {
-                    errorCallback.call(this, error, imageIdIndex, imageId);
-                });
-            }
-            const priority = -5;
-            const requestType = RequestType.Interaction;
-            const additionalDetails = { imageId };
-            const options = {
-                targetBuffer: {
-                    type: this.useNativeDataType ? undefined : 'Float32Array',
-                },
-                preScale: {
-                    enabled: true,
-                },
-                useRGBA: false,
-            };
-            const eventDetail = {
-                imageId,
-                imageIdIndex,
-                viewportId: this.id,
-                renderingEngineId: this.renderingEngineId,
-            };
-            triggerEvent(this.element, Events.PRE_STACK_NEW_IMAGE, eventDetail);
-            imageLoadPoolManager.addRequest(sendRequest.bind(this, imageId, imageIdIndex, options), requestType, additionalDetails, priority);
+        const eventDetail = {
+            imageId,
+            imageIdIndex,
+            viewportId: this.id,
+            renderingEngineId: this.renderingEngineId,
+        };
+        triggerEvent(this.element, Events.PRE_STACK_NEW_IMAGE, eventDetail);
+        return this.imagesLoader.loadImages([imageId], this).then((v) => {
+            return imageId;
         });
     }
     _updateToDisplayImageCPU(image) {
@@ -1277,15 +1296,14 @@ class StackViewport extends Viewport {
             return windowLevelUtil.toLowHighRange(width, center);
         }
     }
-    async _setImageIdIndex(imageIdIndex) {
+    _setImageIdIndex(imageIdIndex) {
         if (imageIdIndex >= this.imageIds.length) {
             throw new Error(`ImageIdIndex provided ${imageIdIndex} is invalid, the stack only has ${this.imageIds.length} elements`);
         }
         this.currentImageIdIndex = imageIdIndex;
         this.hasPixelSpacing = true;
         this.viewportStatus = ViewportStatus.PRE_RENDER;
-        const imageId = await this._loadAndDisplayImage(this.imageIds[imageIdIndex], imageIdIndex);
-        return imageId;
+        return this._loadAndDisplayImage(this.imageIds[imageIdIndex], imageIdIndex);
     }
     resetCameraCPU(resetPan, resetZoom) {
         const { image } = this._cpuFallbackEnabledElement;
@@ -1344,13 +1362,13 @@ class StackViewport extends Viewport {
             triggerEvent(this.element, Events.STACK_VIEWPORT_SCROLL, eventData);
         }
     }
-    async setImageIdIndex(imageIdIndex) {
+    setImageIdIndex(imageIdIndex) {
         this._throwIfDestroyed();
         if (this.currentImageIdIndex === imageIdIndex) {
-            return this.getCurrentImageId();
+            return Promise.resolve(this.getCurrentImageId());
         }
-        const imageId = this._setImageIdIndex(imageIdIndex);
-        return imageId;
+        const imageIdPromise = this._setImageIdIndex(imageIdIndex);
+        return imageIdPromise;
     }
     calibrateSpacing(imageId) {
         const imageIdIndex = this.getImageIds().indexOf(imageId);