@cornerstonejs/metadata 5.0.0

package/dist/esm/utilities/modules/ptImage.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/ptImage.js

@@ -0,0 +1,4 @@
+export const tags = [
+    'FrameReferenceTime',
+    'ActualFrameDuration',
+];

package/dist/esm/utilities/modules/ptIsotope.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/ptIsotope.js

@@ -0,0 +1 @@
+export const tags = [['RadiopharmaceuticalInfo', '00540016']];

package/dist/esm/utilities/modules/ptSeries.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/ptSeries.js

@@ -0,0 +1,5 @@
+export const tags = [
+    'CorrectedImage',
+    'Units',
+    'DecayCorrection',
+];

package/dist/esm/utilities/modules/radiopharmaceuticalInfo.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/radiopharmaceuticalInfo.js

@@ -0,0 +1,6 @@
+export const tags = [
+    'RadiopharmaceuticalStartTime',
+    'RadiopharmaceuticalStopTime',
+    'RadionuclideTotalDose',
+    'RadionuclideHalfLife',
+];

package/dist/esm/utilities/modules/sopCommon.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/sopCommon.js

@@ -0,0 +1 @@
+export const tags = ['SOPInstanceUID', 'SOPClassUID'];

package/dist/esm/utilities/modules/transferSyntax.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/transferSyntax.js

@@ -0,0 +1,4 @@
+export const tags = [
+    'TransferSyntaxUID',
+    'AvailableTransferSyntaxUID',
+];

package/dist/esm/utilities/modules/ultrasoundEnhancedRegion.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/ultrasoundEnhancedRegion.js

@@ -0,0 +1 @@
+export const tags = ['SequenceOfUltrasoundRegions'];

package/dist/esm/utilities/modules/unassigned.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/unassigned.js

@@ -0,0 +1,15 @@
+export const tags = [
+    'ReferencedImageSequence',
+    'ReferencedSOPClassUID',
+    'ReferencedSOPInstanceUID',
+    'ReferencedFrameNumber',
+    'SharedFunctionalGroupsSequence',
+    'PerFrameFunctionalGroupsSequence',
+    'PlanePositionSequence',
+    'AnatomicRegionSequence',
+    'PlaneOrientationSequence',
+    'PixelMeasuresSequence',
+    'PixelValueTransformationSequence',
+    'ParametricMapFrameTypeSequence',
+    'RealWorldValueMappingSequence',
+];

package/dist/esm/utilities/modules/usRegionChild.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/usRegionChild.js

@@ -0,0 +1,18 @@
+export const tags = [
+    'PhysicalDeltaX',
+    'PhysicalDeltaY',
+    'PhysicalUnitsXDirection',
+    'PhysicalUnitsYDirection',
+    'RegionLocationMinY0',
+    'RegionLocationMaxY1',
+    'RegionLocationMinX0',
+    'RegionLocationMaxX1',
+    'ReferencePixelX0',
+    'ReferencePixelY0',
+    ['ReferencePhysicalPixelValueY', '0018602A'],
+    ['ReferencePhysicalPixelValueX', '00186028'],
+    'RegionSpatialFormat',
+    'RegionDataType',
+    'RegionFlags',
+    'TransducerFrequency',
+];

package/dist/esm/utilities/modules/voiLut.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleTagEntry } from './index';
+export declare const tags: ModuleTagEntry[];

package/dist/esm/utilities/modules/voiLut.js

@@ -0,0 +1,6 @@
+export const tags = [
+    'WindowCenter',
+    'WindowWidth',
+    'VOILUTFunction',
+    'WindowCenterWidthExplanation',
+];

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

@@ -0,0 +1,12 @@
+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;
+};
+export default splitImageIdsBy4DTags;
+export { handleMultiframe4D, generateFrameImageId };

package/dist/esm/utilities/splitImageIdsBy4DTags.js

@@ -0,0 +1,314 @@
+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 };
+}
+export default splitImageIdsBy4DTags;
+export { handleMultiframe4D, generateFrameImageId };

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

@@ -0,0 +1,2 @@
+export { toNumber, toFiniteNumber } from '@cornerstonejs/utils';
+export { toNumber as default } from '@cornerstonejs/utils';

package/dist/esm/utilities/toNumber.js

@@ -0,0 +1,2 @@
+export { toNumber, toFiniteNumber } from '@cornerstonejs/utils';
+export { toNumber as default } from '@cornerstonejs/utils';

package/dist/esm/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "5.0.0";

package/dist/esm/version.js

@@ -0,0 +1 @@
+export const version = '5.0.0';

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@cornerstonejs/metadata",
+  "version": "5.0.0",
+  "description": "Cornerstone3D Metadata Foundation - Provider chain, DICOM stream parsing, tag modules, and series splitting",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "repository": "https://github.com/cornerstonejs/cornerstone3D",
+  "files": [
+    "./dist/"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "node": "./dist/esm/index.js",
+      "types": "./dist/esm/index.d.ts"
+    },
+    "./metaData": {
+      "import": "./dist/esm/metaData.js",
+      "node": "./dist/esm/metaData.js",
+      "types": "./dist/esm/metaData.d.ts"
+    },
+    "./enums": {
+      "import": "./dist/esm/enums/index.js",
+      "node": "./dist/esm/enums/index.js",
+      "types": "./dist/esm/enums/index.d.ts"
+    },
+    "./enums/*": {
+      "import": "./dist/esm/enums/*.js",
+      "node": "./dist/esm/enums/*.js",
+      "types": "./dist/esm/enums/*.d.ts"
+    },
+    "./utilities": {
+      "import": "./dist/esm/utilities/index.js",
+      "node": "./dist/esm/utilities/index.js",
+      "types": "./dist/esm/utilities/index.d.ts"
+    },
+    "./utilities/dicomStream": {
+      "import": "./dist/esm/utilities/dicomStream/index.js",
+      "node": "./dist/esm/utilities/dicomStream/index.js",
+      "types": "./dist/esm/utilities/dicomStream/index.d.ts"
+    },
+    "./utilities/metadataProvider": {
+      "import": "./dist/esm/utilities/metadataProvider/index.js",
+      "node": "./dist/esm/utilities/metadataProvider/index.js",
+      "types": "./dist/esm/utilities/metadataProvider/index.d.ts"
+    },
+    "./utilities/*": {
+      "import": "./dist/esm/utilities/*.js",
+      "node": "./dist/esm/utilities/*.js",
+      "types": "./dist/esm/utilities/*.d.ts"
+    },
+    "./types": {
+      "types": "./dist/esm/types/index.d.ts"
+    },
+    "./types/*": {
+      "types": "./dist/esm/types/*.d.ts"
+    },
+    "./version": {
+      "import": "./dist/esm/version.js",
+      "node": "./dist/esm/version.js",
+      "types": "./dist/esm/version.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prebuild": "node ../../scripts/generate-version.js ./",
+    "build:esm": "pnpm run prebuild && tsc --project ./tsconfig.json",
+    "build:esm:watch": "tsc --project ./tsconfig.json --watch",
+    "clean": "rm -rf node_modules/.cache/storybook && shx rm -rf dist",
+    "clean:deep": "pnpm run clean && shx rm -rf node_modules",
+    "build": "pnpm run build:esm",
+    "build:all": "pnpm run build:esm",
+    "dev": "tsc --project ./tsconfig.json --watch",
+    "api-check": "api-extractor --debug run",
+    "lint": "oxlint .",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "@cornerstonejs/calculate-suv": "1.0.3",
+    "@cornerstonejs/utils": "5.0.0",
+    "dcmjs": "0.50.1",
+    "gl-matrix": "3.4.3"
+  },
+  "contributors": [
+    {
+      "name": "Cornerstone.js Contributors",
+      "url": "https://github.com/orgs/cornerstonejs/people"
+    }
+  ],
+  "license": "MIT",
+  "funding": {
+    "type": "individual",
+    "url": "https://ohif.org/donate"
+  },
+  "gitHead": "d6f3fba43abcbaaf7468ff534588f6a88720b875"
+}