@cornerstonejs/dicom-image-loader 4.17.5 → 4.18.1

package/dist/esm/__tests__/ECGHelpers.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/__tests__/ECGHelpers.spec.js

@@ -0,0 +1,191 @@
+import { getECGModule } from '../imageLoader/wadors/metaData/ECGHelpers';
+describe('ECGHelpers', () => {
+    describe('getECGModule', () => {
+        it('should return null when no WaveformSequence is found', () => {
+            const metadata = {};
+            const result = getECGModule(metadata);
+            expect(result).toBeNull();
+        });
+        it('should parse ECG module from DICOM metadata with InlineBinary data', async () => {
+            const numberOfChannels = 2;
+            const numberOfSamples = 10;
+            const buffer = new ArrayBuffer(numberOfChannels * numberOfSamples * 2);
+            const view = new Int16Array(buffer);
+            for (let i = 0; i < numberOfSamples; i++) {
+                view[i * numberOfChannels + 0] = i * 100;
+                view[i * numberOfChannels + 1] = -i * 100;
+            }
+            const base64Data = btoa(String.fromCharCode(...new Uint8Array(buffer)));
+            const metadata = {
+                '54000100': {
+                    Value: [
+                        {
+                            '003A0005': { Value: [numberOfChannels] },
+                            '003A0010': { Value: [numberOfSamples] },
+                            '003A001A': { Value: [500] },
+                            '54001004': { Value: [16] },
+                            '54001006': { Value: ['SS'] },
+                            '003A0020': { Value: ['ECG'] },
+                            '003A0200': {
+                                Value: [
+                                    {
+                                        '003A0208': {
+                                            Value: [
+                                                {
+                                                    '00080104': { Value: ['Lead I'] },
+                                                },
+                                            ],
+                                        },
+                                    },
+                                    {
+                                        '003A0208': {
+                                            Value: [
+                                                {
+                                                    '00080104': { Value: ['Lead II'] },
+                                                },
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                            '54001010': {
+                                InlineBinary: base64Data,
+                            },
+                        },
+                    ],
+                },
+            };
+            const result = getECGModule(metadata);
+            expect(result).not.toBeNull();
+            expect(result?.numberOfWaveformChannels).toBe(numberOfChannels);
+            expect(result?.numberOfWaveformSamples).toBe(numberOfSamples);
+            expect(result?.samplingFrequency).toBe(500);
+            expect(result?.waveformBitsAllocated).toBe(16);
+            expect(result?.waveformSampleInterpretation).toBe('SS');
+            expect(result?.multiplexGroupLabel).toBe('ECG');
+            expect(result?.channelDefinitionSequence.length).toBe(2);
+            expect(result?.channelDefinitionSequence[0].channelSourceSequence?.codeMeaning).toBe('Lead I');
+            expect(result?.channelDefinitionSequence[1].channelSourceSequence?.codeMeaning).toBe('Lead II');
+        });
+        it('should have a retrieveBulkData function that decodes InlineBinary data', async () => {
+            const numberOfChannels = 2;
+            const numberOfSamples = 5;
+            const buffer = new ArrayBuffer(numberOfChannels * numberOfSamples * 2);
+            const view = new Int16Array(buffer);
+            for (let i = 0; i < numberOfSamples; i++) {
+                view[i * numberOfChannels + 0] = i * 100;
+                view[i * numberOfChannels + 1] = -i * 100;
+            }
+            const base64Data = btoa(String.fromCharCode(...new Uint8Array(buffer)));
+            const metadata = {
+                '54000100': {
+                    Value: [
+                        {
+                            '003A0005': { Value: [numberOfChannels] },
+                            '003A0010': { Value: [numberOfSamples] },
+                            '003A001A': { Value: [500] },
+                            '54001004': { Value: [16] },
+                            '54001006': { Value: ['SS'] },
+                            '003A0020': { Value: ['ECG'] },
+                            '003A0200': { Value: [] },
+                            '54001010': {
+                                InlineBinary: base64Data,
+                            },
+                        },
+                    ],
+                },
+            };
+            const ecgModule = getECGModule(metadata);
+            expect(ecgModule).not.toBeNull();
+            expect(ecgModule?.waveformData.retrieveBulkData).toBeDefined();
+            const channelArrays = await ecgModule.waveformData.retrieveBulkData();
+            expect(channelArrays.length).toBe(numberOfChannels);
+            expect(channelArrays[0].length).toBe(numberOfSamples);
+            expect(channelArrays[1].length).toBe(numberOfSamples);
+            expect(channelArrays[0][0]).toBe(0);
+            expect(channelArrays[0][1]).toBe(100);
+            expect(channelArrays[1][0]).toBe(0);
+            expect(channelArrays[1][1]).toBe(-100);
+        });
+        it('should throw error when no data source is found', async () => {
+            const metadata = {
+                '54000100': {
+                    Value: [
+                        {
+                            '003A0005': { Value: [2] },
+                            '003A0010': { Value: [10] },
+                            '003A001A': { Value: [500] },
+                            '003A0200': { Value: [] },
+                            '54001010': {},
+                        },
+                    ],
+                },
+            };
+            const ecgModule = getECGModule(metadata);
+            expect(ecgModule).not.toBeNull();
+            try {
+                await ecgModule.waveformData.retrieveBulkData();
+                throw new Error('Expected retrieveBulkData to throw');
+            }
+            catch (error) {
+                expect(error.message).toContain('[ECGHelpers] No data source found in WaveformData');
+            }
+        });
+        it('should handle metadata with default values', () => {
+            const numberOfChannels = 1;
+            const numberOfSamples = 20;
+            const metadata = {
+                '54000100': {
+                    Value: [
+                        {
+                            '003A0005': { Value: [numberOfChannels] },
+                            '003A0010': { Value: [numberOfSamples] },
+                            '003A001A': { Value: [250] },
+                            '003A0200': { Value: [] },
+                            '54001010': { Value: [] },
+                        },
+                    ],
+                },
+            };
+            const result = getECGModule(metadata);
+            expect(result).not.toBeNull();
+            expect(result?.waveformBitsAllocated).toBe(16);
+            expect(result?.waveformSampleInterpretation).toBe('SS');
+            expect(result?.multiplexGroupLabel).toBe('ECG');
+        });
+        it('should parse channel definitions correctly', () => {
+            const metadata = {
+                '54000100': {
+                    Value: [
+                        {
+                            '003A0005': { Value: [3] },
+                            '003A0010': { Value: [100] },
+                            '003A001A': { Value: [500] },
+                            '003A0200': {
+                                Value: [
+                                    {
+                                        '003A0208': {
+                                            Value: [{ '00080104': { Value: ['Channel A'] } }],
+                                        },
+                                    },
+                                    {
+                                        '003A0208': {
+                                            Value: [{ '00080104': { Value: ['Channel B'] } }],
+                                        },
+                                    },
+                                    {},
+                                ],
+                            },
+                            '54001010': { Value: [] },
+                        },
+                    ],
+                },
+            };
+            const result = getECGModule(metadata);
+            expect(result?.channelDefinitionSequence.length).toBe(3);
+            expect(result?.channelDefinitionSequence[0].channelSourceSequence?.codeMeaning).toBe('Channel A');
+            expect(result?.channelDefinitionSequence[1].channelSourceSequence?.codeMeaning).toBe('Channel B');
+            expect(result?.channelDefinitionSequence[2].channelSourceSequence?.codeMeaning).toBe('Unknown');
+        });
+    });
+});

package/dist/esm/imageLoader/wadors/metaData/ECGHelpers.d.ts

@@ -0,0 +1,17 @@
+export interface EcgModule {
+    numberOfWaveformChannels: number;
+    numberOfWaveformSamples: number;
+    samplingFrequency: number;
+    waveformBitsAllocated: number;
+    waveformSampleInterpretation: string;
+    multiplexGroupLabel: string;
+    channelDefinitionSequence: Array<{
+        channelSourceSequence?: {
+            codeMeaning?: string;
+        };
+    }>;
+    waveformData: {
+        retrieveBulkData: () => Promise<Int16Array[]>;
+    };
+}
+export declare function getECGModule(metadata: Record<string, unknown>, wadoRsRoot?: string, studyUID?: string): EcgModule | null;

package/dist/esm/imageLoader/wadors/metaData/ECGHelpers.js

@@ -0,0 +1,179 @@
+import getValue from './getValue';
+import getNumberValue from './getNumberValue';
+import getSequenceItems from './getSequenceItems';
+const TAG = {
+    WaveformSequence: '54000100',
+    NumberOfWaveformChannels: '003A0005',
+    NumberOfWaveformSamples: '003A0010',
+    SamplingFrequency: '003A001A',
+    MultiplexGroupLabel: '003A0020',
+    ChannelDefinitionSequence: '003A0200',
+    ChannelSourceSequence: '003A0208',
+    CodeMeaning: '00080104',
+    WaveformBitsAllocated: '54001004',
+    WaveformSampleInterpretation: '54001006',
+    WaveformData: '54001010',
+};
+function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+function convertBuffer(dataSrc, numberOfChannels, numberOfSamples, bits, type) {
+    const data = new Uint8Array(dataSrc);
+    if (bits === 16 && type === 'SS') {
+        const ret = [];
+        const bytesPerSample = 2;
+        const totalBytes = bytesPerSample * numberOfChannels * numberOfSamples;
+        const length = Math.min(data.length, totalBytes);
+        for (let channel = 0; channel < numberOfChannels; channel++) {
+            const buffer = new Int16Array(numberOfSamples);
+            ret.push(buffer);
+            let sampleI = 0;
+            for (let sample = 2 * channel; sample < length; sample += 2 * numberOfChannels) {
+                const highByte = data[sample + 1];
+                const lowByte = data[sample];
+                const sign = highByte & 0x80;
+                buffer[sampleI++] = sign
+                    ? 0xffff0000 | (highByte << 8) | lowByte
+                    : (highByte << 8) | lowByte;
+            }
+        }
+        return ret;
+    }
+    console.warn(`[ECGHelpers] Unsupported waveform format: ${bits}-bit ${type}. Only 16-bit SS is supported.`);
+    return [];
+}
+function multipartDecode(response) {
+    const message = new Uint8Array(response);
+    const separator = new TextEncoder().encode('\r\n\r\n');
+    const headerIndex = findToken(message, separator, 0, 1000);
+    if (headerIndex === -1) {
+        return [response];
+    }
+    const headerStr = new TextDecoder().decode(message.slice(0, headerIndex));
+    const boundaryString = identifyBoundary(headerStr);
+    if (!boundaryString) {
+        return [response];
+    }
+    const boundary = new TextEncoder().encode(boundaryString);
+    const components = [];
+    let offset = headerIndex + separator.length;
+    let boundaryIndex = findToken(message, boundary, offset);
+    while (boundaryIndex !== -1) {
+        const contentStart = findToken(message, separator, boundaryIndex, 1000);
+        if (contentStart === -1) {
+            break;
+        }
+        const dataStart = contentStart + separator.length;
+        const nextBoundary = findToken(message, boundary, dataStart);
+        const dataEnd = nextBoundary === -1 ? message.length : nextBoundary - 2;
+        components.push(response.slice(dataStart, dataEnd));
+        if (nextBoundary === -1) {
+            break;
+        }
+        offset = nextBoundary;
+        boundaryIndex = findToken(message, boundary, offset + boundary.length);
+        if (boundaryIndex === -1) {
+            break;
+        }
+    }
+    return components.length > 0 ? components : [response];
+}
+function findToken(message, token, startIndex, maxLength) {
+    const end = maxLength
+        ? Math.min(message.length, startIndex + maxLength)
+        : message.length;
+    for (let i = startIndex; i < end - token.length + 1; i++) {
+        let found = true;
+        for (let j = 0; j < token.length; j++) {
+            if (message[i + j] !== token[j]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            return i;
+        }
+    }
+    return -1;
+}
+function identifyBoundary(header) {
+    const match = header.match(/boundary=([^\s;]+)/i);
+    if (match) {
+        return `--${match[1].replace(/"/g, '')}`;
+    }
+    return null;
+}
+function makeRetrieveBulkData(waveformData, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation, wadoRsRoot, studyUID) {
+    return async () => {
+        if (waveformData.Value) {
+            return waveformData.Value;
+        }
+        if (waveformData.InlineBinary) {
+            const raw = base64ToUint8Array(waveformData.InlineBinary);
+            return convertBuffer(raw, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        if (typeof waveformData.retrieveBulkData === 'function') {
+            const bulkdata = await waveformData.retrieveBulkData();
+            return convertBuffer(bulkdata, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        if (waveformData.BulkDataURI) {
+            let url = waveformData.BulkDataURI;
+            if (url.indexOf(':') === -1 && wadoRsRoot) {
+                url = studyUID
+                    ? `${wadoRsRoot}/studies/${studyUID}/${url}`
+                    : `${wadoRsRoot}/${url}`;
+            }
+            const response = await fetch(url);
+            const buffer = await response.arrayBuffer();
+            const contentType = response.headers.get('content-type') || '';
+            const decoded = contentType.includes('multipart')
+                ? multipartDecode(buffer)[0]
+                : buffer;
+            return convertBuffer(decoded, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        throw new Error('[ECGHelpers] No data source found in WaveformData');
+    };
+}
+export function getECGModule(metadata, wadoRsRoot, studyUID) {
+    const waveformSeqItems = getSequenceItems(metadata[TAG.WaveformSequence]);
+    if (!waveformSeqItems || waveformSeqItems.length === 0) {
+        return null;
+    }
+    const waveform = waveformSeqItems[0];
+    const numberOfChannels = getNumberValue(waveform[TAG.NumberOfWaveformChannels]);
+    const numberOfSamples = getNumberValue(waveform[TAG.NumberOfWaveformSamples]);
+    const samplingFrequency = getNumberValue(waveform[TAG.SamplingFrequency]);
+    const waveformBitsAllocated = getNumberValue(waveform[TAG.WaveformBitsAllocated]) ?? 16;
+    const waveformSampleInterpretation = getValue(waveform[TAG.WaveformSampleInterpretation]) ?? 'SS';
+    const multiplexGroupLabel = getValue(waveform[TAG.MultiplexGroupLabel]) ?? 'ECG';
+    const channelDefItems = getSequenceItems(waveform[TAG.ChannelDefinitionSequence]);
+    const channelDefinitionSequence = (channelDefItems || []).map((channelDef) => {
+        const channelDefRecord = channelDef;
+        const sourceSeqItems = getSequenceItems(channelDefRecord[TAG.ChannelSourceSequence]);
+        const sourceSeq = sourceSeqItems?.[0] || {};
+        const codeMeaning = getValue(sourceSeq[TAG.CodeMeaning]);
+        return {
+            channelSourceSequence: {
+                codeMeaning: codeMeaning || 'Unknown',
+            },
+        };
+    });
+    const waveformDataObj = waveform[TAG.WaveformData] || {};
+    return {
+        numberOfWaveformChannels: numberOfChannels,
+        numberOfWaveformSamples: numberOfSamples,
+        samplingFrequency,
+        waveformBitsAllocated,
+        waveformSampleInterpretation,
+        multiplexGroupLabel,
+        channelDefinitionSequence,
+        waveformData: {
+            retrieveBulkData: makeRetrieveBulkData(waveformDataObj, numberOfChannels, numberOfSamples, waveformBitsAllocated, waveformSampleInterpretation, wadoRsRoot, studyUID),
+        },
+    };
+}

package/dist/esm/imageLoader/wadors/metaData/metaDataProvider.js

@@ -1,4 +1,3 @@
-import * as dicomParser from 'dicom-parser';
 import { Enums, utilities, metaData as coreMetaData, } from '@cornerstonejs/core';
 import getNumberValues from './getNumberValues';
 import getNumberValue from './getNumberValue';
@@ -9,8 +8,9 @@ import { getMultiframeInformation, getFrameInformation, } from '../combineFrameI
 import { extractOrientationFromMetadata, extractPositionFromMetadata, } from './extractPositioningFromMetadata';
 import { getImageTypeSubItemFromMetadata } from './NMHelpers';
 import isNMReconstructable from '../../isNMReconstructable';
-import { getInstanceModule, instanceModuleNames, } from '../../getInstanceModule';
+import { instanceModuleNames } from '../../getInstanceModule';
 import { getUSEnhancedRegions } from './USHelpers';
+import { getECGModule } from './ECGHelpers';
 function metaDataProvider(type, imageId) {
     const { MetadataModules } = Enums;
     if (type === MetadataModules.MULTIFRAME) {
@@ -154,6 +154,20 @@ function metaDataProvider(type, imageId) {
     if (type === MetadataModules.ULTRASOUND_ENHANCED_REGION) {
         return getUSEnhancedRegions(metaData);
     }
+    if (type === MetadataModules.ECG) {
+        const imageUri = imageId.replace('wadors:', '');
+        const studiesIndex = imageUri.indexOf('/studies/');
+        let wadoRsRoot;
+        let studyUID;
+        if (studiesIndex !== -1) {
+            wadoRsRoot = imageUri.substring(0, studiesIndex);
+            const afterStudies = imageUri.substring(studiesIndex + 9);
+            const nextSlash = afterStudies.indexOf('/');
+            studyUID =
+                nextSlash !== -1 ? afterStudies.substring(0, nextSlash) : afterStudies;
+        }
+        return getECGModule(metaData, wadoRsRoot, studyUID);
+    }
     if (type === MetadataModules.CALIBRATION) {
         const modality = getValue(metaData['00080060']);
         if (modality === 'US') {
@@ -162,6 +176,42 @@ function metaDataProvider(type, imageId) {
                 sequenceOfUltrasoundRegions: enhancedRegion,
             };
         }
+        const imageUri = imageId.replace('wadors:', '');
+        const studiesIndex = imageUri.indexOf('/studies/');
+        let wadoRsRoot;
+        let studyUID;
+        if (studiesIndex !== -1) {
+            wadoRsRoot = imageUri.substring(0, studiesIndex);
+            const afterStudies = imageUri.substring(studiesIndex + 9);
+            const nextSlash = afterStudies.indexOf('/');
+            studyUID =
+                nextSlash !== -1 ? afterStudies.substring(0, nextSlash) : afterStudies;
+        }
+        const ecgModule = getECGModule(metaData, wadoRsRoot, studyUID);
+        if (ecgModule) {
+            const { numberOfWaveformSamples, samplingFrequency } = ecgModule;
+            const physicalDeltaX = 1 / (samplingFrequency || 1);
+            const physicalDeltaY = 0.001;
+            const ECG_AMPLITUDE_INDEX_SIZE = 65536;
+            const ECG_AMPLITUDE_OFFSET = 32768;
+            return {
+                sequenceOfUltrasoundRegions: [
+                    {
+                        regionLocationMinX0: 0,
+                        regionLocationMaxX1: numberOfWaveformSamples,
+                        regionLocationMinY0: 0,
+                        regionLocationMaxY1: ECG_AMPLITUDE_INDEX_SIZE - 1,
+                        referencePixelX0: 0,
+                        referencePixelY0: ECG_AMPLITUDE_OFFSET,
+                        physicalDeltaX,
+                        physicalDeltaY,
+                        physicalUnitsXDirection: 4,
+                        physicalUnitsYDirection: -1,
+                        regionDataType: 1,
+                    },
+                ],
+            };
+        }
     }
     if (type === MetadataModules.IMAGE_URL) {
         return getImageUrlModule(imageId, metaData);

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.17.5";
+export declare const version = "4.18.1";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.17.5';
+export const version = '4.18.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/dicom-image-loader",
-  "version": "4.17.5",
+  "version": "4.18.1",
   "description": "Cornerstone Image Loader for DICOM WADO-URI and WADO-RS and Local file",
   "keywords": [
     "DICOM",
@@ -112,7 +112,7 @@
     "uuid": "9.0.1"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.17.5",
+    "@cornerstonejs/core": "4.18.1",
     "dicom-parser": "1.8.21"
   },
   "config": {
@@ -120,5 +120,5 @@
       "path": "./node_modules/cz-conventional-changelog"
     }
   },
-  "gitHead": "d42f5ee3747c6521ef3af5e9d1faf69c98157396"
+  "gitHead": "1fc5684032269b1b1e3e3733cd891d48c27303f7"
 }