@cornerstonejs/core 2.0.0-beta.8 → 2.0.1

package/dist/esm/loaders/volumeLoader.js

@@ -1,56 +1,13 @@
 import '@kitware/vtk.js/Rendering/Profiles/Volume';
-import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import { ImageVolume } from '../cache/classes/ImageVolume';
 import cache from '../cache/cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
-import { createUint16SharedArray, createUint8SharedArray, createFloat32SharedArray, generateVolumePropsFromImageIds, getBufferConfiguration, uuidv4, } from '../utilities';
-import { getConfiguration, getShouldUseSharedArrayBuffer } from '../init';
-import { performCacheOptimizationForVolume, setupCacheOptimizationEventListener, } from '../utilities/cacheUtils';
-function addScalarDataToImageData(imageData, scalarData, dataArrayAttrs) {
-    const scalarArray = vtkDataArray.newInstance({
-        name: `Pixels`,
-        values: scalarData,
-        ...dataArrayAttrs,
-    });
-    imageData.getPointData().setScalars(scalarArray);
-}
-function addScalarDataArraysToImageData(imageData, scalarDataArrays, dataArrayAttrs) {
-    scalarDataArrays.forEach((scalarData, i) => {
-        const vtkScalarArray = vtkDataArray.newInstance({
-            name: `timePoint-${i}`,
-            values: scalarData,
-            ...dataArrayAttrs,
-        });
-        imageData.getPointData().addArray(vtkScalarArray);
-    });
-    imageData.getPointData().setActiveScalars('timePoint-0');
-}
-function createInternalVTKRepresentation(volume) {
-    const { dimensions, metadata, spacing, direction, origin } = volume;
-    const { PhotometricInterpretation } = metadata;
-    let numComponents = 1;
-    if (PhotometricInterpretation === 'RGB') {
-        numComponents = 3;
-    }
-    const imageData = vtkImageData.newInstance();
-    const dataArrayAttrs = { numberOfComponents: numComponents };
-    imageData.setDimensions(dimensions);
-    imageData.setSpacing(spacing);
-    imageData.setDirection(direction);
-    imageData.setOrigin(origin);
-    if (volume.isDynamicVolume()) {
-        const scalarDataArrays = (volume).getScalarDataArrays();
-        addScalarDataArraysToImageData(imageData, scalarDataArrays, dataArrayAttrs);
-    }
-    else {
-        const scalarData = volume.getScalarData();
-        addScalarDataToImageData(imageData, scalarData, dataArrayAttrs);
-    }
-    return imageData;
-}
+import uuidv4 from '../utilities/uuidv4';
+import VoxelManager from '../utilities/VoxelManager';
+import { createAndCacheLocalImage, createAndCacheDerivedImages, } from './imageLoader';
+import { generateVolumePropsFromImageIds } from '../utilities/generateVolumePropsFromImageIds';
 const volumeLoaders = {};
 let unknownVolumeLoader;
 function loadVolumeFromVolumeLoader(volumeId, options) {
@@ -65,7 +22,6 @@ function loadVolumeFromVolumeLoader(volumeId, options) {
         loader = unknownVolumeLoader;
     }
     const volumeLoadObject = loader(volumeId, options);
-    setupCacheOptimizationEventListener(volumeId);
     volumeLoadObject.promise.then(function (volume) {
         triggerEvent(eventTarget, Events.VOLUME_LOADED, { volume });
     }, function (error) {
@@ -87,7 +43,6 @@ export function loadVolume(volumeId, options = { imageIds: [] }) {
     }
     volumeLoadObject = loadVolumeFromVolumeLoader(volumeId, options);
     return volumeLoadObject.promise.then((volume) => {
-        volume.imageData = createInternalVTKRepresentation(volume);
         return volume;
     });
 }
@@ -100,156 +55,154 @@ export async function createAndCacheVolume(volumeId, options) {
         return volumeLoadObject.promise;
     }
     volumeLoadObject = loadVolumeFromVolumeLoader(volumeId, options);
-    volumeLoadObject.promise.then((volume) => {
-        volume.imageData = createInternalVTKRepresentation(volume);
-    });
-    cache.putVolumeLoadObject(volumeId, volumeLoadObject).catch((err) => {
-        throw err;
-    });
+    cache.putVolumeLoadObject(volumeId, volumeLoadObject);
     return volumeLoadObject.promise;
 }
-export async function createAndCacheDerivedVolume(referencedVolumeId, options) {
+export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     const referencedVolume = cache.getVolume(referencedVolumeId);
     if (!referencedVolume) {
         throw new Error(`Cannot created derived volume: Referenced volume with id ${referencedVolumeId} does not exist.`);
     }
     let { volumeId } = options;
-    const { targetBuffer } = options;
     if (volumeId === undefined) {
         volumeId = uuidv4();
     }
     const { metadata, dimensions, spacing, origin, direction } = referencedVolume;
-    const scalarData = referencedVolume.getScalarData();
-    const scalarLength = scalarData.length;
-    const { volumeScalarData, numBytes } = generateVolumeScalarData(targetBuffer, scalarLength);
-    const scalarArray = vtkDataArray.newInstance({
-        name: 'Pixels',
-        numberOfComponents: 1,
-        values: volumeScalarData,
+    const referencedImageIds = referencedVolume.isDynamicVolume()
+        ? referencedVolume.getCurrentTimePointImageIds()
+        : referencedVolume.imageIds ?? [];
+    const derivedImages = createAndCacheDerivedImages(referencedImageIds, {
+        targetBuffer: options.targetBuffer,
     });
-    const derivedImageData = vtkImageData.newInstance();
-    derivedImageData.setDimensions(dimensions);
-    derivedImageData.setSpacing(spacing);
-    derivedImageData.setDirection(direction);
-    derivedImageData.setOrigin(origin);
-    derivedImageData.getPointData().setScalars(scalarArray);
+    const dataType = derivedImages[0].dataType;
+    const derivedVolumeImageIds = derivedImages.map((image) => image.imageId);
     const derivedVolume = new ImageVolume({
         volumeId,
+        dataType,
         metadata: structuredClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
         direction,
-        imageData: derivedImageData,
-        scalarData: volumeScalarData,
-        sizeInBytes: numBytes,
-        imageIds: [],
         referencedVolumeId,
+        imageIds: derivedVolumeImageIds,
+        referencedImageIds: referencedVolume.imageIds ?? [],
     });
-    const volumeLoadObject = {
-        promise: Promise.resolve(derivedVolume),
-    };
-    await cache.putVolumeLoadObject(volumeId, volumeLoadObject);
+    cache.putVolumeSync(volumeId, derivedVolume);
     return derivedVolume;
 }
-export function createLocalVolume(options, volumeId, preventCache = false) {
-    const { metadata, dimensions, spacing, origin, direction, targetBuffer } = options;
-    let { scalarData } = options;
-    const validDataTypes = [
-        'Uint8Array',
-        'Float32Array',
-        'Uint16Array',
-        'Int16Array',
-    ];
-    const scalarLength = dimensions[0] * dimensions[1] * dimensions[2];
-    if (!scalarData || !validDataTypes.includes(scalarData.constructor.name)) {
-        if (!targetBuffer?.type || !validDataTypes.includes(targetBuffer.type)) {
-            throw new Error('createLocalVolume: parameter scalarData must be provided and must be either Uint8Array, Float32Array, Uint16Array or Int16Array');
-        }
-        ({ volumeScalarData: scalarData } = generateVolumeScalarData(targetBuffer, scalarLength));
+export async function createAndCacheVolumeFromImages(volumeId, imageIds) {
+    if (imageIds === undefined) {
+        throw new Error('createAndCacheVolumeFromImages: parameter imageIds must not be undefined');
     }
     if (volumeId === undefined) {
-        volumeId = uuidv4();
+        throw new Error('createAndCacheVolumeFromImages: parameter volumeId must not be undefined');
     }
     const cachedVolume = cache.getVolume(volumeId);
     if (cachedVolume) {
         return cachedVolume;
     }
-    const numBytes = scalarData ? scalarData.buffer.byteLength : scalarLength * 4;
-    const isCacheable = cache.isCacheable(numBytes);
-    if (!isCacheable) {
-        throw new Error(Events.CACHE_SIZE_EXCEEDED);
-    }
-    const scalarArray = vtkDataArray.newInstance({
-        name: 'Pixels',
-        numberOfComponents: 1,
-        values: scalarData,
-    });
-    const imageData = vtkImageData.newInstance();
-    imageData.setDimensions(dimensions);
-    imageData.setSpacing(spacing);
-    imageData.setDirection(direction);
-    imageData.setOrigin(origin);
-    imageData.getPointData().setScalars(scalarArray);
-    const derivedVolume = new ImageVolume({
-        volumeId,
-        metadata: structuredClone(metadata),
-        dimensions: [dimensions[0], dimensions[1], dimensions[2]],
-        spacing,
-        origin,
-        direction,
-        imageData: imageData,
-        scalarData,
-        sizeInBytes: numBytes,
-        referencedImageIds: options.referencedImageIds || [],
-        referencedVolumeId: options.referencedVolumeId,
-        imageIds: options.imageIds || [],
-    });
-    if (preventCache) {
-        return derivedVolume;
+    const imageIdsToLoad = imageIds.filter((imageId) => !cache.getImage(imageId));
+    if (imageIdsToLoad.length === 0) {
+        return createAndCacheVolumeFromImagesSync(volumeId, imageIds);
     }
-    const volumeLoadObject = {
-        promise: Promise.resolve(derivedVolume),
-    };
-    cache.putVolumeLoadObject(volumeId, volumeLoadObject);
-    return derivedVolume;
+    const volume = (await createAndCacheVolume(volumeId, {
+        imageIds,
+    }));
+    return volume;
 }
-export async function createAndCacheVolumeFromImages(volumeId, imageIds, options = {}) {
-    const { preventCache = false } = options;
+export function createAndCacheVolumeFromImagesSync(volumeId, imageIds) {
     if (imageIds === undefined) {
-        throw new Error('createAndCacheVolumeFromImages: parameter imageIds must not be undefined');
+        throw new Error('createAndCacheVolumeFromImagesSync: parameter imageIds must not be undefined');
     }
     if (volumeId === undefined) {
-        throw new Error('createAndCacheVolumeFromImages: parameter volumeId must not be undefined');
+        throw new Error('createAndCacheVolumeFromImagesSync: parameter volumeId must not be undefined');
     }
     const cachedVolume = cache.getVolume(volumeId);
     if (cachedVolume) {
-        return Promise.resolve(cachedVolume);
+        return cachedVolume;
     }
     const volumeProps = generateVolumePropsFromImageIds(imageIds, volumeId);
-    const imagePromises = volumeProps.imageIds.map((imageId, imageIdIndex) => {
-        const imageLoadObject = cache.getImageLoadObject(imageId);
-        return imageLoadObject.promise.then((image) => {
-            const pixelData = image.getPixelData();
-            const offset = imageIdIndex * image.rows * image.columns;
-            volumeProps.scalarData.set(pixelData, offset);
+    const derivedVolume = new ImageVolume({
+        volumeId,
+        dataType: volumeProps.dataType,
+        metadata: structuredClone(volumeProps.metadata),
+        dimensions: volumeProps.dimensions,
+        spacing: volumeProps.spacing,
+        origin: volumeProps.origin,
+        direction: volumeProps.direction,
+        referencedVolumeId: volumeProps.referencedVolumeId,
+        imageIds: volumeProps.imageIds,
+        referencedImageIds: volumeProps.referencedImageIds,
+    });
+    cache.putVolumeSync(volumeId, derivedVolume);
+    return derivedVolume;
+}
+export function createLocalVolume(volumeId, options = {}) {
+    const { metadata, dimensions, spacing, origin, direction, scalarData, targetBuffer, preventCache = false, } = options;
+    const cachedVolume = cache.getVolume(volumeId);
+    if (cachedVolume) {
+        return cachedVolume;
+    }
+    const sliceLength = dimensions[0] * dimensions[1];
+    const dataType = scalarData
+        ? scalarData.constructor.name
+        : targetBuffer?.type ?? 'Float32Array';
+    const totalNumberOfVoxels = sliceLength * dimensions[2];
+    let byteLength;
+    switch (dataType) {
+        case 'Uint8Array':
+        case 'Int8Array':
+            byteLength = totalNumberOfVoxels;
+            break;
+        case 'Uint16Array':
+        case 'Int16Array':
+            byteLength = totalNumberOfVoxels * 2;
+            break;
+        case 'Float32Array':
+            byteLength = totalNumberOfVoxels * 4;
+            break;
+    }
+    const isCacheable = cache.isCacheable(byteLength);
+    if (!isCacheable) {
+        throw new Error(`Cannot created derived volume: Volume with id ${volumeId} is not cacheable.`);
+    }
+    const imageIds = [];
+    const derivedImages = [];
+    for (let i = 0; i < dimensions[2]; i++) {
+        const imageId = `${volumeId}_slice_${i}`;
+        imageIds.push(imageId);
+        const sliceData = scalarData.subarray(i * sliceLength, (i + 1) * sliceLength);
+        const derivedImage = createAndCacheLocalImage(imageId, {
+            scalarData: sliceData,
+            dimensions: [dimensions[0], dimensions[1]],
+            spacing: [spacing[0], spacing[1]],
+            origin,
+            direction,
+            targetBuffer: { type: dataType },
         });
+        derivedImages.push(derivedImage);
+    }
+    const imageVolume = new ImageVolume({
+        volumeId,
+        metadata: structuredClone(metadata),
+        dimensions: [dimensions[0], dimensions[1], dimensions[2]],
+        spacing,
+        origin,
+        direction,
+        imageIds,
+        dataType,
     });
-    await Promise.all(imagePromises);
-    const volume = new ImageVolume({
-        ...volumeProps,
-        referencedImageIds: imageIds,
-        ...options,
+    const voxelManager = VoxelManager.createImageVolumeVoxelManager({
+        imageIds,
+        dimensions,
+        numberOfComponents: 1,
     });
-    performCacheOptimizationForVolume(volume);
-    const volumeLoadObject = {
-        promise: Promise.resolve(volume),
-    };
-    if (preventCache) {
-        return volumeLoadObject.promise;
+    imageVolume.voxelManager = voxelManager;
+    if (!preventCache) {
+        cache.putVolumeSync(volumeId, imageVolume);
     }
-    cache.putVolumeLoadObject(volumeId, volumeLoadObject);
-    return volumeLoadObject.promise;
+    return imageVolume;
 }
 export function registerVolumeLoader(scheme, volumeLoader) {
     volumeLoaders[scheme] = volumeLoader;
@@ -265,52 +218,15 @@ export function registerUnknownVolumeLoader(volumeLoader) {
 export function getUnknownVolumeLoaderSchema() {
     return unknownVolumeLoader.name;
 }
-export async function createAndCacheDerivedSegmentationVolume(referencedVolumeId, options = {}) {
+export function createAndCacheDerivedLabelmapVolume(referencedVolumeId, options = {}) {
     return createAndCacheDerivedVolume(referencedVolumeId, {
         ...options,
-        targetBuffer: {
-            type: 'Uint8Array',
-        },
+        targetBuffer: { type: 'Uint8Array' },
     });
 }
-export async function createLocalSegmentationVolume(options, volumeId, preventCache = false) {
+export function createLocalLabelmapVolume(options, volumeId, preventCache = false) {
     if (!options.scalarData) {
         options.scalarData = new Uint8Array(options.dimensions[0] * options.dimensions[1] * options.dimensions[2]);
     }
-    return createLocalVolume(options, volumeId, preventCache);
-}
-function generateVolumeScalarData(targetBuffer, scalarLength) {
-    const { useNorm16Texture } = getConfiguration().rendering;
-    const { TypedArrayConstructor, numBytes } = getBufferConfiguration(targetBuffer?.type, scalarLength, {
-        use16BitTexture: useNorm16Texture,
-        isVolumeBuffer: true,
-    });
-    const isCacheable = cache.isCacheable(numBytes);
-    if (!isCacheable) {
-        throw new Error(Events.CACHE_SIZE_EXCEEDED);
-    }
-    let volumeScalarData;
-    if (targetBuffer?.sharedArrayBuffer ?? getShouldUseSharedArrayBuffer()) {
-        switch (targetBuffer.type) {
-            case 'Float32Array':
-                volumeScalarData = createFloat32SharedArray(scalarLength);
-                break;
-            case 'Uint8Array':
-                volumeScalarData = createUint8SharedArray(scalarLength);
-                break;
-            case 'Uint16Array':
-                volumeScalarData = createUint16SharedArray(scalarLength);
-                break;
-            case 'Int16Array':
-                volumeScalarData = createUint16SharedArray(scalarLength);
-                break;
-            default:
-                throw new Error('generateVolumeScalarData: SharedArrayBuffer is not supported for the specified target buffer type');
-        }
-    }
-    else {
-        volumeScalarData = new TypedArrayConstructor(scalarLength);
-    }
-    return { volumeScalarData, numBytes };
+    return createLocalVolume(volumeId, { ...options, preventCache });
 }
-//# sourceMappingURL=volumeLoader.js.map

package/dist/esm/metaData.d.ts

@@ -0,0 +1,5 @@
+export declare function addProvider(provider: (type: string, ...query: string[]) => unknown, priority?: number): void;
+export declare function removeProvider(provider: (type: string, query: unknown) => unknown): void;
+export declare function removeAllProviders(): void;
+declare function getMetaData(type: string, ...queries: any[]): any;
+export { getMetaData as get };

package/dist/esm/metaData.js

@@ -33,4 +33,3 @@ function getMetaData(type, ...queries) {
     }
 }
 export { getMetaData as get };
-//# sourceMappingURL=metaData.js.map

package/dist/esm/requestPool/imageLoadPoolManager.d.ts

@@ -0,0 +1,3 @@
+import { RequestPoolManager } from './requestPoolManager';
+declare const imageLoadPoolManager: RequestPoolManager;
+export default imageLoadPoolManager;

package/dist/esm/requestPool/imageLoadPoolManager.js

@@ -6,4 +6,3 @@ imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Interaction, 1000);
 imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Thumbnail, 1000);
 imageLoadPoolManager.setMaxSimultaneousRequests(RequestType.Prefetch, 1000);
 export default imageLoadPoolManager;
-//# sourceMappingURL=imageLoadPoolManager.js.map

package/dist/esm/requestPool/imageRetrievalPoolManager.d.ts

@@ -0,0 +1,3 @@
+import { RequestPoolManager } from './requestPoolManager';
+declare const imageRetrievalPoolManager: RequestPoolManager;
+export default imageRetrievalPoolManager;

package/dist/esm/requestPool/imageRetrievalPoolManager.js

@@ -6,4 +6,3 @@ imageRetrievalPoolManager.setMaxSimultaneousRequests(RequestType.Thumbnail, 200)
 imageRetrievalPoolManager.setMaxSimultaneousRequests(RequestType.Prefetch, 200);
 imageRetrievalPoolManager.grabDelay = 0;
 export default imageRetrievalPoolManager;
-//# sourceMappingURL=imageRetrievalPoolManager.js.map

package/dist/esm/requestPool/requestPoolManager.d.ts

@@ -0,0 +1,42 @@
+import RequestType from '../enums/RequestType';
+import type { IImage } from '../types';
+interface AdditionalDetails {
+    imageId?: string;
+    volumeId?: string;
+}
+interface RequestDetailsInterface {
+    requestFn: () => Promise<IImage | void>;
+    type: RequestType;
+    additionalDetails: AdditionalDetails;
+}
+type RequestPool = {
+    [name in RequestType]: Record<number, RequestDetailsInterface[]>;
+};
+declare class RequestPoolManager {
+    private id;
+    private awake;
+    private requestPool;
+    private numRequests;
+    maxNumRequests: {
+        [RequestType.Interaction]: number;
+        [RequestType.Thumbnail]: number;
+        [RequestType.Prefetch]: number;
+        [RequestType.Compute]: number;
+    };
+    grabDelay: number;
+    private timeoutHandle;
+    constructor(id?: string);
+    setMaxSimultaneousRequests(type: RequestType, maxNumRequests: number): void;
+    getMaxSimultaneousRequests(type: RequestType): number;
+    destroy(): void;
+    addRequest(requestFn: () => Promise<IImage | void>, type: RequestType, additionalDetails: Record<string, unknown>, priority?: number): void;
+    filterRequests(filterFunction: (requestDetails: RequestDetailsInterface) => boolean): void;
+    clearRequestStack(type: string): void;
+    private sendRequests;
+    private getNextRequest;
+    protected startGrabbing(): void;
+    protected startAgain(): void;
+    protected getSortedPriorityGroups(type: string): number[];
+    getRequestPool(): RequestPool;
+}
+export { RequestPoolManager };

package/dist/esm/requestPool/requestPoolManager.js

@@ -1,33 +1,33 @@
 import RequestType from '../enums/RequestType';
-import { uuidv4 } from '../utilities';
+import uuidv4 from '../utilities/uuidv4';
 class RequestPoolManager {
     constructor(id) {
         this.numRequests = {
-            interaction: 0,
-            thumbnail: 0,
-            prefetch: 0,
-            compute: 0,
+            [RequestType.Interaction]: 0,
+            [RequestType.Thumbnail]: 0,
+            [RequestType.Prefetch]: 0,
+            [RequestType.Compute]: 0,
         };
         this.id = id ? id : uuidv4();
         this.requestPool = {
-            interaction: { 0: [] },
-            thumbnail: { 0: [] },
-            prefetch: { 0: [] },
-            compute: { 0: [] },
+            [RequestType.Interaction]: { 0: [] },
+            [RequestType.Thumbnail]: { 0: [] },
+            [RequestType.Prefetch]: { 0: [] },
+            [RequestType.Compute]: { 0: [] },
         };
         this.grabDelay = 5;
         this.awake = false;
         this.numRequests = {
-            interaction: 0,
-            thumbnail: 0,
-            prefetch: 0,
-            compute: 0,
+            [RequestType.Interaction]: 0,
+            [RequestType.Thumbnail]: 0,
+            [RequestType.Prefetch]: 0,
+            [RequestType.Compute]: 0,
         };
         this.maxNumRequests = {
-            interaction: 6,
-            thumbnail: 6,
-            prefetch: 5,
-            compute: 1000,
+            [RequestType.Interaction]: 6,
+            [RequestType.Thumbnail]: 6,
+            [RequestType.Prefetch]: 5,
+            [RequestType.Compute]: 1000,
         };
     }
     setMaxSimultaneousRequests(type, maxNumRequests) {
@@ -153,4 +153,3 @@ class RequestPoolManager {
     }
 }
 export { RequestPoolManager };
-//# sourceMappingURL=requestPoolManager.js.map

package/dist/esm/types/AABB2.d.ts

@@ -0,0 +1,7 @@
+interface AABB2 {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}
+export type { AABB2 as default };

package/dist/esm/types/AABB2.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AABB2.js.map

package/dist/esm/types/AABB3.d.ts

@@ -0,0 +1,9 @@
+interface AABB3 {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+}
+export type { AABB3 as default };

package/dist/esm/types/AABB3.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AABB3.js.map

package/dist/esm/types/ActorSliceRange.d.ts

@@ -0,0 +1,11 @@
+import type { VolumeActor } from './IActor';
+import type Point3 from './Point3';
+interface ActorSliceRange {
+    actor: VolumeActor;
+    viewPlaneNormal: Point3;
+    focalPoint: Point3;
+    min: number;
+    max: number;
+    current: number;
+}
+export type { ActorSliceRange as default };

package/dist/esm/types/ActorSliceRange.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ActorSliceRange.js.map

package/dist/esm/types/AffineMatrix.d.ts

@@ -0,0 +1,27 @@
+type AffineMatrix = [
+    [
+        number,
+        number,
+        number,
+        number
+    ],
+    [
+        number,
+        number,
+        number,
+        number
+    ],
+    [
+        number,
+        number,
+        number,
+        number
+    ],
+    [
+        number,
+        number,
+        number,
+        number
+    ]
+];
+export type { AffineMatrix };

package/dist/esm/types/AffineMatrix.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AffineMatrix.js.map

package/dist/esm/types/BoundsIJK.d.ts

@@ -0,0 +1,3 @@
+import type Point2 from './Point2';
+type BoundsIJK = [Point2, Point2, Point2];
+export type { BoundsIJK as default };

package/dist/esm/types/BoundsIJK.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=BoundsIJK.js.map

package/dist/esm/types/BoundsLPS.d.ts

@@ -0,0 +1,3 @@
+import type Point2 from './Point3';
+type BoundsLPS = [Point2, Point2, Point2];
+export type { BoundsLPS };

package/dist/esm/types/BoundsLPS.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=BoundsLPS.js.map

package/dist/esm/types/CPUFallbackColormap.d.ts

@@ -0,0 +1,20 @@
+import type Point4 from './Point4';
+import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
+interface CPUFallbackColormap {
+    getId: () => string;
+    getColorSchemeName: () => string;
+    setColorSchemeName: (name: string) => void;
+    getNumberOfColors: () => number;
+    setNumberOfColors: (numColors: number) => void;
+    getColor: (index: number) => Point4;
+    getColorRepeating: (index: number) => Point4;
+    setColor: (index: number, rgba: Point4) => void;
+    addColor: (rgba: Point4) => void;
+    insertColor: (index: number, rgba: Point4) => void;
+    removeColor: (index: number) => void;
+    clearColors: () => void;
+    buildLookupTable: (lut: CPUFallbackLookupTable) => void;
+    createLookupTable: () => CPUFallbackLookupTable;
+    isValidIndex: (index: number) => boolean;
+}
+export type { CPUFallbackColormap as default };

package/dist/esm/types/CPUFallbackColormap.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=CPUFallbackColormap.js.map

package/dist/esm/types/CPUFallbackColormapData.d.ts

@@ -0,0 +1,10 @@
+import type Point4 from './Point4';
+interface CPUFallbackColormapData {
+    name: string;
+    numOfColors?: number;
+    colors?: Point4[];
+    segmentedData?: unknown;
+    numColors?: number;
+    gamma?: number;
+}
+export type { CPUFallbackColormapData as default };