@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

package/dist/esm/utilities/VoxelManager.js

@@ -1,8 +1,13 @@
 import cache from '../cache/cache';
+import { InterpolationType } from '../enums';
+import { mat3, vec3 } from 'gl-matrix';
 import RLEVoxelMap from './RLEVoxelMap';
 import isEqual from './isEqual';
 import { iterateOverPointsInShapeVoxelManager } from './pointInShapeCallback';
 const DEFAULT_RLE_SIZE = 5 * 1024;
+const worldToIndexDeltaScratch = [0, 0, 0];
+const worldToIndexResultScratch = [0, 0, 0];
+const worldToIndexTransformCache = new WeakMap();
 export default class VoxelManager {
     get id() {
         return this._id;
@@ -17,11 +22,10 @@ export default class VoxelManager {
         this.scalarData = null;
         this._sliceDataCache = null;
         this.getAtIJK = (i, j, k) => {
-            const index = this.toIndex([i, j, k]);
-            return this._get(index);
+            return this._get(i + j * this.width + k * this.frameSize);
         };
         this.setAtIJK = (i, j, k, v) => {
-            const index = this.toIndex([i, j, k]);
+            const index = i + j * this.width + k * this.frameSize;
             const changed = this._set(index, v);
             if (changed !== false) {
                 this.modifiedSlices.add(k);
@@ -339,6 +343,94 @@ export default class VoxelManager {
         bounds[2][0] = Math.min(point[2], bounds[2][0]);
         bounds[2][1] = Math.max(point[2], bounds[2][1]);
     }
+    static getWorldToIndexTransform(volumeGeometry) {
+        const cachedTransform = worldToIndexTransformCache.get(volumeGeometry);
+        if (cachedTransform) {
+            return cachedTransform;
+        }
+        const direction = volumeGeometry.direction;
+        const spacing = volumeGeometry.spacing;
+        const transform = mat3.fromValues(direction[0] / spacing[0], direction[3] / spacing[1], direction[6] / spacing[2], direction[1] / spacing[0], direction[4] / spacing[1], direction[7] / spacing[2], direction[2] / spacing[0], direction[5] / spacing[1], direction[8] / spacing[2]);
+        worldToIndexTransformCache.set(volumeGeometry, transform);
+        return transform;
+    }
+    static worldToIndexContinuous(volumeGeometry, worldPos) {
+        const origin = volumeGeometry.origin;
+        worldToIndexDeltaScratch[0] = worldPos[0] - origin[0];
+        worldToIndexDeltaScratch[1] = worldPos[1] - origin[1];
+        worldToIndexDeltaScratch[2] = worldPos[2] - origin[2];
+        const continuousIndex = vec3.transformMat3(worldToIndexResultScratch, worldToIndexDeltaScratch, VoxelManager.getWorldToIndexTransform(volumeGeometry));
+        return [continuousIndex[0], continuousIndex[1], continuousIndex[2]];
+    }
+    static sampleAtWorldCoordinates(volume, worldX, worldY, worldZ, interpolationType = InterpolationType.LINEAR) {
+        if (!volume.voxelManager) {
+            return NaN;
+        }
+        const origin = volume.origin;
+        worldToIndexDeltaScratch[0] = worldX - origin[0];
+        worldToIndexDeltaScratch[1] = worldY - origin[1];
+        worldToIndexDeltaScratch[2] = worldZ - origin[2];
+        const continuousIndex = vec3.transformMat3(worldToIndexResultScratch, worldToIndexDeltaScratch, VoxelManager.getWorldToIndexTransform(volume));
+        return VoxelManager.sampleAtContinuousCoordinates(volume.voxelManager, volume.dimensions, continuousIndex[0], continuousIndex[1], continuousIndex[2], interpolationType);
+    }
+    static sampleAtWorld(volume, worldPos, interpolationType = InterpolationType.LINEAR) {
+        return VoxelManager.sampleAtWorldCoordinates(volume, worldPos[0], worldPos[1], worldPos[2], interpolationType);
+    }
+    static sampleAtContinuousIndex(voxelManager, dimensions, continuousIndex, interpolationType = InterpolationType.LINEAR) {
+        return VoxelManager.sampleAtContinuousCoordinates(voxelManager, dimensions, continuousIndex[0], continuousIndex[1], continuousIndex[2], interpolationType);
+    }
+    static sampleAtContinuousCoordinates(voxelManager, dimensions, iC, jC, kC, interpolationType) {
+        return interpolationType === InterpolationType.NEAREST
+            ? VoxelManager.sampleNearestAtContinuousCoordinates(voxelManager, dimensions, iC, jC, kC)
+            : VoxelManager.sampleLinearAtContinuousCoordinates(voxelManager, dimensions, iC, jC, kC);
+    }
+    static sampleNearestAtContinuousCoordinates(voxelManager, dimensions, iC, jC, kC) {
+        const i = Math.floor(iC + 0.5 - 1e-6);
+        const j = Math.floor(jC + 0.5 - 1e-6);
+        const k = Math.floor(kC + 0.5 - 1e-6);
+        const dx = dimensions[0];
+        const dy = dimensions[1];
+        const dz = dimensions[2];
+        if (i < 0 || i >= dx || j < 0 || j >= dy || k < 0 || k >= dz) {
+            return NaN;
+        }
+        return Number(voxelManager.getAtIJK(i, j, k));
+    }
+    static sampleLinearAtContinuousCoordinates(voxelManager, dimensions, i, j, k) {
+        const dx = dimensions[0];
+        const dy = dimensions[1];
+        const dz = dimensions[2];
+        if (i < 0 || i > dx - 1 || j < 0 || j > dy - 1 || k < 0 || k > dz - 1) {
+            return NaN;
+        }
+        const i0 = Math.floor(i);
+        const j0 = Math.floor(j);
+        const k0 = Math.floor(k);
+        const i1 = Math.min(i0 + 1, dx - 1);
+        const j1 = Math.min(j0 + 1, dy - 1);
+        const k1 = Math.min(k0 + 1, dz - 1);
+        const di = i - i0;
+        const dj = j - j0;
+        const dk = k - k0;
+        const oneMinusDi = 1 - di;
+        const oneMinusDj = 1 - dj;
+        const oneMinusDk = 1 - dk;
+        const c000 = Number(voxelManager.getAtIJK(i0, j0, k0));
+        const c100 = Number(voxelManager.getAtIJK(i1, j0, k0));
+        const c010 = Number(voxelManager.getAtIJK(i0, j1, k0));
+        const c110 = Number(voxelManager.getAtIJK(i1, j1, k0));
+        const c001 = Number(voxelManager.getAtIJK(i0, j0, k1));
+        const c101 = Number(voxelManager.getAtIJK(i1, j0, k1));
+        const c011 = Number(voxelManager.getAtIJK(i0, j1, k1));
+        const c111 = Number(voxelManager.getAtIJK(i1, j1, k1));
+        const c00 = c000 * oneMinusDi + c100 * di;
+        const c10 = c010 * oneMinusDi + c110 * di;
+        const c01 = c001 * oneMinusDi + c101 * di;
+        const c11 = c011 * oneMinusDi + c111 * di;
+        const c0 = c00 * oneMinusDj + c10 * dj;
+        const c1 = c01 * oneMinusDj + c11 * dj;
+        return c0 * oneMinusDk + c1 * dk;
+    }
     addPoint(point) {
         const index = Array.isArray(point)
             ? point[0] + this.width * point[1] + this.frameSize * point[2]
@@ -401,37 +493,75 @@ export default class VoxelManager {
     }
     static createImageVolumeVoxelManager({ dimensions, imageIds, numberOfComponents = 1, id, }) {
         const pixelsPerSlice = dimensions[0] * dimensions[1];
-        function getPixelInfo(index) {
-            const sliceIndex = Math.floor(index / pixelsPerSlice);
-            if (sliceIndex < 0 || sliceIndex >= dimensions[2]) {
-                return {};
+        const depth = dimensions[2];
+        const sliceVoxelManagers = new Array(depth);
+        let lastSliceIndex = -1;
+        let lastSliceVoxelManager = null;
+        const warnedMissingImageIds = new Set();
+        const warnedMissingImages = new Set();
+        const resolveSliceVoxelManager = (sliceIndex) => {
+            if (sliceIndex < 0 || sliceIndex >= depth) {
+                return null;
+            }
+            const cachedVoxelManager = sliceVoxelManagers[sliceIndex];
+            if (cachedVoxelManager !== undefined) {
+                return cachedVoxelManager;
             }
             const imageId = imageIds[sliceIndex];
             if (!imageId) {
-                console.warn(`ImageId not found for sliceIndex: ${sliceIndex}`);
-                return { pixelData: null, pixelIndex: null };
+                if (!warnedMissingImageIds.has(sliceIndex)) {
+                    warnedMissingImageIds.add(sliceIndex);
+                    console.warn(`ImageId not found for sliceIndex: ${sliceIndex}`);
+                }
+                sliceVoxelManagers[sliceIndex] = null;
+                return null;
             }
             const image = cache.getImage(imageId);
-            if (!image) {
-                console.warn(`Image not found for imageId: ${imageId}`);
-                return { pixelData: null, pixelIndex: null };
+            if (!image?.voxelManager) {
+                if (!warnedMissingImages.has(imageId)) {
+                    warnedMissingImages.add(imageId);
+                    console.warn(`Image not found for imageId: ${imageId}`);
+                }
+                return null;
             }
-            const voxelManager = image.voxelManager;
-            const pixelIndex = index % pixelsPerSlice;
-            return { voxelManager, pixelIndex };
-        }
+            const imageVoxelManager = image.voxelManager;
+            sliceVoxelManagers[sliceIndex] = imageVoxelManager;
+            return imageVoxelManager;
+        };
         function getVoxelValue(index) {
-            const { voxelManager: imageVoxelManager, pixelIndex } = getPixelInfo(index);
-            if (!imageVoxelManager || pixelIndex === null) {
+            const sliceIndex = Math.floor(index / pixelsPerSlice);
+            if (sliceIndex < 0 || sliceIndex >= depth) {
                 return null;
             }
+            const imageVoxelManager = sliceIndex === lastSliceIndex
+                ? lastSliceVoxelManager
+                : resolveSliceVoxelManager(sliceIndex);
+            if (!imageVoxelManager) {
+                return null;
+            }
+            if (sliceIndex !== lastSliceIndex) {
+                lastSliceIndex = sliceIndex;
+                lastSliceVoxelManager = imageVoxelManager;
+            }
+            const pixelIndex = index - sliceIndex * pixelsPerSlice;
             return imageVoxelManager.getAtIndex(pixelIndex);
         }
         function setVoxelValue(index, v) {
-            const { voxelManager: imageVoxelManager, pixelIndex } = getPixelInfo(index);
-            if (!imageVoxelManager || pixelIndex === null) {
+            const sliceIndex = Math.floor(index / pixelsPerSlice);
+            if (sliceIndex < 0 || sliceIndex >= depth) {
+                return false;
+            }
+            const imageVoxelManager = sliceIndex === lastSliceIndex
+                ? lastSliceVoxelManager
+                : resolveSliceVoxelManager(sliceIndex);
+            if (!imageVoxelManager) {
                 return false;
             }
+            if (sliceIndex !== lastSliceIndex) {
+                lastSliceIndex = sliceIndex;
+                lastSliceVoxelManager = imageVoxelManager;
+            }
+            const pixelIndex = index - sliceIndex * pixelsPerSlice;
             const currentValue = imageVoxelManager.getAtIndex(pixelIndex);
             const isChanged = !isEqual(v, currentValue);
             if (!isChanged) {
@@ -441,8 +571,8 @@ export default class VoxelManager {
             return true;
         }
         const _getConstructor = () => {
-            const { voxelManager: imageVoxelManager, pixelIndex } = getPixelInfo(0);
-            if (!imageVoxelManager || pixelIndex === null) {
+            const imageVoxelManager = resolveSliceVoxelManager(0);
+            if (!imageVoxelManager) {
                 return null;
             }
             return imageVoxelManager.getConstructor();
@@ -454,6 +584,11 @@ export default class VoxelManager {
             _getConstructor,
             _id: id || 'createImageVolumeVoxelManager',
         });
+        voxelManager.invalidateCache = () => {
+            sliceVoxelManagers.fill(undefined);
+            lastSliceIndex = -1;
+            lastSliceVoxelManager = null;
+        };
         voxelManager.getMiddleSliceData = () => {
             const middleSliceIndex = Math.floor(dimensions[2] / 2);
             return voxelManager.getSliceData({
@@ -488,8 +623,8 @@ export default class VoxelManager {
             return [minValue, maxValue];
         };
         voxelManager._getScalarDataLength = () => {
-            const { voxelManager: imageVoxelManager, pixelIndex } = getPixelInfo(0);
-            if (!imageVoxelManager || pixelIndex === null) {
+            const imageVoxelManager = resolveSliceVoxelManager(0);
+            if (!imageVoxelManager) {
                 return 0;
             }
             return imageVoxelManager.getScalarDataLength() * dimensions[2];
@@ -503,8 +638,8 @@ export default class VoxelManager {
             const scalarData = new ScalarDataConstructor(dataLength);
             const sliceSize = dimensions[0] * dimensions[1] * numberOfComponents;
             for (let sliceIndex = 0; sliceIndex < dimensions[2]; sliceIndex++) {
-                const { voxelManager: imageVoxelManager, pixelIndex } = getPixelInfo((sliceIndex * sliceSize) / numberOfComponents);
-                if (imageVoxelManager && pixelIndex !== null) {
+                const imageVoxelManager = resolveSliceVoxelManager(sliceIndex);
+                if (imageVoxelManager) {
                     const sliceStart = sliceIndex * sliceSize;
                     const pixelData = imageVoxelManager.getScalarData();
                     if (numberOfComponents === 1) {
@@ -527,7 +662,7 @@ export default class VoxelManager {
             let minValue = Infinity;
             let maxValue = -Infinity;
             for (let sliceIndex = 0; sliceIndex < dimensions[2]; sliceIndex++) {
-                const { voxelManager: imageVoxelManager } = getPixelInfo((sliceIndex * sliceSize) / numberOfComponents);
+                const imageVoxelManager = resolveSliceVoxelManager(sliceIndex);
                 if (imageVoxelManager && SliceDataConstructor) {
                     const sliceStart = sliceIndex * sliceSize;
                     const sliceEnd = sliceStart + sliceSize;

package/dist/esm/utilities/WSIUtilities.d.ts

@@ -0,0 +1,119 @@
+import type { Point3 } from '../types';
+export interface WSIImageMetadataSource {
+    NumberOfFrames?: number;
+    TotalPixelMatrixColumns: number;
+    TotalPixelMatrixRows: number;
+    ImageOrientationSlide?: number[];
+    ImagedVolumeWidth?: number;
+    ImagedVolumeHeight?: number;
+    ImagedVolumeDepth?: number;
+    TotalPixelMatrixOriginSequence?: Array<{
+        XOffsetInSlideCoordinateSystem?: number;
+        YOffsetInSlideCoordinateSystem?: number;
+        ZOffsetInSlideCoordinateSystem?: number;
+    }>;
+    ['00080008']?: {
+        Value?: string[];
+    };
+    ['00200052']?: {
+        Value?: string[];
+    };
+    isMultiframe?: unknown;
+    frameNumber?: unknown;
+    [key: string]: unknown;
+}
+export interface WSIImageVolumeLike extends WSIImageMetadataSource {
+    ImageType: string[];
+}
+export interface WSIClientLike {
+    getDICOMwebMetadata(imageId: string): WSIImageMetadataSource;
+}
+export interface WSIMapViewLike {
+    getCenter(): [number, number];
+    getExtent?(): number[];
+    getProjection(): {
+        getExtent(): number[];
+    };
+    getResolution(): number;
+    getResolutionForZoom?(zoom: number): number;
+    getRotation(): number;
+    getZoom(): number;
+    setCenter(center: [number, number]): void;
+    setResolution?(resolution: number): void;
+    setRotation(rotation: number): void;
+    setZoom(zoom: number): void;
+}
+export interface WSIMapLike {
+    getView(): WSIMapViewLike;
+    getViewport(): HTMLElement;
+    on(eventName: string, handler: () => void): void;
+    render(): void;
+    un(eventName: string, handler: () => void): void;
+    updateSize?(): void;
+}
+export interface WSIViewerLike {
+    cleanup?(): void;
+    deactivateDragPanInteraction(): void;
+    getAffine(): unknown;
+    getMap(): WSIMapLike;
+    render(args: {
+        container: HTMLElement;
+    }): void;
+}
+export interface WSITransformUtilitiesLike {
+    applyInverseTransform(args: {
+        coordinate: [number, number];
+        affine: unknown;
+    }): [number, number];
+    applyTransform(args: {
+        coordinate: [number, number];
+        affine: unknown;
+    }): [number, number];
+}
+export interface DicomMicroscopyViewerLike {
+    metadata: {
+        VLWholeSlideMicroscopyImage: new (args: {
+            metadata: WSIImageMetadataSource;
+        }) => WSIImageVolumeLike;
+    };
+    utils?: WSITransformUtilitiesLike;
+    viewer: {
+        VolumeImageViewer: new (args: {
+            client: unknown;
+            metadata: WSIImageVolumeLike[];
+            controls: string[];
+            retrieveRendered: boolean;
+            bindings: Record<string, unknown>;
+        }) => WSIViewerLike;
+    };
+}
+export interface WSIImageDataMetadata {
+    bitsAllocated: number;
+    numberOfComponents: number;
+    origin: Point3;
+    direction: number[];
+    dimensions: [number, number, number];
+    spacing: [number, number, number];
+    hasPixelSpacing: boolean;
+    numVoxels: number;
+    imagePlaneModule: Record<string, unknown>;
+}
+export interface LoadedWSIData {
+    volumeImages: WSIImageVolumeLike[];
+    metadataDicomweb: WSIImageMetadataSource[];
+    metadata: WSIImageDataMetadata;
+    frameOfReferenceUID: string | null;
+    imageURISet: Set<string>;
+}
+export declare function getDicomMicroscopyViewer(): Promise<DicomMicroscopyViewerLike>;
+export declare function addWSIMiniNavigationOverlayCss(): void;
+export declare function getWSIImageDataMetadata(args: {
+    metadataDicomweb: WSIImageMetadataSource[];
+    imageIds: string[];
+    imageIndex?: number;
+}): WSIImageDataMetadata;
+export declare function loadWSIData(args: {
+    imageIds: string[];
+    client: WSIClientLike;
+    dicomMicroscopyViewer?: DicomMicroscopyViewerLike;
+}): Promise<LoadedWSIData>;

package/dist/esm/utilities/WSIUtilities.js

@@ -0,0 +1,110 @@
+import { vec3 } from 'gl-matrix';
+import { MetadataModules } from '../enums';
+import { peerImport } from '../init';
+import * as metaData from '../metaData';
+import microscopyViewportCss from '../constants/microscopyViewportCss';
+import imageIdToURI from './imageIdToURI';
+const overlayCssId = 'wsiViewportOverlayCss';
+export async function getDicomMicroscopyViewer() {
+    return peerImport('dicom-microscopy-viewer');
+}
+export function addWSIMiniNavigationOverlayCss() {
+    if (document.getElementById(overlayCssId)) {
+        return;
+    }
+    const overlayCss = document.createElement('style');
+    overlayCss.innerText = microscopyViewportCss;
+    overlayCss.setAttribute('id', overlayCssId);
+    document.getElementsByTagName('head')[0].append(overlayCss);
+}
+export function getWSIImageDataMetadata(args) {
+    const { metadataDicomweb, imageIds, imageIndex = 0 } = args;
+    const maxImage = metadataDicomweb.reduce((currentMax, image) => {
+        return currentMax?.NumberOfFrames < image.NumberOfFrames
+            ? image
+            : currentMax;
+    });
+    const { TotalPixelMatrixColumns: columns, TotalPixelMatrixRows: rows, ImageOrientationSlide, ImagedVolumeWidth: width, ImagedVolumeHeight: height, ImagedVolumeDepth: depth, } = maxImage;
+    const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageIds[imageIndex]);
+    let rowCosines = ImageOrientationSlide.slice(0, 3);
+    let columnCosines = ImageOrientationSlide.slice(3, 6);
+    if (rowCosines == null || columnCosines == null) {
+        rowCosines = [1, 0, 0];
+        columnCosines = [0, 1, 0];
+    }
+    const rowCosineVec = vec3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
+    const colCosineVec = vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+    const scanAxisNormal = vec3.create();
+    vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+    const { XOffsetInSlideCoordinateSystem = 0, YOffsetInSlideCoordinateSystem = 0, ZOffsetInSlideCoordinateSystem = 0, } = maxImage.TotalPixelMatrixOriginSequence?.[0] || {};
+    const origin = [
+        XOffsetInSlideCoordinateSystem,
+        YOffsetInSlideCoordinateSystem,
+        ZOffsetInSlideCoordinateSystem,
+    ];
+    const xSpacing = width / columns;
+    const ySpacing = height / rows;
+    const zSpacing = depth;
+    const xVoxels = columns;
+    const yVoxels = rows;
+    const zVoxels = 1;
+    return {
+        bitsAllocated: 8,
+        numberOfComponents: 3,
+        origin,
+        direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
+        dimensions: [xVoxels, yVoxels, zVoxels],
+        spacing: [xSpacing, ySpacing, zSpacing],
+        hasPixelSpacing: !!(width && height),
+        numVoxels: xVoxels * yVoxels * zVoxels,
+        imagePlaneModule,
+    };
+}
+export async function loadWSIData(args) {
+    const { imageIds, client, dicomMicroscopyViewer } = args;
+    const DicomMicroscopyViewer = dicomMicroscopyViewer || (await getDicomMicroscopyViewer());
+    let frameOfReferenceUID = null;
+    const metadataDicomweb = imageIds.map((imageId) => {
+        const imageMetadata = client.getDICOMwebMetadata(imageId);
+        Object.defineProperty(imageMetadata, 'isMultiframe', {
+            value: imageMetadata.isMultiframe,
+            enumerable: false,
+        });
+        Object.defineProperty(imageMetadata, 'frameNumber', {
+            value: undefined,
+            enumerable: false,
+        });
+        const imageType = imageMetadata['00080008']?.Value;
+        if (imageType?.length === 1) {
+            imageMetadata['00080008'].Value = imageType[0].split('\\');
+        }
+        const imageFrameOfReference = imageMetadata['00200052']?.Value?.[0];
+        if (!frameOfReferenceUID) {
+            frameOfReferenceUID = imageFrameOfReference;
+        }
+        else if (imageFrameOfReference !== frameOfReferenceUID) {
+            imageMetadata['00200052'].Value = [frameOfReferenceUID];
+        }
+        return imageMetadata;
+    });
+    const volumeImages = [];
+    metadataDicomweb.forEach((metadata) => {
+        const image = new DicomMicroscopyViewer.metadata.VLWholeSlideMicroscopyImage({
+            metadata,
+        });
+        const imageFlavor = image.ImageType[2];
+        if (imageFlavor === 'VOLUME' || imageFlavor === 'THUMBNAIL') {
+            volumeImages.push(image);
+        }
+    });
+    return {
+        volumeImages,
+        metadataDicomweb,
+        metadata: getWSIImageDataMetadata({
+            metadataDicomweb: volumeImages,
+            imageIds,
+        }),
+        frameOfReferenceUID,
+        imageURISet: new Set(imageIds.map((imageId) => imageIdToURI(imageId))),
+    };
+}

package/dist/esm/utilities/buildMetadata.js

@@ -8,29 +8,29 @@ export function getValidVOILUTFunction(voiLUTFunction) {
 }
 export function getImagePlaneModule(imageId) {
     const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+    if (imagePlaneModule.usingDefaultValues !== undefined) {
+        return imagePlaneModule;
+    }
+    if (imagePlaneModule.columnPixelSpacing &&
+        imagePlaneModule.rowPixelSpacing &&
+        imagePlaneModule.columnCosines &&
+        imagePlaneModule.rowCosines &&
+        imagePlaneModule.imagePositionPatient &&
+        imagePlaneModule.imageOrientationPatient) {
+        return imagePlaneModule;
+    }
     const newImagePlaneModule = {
         ...imagePlaneModule,
+        usingDefaultValues: true,
     };
-    if (!newImagePlaneModule.columnPixelSpacing) {
-        newImagePlaneModule.columnPixelSpacing = 1;
-    }
-    if (!newImagePlaneModule.rowPixelSpacing) {
-        newImagePlaneModule.rowPixelSpacing = 1;
-    }
-    if (!newImagePlaneModule.columnCosines) {
-        newImagePlaneModule.columnCosines = [0, 1, 0];
-    }
-    if (!newImagePlaneModule.rowCosines) {
-        newImagePlaneModule.rowCosines = [1, 0, 0];
-    }
-    if (!newImagePlaneModule.imagePositionPatient) {
-        newImagePlaneModule.imagePositionPatient = [0, 0, 0];
-    }
-    if (!newImagePlaneModule.imageOrientationPatient) {
-        newImagePlaneModule.imageOrientationPatient = new Float32Array([
-            1, 0, 0, 0, 1, 0,
-        ]);
-    }
+    newImagePlaneModule.columnPixelSpacing ||= 1;
+    newImagePlaneModule.rowPixelSpacing ||= 1;
+    newImagePlaneModule.columnCosines ||= [0, 1, 0];
+    newImagePlaneModule.rowCosines ||= [1, 0, 0];
+    newImagePlaneModule.imagePositionPatient ||= [0, 0, 0];
+    newImagePlaneModule.imageOrientationPatient ||= new Float32Array([
+        1, 0, 0, 0, 1, 0,
+    ]);
     return newImagePlaneModule;
 }
 export function calibrateImagePlaneModule(imageId, imagePlaneModule, currentCalibration) {
@@ -53,10 +53,10 @@ export function calibrateImagePlaneModule(imageId, imagePlaneModule, currentCali
 }
 export function buildMetadata(image) {
     const imageId = image.imageId;
-    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData.get('imagePixelModule', imageId);
+    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = metaData.get(MetadataModules.IMAGE_PIXEL, imageId);
     const { windowWidth, windowCenter, voiLUTFunction } = image;
-    const { modality } = metaData.get('generalSeriesModule', imageId);
-    const imageIdScalingFactor = metaData.get('scalingModule', imageId);
+    const { modality } = metaData.get(MetadataModules.GENERAL_SERIES, imageId);
+    const imageIdScalingFactor = metaData.get(MetadataModules.SCALING, imageId);
     const calibration = metaData.get(MetadataModules.CALIBRATION, imageId);
     const voiLUTFunctionEnum = getValidVOILUTFunction(voiLUTFunction);
     const imagePlaneModule = getImagePlaneModule(imageId);

package/dist/esm/utilities/calculateSpacingBetweenImageIds.js

@@ -1,5 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 import { getConfiguration } from '../init';
 const DEFAULT_THICKNESS_SINGLE_SLICE = 1;
 function getPixelSpacingForCubicVoxel(metadata) {
@@ -18,9 +19,9 @@ function getPixelSpacingForCubicVoxel(metadata) {
     return undefined;
 }
 export default function calculateSpacingBetweenImageIds(imageIds) {
-    const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = metaData.get('imagePlaneModule', imageIds[0]);
+    const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = metaData.get(MetadataModules.IMAGE_PLANE, imageIds[0]);
     if (imageIds.length === 1) {
-        const { sliceThickness, spacingBetweenSlices, columnPixelSpacing, rowPixelSpacing, pixelSpacing, } = metaData.get('imagePlaneModule', imageIds[0]);
+        const { sliceThickness, spacingBetweenSlices, columnPixelSpacing, rowPixelSpacing, pixelSpacing, } = metaData.get(MetadataModules.IMAGE_PLANE, imageIds[0]);
         if (sliceThickness)
             return sliceThickness;
         if (spacingBetweenSlices)
@@ -43,7 +44,7 @@ export default function calculateSpacingBetweenImageIds(imageIds) {
     const usingWadoUri = imageIds[0].split(':')[0] === 'wadouri';
     let spacing;
     function getDistance(imageId) {
-        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
+        const { imagePositionPatient } = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
         const positionVector = vec3.create();
         const ippVec = vec3.fromValues(imagePositionPatient[0], imagePositionPatient[1], imagePositionPatient[2]);
         vec3.sub(positionVector, refIppVec, ippVec);
@@ -69,7 +70,7 @@ export default function calculateSpacingBetweenImageIds(imageIds) {
             imageIds[0],
             imageIds[Math.floor(imageIds.length / 2)],
         ];
-        const metadataForMiddleImage = metaData.get('imagePlaneModule', prefetchedImageIds[1]);
+        const metadataForMiddleImage = metaData.get(MetadataModules.IMAGE_PLANE, prefetchedImageIds[1]);
         if (!metadataForMiddleImage) {
             throw new Error('Incomplete metadata required for volume construction.');
         }
@@ -81,7 +82,7 @@ export default function calculateSpacingBetweenImageIds(imageIds) {
             Math.abs(distanceBetweenFirstAndMiddleImages) /
                 Math.floor(imageIds.length / 2);
     }
-    const { sliceThickness, spacingBetweenSlices, columnPixelSpacing, rowPixelSpacing, pixelSpacing, } = metaData.get('imagePlaneModule', imageIds[0]);
+    const { sliceThickness, spacingBetweenSlices, columnPixelSpacing, rowPixelSpacing, pixelSpacing, } = metaData.get(MetadataModules.IMAGE_PLANE, imageIds[0]);
     const { strictZSpacingForVolumeViewport } = getConfiguration().rendering;
     if ((spacing === 0 || isNaN(spacing)) && !strictZSpacingForVolumeViewport) {
         if (spacingBetweenSlices) {

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.d.ts

@@ -1,6 +1,6 @@
-import type { IImageCalibration } from '../types/IImageCalibration';
-declare const metadataProvider: {
-    add: (imageId: string, payload: IImageCalibration) => void;
-    get: (type: string, imageId: string) => IImageCalibration;
+declare const _default: {
+    add: (imageId: string, payload: import("@cornerstonejs/metadata").IImageCalibration) => void;
+    get: (type: string, imageId: string) => import("@cornerstonejs/metadata").IImageCalibration;
+    clear: () => void;
 };
-export default metadataProvider;
+export default _default;

package/dist/esm/utilities/calibratedPixelSpacingMetadataProvider.js

@@ -1,15 +1,2 @@
-import imageIdToURI from './imageIdToURI';
-const state = {};
-const metadataProvider = {
-    add: (imageId, payload) => {
-        const imageURI = imageIdToURI(imageId);
-        state[imageURI] = payload;
-    },
-    get: (type, imageId) => {
-        if (type === 'calibratedPixelSpacing') {
-            const imageURI = imageIdToURI(imageId);
-            return state[imageURI];
-        }
-    },
-};
-export default metadataProvider;
+import { utilities } from '@cornerstonejs/metadata';
+export default utilities.calibratedPixelSpacingMetadataProvider;

package/dist/esm/utilities/clonePoint3.d.ts

@@ -0,0 +1,3 @@
+import type { Point3 } from '../types';
+export default function clonePoint3(point: ArrayLike<number>): Point3;
+export default function clonePoint3(point?: ArrayLike<number>): Point3 | undefined;

package/dist/esm/utilities/clonePoint3.js

@@ -0,0 +1,3 @@
+export default function clonePoint3(point) {
+    return point ? [point[0], point[1], point[2]] : undefined;
+}

package/dist/esm/utilities/colormap.d.ts

@@ -2,10 +2,11 @@ import type { ColormapPublic, ColormapRegistration } from '../types';
 declare function registerColormap(colormap: ColormapRegistration): void;
 declare function getColormap(name: any): any;
 declare function getColormapNames(): any[];
+declare function resolveColormap(name?: string): ColormapRegistration | undefined;
 declare function findMatchingColormap(rgbPoints: any, actor: any): ColormapPublic | null;
 export declare function setColorMapTransferFunctionForVolumeActor(volumeInfo: any): void;
 export declare function updateOpacity(volumeActor: any, newOpacity: any): void;
 export declare function updateThreshold(volumeActor: any, newThreshold: any): void;
 declare function getThresholdValue(volumeActor: any): any;
 declare function getMaxOpacity(volumeActor: any): number;
-export { getColormap, getColormapNames, registerColormap, findMatchingColormap, getThresholdValue, getMaxOpacity, };
+export { getColormap, getColormapNames, resolveColormap, registerColormap, findMatchingColormap, getThresholdValue, getMaxOpacity, };