@cornerstonejs/core 2.0.0-beta.7 → 2.0.0

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

@@ -0,0 +1,44 @@
+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 LocalImageOptions {
+    frameOfReferenceUID?: string;
+    scalarData?: PixelDataTypedArray;
+    targetBuffer?: {
+        type: PixelDataTypedArrayString;
+    };
+    dimensions?: Point2;
+    spacing?: Point2;
+    origin?: Point3;
+    direction?: Mat3;
+    skipCreateBuffer?: boolean;
+    onCacheAdd?: (image: IImage) => void;
+}
+type DerivedImageOptions = LocalImageOptions & {
+    imageId?: string;
+    instanceNumber?: number;
+};
+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: 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;
+    targetBuffer?: {
+        type: PixelDataTypedArrayString;
+    };
+}): IImage[];
+export declare function createAndCacheLocalImage(imageId: string, options: LocalImageOptions): IImage;
+export declare function cancelLoadImage(imageId: 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 createAndCacheDerivedLabelmapImages(referencedImageIds: string[], options?: DerivedImageOptions): IImage[];
+export declare function createAndCacheDerivedLabelmapImage(referencedImageId: string, options?: DerivedImageOptions): IImage;
+export {};

package/dist/esm/loaders/imageLoader.js

@@ -1,73 +1,71 @@
 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 colonIndex = imageId.indexOf(':');
-    const scheme = imageId.substring(0, colonIndex);
-    const loader = imageLoaders[scheme];
-    if (loader === undefined || loader === null) {
-        if (unknownImageLoader !== undefined) {
-            return unknownImageLoader(imageId);
-        }
-        throw new Error('loadImageFromImageLoader: no image loader for imageId');
+    const cachedImageLoadObject = cache.getImageLoadObject(imageId);
+    if (cachedImageLoadObject) {
+        handleImageLoadPromise(cachedImageLoadObject.promise, imageId);
+        return cachedImageLoadObject;
+    }
+    const scheme = imageId.split(':')[0];
+    const loader = imageLoaders[scheme] || unknownImageLoader;
+    if (!loader) {
+        throw new Error(`loadImageFromImageLoader: No image loader found for scheme '${scheme}'`);
     }
     const imageLoadObject = loader(imageId, options);
-    imageLoadObject.promise.then(function (image) {
+    handleImageLoadPromise(imageLoadObject.promise, imageId);
+    return imageLoadObject;
+}
+function handleImageLoadPromise(imagePromise, imageId) {
+    Promise.resolve(imagePromise)
+        .then((image) => {
+        ensureVoxelManager(image);
         triggerEvent(eventTarget, Events.IMAGE_LOADED, { image });
-    }, function (error) {
-        const errorObject = {
+    })
+        .catch((error) => {
+        const errorDetails = {
             imageId,
             error,
         };
-        triggerEvent(eventTarget, Events.IMAGE_LOAD_FAILED, errorObject);
+        triggerEvent(eventTarget, Events.IMAGE_LOAD_FAILED, errorDetails);
     });
-    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.convertToCornerstoneImage(imageId, imageIdIndex);
-        }
-        return imageLoadObject;
-    }
-    const cachedImage = cache.getCachedImageBasedOnImageURI(imageId);
-    if (cachedImage) {
-        imageLoadObject = cachedImage.imageLoadObject;
-        return imageLoadObject;
+function ensureVoxelManager(image) {
+    if (!image.voxelManager) {
+        const { width, height, numberOfComponents } = image;
+        const voxelManager = VoxelManager.createImageVoxelManager({
+            scalarData: image.getPixelData(),
+            width,
+            height,
+            numberOfComponents,
+        });
+        image.voxelManager = voxelManager;
+        image.getPixelData = () => voxelManager.getScalarData();
+        delete image.imageFrame.pixelData;
     }
-    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 +78,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');
     }
@@ -90,14 +88,24 @@ export function createAndCacheDerivedImage(referencedImageId, options = {}, prev
     const { imageId, skipCreateBuffer, onCacheAdd } = options;
     const imagePlaneModule = metaData.get('imagePlaneModule', referencedImageId);
     const length = imagePlaneModule.rows * imagePlaneModule.columns;
-    const { TypedArrayConstructor } = getBufferConfiguration(options.targetBufferType, length);
+    const { TypedArrayConstructor } = getBufferConfiguration(options.targetBuffer?.type, 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,
+    });
+    genericMetadataProvider.add(derivedImageId, {
+        type: 'generalImageModule',
+        metadata: {
+            instanceNumber: options.instanceNumber,
+        },
     });
     const imagePixelModule = metaData.get('imagePixelModule', referencedImageId);
     genericMetadataProvider.add(derivedImageId, {
@@ -111,78 +119,165 @@ 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,
+        targetBuffer: {
+            type: imageScalarData.constructor.name,
+        },
+        dimensions: [imagePlaneModule.columns, imagePlaneModule.rows],
+        spacing: [
+            imagePlaneModule.columnPixelSpacing,
+            imagePlaneModule.rowPixelSpacing,
+        ],
+        origin: imagePlaneModule.imagePositionPatient,
+        direction: imagePlaneModule.imageOrientationPatient,
+        frameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+    });
+    localImage.referencedImageId = referencedImageId;
+    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, index) => {
         const newOptions = {
-            imageId: options.getDerivedImageId?.(referencedImageId) || `derived:${uuidv4()}`,
+            imageId: options?.getDerivedImageId?.(referencedImageId) ||
+                `derived:${uuidv4()}`,
             ...options,
         };
         derivedImageIds.push(newOptions.imageId);
-        return createAndCacheDerivedImage(referencedImageId, newOptions);
+        return createAndCacheDerivedImage(referencedImageId, {
+            ...newOptions,
+            instanceNumber: index + 1,
+        });
     });
-    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, targetBuffer, skipCreateBuffer, onCacheAdd, frameOfReferenceUID, } = 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 = {
+        frameOfReferenceUID,
+        rows: height,
+        columns: width,
+        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(targetBuffer?.type, 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: targetBuffer?.type,
         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,
         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) {
@@ -199,7 +294,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();
@@ -235,14 +332,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 createAndCacheDerivedLabelmapImages(referencedImageIds, options = {}) {
+    return createAndCacheDerivedImages(referencedImageIds, {
+        ...options,
+        targetBuffer: { type: 'Uint8Array' },
+    });
 }
-export function createAndCacheDerivedSegmentationImage(referencedImageId, options = {
-    targetBufferType: 'Uint8Array',
-}) {
-    return createAndCacheDerivedImage(referencedImageId, options);
+export function createAndCacheDerivedLabelmapImage(referencedImageId, options = {}) {
+    return createAndCacheDerivedImage(referencedImageId, {
+        ...options,
+        targetBuffer: { type: 'Uint8Array' },
+    });
 }
-//# sourceMappingURL=imageLoader.js.map

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

@@ -0,0 +1,6 @@
+import { cornerstoneStreamingImageVolumeLoader } from './cornerstoneStreamingImageVolumeLoader';
+import { cornerstoneStreamingDynamicImageVolumeLoader } from './cornerstoneStreamingDynamicImageVolumeLoader';
+import * as geometryLoader from './geometryLoader';
+import * as imageLoader from './imageLoader';
+import * as volumeLoader from './volumeLoader';
+export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, geometryLoader, imageLoader, volumeLoader, };

package/dist/esm/loaders/index.js

@@ -0,0 +1,7 @@
+import { cornerstoneStreamingImageVolumeLoader } from './cornerstoneStreamingImageVolumeLoader';
+import { cornerstoneStreamingDynamicImageVolumeLoader } from './cornerstoneStreamingDynamicImageVolumeLoader';
+import * as geometryLoader from './geometryLoader';
+import * as imageLoader from './imageLoader';
+import * as volumeLoader from './volumeLoader';
+volumeLoader.registerUnknownVolumeLoader(cornerstoneStreamingImageVolumeLoader);
+export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, geometryLoader, imageLoader, volumeLoader, };

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

@@ -14,8 +14,7 @@ export function createContourSet(geometryId, contourSetData) {
         id: geometryId,
         type: GeometryType.CONTOUR,
         data: contourSet,
-        sizeInBytes: contourSet.getSizeInBytes(),
+        sizeInBytes: contourSet.sizeInBytes,
     };
     return geometry;
 }
-//# sourceMappingURL=createContourSet.js.map

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

@@ -19,4 +19,3 @@ export function validateContourSet(contourSetData) {
         });
     });
 }
-//# sourceMappingURL=validateContourSet.js.map

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

@@ -1,23 +1,21 @@
 import { GeometryType } from '../../../enums';
 import { validateSurface } from './validateSurface';
 import { Surface } from '../../../cache/classes/Surface';
-export function createSurface(geometryId, SurfaceData) {
-    validateSurface(SurfaceData);
+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,
-        },
+        id: surfaceData.id,
+        points: surfaceData.points,
+        polys: surfaceData.polys,
+        color: surfaceData.color,
+        frameOfReferenceUID: surfaceData.frameOfReferenceUID,
+        segmentIndex: surfaceData.segmentIndex ?? 1,
     });
     const geometry = {
         id: geometryId,
         type: GeometryType.SURFACE,
         data: surface,
-        sizeInBytes: surface.getSizeInBytes(),
+        sizeInBytes: surface.sizeInBytes,
     };
     return geometry;
 }
-//# sourceMappingURL=createSurface.js.map

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

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

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

@@ -1,7 +1,14 @@
-export function validateSurface(contourSetData) {
-    const { data } = contourSetData;
-    if (!data.points || !data.polys) {
-        throw new Error('Invalid surface data');
+export function validateSurface(surfaceData) {
+    if (!surfaceData.id) {
+        throw new Error('Surface must have an id');
+    }
+    if (surfaceData.points?.length === 0) {
+        throw new Error('Surface must have non-empty points array');
+    }
+    if (surfaceData.polys?.length === 0) {
+        throw new Error('Surface must have non-empty polys array');
+    }
+    if (!surfaceData.frameOfReferenceUID) {
+        throw new Error('Surface must have a frameOfReferenceUID');
     }
 }
-//# sourceMappingURL=validateSurface.js.map

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

@@ -0,0 +1,40 @@
+import '@kitware/vtk.js/Rendering/Profiles/Volume';
+import type { Point3, Metadata, Mat3, IImageVolume, VolumeLoaderFn, PixelDataTypedArray, PixelDataTypedArrayString, IStreamingImageVolume } from '../types';
+interface VolumeLoaderOptions {
+    imageIds: string[];
+    progressiveRendering?: boolean;
+}
+interface DerivedVolumeOptions {
+    volumeId: string;
+    targetBuffer?: {
+        type: PixelDataTypedArrayString;
+    };
+}
+export interface LocalVolumeOptions {
+    metadata: Metadata;
+    dimensions: Point3;
+    spacing: Point3;
+    origin: Point3;
+    direction: Mat3;
+    scalarData?: PixelDataTypedArray;
+    imageIds?: string[];
+    referencedImageIds?: string[];
+    referencedVolumeId?: string;
+    preventCache?: boolean;
+    targetBuffer?: {
+        type: PixelDataTypedArrayString;
+    };
+}
+export declare function loadVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<IImageVolume>;
+export declare function createAndCacheVolume(volumeId: string, options?: VolumeLoaderOptions): Promise<IImageVolume | IStreamingImageVolume>;
+export declare function createAndCacheDerivedVolume(referencedVolumeId: string, options: DerivedVolumeOptions): IImageVolume;
+export declare function createAndCacheVolumeFromImages(volumeId: string, imageIds: string[]): Promise<IImageVolume>;
+export declare function createAndCacheVolumeFromImagesSync(volumeId: string, imageIds: string[]): 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 createAndCacheDerivedLabelmapVolume(referencedVolumeId: string, options?: DerivedVolumeOptions): IImageVolume;
+export declare function createLocalLabelmapVolume(options: LocalVolumeOptions, volumeId: string, preventCache?: boolean): IImageVolume;
+export {};