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

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

@@ -1,108 +1,117 @@
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
-import HalfFloat from '@kitware/vtk.js/Common/Core/HalfFloat';
-import { getConfiguration } from '../../init';
+import cache from '../../cache';
 function vtkStreamingOpenGLTexture(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLTexture');
+    model.updatedFrames = [];
+    model.volumeId = null;
     const superCreate3DFilterableFromRaw = publicAPI.create3DFilterableFromRaw;
-    publicAPI.create3DFilterableFromRaw = (width, height, depth, numComps, dataType, data, preferSizeOverAccuracy) => {
+    publicAPI.create3DFilterableFromRaw = (width, height, depth, numberOfComponents, dataType, data, preferSizeOverAccuracy) => {
         model.inputDataType = dataType;
-        model.inputNumComps = numComps;
-        superCreate3DFilterableFromRaw(width, height, depth, numComps, dataType, data, preferSizeOverAccuracy);
+        model.inputNumComps = numberOfComponents;
+        superCreate3DFilterableFromRaw(width, height, depth, numberOfComponents, dataType, data, preferSizeOverAccuracy);
     };
-    publicAPI.update3DFromRaw = (data) => {
-        const { updatedFrames } = model;
-        if (!updatedFrames.length) {
+    publicAPI.update3DFromRaw = () => {
+        const { volumeId } = model;
+        if (!volumeId) {
             return;
         }
+        const volume = cache.getVolume(volumeId);
         model._openGLRenderWindow.activateTexture(publicAPI);
         publicAPI.createTexture();
         publicAPI.bind();
-        let bytesPerVoxel;
-        let TypedArrayConstructor;
-        if (data instanceof Uint8Array) {
-            bytesPerVoxel = 1;
-            TypedArrayConstructor = Uint8Array;
-        }
-        else if (data instanceof Int16Array) {
-            bytesPerVoxel = 2;
-            TypedArrayConstructor = Int16Array;
-        }
-        else if (data instanceof Uint16Array) {
-            bytesPerVoxel = 2;
-            TypedArrayConstructor = Uint16Array;
+        if (volume.isDynamicVolume()) {
+            updateDynamicVolumeTexture();
+            return;
         }
-        else if (data instanceof Float32Array) {
-            bytesPerVoxel = 4;
-            TypedArrayConstructor = Float32Array;
+        return (publicAPI.hasUpdatedFrames() && updateTextureImagesUsingVoxelManager());
+    };
+    const superModified = publicAPI.modified;
+    publicAPI.setUpdatedFrame = (frameIndex) => {
+        model.updatedFrames[frameIndex] = true;
+        superModified();
+    };
+    publicAPI.modified = () => {
+        superModified();
+        const volume = cache.getVolume(model.volumeId);
+        if (!volume) {
+            return;
         }
-        else {
-            throw new Error(`No support for given TypedArray.`);
+        const imageIds = volume.imageIds;
+        for (let i = 0; i < imageIds.length; i++) {
+            model.updatedFrames[i] = true;
         }
-        for (let i = 0; i < updatedFrames.length; i++) {
-            if (updatedFrames[i]) {
-                model.fillSubImage3D(data, i, bytesPerVoxel, TypedArrayConstructor);
+    };
+    function updateTextureImagesUsingVoxelManager() {
+        const volume = cache.getVolume(model.volumeId);
+        const imageIds = volume.imageIds;
+        for (let i = 0; i < model.updatedFrames.length; i++) {
+            if (model.updatedFrames[i]) {
+                const image = cache.getImage(imageIds[i]);
+                if (!image) {
+                    continue;
+                }
+                const data = image.voxelManager.getScalarData();
+                const gl = model.context;
+                const dataType = data.constructor.name;
+                const [pixData] = publicAPI.updateArrayDataTypeForGL(dataType, [data]);
+                publicAPI.bind();
+                const zOffset = i;
+                gl.texSubImage3D(model.target, 0, 0, 0, zOffset, model.width, model.height, 1, model.format, model.openGLDataType, pixData);
+                publicAPI.deactivate();
+                model.updatedFrames[i] = null;
             }
         }
-        model.updatedFrames = [];
         if (model.generateMipmap) {
             model.context.generateMipmap(model.target);
         }
         publicAPI.deactivate();
         return true;
-    };
-    model.fillSubImage3D = (data, frameIndex, bytesPerVoxel, TypedArrayConstructor) => {
-        const buffer = data.buffer;
-        const frameLength = model.width * model.height;
-        const frameLengthInBytes = frameLength * model.components * bytesPerVoxel;
-        const zOffset = frameIndex * frameLengthInBytes;
-        const rowLength = model.width * model.components;
-        const gl = model.context;
-        const MAX_TEXTURE_SIZE = gl.getParameter(gl.MAX_TEXTURE_SIZE);
-        let blockHeight = Math.floor((bytesPerVoxel * MAX_TEXTURE_SIZE) / model.width);
-        blockHeight = Math.min(blockHeight, model.height);
-        const { useNorm16Texture, preferSizeOverAccuracy } = getConfiguration().rendering;
-        if (useNorm16Texture && !preferSizeOverAccuracy) {
-            blockHeight = 1;
-        }
-        const multiRowBlockLength = rowLength * blockHeight;
-        const multiRowBlockLengthInBytes = multiRowBlockLength * bytesPerVoxel;
-        const normalBlocks = Math.floor(model.height / blockHeight);
-        const lastBlockHeight = model.height % blockHeight;
-        const multiRowLastBlockLength = rowLength * lastBlockHeight;
-        for (let block = 0; block < normalBlocks; block++) {
-            const yOffset = block * blockHeight;
-            let dataView = new TypedArrayConstructor(buffer, zOffset + block * multiRowBlockLengthInBytes, multiRowBlockLength);
-            if (model.useHalfFloat &&
-                (TypedArrayConstructor === Uint16Array ||
-                    TypedArrayConstructor === Int16Array)) {
-                for (let idx = 0; idx < dataView.length; idx++) {
-                    dataView[idx] = HalfFloat.toHalf(dataView[idx]);
-                }
-                if (TypedArrayConstructor === Int16Array) {
-                    dataView = new Uint16Array(dataView);
-                }
+    }
+    function updateDynamicVolumeTexture() {
+        const volume = cache.getVolume(model.volumeId);
+        const imageIds = volume.getCurrentTimePointImageIds();
+        for (let i = 0; i < imageIds.length; i++) {
+            const imageId = imageIds[i];
+            const image = cache.getImage(imageId);
+            if (!image) {
+                continue;
             }
-            gl.texSubImage3D(model.target, 0, 0, yOffset, frameIndex, model.width, blockHeight, 1, model.format, model.openGLDataType, dataView);
+            const data = image.voxelManager.getScalarData();
+            const gl = model.context;
+            const dataType = data.constructor.name;
+            const [pixData] = publicAPI.updateArrayDataTypeForGL(dataType, [data]);
+            publicAPI.bind();
+            let zOffset = i;
+            gl.texSubImage3D(model.target, 0, 0, 0, zOffset, model.width, model.height, 1, model.format, model.openGLDataType, pixData);
+            publicAPI.deactivate();
         }
-        if (lastBlockHeight !== 0) {
-            const yOffset = normalBlocks * blockHeight;
-            const dataView = new TypedArrayConstructor(buffer, zOffset + normalBlocks * multiRowBlockLengthInBytes, multiRowLastBlockLength);
-            gl.texSubImage3D(model.target, 0, 0, yOffset, frameIndex, model.width, lastBlockHeight, 1, model.format, model.openGLDataType, dataView);
+        if (model.generateMipmap) {
+            model.context.generateMipmap(model.target);
         }
+        publicAPI.deactivate();
+        return true;
+    }
+    publicAPI.hasUpdatedFrames = () => !model.updatedFrames.length || model.updatedFrames.some((frame) => frame);
+    publicAPI.getUpdatedFrames = () => model.updatedFrames;
+    publicAPI.setVolumeId = (volumeId) => {
+        model.volumeId = volumeId;
     };
-    publicAPI.getTextureParameters = () => {
-        return {
-            width: model.width,
-            height: model.height,
-            depth: model.depth,
-            numComps: model.inputNumComps,
-            dataType: model.inputDataType,
-        };
-    };
-    publicAPI.setUpdatedFrame = (frameIndex) => {
-        model.updatedFrames[frameIndex] = true;
+    publicAPI.getVolumeId = () => model.volumeId;
+    publicAPI.setTextureParameters = ({ width, height, depth, numberOfComponents, dataType, }) => {
+        model.width ??= width;
+        model.height ??= height;
+        model.depth ??= depth;
+        model.inputNumComps ??= numberOfComponents;
+        model.inputDataType ??= dataType;
     };
+    publicAPI.getTextureParameters = () => ({
+        width: model.width,
+        height: model.height,
+        depth: model.depth,
+        numberOfComponents: model.inputNumComps,
+        dataType: model.inputDataType,
+    });
 }
 const DEFAULT_VALUES = {
     updatedFrames: [],

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

@@ -31,7 +31,7 @@ function vtkStreamingOpenGLViewNodeFactory(publicAPI, model) {
         let isObject = false;
         const keys = Object.keys(model.overrides);
         while (className && !isObject) {
-            if (keys.indexOf(className) !== -1) {
+            if (keys.includes(className)) {
                 isObject = true;
             }
             else {

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

@@ -2,8 +2,10 @@ import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
 import { Filter } from '@kitware/vtk.js/Rendering/OpenGL/Texture/Constants';
 import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray/Constants';
+import { getTransferFunctionHash } from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow/resourceSharingHelper';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
+import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
 function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLVolumeMapper');
     publicAPI.buildBufferObjects = (ren, actor) => {
@@ -11,10 +13,6 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
         if (!image) {
             return;
         }
-        const scalars = image.getPointData() && image.getPointData().getScalars();
-        if (!scalars) {
-            return;
-        }
         const vprop = actor.getProperty();
         if (!model.jitterTexture.getHandle()) {
             const oTable = new Uint8Array(32 * 32);
@@ -25,18 +23,22 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
             model.jitterTexture.setMagnificationFilter(Filter.LINEAR);
             model.jitterTexture.create2DFromRaw(32, 32, 1, VtkDataTypes.UNSIGNED_CHAR, oTable);
         }
-        const numComp = scalars.getNumberOfComponents();
-        const iComps = vprop.getIndependentComponents();
-        const numIComps = iComps ? numComp : 1;
-        let toString = `${vprop.getMTime()}`;
-        if (model.opacityTextureString !== toString) {
+        const { numberOfComponents: numIComps } = image.get('numberOfComponents');
+        const useIndependentComps = publicAPI.useIndependentComponents(vprop);
+        const scalarOpacityFunc = vprop.getScalarOpacity();
+        const opTex = model._openGLRenderWindow.getGraphicsResourceForObject(scalarOpacityFunc);
+        let toString = getTransferFunctionHash(scalarOpacityFunc, useIndependentComps, numIComps);
+        const reBuildOp = !opTex?.oglObject || opTex.hash !== toString;
+        if (reBuildOp) {
+            model.opacityTexture = vtkOpenGLTexture.newInstance();
+            model.opacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
             const oWidth = 1024;
             const oSize = oWidth * 2 * numIComps;
             const ofTable = new Float32Array(oSize);
             const tmpTable = new Float32Array(oWidth);
             for (let c = 0; c < numIComps; ++c) {
                 const ofun = vprop.getScalarOpacity(c);
-                const opacityFactor = model.renderable.getSampleDistance() /
+                const opacityFactor = publicAPI.getCurrentSampleDistance(ren) /
                     vprop.getScalarOpacityUnitDistance(c);
                 const oRange = ofun.getRange();
                 ofun.getTable(oRange[0], oRange[1], oWidth, tmpTable, 1);
@@ -46,7 +48,7 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                     ofTable[c * oWidth * 2 + i + oWidth] = ofTable[c * oWidth * 2 + i];
                 }
             }
-            model.opacityTexture.releaseGraphicsResources(model._openGLRenderWindow);
+            model.opacityTexture.resetFormatAndType();
             model.opacityTexture.setMinificationFilter(Filter.LINEAR);
             model.opacityTexture.setMagnificationFilter(Filter.LINEAR);
             if (model._openGLRenderWindow.getWebgl2() ||
@@ -55,19 +57,34 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                 model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.FLOAT, ofTable);
             }
             else {
-                const oTable = new Uint8Array(oSize);
+                const oTable = new Uint8ClampedArray(oSize);
                 for (let i = 0; i < oSize; ++i) {
                     oTable[i] = 255.0 * ofTable[i];
                 }
                 model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.UNSIGNED_CHAR, oTable);
             }
-            model.opacityTextureString = toString;
+            if (scalarOpacityFunc) {
+                model._openGLRenderWindow.setGraphicsResourceForObject(scalarOpacityFunc, model.opacityTexture, toString);
+                if (scalarOpacityFunc !== model._scalarOpacityFunc) {
+                    model._openGLRenderWindow.registerGraphicsResourceUser(scalarOpacityFunc, publicAPI);
+                    model._openGLRenderWindow.unregisterGraphicsResourceUser(model._scalarOpacityFunc, publicAPI);
+                }
+                model._scalarOpacityFunc = scalarOpacityFunc;
+            }
+        }
+        else {
+            model.opacityTexture = opTex.oglObject;
         }
-        toString = `${vprop.getMTime()}`;
-        if (model.colorTextureString !== toString) {
+        const colorTransferFunc = vprop.getRGBTransferFunction();
+        toString = getTransferFunctionHash(colorTransferFunc, useIndependentComps, numIComps);
+        const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+        const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== toString;
+        if (reBuildC) {
+            model.colorTexture = vtkOpenGLTexture.newInstance();
+            model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
             const cWidth = 1024;
             const cSize = cWidth * 2 * numIComps * 3;
-            const cTable = new Uint8Array(cSize);
+            const cTable = new Uint8ClampedArray(cSize);
             const tmpTable = new Float32Array(cWidth * 3);
             for (let c = 0; c < numIComps; ++c) {
                 const cfun = vprop.getRGBTransferFunction(c);
@@ -78,39 +95,57 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                     cTable[c * cWidth * 6 + i + cWidth * 3] = 255.0 * tmpTable[i];
                 }
             }
-            model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
+            model.colorTexture.resetFormatAndType();
             model.colorTexture.setMinificationFilter(Filter.LINEAR);
             model.colorTexture.setMagnificationFilter(Filter.LINEAR);
             model.colorTexture.create2DFromRaw(cWidth, 2 * numIComps, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
-            model.colorTextureString = toString;
+            if (colorTransferFunc) {
+                model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, toString);
+                if (colorTransferFunc !== model._colorTransferFunc) {
+                    model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+                    model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
+                }
+                model._colorTransferFunc = colorTransferFunc;
+            }
+        }
+        else {
+            model.colorTexture = cTex.oglObject;
         }
         publicAPI.updateLabelOutlineThicknessTexture(actor);
-        toString = `${image.getMTime()}`;
+        toString = `${image.getMTime()}-${model.scalarTexture.getMTime()}`;
         if (model.scalarTextureString !== toString) {
             const dims = image.getDimensions();
+            model.scalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+            model.scalarTexture.enableUseHalfFloat(false);
             const previousTextureParameters = model.scalarTexture.getTextureParameters();
-            const dataType = image.getPointData().getScalars().getDataType();
-            const data = image.getPointData().getScalars().getData();
+            const dataType = image.get('dataType').dataType;
             let shouldReset = true;
-            if (previousTextureParameters.dataType &&
-                previousTextureParameters.dataType === dataType) {
-                const previousTextureSize = previousTextureParameters.width *
-                    previousTextureParameters.height *
-                    previousTextureParameters.depth *
-                    previousTextureParameters.numComps;
-                if (data.length === previousTextureSize) {
-                    shouldReset = false;
+            if (previousTextureParameters?.dataType === dataType) {
+                if (previousTextureParameters?.width === dims[0]) {
+                    if (previousTextureParameters?.height === dims[1]) {
+                        if (previousTextureParameters?.depth === dims[2]) {
+                            shouldReset = false;
+                        }
+                    }
                 }
             }
             if (shouldReset) {
-                model.scalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
-                model.scalarTexture.releaseGraphicsResources(model._openGLRenderWindow);
+                const norm16Ext = model.context.getExtension('EXT_texture_norm16');
+                model.scalarTexture.setOglNorm16Ext(norm16Ext);
                 model.scalarTexture.resetFormatAndType();
-                model.scalarTexture.create3DFilterableFromRaw(dims[0], dims[1], dims[2], numComp, scalars.getDataType(), scalars.getData(), model.renderable.getPreferSizeOverAccuracy());
+                model.scalarTexture.setTextureParameters({
+                    width: dims[0],
+                    height: dims[1],
+                    depth: dims[2],
+                    numberOfComponents: numIComps,
+                    dataType,
+                });
+                model.scalarTexture.create3DFromRaw(dims[0], dims[1], dims[2], numIComps, dataType, null);
+                model.scalarTexture.update3DFromRaw();
             }
             else {
                 model.scalarTexture.deactivate();
-                model.scalarTexture.update3DFromRaw(data);
+                model.scalarTexture.update3DFromRaw();
             }
             model.scalarTextureString = toString;
         }
@@ -146,16 +181,22 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
         }
         model.VBOBuildTime.modified();
     };
-    publicAPI.getRenderTargetSize = () => {
-        if (model._useSmallViewport) {
-            return [model._smallViewportWidth, model._smallViewportHeight];
+    publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => {
+        if (model.VBOBuildTime.getMTime() < publicAPI.getMTime() ||
+            model.VBOBuildTime.getMTime() < actor.getMTime() ||
+            model.VBOBuildTime.getMTime() < model.renderable.getMTime() ||
+            model.VBOBuildTime.getMTime() < actor.getProperty().getMTime() ||
+            model.VBOBuildTime.getMTime() < model.currentInput.getMTime() ||
+            model.VBOBuildTime.getMTime() < model.scalarTexture?.getMTime() ||
+            model.VBOBuildTime.getMTime() < model.colorTexture?.getMTime() ||
+            model.VBOBuildTime.getMTime() <
+                model.labelOutlineThicknessTexture?.getMTime() ||
+            !model.scalarTexture?.getHandle() ||
+            !model.colorTexture?.getHandle() ||
+            !model.labelOutlineThicknessTexture?.getHandle()) {
+            return true;
         }
-        const { usize, vsize } = model._openGLRenderer.getTiledSizeAndOrigin();
-        return [usize, vsize];
-    };
-    publicAPI.getRenderTargetOffset = () => {
-        const { lowerLeftU, lowerLeftV } = model._openGLRenderer.getTiledSizeAndOrigin();
-        return [lowerLeftU, lowerLeftV];
+        return false;
     };
 }
 const DEFAULT_VALUES = {};

package/dist/esm/Settings.d.ts

@@ -8,7 +8,7 @@ export default class Settings {
     import(root: Record<string, unknown>): void;
     dump(): Record<string, unknown>;
     static assert(subject: Settings): Settings;
-    static getDefaultSettings(subfield?: any): Settings | any;
+    static getDefaultSettings(subfield?: any): Settings | unknown;
     static getRuntimeSettings(): Settings;
     static getObjectSettings(subject: unknown, from?: unknown): Settings;
     static extendRuntimeSettings(): Settings;

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;