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

package/dist/esm/loaders/imageLoader.js

@@ -1,13 +1,20 @@
 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 from '../utilities/genericMetadataProvider';
+import { getBufferConfiguration } from '../utilities/getBufferConfiguration';
+import triggerEvent from '../utilities/triggerEvent';
+import uuidv4 from '../utilities/uuidv4';
+import VoxelManager from '../utilities/VoxelManager';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
-import { metaData } from '../';
+import * as metaData from '../metaData';
 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 +25,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 +51,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 +76,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 +89,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 +111,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 +279,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 +317,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;

package/dist/esm/loaders/utils/surface/createSurface.d.ts

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

package/dist/esm/loaders/utils/surface/validateSurface.d.ts

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

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

@@ -1,42 +1,35 @@
 import '@kitware/vtk.js/Rendering/Profiles/Volume';
-import { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
+import type { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
 interface VolumeLoaderOptions {
-    imageIds: Array<string>;
+    imageIds: string[];
+    progressiveRendering?: boolean;
 }
 interface DerivedVolumeOptions {
     volumeId: string;
-    targetBuffer?: {
-        type: PixelDataTypedArrayString;
-        sharedArrayBuffer?: boolean;
-    };
+    targetBufferType?: PixelDataTypedArrayString;
 }
-interface LocalVolumeOptions {
+export interface LocalVolumeOptions {
     metadata: Metadata;
     dimensions: Point3;
     spacing: Point3;
     origin: Point3;
     direction: Mat3;
     scalarData?: PixelDataTypedArray;
-    imageIds?: Array<string>;
-    referencedImageIds?: Array<string>;
+    imageIds?: string[];
+    referencedImageIds?: string[];
     referencedVolumeId?: string;
-    targetBuffer?: {
-        type: PixelDataTypedArrayString;
-        sharedArrayBuffer?: boolean;
-    };
+    preventCache?: boolean;
+    targetBufferType?: PixelDataTypedArrayString;
 }
 export declare function loadVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<IImageVolume>;
-export declare function createAndCacheEmptyVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<Record<string, any>>;
-export declare function createAndCacheDerivedVolume(referencedVolumeId: string, options: DerivedVolumeOptions): Promise<IImageVolume>;
-export declare function createLocalVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): IImageVolume;
-export declare function createAndCacheVolumeFromImages(volumeId: string, imageIds: string[], options?: {
-    preventCache?: boolean;
-    additionalDetails?: Record<string, any>;
-}): Promise<IImageVolume>;
+export declare function createAndCacheVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<IImageVolume>;
+export declare function createAndCacheDerivedVolume(referencedVolumeId: string, options: DerivedVolumeOptions): IImageVolume;
+export declare function createAndCacheVolumeFromImages(volumeId: string, imageIds: string[]): Promise<IImageVolume>;
+export declare function createLocalVolume(volumeId: string, options?: LocalVolumeOptions): IImageVolume;
 export declare function registerVolumeLoader(scheme: string, volumeLoader: VolumeLoaderFn): void;
 export declare function getVolumeLoaderSchemes(): string[];
 export declare function registerUnknownVolumeLoader(volumeLoader: VolumeLoaderFn): VolumeLoaderFn | undefined;
 export declare function getUnknownVolumeLoaderSchema(): string;
-export declare function createAndCacheDerivedSegmentationVolume(referencedVolumeId: string, options?: DerivedVolumeOptions): Promise<IImageVolume>;
-export declare function createLocalSegmentationVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): Promise<IImageVolume>;
+export declare function createAndCacheDerivedSegmentationVolume(referencedVolumeId: string, options?: DerivedVolumeOptions): IImageVolume;
+export declare function createLocalSegmentationVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): IImageVolume;
 export {};