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

package/dist/esm/loaders/imageLoader.js

@@ -1,11 +1,16 @@
 import cache from '../cache/cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
-import { triggerEvent } 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];
@@ -16,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,
@@ -27,40 +47,19 @@ function loadImageFromImageLoader(imageId, options) {
     });
     return imageLoadObject;
 }
-function loadImageFromCacheOrVolume(imageId, options) {
-    let imageLoadObject = cache.getImageLoadObject(imageId);
-    if (imageLoadObject !== undefined) {
-        return imageLoadObject;
-    }
-    const cachedVolumeInfo = cache.getVolumeContainingImageId(imageId);
-    if (cachedVolumeInfo && cachedVolumeInfo.volume.loadStatus.loaded) {
-        const { volume, imageIdIndex } = cachedVolumeInfo;
-        imageLoadObject = volume.convertToCornerstoneImage(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;
 }
@@ -73,6 +72,195 @@ export function loadAndCacheImages(imageIds, options = { priority: 0, requestTyp
     });
     return allPromises;
 }
+export function createAndCacheDerivedImage(referencedImageId, options = {}) {
+    if (referencedImageId === undefined) {
+        throw new Error('createAndCacheDerivedImage: parameter imageId must not be undefined');
+    }
+    if (options.imageId === undefined) {
+        options.imageId = `derived:${uuidv4()}`;
+    }
+    const { imageId, skipCreateBuffer, onCacheAdd } = options;
+    const imagePlaneModule = metaData.get('imagePlaneModule', referencedImageId);
+    const length = imagePlaneModule.rows * imagePlaneModule.columns;
+    const { TypedArrayConstructor } = getBufferConfiguration(options.targetBufferType, length);
+    const imageScalarData = new TypedArrayConstructor(skipCreateBuffer ? 1 : length);
+    const derivedImageId = imageId;
+    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, {
+        type: 'imagePixelModule',
+        metadata: {
+            ...imagePixelModule,
+            bitsAllocated: 8,
+            bitsStored: 8,
+            highBit: 7,
+            samplesPerPixel: 1,
+            pixelRepresentation: 0,
+        },
+    });
+    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 localImage;
+}
+export function createAndCacheDerivedImages(referencedImageIds, options = {}) {
+    if (referencedImageIds.length === 0) {
+        throw new Error('createAndCacheDerivedImages: parameter imageIds must be list of image Ids');
+    }
+    const derivedImageIds = [];
+    const images = referencedImageIds.map((referencedImageId) => {
+        const newOptions = {
+            imageId: options?.getDerivedImageId?.(referencedImageId) ||
+                `derived:${uuidv4()}`,
+            ...options,
+        };
+        derivedImageIds.push(newOptions.imageId);
+        return createAndCacheDerivedImage(referencedImageId, newOptions);
+    });
+    return images;
+}
+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: imagePixelModule.photometricInterpretation === 'RGB',
+        numberOfComponents: imagePixelModule.samplesPerPixel,
+        dataType: targetBufferType,
+        slope: 1,
+        minPixelValue: 0,
+        maxPixelValue: Math.pow(2, imagePixelModule.bitsStored) - 1,
+        rows: imagePixelModule.rows,
+        columns: imagePixelModule.columns,
+        getCanvas: undefined,
+        height: imagePixelModule.rows,
+        width: imagePixelModule.columns,
+        rgba: undefined,
+        columnPixelSpacing: imagePlaneModule.columnPixelSpacing,
+        rowPixelSpacing: imagePlaneModule.rowPixelSpacing,
+        FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+        invert: false,
+        getPixelData: () => voxelManager.getScalarData(),
+        voxelManager,
+        sizeInBytes: scalarData.byteLength,
+    };
+    onCacheAdd?.(image);
+    cache.putImageSync(image.imageId, image);
+    return image;
+}
 export function cancelLoadImage(imageId) {
     const filterFunction = ({ additionalDetails }) => {
         if (additionalDetails.imageId) {
@@ -87,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();
@@ -95,7 +285,8 @@ export function cancelLoadAll() {
         const requests = requestPool[type];
         Object.keys(requests).forEach((priority) => {
             const requestDetails = requests[priority].pop();
-            const { imageId, volumeId } = requestDetails.additionalDetails;
+            const additionalDetails = requestDetails.additionalDetails;
+            const { imageId, volumeId } = additionalDetails;
             let loadObject;
             if (imageId) {
                 loadObject = cache.getImageLoadObject(imageId);
@@ -122,4 +313,15 @@ export function unregisterAllImageLoaders() {
     Object.keys(imageLoaders).forEach((imageLoader) => delete imageLoaders[imageLoader]);
     unknownImageLoader = undefined;
 }
-//# sourceMappingURL=imageLoader.js.map
+export function createAndCacheDerivedSegmentationImages(referencedImageIds, options = {}) {
+    return createAndCacheDerivedImages(referencedImageIds, {
+        ...options,
+        targetBufferType: 'Uint8Array',
+    });
+}
+export function createAndCacheDerivedSegmentationImage(referencedImageId, options = {}) {
+    return createAndCacheDerivedImage(referencedImageId, {
+        ...options,
+        targetBufferType: 'Uint8Array',
+    });
+}

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

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

package/dist/esm/loaders/utils/contourSet/createContourSet.js

@@ -0,0 +1,20 @@
+import { GeometryType } from '../../../enums';
+import { validateContourSet } from './validateContourSet';
+import { ContourSet } from '../../../cache/classes/ContourSet';
+export function createContourSet(geometryId, contourSetData) {
+    validateContourSet(contourSetData);
+    const contourSet = new ContourSet({
+        id: contourSetData.id,
+        data: contourSetData.data,
+        color: contourSetData.color,
+        frameOfReferenceUID: contourSetData.frameOfReferenceUID,
+        segmentIndex: contourSetData.segmentIndex ?? 1,
+    });
+    const geometry = {
+        id: geometryId,
+        type: GeometryType.CONTOUR,
+        data: contourSet,
+        sizeInBytes: contourSet.getSizeInBytes(),
+    };
+    return geometry;
+}

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

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

package/dist/esm/loaders/utils/contourSet/validateContourSet.js

@@ -0,0 +1,21 @@
+export function validateContourSet(contourSetData) {
+    if (!contourSetData || contourSetData.data.length === 0) {
+        throw new Error('Invalid contour set data, see publicContourSetData type for more info');
+    }
+    if (!contourSetData.id) {
+        throw new Error('Invalid contour set data, each contour set must have an id');
+    }
+    if (!contourSetData.data || !Array.isArray(contourSetData.data)) {
+        throw new Error('Invalid contour set data, each contour set must have an array of contours');
+    }
+    contourSetData.data.forEach((contourData) => {
+        if (!contourData.points || !Array.isArray(contourData.points)) {
+            throw new Error('Invalid contour set data, each contour must have an array of points');
+        }
+        contourData.points.forEach((point) => {
+            if (!point || !Array.isArray(point) || point.length !== 3) {
+                throw new Error('Invalid contour set data, each point must be an array of length 3');
+            }
+        });
+    });
+}

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

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

package/dist/esm/loaders/utils/surface/createSurface.js

@@ -0,0 +1,22 @@
+import { GeometryType } from '../../../enums';
+import { validateSurface } from './validateSurface';
+import { Surface } from '../../../cache/classes/Surface';
+export function createSurface(geometryId, SurfaceData) {
+    validateSurface(SurfaceData);
+    const surface = new Surface({
+        id: SurfaceData.id,
+        color: SurfaceData.color,
+        frameOfReferenceUID: SurfaceData.frameOfReferenceUID,
+        data: {
+            points: SurfaceData.data.points,
+            polys: SurfaceData.data.polys,
+        },
+    });
+    const geometry = {
+        id: geometryId,
+        type: GeometryType.SURFACE,
+        data: surface,
+        sizeInBytes: surface.getSizeInBytes(),
+    };
+    return geometry;
+}

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

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

package/dist/esm/loaders/utils/surface/validateSurface.js

@@ -0,0 +1,6 @@
+export function validateSurface(contourSetData) {
+    const { data } = contourSetData;
+    if (!data.points || !data.polys) {
+        throw new Error('Invalid surface data');
+    }
+}

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

@@ -1,30 +1,34 @@
 import '@kitware/vtk.js/Rendering/Profiles/Volume';
-import { ImageVolume } from '../cache/classes/ImageVolume';
-import type * as Types from '../types';
-import { Point3, Metadata, Mat3 } from '../types';
+import type { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
 interface VolumeLoaderOptions {
-    imageIds: Array<string>;
+    imageIds: string[];
 }
 interface DerivedVolumeOptions {
     volumeId: string;
-    targetBuffer?: {
-        type: 'Float32Array' | 'Uint8Array' | 'Uint16Array' | 'Int16Array';
-        sharedArrayBuffer?: boolean;
-    };
+    targetBufferType?: PixelDataTypedArrayString;
 }
-interface LocalVolumeOptions {
-    scalarData: Float32Array | Uint8Array | Uint16Array | Int16Array;
+export interface LocalVolumeOptions {
     metadata: Metadata;
     dimensions: Point3;
     spacing: Point3;
     origin: Point3;
     direction: Mat3;
+    scalarData?: PixelDataTypedArray;
+    imageIds?: string[];
+    referencedImageIds?: string[];
+    referencedVolumeId?: string;
+    preventCache?: boolean;
+    targetBufferType?: PixelDataTypedArrayString;
 }
-export declare function loadVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<Types.IImageVolume>;
-export declare function createAndCacheVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<Record<string, any>>;
-export declare function createAndCacheDerivedVolume(referencedVolumeId: string, options: DerivedVolumeOptions): Promise<ImageVolume>;
-export declare function createLocalVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): ImageVolume;
-export declare function registerVolumeLoader(scheme: string, volumeLoader: Types.VolumeLoaderFn): void;
+export declare function loadVolume(volumeId: string, options?: VolumeLoaderOptions): 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: Types.VolumeLoaderFn): Types.VolumeLoaderFn | undefined;
+export declare function registerUnknownVolumeLoader(volumeLoader: VolumeLoaderFn): VolumeLoaderFn | undefined;
+export declare function getUnknownVolumeLoaderSchema(): string;
+export declare function createAndCacheDerivedSegmentationVolume(referencedVolumeId: string, options?: DerivedVolumeOptions): IImageVolume;
+export declare function createLocalSegmentationVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): IImageVolume;
 export {};