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

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

@@ -1,48 +1,44 @@
-import { ICache, IImage, IGeometry, IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject, ICachedImage, IImageVolume } from '../types';
+import type { ICache, IImage, IGeometry, IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject, ICachedImage, IImageVolume } from '../types';
 declare class Cache implements ICache {
     private readonly _imageCache;
     private readonly _volumeCache;
     private readonly _geometryCache;
     private _imageCacheSize;
-    private _volumeCacheSize;
     private _maxCacheSize;
-    private _maxInstanceSize;
-    constructor();
     setMaxCacheSize: (newMaxCacheSize: number) => void;
-    isCacheable: (byteLength: number) => boolean;
+    isCacheable: (byteLength: any) => boolean;
     getMaxCacheSize: () => number;
-    getMaxInstanceSize: () => number;
     getCacheSize: () => number;
     getBytesAvailable(): number;
     private _decacheImage;
     private _decacheVolume;
     purgeCache: () => void;
     purgeVolumeCache: () => void;
-    decacheIfNecessaryUntilBytesAvailable(numBytes: number, volumeImageIds?: Array<string>): number | undefined;
+    decacheIfNecessaryUntilBytesAvailable(numBytes: number, volumeImageIds?: string[]): number | undefined;
     private _putImageCommon;
-    putImageLoadObject(imageId: string, imageLoadObject: IImageLoadObject): Promise<any>;
+    putImageLoadObject(imageId: string, imageLoadObject: IImageLoadObject): Promise<void>;
     putImageSync(imageId: string, image: IImage): void;
-    getImageLoadObject(imageId: string): IImageLoadObject;
+    getImageLoadObject(imageId: string): IImageLoadObject | undefined;
     isLoaded(imageId: string): boolean;
     getVolumeContainingImageId(imageId: string): {
         volume: IImageVolume;
         imageIdIndex: number;
-    };
+    } | undefined;
     getCachedImageBasedOnImageURI(imageId: string): ICachedImage | undefined;
-    putVolumeLoadObject(volumeId: string, volumeLoadObject: IVolumeLoadObject): Promise<any>;
-    getVolumeLoadObject: (volumeId: string) => IVolumeLoadObject;
-    getGeometry: (geometryId: string) => IGeometry;
-    getImage: (imageId: string) => IImage;
-    getVolume: (volumeId: string) => IImageVolume;
-    getVolumes: () => Array<IImageVolume>;
-    filterVolumesByReferenceId: (volumeId: string) => Array<IImageVolume>;
+    private _putVolumeCommon;
+    putVolumeSync(volumeId: string, volume: IImageVolume): void;
+    putVolumeLoadObject(volumeId: string, volumeLoadObject: IVolumeLoadObject): Promise<void>;
+    getVolumeLoadObject: (volumeId: string) => IVolumeLoadObject | undefined;
+    getGeometry: (geometryId: string) => IGeometry | undefined;
+    getImage: (imageId: string) => IImage | undefined;
+    getVolume: (volumeId: string) => IImageVolume | undefined;
+    getVolumes: () => IImageVolume[];
+    filterVolumesByReferenceId: (volumeId: string) => IImageVolume[];
     removeImageLoadObject: (imageId: string) => void;
     removeVolumeLoadObject: (volumeId: string) => void;
     putGeometryLoadObject: (geometryId: string, geometryLoadObject: IGeometryLoadObject) => Promise<void>;
     incrementImageCacheSize: (increment: number) => void;
-    incrementVolumeCacheSize: (increment: number) => void;
     decrementImageCacheSize: (decrement: number) => void;
-    decrementVolumeCacheSize: (decrement: number) => void;
 }
 declare const cache: Cache;
 export default cache;

package/dist/esm/cache/cache.js

@@ -1,16 +1,15 @@
-import { triggerEvent, imageIdToURI } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
+import imageIdToURI from '../utilities/imageIdToURI';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
-import { restoreImagesFromBuffer } from './utils/restoreImagesFromBuffer';
 const ONE_GB = 1073741824;
 class Cache {
     constructor() {
         this._imageCache = new Map();
         this._volumeCache = new Map();
+        this._geometryCache = new Map();
         this._imageCacheSize = 0;
-        this._volumeCacheSize = 0;
         this._maxCacheSize = 3 * ONE_GB;
-        this._maxInstanceSize = 4 * ONE_GB - 8;
         this.setMaxCacheSize = (newMaxCacheSize) => {
             if (!newMaxCacheSize || typeof newMaxCacheSize !== 'number') {
                 const errorMessage = `New max cacheSize ${this._maxCacheSize} should be defined and should be a number.`;
@@ -19,19 +18,27 @@ class Cache {
             this._maxCacheSize = newMaxCacheSize;
         };
         this.isCacheable = (byteLength) => {
-            if (byteLength > this._maxInstanceSize) {
-                return false;
-            }
-            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.getMaxInstanceSize = () => this._maxInstanceSize;
-        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();
             }
@@ -42,24 +49,35 @@ 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();
             }
             if (volume.imageData) {
                 volume.imageData.delete();
             }
-            restoreImagesFromBuffer(volume);
             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) {
@@ -68,7 +86,6 @@ class Cache {
                 this.removeImageLoadObject(imageId);
                 triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_REMOVED, { imageId });
             }
-            this.purgeVolumeCache();
         };
         this.purgeVolumeCache = () => {
             const volumeIterator = this._volumeCache.keys();
@@ -88,7 +105,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();
@@ -99,7 +116,7 @@ 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();
@@ -110,7 +127,7 @@ class Cache {
                 throw new Error('getImage: imageId must not be undefined');
             }
             const cachedImage = this._imageCache.get(imageId);
-            if (cachedImage === undefined) {
+            if (!cachedImage) {
                 return;
             }
             cachedImage.timeStamp = Date.now();
@@ -121,7 +138,7 @@ class Cache {
                 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();
@@ -142,7 +159,7 @@ class Cache {
                 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);
@@ -158,10 +175,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,
@@ -211,16 +227,9 @@ class Cache {
         this.incrementImageCacheSize = (increment) => {
             this._imageCacheSize += increment;
         };
-        this.incrementVolumeCacheSize = (increment) => {
-            this._volumeCacheSize += increment;
-        };
         this.decrementImageCacheSize = (decrement) => {
             this._imageCacheSize -= decrement;
         };
-        this.decrementVolumeCacheSize = (decrement) => {
-            this._volumeCacheSize -= decrement;
-        };
-        this._geometryCache = new Map();
     }
     getBytesAvailable() {
         return this.getMaxCacheSize() - this.getCacheSize();
@@ -230,7 +239,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;
@@ -241,7 +250,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));
@@ -254,8 +263,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 });
@@ -290,18 +297,22 @@ class Cache {
         triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_ADDED, eventDetails);
         cachedImage.sharedCacheKey = image.sharedCacheKey;
     }
-    putImageLoadObject(imageId, imageLoadObject) {
+    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 = {
@@ -313,11 +324,19 @@ class Cache {
             sizeInBytes: 0,
         };
         this._imageCache.set(imageId, cachedImage);
+        this._imageCache.set(imageId, cachedImage);
         return imageLoadObject.promise
             .then((image) => {
-            this._putImageCommon(imageId, image, cachedImage);
+            try {
+                this._putImageCommon(imageId, image, cachedImage);
+            }
+            catch (error) {
+                console.debug(`Error in _putImageCommon for image ${imageId}:`, error);
+                throw error;
+            }
         })
             .catch((error) => {
+            console.debug(`Error caching image ${imageId}:`, error);
             this._imageCache.delete(imageId);
             throw error;
         });
@@ -353,7 +372,7 @@ class Cache {
             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();
@@ -371,8 +390,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);
@@ -392,7 +414,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');
         }
@@ -416,24 +481,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);

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

@@ -1,11 +1,11 @@
-import { Point3, ContourData, IContour } from '../../types';
-import { ContourType } from '../../enums';
-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/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';
-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/ImageVolume.d.ts

@@ -1,15 +1,19 @@
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { Metadata, Point3, IImageVolume, Mat3, PixelDataTypedArray, ImageVolumeProps, IImage, IImageLoadObject } from '../../types';
+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: PixelDataTypedArray | Array<PixelDataTypedArray>;
     protected numFrames: number;
     protected totalNumFrames: number;
     protected cornerstoneImageMetaData: any;
     readonly volumeId: string;
-    imageCacheOffsetMap: Map<any, any>;
     isPreScaled: boolean;
     dimensions: Point3;
     direction: Mat3;
@@ -23,39 +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?: Array<string>;
+    referencedImageIds?: string[];
     hasPixelSpacing: boolean;
-    additionalDetails?: Record<string, any>;
+    additionalDetails?: Record<string, unknown>;
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+    dataType?: PixelDataTypedArrayString;
+    numTimePoints?: number;
     constructor(props: ImageVolumeProps);
-    get imageIds(): Array<string>;
-    set imageIds(newImageIds: Array<string>);
+    get sizeInBytes(): number;
+    get imageIds(): string[];
+    set imageIds(newImageIds: string[]);
     private _reprocessImageIds;
     cancelLoading: () => void;
     isDynamicVolume(): boolean;
-    getScalarData(): PixelDataTypedArray;
     getImageIdIndex(imageId: string): number;
+    getImageIdByIndex(imageIdIndex: number): string;
     getImageURIIndex(imageURI: string): number;
     destroy(): void;
-    getScalarDataArrays(): PixelDataTypedArray[];
+    invalidate(): void;
     modified(): void;
-    decache(completelyRemove?: boolean): void | Array<string>;
     removeFromCache(): void;
     getScalarDataLength(): number;
     private _getNumFrames;
-    private _getScalarDataLength;
-    private _createCornerstoneImageMetaData;
-    protected getScalarDataByImageIdIndex(imageIdIndex: number): PixelDataTypedArray;
-    getCornerstoneImage(imageId: string, imageIdIndex: number): IImage;
     protected imageIdIndexToFrameIndex(imageIdIndex: number): number;
-    getCornerstoneImageLoadObject(imageId: string, imageIdIndex: number): IImageLoadObject;
     getCornerstoneImages(): IImage[];
-    convertToImageSlicesAndCache(): string[];
 }
 export default ImageVolume;