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

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

@@ -1,18 +1,20 @@
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import isTypedArray from '../../utilities/isTypedArray';
-import { genericMetadataProvider, getMinMax, imageIdToURI, } from '../../utilities';
+import imageIdToURI from '../../utilities/imageIdToURI';
+import VoxelManager from '../../utilities/VoxelManager';
 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;
-        const { imageIds, scalarData, scaling, dimensions, spacing, origin, direction, volumeId, referencedVolumeId, sizeInBytes, imageData, metadata, referencedImageIds, additionalDetails, } = props;
+        this.numTimePoints = null;
+        const { imageIds, scaling, dimensions, spacing, origin, direction, dataType, volumeId, referencedVolumeId, metadata, referencedImageIds, additionalDetails, voxelManager, numberOfComponents, } = props;
+        if (!dataType) {
+            throw new Error('Data type is required, please provide a data type as string such as "Uint8Array", "Float32Array", etc.');
+        }
+        let { imageData } = props;
         this.imageIds = imageIds;
         this.volumeId = volumeId;
         this.metadata = metadata;
@@ -20,31 +22,37 @@ export class ImageVolume {
         this.spacing = spacing;
         this.origin = origin;
         this.direction = direction;
-        this.scalarData = scalarData;
-        this.sizeInBytes = sizeInBytes;
+        this.dataType = dataType;
         this.vtkOpenGLTexture = vtkStreamingOpenGLTexture.newInstance();
+        this.vtkOpenGLTexture.setVolumeId(volumeId);
+        this.voxelManager =
+            voxelManager ??
+                VoxelManager.createImageVolumeVoxelManager({
+                    dimensions,
+                    imageIds,
+                    numberOfComponents,
+                });
         this.numVoxels =
             this.dimensions[0] * this.dimensions[1] * this.dimensions[2];
-        if (imageData) {
-            this.imageData = imageData;
-        }
-        else {
-            const imageData = vtkImageData.newInstance();
-            const scalarArray = vtkDataArray.newInstance({
-                name: 'Pixels',
-                numberOfComponents: 1,
-                values: scalarData,
-            });
+        if (!imageData) {
+            imageData = vtkImageData.newInstance();
             imageData.setDimensions(dimensions);
             imageData.setSpacing(spacing);
             imageData.setDirection(direction);
             imageData.setOrigin(origin);
-            imageData.getPointData().setScalars(scalarArray);
-            this.imageData = imageData;
         }
+        imageData.set({
+            dataType: dataType,
+            voxelManager: this.voxelManager,
+            id: volumeId,
+            numberOfComponents: numberOfComponents || 1,
+        });
+        imageData.set({
+            hasScalarVolume: false,
+        });
+        this.imageData = imageData;
         this.numFrames = this._getNumFrames();
         this._reprocessImageIds();
-        this._createCornerstoneImageMetaData();
         if (scaling) {
             this.scaling = scaling;
         }
@@ -58,6 +66,9 @@ export class ImageVolume {
             this.additionalDetails = additionalDetails;
         }
     }
+    get sizeInBytes() {
+        return this.voxelManager.sizeInBytes;
+    }
     get imageIds() {
         return this._imageIds;
     }
@@ -75,271 +86,55 @@ export class ImageVolume {
         });
     }
     isDynamicVolume() {
-        return false;
-    }
-    getScalarData() {
-        if (isTypedArray(this.scalarData)) {
-            return this.scalarData;
-        }
-        throw new Error('Unknown scalar data type');
+        return this.numTimePoints > 1;
     }
     getImageIdIndex(imageId) {
         return this._imageIdsIndexMap.get(imageId);
     }
+    getImageIdByIndex(imageIdIndex) {
+        return this._imageIds[imageIdIndex];
+    }
     getImageURIIndex(imageURI) {
         return this._imageURIsIndexMap.get(imageURI);
     }
     destroy() {
         this.imageData.delete();
         this.imageData = null;
-        this.scalarData = null;
+        this.voxelManager.clear();
         this.vtkOpenGLTexture.releaseGraphicsResources();
         this.vtkOpenGLTexture.delete();
     }
-    getScalarDataArrays() {
-        return this.isDynamicVolume()
-            ? this.scalarData
-            : [this.scalarData];
+    invalidate() {
+        for (let i = 0; i < this.imageIds.length; i++) {
+            this.vtkOpenGLTexture.setUpdatedFrame(i);
+        }
+        this.imageData.modified();
     }
     modified() {
         this.imageData.modified();
-        if (this.isDynamicVolume()) {
-            throw new Error('Not implemented');
-        }
-        else {
-            this.scalarData = this.imageData
-                .getPointData()
-                .getScalars()
-                .getData();
-        }
+        this.vtkOpenGLTexture.modified();
         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;
+        return this.voxelManager.getScalarDataLength();
     }
     _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;
+        if (!this.isDynamicVolume()) {
+            return this.imageIds.length;
         }
-        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;
+        return this.numTimePoints;
     }
     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);
+        return imageIds.map((imageId) => {
+            return cache.getImage(imageId);
         });
     }
-    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;

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

@@ -1,10 +1,10 @@
-import { SurfaceData, Point3, ISurface, RGB } from '../../types';
-type SurfaceProps = {
+import type { SurfaceData, Point3, ISurface, RGB } from '../../types';
+interface SurfaceProps {
     id: string;
     data: SurfaceData;
     frameOfReferenceUID: string;
     color?: Point3;
-};
+}
 export declare class Surface implements ISurface {
     readonly id: string;
     readonly sizeInBytes: number;

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

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

package/dist/esm/cache/index.js

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

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

@@ -1,3 +1,3 @@
-import { CPUFallbackColormapsData } from '../types';
+import type { CPUFallbackColormapsData } from '../types';
 declare const colormapsData: CPUFallbackColormapsData;
 export default colormapsData;

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

@@ -1,3 +1,3 @@
-import { ViewportPreset } from '../types';
+import type { ViewportPreset } from '../types';
 declare const presets: ViewportPreset[];
 export default presets;

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

@@ -0,0 +1,5 @@
+export declare enum GenerateImageType {
+    SUM = "SUM",
+    SUBTRACT = "SUBTRACT",
+    AVERAGE = "AVERAGE"
+}

package/dist/esm/enums/GenerateImageType.js

@@ -0,0 +1,6 @@
+export var GenerateImageType;
+(function (GenerateImageType) {
+    GenerateImageType["SUM"] = "SUM";
+    GenerateImageType["SUBTRACT"] = "SUBTRACT";
+    GenerateImageType["AVERAGE"] = "AVERAGE";
+})(GenerateImageType || (GenerateImageType = {}));

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

@@ -18,6 +18,7 @@ declare enum MetadataModules {
     PET_SERIES = "petSeriesModule",
     SOP_COMMON = "sopCommonModule",
     ULTRASOUND_ENHANCED_REGION = "ultrasoundEnhancedRegionModule",
-    VOI_LUT = "voiLutModule"
+    VOI_LUT = "voiLutModule",
+    WADO_WEB_CLIENT = "wadoWebClient"
 }
 export default MetadataModules;

package/dist/esm/enums/MetadataModules.js

@@ -20,5 +20,6 @@ var MetadataModules;
     MetadataModules["SOP_COMMON"] = "sopCommonModule";
     MetadataModules["ULTRASOUND_ENHANCED_REGION"] = "ultrasoundEnhancedRegionModule";
     MetadataModules["VOI_LUT"] = "voiLutModule";
+    MetadataModules["WADO_WEB_CLIENT"] = "wadoWebClient";
 })(MetadataModules || (MetadataModules = {}));
 export default MetadataModules;

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

@@ -3,6 +3,7 @@ declare enum ViewportType {
     ORTHOGRAPHIC = "orthographic",
     PERSPECTIVE = "perspective",
     VOLUME_3D = "volume3d",
-    VIDEO = "video"
+    VIDEO = "video",
+    WholeSlide = "wholeSlide"
 }
 export default ViewportType;

package/dist/esm/enums/ViewportType.js

@@ -5,5 +5,6 @@ var ViewportType;
     ViewportType["PERSPECTIVE"] = "perspective";
     ViewportType["VOLUME_3D"] = "volume3d";
     ViewportType["VIDEO"] = "video";
+    ViewportType["WholeSlide"] = "wholeSlide";
 })(ViewportType || (ViewportType = {}));
 export default ViewportType;

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

@@ -4,7 +4,6 @@ import ViewportType from './ViewportType';
 import InterpolationType from './InterpolationType';
 import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
-import SharedArrayBufferModes from './SharedArrayBufferModes';
 import GeometryType from './GeometryType';
 import ContourType from './ContourType';
 import VOILUTFunctionType from './VOILUTFunctionType';
@@ -14,4 +13,5 @@ import ViewportStatus from './ViewportStatus';
 import ImageQualityStatus from './ImageQualityStatus';
 import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, SharedArrayBufferModes, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, };
+import { GenerateImageType } from './GenerateImageType';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, GenerateImageType, };

package/dist/esm/enums/index.js

@@ -4,7 +4,6 @@ import ViewportType from './ViewportType';
 import InterpolationType from './InterpolationType';
 import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
-import SharedArrayBufferModes from './SharedArrayBufferModes';
 import GeometryType from './GeometryType';
 import ContourType from './ContourType';
 import VOILUTFunctionType from './VOILUTFunctionType';
@@ -14,4 +13,5 @@ import ViewportStatus from './ViewportStatus';
 import ImageQualityStatus from './ImageQualityStatus';
 import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, SharedArrayBufferModes, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, };
+import { GenerateImageType } from './GenerateImageType';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, GenerateImageType, };

package/dist/esm/eventTarget.js

@@ -44,8 +44,7 @@ class CornerstoneEventTarget {
         }
     }
     removeEventListenerDebounced(type, callback) {
-        if (this.debouncedListeners[type] &&
-            this.debouncedListeners[type][callback]) {
+        if (this.debouncedListeners[type]?.[callback]) {
             const debounced = this.debouncedListeners[type][callback];
             this.removeEventListener(type, debounced.handle);
             clearTimeout(debounced.timeoutId);
@@ -67,7 +66,7 @@ class CornerstoneEventTarget {
     }
     dispatchEvent(event) {
         if (!this.listeners[event.type]) {
-            return;
+            return !event.defaultPrevented;
         }
         const stack = this.listeners[event.type].slice();
         const stackLength = stack.length;

package/dist/esm/getEnabledElement.d.ts

@@ -1,4 +1,4 @@
-import { IEnabledElement } from './types';
+import type { IEnabledElement } from './types';
 export default function getEnabledElement(element: HTMLDivElement | undefined): IEnabledElement | undefined;
 export declare function getEnabledElementByIds(viewportId: string, renderingEngineId: string): IEnabledElement;
 export declare function getEnabledElementByViewportId(viewportId: string): IEnabledElement;

package/dist/esm/global.d.ts

@@ -1,7 +1,6 @@
 declare global {
     interface Window {
         crossOriginIsolated: unknown;
-        SharedArrayBuffer: unknown;
     }
 }
 export default global;

package/dist/esm/index.d.ts

@@ -1,32 +1,36 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import { createVolumeActor, createVolumeMapper, getOrCreateCanvas } from './RenderingEngine';
 import RenderingEngine from './RenderingEngine';
+import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
+import createVolumeMapper from './RenderingEngine/helpers/createVolumeMapper';
+import getOrCreateCanvas from './RenderingEngine/helpers/getOrCreateCanvas';
 import VolumeViewport from './RenderingEngine/VolumeViewport';
 import VolumeViewport3D from './RenderingEngine/VolumeViewport3D';
 import BaseVolumeViewport from './RenderingEngine/BaseVolumeViewport';
 import StackViewport from './RenderingEngine/StackViewport';
 import VideoViewport from './RenderingEngine/VideoViewport';
+import WSIViewport from './RenderingEngine/WSIViewport';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { getRenderingEngine, getRenderingEngines } from './RenderingEngine/getRenderingEngine';
-import cache, { ImageVolume, Surface } from './cache';
+import { ImageVolume, Surface } from './cache';
+import cache from './cache/cache';
 import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements } from './getEnabledElement';
 import * as metaData from './metaData';
-import { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, setUseSharedArrayBuffer, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures } from './init';
+import { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport } from './init';
 import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
 import * as geometryLoader from './loaders/geometryLoader';
 import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
 import type * as Types from './types';
-import { IRetrieveConfiguration, IImagesLoader, RetrieveOptions, RetrieveStage, ImageLoadListener } from './types';
+import type { IRetrieveConfiguration, IImagesLoader, RetrieveOptions, RetrieveStage, ImageLoadListener } from './types';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getShouldUseSharedArrayBuffer, setUseSharedArrayBuffer, resetUseSharedArrayBuffer, geometryLoader, ProgressiveRetrieveImages, };
+export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, };

package/dist/esm/index.js

@@ -1,22 +1,26 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import { createVolumeActor, createVolumeMapper, getOrCreateCanvas, } from './RenderingEngine';
 import RenderingEngine from './RenderingEngine';
+import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
+import createVolumeMapper from './RenderingEngine/helpers/createVolumeMapper';
+import getOrCreateCanvas from './RenderingEngine/helpers/getOrCreateCanvas';
 import VolumeViewport from './RenderingEngine/VolumeViewport';
 import VolumeViewport3D from './RenderingEngine/VolumeViewport3D';
 import BaseVolumeViewport from './RenderingEngine/BaseVolumeViewport';
 import StackViewport from './RenderingEngine/StackViewport';
 import VideoViewport from './RenderingEngine/VideoViewport';
+import WSIViewport from './RenderingEngine/WSIViewport';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { getRenderingEngine, getRenderingEngines, } from './RenderingEngine/getRenderingEngine';
-import cache, { ImageVolume, Surface } from './cache';
+import { ImageVolume, Surface } from './cache';
+import cache from './cache/cache';
 import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements, } from './getEnabledElement';
 import * as metaData from './metaData';
-import { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, setUseSharedArrayBuffer, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, } from './init';
+import { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, } from './init';
 import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
@@ -26,4 +30,4 @@ import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getShouldUseSharedArrayBuffer, setUseSharedArrayBuffer, resetUseSharedArrayBuffer, geometryLoader, ProgressiveRetrieveImages, };
+export { init, isCornerstoneInitialized, peerImport, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, getOrCreateCanvas, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, };

package/dist/esm/init.d.ts

@@ -1,16 +1,13 @@
-import { SharedArrayBufferModes } from './enums';
-import { Cornerstone3DConfig } from './types';
-declare function init(configuration?: Cornerstone3DConfig): Promise<boolean>;
-declare function setUseCPURendering(status: boolean): void;
+import type { Cornerstone3DConfig } from './types';
+declare function init(configuration?: Cornerstone3DConfig): boolean;
+declare function setUseCPURendering(status: boolean, updateViewports?: boolean): void;
 declare function setPreferSizeOverAccuracy(status: boolean): void;
 declare function canRenderFloatTextures(): boolean;
 declare function resetUseCPURendering(): void;
 declare function getShouldUseCPURendering(): boolean;
-declare function setUseSharedArrayBuffer(mode: SharedArrayBufferModes | boolean): void;
-declare function resetUseSharedArrayBuffer(): void;
-declare function getShouldUseSharedArrayBuffer(): boolean;
 declare function isCornerstoneInitialized(): boolean;
 declare function getConfiguration(): Cornerstone3DConfig;
 declare function setConfiguration(c: Cornerstone3DConfig): void;
 declare function getWebWorkerManager(): any;
-export { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setUseSharedArrayBuffer, setPreferSizeOverAccuracy, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, };
+declare function peerImport(moduleId: string): any;
+export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, };