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

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

@@ -1,28 +1,61 @@
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import isTypedArray from '../../utilities/isTypedArray';
-import { imageIdToURI } from '../../utilities';
+import { genericMetadataProvider, getMinMax, imageIdToURI, } from '../../utilities';
 import { vtkStreamingOpenGLTexture } from '../../RenderingEngine/vtkClasses';
+import cache from '../cache';
+import * as metaData from '../../metaData';
 export class ImageVolume {
     constructor(props) {
         this._imageIdsIndexMap = new Map();
         this._imageURIsIndexMap = new Map();
+        this.cornerstoneImageMetaData = null;
+        this.imageCacheOffsetMap = new Map();
         this.isPreScaled = false;
-        this.volumeId = props.volumeId;
-        this.metadata = props.metadata;
-        this.dimensions = props.dimensions;
-        this.spacing = props.spacing;
-        this.origin = props.origin;
-        this.direction = props.direction;
-        this.imageData = props.imageData;
-        this.scalarData = props.scalarData;
-        this.sizeInBytes = props.sizeInBytes;
+        const { imageIds, scalarData, scaling, dimensions, spacing, origin, direction, volumeId, referencedVolumeId, sizeInBytes, imageData, metadata, referencedImageIds, additionalDetails, } = props;
+        this.imageIds = imageIds;
+        this.volumeId = volumeId;
+        this.metadata = metadata;
+        this.dimensions = dimensions;
+        this.spacing = spacing;
+        this.origin = origin;
+        this.direction = direction;
+        this.scalarData = scalarData;
+        this.sizeInBytes = sizeInBytes;
         this.vtkOpenGLTexture = vtkStreamingOpenGLTexture.newInstance();
         this.numVoxels =
             this.dimensions[0] * this.dimensions[1] * this.dimensions[2];
-        if (props.scaling) {
-            this.scaling = props.scaling;
+        if (imageData) {
+            this.imageData = imageData;
         }
-        if (props.referencedVolumeId) {
-            this.referencedVolumeId = props.referencedVolumeId;
+        else {
+            const imageData = vtkImageData.newInstance();
+            const scalarArray = vtkDataArray.newInstance({
+                name: 'Pixels',
+                numberOfComponents: 1,
+                values: scalarData,
+            });
+            imageData.setDimensions(dimensions);
+            imageData.setSpacing(spacing);
+            imageData.setDirection(direction);
+            imageData.setOrigin(origin);
+            imageData.getPointData().setScalars(scalarArray);
+            this.imageData = imageData;
+        }
+        this.numFrames = this._getNumFrames();
+        this._reprocessImageIds();
+        this._createCornerstoneImageMetaData();
+        if (scaling) {
+            this.scaling = scaling;
+        }
+        if (referencedVolumeId) {
+            this.referencedVolumeId = referencedVolumeId;
+        }
+        if (referencedImageIds) {
+            this.referencedImageIds = referencedImageIds;
+        }
+        if (additionalDetails) {
+            this.additionalDetails = additionalDetails;
         }
     }
     get imageIds() {
@@ -48,7 +81,7 @@ export class ImageVolume {
         if (isTypedArray(this.scalarData)) {
             return this.scalarData;
         }
-        throw new Error('Unknow scalar data type');
+        throw new Error('Unknown scalar data type');
     }
     getImageIdIndex(imageId) {
         return this._imageIdsIndexMap.get(imageId);
@@ -63,6 +96,250 @@ export class ImageVolume {
         this.vtkOpenGLTexture.releaseGraphicsResources();
         this.vtkOpenGLTexture.delete();
     }
+    getScalarDataArrays() {
+        return this.isDynamicVolume()
+            ? this.scalarData
+            : [this.scalarData];
+    }
+    modified() {
+        this.imageData.modified();
+        if (this.isDynamicVolume()) {
+            throw new Error('Not implemented');
+        }
+        else {
+            this.scalarData = this.imageData
+                .getPointData()
+                .getScalars()
+                .getData();
+        }
+        this.numFrames = this._getNumFrames();
+    }
+    decache(completelyRemove = false) {
+        if (completelyRemove) {
+            this.removeFromCache();
+        }
+        else {
+            this.convertToImageSlicesAndCache();
+            const otherVolumes = cache.filterVolumesByReferenceId(this.volumeId);
+            if (otherVolumes.length) {
+                otherVolumes.forEach((volume) => {
+                    volume.referencedImageIds = this.imageIds;
+                });
+            }
+            if (completelyRemove) {
+                this.removeFromCache();
+            }
+        }
+    }
+    removeFromCache() {
+        cache.removeVolumeLoadObject(this.volumeId);
+    }
+    getScalarDataLength() {
+        const { scalarData } = this;
+        return this.isDynamicVolume()
+            ? scalarData[0].length
+            : scalarData.length;
+    }
+    _getNumFrames() {
+        const { imageIds, scalarData } = this;
+        const scalarDataCount = this.isDynamicVolume() ? scalarData.length : 1;
+        return imageIds.length / scalarDataCount;
+    }
+    _getScalarDataLength() {
+        const { scalarData } = this;
+        return this.isDynamicVolume()
+            ? scalarData[0].length
+            : scalarData.length;
+    }
+    _createCornerstoneImageMetaData() {
+        const { numFrames } = this;
+        if (numFrames === 0) {
+            return;
+        }
+        const bytesPerImage = this.sizeInBytes / numFrames;
+        const scalarDataLength = this._getScalarDataLength();
+        const numComponents = scalarDataLength / this.numVoxels;
+        const pixelsPerImage = this.dimensions[0] * this.dimensions[1] * numComponents;
+        const { PhotometricInterpretation, voiLut, VOILUTFunction } = this.metadata;
+        let windowCenter = [];
+        let windowWidth = [];
+        if (voiLut && voiLut.length) {
+            windowCenter = voiLut.map((voi) => {
+                return voi.windowCenter;
+            });
+            windowWidth = voiLut.map((voi) => {
+                return voi.windowWidth;
+            });
+        }
+        const color = numComponents > 1 ? true : false;
+        this.cornerstoneImageMetaData = {
+            bytesPerImage,
+            numComponents,
+            pixelsPerImage,
+            windowCenter,
+            windowWidth,
+            color,
+            rgba: false,
+            spacing: this.spacing,
+            dimensions: this.dimensions,
+            photometricInterpretation: PhotometricInterpretation,
+            voiLUTFunction: VOILUTFunction,
+            invert: PhotometricInterpretation === 'MONOCHROME1',
+        };
+    }
+    getScalarDataByImageIdIndex(imageIdIndex) {
+        if (imageIdIndex < 0 || imageIdIndex >= this.imageIds.length) {
+            throw new Error('imageIdIndex out of range');
+        }
+        const scalarDataArrays = this.getScalarDataArrays();
+        const scalarDataIndex = Math.floor(imageIdIndex / this.numFrames);
+        return scalarDataArrays[scalarDataIndex];
+    }
+    getCornerstoneImage(imageId, imageIdIndex) {
+        const { imageIds } = this;
+        const frameIndex = this.imageIdIndexToFrameIndex(imageIdIndex);
+        const { bytesPerImage, pixelsPerImage, windowCenter, windowWidth, numComponents, color, dimensions, spacing, invert, voiLUTFunction, photometricInterpretation, } = this.cornerstoneImageMetaData;
+        const scalarData = this.getScalarDataByImageIdIndex(imageIdIndex);
+        const volumeBuffer = scalarData.buffer;
+        const TypedArray = scalarData.constructor;
+        const bytePerPixel = bytesPerImage / pixelsPerImage;
+        let byteOffset = bytesPerImage * frameIndex;
+        if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
+            byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
+        }
+        const imageScalarData = new TypedArray(pixelsPerImage);
+        const volumeBufferView = new TypedArray(volumeBuffer, byteOffset, pixelsPerImage);
+        imageScalarData.set(volumeBufferView);
+        const volumeImageId = imageIds[imageIdIndex];
+        const modalityLutModule = metaData.get('modalityLutModule', volumeImageId) || {};
+        const minMax = getMinMax(imageScalarData);
+        const intercept = modalityLutModule.rescaleIntercept
+            ? modalityLutModule.rescaleIntercept
+            : 0;
+        const imageOrientationPatient = [
+            this.direction[0],
+            this.direction[1],
+            this.direction[2],
+            this.direction[3],
+            this.direction[4],
+            this.direction[5],
+        ];
+        const precision = 6;
+        const imagePositionPatient = [
+            parseFloat((this.origin[0] +
+                imageIdIndex * this.direction[6] * this.spacing[0]).toFixed(precision)),
+            parseFloat((this.origin[1] +
+                imageIdIndex * this.direction[7] * this.spacing[1]).toFixed(precision)),
+            parseFloat((this.origin[2] +
+                imageIdIndex * this.direction[8] * this.spacing[2]).toFixed(precision)),
+        ];
+        const image = {
+            imageId,
+            intercept,
+            windowCenter,
+            windowWidth,
+            voiLUTFunction,
+            color,
+            rgba: false,
+            numComps: numComponents,
+            rows: dimensions[1],
+            columns: dimensions[0],
+            sizeInBytes: imageScalarData.byteLength,
+            getPixelData: () => imageScalarData,
+            minPixelValue: minMax.min,
+            maxPixelValue: minMax.max,
+            slope: modalityLutModule.rescaleSlope
+                ? modalityLutModule.rescaleSlope
+                : 1,
+            getCanvas: undefined,
+            height: dimensions[0],
+            width: dimensions[1],
+            columnPixelSpacing: spacing[0],
+            rowPixelSpacing: spacing[1],
+            invert,
+            photometricInterpretation,
+        };
+        const pixelData = image.getPixelData();
+        const bitsAllocated = pixelData.BYTES_PER_ELEMENT * 8;
+        const imagePixelModule = {
+            bitsAllocated,
+            photometricInterpretation: image.photometricInterpretation,
+            windowWidth: image.windowWidth,
+            windowCenter: image.windowCenter,
+            voiLUTFunction: image.voiLUTFunction,
+        };
+        const imagePlaneModule = {
+            rowCosines: [this.direction[0], this.direction[1], this.direction[2]],
+            columnCosines: [this.direction[3], this.direction[4], this.direction[5]],
+            pixelSpacing: [this.spacing[0], this.spacing[1]],
+            imageOrientationPatient: imageOrientationPatient,
+            imagePositionPatient: imagePositionPatient,
+            columnPixelSpacing: image.columnPixelSpacing,
+            rowPixelSpacing: image.rowPixelSpacing,
+            columns: image.columns,
+            rows: image.rows,
+        };
+        const generalSeriesModule = {};
+        const metadata = {
+            imagePixelModule,
+            imagePlaneModule,
+            generalSeriesModule,
+        };
+        ['imagePixelModule', 'imagePlaneModule', 'generalSeriesModule'].forEach((type) => {
+            genericMetadataProvider.add(imageId, {
+                type,
+                metadata: metadata[type],
+            });
+        });
+        return image;
+    }
+    imageIdIndexToFrameIndex(imageIdIndex) {
+        return imageIdIndex % this.numFrames;
+    }
+    getCornerstoneImageLoadObject(imageId, imageIdIndex) {
+        const image = this.getCornerstoneImage(imageId, imageIdIndex);
+        const imageLoadObject = {
+            promise: Promise.resolve(image),
+        };
+        return imageLoadObject;
+    }
+    getCornerstoneImages() {
+        const { imageIds } = this;
+        return imageIds.map((imageId, imageIdIndex) => {
+            return this.getCornerstoneImage(imageId, imageIdIndex);
+        });
+    }
+    convertToImageSlicesAndCache() {
+        const byteLength = this.sizeInBytes;
+        if (!this.imageIds?.length) {
+            const referencedVolumeId = this.referencedVolumeId;
+            let numSlices = this.dimensions[2];
+            if (referencedVolumeId) {
+                const referencedVolume = cache.getVolume(referencedVolumeId);
+                numSlices = referencedVolume?.imageIds?.length ?? numSlices;
+            }
+            this.imageIds = Array.from({ length: numSlices }, (_, i) => {
+                return `generated:${this.volumeId}:${i}`;
+            });
+            this._reprocessImageIds();
+            this.numFrames = this._getNumFrames();
+            this._createCornerstoneImageMetaData();
+        }
+        const numImages = this.imageIds.length;
+        const { bytesPerImage } = this.cornerstoneImageMetaData;
+        let bytesRemaining = cache.decacheIfNecessaryUntilBytesAvailable(byteLength, this.imageIds);
+        for (let imageIdIndex = 0; imageIdIndex < numImages; imageIdIndex++) {
+            const imageId = this.imageIds[imageIdIndex];
+            bytesRemaining = bytesRemaining - bytesPerImage;
+            const image = this.getCornerstoneImage(imageId, imageIdIndex);
+            if (!cache.getImageLoadObject(imageId)) {
+                cache.putImageSync(imageId, image);
+            }
+            if (bytesRemaining <= bytesPerImage) {
+                break;
+            }
+        }
+        return this.imageIds;
+    }
 }
 export default ImageVolume;
-//# sourceMappingURL=ImageVolume.js.map

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

@@ -0,0 +1,25 @@
+import { SurfaceData, Point3, ISurface, RGB } from '../../types';
+type SurfaceProps = {
+    id: string;
+    data: SurfaceData;
+    frameOfReferenceUID: string;
+    color?: Point3;
+};
+export declare class Surface implements ISurface {
+    readonly id: string;
+    readonly sizeInBytes: number;
+    readonly frameOfReferenceUID: string;
+    private color;
+    private points;
+    private polys;
+    constructor(props: SurfaceProps);
+    _getSizeInBytes(): number;
+    getColor(): RGB;
+    getPoints(): number[];
+    getPolys(): number[];
+    setColor(color: RGB): void;
+    setPoints(points: number[]): void;
+    setPolys(polys: number[]): void;
+    getSizeInBytes(): number;
+}
+export {};

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

@@ -0,0 +1,35 @@
+export class Surface {
+    constructor(props) {
+        this.color = [200, 0, 0];
+        this.id = props.id;
+        this.points = props.data.points;
+        this.polys = props.data.polys;
+        this.color = props.color ?? this.color;
+        this.frameOfReferenceUID = props.frameOfReferenceUID;
+        this.sizeInBytes = this._getSizeInBytes();
+    }
+    _getSizeInBytes() {
+        return this.points.length * 4 + this.polys.length * 4;
+    }
+    getColor() {
+        return this.color;
+    }
+    getPoints() {
+        return this.points;
+    }
+    getPolys() {
+        return this.polys;
+    }
+    setColor(color) {
+        this.color = color;
+    }
+    setPoints(points) {
+        this.points = points;
+    }
+    setPolys(polys) {
+        this.polys = polys;
+    }
+    getSizeInBytes() {
+        return this.sizeInBytes;
+    }
+}

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

@@ -1,4 +1,5 @@
 import cache, { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
-export { ImageVolume, Cache };
+import { Surface } from './classes/Surface';
+export { ImageVolume, Cache, Surface };
 export default cache;

package/dist/esm/cache/index.js

@@ -1,5 +1,5 @@
 import cache, { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
-export { ImageVolume, Cache };
+import { Surface } from './classes/Surface';
+export { ImageVolume, Cache, Surface };
 export default cache;
-//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,2 @@
+import { IImageVolume } from '../../types';
+export declare function restoreImagesFromBuffer(volume: IImageVolume): void;

package/dist/esm/cache/utils/restoreImagesFromBuffer.js

@@ -0,0 +1,28 @@
+import cache from '../cache';
+export function restoreImagesFromBuffer(volume) {
+    if (!volume.getScalarData) {
+        return;
+    }
+    const scalarData = volume.getScalarData();
+    const imageCacheOffsetMap = volume.imageCacheOffsetMap;
+    if (imageCacheOffsetMap.size === 0) {
+        return;
+    }
+    for (const [imageId, { offset }] of imageCacheOffsetMap) {
+        const image = cache.getImage(imageId);
+        if (!image) {
+            console.warn(`Image with id ${imageId} not found in cache.`);
+            continue;
+        }
+        const viewPixelData = image.getPixelData();
+        const length = viewPixelData.length;
+        const pixelData = new viewPixelData.constructor(scalarData.buffer, offset, length);
+        image.getPixelData = () => pixelData;
+        if (image.imageFrame) {
+            image.imageFrame.pixelData = pixelData;
+        }
+        delete image.bufferView;
+        cache.incrementImageCacheSize(image.sizeInBytes);
+    }
+    console.log(`Images restored from buffer for volume ${volume.volumeId}.`);
+}

package/dist/esm/constants/backgroundColors.d.ts

@@ -0,0 +1,4 @@
+declare const backgroundColors: {
+    slicer3D: number[];
+};
+export default backgroundColors;

package/dist/esm/constants/backgroundColors.js

@@ -0,0 +1,4 @@
+const backgroundColors = {
+    slicer3D: [160 / 255, 164 / 255, 217 / 255],
+};
+export default backgroundColors;

package/dist/esm/constants/cpuColormaps.js

@@ -1523,4 +1523,3 @@ const colormapsData = {
     },
 };
 export default colormapsData;
-//# sourceMappingURL=cpuColormaps.js.map

package/dist/esm/constants/epsilon.js

@@ -1,3 +1,2 @@
 const EPSILON = 1e-3;
 export default EPSILON;
-//# sourceMappingURL=epsilon.js.map

package/dist/esm/constants/index.d.ts

@@ -3,4 +3,5 @@ import RENDERING_DEFAULTS from './rendering';
 import EPSILON from './epsilon';
 import MPR_CAMERA_VALUES from './mprCameraValues';
 import VIEWPORT_PRESETS from './viewportPresets';
-export { CPU_COLORMAPS, RENDERING_DEFAULTS, MPR_CAMERA_VALUES, EPSILON, VIEWPORT_PRESETS, };
+import BACKGROUND_COLORS from './backgroundColors';
+export { CPU_COLORMAPS, RENDERING_DEFAULTS, MPR_CAMERA_VALUES, EPSILON, VIEWPORT_PRESETS, BACKGROUND_COLORS, };

package/dist/esm/constants/index.js

@@ -3,5 +3,5 @@ import RENDERING_DEFAULTS from './rendering';
 import EPSILON from './epsilon';
 import MPR_CAMERA_VALUES from './mprCameraValues';
 import VIEWPORT_PRESETS from './viewportPresets';
-export { CPU_COLORMAPS, RENDERING_DEFAULTS, MPR_CAMERA_VALUES, EPSILON, VIEWPORT_PRESETS, };
-//# sourceMappingURL=index.js.map
+import BACKGROUND_COLORS from './backgroundColors';
+export { CPU_COLORMAPS, RENDERING_DEFAULTS, MPR_CAMERA_VALUES, EPSILON, VIEWPORT_PRESETS, BACKGROUND_COLORS, };

package/dist/esm/constants/mprCameraValues.js

@@ -15,4 +15,3 @@ const MPR_CAMERA_VALUES = {
 };
 const mprCameraValues = deepFreeze(MPR_CAMERA_VALUES);
 export default mprCameraValues;
-//# sourceMappingURL=mprCameraValues.js.map

package/dist/esm/constants/rendering.js

@@ -4,4 +4,3 @@ const RENDERING_DEFAULTS = {
 };
 Object.freeze(RENDERING_DEFAULTS);
 export default RENDERING_DEFAULTS;
-//# sourceMappingURL=rendering.js.map

package/dist/esm/constants/viewportPresets.js

@@ -313,4 +313,3 @@ const presets = [
     },
 ];
 export default presets;
-//# sourceMappingURL=viewportPresets.js.map

package/dist/esm/enums/BlendModes.d.ts

@@ -1,7 +1,7 @@
 declare enum BlendModes {
-    COMPOSITE = 0,
-    MAXIMUM_INTENSITY_BLEND = 1,
-    MINIMUM_INTENSITY_BLEND = 2,
-    AVERAGE_INTENSITY_BLEND = 3
+    COMPOSITE,
+    MAXIMUM_INTENSITY_BLEND,
+    MINIMUM_INTENSITY_BLEND,
+    AVERAGE_INTENSITY_BLEND
 }
 export default BlendModes;

package/dist/esm/enums/BlendModes.js

@@ -2,10 +2,9 @@ import vtkConstants from '@kitware/vtk.js/Rendering/Core/VolumeMapper/Constants'
 const { BlendMode } = vtkConstants;
 var BlendModes;
 (function (BlendModes) {
-    BlendModes[BlendModes["COMPOSITE"] = 0] = "COMPOSITE";
-    BlendModes[BlendModes["MAXIMUM_INTENSITY_BLEND"] = 1] = "MAXIMUM_INTENSITY_BLEND";
-    BlendModes[BlendModes["MINIMUM_INTENSITY_BLEND"] = 2] = "MINIMUM_INTENSITY_BLEND";
-    BlendModes[BlendModes["AVERAGE_INTENSITY_BLEND"] = 3] = "AVERAGE_INTENSITY_BLEND";
+    BlendModes[BlendModes["COMPOSITE"] = BlendMode.COMPOSITE_BLEND] = "COMPOSITE";
+    BlendModes[BlendModes["MAXIMUM_INTENSITY_BLEND"] = BlendMode.MAXIMUM_INTENSITY_BLEND] = "MAXIMUM_INTENSITY_BLEND";
+    BlendModes[BlendModes["MINIMUM_INTENSITY_BLEND"] = BlendMode.MINIMUM_INTENSITY_BLEND] = "MINIMUM_INTENSITY_BLEND";
+    BlendModes[BlendModes["AVERAGE_INTENSITY_BLEND"] = BlendMode.AVERAGE_INTENSITY_BLEND] = "AVERAGE_INTENSITY_BLEND";
 })(BlendModes || (BlendModes = {}));
 export default BlendModes;
-//# sourceMappingURL=BlendModes.js.map

package/dist/esm/enums/CalibrationTypes.js

@@ -9,4 +9,3 @@ export var CalibrationTypes;
     CalibrationTypes["UNCALIBRATED"] = "Uncalibrated";
 })(CalibrationTypes || (CalibrationTypes = {}));
 export default CalibrationTypes;
-//# sourceMappingURL=CalibrationTypes.js.map

package/dist/esm/enums/ContourType.js

@@ -4,4 +4,3 @@ var ContourType;
     ContourType["OPEN_PLANAR"] = "OPEN_PLANAR";
 })(ContourType || (ContourType = {}));
 export default ContourType;
-//# sourceMappingURL=ContourType.js.map

package/dist/esm/enums/DynamicOperatorType.js

@@ -5,4 +5,3 @@ var DynamicOperatorType;
     DynamicOperatorType["SUBTRACT"] = "SUBTRACT";
 })(DynamicOperatorType || (DynamicOperatorType = {}));
 export default DynamicOperatorType;
-//# sourceMappingURL=DynamicOperatorType.js.map

package/dist/esm/enums/Events.d.ts

@@ -1,9 +1,11 @@
 declare enum Events {
+    ERROR_EVENT = "CORNERSTONE_ERROR",
     CACHE_SIZE_EXCEEDED = "CACHE_SIZE_EXCEEDED",
     IMAGE_LOAD_ERROR = "IMAGE_LOAD_ERROR",
     CAMERA_MODIFIED = "CORNERSTONE_CAMERA_MODIFIED",
     CAMERA_RESET = "CORNERSTONE_CAMERA_RESET",
     VOI_MODIFIED = "CORNERSTONE_VOI_MODIFIED",
+    PRESET_MODIFIED = "CORNERSTONE_VIEWPORT_RENDERING_PRESET_MODIFIED",
     DISPLAY_AREA_MODIFIED = "CORNERSTONE_DISPLAY_AREA_MODIFIED",
     ELEMENT_DISABLED = "CORNERSTONE_ELEMENT_DISABLED",
     ELEMENT_ENABLED = "CORNERSTONE_ELEMENT_ENABLED",
@@ -11,6 +13,7 @@ declare enum Events {
     IMAGE_VOLUME_MODIFIED = "CORNERSTONE_IMAGE_VOLUME_MODIFIED",
     IMAGE_VOLUME_LOADING_COMPLETED = "CORNERSTONE_IMAGE_VOLUME_LOADING_COMPLETED",
     IMAGE_LOADED = "CORNERSTONE_IMAGE_LOADED",
+    IMAGE_RETRIEVAL_STAGE = "CORNERSTONE_IMAGE_RETRIEVAL_STAGE",
     IMAGE_LOAD_FAILED = "CORNERSTONE_IMAGE_LOAD_FAILED",
     VOLUME_VIEWPORT_NEW_VOLUME = "CORNERSTONE_VOLUME_VIEWPORT_NEW_VOLUME",
     VOLUME_LOADED = "CORNERSTONE_VOLUME_LOADED",
@@ -23,10 +26,13 @@ declare enum Events {
     VOLUME_NEW_IMAGE = "CORNERSTONE_VOLUME_NEW_IMAGE",
     PRE_STACK_NEW_IMAGE = "CORNERSTONE_PRE_STACK_NEW_IMAGE",
     IMAGE_SPACING_CALIBRATED = "CORNERSTONE_IMAGE_SPACING_CALIBRATED",
-    IMAGE_LOAD_PROGRESS = "CORNERSTONE_IMAGE_LOAD_PROGRESS",
     STACK_VIEWPORT_NEW_STACK = "CORNERSTONE_STACK_VIEWPORT_NEW_STACK",
     STACK_VIEWPORT_SCROLL = "CORNERSTONE_STACK_VIEWPORT_SCROLL",
     GEOMETRY_CACHE_GEOMETRY_ADDED = "CORNERSTONE_GEOMETRY_CACHE_GEOMETRY_ADDED",
-    VOLUME_SCROLL_OUT_OF_BOUNDS = "CORNERSTONE_VOLUME_SCROLL_OUT_OF_BOUNDS"
+    VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS = "VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS",
+    VOLUME_VIEWPORT_SCROLL = "VOLUME_VIEWPORT_SCROLL",
+    CLIPPING_PLANES_UPDATED = "CORNERSTONE_CLIPPING_PLANES_UPDATED",
+    WEB_WORKER_PROGRESS = "CORNERSTONE_WEB_WORKER_PROGRESS",
+    COLORMAP_MODIFIED = "CORNERSTONE_COLORMAP_MODIFIED"
 }
 export default Events;

package/dist/esm/enums/Events.js

@@ -1,10 +1,12 @@
 var Events;
 (function (Events) {
+    Events["ERROR_EVENT"] = "CORNERSTONE_ERROR";
     Events["CACHE_SIZE_EXCEEDED"] = "CACHE_SIZE_EXCEEDED";
     Events["IMAGE_LOAD_ERROR"] = "IMAGE_LOAD_ERROR";
     Events["CAMERA_MODIFIED"] = "CORNERSTONE_CAMERA_MODIFIED";
     Events["CAMERA_RESET"] = "CORNERSTONE_CAMERA_RESET";
     Events["VOI_MODIFIED"] = "CORNERSTONE_VOI_MODIFIED";
+    Events["PRESET_MODIFIED"] = "CORNERSTONE_VIEWPORT_RENDERING_PRESET_MODIFIED";
     Events["DISPLAY_AREA_MODIFIED"] = "CORNERSTONE_DISPLAY_AREA_MODIFIED";
     Events["ELEMENT_DISABLED"] = "CORNERSTONE_ELEMENT_DISABLED";
     Events["ELEMENT_ENABLED"] = "CORNERSTONE_ELEMENT_ENABLED";
@@ -12,6 +14,7 @@ var Events;
     Events["IMAGE_VOLUME_MODIFIED"] = "CORNERSTONE_IMAGE_VOLUME_MODIFIED";
     Events["IMAGE_VOLUME_LOADING_COMPLETED"] = "CORNERSTONE_IMAGE_VOLUME_LOADING_COMPLETED";
     Events["IMAGE_LOADED"] = "CORNERSTONE_IMAGE_LOADED";
+    Events["IMAGE_RETRIEVAL_STAGE"] = "CORNERSTONE_IMAGE_RETRIEVAL_STAGE";
     Events["IMAGE_LOAD_FAILED"] = "CORNERSTONE_IMAGE_LOAD_FAILED";
     Events["VOLUME_VIEWPORT_NEW_VOLUME"] = "CORNERSTONE_VOLUME_VIEWPORT_NEW_VOLUME";
     Events["VOLUME_LOADED"] = "CORNERSTONE_VOLUME_LOADED";
@@ -24,11 +27,13 @@ var Events;
     Events["VOLUME_NEW_IMAGE"] = "CORNERSTONE_VOLUME_NEW_IMAGE";
     Events["PRE_STACK_NEW_IMAGE"] = "CORNERSTONE_PRE_STACK_NEW_IMAGE";
     Events["IMAGE_SPACING_CALIBRATED"] = "CORNERSTONE_IMAGE_SPACING_CALIBRATED";
-    Events["IMAGE_LOAD_PROGRESS"] = "CORNERSTONE_IMAGE_LOAD_PROGRESS";
     Events["STACK_VIEWPORT_NEW_STACK"] = "CORNERSTONE_STACK_VIEWPORT_NEW_STACK";
     Events["STACK_VIEWPORT_SCROLL"] = "CORNERSTONE_STACK_VIEWPORT_SCROLL";
     Events["GEOMETRY_CACHE_GEOMETRY_ADDED"] = "CORNERSTONE_GEOMETRY_CACHE_GEOMETRY_ADDED";
-    Events["VOLUME_SCROLL_OUT_OF_BOUNDS"] = "CORNERSTONE_VOLUME_SCROLL_OUT_OF_BOUNDS";
+    Events["VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS"] = "VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS";
+    Events["VOLUME_VIEWPORT_SCROLL"] = "VOLUME_VIEWPORT_SCROLL";
+    Events["CLIPPING_PLANES_UPDATED"] = "CORNERSTONE_CLIPPING_PLANES_UPDATED";
+    Events["WEB_WORKER_PROGRESS"] = "CORNERSTONE_WEB_WORKER_PROGRESS";
+    Events["COLORMAP_MODIFIED"] = "CORNERSTONE_COLORMAP_MODIFIED";
 })(Events || (Events = {}));
 export default Events;
-//# sourceMappingURL=Events.js.map

package/dist/esm/enums/GeometryType.d.ts

@@ -1,4 +1,5 @@
 declare enum GeometryType {
-    CONTOUR = "contour"
+    CONTOUR = "contour",
+    SURFACE = "Surface"
 }
 export default GeometryType;

package/dist/esm/enums/GeometryType.js

@@ -1,6 +1,6 @@
 var GeometryType;
 (function (GeometryType) {
     GeometryType["CONTOUR"] = "contour";
+    GeometryType["SURFACE"] = "Surface";
 })(GeometryType || (GeometryType = {}));
 export default GeometryType;
-//# sourceMappingURL=GeometryType.js.map

package/dist/esm/enums/ImageQualityStatus.d.ts

@@ -0,0 +1,8 @@
+declare enum ImageQualityStatus {
+    FAR_REPLICATE = 1,
+    ADJACENT_REPLICATE = 3,
+    SUBRESOLUTION = 6,
+    LOSSY = 7,
+    FULL_RESOLUTION = 8
+}
+export default ImageQualityStatus;