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

package/dist/esm/cache/cache.js

@@ -1,9 +1,14 @@
 import { triggerEvent, imageIdToURI } from '../utilities';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
-const MAX_CACHE_SIZE_1GB = 1073741824;
+const ONE_GB = 1073741824;
 class Cache {
     constructor() {
+        this._imageCache = new Map();
+        this._volumeCache = new Map();
+        this._geometryCache = new Map();
+        this._imageCacheSize = 0;
+        this._maxCacheSize = 3 * ONE_GB;
         this.setMaxCacheSize = (newMaxCacheSize) => {
             if (!newMaxCacheSize || typeof newMaxCacheSize !== 'number') {
                 const errorMessage = `New max cacheSize ${this._maxCacheSize} should be defined and should be a number.`;
@@ -12,15 +17,27 @@ class Cache {
             this._maxCacheSize = newMaxCacheSize;
         };
         this.isCacheable = (byteLength) => {
-            const unallocatedSpace = this.getBytesAvailable();
-            const imageCacheSize = this._imageCacheSize;
-            const availableSpace = unallocatedSpace + imageCacheSize;
-            return availableSpace > byteLength;
+            const bytesAvailable = this.getBytesAvailable();
+            const purgableImageBytes = Array.from(this._imageCache.values()).reduce((total, image) => {
+                if (!image.sharedCacheKey) {
+                    return total + image.sizeInBytes;
+                }
+                return total;
+            }, 0);
+            const availableSpaceWithoutSharedCacheKey = bytesAvailable + purgableImageBytes;
+            return availableSpaceWithoutSharedCacheKey >= byteLength;
         };
         this.getMaxCacheSize = () => this._maxCacheSize;
-        this.getCacheSize = () => this._imageCacheSize + this._volumeCacheSize;
+        this.getCacheSize = () => this._imageCacheSize;
         this._decacheImage = (imageId) => {
-            const { imageLoadObject } = this._imageCache.get(imageId);
+            const cachedImage = this._imageCache.get(imageId);
+            if (!cachedImage) {
+                return;
+            }
+            if (cachedImage.sharedCacheKey) {
+                throw new Error('Cannot decache an image with a shared cache key. You need to manually decache the volume first.');
+            }
+            const { imageLoadObject } = cachedImage;
             if (imageLoadObject.cancelFn) {
                 imageLoadObject.cancelFn();
             }
@@ -31,7 +48,13 @@ class Cache {
         };
         this._decacheVolume = (volumeId) => {
             const cachedVolume = this._volumeCache.get(volumeId);
+            if (!cachedVolume) {
+                return;
+            }
             const { volumeLoadObject, volume } = cachedVolume;
+            if (!volume) {
+                return;
+            }
             if (volume.cancelLoading) {
                 volume.cancelLoading();
             }
@@ -41,13 +64,19 @@ class Cache {
             if (volumeLoadObject.cancelFn) {
                 volumeLoadObject.cancelFn();
             }
-            if (volumeLoadObject.decache) {
-                volumeLoadObject.decache();
+            if (volume.imageIds) {
+                volume.imageIds.forEach((imageId) => {
+                    const cachedImage = this._imageCache.get(imageId);
+                    if (cachedImage && cachedImage.sharedCacheKey === volumeId) {
+                        cachedImage.sharedCacheKey = undefined;
+                    }
+                });
             }
             this._volumeCache.delete(volumeId);
         };
         this.purgeCache = () => {
             const imageIterator = this._imageCache.keys();
+            this.purgeVolumeCache();
             while (true) {
                 const { value: imageId, done } = imageIterator.next();
                 if (done) {
@@ -56,7 +85,6 @@ class Cache {
                 this.removeImageLoadObject(imageId);
                 triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_REMOVED, { imageId });
             }
-            this.purgeVolumeCache();
         };
         this.purgeVolumeCache = () => {
             const volumeIterator = this._volumeCache.keys();
@@ -76,7 +104,7 @@ class Cache {
                 throw new Error('getVolumeLoadObject: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 return;
             }
             cachedVolume.timeStamp = Date.now();
@@ -87,33 +115,55 @@ class Cache {
                 throw new Error('getGeometry: geometryId must not be undefined');
             }
             const cachedGeometry = this._geometryCache.get(geometryId);
-            if (cachedGeometry === undefined) {
+            if (!cachedGeometry) {
                 return;
             }
             cachedGeometry.timeStamp = Date.now();
             return cachedGeometry.geometry;
         };
+        this.getImage = (imageId) => {
+            if (imageId === undefined) {
+                throw new Error('getImage: imageId must not be undefined');
+            }
+            const cachedImage = this._imageCache.get(imageId);
+            if (!cachedImage) {
+                return;
+            }
+            cachedImage.timeStamp = Date.now();
+            return cachedImage.image;
+        };
         this.getVolume = (volumeId) => {
             if (volumeId === undefined) {
                 throw new Error('getVolume: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 return;
             }
             cachedVolume.timeStamp = Date.now();
             return cachedVolume.volume;
         };
+        this.getVolumes = () => {
+            const cachedVolumes = Array.from(this._volumeCache.values());
+            return cachedVolumes.map((cachedVolume) => cachedVolume.volume);
+        };
+        this.filterVolumesByReferenceId = (volumeId) => {
+            const cachedVolumes = this.getVolumes();
+            return cachedVolumes.filter((volume) => {
+                return volume.referencedVolumeId === volumeId;
+            });
+        };
         this.removeImageLoadObject = (imageId) => {
             if (imageId === undefined) {
                 throw new Error('removeImageLoadObject: imageId must not be undefined');
             }
             const cachedImage = this._imageCache.get(imageId);
-            if (cachedImage === undefined) {
+            if (!cachedImage) {
                 throw new Error('removeImageLoadObject: imageId was not present in imageCache');
             }
-            this._incrementImageCacheSize(-cachedImage.sizeInBytes);
+            this.incrementImageCacheSize(-cachedImage.sizeInBytes);
             const eventDetails = {
+                image: cachedImage,
                 imageId,
             };
             triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_REMOVED, eventDetails);
@@ -124,10 +174,9 @@ class Cache {
                 throw new Error('removeVolumeLoadObject: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 throw new Error('removeVolumeLoadObject: volumeId was not present in volumeCache');
             }
-            this._incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
             const eventDetails = {
                 volume: cachedVolume,
                 volumeId,
@@ -174,18 +223,12 @@ class Cache {
                 throw error;
             });
         };
-        this._incrementImageCacheSize = (increment) => {
+        this.incrementImageCacheSize = (increment) => {
             this._imageCacheSize += increment;
         };
-        this._incrementVolumeCacheSize = (increment) => {
-            this._volumeCacheSize += increment;
+        this.decrementImageCacheSize = (decrement) => {
+            this._imageCacheSize -= decrement;
         };
-        this._imageCache = new Map();
-        this._volumeCache = new Map();
-        this._geometryCache = new Map();
-        this._imageCacheSize = 0;
-        this._volumeCacheSize = 0;
-        this._maxCacheSize = MAX_CACHE_SIZE_1GB;
     }
     getBytesAvailable() {
         return this.getMaxCacheSize() - this.getCacheSize();
@@ -195,7 +238,7 @@ class Cache {
         if (bytesAvailable >= numBytes) {
             return bytesAvailable;
         }
-        let cachedImages = Array.from(this._imageCache.values());
+        const cachedImages = Array.from(this._imageCache.values()).filter((cachedImage) => !cachedImage.sharedCacheKey);
         function compare(a, b) {
             if (a.timeStamp > b.timeStamp) {
                 return 1;
@@ -206,7 +249,7 @@ class Cache {
             return 0;
         }
         cachedImages.sort(compare);
-        let cachedImageIds = cachedImages.map((im) => im.imageId);
+        const cachedImageIds = cachedImages.map((im) => im.imageId);
         let imageIdsToPurge = cachedImageIds;
         if (volumeImageIds) {
             imageIdsToPurge = cachedImageIds.filter((id) => !volumeImageIds.includes(id));
@@ -219,8 +262,6 @@ class Cache {
                 return bytesAvailable;
             }
         }
-        cachedImages = Array.from(this._imageCache.values());
-        cachedImageIds = cachedImages.map((im) => im.imageId);
         for (const imageId of cachedImageIds) {
             this.removeImageLoadObject(imageId);
             triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_REMOVED, { imageId });
@@ -230,18 +271,47 @@ class Cache {
             }
         }
     }
-    putImageLoadObject(imageId, imageLoadObject) {
+    _putImageCommon(imageId, image, cachedImage) {
+        if (!this._imageCache.get(imageId)) {
+            console.warn('The image was purged from the cache before it completed loading.');
+            return;
+        }
+        if (image.sizeInBytes === undefined || Number.isNaN(image.sizeInBytes)) {
+            throw new Error('_putImageCommon: image.sizeInBytes must not be undefined');
+        }
+        if (image.sizeInBytes.toFixed === undefined) {
+            throw new Error('_putImageCommon: image.sizeInBytes is not a number');
+        }
+        if (!this.isCacheable(image.sizeInBytes)) {
+            throw new Error(Events.CACHE_SIZE_EXCEEDED);
+        }
+        this.decacheIfNecessaryUntilBytesAvailable(image.sizeInBytes);
+        cachedImage.loaded = true;
+        cachedImage.image = image;
+        cachedImage.sizeInBytes = image.sizeInBytes;
+        this.incrementImageCacheSize(cachedImage.sizeInBytes);
+        const eventDetails = {
+            image: cachedImage,
+        };
+        triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_ADDED, eventDetails);
+        cachedImage.sharedCacheKey = image.sharedCacheKey;
+    }
+    async putImageLoadObject(imageId, imageLoadObject) {
         if (imageId === undefined) {
+            console.error('putImageLoadObject: imageId must not be undefined');
             throw new Error('putImageLoadObject: imageId must not be undefined');
         }
         if (imageLoadObject.promise === undefined) {
+            console.error('putImageLoadObject: imageLoadObject.promise must not be undefined');
             throw new Error('putImageLoadObject: imageLoadObject.promise must not be undefined');
         }
         if (this._imageCache.has(imageId)) {
+            console.warn(`putImageLoadObject: imageId ${imageId} already in cache`);
             throw new Error('putImageLoadObject: imageId already in cache');
         }
         if (imageLoadObject.cancelFn &&
             typeof imageLoadObject.cancelFn !== 'function') {
+            console.error('putImageLoadObject: imageLoadObject.cancel must be a function');
             throw new Error('putImageLoadObject: imageLoadObject.cancel must be a function');
         }
         const cachedImage = {
@@ -253,49 +323,61 @@ class Cache {
             sizeInBytes: 0,
         };
         this._imageCache.set(imageId, cachedImage);
+        this._imageCache.set(imageId, cachedImage);
         return imageLoadObject.promise
             .then((image) => {
-            if (!this._imageCache.get(imageId)) {
-                console.warn('The image was purged from the cache before it completed loading.');
-                return;
+            try {
+                this._putImageCommon(imageId, image, cachedImage);
             }
-            if (Number.isNaN(image.sizeInBytes)) {
-                throw new Error('putImageLoadObject: image.sizeInBytes must not be undefined');
-            }
-            if (image.sizeInBytes.toFixed === undefined) {
-                throw new Error('putImageLoadObject: image.sizeInBytes is not a number');
-            }
-            if (!this.isCacheable(image.sizeInBytes)) {
-                throw new Error(Events.CACHE_SIZE_EXCEEDED);
+            catch (error) {
+                console.debug(`Error in _putImageCommon for image ${imageId}:`, error);
+                throw error;
             }
-            this.decacheIfNecessaryUntilBytesAvailable(image.sizeInBytes);
-            cachedImage.loaded = true;
-            cachedImage.image = image;
-            cachedImage.sizeInBytes = image.sizeInBytes;
-            this._incrementImageCacheSize(cachedImage.sizeInBytes);
-            const eventDetails = {
-                image: cachedImage,
-            };
-            triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_ADDED, eventDetails);
-            cachedImage.sharedCacheKey = image.sharedCacheKey;
         })
             .catch((error) => {
+            console.debug(`Error caching image ${imageId}:`, error);
             this._imageCache.delete(imageId);
             throw error;
         });
     }
+    putImageSync(imageId, image) {
+        if (imageId === undefined) {
+            throw new Error('putImageSync: imageId must not be undefined');
+        }
+        if (this._imageCache.has(imageId)) {
+            throw new Error('putImageSync: imageId already in cache');
+        }
+        const cachedImage = {
+            loaded: false,
+            imageId,
+            sharedCacheKey: undefined,
+            imageLoadObject: {
+                promise: Promise.resolve(image),
+            },
+            timeStamp: Date.now(),
+            sizeInBytes: 0,
+        };
+        this._imageCache.set(imageId, cachedImage);
+        try {
+            this._putImageCommon(imageId, image, cachedImage);
+        }
+        catch (error) {
+            this._imageCache.delete(imageId);
+            throw error;
+        }
+    }
     getImageLoadObject(imageId) {
         if (imageId === undefined) {
             throw new Error('getImageLoadObject: imageId must not be undefined');
         }
         const cachedImage = this._imageCache.get(imageId);
-        if (cachedImage === undefined) {
+        if (!cachedImage) {
             return;
         }
         cachedImage.timeStamp = Date.now();
         return cachedImage.imageLoadObject;
     }
-    isImageIdCached(imageId) {
+    isLoaded(imageId) {
         const cachedImage = this._imageCache.get(imageId);
         if (!cachedImage) {
             return false;
@@ -307,8 +389,11 @@ class Cache {
         const imageIdToUse = imageIdToURI(imageId);
         for (const volumeId of volumeIds) {
             const cachedVolume = this._volumeCache.get(volumeId);
+            if (!cachedVolume) {
+                return;
+            }
             const { volume } = cachedVolume;
-            if (!volume?.imageIds?.length) {
+            if (!volume.imageIds.length) {
                 return;
             }
             const imageIdIndex = volume.getImageURIIndex(imageIdToUse);
@@ -328,7 +413,50 @@ class Cache {
         }
         return this._imageCache.get(foundImageId);
     }
-    putVolumeLoadObject(volumeId, volumeLoadObject) {
+    _putVolumeCommon(volumeId, volume, cachedVolume) {
+        if (!this._volumeCache.get(volumeId)) {
+            console.warn('The volume was purged from the cache before it completed loading.');
+            return;
+        }
+        cachedVolume.loaded = true;
+        cachedVolume.volume = volume;
+        volume.imageIds?.forEach((imageId) => {
+            const image = this._imageCache.get(imageId);
+            if (image) {
+                image.sharedCacheKey = volumeId;
+            }
+        });
+        const eventDetails = {
+            volume: cachedVolume,
+        };
+        triggerEvent(eventTarget, Events.VOLUME_CACHE_VOLUME_ADDED, eventDetails);
+    }
+    putVolumeSync(volumeId, volume) {
+        if (volumeId === undefined) {
+            throw new Error('putVolumeSync: volumeId must not be undefined');
+        }
+        if (this._volumeCache.has(volumeId)) {
+            throw new Error('putVolumeSync: volumeId already in cache');
+        }
+        const cachedVolume = {
+            loaded: false,
+            volumeId,
+            volumeLoadObject: {
+                promise: Promise.resolve(volume),
+            },
+            timeStamp: Date.now(),
+            sizeInBytes: 0,
+        };
+        this._volumeCache.set(volumeId, cachedVolume);
+        try {
+            this._putVolumeCommon(volumeId, volume, cachedVolume);
+        }
+        catch (error) {
+            this._volumeCache.delete(volumeId);
+            throw error;
+        }
+    }
+    async putVolumeLoadObject(volumeId, volumeLoadObject) {
         if (volumeId === undefined) {
             throw new Error('putVolumeLoadObject: volumeId must not be undefined');
         }
@@ -352,24 +480,14 @@ class Cache {
         this._volumeCache.set(volumeId, cachedVolume);
         return volumeLoadObject.promise
             .then((volume) => {
-            if (!this._volumeCache.get(volumeId)) {
-                console.warn('The image was purged from the cache before it completed loading.');
-                return;
+            try {
+                this._putVolumeCommon(volumeId, volume, cachedVolume);
             }
-            if (Number.isNaN(volume.sizeInBytes)) {
-                throw new Error('putVolumeLoadObject: volume.sizeInBytes must not be undefined');
-            }
-            if (volume.sizeInBytes.toFixed === undefined) {
-                throw new Error('putVolumeLoadObject: volume.sizeInBytes is not a number');
+            catch (error) {
+                console.error(`Error in _putVolumeCommon for volume ${volumeId}:`, error);
+                this._volumeCache.delete(volumeId);
+                throw error;
             }
-            this.decacheIfNecessaryUntilBytesAvailable(volume.sizeInBytes, volume.imageIds);
-            cachedVolume.volume = volume;
-            cachedVolume.sizeInBytes = volume.sizeInBytes;
-            this._incrementVolumeCacheSize(cachedVolume.sizeInBytes);
-            const eventDetails = {
-                volume: cachedVolume,
-            };
-            triggerEvent(eventTarget, Events.VOLUME_CACHE_VOLUME_ADDED, eventDetails);
         })
             .catch((error) => {
             this._volumeCache.delete(volumeId);
@@ -380,4 +498,3 @@ class Cache {
 const cache = new Cache();
 export default cache;
 export { Cache };
-//# sourceMappingURL=cache.js.map

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

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

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,12 +1,12 @@
-import { Point3, IContourSet, IContour, ContourData } from '../../types';
+import type { Point3, IContourSet, 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 {
     readonly id: string;
     readonly sizeInBytes: number;

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';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type { Metadata, Point3, IImageVolume, 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 implements IImageVolume {
     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;