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

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

@@ -0,0 +1,4 @@
+import { MetadataImagePixelModule } from '../../../types';
+import { DataSet } from 'dicom-parser';
+declare function getImagePixelModule(dataSet: DataSet): MetadataImagePixelModule;
+export default getImagePixelModule;

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

@@ -0,0 +1,79 @@
+function getLutDescriptor(dataSet, tag) {
+    if (!dataSet.elements[tag] || dataSet.elements[tag].length !== 6) {
+        return;
+    }
+    return [
+        dataSet.uint16(tag, 0),
+        dataSet.uint16(tag, 1),
+        dataSet.uint16(tag, 2),
+    ];
+}
+function getLutData(lutDataSet, tag, lutDescriptor) {
+    const lut = [];
+    const lutData = lutDataSet.elements[tag];
+    for (let i = 0; i < lutDescriptor[0]; i++) {
+        if (lutDescriptor[2] === 16) {
+            lut[i] = lutDataSet.uint16(tag, i);
+        }
+        else {
+            lut[i] = lutDataSet.byteArray[i + lutData.dataOffset];
+        }
+    }
+    return lut;
+}
+function populatePaletteColorLut(dataSet, imagePixelModule) {
+    imagePixelModule.redPaletteColorLookupTableDescriptor = getLutDescriptor(dataSet, 'x00281101');
+    imagePixelModule.greenPaletteColorLookupTableDescriptor = getLutDescriptor(dataSet, 'x00281102');
+    imagePixelModule.bluePaletteColorLookupTableDescriptor = getLutDescriptor(dataSet, 'x00281103');
+    if (imagePixelModule.redPaletteColorLookupTableDescriptor[0] === 0) {
+        imagePixelModule.redPaletteColorLookupTableDescriptor[0] = 65536;
+        imagePixelModule.greenPaletteColorLookupTableDescriptor[0] = 65536;
+        imagePixelModule.bluePaletteColorLookupTableDescriptor[0] = 65536;
+    }
+    const numLutEntries = imagePixelModule.redPaletteColorLookupTableDescriptor[0];
+    const lutData = dataSet.elements.x00281201;
+    const lutBitsAllocated = lutData.length === numLutEntries ? 8 : 16;
+    if (imagePixelModule.redPaletteColorLookupTableDescriptor[2] !==
+        lutBitsAllocated) {
+        imagePixelModule.redPaletteColorLookupTableDescriptor[2] = lutBitsAllocated;
+        imagePixelModule.greenPaletteColorLookupTableDescriptor[2] =
+            lutBitsAllocated;
+        imagePixelModule.bluePaletteColorLookupTableDescriptor[2] =
+            lutBitsAllocated;
+    }
+    imagePixelModule.redPaletteColorLookupTableData = getLutData(dataSet, 'x00281201', imagePixelModule.redPaletteColorLookupTableDescriptor);
+    imagePixelModule.greenPaletteColorLookupTableData = getLutData(dataSet, 'x00281202', imagePixelModule.greenPaletteColorLookupTableDescriptor);
+    imagePixelModule.bluePaletteColorLookupTableData = getLutData(dataSet, 'x00281203', imagePixelModule.bluePaletteColorLookupTableDescriptor);
+}
+function populateSmallestLargestPixelValues(dataSet, imagePixelModule) {
+    const pixelRepresentation = dataSet.uint16('x00280103');
+    if (pixelRepresentation === 0) {
+        imagePixelModule.smallestPixelValue = dataSet.uint16('x00280106');
+        imagePixelModule.largestPixelValue = dataSet.uint16('x00280107');
+    }
+    else {
+        imagePixelModule.smallestPixelValue = dataSet.int16('x00280106');
+        imagePixelModule.largestPixelValue = dataSet.int16('x00280107');
+    }
+}
+function getImagePixelModule(dataSet) {
+    const imagePixelModule = {
+        samplesPerPixel: dataSet.uint16('x00280002'),
+        photometricInterpretation: dataSet.string('x00280004'),
+        rows: dataSet.uint16('x00280010'),
+        columns: dataSet.uint16('x00280011'),
+        bitsAllocated: dataSet.uint16('x00280100'),
+        bitsStored: dataSet.uint16('x00280101'),
+        highBit: dataSet.uint16('x00280102'),
+        pixelRepresentation: dataSet.uint16('x00280103'),
+        planarConfiguration: dataSet.uint16('x00280006'),
+        pixelAspectRatio: dataSet.string('x00280034'),
+    };
+    populateSmallestLargestPixelValues(dataSet, imagePixelModule);
+    if (imagePixelModule.photometricInterpretation === 'PALETTE COLOR' &&
+        dataSet.elements.x00281101) {
+        populatePaletteColorLut(dataSet, imagePixelModule);
+    }
+    return imagePixelModule;
+}
+export default getImagePixelModule;

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

@@ -0,0 +1,4 @@
+import { Element } from 'dicom-parser';
+import { LutType } from '../../../types';
+declare function getLUTs(pixelRepresentation: number, lutSequence: Element): LutType[];
+export default getLUTs;

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

@@ -0,0 +1,44 @@
+function getLUT(pixelRepresentation, lutDataSet) {
+    let numLUTEntries = lutDataSet.uint16('x00283002', 0);
+    if (numLUTEntries === 0) {
+        numLUTEntries = 65535;
+    }
+    let firstValueMapped = 0;
+    if (pixelRepresentation === 0) {
+        firstValueMapped = lutDataSet.uint16('x00283002', 1);
+    }
+    else {
+        firstValueMapped = lutDataSet.int16('x00283002', 1);
+    }
+    const numBitsPerEntry = lutDataSet.uint16('x00283002', 2);
+    const lut = {
+        id: '1',
+        firstValueMapped,
+        numBitsPerEntry,
+        lut: [],
+    };
+    for (let i = 0; i < numLUTEntries; i++) {
+        if (pixelRepresentation === 0) {
+            lut.lut[i] = lutDataSet.uint16('x00283006', i);
+        }
+        else {
+            lut.lut[i] = lutDataSet.int16('x00283006', i);
+        }
+    }
+    return lut;
+}
+function getLUTs(pixelRepresentation, lutSequence) {
+    if (!lutSequence || !lutSequence.items || !lutSequence.items.length) {
+        return;
+    }
+    const luts = [];
+    for (let i = 0; i < lutSequence.items.length; i++) {
+        const lutDataSet = lutSequence.items[i].dataSet;
+        const lut = getLUT(pixelRepresentation, lutDataSet);
+        if (lut) {
+            luts.push(lut);
+        }
+    }
+    return luts;
+}
+export default getLUTs;

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

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

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

@@ -0,0 +1,30 @@
+function getMinStoredPixelValue(dataSet) {
+    const pixelRepresentation = dataSet.uint16('x00280103');
+    const bitsStored = dataSet.uint16('x00280101');
+    if (pixelRepresentation === 0) {
+        return 0;
+    }
+    return -1 << (bitsStored - 1);
+}
+function getModalityLUTOutputPixelRepresentation(dataSet) {
+    const sopClassUID = dataSet.string('x00080016');
+    if (sopClassUID === '1.2.840.10008.5.1.4.1.1.2' ||
+        sopClassUID === '1.2.840.10008.5.1.4.1.1.2.1') {
+        return 1;
+    }
+    const rescaleIntercept = dataSet.floatString('x00281052');
+    const rescaleSlope = dataSet.floatString('x00281053');
+    if (rescaleIntercept !== undefined && rescaleSlope !== undefined) {
+        const minStoredPixelValue = getMinStoredPixelValue(dataSet);
+        const minModalityLutValue = minStoredPixelValue * rescaleSlope + rescaleIntercept;
+        if (minModalityLutValue < 0) {
+            return 1;
+        }
+        return 0;
+    }
+    if (dataSet.elements.x00283000 && dataSet.elements.x00283000.length > 0) {
+        return 0;
+    }
+    return dataSet.uint16('x00280103');
+}
+export default getModalityLUTOutputPixelRepresentation;

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

@@ -0,0 +1,3 @@
+import { DataSet } from 'dicom-parser';
+declare function getNumberValues(dataSet: DataSet, tag: string, minimumLength: number): number[];
+export default getNumberValues;

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

@@ -0,0 +1,16 @@
+function getNumberValues(dataSet, tag, minimumLength) {
+    const values = [];
+    const valueAsString = dataSet.string(tag);
+    if (!valueAsString) {
+        return;
+    }
+    const split = valueAsString.split('\\');
+    if (minimumLength && split.length < minimumLength) {
+        return;
+    }
+    for (let i = 0; i < split.length; i++) {
+        values.push(parseFloat(split[i]));
+    }
+    return values;
+}
+export default getNumberValues;

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

@@ -0,0 +1,4 @@
+import { DataSet } from 'dicom-parser';
+export default function getOverlayPlaneModule(dataSet: DataSet): {
+    overlays: any[];
+};

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

@@ -0,0 +1,36 @@
+export default function getOverlayPlaneModule(dataSet) {
+    const overlays = [];
+    for (let overlayGroup = 0x00; overlayGroup <= 0x1e; overlayGroup += 0x02) {
+        let groupStr = `x60${overlayGroup.toString(16)}`;
+        if (groupStr.length === 4) {
+            groupStr = `x600${overlayGroup.toString(16)}`;
+        }
+        const data = dataSet.elements[`${groupStr}3000`];
+        if (!data) {
+            continue;
+        }
+        const pixelData = [];
+        for (let i = 0; i < data.length; i++) {
+            for (let k = 0; k < 8; k++) {
+                const byte_as_int = dataSet.byteArray[data.dataOffset + i];
+                pixelData[i * 8 + k] = (byte_as_int >> k) & 0b1;
+            }
+        }
+        overlays.push({
+            rows: dataSet.uint16(`${groupStr}0010`),
+            columns: dataSet.uint16(`${groupStr}0011`),
+            type: dataSet.string(`${groupStr}0040`),
+            x: dataSet.int16(`${groupStr}0050`, 1) - 1,
+            y: dataSet.int16(`${groupStr}0050`, 0) - 1,
+            pixelData,
+            description: dataSet.string(`${groupStr}0022`),
+            label: dataSet.string(`${groupStr}1500`),
+            roiArea: dataSet.string(`${groupStr}1301`),
+            roiMean: dataSet.string(`${groupStr}1302`),
+            roiStandardDeviation: dataSet.string(`${groupStr}1303`),
+        });
+    }
+    return {
+        overlays,
+    };
+}

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

@@ -0,0 +1,5 @@
+export { default as getImagePixelModule } from './getImagePixelModule';
+export { default as getLUTs } from './getLUTs';
+export { default as getModalityLUTOutputPixelRepresentation } from './getModalityLUTOutputPixelRepresentation';
+export { default as getNumberValues } from './getNumberValues';
+export { default as metaDataProvider } from './metaDataProvider';

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

@@ -0,0 +1,5 @@
+export { default as getImagePixelModule } from './getImagePixelModule';
+export { default as getLUTs } from './getLUTs';
+export { default as getModalityLUTOutputPixelRepresentation } from './getModalityLUTOutputPixelRepresentation';
+export { default as getNumberValues } from './getNumberValues';
+export { default as metaDataProvider } from './metaDataProvider';

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

@@ -0,0 +1,2 @@
+declare function metaDataProvider(type: any, imageId: any): object;
+export default metaDataProvider;

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

@@ -0,0 +1,210 @@
+import external from '../../../externalModules';
+import getNumberValues from './getNumberValues';
+import parseImageId from '../parseImageId';
+import dataSetCacheManager from '../dataSetCacheManager';
+import getImagePixelModule from './getImagePixelModule';
+import getOverlayPlaneModule from './getOverlayPlaneModule';
+import getLUTs from './getLUTs';
+import getModalityLUTOutputPixelRepresentation from './getModalityLUTOutputPixelRepresentation';
+import { getDirectFrameInformation } from '../combineFrameInstanceDataset';
+import multiframeDataset from '../retrieveMultiframeDataset';
+import { getImageTypeSubItemFromDataset, extractOrientationFromDataset, extractPositionFromDataset, extractSpacingFromDataset, extractSliceThicknessFromDataset, } from './extractPositioningFromDataset';
+import isNMReconstructable from '../../isNMReconstructable';
+import { getInstanceModule, instanceModuleNames, } from '../../getInstanceModule';
+function metaDataProvider(type, imageId) {
+    const { MetadataModules } = external.cornerstone.Enums;
+    const { dicomParser } = external;
+    if (Array.isArray(imageId)) {
+        return;
+    }
+    const parsedImageId = parseImageId(imageId);
+    if (type === MetadataModules.MULTIFRAME) {
+        const multiframeData = multiframeDataset.retrieveMultiframeDataset(parsedImageId.url);
+        if (!multiframeData.dataSet) {
+            return;
+        }
+        const multiframeInfo = getDirectFrameInformation(multiframeData.dataSet, multiframeData.frame);
+        return multiframeInfo;
+    }
+    let url = parsedImageId.url;
+    if (parsedImageId.frame) {
+        url = `${url}&frame=${parsedImageId.frame}`;
+    }
+    const dataSet = dataSetCacheManager.get(url);
+    if (!dataSet) {
+        return;
+    }
+    if (type === MetadataModules.GENERAL_STUDY) {
+        return {
+            studyDescription: dataSet.string('x00081030'),
+            studyDate: dicomParser.parseDA(dataSet.string('x00080020')),
+            studyTime: dicomParser.parseTM(dataSet.string('x00080030') || ''),
+            accessionNumber: dataSet.string('x00080050'),
+        };
+    }
+    if (type === MetadataModules.GENERAL_SERIES) {
+        return {
+            modality: dataSet.string('x00080060'),
+            seriesInstanceUID: dataSet.string('x0020000e'),
+            seriesNumber: dataSet.intString('x00200011'),
+            studyInstanceUID: dataSet.string('x0020000d'),
+            seriesDate: dicomParser.parseDA(dataSet.string('x00080021')),
+            seriesTime: dicomParser.parseTM(dataSet.string('x00080031') || ''),
+            acquisitionDate: dicomParser.parseDA(dataSet.string('x00080022')),
+            acquisitionTime: dicomParser.parseTM(dataSet.string('x00080032') || ''),
+        };
+    }
+    if (type === MetadataModules.GENERAL_IMAGE) {
+        return {
+            sopInstanceUID: dataSet.string('x00080018'),
+            instanceNumber: dataSet.intString('x00200013'),
+            lossyImageCompression: dataSet.string('x00282110'),
+            lossyImageCompressionRatio: dataSet.floatString('x00282112'),
+            lossyImageCompressionMethod: dataSet.string('x00282114'),
+        };
+    }
+    if (type === MetadataModules.PATIENT) {
+        return {
+            patientID: dataSet.string('x00100020'),
+            patientName: dataSet.string('x00100010'),
+        };
+    }
+    if (type === MetadataModules.PATIENT_STUDY) {
+        return {
+            patientAge: dataSet.intString('x00101010'),
+            patientSize: dataSet.floatString('x00101020'),
+            patientSex: dataSet.string('x00100040'),
+            patientWeight: dataSet.floatString('x00101030'),
+        };
+    }
+    if (type === MetadataModules.NM_MULTIFRAME_GEOMETRY) {
+        const modality = dataSet.string('x00080060');
+        const imageSubType = getImageTypeSubItemFromDataset(dataSet, 2);
+        return {
+            modality,
+            imageType: dataSet.string('x00080008'),
+            imageSubType,
+            imageOrientationPatient: extractOrientationFromDataset(dataSet),
+            imagePositionPatient: extractPositionFromDataset(dataSet),
+            sliceThickness: extractSliceThicknessFromDataset(dataSet),
+            pixelSpacing: extractSpacingFromDataset(dataSet),
+            numberOfFrames: dataSet.uint16('x00280008'),
+            isNMReconstructable: isNMReconstructable(imageSubType) && modality.includes('NM'),
+        };
+    }
+    if (type === MetadataModules.IMAGE_PLANE) {
+        const imageOrientationPatient = extractOrientationFromDataset(dataSet);
+        const imagePositionPatient = extractPositionFromDataset(dataSet);
+        const pixelSpacing = extractSpacingFromDataset(dataSet);
+        const sliceThickness = extractSliceThicknessFromDataset(dataSet);
+        let columnPixelSpacing = null;
+        let rowPixelSpacing = null;
+        if (pixelSpacing) {
+            rowPixelSpacing = pixelSpacing[0];
+            columnPixelSpacing = pixelSpacing[1];
+        }
+        let rowCosines = null;
+        let columnCosines = null;
+        if (imageOrientationPatient) {
+            rowCosines = [
+                parseFloat(imageOrientationPatient[0]),
+                parseFloat(imageOrientationPatient[1]),
+                parseFloat(imageOrientationPatient[2]),
+            ];
+            columnCosines = [
+                parseFloat(imageOrientationPatient[3]),
+                parseFloat(imageOrientationPatient[4]),
+                parseFloat(imageOrientationPatient[5]),
+            ];
+        }
+        return {
+            frameOfReferenceUID: dataSet.string('x00200052'),
+            rows: dataSet.uint16('x00280010'),
+            columns: dataSet.uint16('x00280011'),
+            imageOrientationPatient,
+            rowCosines,
+            columnCosines,
+            imagePositionPatient,
+            sliceThickness,
+            sliceLocation: dataSet.floatString('x00201041'),
+            pixelSpacing,
+            rowPixelSpacing,
+            columnPixelSpacing,
+        };
+    }
+    if (type === MetadataModules.CINE) {
+        return {
+            frameTime: dataSet.floatString('x00181063'),
+        };
+    }
+    if (type === MetadataModules.IMAGE_PIXEL) {
+        return getImagePixelModule(dataSet);
+    }
+    if (type === MetadataModules.VOI_LUT) {
+        const modalityLUTOutputPixelRepresentation = getModalityLUTOutputPixelRepresentation(dataSet);
+        return {
+            windowCenter: getNumberValues(dataSet, 'x00281050', 1),
+            windowWidth: getNumberValues(dataSet, 'x00281051', 1),
+            voiLUTSequence: getLUTs(modalityLUTOutputPixelRepresentation, dataSet.elements.x00283010),
+        };
+    }
+    if (type === MetadataModules.MODALITY_LUT) {
+        return {
+            rescaleIntercept: dataSet.floatString('x00281052'),
+            rescaleSlope: dataSet.floatString('x00281053'),
+            rescaleType: dataSet.string('x00281054'),
+            modalityLUTSequence: getLUTs(dataSet.uint16('x00280103'), dataSet.elements.x00283000),
+        };
+    }
+    if (type === MetadataModules.SOP_COMMON) {
+        return {
+            sopClassUID: dataSet.string('x00080016'),
+            sopInstanceUID: dataSet.string('x00080018'),
+        };
+    }
+    if (type === MetadataModules.PET_ISOTOPE) {
+        const radiopharmaceuticalInfo = dataSet.elements.x00540016;
+        if (radiopharmaceuticalInfo === undefined) {
+            return;
+        }
+        const firstRadiopharmaceuticalInfoDataSet = radiopharmaceuticalInfo.items[0].dataSet;
+        return {
+            radiopharmaceuticalInfo: {
+                radiopharmaceuticalStartTime: dicomParser.parseTM(firstRadiopharmaceuticalInfoDataSet.string('x00181072') || ''),
+                radionuclideTotalDose: firstRadiopharmaceuticalInfoDataSet.floatString('x00181074'),
+                radionuclideHalfLife: firstRadiopharmaceuticalInfoDataSet.floatString('x00181075'),
+            },
+        };
+    }
+    if (type === MetadataModules.OVERLAY_PLANE) {
+        return getOverlayPlaneModule(dataSet);
+    }
+    if (type === 'transferSyntax') {
+        let transferSyntaxUID;
+        try {
+            transferSyntaxUID = dataSet.string('x00020010');
+        }
+        catch (error) {
+        }
+        return {
+            transferSyntaxUID,
+        };
+    }
+    if (type === MetadataModules.PET_SERIES) {
+        return {
+            correctedImage: dataSet.string('x00280051'),
+            units: dataSet.string('x00541001'),
+            decayCorrection: dataSet.string('x00541102'),
+        };
+    }
+    if (type === MetadataModules.PET_IMAGE) {
+        return {
+            frameReferenceTime: dataSet.floatString(dataSet.string('x00541300') || ''),
+            actualFrameDuration: dataSet.intString(dataSet.string('x00181242')),
+        };
+    }
+    if (type === 'instance') {
+        return getInstanceModule(imageId, metaDataProvider, instanceModuleNames);
+    }
+}
+export default metaDataProvider;

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

@@ -0,0 +1,8 @@
+export interface CornerstoneImageUrl {
+    scheme: string;
+    url: string;
+    frame: number;
+    pixelDataFrame: number;
+}
+declare function parseImageId(imageId: string): CornerstoneImageUrl;
+export default parseImageId;

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

@@ -0,0 +1,20 @@
+function parseImageId(imageId) {
+    const firstColonIndex = imageId.indexOf(':');
+    let url = imageId.substring(firstColonIndex + 1);
+    const frameIndex = url.indexOf('frame=');
+    let frame;
+    if (frameIndex !== -1) {
+        const frameStr = url.substring(frameIndex + 6);
+        frame = parseInt(frameStr, 10);
+        url = url.substring(0, frameIndex - 1);
+    }
+    const scheme = imageId.substring(0, firstColonIndex);
+    const adjustedFrame = frame !== undefined ? frame - 1 : undefined;
+    return {
+        scheme,
+        url,
+        frame,
+        pixelDataFrame: adjustedFrame,
+    };
+}
+export default parseImageId;

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

@@ -0,0 +1,2 @@
+import * as cornerstoneImport from '@cornerstonejs/core';
+export default function (cornerstone: typeof cornerstoneImport): void;

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

@@ -0,0 +1,8 @@
+import { loadImage } from './loadImage';
+import { metaDataProvider } from './metaData/index';
+export default function (cornerstone) {
+    cornerstone.registerImageLoader('dicomweb', loadImage);
+    cornerstone.registerImageLoader('wadouri', loadImage);
+    cornerstone.registerImageLoader('dicomfile', loadImage);
+    cornerstone.metaData.addProvider(metaDataProvider);
+}

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

@@ -0,0 +1,18 @@
+/// <reference types="dicom-parser" />
+declare function _get(uri: any): {
+    dataSet: import("dicom-parser").DataSet;
+    cacheCount: number;
+};
+declare function isMultiframeDataset(uri: any): boolean;
+declare function retrieveMultiframeDataset(uri: any): {
+    dataSet: any;
+    frame: number;
+};
+declare function generateMultiframeWADOURIs(uri: any): any[];
+declare const _default: {
+    _get: typeof _get;
+    generateMultiframeWADOURIs: typeof generateMultiframeWADOURIs;
+    retrieveMultiframeDataset: typeof retrieveMultiframeDataset;
+    isMultiframeDataset: typeof isMultiframeDataset;
+};
+export default _default;

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

@@ -0,0 +1,57 @@
+import { loadedDataSets } from './dataSetCacheManager';
+function _get(uri) {
+    if (!loadedDataSets[uri]) {
+        return;
+    }
+    return loadedDataSets[uri];
+}
+function isMultiframeDataset(uri) {
+    const dataSet = _get(uri);
+    return _isMultiframeDataset(dataSet);
+}
+function _isMultiframeDataset(dataSet) {
+    if (!dataSet) {
+        return false;
+    }
+    const numberOfFrames = dataSet.intString('x00280008');
+    return numberOfFrames && numberOfFrames > 1;
+}
+function retrieveFrameParameterIndex(uri) {
+    return uri.indexOf('&frame=');
+}
+function retrieveMultiframeDataset(uri) {
+    const frameParameterIndex = retrieveFrameParameterIndex(uri);
+    const multiframeURI = frameParameterIndex === -1 ? uri : uri.slice(0, frameParameterIndex);
+    const frame = parseInt(uri.slice(frameParameterIndex + 7), 10) || 1;
+    let dataSet;
+    if (loadedDataSets[multiframeURI]) {
+        dataSet = loadedDataSets[multiframeURI].dataSet;
+    }
+    else {
+        dataSet = undefined;
+    }
+    return {
+        dataSet,
+        frame,
+    };
+}
+function generateMultiframeWADOURIs(uri) {
+    const listWADOURIs = [];
+    const dataSet = _get(uri);
+    if (_isMultiframeDataset(dataSet)) {
+        const numberOfFrames = dataSet.intString('x00280008');
+        for (let i = 1; i <= numberOfFrames; i++) {
+            listWADOURIs.push(`${uri}&frame=${i}`);
+        }
+    }
+    else {
+        listWADOURIs.push(uri);
+    }
+    return listWADOURIs;
+}
+export default {
+    _get,
+    generateMultiframeWADOURIs,
+    retrieveMultiframeDataset,
+    isMultiframeDataset,
+};

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

@@ -0,0 +1,3 @@
+import { ByteArray } from 'dicom-parser';
+declare function unpackBinaryFrame(byteArray: ByteArray, frameOffset: number, pixelsPerFrame: number): Uint8Array;
+export default unpackBinaryFrame;

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

@@ -0,0 +1,14 @@
+function isBitSet(byte, bitPos) {
+    return byte & (1 << bitPos);
+}
+function unpackBinaryFrame(byteArray, frameOffset, pixelsPerFrame) {
+    const pixelData = new Uint8Array(pixelsPerFrame);
+    for (let i = 0; i < pixelsPerFrame; i++) {
+        const bytePos = Math.floor(i / 8);
+        const byte = byteArray[bytePos + frameOffset];
+        const bitPos = i % 8;
+        pixelData[i] = isBitSet(byte, bitPos) ? 1 : 0;
+    }
+    return pixelData;
+}
+export default unpackBinaryFrame;

package/dist/esm/src/shared/calculateMinMax.d.ts

@@ -0,0 +1,2 @@
+import { ImageFrame } from '../types';
+export default function calculateMinMax(imageFrame: ImageFrame, strict?: boolean): void;

package/dist/esm/src/shared/calculateMinMax.js

@@ -0,0 +1,24 @@
+import getMinMax from './getMinMax';
+export default function calculateMinMax(imageFrame, strict = true) {
+    const minMax = imageFrame.minAfterScale !== undefined ||
+        imageFrame.maxAfterScale !== undefined
+        ? { min: imageFrame.minAfterScale, max: imageFrame.maxAfterScale }
+        : getMinMax(imageFrame.pixelData);
+    const mustAssign = !(isNumber(imageFrame.smallestPixelValue) &&
+        isNumber(imageFrame.largestPixelValue));
+    if (strict === true && !mustAssign) {
+        if (imageFrame.smallestPixelValue !== minMax.min) {
+            console.warn('Image smallestPixelValue tag is incorrect. Rendering performance will suffer considerably.');
+        }
+        if (imageFrame.largestPixelValue !== minMax.max) {
+            console.warn('Image largestPixelValue tag is incorrect. Rendering performance will suffer considerably.');
+        }
+    }
+    else {
+        imageFrame.smallestPixelValue = minMax.min;
+        imageFrame.largestPixelValue = minMax.max;
+    }
+}
+function isNumber(numValue) {
+    return typeof numValue === 'number';
+}

package/dist/esm/src/shared/calculateMinMax_test.d.ts

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