@cornerstonejs/dicom-image-loader 2.0.0-beta.7 → 2.0.0

package/dist/esm/imageLoader/convertColorSpace.js

@@ -0,0 +1,40 @@
+import { convertRGBColorByPixel, convertRGBColorByPlane, convertYBRFullByPixel, convertYBRFull422ByPixel, convertYBRFullByPlane, convertPALETTECOLOR, } from './colorSpaceConverters/index';
+function convertRGB(imageFrame, colorBuffer, useRGBA) {
+    if (imageFrame.planarConfiguration === 0) {
+        convertRGBColorByPixel(imageFrame.pixelData, colorBuffer, useRGBA);
+    }
+    else {
+        convertRGBColorByPlane(imageFrame.pixelData, colorBuffer, useRGBA);
+    }
+}
+function convertYBRFull(imageFrame, colorBuffer, useRGBA) {
+    if (imageFrame.planarConfiguration === 0) {
+        convertYBRFullByPixel(imageFrame.pixelData, colorBuffer, useRGBA);
+    }
+    else {
+        convertYBRFullByPlane(imageFrame.pixelData, colorBuffer, useRGBA);
+    }
+}
+export default function convertColorSpace(imageFrame, colorBuffer, useRGBA) {
+    if (imageFrame.photometricInterpretation === 'RGB') {
+        convertRGB(imageFrame, colorBuffer, useRGBA);
+    }
+    else if (imageFrame.photometricInterpretation === 'YBR_RCT') {
+        convertRGB(imageFrame, colorBuffer, useRGBA);
+    }
+    else if (imageFrame.photometricInterpretation === 'YBR_ICT') {
+        convertRGB(imageFrame, colorBuffer, useRGBA);
+    }
+    else if (imageFrame.photometricInterpretation === 'PALETTE COLOR') {
+        convertPALETTECOLOR(imageFrame, colorBuffer, useRGBA);
+    }
+    else if (imageFrame.photometricInterpretation === 'YBR_FULL_422') {
+        convertYBRFull422ByPixel(imageFrame.pixelData, colorBuffer, useRGBA);
+    }
+    else if (imageFrame.photometricInterpretation === 'YBR_FULL') {
+        convertYBRFull(imageFrame, colorBuffer, useRGBA);
+    }
+    else {
+        throw new Error(`No color space conversion for photometric interpretation ${imageFrame.photometricInterpretation}`);
+    }
+}

package/dist/esm/imageLoader/createImage.d.ts

@@ -0,0 +1,5 @@
+import type { ByteArray } from 'dicom-parser';
+import type { DICOMLoaderImageOptions, DICOMLoaderIImage } from '../types';
+import type { Types } from '@cornerstonejs/core';
+declare function createImage(imageId: string, pixelData: ByteArray, transferSyntax: string, options?: DICOMLoaderImageOptions): Promise<DICOMLoaderIImage | Types.IImageFrame>;
+export default createImage;

package/dist/esm/imageLoader/createImage.js

@@ -0,0 +1,245 @@
+import getMinMax from '../shared/getMinMax';
+import getPixelDataTypeFromMinMax from '../shared/getPixelDataTypeFromMinMax';
+import { canRenderFloatTextures, Enums, metaData, utilities, } from '@cornerstonejs/core';
+import convertColorSpace from './convertColorSpace';
+import isColorConversionRequired from './isColorConversionRequired';
+import decodeImageFrame from './decodeImageFrame';
+import getImageFrame from './getImageFrame';
+import getScalingParameters from './getScalingParameters';
+import { getOptions } from './internal/options';
+import isColorImageFn from '../shared/isColorImage';
+let lastImageIdDrawn = '';
+function isModalityLUTForDisplay(sopClassUid) {
+    return (sopClassUid !== '1.2.840.10008.5.1.4.1.1.12.1' &&
+        sopClassUid !== '1.2.840.10008.5.1.4.1.1.12.2.1');
+}
+function setPixelDataType(imageFrame) {
+    const minValue = imageFrame.smallestPixelValue;
+    const maxValue = imageFrame.largestPixelValue;
+    const TypedArray = getPixelDataTypeFromMinMax(minValue, maxValue);
+    if (TypedArray) {
+        const typedArray = new TypedArray(imageFrame.pixelData);
+        imageFrame.pixelData = typedArray;
+    }
+    else {
+        throw new Error('Could not apply a typed array to the pixel data');
+    }
+}
+function removeAFromRGBA(pixelData, targetBuffer) {
+    const numPixels = pixelData.length / 4;
+    let rgbIndex = 0;
+    let bufferIndex = 0;
+    for (let i = 0; i < numPixels; i++) {
+        targetBuffer[bufferIndex++] = pixelData[rgbIndex++];
+        targetBuffer[bufferIndex++] = pixelData[rgbIndex++];
+        targetBuffer[bufferIndex++] = pixelData[rgbIndex++];
+        rgbIndex++;
+    }
+    return targetBuffer;
+}
+function createImage(imageId, pixelData, transferSyntax, options = {}) {
+    const useRGBA = options.useRGBA;
+    options.preScale = {
+        enabled: options.preScale && options.preScale.enabled !== undefined
+            ? options.preScale.enabled
+            : true,
+    };
+    if (!pixelData?.length) {
+        return Promise.reject(new Error('The pixel data is missing'));
+    }
+    const { MetadataModules } = Enums;
+    const canvas = document.createElement('canvas');
+    const imageFrame = getImageFrame(imageId);
+    imageFrame.decodeLevel = options.decodeLevel;
+    options.allowFloatRendering = canRenderFloatTextures();
+    if (options.preScale.enabled) {
+        const scalingParameters = getScalingParameters(metaData, imageId);
+        if (scalingParameters) {
+            options.preScale = {
+                ...options.preScale,
+                scalingParameters: scalingParameters,
+            };
+        }
+    }
+    const { decodeConfig } = getOptions();
+    Object.keys(imageFrame).forEach((key) => {
+        if (typeof imageFrame[key] === 'function' ||
+            imageFrame[key] instanceof Promise) {
+            delete imageFrame[key];
+        }
+    });
+    const decodePromise = decodeImageFrame(imageFrame, transferSyntax, pixelData, canvas, options, decodeConfig);
+    const isColorImage = isColorImageFn(imageFrame.photometricInterpretation);
+    return new Promise((resolve, reject) => {
+        decodePromise.then(function (imageFrame) {
+            let alreadyTyped = false;
+            if (options.targetBuffer &&
+                options.targetBuffer.type &&
+                !isColorImage) {
+                const { arrayBuffer, type, offset: rawOffset = 0, length: rawLength, } = options.targetBuffer;
+                const imageFrameLength = imageFrame.pixelDataLength;
+                const offset = rawOffset;
+                const length = rawLength !== null && rawLength !== undefined
+                    ? rawLength
+                    : imageFrameLength - offset;
+                const typedArrayConstructors = {
+                    Uint8Array,
+                    Uint16Array,
+                    Int16Array,
+                    Float32Array,
+                };
+                if (length !== imageFrame.pixelDataLength) {
+                    throw new Error(`target array for image does not have the same length (${length}) as the decoded image length (${imageFrame.pixelDataLength}).`);
+                }
+                const TypedArrayConstructor = typedArrayConstructors[type];
+                const typedArray = arrayBuffer
+                    ? new TypedArrayConstructor(arrayBuffer, offset, length)
+                    : new TypedArrayConstructor(imageFrame.pixelData);
+                if (length !== imageFrame.pixelDataLength) {
+                    throw new Error('target array for image does not have the same length as the decoded image length.');
+                }
+                imageFrame.pixelData = typedArray;
+                alreadyTyped = true;
+            }
+            if (!alreadyTyped) {
+                setPixelDataType(imageFrame);
+            }
+            const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId) || {};
+            const voiLutModule = metaData.get(MetadataModules.VOI_LUT, imageId) || {};
+            const modalityLutModule = metaData.get(MetadataModules.MODALITY_LUT, imageId) || {};
+            const sopCommonModule = metaData.get(MetadataModules.SOP_COMMON, imageId) || {};
+            const calibrationModule = metaData.get(MetadataModules.CALIBRATION, imageId) || {};
+            const { rows, columns } = imageFrame;
+            if (isColorImage) {
+                if (isColorConversionRequired(imageFrame)) {
+                    canvas.height = imageFrame.rows;
+                    canvas.width = imageFrame.columns;
+                    const context = canvas.getContext('2d');
+                    let imageData = context.createImageData(imageFrame.columns, imageFrame.rows);
+                    if (!useRGBA) {
+                        imageData = {
+                            ...imageData,
+                            data: new Uint8ClampedArray(3 * imageFrame.columns * imageFrame.rows),
+                        };
+                    }
+                    convertColorSpace(imageFrame, imageData.data, useRGBA);
+                    imageFrame.imageData = imageData;
+                    imageFrame.pixelData = imageData.data;
+                    imageFrame.pixelDataLength = imageData.data.length;
+                }
+                else if (!useRGBA &&
+                    imageFrame.pixelDataLength === 4 * rows * columns) {
+                    const colorBuffer = new Uint8Array((imageFrame.pixelData.length / 4) * 3);
+                    imageFrame.pixelData = removeAFromRGBA(imageFrame.pixelData, colorBuffer);
+                    imageFrame.pixelDataLength = imageFrame.pixelData.length;
+                }
+                const minMax = getMinMax(imageFrame.pixelData);
+                imageFrame.smallestPixelValue = minMax.min;
+                imageFrame.largestPixelValue = minMax.max;
+            }
+            const voxelManager = utilities.VoxelManager.createImageVoxelManager({
+                scalarData: imageFrame.pixelData,
+                width: imageFrame.columns,
+                height: imageFrame.rows,
+                numberOfComponents: imageFrame.samplesPerPixel,
+            });
+            const image = {
+                imageId,
+                dataType: imageFrame.pixelData.constructor
+                    .name,
+                color: isColorImage,
+                calibration: calibrationModule,
+                columnPixelSpacing: imagePlaneModule.columnPixelSpacing,
+                columns: imageFrame.columns,
+                height: imageFrame.rows,
+                preScale: imageFrame.preScale,
+                intercept: modalityLutModule.rescaleIntercept
+                    ? modalityLutModule.rescaleIntercept
+                    : 0,
+                slope: modalityLutModule.rescaleSlope
+                    ? modalityLutModule.rescaleSlope
+                    : 1,
+                invert: imageFrame.photometricInterpretation === 'MONOCHROME1',
+                minPixelValue: imageFrame.smallestPixelValue,
+                maxPixelValue: imageFrame.largestPixelValue,
+                rowPixelSpacing: imagePlaneModule.rowPixelSpacing,
+                rows: imageFrame.rows,
+                sizeInBytes: imageFrame.pixelData.byteLength,
+                width: imageFrame.columns,
+                windowCenter: voiLutModule.windowCenter
+                    ? voiLutModule.windowCenter[0]
+                    : undefined,
+                windowWidth: voiLutModule.windowWidth
+                    ? voiLutModule.windowWidth[0]
+                    : undefined,
+                voiLUTFunction: voiLutModule.voiLUTFunction
+                    ? voiLutModule.voiLUTFunction
+                    : undefined,
+                decodeTimeInMS: imageFrame.decodeTimeInMS,
+                floatPixelData: undefined,
+                imageFrame,
+                voxelManager,
+                rgba: isColorImage && useRGBA,
+                getPixelData: () => imageFrame.pixelData,
+                getCanvas: undefined,
+                numberOfComponents: imageFrame.samplesPerPixel,
+            };
+            if (image.color) {
+                image.getCanvas = function () {
+                    if (lastImageIdDrawn === imageId) {
+                        return canvas;
+                    }
+                    const width = image.columns;
+                    const height = image.rows;
+                    canvas.height = height;
+                    canvas.width = width;
+                    const ctx = canvas.getContext('2d');
+                    const imageData = ctx.createImageData(width, height);
+                    const arr = imageFrame.pixelData;
+                    if (arr.length === width * height * 4) {
+                        for (let i = 0; i < arr.length; i++) {
+                            imageData.data[i] = arr[i];
+                        }
+                    }
+                    else if (arr.length === width * height * 3) {
+                        let j = 0;
+                        for (let i = 0; i < arr.length; i += 3) {
+                            imageData.data[j++] = arr[i];
+                            imageData.data[j++] = arr[i + 1];
+                            imageData.data[j++] = arr[i + 2];
+                            imageData.data[j++] = 255;
+                        }
+                    }
+                    imageFrame.pixelData = imageData.data;
+                    imageFrame.pixelDataLength = imageData.data.length;
+                    imageFrame.imageData = imageData;
+                    ctx.putImageData(imageFrame.imageData, 0, 0);
+                    lastImageIdDrawn = imageId;
+                    return canvas;
+                };
+            }
+            if (modalityLutModule.modalityLUTSequence &&
+                modalityLutModule.modalityLUTSequence.length > 0 &&
+                isModalityLUTForDisplay(sopCommonModule.sopClassUID)) {
+                image.modalityLUT = modalityLutModule.modalityLUTSequence[0];
+            }
+            if (voiLutModule.voiLUTSequence &&
+                voiLutModule.voiLUTSequence.length > 0) {
+                image.voiLUT = voiLutModule.voiLUTSequence[0];
+            }
+            if (image.color) {
+                image.windowWidth = 256;
+                image.windowCenter = 128;
+            }
+            if (image.windowCenter === undefined ||
+                image.windowWidth === undefined) {
+                const minVoi = image.imageFrame.smallestPixelValue;
+                const maxVoi = image.imageFrame.largestPixelValue;
+                image.windowWidth = maxVoi - minVoi;
+                image.windowCenter = (maxVoi + minVoi) / 2;
+            }
+            resolve(image);
+        }, reject);
+    });
+}
+export default createImage;

package/dist/esm/imageLoader/decodeImageFrame.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare function decodeImageFrame(imageFrame: any, transferSyntax: any, pixelData: any, canvas: any, options: {}, decodeConfig: any): Promise<Types.IImageFrame>;
+export default decodeImageFrame;

package/dist/esm/imageLoader/decodeImageFrame.js

@@ -0,0 +1,63 @@
+import decodeJPEGBaseline8BitColor from './decodeJPEGBaseline8BitColor';
+import { getWebWorkerManager } from '@cornerstonejs/core';
+function processDecodeTask(imageFrame, transferSyntax, pixelData, srcOptions, decodeConfig) {
+    const options = { ...srcOptions };
+    delete options.loader;
+    delete options.streamingData;
+    const webWorkerManager = getWebWorkerManager();
+    const priority = options.priority || undefined;
+    const transferList = options.transferPixelData
+        ? [pixelData.buffer]
+        : undefined;
+    return webWorkerManager.executeTask('dicomImageLoader', 'decodeTask', {
+        imageFrame,
+        transferSyntax,
+        pixelData,
+        options,
+        decodeConfig,
+    }, {
+        priority,
+        requestType: options?.requestType,
+    });
+}
+function decodeImageFrame(imageFrame, transferSyntax, pixelData, canvas, options = {}, decodeConfig) {
+    switch (transferSyntax) {
+        case '1.2.840.10008.1.2':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.1':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.2':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.1.99':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.5':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.4.50':
+            if (imageFrame.bitsAllocated === 8 &&
+                (imageFrame.samplesPerPixel === 3 || imageFrame.samplesPerPixel === 4)) {
+                return decodeJPEGBaseline8BitColor(imageFrame, pixelData, canvas);
+            }
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.4.51':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.4.57':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.4.70':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.4.80':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.4.81':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.4.90':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '1.2.840.10008.1.2.4.91':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+        case '3.2.840.10008.1.2.4.96':
+        case '1.2.840.10008.1.2.4.201':
+        case '1.2.840.10008.1.2.4.202':
+        case '1.2.840.10008.1.2.4.203':
+            return processDecodeTask(imageFrame, transferSyntax, pixelData, options, decodeConfig);
+    }
+    return Promise.reject(new Error(`No decoder for transfer syntax ${transferSyntax}`));
+}
+export default decodeImageFrame;

package/dist/esm/imageLoader/decodeJPEGBaseline8BitColor.d.ts

@@ -0,0 +1,4 @@
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+declare function decodeJPEGBaseline8BitColor(imageFrame: Types.IImageFrame, pixelData: ByteArray, canvas: HTMLCanvasElement): Promise<Types.IImageFrame>;
+export default decodeJPEGBaseline8BitColor;

package/dist/esm/imageLoader/decodeJPEGBaseline8BitColor.js

@@ -0,0 +1,64 @@
+import getMinMax from '../shared/getMinMax';
+function arrayBufferToString(buffer) {
+    return binaryToString(String.fromCharCode.apply(null, Array.prototype.slice.apply(new Uint8Array(buffer))));
+}
+function binaryToString(binary) {
+    let error;
+    try {
+        return decodeURIComponent(escape(binary));
+    }
+    catch (_error) {
+        error = _error;
+        if (error instanceof URIError) {
+            return binary;
+        }
+        throw error;
+    }
+}
+function decodeJPEGBaseline8BitColor(imageFrame, pixelData, canvas) {
+    const start = new Date().getTime();
+    const imgBlob = new Blob([pixelData], { type: 'image/jpeg' });
+    return new Promise((resolve, reject) => {
+        const fileReader = new FileReader();
+        if (fileReader.readAsBinaryString === undefined) {
+            fileReader.readAsArrayBuffer(imgBlob);
+        }
+        else {
+            fileReader.readAsBinaryString(imgBlob);
+        }
+        fileReader.onload = function () {
+            const img = new Image();
+            img.onload = function () {
+                canvas.height = img.height;
+                canvas.width = img.width;
+                imageFrame.rows = img.height;
+                imageFrame.columns = img.width;
+                const context = canvas.getContext('2d');
+                context.drawImage(this, 0, 0);
+                const imageData = context.getImageData(0, 0, img.width, img.height);
+                const end = new Date().getTime();
+                imageFrame.pixelData = new Uint8Array(imageData.data.buffer);
+                imageFrame.imageData = imageData;
+                imageFrame.decodeTimeInMS = end - start;
+                const minMax = getMinMax(imageFrame.pixelData);
+                imageFrame.smallestPixelValue = minMax.min;
+                imageFrame.largestPixelValue = minMax.max;
+                imageFrame.pixelDataLength = imageFrame.pixelData.length;
+                resolve(imageFrame);
+            };
+            img.onerror = function (error) {
+                reject(error);
+            };
+            if (fileReader.readAsBinaryString === undefined) {
+                img.src = `data:image/jpeg;base64,${window.btoa(arrayBufferToString(fileReader.result))}`;
+            }
+            else {
+                img.src = `data:image/jpeg;base64,${window.btoa(fileReader.result)}`;
+            }
+        };
+        fileReader.onerror = (e) => {
+            reject(e);
+        };
+    });
+}
+export default decodeJPEGBaseline8BitColor;

package/dist/esm/imageLoader/getImageFrame.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare function getImageFrame(imageId: string): Types.IImageFrame;
+export default getImageFrame;

package/dist/esm/imageLoader/getImageFrame.js

@@ -0,0 +1,25 @@
+import { metaData } from '@cornerstonejs/core';
+function getImageFrame(imageId) {
+    const imagePixelModule = metaData.get('imagePixelModule', imageId);
+    return {
+        samplesPerPixel: imagePixelModule.samplesPerPixel,
+        photometricInterpretation: imagePixelModule.photometricInterpretation,
+        planarConfiguration: imagePixelModule.planarConfiguration,
+        rows: imagePixelModule.rows,
+        columns: imagePixelModule.columns,
+        bitsAllocated: imagePixelModule.bitsAllocated,
+        bitsStored: imagePixelModule.bitsStored,
+        pixelRepresentation: imagePixelModule.pixelRepresentation,
+        smallestPixelValue: imagePixelModule.smallestPixelValue,
+        largestPixelValue: imagePixelModule.largestPixelValue,
+        redPaletteColorLookupTableDescriptor: imagePixelModule.redPaletteColorLookupTableDescriptor,
+        greenPaletteColorLookupTableDescriptor: imagePixelModule.greenPaletteColorLookupTableDescriptor,
+        bluePaletteColorLookupTableDescriptor: imagePixelModule.bluePaletteColorLookupTableDescriptor,
+        redPaletteColorLookupTableData: imagePixelModule.redPaletteColorLookupTableData,
+        greenPaletteColorLookupTableData: imagePixelModule.greenPaletteColorLookupTableData,
+        bluePaletteColorLookupTableData: imagePixelModule.bluePaletteColorLookupTableData,
+        pixelData: undefined,
+        imageId,
+    };
+}
+export default getImageFrame;

package/dist/esm/imageLoader/getInstanceModule.d.ts

@@ -0,0 +1,3 @@
+declare function getInstanceModule(imageId: any, metaDataProvider: any, types: any): {};
+declare const instanceModuleNames: string[];
+export { getInstanceModule, instanceModuleNames };

package/dist/esm/imageLoader/getInstanceModule.js

@@ -0,0 +1,40 @@
+function getInstanceModule(imageId, metaDataProvider, types) {
+    const result = {};
+    for (const t of types) {
+        try {
+            const data = metaDataProvider(t, imageId);
+            if (data) {
+                const capitalizedData = {};
+                for (const key in data) {
+                    if (key in data) {
+                        const capitalizedKey = capitalizeTag(key);
+                        capitalizedData[capitalizedKey] = data[key];
+                    }
+                }
+                Object.assign(result, capitalizedData);
+            }
+        }
+        catch (error) {
+            console.error(`Error retrieving ${t} data:`, error);
+        }
+    }
+    return result;
+}
+const capitalizeTag = (tag) => tag.charAt(0).toUpperCase() + tag.slice(1);
+const instanceModuleNames = [
+    'multiframeModule',
+    'generalSeriesModule',
+    'patientStudyModule',
+    'imagePlaneModule',
+    'nmMultiframeGeometryModule',
+    'imagePixelModule',
+    'modalityLutModule',
+    'voiLutModule',
+    'sopCommonModule',
+    'petIsotopeModule',
+    'overlayPlaneModule',
+    'transferSyntax',
+    'petSeriesModule',
+    'petImageModule',
+];
+export { getInstanceModule, instanceModuleNames };

package/dist/esm/imageLoader/getMinMax.d.ts

@@ -0,0 +1,4 @@
+export default function getMinMax(storedPixelData: ArrayLike<number>): {
+    min: number;
+    max: number;
+};

package/dist/esm/imageLoader/getMinMax.js

@@ -0,0 +1,15 @@
+export default function getMinMax(storedPixelData) {
+    let min = storedPixelData[0];
+    let max = storedPixelData[0];
+    let storedPixel;
+    const numPixels = storedPixelData.length;
+    for (let index = 0; index < numPixels; index++) {
+        storedPixel = storedPixelData[index];
+        min = Math.min(min, storedPixel);
+        max = Math.max(max, storedPixel);
+    }
+    return {
+        min,
+        max,
+    };
+}

package/dist/esm/imageLoader/getScalingParameters.d.ts

@@ -0,0 +1,6 @@
+export default function getScalingParameters(metaData: any, imageId: string): {
+    suvbw: any;
+    rescaleSlope: any;
+    rescaleIntercept: any;
+    modality: string;
+};

package/dist/esm/imageLoader/getScalingParameters.js

@@ -0,0 +1,16 @@
+export default function getScalingParameters(metaData, imageId) {
+    const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
+    const generalSeriesModule = (metaData.get('generalSeriesModule', imageId) ||
+        {});
+    const { modality } = generalSeriesModule;
+    const scalingParameters = {
+        rescaleSlope: modalityLutModule.rescaleSlope,
+        rescaleIntercept: modalityLutModule.rescaleIntercept,
+        modality,
+    };
+    const suvFactor = metaData.get('scalingModule', imageId) || {};
+    return {
+        ...scalingParameters,
+        ...(modality === 'PT' && { suvbw: suvFactor.suvbw }),
+    };
+}

package/dist/esm/imageLoader/imageIdToURI.d.ts

@@ -0,0 +1 @@
+export default function imageIdToURI(imageId: string): string;

package/dist/esm/imageLoader/imageIdToURI.js

@@ -0,0 +1,4 @@
+export default function imageIdToURI(imageId) {
+    const colonIndex = imageId.indexOf(':');
+    return imageId.substring(colonIndex + 1);
+}

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

@@ -0,0 +1,91 @@
+import { convertRGBColorByPixel, convertRGBColorByPlane, convertYBRFullByPixel, convertYBRFullByPlane, convertPALETTECOLOR } from './colorSpaceConverters/index';
+import { default as wadouri } from './wadouri/index';
+import { default as wadors } from './wadors/index';
+import { default as init } from './init';
+import { default as convertColorSpace } from './convertColorSpace';
+import { default as createImage } from './createImage';
+import { default as decodeJPEGBaseline8BitColor } from './decodeJPEGBaseline8BitColor';
+import { default as getImageFrame } from './getImageFrame';
+import { default as getMinMax } from '../shared/getMinMax';
+import { default as isColorImage } from '../shared/isColorImage';
+import { default as isJPEGBaseline8BitColor } from './isJPEGBaseline8BitColor';
+import { default as getPixelData } from './wadors/getPixelData';
+import { internal } from './internal/index';
+declare const cornerstoneDICOMImageLoader: {
+    convertRGBColorByPixel: typeof convertRGBColorByPixel;
+    convertRGBColorByPlane: typeof convertRGBColorByPlane;
+    convertYBRFullByPixel: typeof convertYBRFullByPixel;
+    convertYBRFullByPlane: typeof convertYBRFullByPlane;
+    convertPALETTECOLOR: typeof convertPALETTECOLOR;
+    wadouri: {
+        metaData: {
+            getImagePixelModule: typeof import("./wadouri/metaData").getImagePixelModule;
+            getLUTs: typeof import("./wadouri/metaData").getLUTs;
+            getModalityLUTOutputPixelRepresentation: typeof import("./wadouri/metaData").getModalityLUTOutputPixelRepresentation;
+            getNumberValues: typeof import("./wadouri/metaData").getNumberValues;
+            metaDataProvider: typeof import("./wadouri/metaData").metaDataProvider;
+            metadataForDataset: typeof import("./wadouri/metaData").metadataForDataset;
+        };
+        dataSetCacheManager: {
+            isLoaded: (uri: string) => boolean;
+            load: (uri: string, loadRequest: import("../types").LoadRequestFunction, imageId: string) => import("./wadouri/dataSetCacheManager").CornerstoneWadoLoaderCachedPromise;
+            unload: (uri: string) => void;
+            getInfo: typeof import("./wadouri/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 import("./wadouri/getEncapsulatedImageFrame").default;
+        getUncompressedImageFrame: typeof import("./wadouri/getUncompressedImageFrame").default;
+        loadFileRequest: typeof import("./wadouri/loadFileRequest").default;
+        loadImageFromPromise: typeof import("./wadouri/loadImage").loadImageFromPromise;
+        getLoaderForScheme: typeof import("./wadouri/loadImage").getLoaderForScheme;
+        getPixelData: typeof import("./wadouri/getPixelData").default;
+        loadImage: typeof import("./wadouri/loadImage").loadImage;
+        parseImageId: typeof import("./wadouri/parseImageId").default;
+        unpackBinaryFrame: typeof import("./wadouri/unpackBinaryFrame").default;
+        register: typeof import("./wadouri/register").default;
+    };
+    wadors: {
+        metaData: {
+            getNumberString: typeof import("./wadors/metaData").getNumberString;
+            getNumberValue: typeof import("./wadors/metaData").getNumberValue;
+            getNumberValues: typeof import("./wadors/metaData").getNumberValues;
+            getValue: typeof import("./wadors/metaData").getValue;
+            metaDataProvider: typeof import("./wadors/metaData").metaDataProvider;
+        };
+        findIndexOfString: typeof import("./wadors/findIndexOfString").default;
+        getPixelData: typeof getPixelData;
+        loadImage: typeof import("./wadors/loadImage").default;
+        metaDataManager: {
+            add: (imageId: string, metadata: import("../types").WADORSMetaData) => void;
+            get: (imageId: string) => import("../types").WADORSMetaData;
+            remove: (imageId: any) => void;
+            purge: () => void;
+        };
+        register: typeof import("./wadors/register").default;
+    };
+    init: typeof init;
+    convertColorSpace: typeof convertColorSpace;
+    createImage: typeof createImage;
+    decodeJPEGBaseline8BitColor: typeof decodeJPEGBaseline8BitColor;
+    getImageFrame: typeof getImageFrame;
+    getPixelData: typeof getPixelData;
+    getMinMax: typeof getMinMax;
+    isColorImage: typeof isColorImage;
+    isJPEGBaseline8BitColor: typeof isJPEGBaseline8BitColor;
+    internal: {
+        xhrRequest: typeof import("./internal/xhrRequest").default;
+        streamRequest: typeof import("./internal/streamRequest").default;
+        setOptions: typeof import("./internal/options").setOptions;
+        getOptions: typeof import("./internal/options").getOptions;
+    };
+};
+export { convertRGBColorByPixel, convertRGBColorByPlane, convertYBRFullByPixel, convertYBRFullByPlane, convertPALETTECOLOR, wadouri, wadors, init, convertColorSpace, createImage, decodeJPEGBaseline8BitColor, getImageFrame, getPixelData, getMinMax, isColorImage, isJPEGBaseline8BitColor, internal, };
+export default cornerstoneDICOMImageLoader;