@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/esm/loaders/utils/contourSet/createContourSet.js

@@ -0,0 +1,20 @@
+import { GeometryType } from '../../../enums';
+import { validateContourSet } from './validateContourSet';
+import { ContourSet } from '../../../cache/classes/ContourSet';
+export function createContourSet(geometryId, contourSetData) {
+    validateContourSet(contourSetData);
+    const contourSet = new ContourSet({
+        id: contourSetData.id,
+        data: contourSetData.data,
+        color: contourSetData.color,
+        frameOfReferenceUID: contourSetData.frameOfReferenceUID,
+        segmentIndex: contourSetData.segmentIndex ?? 1,
+    });
+    const geometry = {
+        id: geometryId,
+        type: GeometryType.CONTOUR,
+        data: contourSet,
+        sizeInBytes: contourSet.getSizeInBytes(),
+    };
+    return geometry;
+}

package/dist/esm/loaders/utils/contourSet/validateContourSet.d.ts

@@ -0,0 +1,2 @@
+import { PublicContourSetData } from '../../../types';
+export declare function validateContourSet(contourSetData: PublicContourSetData): void;

package/dist/esm/loaders/utils/contourSet/validateContourSet.js

@@ -0,0 +1,21 @@
+export function validateContourSet(contourSetData) {
+    if (!contourSetData || contourSetData.data.length === 0) {
+        throw new Error('Invalid contour set data, see publicContourSetData type for more info');
+    }
+    if (!contourSetData.id) {
+        throw new Error('Invalid contour set data, each contour set must have an id');
+    }
+    if (!contourSetData.data || !Array.isArray(contourSetData.data)) {
+        throw new Error('Invalid contour set data, each contour set must have an array of contours');
+    }
+    contourSetData.data.forEach((contourData) => {
+        if (!contourData.points || !Array.isArray(contourData.points)) {
+            throw new Error('Invalid contour set data, each contour must have an array of points');
+        }
+        contourData.points.forEach((point) => {
+            if (!point || !Array.isArray(point) || point.length !== 3) {
+                throw new Error('Invalid contour set data, each point must be an array of length 3');
+            }
+        });
+    });
+}

package/dist/esm/loaders/utils/surface/createSurface.d.ts

@@ -0,0 +1,2 @@
+import { IGeometry, PublicSurfaceData } from '../../../types';
+export declare function createSurface(geometryId: string, SurfaceData: PublicSurfaceData): IGeometry;

package/dist/esm/loaders/utils/surface/createSurface.js

@@ -0,0 +1,22 @@
+import { GeometryType } from '../../../enums';
+import { validateSurface } from './validateSurface';
+import { Surface } from '../../../cache/classes/Surface';
+export function createSurface(geometryId, SurfaceData) {
+    validateSurface(SurfaceData);
+    const surface = new Surface({
+        id: SurfaceData.id,
+        color: SurfaceData.color,
+        frameOfReferenceUID: SurfaceData.frameOfReferenceUID,
+        data: {
+            points: SurfaceData.data.points,
+            polys: SurfaceData.data.polys,
+        },
+    });
+    const geometry = {
+        id: geometryId,
+        type: GeometryType.SURFACE,
+        data: surface,
+        sizeInBytes: surface.getSizeInBytes(),
+    };
+    return geometry;
+}

package/dist/esm/loaders/utils/surface/validateSurface.d.ts

@@ -0,0 +1,2 @@
+import { PublicSurfaceData } from '../../../types';
+export declare function validateSurface(contourSetData: PublicSurfaceData): void;

package/dist/esm/loaders/utils/surface/validateSurface.js

@@ -0,0 +1,6 @@
+export function validateSurface(contourSetData) {
+    const { data } = contourSetData;
+    if (!data.points || !data.polys) {
+        throw new Error('Invalid surface data');
+    }
+}

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

@@ -1,30 +1,42 @@
 import '@kitware/vtk.js/Rendering/Profiles/Volume';
-import { ImageVolume } from '../cache/classes/ImageVolume';
-import type * as Types from '../types';
-import { Point3, Metadata, Mat3 } from '../types';
+import { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
 interface VolumeLoaderOptions {
     imageIds: Array<string>;
 }
 interface DerivedVolumeOptions {
     volumeId: string;
     targetBuffer?: {
-        type: 'Float32Array' | 'Uint8Array' | 'Uint16Array' | 'Int16Array';
+        type: PixelDataTypedArrayString;
         sharedArrayBuffer?: boolean;
     };
 }
 interface LocalVolumeOptions {
-    scalarData: Float32Array | Uint8Array | Uint16Array | Int16Array;
     metadata: Metadata;
     dimensions: Point3;
     spacing: Point3;
     origin: Point3;
     direction: Mat3;
+    scalarData?: PixelDataTypedArray;
+    imageIds?: Array<string>;
+    referencedImageIds?: Array<string>;
+    referencedVolumeId?: string;
+    targetBuffer?: {
+        type: PixelDataTypedArrayString;
+        sharedArrayBuffer?: boolean;
+    };
 }
-export declare function loadVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<Types.IImageVolume>;
-export declare function createAndCacheVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<Record<string, any>>;
-export declare function createAndCacheDerivedVolume(referencedVolumeId: string, options: DerivedVolumeOptions): Promise<ImageVolume>;
-export declare function createLocalVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): ImageVolume;
-export declare function registerVolumeLoader(scheme: string, volumeLoader: Types.VolumeLoaderFn): void;
+export declare function loadVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<IImageVolume>;
+export declare function createAndCacheEmptyVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<Record<string, any>>;
+export declare function createAndCacheDerivedVolume(referencedVolumeId: string, options: DerivedVolumeOptions): Promise<IImageVolume>;
+export declare function createLocalVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): IImageVolume;
+export declare function createAndCacheVolumeFromImages(volumeId: string, imageIds: string[], options?: {
+    preventCache?: boolean;
+    additionalDetails?: Record<string, any>;
+}): Promise<IImageVolume>;
+export declare function registerVolumeLoader(scheme: string, volumeLoader: VolumeLoaderFn): void;
 export declare function getVolumeLoaderSchemes(): string[];
-export declare function registerUnknownVolumeLoader(volumeLoader: Types.VolumeLoaderFn): Types.VolumeLoaderFn | undefined;
+export declare function registerUnknownVolumeLoader(volumeLoader: VolumeLoaderFn): VolumeLoaderFn | undefined;
+export declare function getUnknownVolumeLoaderSchema(): string;
+export declare function createAndCacheDerivedSegmentationVolume(referencedVolumeId: string, options?: DerivedVolumeOptions): Promise<IImageVolume>;
+export declare function createLocalSegmentationVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): Promise<IImageVolume>;
 export {};

package/dist/esm/loaders/volumeLoader.js

@@ -1,14 +1,14 @@
 import '@kitware/vtk.js/Rendering/Profiles/Volume';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import cloneDeep from 'lodash.clonedeep';
 import { ImageVolume } from '../cache/classes/ImageVolume';
 import cache from '../cache/cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
-import { uuidv4 } from '../utilities';
-import { getConfiguration } from '../init';
+import { createUint16SharedArray, createUint8SharedArray, createFloat32SharedArray, generateVolumePropsFromImageIds, getBufferConfiguration, uuidv4, } from '../utilities';
+import { getConfiguration, getShouldUseSharedArrayBuffer } from '../init';
+import { performCacheOptimizationForVolume, setupCacheOptimizationEventListener, } from '../utilities/cacheUtils';
 function addScalarDataToImageData(imageData, scalarData, dataArrayAttrs) {
     const scalarArray = vtkDataArray.newInstance({
         name: `Pixels`,
@@ -56,14 +56,16 @@ let unknownVolumeLoader;
 function loadVolumeFromVolumeLoader(volumeId, options) {
     const colonIndex = volumeId.indexOf(':');
     const scheme = volumeId.substring(0, colonIndex);
-    const loader = volumeLoaders[scheme];
+    let loader = volumeLoaders[scheme];
     if (loader === undefined || loader === null) {
-        if (unknownVolumeLoader !== undefined) {
-            return unknownVolumeLoader(volumeId, options);
+        if (unknownVolumeLoader == null ||
+            typeof unknownVolumeLoader !== 'function') {
+            throw new Error(`No volume loader for scheme ${scheme} has been registered`);
         }
-        throw new Error('loadVolumeFromVolumeLoader: no volume loader for volumeId');
+        loader = unknownVolumeLoader;
     }
     const volumeLoadObject = loader(volumeId, options);
+    setupCacheOptimizationEventListener(volumeId);
     volumeLoadObject.promise.then(function (volume) {
         triggerEvent(eventTarget, Events.VOLUME_LOADED, { volume });
     }, function (error) {
@@ -89,9 +91,9 @@ export function loadVolume(volumeId, options = { imageIds: [] }) {
         return volume;
     });
 }
-export async function createAndCacheVolume(volumeId, options) {
+export async function createAndCacheEmptyVolume(volumeId, options) {
     if (volumeId === undefined) {
-        throw new Error('createAndCacheVolume: parameter volumeId must not be undefined');
+        throw new Error('createAndCacheEmptyVolume: parameter volumeId must not be undefined');
     }
     let volumeLoadObject = cache.getVolumeLoadObject(volumeId);
     if (volumeLoadObject !== undefined) {
@@ -119,45 +121,7 @@ export async function createAndCacheDerivedVolume(referencedVolumeId, options) {
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
     const scalarData = referencedVolume.getScalarData();
     const scalarLength = scalarData.length;
-    let numBytes, TypedArray;
-    const { useNorm16Texture } = getConfiguration().rendering;
-    if (targetBuffer) {
-        if (targetBuffer.type === 'Float32Array') {
-            numBytes = scalarLength * 4;
-            TypedArray = Float32Array;
-        }
-        else if (targetBuffer.type === 'Uint8Array') {
-            numBytes = scalarLength;
-            TypedArray = Uint8Array;
-        }
-        else if (useNorm16Texture && targetBuffer.type === 'Uint16Array') {
-            numBytes = scalarLength * 2;
-            TypedArray = Uint16Array;
-        }
-        else if (useNorm16Texture && targetBuffer.type === 'Int16Array') {
-            numBytes = scalarLength * 2;
-            TypedArray = Uint16Array;
-        }
-        else {
-            throw new Error('TargetBuffer should be Float32Array or Uint8Array');
-        }
-    }
-    else {
-        numBytes = scalarLength * 4;
-        TypedArray = Float32Array;
-    }
-    const isCacheable = cache.isCacheable(numBytes);
-    if (!isCacheable) {
-        throw new Error(Events.CACHE_SIZE_EXCEEDED);
-    }
-    let volumeScalarData;
-    if (targetBuffer?.sharedArrayBuffer) {
-        const buffer = new SharedArrayBuffer(numBytes);
-        volumeScalarData = new TypedArray(buffer);
-    }
-    else {
-        volumeScalarData = new TypedArray(scalarLength);
-    }
+    const { volumeScalarData, numBytes } = generateVolumeScalarData(targetBuffer, scalarLength);
     const scalarArray = vtkDataArray.newInstance({
         name: 'Pixels',
         numberOfComponents: 1,
@@ -169,9 +133,16 @@ export async function createAndCacheDerivedVolume(referencedVolumeId, options) {
     derivedImageData.setDirection(direction);
     derivedImageData.setOrigin(origin);
     derivedImageData.getPointData().setScalars(scalarArray);
+    const referencedImageIds = referencedVolume.imageIds ?? [];
+    let derivedVolumeImageIds = [];
+    if (referencedImageIds.length) {
+        derivedVolumeImageIds = referencedImageIds.map((imageId) => {
+            return `derived:${imageId}`;
+        });
+    }
     const derivedVolume = new ImageVolume({
         volumeId,
-        metadata: cloneDeep(metadata),
+        metadata: structuredClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
@@ -180,21 +151,31 @@ export async function createAndCacheDerivedVolume(referencedVolumeId, options) {
         scalarData: volumeScalarData,
         sizeInBytes: numBytes,
         referencedVolumeId,
+        imageIds: derivedVolumeImageIds,
+        referencedImageIds: referencedVolume.imageIds ?? [],
     });
     const volumeLoadObject = {
         promise: Promise.resolve(derivedVolume),
     };
     await cache.putVolumeLoadObject(volumeId, volumeLoadObject);
+    performCacheOptimizationForVolume(derivedVolume);
     return derivedVolume;
 }
 export function createLocalVolume(options, volumeId, preventCache = false) {
-    const { scalarData, metadata, dimensions, spacing, origin, direction } = options;
-    if (!scalarData ||
-        !(scalarData instanceof Uint8Array ||
-            scalarData instanceof Float32Array ||
-            scalarData instanceof Uint16Array ||
-            scalarData instanceof Int16Array)) {
-        throw new Error('To use createLocalVolume you should pass scalarData of type Uint8Array, Uint16Array, Int16Array or Float32Array');
+    const { metadata, dimensions, spacing, origin, direction, targetBuffer } = options;
+    let { scalarData } = options;
+    const validDataTypes = [
+        'Uint8Array',
+        'Float32Array',
+        'Uint16Array',
+        'Int16Array',
+    ];
+    const scalarLength = dimensions[0] * dimensions[1] * dimensions[2];
+    if (!scalarData || !validDataTypes.includes(scalarData.constructor.name)) {
+        if (!targetBuffer?.type || !validDataTypes.includes(targetBuffer.type)) {
+            throw new Error('createLocalVolume: parameter scalarData must be provided and must be either Uint8Array, Float32Array, Uint16Array or Int16Array');
+        }
+        ({ volumeScalarData: scalarData } = generateVolumeScalarData(targetBuffer, scalarLength));
     }
     if (volumeId === undefined) {
         volumeId = uuidv4();
@@ -203,7 +184,6 @@ export function createLocalVolume(options, volumeId, preventCache = false) {
     if (cachedVolume) {
         return cachedVolume;
     }
-    const scalarLength = dimensions[0] * dimensions[1] * dimensions[2];
     const numBytes = scalarData ? scalarData.buffer.byteLength : scalarLength * 4;
     const isCacheable = cache.isCacheable(numBytes);
     if (!isCacheable) {
@@ -222,7 +202,7 @@ export function createLocalVolume(options, volumeId, preventCache = false) {
     imageData.getPointData().setScalars(scalarArray);
     const derivedVolume = new ImageVolume({
         volumeId,
-        metadata: cloneDeep(metadata),
+        metadata: structuredClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
@@ -230,6 +210,9 @@ export function createLocalVolume(options, volumeId, preventCache = false) {
         imageData: imageData,
         scalarData,
         sizeInBytes: numBytes,
+        referencedImageIds: options.referencedImageIds || [],
+        referencedVolumeId: options.referencedVolumeId,
+        imageIds: options.imageIds || [],
     });
     if (preventCache) {
         return derivedVolume;
@@ -238,8 +221,46 @@ export function createLocalVolume(options, volumeId, preventCache = false) {
         promise: Promise.resolve(derivedVolume),
     };
     cache.putVolumeLoadObject(volumeId, volumeLoadObject);
+    performCacheOptimizationForVolume(derivedVolume);
     return derivedVolume;
 }
+export async function createAndCacheVolumeFromImages(volumeId, imageIds, options = {}) {
+    const { preventCache = false } = options;
+    if (imageIds === undefined) {
+        throw new Error('createAndCacheVolumeFromImages: parameter imageIds must not be undefined');
+    }
+    if (volumeId === undefined) {
+        throw new Error('createAndCacheVolumeFromImages: parameter volumeId must not be undefined');
+    }
+    const cachedVolume = cache.getVolume(volumeId);
+    if (cachedVolume) {
+        return Promise.resolve(cachedVolume);
+    }
+    const volumeProps = generateVolumePropsFromImageIds(imageIds, volumeId);
+    const imagePromises = volumeProps.imageIds.map((imageId, imageIdIndex) => {
+        const imageLoadObject = cache.getImageLoadObject(imageId);
+        return imageLoadObject.promise.then((image) => {
+            const pixelData = image.getPixelData();
+            const offset = imageIdIndex * image.rows * image.columns;
+            volumeProps.scalarData.set(pixelData, offset);
+        });
+    });
+    await Promise.all(imagePromises);
+    const volume = new ImageVolume({
+        ...volumeProps,
+        referencedImageIds: imageIds,
+        ...options,
+    });
+    performCacheOptimizationForVolume(volume);
+    const volumeLoadObject = {
+        promise: Promise.resolve(volume),
+    };
+    if (preventCache) {
+        return volumeLoadObject.promise;
+    }
+    cache.putVolumeLoadObject(volumeId, volumeLoadObject);
+    return volumeLoadObject.promise;
+}
 export function registerVolumeLoader(scheme, volumeLoader) {
     volumeLoaders[scheme] = volumeLoader;
 }
@@ -251,4 +272,54 @@ export function registerUnknownVolumeLoader(volumeLoader) {
     unknownVolumeLoader = volumeLoader;
     return oldVolumeLoader;
 }
-//# sourceMappingURL=volumeLoader.js.map
+export function getUnknownVolumeLoaderSchema() {
+    return unknownVolumeLoader.name;
+}
+export async function createAndCacheDerivedSegmentationVolume(referencedVolumeId, options = {}) {
+    return createAndCacheDerivedVolume(referencedVolumeId, {
+        ...options,
+        targetBuffer: {
+            type: 'Uint8Array',
+        },
+    });
+}
+export async function createLocalSegmentationVolume(options, volumeId, preventCache = false) {
+    if (!options.scalarData) {
+        options.scalarData = new Uint8Array(options.dimensions[0] * options.dimensions[1] * options.dimensions[2]);
+    }
+    return createLocalVolume(options, volumeId, preventCache);
+}
+function generateVolumeScalarData(targetBuffer, scalarLength) {
+    const { useNorm16Texture } = getConfiguration().rendering;
+    const { TypedArrayConstructor, numBytes } = getBufferConfiguration(targetBuffer?.type, scalarLength, {
+        use16BitTexture: useNorm16Texture,
+        isVolumeBuffer: true,
+    });
+    const isCacheable = cache.isCacheable(numBytes);
+    if (!isCacheable) {
+        throw new Error(Events.CACHE_SIZE_EXCEEDED);
+    }
+    let volumeScalarData;
+    if (targetBuffer?.sharedArrayBuffer ?? getShouldUseSharedArrayBuffer()) {
+        switch (targetBuffer.type) {
+            case 'Float32Array':
+                volumeScalarData = createFloat32SharedArray(scalarLength);
+                break;
+            case 'Uint8Array':
+                volumeScalarData = createUint8SharedArray(scalarLength);
+                break;
+            case 'Uint16Array':
+                volumeScalarData = createUint16SharedArray(scalarLength);
+                break;
+            case 'Int16Array':
+                volumeScalarData = createUint16SharedArray(scalarLength);
+                break;
+            default:
+                throw new Error('generateVolumeScalarData: SharedArrayBuffer is not supported for the specified target buffer type');
+        }
+    }
+    else {
+        volumeScalarData = new TypedArrayConstructor(scalarLength);
+    }
+    return { volumeScalarData, numBytes };
+}

package/dist/esm/metaData.d.ts

@@ -1,7 +1,7 @@
-export declare function addProvider(provider: (type: string, query: any) => any, priority?: number): void;
+export declare function addProvider(provider: (type: string, ...query: string[]) => any, priority?: number): void;
 export declare function removeProvider(provider: (type: string, query: any) => {
     any: any;
 }): void;
 export declare function removeAllProviders(): void;
-declare function getMetaData(type: string, query: string): any;
+declare function getMetaData(type: string, ...queries: any[]): any;
 export { getMetaData as get };

package/dist/esm/metaData.js

@@ -24,13 +24,12 @@ export function removeAllProviders() {
         providers.pop();
     }
 }
-function getMetaData(type, query) {
+function getMetaData(type, ...queries) {
     for (let i = 0; i < providers.length; i++) {
-        const result = providers[i].provider(type, query);
+        const result = providers[i].provider(type, ...queries);
         if (result !== undefined) {
             return result;
         }
     }
 }
 export { getMetaData as get };
-//# sourceMappingURL=metaData.js.map

package/dist/esm/requestPool/imageLoadPoolManager.js

@@ -6,4 +6,3 @@ imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Interaction, 1000);
 imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Thumbnail, 1000);
 imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Prefetch, 1000);
 export default imageLoadPoolManager;
-//# sourceMappingURL=imageLoadPoolManager.js.map

package/dist/esm/requestPool/imageRetrievalPoolManager.js

@@ -6,4 +6,3 @@ imageRetrievalPoolManager.setMaxSimultaneousRequests(RequestType.Thumbnail, 200)
 imageRetrievalPoolManager.setMaxSimultaneousRequests(RequestType.Prefetch, 200);
 imageRetrievalPoolManager.grabDelay = 0;
 export default imageRetrievalPoolManager;
-//# sourceMappingURL=imageRetrievalPoolManager.js.map

package/dist/esm/requestPool/requestPoolManager.d.ts

@@ -1,15 +1,15 @@
 import RequestType from '../enums/RequestType';
 import { IImage } from '../types';
-declare type AdditionalDetails = {
+type AdditionalDetails = {
     imageId?: string;
     volumeId?: string;
 };
-declare type RequestDetailsInterface = {
+type RequestDetailsInterface = {
     requestFn: () => Promise<IImage | void>;
     type: RequestType;
     additionalDetails: AdditionalDetails;
 };
-declare type RequestPool = {
+type RequestPool = {
     [name in RequestType]: {
         [key: number]: RequestDetailsInterface[];
     };
@@ -23,6 +23,7 @@ declare class RequestPoolManager {
         interaction: number;
         thumbnail: number;
         prefetch: number;
+        compute: number;
     };
     grabDelay: number;
     private timeoutHandle;
@@ -40,6 +41,4 @@ declare class RequestPoolManager {
     protected getSortedPriorityGroups(type: string): Array<number>;
     getRequestPool(): RequestPool;
 }
-declare const requestPoolManager: RequestPoolManager;
 export { RequestPoolManager };
-export default requestPoolManager;

package/dist/esm/requestPool/requestPoolManager.js

@@ -6,12 +6,14 @@ class RequestPoolManager {
             interaction: 0,
             thumbnail: 0,
             prefetch: 0,
+            compute: 0,
         };
         this.id = id ? id : uuidv4();
         this.requestPool = {
             interaction: { 0: [] },
             thumbnail: { 0: [] },
             prefetch: { 0: [] },
+            compute: { 0: [] },
         };
         this.grabDelay = 5;
         this.awake = false;
@@ -19,11 +21,13 @@ class RequestPoolManager {
             interaction: 0,
             thumbnail: 0,
             prefetch: 0,
+            compute: 0,
         };
         this.maxNumRequests = {
             interaction: 6,
             thumbnail: 6,
             prefetch: 5,
+            compute: 1000,
         };
     }
     setMaxSimultaneousRequests(type, maxNumRequests) {
@@ -47,13 +51,7 @@ class RequestPoolManager {
             this.requestPool[type][priority] = [];
         }
         this.requestPool[type][priority].push(requestDetails);
-        if (!this.awake) {
-            this.awake = true;
-            this.startGrabbing();
-        }
-        else if (type === RequestType.Interaction) {
-            this.startGrabbing();
-        }
+        this.startGrabbing();
     }
     filterRequests(filterFunction) {
         Object.keys(this.requestPool).forEach((type) => {
@@ -73,6 +71,7 @@ class RequestPoolManager {
     }
     sendRequests(type) {
         const requestsToSend = this.maxNumRequests[type] - this.numRequests[type];
+        let syncImageCount = 0;
         for (let i = 0; i < requestsToSend; i++) {
             const requestDetails = this.getNextRequest(type);
             if (requestDetails === null) {
@@ -81,12 +80,28 @@ class RequestPoolManager {
             else if (requestDetails) {
                 this.numRequests[type]++;
                 this.awake = true;
-                requestDetails.requestFn().finally(() => {
+                let requestResult;
+                try {
+                    requestResult = requestDetails.requestFn();
+                }
+                catch (e) {
+                    console.warn('sendRequest failed', e);
+                }
+                if (requestResult?.finally) {
+                    requestResult.finally(() => {
+                        this.numRequests[type]--;
+                        this.startAgain();
+                    });
+                }
+                else {
                     this.numRequests[type]--;
-                    this.startAgain();
-                });
+                    syncImageCount++;
+                }
             }
         }
+        if (syncImageCount) {
+            this.startAgain();
+        }
         return true;
     }
     getNextRequest(type) {
@@ -102,9 +117,11 @@ class RequestPoolManager {
         const hasRemainingInteractionRequests = this.sendRequests(RequestType.Interaction);
         const hasRemainingThumbnailRequests = this.sendRequests(RequestType.Thumbnail);
         const hasRemainingPrefetchRequests = this.sendRequests(RequestType.Prefetch);
+        const hasRemainingComputeRequests = this.sendRequests(RequestType.Compute);
         if (!hasRemainingInteractionRequests &&
             !hasRemainingThumbnailRequests &&
-            !hasRemainingPrefetchRequests) {
+            !hasRemainingPrefetchRequests &&
+            !hasRemainingComputeRequests) {
             this.awake = false;
         }
     }
@@ -135,7 +152,4 @@ class RequestPoolManager {
         return this.requestPool;
     }
 }
-const requestPoolManager = new RequestPoolManager();
 export { RequestPoolManager };
-export default requestPoolManager;
-//# sourceMappingURL=requestPoolManager.js.map

package/dist/esm/types/AABB2.d.ts

@@ -0,0 +1,7 @@
+type AABB2 = {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+export type { AABB2 as default };

package/dist/esm/types/AABB2.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/AABB3.d.ts

@@ -0,0 +1,9 @@
+type AABB3 = {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+};
+export type { AABB3 as default };

package/dist/esm/types/AABB3.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/ActorSliceRange.d.ts

@@ -1,6 +1,6 @@
 import { VolumeActor } from './IActor';
 import Point3 from './Point3';
-declare type ActorSliceRange = {
+type ActorSliceRange = {
     actor: VolumeActor;
     viewPlaneNormal: Point3;
     focalPoint: Point3;

package/dist/esm/types/ActorSliceRange.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=ActorSliceRange.js.map

package/dist/esm/types/AffineMatrix.d.ts

@@ -1,4 +1,4 @@
-declare type AffineMatrix = [
+type AffineMatrix = [
     [
         number,
         number,

package/dist/esm/types/AffineMatrix.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=AffineMatrix.js.map

package/dist/esm/types/BoundsIJK.d.ts

@@ -0,0 +1,3 @@
+import type Point2 from './Point2';
+type BoundsIJK = [Point2, Point2, Point2];
+export default BoundsIJK;

package/dist/esm/types/BoundsIJK.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/BoundsLPS.d.ts

@@ -0,0 +1,3 @@
+import type Point2 from './Point3';
+type BoundsLPS = [Point2, Point2, Point2];
+export default BoundsLPS;