@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/utilities/index.js

@@ -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';
@@ -90,7 +97,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';
@@ -98,8 +107,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';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
 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, };

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

@@ -1,5 +1,3 @@
-export declare function isEqual<ValueType>(v1: ValueType, v2: ValueType, tolerance?: number): boolean;
-export declare const isEqualNegative: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
-export declare const isEqualAbs: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
-export declare function isNumber(n: number[] | number): boolean;
-export default isEqual;
+import { isEqual, isEqualNegative, isEqualAbs, isNumber, isEqual as isEqualDefault } from '@cornerstonejs/utils';
+export { isEqual, isEqualNegative, isEqualAbs, isNumber };
+export default isEqualDefault;

package/dist/esm/utilities/isEqual.js

@@ -1,48 +1,3 @@
-function areNumbersEqualWithTolerance(num1, num2, tolerance) {
-    return Math.abs(num1 - num2) <= tolerance;
-}
-function areArraysEqual(arr1, arr2, tolerance = 1e-5) {
-    if (arr1.length !== arr2.length) {
-        return false;
-    }
-    for (let i = 0; i < arr1.length; i++) {
-        if (!areNumbersEqualWithTolerance(arr1[i], arr2[i], tolerance)) {
-            return false;
-        }
-    }
-    return true;
-}
-function isNumberType(value) {
-    return typeof value === 'number';
-}
-function isNumberArrayLike(value) {
-    return (value &&
-        typeof value === 'object' &&
-        'length' in value &&
-        typeof value.length === 'number' &&
-        value.length > 0 &&
-        typeof value[0] === 'number');
-}
-export function isEqual(v1, v2, tolerance = 1e-5) {
-    if (typeof v1 !== typeof v2 || v1 === null || v2 === null) {
-        return false;
-    }
-    if (isNumberType(v1) && isNumberType(v2)) {
-        return areNumbersEqualWithTolerance(v1, v2, tolerance);
-    }
-    if (isNumberArrayLike(v1) && isNumberArrayLike(v2)) {
-        return areArraysEqual(v1, v2, tolerance);
-    }
-    return false;
-}
-const negative = (v) => typeof v === 'number' ? -v : v?.map ? v.map(negative) : !v;
-const abs = (v) => typeof v === 'number' ? Math.abs(v) : v?.map ? v.map(abs) : v;
-export const isEqualNegative = (v1, v2, tolerance = undefined) => isEqual(v1, negative(v2), tolerance);
-export const isEqualAbs = (v1, v2, tolerance = undefined) => isEqual(abs(v1), abs(v2), tolerance);
-export function isNumber(n) {
-    if (Array.isArray(n)) {
-        return isNumber(n[0]);
-    }
-    return isFinite(n) && !isNaN(n);
-}
-export default isEqual;
+import { isEqual, isEqualNegative, isEqualAbs, isNumber, isEqual as isEqualDefault, } from '@cornerstonejs/utils';
+export { isEqual, isEqualNegative, isEqualAbs, isNumber };
+export default isEqualDefault;

package/dist/esm/utilities/isValidVolume.js

@@ -1,12 +1,21 @@
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 import isEqual from './isEqual';
 function isValidVolume(imageIds) {
     if (!imageIds.length) {
         return false;
     }
     const imageId0 = imageIds[0];
-    const { modality, seriesInstanceUID } = metaData.get('generalSeriesModule', imageId0);
-    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, usingDefaultValues, } = metaData.get('imagePlaneModule', imageId0);
+    const generalSeries = metaData.get(MetadataModules.GENERAL_SERIES, imageId0);
+    if (!generalSeries) {
+        return false;
+    }
+    const { modality, seriesInstanceUID } = generalSeries;
+    const imagePlane = metaData.get(MetadataModules.IMAGE_PLANE, imageId0);
+    if (!imagePlane) {
+        return false;
+    }
+    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, usingDefaultValues, } = imagePlane;
     if (usingDefaultValues) {
         return false;
     }
@@ -22,8 +31,14 @@ function isValidVolume(imageIds) {
     let validVolume = true;
     for (let i = 0; i < imageIds.length; i++) {
         const imageId = imageIds[i];
-        const { modality, seriesInstanceUID } = metaData.get('generalSeriesModule', imageId);
-        const { imageOrientationPatient, pixelSpacing, columns, rows } = metaData.get('imagePlaneModule', imageId);
+        const general = metaData.get(MetadataModules.GENERAL_SERIES, imageId);
+        const plane = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+        if (!general || !plane) {
+            validVolume = false;
+            break;
+        }
+        const { modality, seriesInstanceUID } = general;
+        const { imageOrientationPatient, pixelSpacing, columns, rows } = plane;
         if (seriesInstanceUID !== baseMetadata.seriesInstanceUID) {
             validVolume = false;
             break;

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

@@ -1,2 +1,4 @@
+import { utilities } from '@cornerstonejs/metadata';
+declare const _default: typeof utilities.isVideoTransferSyntax;
+export default _default;
 export declare const videoUIDs: Set<string>;
-export default function isVideoTransferSyntax(uidOrUids: string | string[]): string | false;

package/dist/esm/utilities/isVideoTransferSyntax.js

@@ -1,25 +1,3 @@
-export const videoUIDs = new Set([
-    '1.2.840.10008.1.2.4.100',
-    '1.2.840.10008.1.2.4.100.1',
-    '1.2.840.10008.1.2.4.101',
-    '1.2.840.10008.1.2.4.101.1',
-    '1.2.840.10008.1.2.4.102',
-    '1.2.840.10008.1.2.4.102.1',
-    '1.2.840.10008.1.2.4.103',
-    '1.2.840.10008.1.2.4.103.1',
-    '1.2.840.10008.1.2.4.104',
-    '1.2.840.10008.1.2.4.104.1',
-    '1.2.840.10008.1.2.4.105',
-    '1.2.840.10008.1.2.4.105.1',
-    '1.2.840.10008.1.2.4.106',
-    '1.2.840.10008.1.2.4.106.1',
-    '1.2.840.10008.1.2.4.107',
-    '1.2.840.10008.1.2.4.108',
-]);
-export default function isVideoTransferSyntax(uidOrUids) {
-    if (!uidOrUids) {
-        return false;
-    }
-    const uids = Array.isArray(uidOrUids) ? uidOrUids : [uidOrUids];
-    return uids.find((uid) => videoUIDs.has(uid));
-}
+import { utilities } from '@cornerstonejs/metadata';
+export default utilities.isVideoTransferSyntax;
+export const { videoUIDs } = utilities;

package/dist/esm/utilities/loadImageToCanvas.js

@@ -1,6 +1,6 @@
 import { loadAndCacheImage } from '../loaders/imageLoader';
 import * as metaData from '../metaData';
-import { RequestType } from '../enums';
+import { MetadataModules, RequestType } from '../enums';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import renderToCanvasGPU from './renderToCanvasGPU';
 import renderToCanvasCPU from './renderToCanvasCPU';
@@ -15,7 +15,7 @@ export default function loadImageToCanvas(options) {
     const renderFn = useCPURendering ? renderToCanvasCPU : renderToCanvasGPU;
     return new Promise((resolve, reject) => {
         function successCallback(imageOrVolume, imageId) {
-            const { modality } = metaData.get('generalSeriesModule', imageId) || {};
+            const { modality } = metaData.get(MetadataModules.GENERAL_SERIES, imageId) || {};
             const image = !isVolume && imageOrVolume;
             const volume = isVolume && imageOrVolume;
             if (image) {

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

@@ -1,14 +1,3 @@
-import type { Logger as LogLevelLogger } from 'loglevel';
-export type Logger = LogLevelLogger & {
-    getLogger: (...categories: string[]) => Logger;
-};
-export declare function getRootLogger(name: string): Logger;
-export declare function getLogger(...name: string[]): Logger;
-export declare const cs3dLog: Logger;
-export declare const coreLog: Logger;
-export declare const toolsLog: Logger;
-export declare const loaderLog: Logger;
-export declare const aiLog: Logger;
-export declare const examplesLog: Logger;
-export declare const dicomConsistencyLog: Logger;
-export declare const imageConsistencyLog: Logger;
+import { logging } from '@cornerstonejs/utils';
+export declare const getRootLogger: typeof logging.getRootLogger, getLogger: typeof logging.getLogger, cs3dLog: logging.Logger, workerLog: logging.Logger, coreLog: logging.Logger, toolsLog: logging.Logger, loaderLog: logging.Logger, aiLog: logging.Logger, examplesLog: logging.Logger, dicomConsistencyLog: logging.Logger, imageConsistencyLog: logging.Logger;
+export type Logger = logging.Logger;

package/dist/esm/utilities/logger.js

@@ -1,23 +1,2 @@
-import loglevelImport from 'loglevel';
-const loglevel = loglevelImport.noConflict();
-if (typeof window !== 'undefined') {
-    window.log = loglevel;
-}
-export function getRootLogger(name) {
-    const logger = loglevel.getLogger(name[0]);
-    logger.getLogger = (...names) => {
-        return getRootLogger(`${name}.${names.join('.')}`);
-    };
-    return logger;
-}
-export function getLogger(...name) {
-    return getRootLogger(name.join('.'));
-}
-export const cs3dLog = getRootLogger('cs3d');
-export const coreLog = cs3dLog.getLogger('core');
-export const toolsLog = cs3dLog.getLogger('tools');
-export const loaderLog = cs3dLog.getLogger('dicomImageLoader');
-export const aiLog = cs3dLog.getLogger('ai');
-export const examplesLog = cs3dLog.getLogger('examples');
-export const dicomConsistencyLog = getLogger('consistency', 'dicom');
-export const imageConsistencyLog = getLogger('consistency', 'image');
+import { logging } from '@cornerstonejs/utils';
+export const { getRootLogger, getLogger, cs3dLog, workerLog, coreLog, toolsLog, loaderLog, aiLog, examplesLog, dicomConsistencyLog, imageConsistencyLog, } = logging;

package/dist/esm/utilities/rotateToViewCoordinates.js

@@ -2,13 +2,13 @@ import { vec3 } from 'gl-matrix';
 export function rotateToViewCoordinates(imageData, viewPlaneNormal, viewUp) {
     const viewRight = vec3.cross(vec3.create(), viewPlaneNormal, viewUp);
     vec3.normalize(viewRight, viewRight);
-    const extent = imageData.getExtent();
-    const xMin = extent[0];
-    const xMax = extent[1] + 1;
-    const yMin = extent[2];
-    const yMax = extent[3] + 1;
-    const zMin = extent[4];
-    const zMax = extent[5] + 1;
+    const spatialExtent = imageData.getSpatialExtent();
+    const xMin = spatialExtent[0];
+    const xMax = spatialExtent[1];
+    const yMin = spatialExtent[2];
+    const yMax = spatialExtent[3];
+    const zMin = spatialExtent[4];
+    const zMax = spatialExtent[5];
     const corners = [
         [xMin, yMin, zMin],
         [xMax, yMin, zMin],

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

@@ -1,4 +1,4 @@
-import { VolumeViewport } from '../RenderingEngine';
+import VolumeViewport from '../RenderingEngine/VolumeViewport';
 import type { ScrollOptions, IViewport, IVideoViewport } from '../types';
 export default function scroll(viewport: IViewport | IVideoViewport, options: ScrollOptions): void;
 export declare function scrollVolume(viewport: VolumeViewport, volumeId: string, delta: number, scrollSlabs?: boolean): void;

package/dist/esm/utilities/scroll.js

@@ -1,5 +1,6 @@
 import { Events } from '../enums';
-import { StackViewport, VolumeViewport } from '../RenderingEngine';
+import StackViewport from '../RenderingEngine/StackViewport';
+import VolumeViewport from '../RenderingEngine/VolumeViewport';
 import getVolumeViewportScrollInfo from './getVolumeViewportScrollInfo';
 import snapFocalPointToSlice from './snapFocalPointToSlice';
 import getEnabledElement from '../getEnabledElement';

package/dist/esm/utilities/sortImageIdsAndGetSpacing.js

@@ -1,8 +1,9 @@
 import { vec3 } from 'gl-matrix';
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
-    const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = metaData.get('imagePlaneModule', imageIds[0]);
+    const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = metaData.get(MetadataModules.IMAGE_PLANE, imageIds[0]);
     if (!scanAxisNormal) {
         const rowCosineVec = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
         const colCosineVec = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
@@ -13,7 +14,7 @@ export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
     const zSpacing = calculateSpacingBetweenImageIds(imageIds);
     let sortedImageIds;
     function getDistance(imageId) {
-        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
+        const { imagePositionPatient } = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
         const positionVector = vec3.create();
         vec3.sub(positionVector, referenceImagePositionPatient, imagePositionPatient);
         return vec3.dot(positionVector, scanAxisNormal);
@@ -41,7 +42,7 @@ export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
             sortedImageIds.reverse();
         }
     }
-    const { imagePositionPatient: origin } = metaData.get('imagePlaneModule', sortedImageIds[0]);
+    const { imagePositionPatient: origin } = metaData.get(MetadataModules.IMAGE_PLANE, sortedImageIds[0]);
     const result = {
         zSpacing,
         origin,

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

@@ -1,12 +1,4 @@
-interface MultiframeSplitResult {
-    imageIdGroups: string[][];
-    splittingTag: string;
-}
-declare function generateFrameImageId(baseImageId: string, frameNumber: number): string;
-declare function handleMultiframe4D(imageIds: string[]): MultiframeSplitResult | null;
-declare function splitImageIdsBy4DTags(imageIds: string[]): {
-    imageIdGroups: string[][];
-    splittingTag: string | null;
-};
+import { utilities } from '@cornerstonejs/metadata';
+declare const splitImageIdsBy4DTags: typeof utilities.splitImageIdsBy4DTags, handleMultiframe4D: typeof utilities.handleMultiframe4D, generateFrameImageId: typeof utilities.generateFrameImageId;
 export default splitImageIdsBy4DTags;
 export { handleMultiframe4D, generateFrameImageId };

package/dist/esm/utilities/splitImageIdsBy4DTags.js

@@ -1,314 +1,4 @@
-import * as metaData from '../metaData';
-import { toFiniteNumber } from './toNumber';
-function generateFrameImageId(baseImageId, frameNumber) {
-    const framePattern = /\/frames\/\d+/;
-    if (!framePattern.test(baseImageId)) {
-        throw new Error(`generateFrameImageId: baseImageId must contain a "/frames/" pattern followed by a digit. ` +
-            `Expected format: e.g., "wadouri:http://example.com/image/frames/1" or "wadors:/path/to/image.dcm/frames/1". ` +
-            `Received: ${baseImageId}`);
-    }
-    return baseImageId.replace(framePattern, `/frames/${frameNumber}`);
-}
-function handleMultiframe4D(imageIds) {
-    if (!imageIds || imageIds.length === 0) {
-        return null;
-    }
-    const baseImageId = imageIds[0];
-    const instance = metaData.get('instance', baseImageId);
-    if (!instance) {
-        return null;
-    }
-    const numberOfFrames = instance.NumberOfFrames;
-    if (!numberOfFrames || numberOfFrames <= 1) {
-        return null;
-    }
-    const timeSlotVector = instance.TimeSlotVector;
-    if (!timeSlotVector || !Array.isArray(timeSlotVector)) {
-        return null;
-    }
-    const sliceVector = instance.SliceVector;
-    const numberOfSlices = instance.NumberOfSlices;
-    if (timeSlotVector.length !== numberOfFrames) {
-        console.warn('TimeSlotVector length does not match NumberOfFrames:', timeSlotVector.length, 'vs', numberOfFrames);
-        return null;
-    }
-    if (sliceVector) {
-        if (!Array.isArray(sliceVector)) {
-            console.warn('SliceVector exists but is not an array. Expected length:', numberOfFrames);
-            return null;
-        }
-        if (sliceVector.length !== numberOfFrames ||
-            sliceVector.some((val) => val === undefined)) {
-            console.warn('SliceVector exists but has invalid length or undefined entries. Expected length:', numberOfFrames, 'Actual length:', sliceVector.length);
-            return null;
-        }
-    }
-    const timeSlotGroups = new Map();
-    for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
-        const timeSlot = timeSlotVector[frameIndex];
-        const sliceIndex = sliceVector?.[frameIndex] ?? frameIndex;
-        if (!timeSlotGroups.has(timeSlot)) {
-            timeSlotGroups.set(timeSlot, []);
-        }
-        timeSlotGroups.get(timeSlot).push({ frameIndex, sliceIndex });
-    }
-    const sortedTimeSlots = Array.from(timeSlotGroups.keys()).sort((a, b) => a - b);
-    const imageIdGroups = sortedTimeSlots.map((timeSlot) => {
-        const frames = timeSlotGroups.get(timeSlot);
-        frames.sort((a, b) => a.sliceIndex - b.sliceIndex);
-        return frames.map((frame) => generateFrameImageId(baseImageId, frame.frameIndex + 1));
-    });
-    const expectedSlicesPerTimeSlot = numberOfSlices || imageIdGroups[0]?.length;
-    const allGroupsHaveSameLength = imageIdGroups.every((group) => group.length === expectedSlicesPerTimeSlot);
-    if (!allGroupsHaveSameLength) {
-        console.warn('Multiframe 4D split resulted in uneven time slot groups. Expected', expectedSlicesPerTimeSlot, 'slices per time slot.');
-    }
-    return {
-        imageIdGroups,
-        splittingTag: 'TimeSlotVector',
-    };
-}
-function handleCardiac4D(imageIds) {
-    if (!imageIds || imageIds.length === 0) {
-        return null;
-    }
-    const cardiacNumberOfImages = getFiniteValue(imageIds[0], 'CardiacNumberOfImages');
-    if (cardiacNumberOfImages === undefined) {
-        return null;
-    }
-    const stacks = new Map();
-    for (const imageId of imageIds) {
-        const stackId = metaData.get('StackID', imageId);
-        const inStackPositionNumber = getFiniteValue(imageId, 'InStackPositionNumber');
-        const triggerTime = getFiniteValue(imageId, 'TriggerTime');
-        if (stackId === undefined ||
-            inStackPositionNumber === undefined ||
-            triggerTime === undefined) {
-            return null;
-        }
-        const stackKey = String(stackId);
-        if (!stacks.has(stackKey)) {
-            stacks.set(stackKey, new Map());
-        }
-        const positions = stacks.get(stackKey);
-        if (!positions.has(inStackPositionNumber)) {
-            positions.set(inStackPositionNumber, []);
-        }
-        positions.get(inStackPositionNumber).push({ imageId, triggerTime });
-    }
-    const sortedStackIds = Array.from(stacks.keys()).sort((a, b) => Number(a) - Number(b));
-    if (sortedStackIds.length === 0) {
-        return null;
-    }
-    const preparedStacks = [];
-    let timeCount;
-    for (const stackId of sortedStackIds) {
-        const positions = stacks.get(stackId);
-        const sortedPositions = Array.from(positions.keys()).sort((a, b) => a - b);
-        for (const position of sortedPositions) {
-            const frames = positions.get(position);
-            frames.sort((a, b) => a.triggerTime - b.triggerTime);
-            if (timeCount === undefined) {
-                timeCount = frames.length;
-            }
-            else if (frames.length !== timeCount) {
-                return null;
-            }
-        }
-        preparedStacks.push({
-            stackId,
-            positions: sortedPositions,
-            framesByPosition: positions,
-        });
-    }
-    if (!timeCount) {
-        return null;
-    }
-    const imageIdGroups = [];
-    for (let timeIndex = 0; timeIndex < timeCount; timeIndex++) {
-        const group = [];
-        for (const stack of preparedStacks) {
-            for (const position of stack.positions) {
-                const frames = stack.framesByPosition.get(position);
-                group.push(frames[timeIndex].imageId);
-            }
-        }
-        imageIdGroups.push(group);
-    }
-    return {
-        imageIdGroups,
-        splittingTag: 'CardiacTriggerTime',
-    };
-}
-const groupBy = (array, key) => {
-    return array.reduce((rv, x) => {
-        (rv[x[key]] = rv[x[key]] || []).push(x);
-        return rv;
-    }, {});
-};
-function getIPPGroups(imageIds) {
-    const ippMetadata = imageIds.map((imageId) => {
-        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId) || {};
-        return { imageId, imagePositionPatient };
-    });
-    if (!ippMetadata.every((item) => item.imagePositionPatient)) {
-        return null;
-    }
-    const positionGroups = groupBy(ippMetadata, 'imagePositionPatient');
-    const positions = Object.keys(positionGroups);
-    const frame_count = positionGroups[positions[0]].length;
-    if (frame_count === 1) {
-        return null;
-    }
-    const frame_count_equal = positions.every((k) => positionGroups[k].length === frame_count);
-    if (!frame_count_equal) {
-        return null;
-    }
-    return positionGroups;
-}
-function test4DTag(IPPGroups, value_getter) {
-    const frame_groups = {};
-    let first_frame_value_set = [];
-    const positions = Object.keys(IPPGroups);
-    for (let i = 0; i < positions.length; i++) {
-        const frame_value_set = new Set();
-        const frames = IPPGroups[positions[i]];
-        for (let j = 0; j < frames.length; j++) {
-            const frame_value = value_getter(frames[j].imageId) || 0;
-            frame_groups[frame_value] = frame_groups[frame_value] || [];
-            frame_groups[frame_value].push({ imageId: frames[j].imageId });
-            frame_value_set.add(frame_value);
-            if (frame_value_set.size - 1 < j) {
-                return undefined;
-            }
-        }
-        if (i == 0) {
-            first_frame_value_set = Array.from(frame_value_set);
-        }
-        else if (!setEquals(first_frame_value_set, frame_value_set)) {
-            return undefined;
-        }
-    }
-    return frame_groups;
-}
-function getTagValue(imageId, tag) {
-    const value = metaData.get(tag, imageId);
-    try {
-        return parseFloat(value);
-    }
-    catch {
-        return undefined;
-    }
-}
-function getFiniteValue(imageId, tag) {
-    return toFiniteNumber(getTagValue(imageId, tag));
-}
-function getPhilipsPrivateBValue(imageId) {
-    const value = metaData.get('20011003', imageId);
-    try {
-        const { InlineBinary } = value;
-        if (InlineBinary) {
-            const value_bytes = atob(InlineBinary);
-            const ary_buf = new ArrayBuffer(value_bytes.length);
-            const dv = new DataView(ary_buf);
-            for (let i = 0; i < value_bytes.length; i++) {
-                dv.setUint8(i, value_bytes.charCodeAt(i));
-            }
-            return new Float32Array(ary_buf)[0];
-        }
-        return parseFloat(value);
-    }
-    catch {
-        return undefined;
-    }
-}
-function getSiemensPrivateBValue(imageId) {
-    let value = metaData.get('0019100c', imageId) || metaData.get('0019100C', imageId);
-    try {
-        const { InlineBinary } = value;
-        if (InlineBinary) {
-            value = atob(InlineBinary);
-        }
-        return parseFloat(value);
-    }
-    catch {
-        return undefined;
-    }
-}
-function getGEPrivateBValue(imageId) {
-    let value = metaData.get('00431039', imageId);
-    try {
-        const { InlineBinary } = value;
-        if (InlineBinary) {
-            value = atob(InlineBinary).split('//');
-        }
-        return parseFloat(value[0]) % 100000;
-    }
-    catch {
-        return undefined;
-    }
-}
-function setEquals(set_a, set_b) {
-    if (set_a.length != set_b.size) {
-        return false;
-    }
-    for (let i = 0; i < set_a.length; i++) {
-        if (!set_b.has(set_a[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-function getPetFrameReferenceTime(imageId) {
-    const moduleInfo = metaData.get('petImageModule', imageId);
-    return moduleInfo ? moduleInfo['frameReferenceTime'] : 0;
-}
-function splitImageIdsBy4DTags(imageIds) {
-    const multiframeResult = handleMultiframe4D(imageIds);
-    if (multiframeResult) {
-        return multiframeResult;
-    }
-    const cardiacResult = handleCardiac4D(imageIds);
-    if (cardiacResult) {
-        return cardiacResult;
-    }
-    const positionGroups = getIPPGroups(imageIds);
-    if (!positionGroups) {
-        return { imageIdGroups: [imageIds], splittingTag: null };
-    }
-    const tags = [
-        'TemporalPositionIdentifier',
-        'DiffusionBValue',
-        'TriggerTime',
-        'EchoTime',
-        'EchoNumber',
-        'PhilipsPrivateBValue',
-        'SiemensPrivateBValue',
-        'GEPrivateBValue',
-        'PetFrameReferenceTime',
-    ];
-    const fncList2 = [
-        (imageId) => getTagValue(imageId, tags[0]),
-        (imageId) => getTagValue(imageId, tags[1]),
-        (imageId) => getTagValue(imageId, tags[2]),
-        (imageId) => getTagValue(imageId, tags[3]),
-        (imageId) => getTagValue(imageId, tags[4]),
-        getPhilipsPrivateBValue,
-        getSiemensPrivateBValue,
-        getGEPrivateBValue,
-        getPetFrameReferenceTime,
-    ];
-    for (let i = 0; i < fncList2.length; i++) {
-        const frame_groups = test4DTag(positionGroups, fncList2[i]);
-        if (frame_groups) {
-            const sortedKeys = Object.keys(frame_groups)
-                .map(Number.parseFloat)
-                .sort((a, b) => a - b);
-            const imageIdGroups = sortedKeys.map((key) => frame_groups[key].map((item) => item.imageId));
-            return { imageIdGroups, splittingTag: tags[i] };
-        }
-    }
-    return { imageIdGroups: [imageIds], splittingTag: null };
-}
+import { utilities } from '@cornerstonejs/metadata';
+const { splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId } = utilities;
 export default splitImageIdsBy4DTags;
 export { handleMultiframe4D, generateFrameImageId };