@cornerstonejs/dicom-image-loader 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/esm/src/imageLoader/wadors/extractMultipart.js

@@ -0,0 +1,73 @@
+import { Enums } from '@cornerstonejs/core';
+import findIndexOfString from './findIndexOfString';
+const { ImageQualityStatus } = Enums;
+export default function extractMultipart(contentType, imageFrameAsArrayBuffer, options) {
+    options ||= {};
+    const response = new Uint8Array(imageFrameAsArrayBuffer);
+    const isPartial = !!options?.isPartial;
+    if (contentType.indexOf('multipart') === -1) {
+        return {
+            contentType,
+            imageQualityStatus: isPartial
+                ? ImageQualityStatus.SUBRESOLUTION
+                : ImageQualityStatus.FULL_RESOLUTION,
+            pixelData: response,
+        };
+    }
+    let { tokenIndex, responseHeaders, boundary, multipartContentType } = options;
+    tokenIndex ||= findIndexOfString(response, '\r\n\r\n');
+    if (tokenIndex === -1) {
+        throw new Error('invalid response - no multipart mime header');
+    }
+    if (!boundary) {
+        const header = uint8ArrayToString(response, 0, tokenIndex);
+        responseHeaders = header.split('\r\n');
+        boundary = findBoundary(responseHeaders);
+        if (!boundary) {
+            throw new Error('invalid response - no boundary marker');
+        }
+    }
+    const offset = tokenIndex + 4;
+    const endIndex = findIndexOfString(response, boundary, offset);
+    if (endIndex === -1 && !isPartial) {
+        throw new Error('invalid response - terminating boundary not found');
+    }
+    multipartContentType ||= findContentType(responseHeaders);
+    options.tokenIndex = tokenIndex;
+    options.boundary = boundary;
+    options.responseHeaders = responseHeaders;
+    options.multipartContentType = multipartContentType;
+    options.isPartial = endIndex === -1;
+    return {
+        contentType: multipartContentType,
+        extractDone: !isPartial || endIndex !== -1,
+        tokenIndex,
+        responseHeaders,
+        boundary,
+        multipartContentType,
+        pixelData: imageFrameAsArrayBuffer.slice(offset, endIndex - 2),
+    };
+}
+export function findBoundary(header) {
+    for (let i = 0; i < header.length; i++) {
+        if (header[i].substr(0, 2) === '--') {
+            return header[i];
+        }
+    }
+}
+export function findContentType(header) {
+    for (let i = 0; i < header.length; i++) {
+        if (header[i].substr(0, 13) === 'Content-Type:') {
+            return header[i].substr(13).trim();
+        }
+    }
+}
+export function uint8ArrayToString(data, offset, length) {
+    offset = offset || 0;
+    length = length || data.length - offset;
+    let str = '';
+    for (let i = offset; i < offset + length; i++) {
+        str += String.fromCharCode(data[i]);
+    }
+    return str;
+}

package/dist/esm/src/imageLoader/wadors/findIndexOfString.d.ts

@@ -0,0 +1,2 @@
+declare function findIndexOfString(data: Uint8Array, str: string, offset?: number): number;
+export default findIndexOfString;

package/dist/esm/src/imageLoader/wadors/findIndexOfString.js

@@ -0,0 +1,32 @@
+function checkToken(token, data, dataOffset) {
+    if (dataOffset + token.length > data.length) {
+        return false;
+    }
+    let endIndex = dataOffset;
+    for (let i = 0; i < token.length; i++) {
+        if (token[i] !== data[endIndex++]) {
+            return false;
+        }
+    }
+    return true;
+}
+function stringToUint8Array(str) {
+    const uint = new Uint8Array(str.length);
+    for (let i = 0, j = str.length; i < j; i++) {
+        uint[i] = str.charCodeAt(i);
+    }
+    return uint;
+}
+function findIndexOfString(data, str, offset) {
+    offset = offset || 0;
+    const token = stringToUint8Array(str);
+    for (let i = offset; i < data.length; i++) {
+        if (token[0] === data[i]) {
+            if (checkToken(token, data, i)) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+export default findIndexOfString;

package/dist/esm/src/imageLoader/wadors/getImageQualityStatus.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import { Enums } from '@cornerstonejs/core';
+export declare function getImageQualityStatus(retrieveOptions: Types.RetrieveOptions, done?: boolean): Enums.ImageQualityStatus;

package/dist/esm/src/imageLoader/wadors/getImageQualityStatus.js

@@ -0,0 +1,8 @@
+import { Enums } from '@cornerstonejs/core';
+const { ImageQualityStatus } = Enums;
+export function getImageQualityStatus(retrieveOptions, done = true) {
+    if (!done) {
+        return ImageQualityStatus.SUBRESOLUTION;
+    }
+    return (retrieveOptions.imageQualityStatus ?? ImageQualityStatus.FULL_RESOLUTION);
+}

package/dist/esm/src/imageLoader/wadors/getPixelData.d.ts

@@ -0,0 +1,26 @@
+import type { CornerstoneWadoRsLoaderOptions } from './loadImage';
+declare function getPixelData(uri: string, imageId: string, mediaType?: string, options?: CornerstoneWadoRsLoaderOptions): import("packages/core/dist/esm/utilities/ProgressiveIterator").PromiseIterator<unknown> | import("../../types").LoaderXhrRequestPromise<{
+    contentType: string;
+    pixelData: Uint8Array;
+    imageQualityStatus: import("packages/core/dist/esm/enums").ImageQualityStatus;
+    percentComplete: number;
+}> | Promise<{
+    contentType: string;
+    imageQualityStatus: import("packages/core/dist/esm/enums").ImageQualityStatus;
+    pixelData: Uint8Array;
+    extractDone?: undefined;
+    tokenIndex?: undefined;
+    responseHeaders?: undefined;
+    boundary?: undefined;
+    multipartContentType?: undefined;
+} | {
+    contentType: any;
+    extractDone: boolean;
+    tokenIndex: any;
+    responseHeaders: any;
+    boundary: any;
+    multipartContentType: any;
+    pixelData: any;
+    imageQualityStatus?: undefined;
+}>;
+export default getPixelData;

package/dist/esm/src/imageLoader/wadors/getPixelData.js

@@ -0,0 +1,35 @@
+import { xhrRequest } from '../internal/index';
+import streamRequest from '../internal/streamRequest';
+import rangeRequest from '../internal/rangeRequest';
+import extractMultipart from './extractMultipart';
+import { getImageQualityStatus } from './getImageQualityStatus';
+function getPixelData(uri, imageId, mediaType = 'application/octet-stream', options) {
+    const { streamingData, retrieveOptions = {} } = options || {};
+    const headers = {
+        Accept: mediaType,
+    };
+    let url = retrieveOptions.urlArguments
+        ? `${uri}${uri.indexOf('?') === -1 ? '?' : '&'}${retrieveOptions.urlArguments}`
+        : uri;
+    if (retrieveOptions.framesPath) {
+        url = url.replace('/frames/', retrieveOptions.framesPath);
+    }
+    if (streamingData?.url !== url) {
+        options.streamingData = { url };
+    }
+    if (retrieveOptions.rangeIndex !== undefined) {
+        return rangeRequest(url, imageId, headers, options);
+    }
+    if (retrieveOptions.streaming) {
+        return streamRequest(url, imageId, headers, options);
+    }
+    const loadPromise = xhrRequest(url, imageId, headers);
+    const { xhr } = loadPromise;
+    return loadPromise.then(function (imageFrameAsArrayBuffer) {
+        const contentType = xhr.getResponseHeader('Content-Type') || 'application/octet-stream';
+        const extracted = extractMultipart(contentType, new Uint8Array(imageFrameAsArrayBuffer));
+        extracted.imageQualityStatus = getImageQualityStatus(retrieveOptions, true);
+        return extracted;
+    });
+}
+export default getPixelData;

package/dist/esm/src/imageLoader/wadors/getTagValue.d.ts

@@ -0,0 +1 @@
+export default function getTagValue(tag: any, justElement?: boolean): any;

package/dist/esm/src/imageLoader/wadors/getTagValue.js

@@ -0,0 +1,9 @@
+export default function getTagValue(tag, justElement = true) {
+    if (tag && tag.Value) {
+        if (tag.Value[0] && justElement) {
+            return tag.Value[0];
+        }
+        return tag.Value;
+    }
+    return tag;
+}

package/dist/esm/src/imageLoader/wadors/index.d.ts

@@ -0,0 +1,25 @@
+import { getNumberString, getNumberValue, getNumberValues, getValue, metaDataProvider } from './metaData/index';
+import findIndexOfString from './findIndexOfString';
+import getPixelData from './getPixelData';
+import loadImage from './loadImage';
+import register from './register';
+declare const _default: {
+    metaData: {
+        getNumberString: typeof getNumberString;
+        getNumberValue: typeof getNumberValue;
+        getNumberValues: typeof getNumberValues;
+        getValue: typeof getValue;
+        metaDataProvider: typeof metaDataProvider;
+    };
+    findIndexOfString: typeof findIndexOfString;
+    getPixelData: typeof getPixelData;
+    loadImage: typeof loadImage;
+    metaDataManager: {
+        add: (imageId: string, metadata: import("../../types").WADORSMetaData) => void;
+        get: (imageId: string) => import("../../types").WADORSMetaData;
+        remove: (imageId: any) => void;
+        purge: () => void;
+    };
+    register: typeof register;
+};
+export default _default;

package/dist/esm/src/imageLoader/wadors/index.js

@@ -0,0 +1,21 @@
+import { getNumberString, getNumberValue, getNumberValues, getValue, metaDataProvider, } from './metaData/index';
+import findIndexOfString from './findIndexOfString';
+import getPixelData from './getPixelData';
+import metaDataManager from './metaDataManager';
+import loadImage from './loadImage';
+import register from './register';
+const metaData = {
+    getNumberString,
+    getNumberValue,
+    getNumberValues,
+    getValue,
+    metaDataProvider,
+};
+export default {
+    metaData,
+    findIndexOfString,
+    getPixelData,
+    loadImage,
+    metaDataManager,
+    register,
+};

package/dist/esm/src/imageLoader/wadors/loadImage.d.ts

@@ -0,0 +1,25 @@
+import type { Types } from '@cornerstonejs/core';
+import type { DICOMLoaderImageOptions } from '../../types';
+export declare function getTransferSyntaxForContentType(contentType: string): string;
+export interface StreamingData {
+    url: string;
+    encodedData?: Uint8Array;
+    totalBytes?: number;
+    chunkSize?: number;
+    totalRanges?: number;
+    rangesFetched?: number;
+}
+export interface CornerstoneWadoRsLoaderOptions extends DICOMLoaderImageOptions {
+    requestType?: string;
+    additionalDetails?: {
+        imageId: string;
+    };
+    priority?: number;
+    addToBeginning?: boolean;
+    retrieveType?: string;
+    transferSyntaxUID?: string;
+    retrieveOptions?: Types.RangeRetrieveOptions;
+    streamingData?: StreamingData;
+}
+declare function loadImage(imageId: string, options?: CornerstoneWadoRsLoaderOptions): Types.IImageLoadObject;
+export default loadImage;

package/dist/esm/src/imageLoader/wadors/loadImage.js

@@ -0,0 +1,125 @@
+import { Enums, utilities } from '@cornerstonejs/core';
+import external from '../../externalModules';
+import createImage from '../createImage';
+import getPixelData from './getPixelData';
+const { ProgressiveIterator } = utilities;
+const { ImageQualityStatus } = Enums;
+const streamableTransferSyntaxes = new Set([
+    '3.2.840.10008.1.2.4.96',
+    '1.2.840.10008.1.2.4.202',
+    '1.2.840.10008.1.2.4.203',
+]);
+export function getTransferSyntaxForContentType(contentType) {
+    const defaultTransferSyntax = '1.2.840.10008.1.2';
+    if (!contentType) {
+        return defaultTransferSyntax;
+    }
+    const parameters = contentType.split(';');
+    const params = {};
+    parameters.forEach((parameter) => {
+        const parameterValues = parameter.split('=');
+        if (parameterValues.length !== 2) {
+            return;
+        }
+        const value = parameterValues[1].trim().replace(/"/g, '');
+        params[parameterValues[0].trim()] = value;
+    });
+    const defaultTransferSyntaxByType = {
+        'image/jpeg': '1.2.840.10008.1.2.4.50',
+        'image/x-dicom-rle': '1.2.840.10008.1.2.5',
+        'image/x-jls': '1.2.840.10008.1.2.4.80',
+        'image/jls': '1.2.840.10008.1.2.4.80',
+        'image/jll': '1.2.840.10008.1.2.4.70',
+        'image/jp2': '1.2.840.10008.1.2.4.90',
+        'image/jpx': '1.2.840.10008.1.2.4.92',
+        'image/jphc': '3.2.840.10008.1.2.4.96',
+        'image/jxl': '1.2.840.10008.1.2.4.140',
+    };
+    if (params['transfer-syntax']) {
+        return params['transfer-syntax'];
+    }
+    else if (contentType &&
+        !Object.keys(params).length &&
+        defaultTransferSyntaxByType[contentType]) {
+        return defaultTransferSyntaxByType[contentType];
+    }
+    else if (params.type && defaultTransferSyntaxByType[params.type]) {
+        return defaultTransferSyntaxByType[params.type];
+    }
+    else if (defaultTransferSyntaxByType[contentType]) {
+        return defaultTransferSyntaxByType[contentType];
+    }
+    return defaultTransferSyntax;
+}
+function getImageRetrievalPool() {
+    return external.cornerstone.imageRetrievalPoolManager;
+}
+const mediaType = 'multipart/related; type=application/octet-stream; transfer-syntax=*';
+function loadImage(imageId, options = {}) {
+    const imageRetrievalPool = getImageRetrievalPool();
+    const start = new Date().getTime();
+    const uncompressedIterator = new ProgressiveIterator('decompress');
+    async function sendXHR(imageURI, imageId, mediaType) {
+        uncompressedIterator.generate(async (it) => {
+            const compressedIt = ProgressiveIterator.as(getPixelData(imageURI, imageId, mediaType, options));
+            let lastDecodeLevel = 10;
+            for await (const result of compressedIt) {
+                const { pixelData, imageQualityStatus = ImageQualityStatus.FULL_RESOLUTION, percentComplete, done = true, extractDone = true, } = result;
+                const transferSyntax = getTransferSyntaxForContentType(result.contentType);
+                if (!extractDone && !streamableTransferSyntaxes.has(transferSyntax)) {
+                    continue;
+                }
+                const decodeLevel = result.decodeLevel ??
+                    (imageQualityStatus === ImageQualityStatus.FULL_RESOLUTION
+                        ? 0
+                        : decodeLevelFromComplete(percentComplete, options.retrieveOptions?.decodeLevel));
+                if (!done && lastDecodeLevel <= decodeLevel) {
+                    continue;
+                }
+                try {
+                    const useOptions = {
+                        ...options,
+                        decodeLevel,
+                    };
+                    const image = (await createImage(imageId, pixelData, transferSyntax, useOptions));
+                    const end = new Date().getTime();
+                    image.loadTimeInMS = end - start;
+                    image.transferSyntaxUID = transferSyntax;
+                    image.imageQualityStatus = imageQualityStatus;
+                    it.add(image, done);
+                    lastDecodeLevel = decodeLevel;
+                }
+                catch (e) {
+                    if (extractDone) {
+                        console.warn("Couldn't decode", e);
+                        throw e;
+                    }
+                }
+            }
+        });
+    }
+    const requestType = options.requestType || 'interaction';
+    const additionalDetails = options.additionalDetails || { imageId };
+    const priority = options.priority === undefined ? 5 : options.priority;
+    const addToBeginning = options.addToBeginning || false;
+    const uri = imageId.substring(7);
+    imageRetrievalPool.addRequest(sendXHR.bind(this, uri, imageId, mediaType), requestType, additionalDetails, priority, addToBeginning);
+    return {
+        promise: uncompressedIterator.getDonePromise(),
+        cancelFn: undefined,
+    };
+}
+function decodeLevelFromComplete(percent, retrieveDecodeLevel = 4) {
+    const testSize = percent / 100 - 0.02;
+    if (testSize > 1 / 4) {
+        return Math.min(retrieveDecodeLevel, 0);
+    }
+    if (testSize > 1 / 16) {
+        return Math.min(retrieveDecodeLevel, 1);
+    }
+    if (testSize > 1 / 64) {
+        return Math.min(retrieveDecodeLevel, 2);
+    }
+    return Math.min(retrieveDecodeLevel, 3);
+}
+export default loadImage;

package/dist/esm/src/imageLoader/wadors/loadImage_test.d.ts

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

package/dist/esm/src/imageLoader/wadors/loadImage_test.js

@@ -0,0 +1,41 @@
+import { expect } from 'chai';
+import { getTransferSyntaxForContentType } from './loadImage';
+const cases = [
+    [undefined, '1.2.840.10008.1.2'],
+    [null, '1.2.840.10008.1.2'],
+    ['', '1.2.840.10008.1.2'],
+    ['multipart/related; type="application/octet-stream"', '1.2.840.10008.1.2'],
+    [
+        'multipart/related; type="application/octet-stream"; transfer-syntax= ',
+        '1.2.840.10008.1.2',
+    ],
+    [
+        'multipart/related; type=image/dicom+jpeg; transfer-syntax=1.2.840.10008.1.2.4.70',
+        '1.2.840.10008.1.2.4.70',
+    ],
+    [
+        'multipart/related; image/dicom+jpx; transfer-syntax=1.2.840.10008.1.2.4.93',
+        '1.2.840.10008.1.2.4.93',
+    ],
+    [
+        'multipart/related; video/mpeg; transfer-syntax=1.2.840.10008.1.2.4.100',
+        '1.2.840.10008.1.2.4.100',
+    ],
+    ['multipart/related; type="image/jpeg"', '1.2.840.10008.1.2.4.50'],
+    ['multipart/related; type="image/x-jls"', '1.2.840.10008.1.2.4.80'],
+    ['multipart/related; type="image/x-dicom-rle"', '1.2.840.10008.1.2.5'],
+    ['multipart/related; type="image/jp2"', '1.2.840.10008.1.2.4.90'],
+    ['multipart/related; type="image/jpx"', '1.2.840.10008.1.2.4.92'],
+];
+describe('#getTransferSyntaxForContentType', function () {
+    cases.forEach(function (testCase) {
+        const contentType = testCase[0];
+        const expectedTransferSyntax = testCase[1];
+        it(`given a content type of ${contentType}, should return ${expectedTransferSyntax}`, () => {
+            const transferSyntax = getTransferSyntaxForContentType(contentType);
+            console.log(transferSyntax);
+            console.log(expectedTransferSyntax);
+            expect(transferSyntax).to.be.equal(expectedTransferSyntax);
+        });
+    });
+});

package/dist/esm/src/imageLoader/wadors/metaData/NMHelpers.d.ts

@@ -0,0 +1,5 @@
+declare function isNMModality(metaData: any): boolean;
+declare function getImageTypeSubItemFromMetadata(metaData: any, index: any): any;
+declare function extractOrientationFromNMMultiframeMetadata(metaData: any): any;
+declare function extractPositionFromNMMultiframeMetadata(metaData: any): any;
+export { extractOrientationFromNMMultiframeMetadata, extractPositionFromNMMultiframeMetadata, isNMModality, getImageTypeSubItemFromMetadata, };

package/dist/esm/src/imageLoader/wadors/metaData/NMHelpers.js

@@ -0,0 +1,38 @@
+import getTagValue from '../getTagValue';
+import getValue from './getValue';
+import isNMReconstructable from '../../isNMReconstructable';
+import getNumberValues from './getNumberValues';
+function isNMModality(metaData) {
+    const modality = getValue(metaData['00080060']);
+    return modality.includes('NM');
+}
+function getImageTypeSubItemFromMetadata(metaData, index) {
+    const imageType = getTagValue(metaData['00080008'], false);
+    if (imageType) {
+        return imageType[index];
+    }
+    return undefined;
+}
+function extractOrientationFromNMMultiframeMetadata(metaData) {
+    let imageOrientationPatient;
+    const imageSubType = getImageTypeSubItemFromMetadata(metaData, 2);
+    if (imageSubType && isNMReconstructable(imageSubType)) {
+        const detectorInformationSequence = getTagValue(metaData['00540022']);
+        if (detectorInformationSequence) {
+            imageOrientationPatient = getNumberValues(detectorInformationSequence['00200037'], 6);
+        }
+    }
+    return imageOrientationPatient;
+}
+function extractPositionFromNMMultiframeMetadata(metaData) {
+    let imagePositionPatient;
+    const imageSubType = getImageTypeSubItemFromMetadata(metaData, 2);
+    if (imageSubType && isNMReconstructable(imageSubType)) {
+        const detectorInformationSequence = getTagValue(metaData['00540022']);
+        if (detectorInformationSequence) {
+            imagePositionPatient = getNumberValues(detectorInformationSequence['00200032'], 3);
+        }
+    }
+    return imagePositionPatient;
+}
+export { extractOrientationFromNMMultiframeMetadata, extractPositionFromNMMultiframeMetadata, isNMModality, getImageTypeSubItemFromMetadata, };

package/dist/esm/src/imageLoader/wadors/metaData/USHelpers.d.ts

@@ -0,0 +1,19 @@
+declare function getUSEnhancedRegions(metadata: any): {
+    regionLocationMinY0: number;
+    regionLocationMaxY1: number;
+    regionLocationMinX0: number;
+    regionLocationMaxX1: number;
+    referencePixelX0: number;
+    referencePixelY0: number;
+    physicalDeltaX: number;
+    physicalDeltaY: number;
+    physicalUnitsXDirection: number;
+    physicalUnitsYDirection: number;
+    referencePhysicalPixelValueY: number;
+    referencePhysicalPixelValueX: number;
+    regionSpatialFormat: number;
+    regionDataType: number;
+    regionFlags: number;
+    transducerFrequency: number;
+}[];
+export { getUSEnhancedRegions };

package/dist/esm/src/imageLoader/wadors/metaData/USHelpers.js

@@ -0,0 +1,46 @@
+import { getFirstNumberValue } from './getFirstNumberValue';
+import getSequenceItems from './getSequenceItems';
+function getUSEnhancedRegions(metadata) {
+    const sequenceOfUltrasoundRegions = getSequenceItems(metadata['00186011']);
+    if (!sequenceOfUltrasoundRegions || !sequenceOfUltrasoundRegions.length) {
+        return null;
+    }
+    const regions = sequenceOfUltrasoundRegions.map((sequence) => {
+        const physicalDeltaX = getFirstNumberValue(sequence, '0018602C');
+        const physicalDeltaY = getFirstNumberValue(sequence, '0018602E');
+        const physicalUnitsXDirection = getFirstNumberValue(sequence, '00186024');
+        const physicalUnitsYDirection = getFirstNumberValue(sequence, '00186026');
+        const regionLocationMinY0 = getFirstNumberValue(sequence, '0018601A');
+        const regionLocationMaxY1 = getFirstNumberValue(sequence, '0018601E');
+        const regionLocationMinX0 = getFirstNumberValue(sequence, '00186018');
+        const regionLocationMaxX1 = getFirstNumberValue(sequence, '0018601C');
+        const referencePixelX0 = getFirstNumberValue(sequence, '00186020');
+        const referencePixelY0 = getFirstNumberValue(sequence, '00186022');
+        const referencePhysicalPixelValueY = getFirstNumberValue(sequence, '0018602A');
+        const referencePhysicalPixelValueX = getFirstNumberValue(sequence, '00186028');
+        const regionSpatialFormat = getFirstNumberValue(sequence, '00186012');
+        const regionDataType = getFirstNumberValue(sequence, '00186014');
+        const regionFlags = getFirstNumberValue(sequence, '00186016');
+        const transducerFrequency = getFirstNumberValue(sequence, '00186030');
+        return {
+            regionLocationMinY0,
+            regionLocationMaxY1,
+            regionLocationMinX0,
+            regionLocationMaxX1,
+            referencePixelX0,
+            referencePixelY0,
+            physicalDeltaX,
+            physicalDeltaY,
+            physicalUnitsXDirection,
+            physicalUnitsYDirection,
+            referencePhysicalPixelValueY,
+            referencePhysicalPixelValueX,
+            regionSpatialFormat,
+            regionDataType,
+            regionFlags,
+            transducerFrequency,
+        };
+    });
+    return regions;
+}
+export { getUSEnhancedRegions };

package/dist/esm/src/imageLoader/wadors/metaData/extractPositioningFromMetadata.d.ts

@@ -0,0 +1,3 @@
+declare function extractOrientationFromMetadata(metaData: any): number[];
+declare function extractPositionFromMetadata(metaData: any): number[];
+export { extractOrientationFromMetadata, extractPositionFromMetadata };

package/dist/esm/src/imageLoader/wadors/metaData/extractPositioningFromMetadata.js

@@ -0,0 +1,18 @@
+import getNumberValues from './getNumberValues';
+import { extractOrientationFromNMMultiframeMetadata, extractPositionFromNMMultiframeMetadata, isNMModality, } from './NMHelpers';
+function extractOrientationFromMetadata(metaData) {
+    let imageOrientationPatient = getNumberValues(metaData['00200037'], 6);
+    if (!imageOrientationPatient && isNMModality(metaData)) {
+        imageOrientationPatient =
+            extractOrientationFromNMMultiframeMetadata(metaData);
+    }
+    return imageOrientationPatient;
+}
+function extractPositionFromMetadata(metaData) {
+    let imagePositionPatient = getNumberValues(metaData['00200032'], 3);
+    if (!imagePositionPatient && isNMModality(metaData)) {
+        imagePositionPatient = extractPositionFromNMMultiframeMetadata(metaData);
+    }
+    return imagePositionPatient;
+}
+export { extractOrientationFromMetadata, extractPositionFromMetadata };

package/dist/esm/src/imageLoader/wadors/metaData/getFirstNumberValue.d.ts

@@ -0,0 +1,2 @@
+declare function getFirstNumberValue(sequence: unknown, key: string): number | null;
+export { getFirstNumberValue };

package/dist/esm/src/imageLoader/wadors/metaData/getFirstNumberValue.js

@@ -0,0 +1,6 @@
+import getNumberValues from './getNumberValues';
+function getFirstNumberValue(sequence, key) {
+    const values = getNumberValues(sequence[key]);
+    return values ? values[0] : null;
+}
+export { getFirstNumberValue };

package/dist/esm/src/imageLoader/wadors/metaData/getNumberString.d.ts

@@ -0,0 +1,3 @@
+import type { WADORSMetaDataElement } from '../../../types';
+declare function getNumberString(element: WADORSMetaDataElement, index: number, defaultValue: number): number;
+export default getNumberString;

package/dist/esm/src/imageLoader/wadors/metaData/getNumberString.js

@@ -0,0 +1,9 @@
+import getValue from './getValue';
+function getNumberString(element, index, defaultValue) {
+    const value = getValue(element, index, defaultValue);
+    if (value === undefined) {
+        return;
+    }
+    return parseFloat(String(value));
+}
+export default getNumberString;

package/dist/esm/src/imageLoader/wadors/metaData/getNumberValue.d.ts

@@ -0,0 +1,3 @@
+import type { WADORSMetaDataElement } from '../../../types';
+declare function getNumberValue(element: WADORSMetaDataElement, index?: number): number;
+export default getNumberValue;

package/dist/esm/src/imageLoader/wadors/metaData/getNumberValue.js

@@ -0,0 +1,9 @@
+import getValue from './getValue';
+function getNumberValue(element, index) {
+    const value = getValue(element, index);
+    if (value === undefined) {
+        return;
+    }
+    return parseFloat(value);
+}
+export default getNumberValue;

package/dist/esm/src/imageLoader/wadors/metaData/getNumberValues.d.ts

@@ -0,0 +1,3 @@
+import type { WADORSMetaDataElement } from '../../../types';
+declare function getNumberValues(element: WADORSMetaDataElement, minimumLength?: number): number[];
+export default getNumberValues;

package/dist/esm/src/imageLoader/wadors/metaData/getNumberValues.js

@@ -0,0 +1,20 @@
+function getNumberValues(element, minimumLength) {
+    if (!element) {
+        return;
+    }
+    if (!element.Value) {
+        return;
+    }
+    if (!Array.isArray(element.Value)) {
+        return;
+    }
+    if (minimumLength && element.Value.length < minimumLength) {
+        return;
+    }
+    const values = [];
+    for (let i = 0; i < element.Value.length; i++) {
+        values.push(parseFloat(element.Value[i]));
+    }
+    return values;
+}
+export default getNumberValues;