@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/utilities/colormap.js

@@ -4,6 +4,9 @@ import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunc
 import isEqual from './isEqual';
 import { actorIsA } from './actorCheck';
 const _colormaps = new Map();
+function normalizeColormapName(name) {
+    return name?.trim().toLowerCase();
+}
 function registerColormap(colormap) {
     colormap.name = colormap.name || colormap.Name;
     _colormaps.set(colormap.name, colormap);
@@ -14,6 +17,42 @@ function getColormap(name) {
 function getColormapNames() {
     return Array.from(_colormaps.keys());
 }
+function findRegisteredColormap(name) {
+    const exactMatch = getColormap(name);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    const normalizedName = normalizeColormapName(name);
+    if (!normalizedName) {
+        return;
+    }
+    for (const [registeredName, registeredColormap] of _colormaps.entries()) {
+        if (normalizeColormapName(registeredName) === normalizedName ||
+            normalizeColormapName(registeredColormap.Name) === normalizedName) {
+            return registeredColormap;
+        }
+    }
+}
+function findVTKColormap(name) {
+    const exactMatch = vtkColorMaps.getPresetByName(name);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    const normalizedName = normalizeColormapName(name);
+    if (!normalizedName) {
+        return;
+    }
+    const matchedPresetName = vtkColorMaps.rgbPresetNames.find((presetName) => normalizeColormapName(presetName) === normalizedName);
+    return matchedPresetName
+        ? vtkColorMaps.getPresetByName(matchedPresetName)
+        : undefined;
+}
+function resolveColormap(name) {
+    if (!name?.trim()) {
+        return;
+    }
+    return findRegisteredColormap(name) || findVTKColormap(name);
+}
 function findMatchingColormap(rgbPoints, actor) {
     const colormapsVTK = vtkColorMaps.rgbPresetNames.map((presetName) => vtkColorMaps.getPresetByName(presetName));
     const colormapsCS3D = getColormapNames().map((colormapName) => getColormap(colormapName));
@@ -34,11 +73,11 @@ function findMatchingColormap(rgbPoints, actor) {
         return null;
     }
     const opacity = [];
-    if (actorIsA(actor, 'vtkVolume')) {
+    if (actorIsA(actor, 'vtkVolume') || actorIsA(actor, 'vtkImageSlice')) {
         const opacityPoints = actor
             .getProperty()
-            .getScalarOpacity(0)
-            .getDataPointer();
+            ?.getScalarOpacity?.(0)
+            ?.getDataPointer?.();
         if (!opacityPoints) {
             return {
                 name: matchedColormap.Name,
@@ -135,4 +174,4 @@ function getMaxOpacity(volumeActor) {
     }
     return maxOpacity;
 }
-export { getColormap, getColormapNames, registerColormap, findMatchingColormap, getThresholdValue, getMaxOpacity, };
+export { getColormap, getColormapNames, resolveColormap, registerColormap, findMatchingColormap, getThresholdValue, getMaxOpacity, };

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

@@ -1 +1 @@
-export declare function deepClone(obj: unknown): unknown;
+export declare function deepClone<T>(value: T): T;

package/dist/esm/utilities/deepClone.js

@@ -1,23 +1,52 @@
-export function deepClone(obj) {
-    if (obj === null || typeof obj !== 'object') {
-        return obj;
+export function deepClone(value) {
+    if (typeof structuredClone === 'function') {
+        try {
+            return structuredClone(value);
+        }
+        catch {
+        }
+    }
+    return cloneValue(value, new WeakMap());
+}
+function cloneValue(value, seen) {
+    if (value === null || typeof value !== 'object') {
+        return value;
     }
-    if (typeof obj === 'function') {
-        return obj;
+    const existingClone = seen.get(value);
+    if (existingClone) {
+        return existingClone;
     }
-    if (typeof structuredClone === 'function') {
-        return obj;
+    if (value instanceof Date) {
+        return new Date(value.getTime());
     }
-    if (Array.isArray(obj)) {
-        return obj.map(deepClone);
+    if (value instanceof Map) {
+        const clonedMap = new Map();
+        seen.set(value, clonedMap);
+        value.forEach((mapValue, mapKey) => {
+            clonedMap.set(cloneValue(mapKey, seen), cloneValue(mapValue, seen));
+        });
+        return clonedMap;
     }
-    else {
-        const clonedObj = {};
-        for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                clonedObj[key] = deepClone(obj[key]);
-            }
-        }
-        return clonedObj;
+    if (value instanceof Set) {
+        const clonedSet = new Set();
+        seen.set(value, clonedSet);
+        value.forEach((setValue) => {
+            clonedSet.add(cloneValue(setValue, seen));
+        });
+        return clonedSet;
+    }
+    if (Array.isArray(value)) {
+        const clonedArray = [];
+        seen.set(value, clonedArray);
+        value.forEach((item, index) => {
+            clonedArray[index] = cloneValue(item, seen);
+        });
+        return clonedArray;
     }
+    const clonedObject = {};
+    seen.set(value, clonedObject);
+    Reflect.ownKeys(value).forEach((key) => {
+        clonedObject[key] = cloneValue(value[key], seen);
+    });
+    return clonedObject;
 }

package/dist/esm/utilities/genericMetadataProvider.js

@@ -1,10 +1,11 @@
 import { addProvider } from '../metaData';
+import { deepClone } from './deepClone';
 let state = {};
 const metadataProvider = {
     add: (imageId, payload) => {
         metadataProvider.addRaw(imageId, {
             ...payload,
-            metadata: structuredClone(payload.metadata),
+            metadata: deepClone(payload.metadata),
         });
     },
     addRaw: (imageId, payload) => {

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

@@ -0,0 +1,8 @@
+declare const genericViewportDataSetMetadataProvider: {
+    VIEWPORT_V2_DATA_SET: string;
+    add(dataId: string, dataSet: unknown): void;
+    get(type: string, dataId: string): unknown;
+    remove(dataId: string): void;
+    clear(): void;
+};
+export default genericViewportDataSetMetadataProvider;

package/dist/esm/utilities/genericViewportDataSetMetadataProvider.js

@@ -0,0 +1,23 @@
+import { addProvider } from '../metaData';
+const VIEWPORT_V2_DATA_SET = 'genericViewportDataSet';
+let state = {};
+const genericViewportDataSetMetadataProvider = {
+    VIEWPORT_V2_DATA_SET,
+    add(dataId, dataSet) {
+        state[dataId] = dataSet;
+    },
+    get(type, dataId) {
+        if (type !== VIEWPORT_V2_DATA_SET) {
+            return;
+        }
+        return state[dataId];
+    },
+    remove(dataId) {
+        delete state[dataId];
+    },
+    clear() {
+        state = {};
+    },
+};
+addProvider(genericViewportDataSetMetadataProvider.get);
+export default genericViewportDataSetMetadataProvider;

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

@@ -0,0 +1,2 @@
+import type { IImageVolume, OrientationVectors } from '../types';
+export default function getAcquisitionPlaneOrientation(imageVolume: IImageVolume): OrientationVectors;

package/dist/esm/utilities/getAcquisitionPlaneOrientation.js

@@ -0,0 +1,7 @@
+export default function getAcquisitionPlaneOrientation(imageVolume) {
+    const { direction } = imageVolume;
+    return {
+        viewPlaneNormal: direction.slice(6, 9).map((x) => -x),
+        viewUp: direction.slice(3, 6).map((x) => -x),
+    };
+}

package/dist/esm/utilities/getClosestImageId.js

@@ -1,5 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 import { coreLog } from './logger';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import { EPSILON } from '../constants';
@@ -24,7 +25,7 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
     let minDistance = Infinity;
     for (let i = 0; i < imageIds.length; i++) {
         const imageId = imageIds[i];
-        const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+        const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
         if (!imagePlaneModule?.imagePositionPatient) {
             log.warn(`Missing imagePositionPatient for imageId: ${imageId}`);
             continue;

package/dist/esm/utilities/getClosestStackImageIndexForPoint.js

@@ -1,6 +1,7 @@
 import { vec3 } from 'gl-matrix';
 import * as planar from './planar';
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 export default function getClosestStackImageIndexForPoint(point, viewport) {
     const minimalDistance = calculateMinimalDistanceForStackViewport(point, viewport);
     return minimalDistance ? minimalDistance.index : null;
@@ -57,7 +58,7 @@ export function calculateMinimalDistanceForStackViewport(point, viewport) {
     return closestStack.distance === Infinity ? null : closestStack;
 }
 function getPlaneMetadata(imageId) {
-    const targetImagePlane = metaData.get('imagePlaneModule', imageId);
+    const targetImagePlane = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
     if (!targetImagePlane ||
         !(targetImagePlane.rowCosines instanceof Array &&
             targetImagePlane.rowCosines.length === 3) ||

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

@@ -1,13 +1,5 @@
-import { CalibrationTypes } from '../enums';
-export declare function getERMF(instance: any): any;
-export declare function calculateRadiographicPixelSpacing(instance: any): {
-    PixelSpacing: any;
-    type: CalibrationTypes;
-    isProjection: boolean;
-};
-export declare function getPixelSpacingInformation(instance: any): {
-    PixelSpacing: any;
-    type: CalibrationTypes;
-    isProjection: boolean;
-};
-export default getPixelSpacingInformation;
+import { utilities } from '@cornerstonejs/metadata';
+declare const getPixelSpacingInformation: typeof utilities.getPixelSpacingInformation, calculateRadiographicPixelSpacing: typeof utilities.calculateRadiographicPixelSpacing, getERMF: typeof utilities.getERMF;
+export { getPixelSpacingInformation, calculateRadiographicPixelSpacing, getERMF, };
+declare const _default: typeof utilities.getPixelSpacingInformation;
+export default _default;

package/dist/esm/utilities/getPixelSpacingInformation.js

@@ -1,93 +1,4 @@
-import { isEqual } from './isEqual';
-import { CalibrationTypes } from '../enums';
-const projectionRadiographSOPClassUIDs = new Set([
-    '1.2.840.10008.5.1.4.1.1.1',
-    '1.2.840.10008.5.1.4.1.1.1.1',
-    '1.2.840.10008.5.1.4.1.1.1.1.1',
-    '1.2.840.10008.5.1.4.1.1.1.2',
-    '1.2.840.10008.5.1.4.1.1.1.2.1',
-    '1.2.840.10008.5.1.4.1.1.1.3',
-    '1.2.840.10008.5.1.4.1.1.1.3.1',
-    '1.2.840.10008.5.1.4.1.1.12.1',
-    '1.2.840.10008.5.1.4.1.1.12.1.1',
-    '1.2.840.10008.5.1.4.1.1.12.2',
-    '1.2.840.10008.5.1.4.1.1.12.2.1',
-    '1.2.840.10008.5.1.4.1.1.12.3',
-]);
-export function getERMF(instance) {
-    const { PixelSpacing, ImagerPixelSpacing, EstimatedRadiographicMagnificationFactor: ermf, DistanceSourceToDetector: sid, DistanceSourceToPatient: sod, } = instance;
-    if (ermf) {
-        return ermf;
-    }
-    if (sod < sid) {
-        return sid / sod;
-    }
-    if (ImagerPixelSpacing?.[0] > PixelSpacing?.[0]) {
-        return true;
-    }
-}
-export function calculateRadiographicPixelSpacing(instance) {
-    const { PixelSpacing, ImagerPixelSpacing, PixelSpacingCalibrationType } = instance;
-    const isProjection = true;
-    if (PixelSpacing && PixelSpacingCalibrationType === 'GEOMETRY') {
-        if (isEqual(PixelSpacing, ImagerPixelSpacing)) {
-            console.warn('Calibration type is geometry, but pixel spacing and imager pixel spacing identical', PixelSpacing, ImagerPixelSpacing);
-        }
-        return {
-            PixelSpacing,
-            type: CalibrationTypes.ERMF,
-            isProjection,
-        };
-    }
-    if (PixelSpacing && PixelSpacingCalibrationType === 'FIDUCIAL') {
-        return {
-            PixelSpacing,
-            type: CalibrationTypes.CALIBRATED,
-            isProjection,
-        };
-    }
-    if (ImagerPixelSpacing) {
-        const ermf = getERMF(instance);
-        if (ermf > 1) {
-            const correctedPixelSpacing = ImagerPixelSpacing.map((pixelSpacing) => pixelSpacing / ermf);
-            return {
-                PixelSpacing: correctedPixelSpacing,
-                type: CalibrationTypes.ERMF,
-                isProjection,
-            };
-        }
-        if (ermf === true) {
-            return {
-                PixelSpacing,
-                type: CalibrationTypes.ERMF,
-                isProjection,
-            };
-        }
-        if (ermf) {
-            console.error('Illegal ERMF value:', ermf);
-        }
-        return {
-            PixelSpacing: PixelSpacing || ImagerPixelSpacing,
-            type: CalibrationTypes.PROJECTION,
-            isProjection,
-        };
-    }
-    return {
-        PixelSpacing,
-        type: CalibrationTypes.UNKNOWN,
-        isProjection,
-    };
-}
-export function getPixelSpacingInformation(instance) {
-    const { PixelSpacing, SOPClassUID } = instance;
-    const isProjection = projectionRadiographSOPClassUIDs.has(SOPClassUID);
-    if (isProjection) {
-        return calculateRadiographicPixelSpacing(instance);
-    }
-    return {
-        PixelSpacing,
-        type: CalibrationTypes.NOT_APPLICABLE,
-        isProjection: false,
-    };
-}
-export default getPixelSpacingInformation;
+import { utilities } from '@cornerstonejs/metadata';
+const { getPixelSpacingInformation, calculateRadiographicPixelSpacing, getERMF, } = utilities;
+export { getPixelSpacingInformation, calculateRadiographicPixelSpacing, getERMF, };
+export default utilities.getPixelSpacingInformation;

package/dist/esm/utilities/getScalingParameters.js

@@ -1,14 +1,15 @@
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 export default function getScalingParameters(imageId) {
-    const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-    const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+    const modalityLutModule = metaData.get(MetadataModules.MODALITY_LUT, imageId) || {};
+    const generalSeriesModule = metaData.get(MetadataModules.GENERAL_SERIES, imageId) || {};
     const { modality } = generalSeriesModule;
     const scalingParameters = {
         rescaleSlope: modalityLutModule.rescaleSlope || 1,
         rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
         modality,
     };
-    const scalingModules = metaData.get('scalingModule', imageId) || {};
+    const scalingModules = metaData.get(MetadataModules.SCALING, imageId) || {};
     return {
         ...scalingParameters,
         ...(modality === 'PT' && {

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

@@ -0,0 +1,3 @@
+import { VOILUTFunctionType } from '../enums';
+import type { VOIRange } from '../types';
+export default function getVOIRangeFromWindowLevel(windowWidth: number | number[] | undefined, windowCenter: number | number[] | undefined, voiLUTFunction?: VOILUTFunctionType): VOIRange | undefined;

package/dist/esm/utilities/getVOIRangeFromWindowLevel.js

@@ -0,0 +1,18 @@
+import { VOILUTFunctionType } from '../enums';
+import { toLowHighRange } from './windowLevel';
+export default function getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction = VOILUTFunctionType.LINEAR) {
+    let center;
+    let width;
+    if (typeof windowCenter === 'number' && typeof windowWidth === 'number') {
+        center = windowCenter;
+        width = windowWidth;
+    }
+    else if (Array.isArray(windowCenter) && Array.isArray(windowWidth)) {
+        center = windowCenter[0];
+        width = windowWidth[0];
+    }
+    if (center === undefined || width === undefined) {
+        return;
+    }
+    return toLowHighRange(width, center, voiLUTFunction);
+}

package/dist/esm/utilities/getViewportImageIds.js

@@ -1,4 +1,4 @@
-import { VolumeViewport } from '../RenderingEngine';
+import VolumeViewport from '../RenderingEngine/VolumeViewport';
 import cache from '../cache/cache';
 function getViewportImageIds(viewport) {
     if (viewport instanceof VolumeViewport) {

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

@@ -1,4 +1,2 @@
-import type { IBaseVolumeViewport, IStackViewport } from '../types';
-type Viewport = IStackViewport | IBaseVolumeViewport;
-export default function getViewportsWithImageURI(imageURI: string): Viewport[];
-export {};
+import { type ImageSliceViewport } from './viewportCapabilities';
+export default function getViewportsWithImageURI(imageURI: string): ImageSliceViewport[];

package/dist/esm/utilities/getViewportsWithImageURI.js

@@ -1,9 +1,12 @@
 import { getRenderingEngines } from '../RenderingEngine/getRenderingEngine';
+import { viewportSupportsImageSlices, } from './viewportCapabilities';
 export default function getViewportsWithImageURI(imageURI) {
     const renderingEngines = getRenderingEngines();
     const viewports = [];
     renderingEngines.forEach((renderingEngine) => {
-        const viewportsForRenderingEngine = renderingEngine.getViewports();
+        const viewportsForRenderingEngine = renderingEngine
+            .getViewports()
+            .filter(viewportSupportsImageSlices);
         viewportsForRenderingEngine.forEach((viewport) => {
             if (viewport.hasImageURI(imageURI)) {
                 viewports.push(viewport);

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

@@ -1,3 +1,3 @@
-import type { IVolumeViewport } from '../types';
-declare function getViewportsWithVolumeId(volumeId: string): IVolumeViewport[];
+import { type VolumeIdViewport } from './viewportCapabilities';
+declare function getViewportsWithVolumeId(volumeId: string): VolumeIdViewport[];
 export default getViewportsWithVolumeId;

package/dist/esm/utilities/getViewportsWithVolumeId.js

@@ -1,9 +1,12 @@
 import { getRenderingEngines } from '../RenderingEngine/getRenderingEngine';
+import { viewportSupportsVolumeId, } from './viewportCapabilities';
 function getViewportsWithVolumeId(volumeId) {
     const renderingEngines = getRenderingEngines();
     const targetViewports = [];
     renderingEngines.forEach((renderingEngine) => {
-        const viewports = renderingEngine.getVolumeViewports();
+        const viewports = renderingEngine
+            .getViewports()
+            .filter(viewportSupportsVolumeId);
         const filteredViewports = viewports.filter((vp) => vp.hasVolumeId(volumeId));
         targetViewports.push(...filteredViewports);
     });

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

@@ -1,3 +1,3 @@
-import type { IVolumeViewport } from '../types';
-declare function getViewportsWithVolumeURI(volumeURI: string, renderingEngineId?: string): IVolumeViewport[];
+import { type VolumeURIViewport } from './viewportCapabilities';
+declare function getViewportsWithVolumeURI(volumeURI: string, renderingEngineId?: string): VolumeURIViewport[];
 export default getViewportsWithVolumeURI;

package/dist/esm/utilities/getViewportsWithVolumeURI.js

@@ -1,11 +1,14 @@
 import { getRenderingEngines, getRenderingEngine, } from '../RenderingEngine/getRenderingEngine';
+import { viewportSupportsVolumeURI, } from './viewportCapabilities';
 function getViewportsWithVolumeURI(volumeURI, renderingEngineId) {
     const renderingEngines = renderingEngineId
         ? [getRenderingEngine(renderingEngineId)]
         : getRenderingEngines();
     const targetViewports = [];
     renderingEngines.forEach((renderingEngine) => {
-        const viewports = renderingEngine.getVolumeViewports();
+        const viewports = renderingEngine
+            .getViewports()
+            .filter(viewportSupportsVolumeURI);
         const filteredViewports = viewports.filter((vp) => vp.hasVolumeURI(volumeURI));
         targetViewports.push(...filteredViewports);
     });

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

@@ -0,0 +1,6 @@
+import type { Point3 } from '../types';
+export default function getVolumeViewReferenceId(args: {
+    sliceIndex: number;
+    viewPlaneNormal: Point3;
+    volumeId: string;
+}): string;

package/dist/esm/utilities/getVolumeViewReferenceId.js

@@ -0,0 +1,6 @@
+export default function getVolumeViewReferenceId(args) {
+    const { sliceIndex, viewPlaneNormal, volumeId } = args;
+    const querySeparator = volumeId.includes('?') ? '&' : '?';
+    const formattedNormal = viewPlaneNormal.map((value) => value.toFixed(3));
+    return `volumeId:${volumeId}${querySeparator}sliceIndex=${sliceIndex}&viewPlaneNormal=${formattedNormal.join(',')}`;
+}

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

@@ -5,7 +5,7 @@ declare function getVolumeViewportScrollInfo(viewport: IVolumeViewport, volumeId
     sliceRangeInfo: {
         sliceRange: import("../types").ActorSliceRange;
         spacingInNormalDirection: number;
-        camera: import("../types").ICamera;
+        camera: import("../types").ICamera<number>;
     };
 };
 export default getVolumeViewportScrollInfo;

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

@@ -1,3 +1,3 @@
-import type { IVolumeViewport } from '../types';
-declare function getVolumeViewportsContainingSameVolumes(targetViewport: IVolumeViewport, renderingEngineId?: string): IVolumeViewport[];
+import { type VolumeActorViewport } from './viewportCapabilities';
+declare function getVolumeViewportsContainingSameVolumes(targetViewport: VolumeActorViewport, renderingEngineId?: string): VolumeActorViewport[];
 export default getVolumeViewportsContainingSameVolumes;

package/dist/esm/utilities/getVolumeViewportsContainingSameVolumes.js

@@ -1,4 +1,5 @@
 import { getRenderingEngines, getRenderingEngine, } from '../RenderingEngine/getRenderingEngine';
+import { viewportSupportsVolumeActors, } from './viewportCapabilities';
 function getVolumeViewportsContainingSameVolumes(targetViewport, renderingEngineId) {
     let renderingEngines;
     if (renderingEngineId) {
@@ -10,7 +11,9 @@ function getVolumeViewportsContainingSameVolumes(targetViewport, renderingEngine
     const sameVolumesViewports = [];
     renderingEngines.forEach((renderingEngine) => {
         const targetActors = targetViewport.getActors();
-        const viewports = renderingEngine.getVolumeViewports();
+        const viewports = renderingEngine
+            .getViewports()
+            .filter(viewportSupportsVolumeActors);
         for (const vp of viewports) {
             const vpActors = vp.getActors();
             if (vpActors.length !== targetActors.length) {

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

@@ -0,0 +1 @@
+export default function hasOwn<T extends object, K extends PropertyKey>(object: T, key: K): object is T & Record<K, unknown>;

package/dist/esm/utilities/hasOwn.js

@@ -0,0 +1,3 @@
+export default function hasOwn(object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key);
+}

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

@@ -1 +1,3 @@
-export default function imageIdToURI(imageId: string): string;
+import { utilities } from '@cornerstonejs/metadata';
+declare const _default: typeof utilities.imageIdToURI;
+export default _default;

package/dist/esm/utilities/imageIdToURI.js

@@ -1,7 +1,2 @@
-export default function imageIdToURI(imageId) {
-    if (!imageId) {
-        return '';
-    }
-    const colonIndex = imageId.indexOf(':');
-    return colonIndex === -1 ? imageId : imageId.substring(colonIndex + 1);
-}
+import { utilities } from '@cornerstonejs/metadata';
+export default utilities.imageIdToURI;

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

@@ -7,7 +7,10 @@ import scaleRgbTransferFunction from './scaleRgbTransferFunction';
 import triggerEvent from './triggerEvent';
 import uuidv4 from './uuidv4';
 import getMinMax from './getMinMax';
+import clonePoint3 from './clonePoint3';
+import hasOwn from './hasOwn';
 import getRuntimeId from './getRuntimeId';
+import getVOIRangeFromWindowLevel from './getVOIRangeFromWindowLevel';
 import imageIdToURI from './imageIdToURI';
 import calibratedPixelSpacingMetadataProvider from './calibratedPixelSpacingMetadataProvider';
 import clamp from './clamp';
@@ -54,6 +57,7 @@ import { updateVTKImageDataWithCornerstoneImage } from './updateVTKImageDataWith
 import ProgressiveIterator from './ProgressiveIterator';
 import decimate from './decimate';
 import imageRetrieveMetadataProvider from './imageRetrieveMetadataProvider';
+import genericViewportDataSetMetadataProvider from './genericViewportDataSetMetadataProvider';
 import isVideoTransferSyntax from './isVideoTransferSyntax';
 import { getBufferConfiguration } from './getBufferConfiguration';
 import { generateVolumePropsFromImageIds } from './generateVolumePropsFromImageIds';
@@ -69,6 +73,9 @@ import { getRandomSampleFromArray } from './getRandomSampleFromArray';
 import { getVolumeId } from './getVolumeId';
 import { hasFloatScalingParameters } from './hasFloatScalingParameters';
 import { pointInShapeCallback } from './pointInShapeCallback';
+import * as ECGUtilities from './ECGUtilities';
+import * as VideoUtilities from './VideoUtilities';
+import * as WSIUtilities from './WSIUtilities';
 export * as planar from './planar';
 import * as windowLevel from './windowLevel';
 import * as colormap from './colormap';
@@ -89,7 +96,9 @@ import { jumpToSlice } from './jumpToSlice';
 import scroll from './scroll';
 import clip from './clip';
 import createSubVolume from './createSubVolume';
+import getAcquisitionPlaneOrientation from './getAcquisitionPlaneOrientation';
 import getVolumeDirectionVectors from './getVolumeDirectionVectors';
+import getVolumeViewReferenceId from './getVolumeViewReferenceId';
 import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
@@ -97,8 +106,9 @@ export * from './getPixelSpacingInformation';
 export * from './getPlaneCubeIntersectionDimensions';
 export * from './rotateToViewCoordinates';
 import { asArray } from './asArray';
+import { viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI } from './viewportCapabilities';
 import { getNormalizedAspectRatio } from './getNormalizedAspectRatio';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, getNormalizedAspectRatio, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, clonePoint3, hasOwn, getRuntimeId, getVOIRangeFromWindowLevel, isOpposite, getViewportModality, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, genericViewportDataSetMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, ECGUtilities, VideoUtilities, WSIUtilities, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getAcquisitionPlaneOrientation, getVolumeDirectionVectors, getVolumeViewReferenceId, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI, getNormalizedAspectRatio, };