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

package/dist/esm/init.js

@@ -1,14 +1,9 @@
-import { getGPUTier } from 'detect-gpu';
-import { SharedArrayBufferModes } from './enums';
 import { getRenderingEngines } from './RenderingEngine/getRenderingEngine';
 let csRenderInitialized = false;
-let useSharedArrayBuffer = true;
-let sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
 import { deepMerge } from './utilities';
 import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager';
 const defaultConfig = {
-    gpuTier: undefined,
-    detectGPUConfig: {},
+    gpuTier: { tier: 2 },
     isMobile: false,
     rendering: {
         useCPURendering: false,
@@ -16,19 +11,11 @@ const defaultConfig = {
         useNorm16Texture: false,
         strictZSpacingForVolumeViewport: true,
     },
-    enableCacheOptimization: true,
+    peerImport: (moduleId) => null,
 };
 let config = {
-    gpuTier: undefined,
-    detectGPUConfig: {},
-    isMobile: false,
-    rendering: {
-        useCPURendering: false,
-        preferSizeOverAccuracy: false,
-        useNorm16Texture: false,
-        strictZSpacingForVolumeViewport: true,
-    },
-    enableCacheOptimization: true,
+    ...defaultConfig,
+    rendering: { ...defaultConfig.rendering },
 };
 let webWorkerManager = null;
 function _getGLContext() {
@@ -42,19 +29,6 @@ function _hasActiveWebGLContext() {
     const gl = _getGLContext();
     return (gl instanceof WebGLRenderingContext || gl instanceof WebGL2RenderingContext);
 }
-function hasSharedArrayBuffer() {
-    try {
-        if (new SharedArrayBuffer(0)) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    catch {
-        return false;
-    }
-}
 function _hasNorm16TextureSupport() {
     const gl = _getGLContext();
     if (gl) {
@@ -72,10 +46,10 @@ function isIOS() {
     else {
         return (navigator.maxTouchPoints &&
             navigator.maxTouchPoints > 2 &&
-            /MacIntel/.test(navigator.platform));
+            navigator.platform.includes('MacIntel'));
     }
 }
-async function init(configuration = config) {
+function init(configuration = config) {
     if (csRenderInitialized) {
         return csRenderInitialized;
     }
@@ -83,7 +57,7 @@ async function init(configuration = config) {
     if (isIOS()) {
         config.rendering.useNorm16Texture = _hasNorm16TextureSupport();
         if (!config.rendering.useNorm16Texture) {
-            if (configuration.rendering?.preferSizeOverAccuracy) {
+            if (configuration.rendering.preferSizeOverAccuracy) {
                 config.rendering.preferSizeOverAccuracy = true;
             }
             else {
@@ -97,28 +71,20 @@ async function init(configuration = config) {
         config.rendering.useCPURendering = true;
     }
     else {
-        config.gpuTier =
-            config.gpuTier || (await getGPUTier(config.detectGPUConfig));
-        console.log('CornerstoneRender: Using detect-gpu to get the GPU benchmark:', config.gpuTier);
-        if (config.gpuTier?.tier < 1) {
-            console.log('CornerstoneRender: GPU is not powerful enough, using CPU rendering');
-            config.rendering.useCPURendering = true;
-        }
-        else {
-            console.log('CornerstoneRender: using GPU rendering');
-        }
+        console.log('CornerstoneRender: using GPU rendering');
     }
-    setUseSharedArrayBuffer(sharedArrayBufferMode);
     csRenderInitialized = true;
     if (!webWorkerManager) {
         webWorkerManager = new CentralizedWebWorkerManager();
     }
     return csRenderInitialized;
 }
-function setUseCPURendering(status) {
+function setUseCPURendering(status, updateViewports = true) {
     config.rendering.useCPURendering = status;
     csRenderInitialized = true;
-    _updateRenderingPipelinesForAllViewports();
+    if (updateViewports) {
+        _updateRenderingPipelinesForAllViewports();
+    }
 }
 function setPreferSizeOverAccuracy(status) {
     config.rendering.preferSizeOverAccuracy = status;
@@ -138,38 +104,6 @@ function resetUseCPURendering() {
 function getShouldUseCPURendering() {
     return config.rendering.useCPURendering;
 }
-function setUseSharedArrayBuffer(mode) {
-    if (mode == SharedArrayBufferModes.AUTO) {
-        sharedArrayBufferMode = SharedArrayBufferModes.AUTO;
-        const hasSharedBuffer = hasSharedArrayBuffer();
-        if (!hasSharedBuffer) {
-            useSharedArrayBuffer = false;
-            console.warn(`CornerstoneRender: SharedArray Buffer not allowed, performance may be slower.
-        Try ensuring page is cross-origin isolated to enable SharedArrayBuffer.`);
-        }
-        else {
-            useSharedArrayBuffer = true;
-            console.log('CornerstoneRender: using SharedArrayBuffer');
-        }
-        return;
-    }
-    if (mode == SharedArrayBufferModes.TRUE || mode == true) {
-        sharedArrayBufferMode = SharedArrayBufferModes.TRUE;
-        useSharedArrayBuffer = true;
-        return;
-    }
-    if (mode == SharedArrayBufferModes.FALSE || mode == false) {
-        sharedArrayBufferMode = SharedArrayBufferModes.FALSE;
-        useSharedArrayBuffer = false;
-        return;
-    }
-}
-function resetUseSharedArrayBuffer() {
-    setUseSharedArrayBuffer(sharedArrayBufferMode);
-}
-function getShouldUseSharedArrayBuffer() {
-    return useSharedArrayBuffer;
-}
 function isCornerstoneInitialized() {
     return csRenderInitialized;
 }
@@ -181,9 +115,11 @@ function setConfiguration(c) {
     _updateRenderingPipelinesForAllViewports();
 }
 function _updateRenderingPipelinesForAllViewports() {
-    getRenderingEngines().forEach((engine) => engine
-        .getViewports()
-        .forEach((viewport) => viewport.updateRenderingPipeline?.()));
+    getRenderingEngines().forEach((engine) => {
+        engine.getViewports().forEach((viewport) => {
+            viewport.updateRenderingPipeline();
+        });
+    });
 }
 function getWebWorkerManager() {
     if (!webWorkerManager) {
@@ -191,4 +127,7 @@ function getWebWorkerManager() {
     }
     return webWorkerManager;
 }
-export { init, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, isCornerstoneInitialized, setUseCPURendering, setUseSharedArrayBuffer, setPreferSizeOverAccuracy, resetUseCPURendering, resetUseSharedArrayBuffer, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, };
+function peerImport(moduleId) {
+    return config.peerImport(moduleId);
+}
+export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, };

package/dist/esm/loaders/ProgressiveRetrieveImages.d.ts

@@ -1,20 +1,20 @@
-import { IRetrieveConfiguration, IImagesLoader, RetrieveStage, ImageLoadListener, RetrieveOptions } from '../types';
+import type { IRetrieveConfiguration, IImagesLoader, RetrieveStage, ImageLoadListener, RetrieveOptions } from '../types';
 import singleRetrieveStages from './configuration/singleRetrieve';
 import sequentialRetrieveStages from './configuration/sequentialRetrieve';
 import interleavedRetrieveStages from './configuration/interleavedRetrieve';
 import { ImageQualityStatus } from '../enums';
 export { sequentialRetrieveStages, interleavedRetrieveStages, singleRetrieveStages, };
-export type NearbyRequest = {
+export interface NearbyRequest {
     itemId: string;
     linearId?: string;
     imageQualityStatus: ImageQualityStatus;
-};
-export type ProgressiveRequest = {
+}
+export interface ProgressiveRequest {
     imageId: string;
     stage: RetrieveStage;
     next?: ProgressiveRequest;
     nearbyRequests?: NearbyRequest[];
-};
+}
 export declare class ProgressiveRetrieveImages implements IImagesLoader, IRetrieveConfiguration {
     static createProgressive: typeof createProgressive;
     static interleavedRetrieveStages: {

package/dist/esm/loaders/ProgressiveRetrieveImages.js

@@ -186,7 +186,9 @@ class ProgressiveRetrieveImagesInstance {
         for (const stage of this.stages) {
             const indices = stage.positions ||
                 decimate(this.imageIds, stage.decimate || 1, stage.offset ?? 0);
-            indices.forEach((index) => addStageInstance(stage, index));
+            indices.forEach((index) => {
+                addStageInstance(stage, index);
+            });
         }
         return interleaved;
     }

package/dist/esm/loaders/configuration/interleavedRetrieve.d.ts

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

package/dist/esm/loaders/fillNearbyFrames.d.ts

@@ -1,3 +1,3 @@
-import { ImageLoadListener } from '../types';
-import { ImageQualityStatus } from '../enums';
+import type { ImageLoadListener } from '../types';
+import type { ImageQualityStatus } from '../enums';
 export declare function fillNearbyFrames(listener: ImageLoadListener, imageQualityStatusMap: Map<string, ImageQualityStatus>, request: any, image: any, options: any): void;

package/dist/esm/loaders/geometryLoader.d.ts

@@ -1,9 +1,9 @@
 import '@kitware/vtk.js/Rendering/Profiles/Geometry';
 import { GeometryType } from '../enums';
-import { IGeometry, PublicContourSetData, PublicSurfaceData } from '../types';
-type GeometryOptions = {
+import type { IGeometry, PublicContourSetData, PublicSurfaceData } from '../types';
+interface GeometryOptions {
     type: GeometryType;
     geometryData: PublicContourSetData | PublicSurfaceData;
-};
+}
 declare function createAndCacheGeometry(geometryId: string, options: GeometryOptions): Promise<IGeometry>;
 export { createAndCacheGeometry };

package/dist/esm/loaders/imageLoader.d.ts

@@ -1,43 +1,38 @@
-import { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray } from '../types';
+import type { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray } from '../types';
 export interface ImageLoaderOptions {
     priority: number;
     requestType: string;
     additionalDetails?: Record<string, unknown>;
     ignoreCache?: boolean;
 }
-interface DerivedImages {
-    imageIds: Array<string>;
-    promises: Array<Promise<IImage>>;
-}
-type LocalImageOptions = {
+interface LocalImageOptions {
     scalarData?: PixelDataTypedArray;
     targetBufferType?: PixelDataTypedArrayString;
     dimensions?: Point2;
-    spacing?: Point3;
+    spacing?: Point2;
     origin?: Point3;
     direction?: Mat3;
     skipCreateBuffer?: boolean;
     onCacheAdd?: (image: IImage) => void;
-};
+}
 type DerivedImageOptions = LocalImageOptions & {
     imageId?: string;
-    targetBufferType?: PixelDataTypedArrayString;
 };
 export declare function loadImage(imageId: string, options?: ImageLoaderOptions): Promise<IImage>;
 export declare function loadAndCacheImage(imageId: string, options?: ImageLoaderOptions): Promise<IImage>;
-export declare function loadAndCacheImages(imageIds: Array<string>, options?: ImageLoaderOptions): Promise<IImage>[];
-export declare function createAndCacheDerivedImage(referencedImageId: string, options?: DerivedImageOptions, preventCache?: boolean): Promise<IImage>;
-export declare function createAndCacheDerivedImages(referencedImageIds: Array<string>, options?: DerivedImageOptions & {
+export declare function loadAndCacheImages(imageIds: string[], options?: ImageLoaderOptions): Promise<IImage>[];
+export declare function createAndCacheDerivedImage(referencedImageId: string, options?: DerivedImageOptions): IImage;
+export declare function createAndCacheDerivedImages(referencedImageIds: string[], options?: DerivedImageOptions & {
     getDerivedImageId?: (referencedImageId: string) => string;
     targetBufferType?: PixelDataTypedArrayString;
-}): DerivedImages;
-export declare function createAndCacheLocalImage(options: LocalImageOptions, imageId: string, preventCache?: boolean): IImage;
+}): IImage[];
+export declare function createAndCacheLocalImage(imageId: string, options: LocalImageOptions): IImage;
 export declare function cancelLoadImage(imageId: string): void;
-export declare function cancelLoadImages(imageIds: Array<string>): void;
+export declare function cancelLoadImages(imageIds: string[]): void;
 export declare function cancelLoadAll(): void;
 export declare function registerImageLoader(scheme: string, imageLoader: ImageLoaderFn): void;
 export declare function registerUnknownImageLoader(imageLoader: ImageLoaderFn): ImageLoaderFn;
 export declare function unregisterAllImageLoaders(): void;
-export declare function createAndCacheDerivedSegmentationImages(referencedImageIds: Array<string>, options?: DerivedImageOptions): DerivedImages;
-export declare function createAndCacheDerivedSegmentationImage(referencedImageId: string, options?: DerivedImageOptions): Promise<IImage>;
+export declare function createAndCacheDerivedSegmentationImages(referencedImageIds: string[], options?: DerivedImageOptions): IImage[];
+export declare function createAndCacheDerivedSegmentationImage(referencedImageId: string, options?: DerivedImageOptions): IImage;
 export {};

package/dist/esm/loaders/imageLoader.js

@@ -1,13 +1,16 @@
 import cache from '../cache/cache';
-import { ImageVolume } from '../cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
-import { genericMetadataProvider, getBufferConfiguration, triggerEvent, uuidv4, } from '../utilities';
+import { genericMetadataProvider, getBufferConfiguration, triggerEvent, uuidv4, VoxelManager, } from '../utilities';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import { metaData } from '../';
 const imageLoaders = {};
 let unknownImageLoader;
 function loadImageFromImageLoader(imageId, options) {
+    const cachedImage = cache.getImageLoadObject(imageId);
+    if (cachedImage) {
+        return cachedImage;
+    }
     const colonIndex = imageId.indexOf(':');
     const scheme = imageId.substring(0, colonIndex);
     const loader = imageLoaders[scheme];
@@ -18,9 +21,24 @@ function loadImageFromImageLoader(imageId, options) {
         throw new Error('loadImageFromImageLoader: no image loader for imageId');
     }
     const imageLoadObject = loader(imageId, options);
-    imageLoadObject.promise.then(function (image) {
+    imageLoadObject.promise
+        .then((image) => {
+        const scalarData = image.getPixelData();
+        const { width, height, numberOfComponents } = image;
+        if (!image.voxelManager) {
+            const voxelManager = VoxelManager.createImageVoxelManager({
+                scalarData,
+                width,
+                height,
+                numberOfComponents,
+            });
+            image.voxelManager = voxelManager;
+            image.getPixelData = () => voxelManager.getScalarData();
+            delete image.imageFrame.pixelData;
+        }
         triggerEvent(eventTarget, Events.IMAGE_LOADED, { image });
-    }, function (error) {
+    })
+        .catch((error) => {
         const errorObject = {
             imageId,
             error,
@@ -29,45 +47,19 @@ function loadImageFromImageLoader(imageId, options) {
     });
     return imageLoadObject;
 }
-function loadImageFromCacheOrVolume(imageId, options) {
-    if (options.ignoreCache) {
-        return loadImageFromImageLoader(imageId, options);
-    }
-    let imageLoadObject = cache.getImageLoadObject(imageId);
-    if (imageLoadObject !== undefined) {
-        return imageLoadObject;
-    }
-    const cachedVolumeInfo = cache.getVolumeContainingImageId(imageId);
-    if (cachedVolumeInfo?.volume?.loadStatus?.loaded) {
-        const { volume, imageIdIndex } = cachedVolumeInfo;
-        if (volume instanceof ImageVolume) {
-            imageLoadObject = volume.getCornerstoneImageLoadObject(imageId, imageIdIndex);
-        }
-        return imageLoadObject;
-    }
-    const cachedImage = cache.getCachedImageBasedOnImageURI(imageId);
-    if (cachedImage) {
-        imageLoadObject = cachedImage.imageLoadObject;
-        return imageLoadObject;
-    }
-    imageLoadObject = loadImageFromImageLoader(imageId, options);
-    return imageLoadObject;
-}
 export function loadImage(imageId, options = { priority: 0, requestType: 'prefetch' }) {
     if (imageId === undefined) {
         throw new Error('loadImage: parameter imageId must not be undefined');
     }
-    return loadImageFromCacheOrVolume(imageId, options).promise;
+    return loadImageFromImageLoader(imageId, options).promise;
 }
 export function loadAndCacheImage(imageId, options = { priority: 0, requestType: 'prefetch' }) {
     if (imageId === undefined) {
         throw new Error('loadAndCacheImage: parameter imageId must not be undefined');
     }
-    const imageLoadObject = loadImageFromCacheOrVolume(imageId, options);
+    const imageLoadObject = loadImageFromImageLoader(imageId, options);
     if (!cache.getImageLoadObject(imageId)) {
-        cache.putImageLoadObject(imageId, imageLoadObject).catch((err) => {
-            console.warn(err);
-        });
+        cache.putImageLoadObject(imageId, imageLoadObject);
     }
     return imageLoadObject.promise;
 }
@@ -80,7 +72,7 @@ export function loadAndCacheImages(imageIds, options = { priority: 0, requestTyp
     });
     return allPromises;
 }
-export function createAndCacheDerivedImage(referencedImageId, options = {}, preventCache = false) {
+export function createAndCacheDerivedImage(referencedImageId, options = {}) {
     if (referencedImageId === undefined) {
         throw new Error('createAndCacheDerivedImage: parameter imageId must not be undefined');
     }
@@ -93,11 +85,15 @@ export function createAndCacheDerivedImage(referencedImageId, options = {}, prev
     const { TypedArrayConstructor } = getBufferConfiguration(options.targetBufferType, length);
     const imageScalarData = new TypedArrayConstructor(skipCreateBuffer ? 1 : length);
     const derivedImageId = imageId;
-    ['imagePlaneModule', 'generalSeriesModule'].forEach((type) => {
-        genericMetadataProvider.add(derivedImageId, {
-            type,
-            metadata: metaData.get(type, referencedImageId),
-        });
+    const referencedImagePlaneMetadata = metaData.get('imagePlaneModule', referencedImageId);
+    genericMetadataProvider.add(derivedImageId, {
+        type: 'imagePlaneModule',
+        metadata: referencedImagePlaneMetadata,
+    });
+    const referencedImageGeneralSeriesMetadata = metaData.get('generalSeriesModule', referencedImageId);
+    genericMetadataProvider.add(derivedImageId, {
+        type: 'generalSeriesModule',
+        metadata: referencedImageGeneralSeriesMetadata,
     });
     const imagePixelModule = metaData.get('imagePixelModule', referencedImageId);
     genericMetadataProvider.add(derivedImageId, {
@@ -111,79 +107,158 @@ export function createAndCacheDerivedImage(referencedImageId, options = {}, prev
             pixelRepresentation: 0,
         },
     });
-    const localImage = createAndCacheLocalImage({ scalarData: imageScalarData, onCacheAdd, skipCreateBuffer }, imageId, true);
-    const imageLoadObject = {
-        promise: Promise.resolve(localImage),
-    };
-    if (!preventCache) {
-        cache.putImageLoadObject(derivedImageId, imageLoadObject);
+    const localImage = createAndCacheLocalImage(imageId, {
+        scalarData: imageScalarData,
+        onCacheAdd,
+        skipCreateBuffer,
+        targetBufferType: imageScalarData.constructor
+            .name,
+        dimensions: [imagePlaneModule.columns, imagePlaneModule.rows],
+        spacing: [
+            imagePlaneModule.columnPixelSpacing,
+            imagePlaneModule.rowPixelSpacing,
+        ],
+        origin: imagePlaneModule.imagePositionPatient,
+        direction: imagePlaneModule.imageOrientationPatient,
+    });
+    if (!cache.getImageLoadObject(imageId)) {
+        cache.putImageSync(imageId, localImage);
     }
-    return imageLoadObject.promise;
+    return localImage;
 }
 export function createAndCacheDerivedImages(referencedImageIds, options = {}) {
-    if (referencedImageIds?.length === 0) {
+    if (referencedImageIds.length === 0) {
         throw new Error('createAndCacheDerivedImages: parameter imageIds must be list of image Ids');
     }
     const derivedImageIds = [];
-    const allPromises = referencedImageIds.map((referencedImageId) => {
+    const images = referencedImageIds.map((referencedImageId) => {
         const newOptions = {
-            imageId: options.getDerivedImageId?.(referencedImageId) || `derived:${uuidv4()}`,
+            imageId: options?.getDerivedImageId?.(referencedImageId) ||
+                `derived:${uuidv4()}`,
             ...options,
         };
         derivedImageIds.push(newOptions.imageId);
         return createAndCacheDerivedImage(referencedImageId, newOptions);
     });
-    return { imageIds: derivedImageIds, promises: allPromises };
+    return images;
 }
-export function createAndCacheLocalImage(options, imageId, preventCache = false) {
-    const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
-    const length = imagePlaneModule.rows * imagePlaneModule.columns;
+export function createAndCacheLocalImage(imageId, options) {
+    const { scalarData, origin, direction, targetBufferType, skipCreateBuffer, onCacheAdd, } = options;
+    const dimensions = options.dimensions;
+    const spacing = options.spacing;
+    if (!dimensions || !spacing) {
+        throw new Error('createAndCacheLocalImage: dimensions and spacing are required');
+    }
+    const width = dimensions[0];
+    const height = dimensions[1];
+    const columnPixelSpacing = spacing[0];
+    const rowPixelSpacing = spacing[1];
+    const imagePlaneModule = {
+        rows: height.toString(),
+        columns: width.toString(),
+        imageOrientationPatient: direction ?? [1, 0, 0, 0, 1, 0],
+        rowCosines: direction ? direction.slice(0, 3) : [1, 0, 0],
+        columnCosines: direction ? direction.slice(3, 6) : [0, 1, 0],
+        imagePositionPatient: origin ?? [0, 0, 0],
+        pixelSpacing: [rowPixelSpacing, columnPixelSpacing],
+        rowPixelSpacing: rowPixelSpacing,
+        columnPixelSpacing: columnPixelSpacing,
+    };
+    const length = width * height;
+    const numberOfComponents = scalarData.length / length;
+    let scalarDataToUse;
+    if (scalarData) {
+        if (!(scalarData instanceof Uint8Array ||
+            scalarData instanceof Float32Array ||
+            scalarData instanceof Uint16Array ||
+            scalarData instanceof Int16Array)) {
+            throw new Error('createAndCacheLocalImage: scalarData must be of type Uint8Array, Uint16Array, Int16Array or Float32Array');
+        }
+        scalarDataToUse = scalarData;
+    }
+    else if (!skipCreateBuffer) {
+        const { numBytes, TypedArrayConstructor } = getBufferConfiguration(targetBufferType, length);
+        const imageScalarData = new TypedArrayConstructor(length);
+        scalarDataToUse = imageScalarData;
+    }
+    let bitsAllocated, bitsStored, highBit;
+    if (scalarDataToUse instanceof Uint8Array) {
+        bitsAllocated = 8;
+        bitsStored = 8;
+        highBit = 7;
+    }
+    else if (scalarDataToUse instanceof Uint16Array) {
+        bitsAllocated = 16;
+        bitsStored = 16;
+        highBit = 15;
+    }
+    else if (scalarDataToUse instanceof Int16Array) {
+        bitsAllocated = 16;
+        bitsStored = 16;
+        highBit = 15;
+    }
+    else if (scalarDataToUse instanceof Float32Array) {
+        bitsAllocated = 32;
+        bitsStored = 32;
+        highBit = 31;
+    }
+    else {
+        throw new Error('Unsupported scalarData type');
+    }
+    const imagePixelModule = {
+        samplesPerPixel: 1,
+        photometricInterpretation: scalarDataToUse.length > dimensions[0] * dimensions[1]
+            ? 'RGB'
+            : 'MONOCHROME2',
+        rows: height,
+        columns: width,
+        bitsAllocated,
+        bitsStored,
+        highBit,
+    };
+    const metadata = {
+        imagePlaneModule,
+        imagePixelModule,
+    };
+    ['imagePlaneModule', 'imagePixelModule'].forEach((type) => {
+        genericMetadataProvider.add(imageId, {
+            type,
+            metadata: metadata[type] || {},
+        });
+    });
+    const voxelManager = VoxelManager.createImageVoxelManager({
+        height,
+        width,
+        numberOfComponents,
+        scalarData: scalarDataToUse,
+    });
     const image = {
         imageId: imageId,
         intercept: 0,
         windowCenter: 0,
         windowWidth: 0,
-        color: false,
-        numComps: 1,
+        color: imagePixelModule.photometricInterpretation === 'RGB',
+        numberOfComponents: imagePixelModule.samplesPerPixel,
+        dataType: targetBufferType,
         slope: 1,
         minPixelValue: 0,
-        maxPixelValue: 255,
-        voiLUTFunction: undefined,
-        rows: imagePlaneModule.rows,
-        columns: imagePlaneModule.columns,
+        maxPixelValue: Math.pow(2, imagePixelModule.bitsStored) - 1,
+        rows: imagePixelModule.rows,
+        columns: imagePixelModule.columns,
         getCanvas: undefined,
-        height: imagePlaneModule.rows,
-        width: imagePlaneModule.columns,
+        height: imagePixelModule.rows,
+        width: imagePixelModule.columns,
         rgba: undefined,
         columnPixelSpacing: imagePlaneModule.columnPixelSpacing,
         rowPixelSpacing: imagePlaneModule.rowPixelSpacing,
-        FrameOfReferenceUID: imagePlaneModule.FrameOfReferenceUID,
+        FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
         invert: false,
+        getPixelData: () => voxelManager.getScalarData(),
+        voxelManager,
+        sizeInBytes: scalarData.byteLength,
     };
-    if (options.scalarData) {
-        const imageScalarData = options.scalarData;
-        if (!(imageScalarData instanceof Uint8Array ||
-            imageScalarData instanceof Float32Array ||
-            imageScalarData instanceof Uint16Array ||
-            imageScalarData instanceof Int16Array)) {
-            throw new Error('To use createLocalVolume you should pass scalarData of type Uint8Array, Uint16Array, Int16Array or Float32Array');
-        }
-        image.sizeInBytes = imageScalarData.byteLength;
-        image.getPixelData = () => imageScalarData;
-    }
-    else if (options.skipCreateBuffer !== true) {
-        const { numBytes, TypedArrayConstructor } = getBufferConfiguration(options.targetBufferType, length);
-        const imageScalarData = new TypedArrayConstructor(length);
-        image.sizeInBytes = numBytes;
-        image.getPixelData = () => imageScalarData;
-    }
-    options.onCacheAdd?.(image);
-    const imageLoadObject = {
-        promise: Promise.resolve(image),
-    };
-    if (!preventCache) {
-        cache.putImageLoadObject(image.imageId, imageLoadObject);
-    }
+    onCacheAdd?.(image);
+    cache.putImageSync(image.imageId, image);
     return image;
 }
 export function cancelLoadImage(imageId) {
@@ -200,7 +275,9 @@ export function cancelLoadImage(imageId) {
     }
 }
 export function cancelLoadImages(imageIds) {
-    imageIds.forEach((imageId) => cancelLoadImage(imageId));
+    imageIds.forEach((imageId) => {
+        cancelLoadImage(imageId);
+    });
 }
 export function cancelLoadAll() {
     const requestPool = imageLoadPoolManager.getRequestPool();
@@ -236,13 +313,15 @@ export function unregisterAllImageLoaders() {
     Object.keys(imageLoaders).forEach((imageLoader) => delete imageLoaders[imageLoader]);
     unknownImageLoader = undefined;
 }
-export function createAndCacheDerivedSegmentationImages(referencedImageIds, options = {
-    targetBufferType: 'Uint8Array',
-}) {
-    return createAndCacheDerivedImages(referencedImageIds, options);
+export function createAndCacheDerivedSegmentationImages(referencedImageIds, options = {}) {
+    return createAndCacheDerivedImages(referencedImageIds, {
+        ...options,
+        targetBufferType: 'Uint8Array',
+    });
 }
-export function createAndCacheDerivedSegmentationImage(referencedImageId, options = {
-    targetBufferType: 'Uint8Array',
-}) {
-    return createAndCacheDerivedImage(referencedImageId, options);
+export function createAndCacheDerivedSegmentationImage(referencedImageId, options = {}) {
+    return createAndCacheDerivedImage(referencedImageId, {
+        ...options,
+        targetBufferType: 'Uint8Array',
+    });
 }

package/dist/esm/loaders/utils/contourSet/createContourSet.d.ts

@@ -1,2 +1,2 @@
-import { IGeometry, PublicContourSetData } from '../../../types';
+import type { IGeometry, PublicContourSetData } from '../../../types';
 export declare function createContourSet(geometryId: string, contourSetData: PublicContourSetData): IGeometry;

package/dist/esm/loaders/utils/contourSet/validateContourSet.d.ts

@@ -1,2 +1,2 @@
-import { PublicContourSetData } from '../../../types';
+import type { PublicContourSetData } from '../../../types';
 export declare function validateContourSet(contourSetData: PublicContourSetData): void;