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

package/dist/esm/src/imageLoader/wadouri/dataSetCacheManager.js

@@ -0,0 +1,142 @@
+import external from '../../externalModules';
+import { xhrRequest } from '../internal/index';
+import dataSetFromPartialContent from './dataset-from-partial-content';
+import { combineFrameInstanceDataset } from './combineFrameInstanceDataset';
+import multiframeDataset from './retrieveMultiframeDataset';
+let cacheSizeInBytes = 0;
+let loadedDataSets = {};
+let promises = {};
+function isLoaded(uri) {
+    return loadedDataSets[uri] !== undefined;
+}
+function get(uri) {
+    let dataSet;
+    if (uri.includes('&frame=')) {
+        const { frame, dataSet: multiframeDataSet } = multiframeDataset.retrieveMultiframeDataset(uri);
+        dataSet = combineFrameInstanceDataset(frame, multiframeDataSet);
+    }
+    else if (loadedDataSets[uri]) {
+        dataSet = loadedDataSets[uri].dataSet;
+    }
+    return dataSet;
+}
+function update(uri, dataSet) {
+    const loadedDataSet = loadedDataSets[uri];
+    if (!loadedDataSet) {
+        console.error(`No loaded dataSet for uri ${uri}`);
+        return;
+    }
+    cacheSizeInBytes -= loadedDataSet.dataSet.byteArray.length;
+    loadedDataSet.dataSet = dataSet;
+    cacheSizeInBytes += dataSet.byteArray.length;
+    external.cornerstone.triggerEvent(external.cornerstone.events, 'datasetscachechanged', {
+        uri,
+        action: 'updated',
+        cacheInfo: getInfo(),
+    });
+}
+function load(uri, loadRequest = xhrRequest, imageId) {
+    const { cornerstone, dicomParser } = external;
+    if (loadedDataSets[uri]) {
+        return new Promise((resolve) => {
+            loadedDataSets[uri].cacheCount++;
+            resolve(loadedDataSets[uri].dataSet);
+        });
+    }
+    if (promises[uri]) {
+        promises[uri].cacheCount++;
+        return promises[uri];
+    }
+    const loadDICOMPromise = loadRequest(uri, imageId);
+    const promise = new Promise((resolve, reject) => {
+        loadDICOMPromise
+            .then(async function (dicomPart10AsArrayBuffer) {
+            const partialContent = {
+                isPartialContent: false,
+                fileTotalLength: null,
+            };
+            if (!(dicomPart10AsArrayBuffer instanceof ArrayBuffer)) {
+                if (!dicomPart10AsArrayBuffer.arrayBuffer) {
+                    return reject(new Error('If not returning ArrayBuffer, must return object with `arrayBuffer` parameter'));
+                }
+                partialContent.isPartialContent =
+                    dicomPart10AsArrayBuffer.flags.isPartialContent;
+                partialContent.fileTotalLength =
+                    dicomPart10AsArrayBuffer.flags.fileTotalLength;
+                dicomPart10AsArrayBuffer = dicomPart10AsArrayBuffer.arrayBuffer;
+            }
+            const byteArray = new Uint8Array(dicomPart10AsArrayBuffer);
+            let dataSet;
+            try {
+                if (partialContent.isPartialContent) {
+                    dataSet = await dataSetFromPartialContent(byteArray, loadRequest, {
+                        uri,
+                        imageId,
+                        fileTotalLength: partialContent.fileTotalLength,
+                    });
+                }
+                else {
+                    dataSet = dicomParser.parseDicom(byteArray);
+                }
+            }
+            catch (error) {
+                return reject(error);
+            }
+            loadedDataSets[uri] = {
+                dataSet,
+                cacheCount: promise.cacheCount,
+            };
+            cacheSizeInBytes += dataSet.byteArray.length;
+            resolve(dataSet);
+            cornerstone.triggerEvent(cornerstone.events, 'datasetscachechanged', {
+                uri,
+                action: 'loaded',
+                cacheInfo: getInfo(),
+            });
+        }, reject)
+            .then(() => {
+            delete promises[uri];
+        }, () => {
+            delete promises[uri];
+        });
+    });
+    promise.cacheCount = 1;
+    promises[uri] = promise;
+    return promise;
+}
+function unload(uri) {
+    const { cornerstone } = external;
+    if (loadedDataSets[uri]) {
+        loadedDataSets[uri].cacheCount--;
+        if (loadedDataSets[uri].cacheCount === 0) {
+            cacheSizeInBytes -= loadedDataSets[uri].dataSet.byteArray.length;
+            delete loadedDataSets[uri];
+            cornerstone.triggerEvent(cornerstone.events, 'datasetscachechanged', {
+                uri,
+                action: 'unloaded',
+                cacheInfo: getInfo(),
+            });
+        }
+    }
+}
+export function getInfo() {
+    return {
+        cacheSizeInBytes,
+        numberOfDataSetsCached: Object.keys(loadedDataSets).length,
+    };
+}
+function purge() {
+    loadedDataSets = {};
+    promises = {};
+    cacheSizeInBytes = 0;
+}
+export default {
+    isLoaded,
+    load,
+    unload,
+    getInfo,
+    purge,
+    get,
+    update,
+};
+export { loadedDataSets };

package/dist/esm/src/imageLoader/wadouri/dataSetCacheManager_test.d.ts

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

package/dist/esm/src/imageLoader/wadouri/dataSetCacheManager_test.js

@@ -0,0 +1,10 @@
+import { expect } from 'chai';
+import dataSetCacheManager from './dataSetCacheManager';
+describe('#getInfo', () => {
+    it('should return cache info for an empty cache', function () {
+        dataSetCacheManager.purge();
+        const cacheInfo = dataSetCacheManager.getInfo();
+        expect(cacheInfo.cacheSizeInBytes).to.be.equal(0);
+        expect(cacheInfo.numberOfDataSetsCached).to.be.equal(0);
+    });
+});

package/dist/esm/src/imageLoader/wadouri/dataset-from-partial-content.d.ts

@@ -0,0 +1,6 @@
+import type { LoadRequestFunction, DICOMLoaderDataSetWithFetchMore } from '../../types';
+export default function dataSetFromPartialContent(byteArray: Uint8Array, loadRequest: LoadRequestFunction, metadata: {
+    uri: string;
+    imageId: string;
+    fileTotalLength: number | null;
+}): Promise<DICOMLoaderDataSetWithFetchMore>;

package/dist/esm/src/imageLoader/wadouri/dataset-from-partial-content.js

@@ -0,0 +1,56 @@
+import external from '../../externalModules';
+function fixFragments(dataSet) {
+    const fragments = dataSet.elements.x7fe00010.fragments;
+    const totalLength = dataSet.byteArray.length;
+    for (const fragment of fragments) {
+        const { position, length } = fragment;
+        if (length > totalLength - position) {
+            console.log(`Truncated fragment, changing fragment length from ${fragment.length} to ${totalLength - position}`);
+            fragment.length = totalLength - position;
+        }
+    }
+    return dataSet;
+}
+function parsePartialByteArray(byteArray) {
+    const { dicomParser } = external;
+    let dataSet = dicomParser.parseDicom(byteArray, {
+        untilTag: 'x7fe00010',
+    });
+    if (!dataSet.elements.x7fe00010) {
+        console.warn('Pixel data not found!');
+    }
+    let pixelDataSet;
+    try {
+        pixelDataSet = dicomParser.parseDicom(byteArray);
+    }
+    catch (err) {
+        console.error(err);
+        console.log('pixel data dataset:', err.dataSet);
+        pixelDataSet = err.dataSet;
+    }
+    dataSet.elements.x7fe00010 = pixelDataSet.elements.x7fe00010;
+    dataSet = fixFragments(dataSet);
+    return dataSet;
+}
+export default async function dataSetFromPartialContent(byteArray, loadRequest, metadata) {
+    const dataSet = parsePartialByteArray(byteArray);
+    const { uri, imageId, fileTotalLength } = metadata;
+    dataSet.fetchMore = async function (fetchOptions) {
+        const _options = Object.assign({
+            uri,
+            imageId,
+            fetchedLength: byteArray.length,
+            lengthToFetch: fileTotalLength - byteArray.length,
+        }, fetchOptions);
+        const { fetchedLength, lengthToFetch } = _options;
+        const { arrayBuffer } = await loadRequest(uri, imageId, {
+            byteRange: `${fetchedLength}-${fetchedLength + lengthToFetch}`,
+        });
+        const byteArrayToAppend = new Uint8Array(arrayBuffer);
+        const combinedByteArray = new Uint8Array(dataSet.byteArray.length + byteArrayToAppend.length);
+        combinedByteArray.set(dataSet.byteArray);
+        combinedByteArray.set(byteArrayToAppend, dataSet.byteArray.length);
+        return dataSetFromPartialContent(combinedByteArray, loadRequest, metadata);
+    };
+    return dataSet;
+}

package/dist/esm/src/imageLoader/wadouri/fileManager.d.ts

@@ -0,0 +1,11 @@
+declare function add(file: Blob): string;
+declare function get(index: number): Blob;
+declare function remove(index: number): void;
+declare function purge(): void;
+declare const _default: {
+    add: typeof add;
+    get: typeof get;
+    remove: typeof remove;
+    purge: typeof purge;
+};
+export default _default;

package/dist/esm/src/imageLoader/wadouri/fileManager.js

@@ -0,0 +1,20 @@
+let files = [];
+function add(file) {
+    const fileIndex = files.push(file);
+    return `dicomfile:${fileIndex - 1}`;
+}
+function get(index) {
+    return files[index];
+}
+function remove(index) {
+    files[index] = undefined;
+}
+function purge() {
+    files = [];
+}
+export default {
+    add,
+    get,
+    remove,
+    purge,
+};

package/dist/esm/src/imageLoader/wadouri/getEncapsulatedImageFrame.d.ts

@@ -0,0 +1,2 @@
+import type { ByteArray, DataSet } from 'dicom-parser';
+export default function getEncapsulatedImageFrame(dataSet: DataSet, frameIndex: number): ByteArray;

package/dist/esm/src/imageLoader/wadouri/getEncapsulatedImageFrame.js

@@ -0,0 +1,33 @@
+import { ByteStream, readSequenceItem } from 'dicom-parser';
+import external from '../../externalModules';
+function framesAreFragmented(dataSet) {
+    const numberOfFrames = dataSet.intString('x00280008');
+    const pixelDataElement = dataSet.elements.x7fe00010;
+    return numberOfFrames !== pixelDataElement.fragments.length;
+}
+export default function getEncapsulatedImageFrame(dataSet, frameIndex) {
+    const { dicomParser } = external;
+    if (dataSet.elements.x7fe00010 &&
+        dataSet.elements.x7fe00010.basicOffsetTable.length) {
+        return dicomParser.readEncapsulatedImageFrame(dataSet, dataSet.elements.x7fe00010, frameIndex);
+    }
+    if (framesAreFragmented(dataSet)) {
+        const basicOffsetTable = dicomParser.createJPEGBasicOffsetTable(dataSet, dataSet.elements.x7fe00010);
+        return dicomParser.readEncapsulatedImageFrame(dataSet, dataSet.elements.x7fe00010, frameIndex, basicOffsetTable);
+    }
+    const fragments = dataSet.elements.x7fe00010.fragments;
+    const byteStream = new ByteStream(dataSet.byteArrayParser, dataSet.byteArray, dataSet.elements.x7fe00010.dataOffset);
+    const basicOffsetTable = readSequenceItem(byteStream);
+    if (basicOffsetTable.tag !== 'xfffee000') {
+        throw 'dicomParser.readEncapsulatedPixelData: missing basic offset table xfffee000';
+    }
+    byteStream.seek(basicOffsetTable.length);
+    const fragmentZeroPosition = byteStream.position;
+    if (frameIndex + 1 > fragments.length) {
+        throw 'dicomParser.readEncapsulatedPixelData: frame exceeds number of fragments';
+    }
+    const fragmentHeaderSize = 8;
+    const byteOffset = fragmentZeroPosition + fragments[frameIndex].offset + fragmentHeaderSize;
+    const length = fragments[frameIndex].length;
+    return new Uint8Array(byteStream.byteArray.buffer.slice(byteStream.byteArray.byteOffset + byteOffset, byteStream.byteArray.byteOffset + byteOffset + length));
+}

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

@@ -0,0 +1,3 @@
+import type { ByteArray, DataSet } from 'dicom-parser';
+declare function getPixelData(dataSet: DataSet, frameIndex?: number): ByteArray;
+export default getPixelData;

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

@@ -0,0 +1,13 @@
+import getEncapsulatedImageFrame from './getEncapsulatedImageFrame';
+import getUncompressedImageFrame from './getUncompressedImageFrame';
+function getPixelData(dataSet, frameIndex = 0) {
+    const pixelDataElement = dataSet.elements.x7fe00010 || dataSet.elements.x7fe00008;
+    if (!pixelDataElement) {
+        return null;
+    }
+    if (pixelDataElement.encapsulatedPixelData) {
+        return getEncapsulatedImageFrame(dataSet, frameIndex);
+    }
+    return getUncompressedImageFrame(dataSet, frameIndex);
+}
+export default getPixelData;

package/dist/esm/src/imageLoader/wadouri/getUncompressedImageFrame.d.ts

@@ -0,0 +1,3 @@
+import type { DataSet } from 'dicom-parser';
+declare function getUncompressedImageFrame(dataSet: DataSet, frameIndex: number): Uint8Array;
+export default getUncompressedImageFrame;

package/dist/esm/src/imageLoader/wadouri/getUncompressedImageFrame.js

@@ -0,0 +1,47 @@
+import unpackBinaryFrame from './unpackBinaryFrame';
+function getUncompressedImageFrame(dataSet, frameIndex) {
+    const pixelDataElement = dataSet.elements.x7fe00010 || dataSet.elements.x7fe00008;
+    const bitsAllocated = dataSet.uint16('x00280100');
+    const rows = dataSet.uint16('x00280010');
+    const columns = dataSet.uint16('x00280011');
+    let samplesPerPixel = dataSet.uint16('x00280002');
+    const photometricInterpretation = dataSet.string('x00280004');
+    if (photometricInterpretation === 'YBR_FULL_422') {
+        samplesPerPixel = 2;
+        console.warn(`Using SamplesPerPixel of 2 for YBR_FULL_422 photometric interpretation.
+      See http://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.6.3.html for more information.`);
+    }
+    const pixelDataOffset = pixelDataElement.dataOffset;
+    const pixelsPerFrame = rows * columns * samplesPerPixel;
+    let frameOffset;
+    if (bitsAllocated === 8) {
+        frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame;
+        if (frameOffset >= dataSet.byteArray.length) {
+            throw new Error('frame exceeds size of pixelData');
+        }
+        return new Uint8Array(dataSet.byteArray.buffer.slice(frameOffset, frameOffset + pixelsPerFrame));
+    }
+    else if (bitsAllocated === 16) {
+        frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 2;
+        if (frameOffset >= dataSet.byteArray.length) {
+            throw new Error('frame exceeds size of pixelData');
+        }
+        return new Uint8Array(dataSet.byteArray.buffer.slice(frameOffset, frameOffset + pixelsPerFrame * 2));
+    }
+    else if (bitsAllocated === 1) {
+        frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 0.125;
+        if (frameOffset >= dataSet.byteArray.length) {
+            throw new Error('frame exceeds size of pixelData');
+        }
+        return unpackBinaryFrame(dataSet.byteArray, frameOffset, pixelsPerFrame);
+    }
+    else if (bitsAllocated === 32) {
+        frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 4;
+        if (frameOffset >= dataSet.byteArray.length) {
+            throw new Error('frame exceeds size of pixelData');
+        }
+        return new Uint8Array(dataSet.byteArray.buffer.slice(frameOffset, frameOffset + pixelsPerFrame * 4));
+    }
+    throw new Error('unsupported pixel format');
+}
+export default getUncompressedImageFrame;

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

@@ -0,0 +1,42 @@
+import { getImagePixelModule, getLUTs, getModalityLUTOutputPixelRepresentation, getNumberValues, metaDataProvider } from './metaData/index';
+import getEncapsulatedImageFrame from './getEncapsulatedImageFrame';
+import getUncompressedImageFrame from './getUncompressedImageFrame';
+import loadFileRequest from './loadFileRequest';
+import { loadImageFromPromise, getLoaderForScheme, loadImage } from './loadImage';
+import parseImageId from './parseImageId';
+import unpackBinaryFrame from './unpackBinaryFrame';
+import register from './register';
+declare const _default: {
+    metaData: {
+        getImagePixelModule: typeof getImagePixelModule;
+        getLUTs: typeof getLUTs;
+        getModalityLUTOutputPixelRepresentation: typeof getModalityLUTOutputPixelRepresentation;
+        getNumberValues: typeof getNumberValues;
+        metaDataProvider: typeof metaDataProvider;
+    };
+    dataSetCacheManager: {
+        isLoaded: (uri: string) => boolean;
+        load: (uri: string, loadRequest: import("../../types").LoadRequestFunction, imageId: string) => import("./dataSetCacheManager").CornerstoneWadoLoaderCachedPromise;
+        unload: (uri: string) => void;
+        getInfo: typeof import("./dataSetCacheManager").getInfo;
+        purge: () => void;
+        get: (uri: string) => import("dicom-parser").DataSet;
+        update: (uri: string, dataSet: import("dicom-parser").DataSet) => void;
+    };
+    fileManager: {
+        add: (file: Blob) => string;
+        get: (index: number) => Blob;
+        remove: (index: number) => void;
+        purge: () => void;
+    };
+    getEncapsulatedImageFrame: typeof getEncapsulatedImageFrame;
+    getUncompressedImageFrame: typeof getUncompressedImageFrame;
+    loadFileRequest: typeof loadFileRequest;
+    loadImageFromPromise: typeof loadImageFromPromise;
+    getLoaderForScheme: typeof getLoaderForScheme;
+    loadImage: typeof loadImage;
+    parseImageId: typeof parseImageId;
+    unpackBinaryFrame: typeof unpackBinaryFrame;
+    register: typeof register;
+};
+export default _default;

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

@@ -0,0 +1,31 @@
+import { getImagePixelModule, getLUTs, getModalityLUTOutputPixelRepresentation, getNumberValues, metaDataProvider, } from './metaData/index';
+import dataSetCacheManager from './dataSetCacheManager';
+import fileManager from './fileManager';
+import getEncapsulatedImageFrame from './getEncapsulatedImageFrame';
+import getUncompressedImageFrame from './getUncompressedImageFrame';
+import loadFileRequest from './loadFileRequest';
+import { loadImageFromPromise, getLoaderForScheme, loadImage, } from './loadImage';
+import parseImageId from './parseImageId';
+import unpackBinaryFrame from './unpackBinaryFrame';
+import register from './register';
+const metaData = {
+    getImagePixelModule,
+    getLUTs,
+    getModalityLUTOutputPixelRepresentation,
+    getNumberValues,
+    metaDataProvider,
+};
+export default {
+    metaData,
+    dataSetCacheManager,
+    fileManager,
+    getEncapsulatedImageFrame,
+    getUncompressedImageFrame,
+    loadFileRequest,
+    loadImageFromPromise,
+    getLoaderForScheme,
+    loadImage,
+    parseImageId,
+    unpackBinaryFrame,
+    register,
+};

package/dist/esm/src/imageLoader/wadouri/loadFileRequest.d.ts

@@ -0,0 +1,2 @@
+declare function loadFileRequest(uri: string): Promise<ArrayBuffer>;
+export default loadFileRequest;

package/dist/esm/src/imageLoader/wadouri/loadFileRequest.js

@@ -0,0 +1,17 @@
+import parseImageId from './parseImageId';
+import fileManager from './fileManager';
+function loadFileRequest(uri) {
+    const parsedImageId = parseImageId(uri);
+    const fileIndex = parseInt(parsedImageId.url, 10);
+    const file = fileManager.get(fileIndex);
+    return new Promise((resolve, reject) => {
+        const fileReader = new FileReader();
+        fileReader.onload = (e) => {
+            const dicomPart10AsArrayBuffer = e.target.result;
+            resolve(dicomPart10AsArrayBuffer);
+        };
+        fileReader.onerror = reject;
+        fileReader.readAsArrayBuffer(file);
+    });
+}
+export default loadFileRequest;

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

@@ -0,0 +1,9 @@
+import type { DataSet } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+import type { LoadRequestFunction, DICOMLoaderIImage, DICOMLoaderImageOptions } from '../../types';
+declare function loadImageFromPromise(dataSetPromise: Promise<DataSet>, imageId: string, frame: number, sharedCacheKey: string, options: DICOMLoaderImageOptions, callbacks?: {
+    imageDoneCallback: (image: DICOMLoaderIImage) => void;
+}): Types.IImageLoadObject;
+declare function getLoaderForScheme(scheme: string): LoadRequestFunction;
+declare function loadImage(imageId: string, options?: DICOMLoaderImageOptions): Types.IImageLoadObject;
+export { loadImageFromPromise, getLoaderForScheme, loadImage };

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

@@ -0,0 +1,104 @@
+import createImage from '../createImage';
+import { xhrRequest } from '../internal/index';
+import dataSetCacheManager from './dataSetCacheManager';
+import getPixelData from './getPixelData';
+import loadFileRequest from './loadFileRequest';
+import parseImageId from './parseImageId';
+function addDecache(imageLoadObject, imageId) {
+    imageLoadObject.decache = function () {
+        const parsedImageId = parseImageId(imageId);
+        dataSetCacheManager.unload(parsedImageId.url);
+    };
+}
+function loadImageFromPromise(dataSetPromise, imageId, frame = 0, sharedCacheKey, options, callbacks) {
+    const start = new Date().getTime();
+    const imageLoadObject = {
+        cancelFn: undefined,
+        promise: undefined,
+    };
+    imageLoadObject.promise = new Promise((resolve, reject) => {
+        dataSetPromise.then((dataSet) => {
+            const pixelData = getPixelData(dataSet, frame);
+            const transferSyntax = dataSet.string('x00020010');
+            const loadEnd = new Date().getTime();
+            const imagePromise = createImage(imageId, pixelData, transferSyntax, options);
+            addDecache(imageLoadObject, imageId);
+            imagePromise.then((image) => {
+                image = image;
+                image.data = dataSet;
+                image.sharedCacheKey = sharedCacheKey;
+                const end = new Date().getTime();
+                image.loadTimeInMS = loadEnd - start;
+                image.totalTimeInMS = end - start;
+                if (callbacks !== undefined &&
+                    callbacks.imageDoneCallback !== undefined) {
+                    callbacks.imageDoneCallback(image);
+                }
+                resolve(image);
+            }, function (error) {
+                reject({
+                    error,
+                    dataSet,
+                });
+            });
+        }, function (error) {
+            reject({
+                error,
+            });
+        });
+    });
+    return imageLoadObject;
+}
+function loadImageFromDataSet(dataSet, imageId, frame = 0, sharedCacheKey, options) {
+    const start = new Date().getTime();
+    const promise = new Promise((resolve, reject) => {
+        const loadEnd = new Date().getTime();
+        let imagePromise;
+        try {
+            const pixelData = getPixelData(dataSet, frame);
+            const transferSyntax = dataSet.string('x00020010');
+            imagePromise = createImage(imageId, pixelData, transferSyntax, options);
+        }
+        catch (error) {
+            reject({
+                error,
+                dataSet,
+            });
+            return;
+        }
+        imagePromise.then((image) => {
+            image = image;
+            image.data = dataSet;
+            image.sharedCacheKey = sharedCacheKey;
+            const end = new Date().getTime();
+            image.loadTimeInMS = loadEnd - start;
+            image.totalTimeInMS = end - start;
+            resolve(image);
+        }, reject);
+    });
+    return {
+        promise: promise,
+        cancelFn: undefined,
+    };
+}
+function getLoaderForScheme(scheme) {
+    if (scheme === 'dicomweb' || scheme === 'wadouri') {
+        return xhrRequest;
+    }
+    else if (scheme === 'dicomfile') {
+        return loadFileRequest;
+    }
+}
+function loadImage(imageId, options = {}) {
+    const parsedImageId = parseImageId(imageId);
+    options = Object.assign({}, options);
+    delete options.loader;
+    const schemeLoader = getLoaderForScheme(parsedImageId.scheme);
+    if (dataSetCacheManager.isLoaded(parsedImageId.url)) {
+        const dataSet = dataSetCacheManager.get(parsedImageId.url, schemeLoader, imageId);
+        return loadImageFromDataSet(dataSet, imageId, parsedImageId.pixelDataFrame, parsedImageId.url, options);
+    }
+    const dataSetPromise = dataSetCacheManager.load(parsedImageId.url, schemeLoader, imageId);
+    return loadImageFromPromise(dataSetPromise, imageId, parsedImageId.frame, parsedImageId.url, options);
+}
+export { loadImageFromPromise, getLoaderForScheme, loadImage };

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

@@ -0,0 +1,2 @@
+declare function getUSEnhancedRegions(metadata: any): any;
+export { getUSEnhancedRegions };

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

@@ -0,0 +1,44 @@
+function getUSEnhancedRegions(metadata) {
+    const sequence = metadata.elements['x00186011'];
+    if (!sequence || !sequence.items) {
+        return [];
+    }
+    const regions = sequence.items.map((item) => {
+        const physicalDeltaX = item.dataSet.double('x0018602c');
+        const physicalDeltaY = item.dataSet.double('x0018602e');
+        const physicalUnitsXDirection = item.dataSet.uint16('x00186024');
+        const physicalUnitsYDirection = item.dataSet.uint16('x00186026');
+        const regionLocationMinY0 = item.dataSet.uint16('x0018601a');
+        const regionLocationMaxY1 = item.dataSet.uint16('x0018601e');
+        const regionLocationMinX0 = item.dataSet.uint16('x00186018');
+        const regionLocationMaxX1 = item.dataSet.uint16('x0018601c');
+        const referencePixelX0 = item.dataSet.int32('x00186020') || null;
+        const referencePixelY0 = item.dataSet.int32('x00186022') || null;
+        const referencePhysicalPixelValueY = item.dataSet.uint16('x0018602a');
+        const referencePhysicalPixelValueX = item.dataSet.uint16('x00186028');
+        const regionSpatialFormat = item.dataSet.uint16('x00186012');
+        const regionDataType = item.dataSet.uint16('x00186014');
+        const regionFlags = item.dataSet.uint16('x00186016');
+        const transducerFrequency = item.dataSet.uint16('x00186030');
+        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/wadouri/metaData/extractPositioningFromDataset.d.ts

@@ -0,0 +1,6 @@
+declare function getImageTypeSubItemFromDataset(dataSet: any, index: any): any;
+declare function extractOrientationFromDataset(dataSet: any): number[];
+declare function extractPositionFromDataset(dataSet: any): number[];
+declare function extractSpacingFromDataset(dataSet: any): number[];
+declare function extractSliceThicknessFromDataset(dataSet: any): any;
+export { getImageTypeSubItemFromDataset, extractOrientationFromDataset, extractPositionFromDataset, extractSpacingFromDataset, extractSliceThicknessFromDataset, };