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

package/dist/esm/RenderingEngine/vtkClasses/vtkSlabCamera.js

@@ -1,7 +1,17 @@
 import macro from '@kitware/vtk.js/macros';
 import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
-import { vec3, mat4 } from 'gl-matrix';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
+import { vec3, mat4 } from 'gl-matrix';
+const DEFAULT_VALUES = {
+    isPerformingCoordinateTransformation: false,
+};
+function extend(publicAPI, model, initialValues = {}) {
+    Object.assign(model, DEFAULT_VALUES, initialValues);
+    vtkCamera.extend(publicAPI, model, initialValues);
+    macro.setGet(publicAPI, model, ['isPerformingCoordinateTransformation']);
+    vtkSlabCamera(publicAPI, model);
+}
+const newInstance = macro.newInstance(extend, 'vtkSlabCamera');
 function vtkSlabCamera(publicAPI, model) {
     model.classHierarchy.push('vtkSlabCamera');
     const tmpMatrix = mat4.identity(new Float64Array(16));
@@ -72,15 +82,5 @@ function vtkSlabCamera(publicAPI, model) {
         return result;
     };
 }
-const DEFAULT_VALUES = {
-    isPerformingCoordinateTransformation: false,
-};
-export function extend(publicAPI, model, initialValues = {}) {
-    Object.assign(model, DEFAULT_VALUES, initialValues);
-    vtkCamera.extend(publicAPI, model, initialValues);
-    macro.setGet(publicAPI, model, ['isPerformingCoordinateTransformation']);
-    vtkSlabCamera(publicAPI, model);
-}
-export const newInstance = macro.newInstance(extend, 'vtkSlabCamera');
 export default { newInstance, extend };
-//# sourceMappingURL=vtkSlabCamera.js.map
+export { newInstance, extend };

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLRenderWindow.js

@@ -1,6 +1,6 @@
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
-import vtkStreamingOpenGLViewNodeFactory from './vtkStreamingOpenGLViewNodeFactory';
+import vtkStreamingOpenGLViewNodeFactory, { registerOverride, } from './vtkStreamingOpenGLViewNodeFactory';
 function vtkStreamingOpenGLRenderWindow(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLRenderWindow');
 }
@@ -8,9 +8,8 @@ export function extend(publicAPI, model, initialValues = {}) {
     Object.assign(model, initialValues);
     vtkOpenGLRenderWindow.extend(publicAPI, model, initialValues);
     model.myFactory = vtkStreamingOpenGLViewNodeFactory.newInstance();
-    model.myFactory.registerOverride('vtkRenderWindow', newInstance);
+    registerOverride('vtkRenderWindow', newInstance);
     vtkStreamingOpenGLRenderWindow(publicAPI, model);
 }
 export const newInstance = macro.newInstance(extend, 'vtkStreamingOpenGLRenderWindow');
 export default { newInstance, extend };
-//# sourceMappingURL=vtkStreamingOpenGLRenderWindow.js.map

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLTexture.js

@@ -114,4 +114,3 @@ export function extend(publicAPI, model, initialValues = {}) {
 }
 export const newInstance = macro.newInstance(extend, 'vtkStreamingOpenGLTexture');
 export default { newInstance, extend };
-//# sourceMappingURL=vtkStreamingOpenGLTexture.js.map

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLViewNodeFactory.d.ts

@@ -1,3 +1,4 @@
+export function registerOverride(className: any, fn: any): void;
 export function extend(publicAPI: any, model: any, initialValues?: {}): void;
 export const newInstance: any;
 declare namespace _default {

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLViewNodeFactory.js

@@ -16,6 +16,10 @@ import vtkOpenGLVolume from '@kitware/vtk.js/Rendering/OpenGL/Volume';
 import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
 import vtkViewNodeFactory from '@kitware/vtk.js/Rendering/SceneGraph/ViewNodeFactory';
 import vtkStreamingOpenGLVolumeMapper from './vtkStreamingOpenGLVolumeMapper';
+const CLASS_MAPPING = Object.create(null);
+export function registerOverride(className, fn) {
+    CLASS_MAPPING[className] = fn;
+}
 function vtkStreamingOpenGLViewNodeFactory(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLViewNodeFactory');
     publicAPI.createNode = (dataObject) => {
@@ -42,6 +46,7 @@ function vtkStreamingOpenGLViewNodeFactory(publicAPI, model) {
         vn.setMyFactory(publicAPI);
         return vn;
     };
+    model.overrides = CLASS_MAPPING;
     model.getModelInitialValues = (dataObject) => {
         const initialValues = {};
         const className = dataObject.getClassName();
@@ -56,23 +61,22 @@ export function extend(publicAPI, model, initialValues = {}) {
     Object.assign(model, DEFAULT_VALUES, initialValues);
     vtkViewNodeFactory.extend(publicAPI, model, initialValues);
     vtkStreamingOpenGLViewNodeFactory(publicAPI, model);
-    publicAPI.registerOverride('vtkActor', vtkOpenGLActor.newInstance);
-    publicAPI.registerOverride('vtkActor2D', vtkOpenGLActor2D.newInstance);
-    publicAPI.registerOverride('vtkCamera', vtkOpenGLCamera.newInstance);
-    publicAPI.registerOverride('vtkGlyph3DMapper', vtkOpenGLGlyph3DMapper.newInstance);
-    publicAPI.registerOverride('vtkImageMapper', vtkOpenGLImageMapper.newInstance);
-    publicAPI.registerOverride('vtkImageSlice', vtkOpenGLImageSlice.newInstance);
-    publicAPI.registerOverride('vtkMapper', vtkOpenGLPolyDataMapper.newInstance);
-    publicAPI.registerOverride('vtkPixelSpaceCallbackMapper', vtkOpenGLPixelSpaceCallbackMapper.newInstance);
-    publicAPI.registerOverride('vtkRenderer', vtkOpenGLRenderer.newInstance);
-    publicAPI.registerOverride('vtkSkybox', vtkOpenGLSkybox.newInstance);
-    publicAPI.registerOverride('vtkSphereMapper', vtkOpenGLSphereMapper.newInstance);
-    publicAPI.registerOverride('vtkStickMapper', vtkOpenGLStickMapper.newInstance);
-    publicAPI.registerOverride('vtkTexture', vtkOpenGLTexture.newInstance);
-    publicAPI.registerOverride('vtkVolume', vtkOpenGLVolume.newInstance);
-    publicAPI.registerOverride('vtkVolumeMapper', vtkOpenGLVolumeMapper.newInstance);
-    publicAPI.registerOverride('vtkSharedVolumeMapper', vtkStreamingOpenGLVolumeMapper.newInstance);
+    registerOverride('vtkActor', vtkOpenGLActor.newInstance);
+    registerOverride('vtkActor2D', vtkOpenGLActor2D.newInstance);
+    registerOverride('vtkCamera', vtkOpenGLCamera.newInstance);
+    registerOverride('vtkGlyph3DMapper', vtkOpenGLGlyph3DMapper.newInstance);
+    registerOverride('vtkImageMapper', vtkOpenGLImageMapper.newInstance);
+    registerOverride('vtkImageSlice', vtkOpenGLImageSlice.newInstance);
+    registerOverride('vtkMapper', vtkOpenGLPolyDataMapper.newInstance);
+    registerOverride('vtkPixelSpaceCallbackMapper', vtkOpenGLPixelSpaceCallbackMapper.newInstance);
+    registerOverride('vtkRenderer', vtkOpenGLRenderer.newInstance);
+    registerOverride('vtkSkybox', vtkOpenGLSkybox.newInstance);
+    registerOverride('vtkSphereMapper', vtkOpenGLSphereMapper.newInstance);
+    registerOverride('vtkStickMapper', vtkOpenGLStickMapper.newInstance);
+    registerOverride('vtkTexture', vtkOpenGLTexture.newInstance);
+    registerOverride('vtkVolume', vtkOpenGLVolume.newInstance);
+    registerOverride('vtkVolumeMapper', vtkOpenGLVolumeMapper.newInstance);
+    registerOverride('vtkSharedVolumeMapper', vtkStreamingOpenGLVolumeMapper.newInstance);
 }
 export const newInstance = macro.newInstance(extend, 'vtkStreamingOpenGLViewNodeFactory');
 export default { newInstance, extend };
-//# sourceMappingURL=vtkStreamingOpenGLViewNodeFactory.js.map

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLVolumeMapper.js

@@ -4,7 +4,6 @@ import { Filter } from '@kitware/vtk.js/Rendering/OpenGL/Texture/Constants';
 import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray/Constants';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
-const { vtkWarningMacro } = macro;
 function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLVolumeMapper');
     publicAPI.buildBufferObjects = (ren, actor) => {
@@ -85,6 +84,7 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
             model.colorTexture.create2DFromRaw(cWidth, 2 * numIComps, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
             model.colorTextureString = toString;
         }
+        publicAPI.updateLabelOutlineThicknessTexture(actor);
         toString = `${image.getMTime()}`;
         if (model.scalarTextureString !== toString) {
             const dims = image.getDimensions();
@@ -168,4 +168,3 @@ export function extend(publicAPI, model, initialValues = {}) {
 }
 export const newInstance = macro.newInstance(extend, 'vtkStreamingOpenGLVolumeMapper');
 export default { newInstance, extend };
-//# sourceMappingURL=vtkStreamingOpenGLVolumeMapper.js.map

package/dist/esm/Settings.js

@@ -4,7 +4,9 @@ const OBJECT_SETTINGS_MAP = Symbol('ObjectSettingsMap');
 const DICTIONARY = Symbol('Dictionary');
 export default class Settings {
     constructor(base) {
-        const dictionary = Object.create(base instanceof Settings && DICTIONARY in base ? base[DICTIONARY] : null);
+        const dictionary = Object.create((base instanceof Settings && DICTIONARY in base
+            ? base[DICTIONARY]
+            : null));
         Object.seal(Object.defineProperty(this, DICTIONARY, {
             value: dictionary,
         }));
@@ -190,4 +192,3 @@ function deepSet(context, key, value) {
     }
 }
 Settings.getDefaultSettings().set('useCursors', true);
-//# sourceMappingURL=Settings.js.map

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

@@ -1,4 +1,4 @@
-import { ICache, IImageVolume, IGeometry, IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject, ICachedImage } from '../types';
+import { ICache, IImage, IGeometry, IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject, ICachedImage, IImageVolume } from '../types';
 declare class Cache implements ICache {
     private readonly _imageCache;
     private readonly _volumeCache;
@@ -6,10 +6,12 @@ declare class Cache implements ICache {
     private _imageCacheSize;
     private _volumeCacheSize;
     private _maxCacheSize;
+    private _maxInstanceSize;
     constructor();
     setMaxCacheSize: (newMaxCacheSize: number) => void;
     isCacheable: (byteLength: number) => boolean;
     getMaxCacheSize: () => number;
+    getMaxInstanceSize: () => number;
     getCacheSize: () => number;
     getBytesAvailable(): number;
     private _decacheImage;
@@ -17,9 +19,11 @@ declare class Cache implements ICache {
     purgeCache: () => void;
     purgeVolumeCache: () => void;
     decacheIfNecessaryUntilBytesAvailable(numBytes: number, volumeImageIds?: Array<string>): number | undefined;
+    private _putImageCommon;
     putImageLoadObject(imageId: string, imageLoadObject: IImageLoadObject): Promise<any>;
+    putImageSync(imageId: string, image: IImage): void;
     getImageLoadObject(imageId: string): IImageLoadObject;
-    isImageIdCached(imageId: string): boolean;
+    isLoaded(imageId: string): boolean;
     getVolumeContainingImageId(imageId: string): {
         volume: IImageVolume;
         imageIdIndex: number;
@@ -28,12 +32,17 @@ declare class Cache implements ICache {
     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>;
     removeImageLoadObject: (imageId: string) => void;
     removeVolumeLoadObject: (volumeId: string) => void;
     putGeometryLoadObject: (geometryId: string, geometryLoadObject: IGeometryLoadObject) => Promise<void>;
-    private _incrementImageCacheSize;
-    private _incrementVolumeCacheSize;
+    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,9 +1,16 @@
 import { triggerEvent, imageIdToURI } from '../utilities';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
-const MAX_CACHE_SIZE_1GB = 1073741824;
+import { restoreImagesFromBuffer } from './utils/restoreImagesFromBuffer';
+const ONE_GB = 1073741824;
 class Cache {
     constructor() {
+        this._imageCache = new Map();
+        this._volumeCache = 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.`;
@@ -12,12 +19,16 @@ 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;
         };
         this.getMaxCacheSize = () => this._maxCacheSize;
+        this.getMaxInstanceSize = () => this._maxInstanceSize;
         this.getCacheSize = () => this._imageCacheSize + this._volumeCacheSize;
         this._decacheImage = (imageId) => {
             const { imageLoadObject } = this._imageCache.get(imageId);
@@ -38,6 +49,7 @@ class Cache {
             if (volume.imageData) {
                 volume.imageData.delete();
             }
+            restoreImagesFromBuffer(volume);
             if (volumeLoadObject.cancelFn) {
                 volumeLoadObject.cancelFn();
             }
@@ -93,6 +105,17 @@ class Cache {
             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 === undefined) {
+                return;
+            }
+            cachedImage.timeStamp = Date.now();
+            return cachedImage.image;
+        };
         this.getVolume = (volumeId) => {
             if (volumeId === undefined) {
                 throw new Error('getVolume: volumeId must not be undefined');
@@ -104,6 +127,16 @@ class Cache {
             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');
@@ -112,8 +145,9 @@ class Cache {
             if (cachedImage === undefined) {
                 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);
@@ -127,7 +161,7 @@ class Cache {
             if (cachedVolume === undefined) {
                 throw new Error('removeVolumeLoadObject: volumeId was not present in volumeCache');
             }
-            this._incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
+            this.incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
             const eventDetails = {
                 volume: cachedVolume,
                 volumeId,
@@ -174,18 +208,19 @@ class Cache {
                 throw error;
             });
         };
-        this._incrementImageCacheSize = (increment) => {
+        this.incrementImageCacheSize = (increment) => {
             this._imageCacheSize += increment;
         };
-        this._incrementVolumeCacheSize = (increment) => {
+        this.incrementVolumeCacheSize = (increment) => {
             this._volumeCacheSize += increment;
         };
-        this._imageCache = new Map();
-        this._volumeCache = new Map();
+        this.decrementImageCacheSize = (decrement) => {
+            this._imageCacheSize -= decrement;
+        };
+        this.decrementVolumeCacheSize = (decrement) => {
+            this._volumeCacheSize -= decrement;
+        };
         this._geometryCache = new Map();
-        this._imageCacheSize = 0;
-        this._volumeCacheSize = 0;
-        this._maxCacheSize = MAX_CACHE_SIZE_1GB;
     }
     getBytesAvailable() {
         return this.getMaxCacheSize() - this.getCacheSize();
@@ -230,6 +265,31 @@ class Cache {
             }
         }
     }
+    _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;
+    }
     putImageLoadObject(imageId, imageLoadObject) {
         if (imageId === undefined) {
             throw new Error('putImageLoadObject: imageId must not be undefined');
@@ -255,35 +315,39 @@ class Cache {
         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;
-            }
-            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);
-            }
-            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;
+            this._putImageCommon(imageId, image, cachedImage);
         })
             .catch((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');
@@ -295,7 +359,7 @@ class Cache {
         cachedImage.timeStamp = Date.now();
         return cachedImage.imageLoadObject;
     }
-    isImageIdCached(imageId) {
+    isLoaded(imageId) {
         const cachedImage = this._imageCache.get(imageId);
         if (!cachedImage) {
             return false;
@@ -365,7 +429,7 @@ class Cache {
             this.decacheIfNecessaryUntilBytesAvailable(volume.sizeInBytes, volume.imageIds);
             cachedVolume.volume = volume;
             cachedVolume.sizeInBytes = volume.sizeInBytes;
-            this._incrementVolumeCacheSize(cachedVolume.sizeInBytes);
+            this.incrementVolumeCacheSize(cachedVolume.sizeInBytes);
             const eventDetails = {
                 volume: cachedVolume,
             };
@@ -380,4 +444,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,6 +1,6 @@
 import { Point3, ContourData, IContour } from '../../types';
 import { ContourType } from '../../enums';
-declare type ContourProps = {
+type ContourProps = {
     id: string;
     data: ContourData;
     color: Point3;

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

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

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

@@ -1,6 +1,6 @@
 import { Point3, IContourSet, IContour, ContourData } from '../../types';
 import Contour from './Contour';
-declare type ContourSetProps = {
+type ContourSetProps = {
     id: string;
     data: ContourData[];
     frameOfReferenceUID: string;

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

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

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

@@ -1,11 +1,15 @@
-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 { Metadata, Point3, IImageVolume, Mat3, PixelDataTypedArray, ImageVolumeProps, IImage, IImageLoadObject } from '../../types';
 export declare class ImageVolume implements IImageVolume {
     private _imageIds;
     private _imageIdsIndexMap;
     private _imageURIsIndexMap;
-    protected scalarData: VolumeScalarData | Array<VolumeScalarData>;
+    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;
@@ -26,16 +30,32 @@ export declare class ImageVolume implements IImageVolume {
     vtkOpenGLTexture: any;
     loadStatus?: Record<string, any>;
     referencedVolumeId?: string;
+    referencedImageIds?: Array<string>;
     hasPixelSpacing: boolean;
-    constructor(props: IVolume);
+    additionalDetails?: Record<string, any>;
+    constructor(props: ImageVolumeProps);
     get imageIds(): Array<string>;
     set imageIds(newImageIds: Array<string>);
     private _reprocessImageIds;
     cancelLoading: () => void;
     isDynamicVolume(): boolean;
-    getScalarData(): VolumeScalarData;
+    getScalarData(): PixelDataTypedArray;
     getImageIdIndex(imageId: string): number;
     getImageURIIndex(imageURI: string): number;
     destroy(): void;
+    getScalarDataArrays(): PixelDataTypedArray[];
+    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;