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

package/dist/esm/src/constants/transferSyntaxes.d.ts

@@ -0,0 +1,46 @@
+export default transferSyntaxes;
+declare namespace transferSyntaxes {
+    let IMPLICIT_VR_LITTLE_ENDIAN: string;
+    let EXPLICIT_VR_LITTLE_ENDIAN: string;
+    let DEFLATED_EXPLICIT_VR_LITTLE_ENDIAN: string;
+    let EXPLICIT_VR_BIG_ENDIAN: string;
+    let JPEG_BASELINE_PROCESS_1: string;
+    let JPEG_EXTENDED_PROCESS_2_4: string;
+    let JPEG_EXTENDED_PROCESSES_3_5: string;
+    let JPEG_SPECTRAL_SELECTION_NONHIERARCHICAL_PROCESSES_6_8: string;
+    let JPEG_SPECTRAL_SELECTION_NONHIERARCHICAL_PROCESSES_7_9: string;
+    let JPEG_FULL_PROGRESSION_NONHIERARCHICAL_PROCESSES_10_12: string;
+    let JPEG_FULL_PROGRESSION_NONHIERARCHICAL_PROCESSES_11_13: string;
+    let JPEG_LOSSLESS_NONHIERARCHICAL_PROCESS_14: string;
+    let JPEG_LOSSLESS_NONHIERARCHICAL_PROCESS_15: string;
+    let JPEG_EXTENDED_HIERARCHICAL_PROCESSES_16_18: string;
+    let JPEG_EXTENDED_HIERARCHICAL_PROCESSES_17_19: string;
+    let JPEG_SPECTRAL_SELECTION_HIERARCHICAL_PROCESSES_20_22: string;
+    let JPEG_SPECTRAL_SELECTION_HIERARCHICAL_PROCESSES_21_23: string;
+    let JPEG_FULL_PROGRESSION_HIERARCHICAL_PROCESSES_24_26: string;
+    let JPEG_FULL_PROGRESSION_HIERARCHICAL_PROCESSES_25_27: string;
+    let JPEG_LOSSLESS_NONHIERARCHICAL_PROCESS_28: string;
+    let JPEG_LOSSLESS_NONHIERARCHICAL_PROCESS_29: string;
+    let JPEG_LOSSLESS_NONHIERARCHICAL_FIRST_ORDER_PREDICTION_PROCESS_14: string;
+    let JPEG_LS_LOSSLESS_IMAGE_COMPRESSION: string;
+    let JPEG_LS_LOSSY_NEAR_LOSSLESS_IMAGE_COMPRESSION: string;
+    let JPEG_2000_IMAGE_COMPRESSION_LOSSLESS_ONLY: string;
+    let JPEG_2000_IMAGE_COMPRESSION: string;
+    let JPEG_2000_PART_2_MULTICOMPONENT_IMAGE_COMPRESSION_LOSSLESS_ONLY: string;
+    let JPEG_2000_PART_2_MULTICOMPONENT_IMAGE_COMPRESSION: string;
+    let JPIP_REFERENCED: string;
+    let JPIP_REFERENCED_DEFLATE: string;
+    let MPEG2_MAIN_PROFILE_MAIN_LEVEL: string;
+    let MPEG4_AVC_H264_HIGH_PROFILE_LEVEL_4_1: string;
+    let MPEG4_AVC_H264_BD_COMPATIBLE_HIGH_PROFILE_LEVEL_4_1: string;
+    let MPEG4_AVC_H264_HIGH_PROFILE_FOR_2D_VIDEO: string;
+    let MPEG4_AVC_H264_HIGH_PROFILE_FOR_3D_VIDEO: string;
+    let JPIP_LOSSLESS: string;
+    let JPIP_PART2_MULTICOMPONENT_IMAGE_COMPRESSION: string;
+    let RFC_2557_MIME_ENCAPSULATION: string;
+    let JPEG_XR_IMAGE_COMPRESSION: string;
+    let JPEG_2000_IMAGE_COMPRESSION_LOSSLESS_ONLY_RETIRED: string;
+    let JPEG_2000_IMAGE_COMPRESSION_RETIRED: string;
+    let JPEG_2000_PART_2_MULTICOMPONENT_IMAGE_COMPRESSION_LOSSLESS_ONLY_RETIRED: string;
+    let JPEG_2000_PART_2_MULTICOMPONENT_IMAGE_COMPRESSION_RETIRED: string;
+}

package/dist/esm/src/constants/transferSyntaxes.js

@@ -0,0 +1,46 @@
+const transferSyntaxes = {
+    IMPLICIT_VR_LITTLE_ENDIAN: '1.2.840.10008.1.2',
+    EXPLICIT_VR_LITTLE_ENDIAN: '1.2.840.10008.1.2.1',
+    DEFLATED_EXPLICIT_VR_LITTLE_ENDIAN: '1.2.840.10008.1.2.1.99',
+    EXPLICIT_VR_BIG_ENDIAN: '1.2.840.10008.1.2.2',
+    JPEG_BASELINE_PROCESS_1: '1.2.840.10008.1.2.4.50',
+    JPEG_EXTENDED_PROCESS_2_4: '1.2.840.10008.1.2.4.51',
+    JPEG_EXTENDED_PROCESSES_3_5: '1.2.840.10008.1.2.4.52',
+    JPEG_SPECTRAL_SELECTION_NONHIERARCHICAL_PROCESSES_6_8: '1.2.840.10008.1.2.4.53',
+    JPEG_SPECTRAL_SELECTION_NONHIERARCHICAL_PROCESSES_7_9: '1.2.840.10008.1.2.4.54',
+    JPEG_FULL_PROGRESSION_NONHIERARCHICAL_PROCESSES_10_12: '1.2.840.10008.1.2.4.55',
+    JPEG_FULL_PROGRESSION_NONHIERARCHICAL_PROCESSES_11_13: '1.2.840.10008.1.2.4.56',
+    JPEG_LOSSLESS_NONHIERARCHICAL_PROCESS_14: '1.2.840.10008.1.2.4.57',
+    JPEG_LOSSLESS_NONHIERARCHICAL_PROCESS_15: '1.2.840.10008.1.2.4.58',
+    JPEG_EXTENDED_HIERARCHICAL_PROCESSES_16_18: '1.2.840.10008.1.2.4.59',
+    JPEG_EXTENDED_HIERARCHICAL_PROCESSES_17_19: '1.2.840.10008.1.2.4.60',
+    JPEG_SPECTRAL_SELECTION_HIERARCHICAL_PROCESSES_20_22: '1.2.840.10008.1.2.4.61',
+    JPEG_SPECTRAL_SELECTION_HIERARCHICAL_PROCESSES_21_23: '1.2.840.10008.1.2.4.62',
+    JPEG_FULL_PROGRESSION_HIERARCHICAL_PROCESSES_24_26: '1.2.840.10008.1.2.4.63',
+    JPEG_FULL_PROGRESSION_HIERARCHICAL_PROCESSES_25_27: '1.2.840.10008.1.2.4.64',
+    JPEG_LOSSLESS_NONHIERARCHICAL_PROCESS_28: '1.2.840.10008.1.2.4.65',
+    JPEG_LOSSLESS_NONHIERARCHICAL_PROCESS_29: '1.2.840.10008.1.2.4.66',
+    JPEG_LOSSLESS_NONHIERARCHICAL_FIRST_ORDER_PREDICTION_PROCESS_14: '1.2.840.10008.1.2.4.70',
+    JPEG_LS_LOSSLESS_IMAGE_COMPRESSION: '1.2.840.10008.1.2.4.80',
+    JPEG_LS_LOSSY_NEAR_LOSSLESS_IMAGE_COMPRESSION: '1.2.840.10008.1.2.4.81',
+    JPEG_2000_IMAGE_COMPRESSION_LOSSLESS_ONLY: '1.2.840.10008.1.2.4.90',
+    JPEG_2000_IMAGE_COMPRESSION: '1.2.840.10008.1.2.4.91',
+    JPEG_2000_PART_2_MULTICOMPONENT_IMAGE_COMPRESSION_LOSSLESS_ONLY: '1.2.840.10008.1.2.4.92',
+    JPEG_2000_PART_2_MULTICOMPONENT_IMAGE_COMPRESSION: '1.2.840.10008.1.2.4.93',
+    JPIP_REFERENCED: '1.2.840.10008.1.2.4.94',
+    JPIP_REFERENCED_DEFLATE: '1.2.840.10008.1.2.4.95',
+    MPEG2_MAIN_PROFILE_MAIN_LEVEL: '1.2.840.10008.1.2.4.100',
+    MPEG4_AVC_H264_HIGH_PROFILE_LEVEL_4_1: '1.2.840.10008.1.2.4.101',
+    MPEG4_AVC_H264_BD_COMPATIBLE_HIGH_PROFILE_LEVEL_4_1: '1.2.840.10008.1.2.4.102',
+    MPEG4_AVC_H264_HIGH_PROFILE_FOR_2D_VIDEO: '1.2.840.10008.1.2.4.103',
+    MPEG4_AVC_H264_HIGH_PROFILE_FOR_3D_VIDEO: '1.2.840.10008.1.2.4.104',
+    JPIP_LOSSLESS: '1.2.840.10008.1.2.4.96',
+    JPIP_PART2_MULTICOMPONENT_IMAGE_COMPRESSION: '1.2.840.10008.1.2.4.97',
+    RFC_2557_MIME_ENCAPSULATION: '1.2.840.10008.1.2.6.1',
+    JPEG_XR_IMAGE_COMPRESSION: '1.2.840.10008.1.2.6.2',
+    JPEG_2000_IMAGE_COMPRESSION_LOSSLESS_ONLY_RETIRED: '1.2.840.10008.1.2.4.90R',
+    JPEG_2000_IMAGE_COMPRESSION_RETIRED: '1.2.840.10008.1.2.4.91R',
+    JPEG_2000_PART_2_MULTICOMPONENT_IMAGE_COMPRESSION_LOSSLESS_ONLY_RETIRED: '1.2.840.10008.1.2.4.92R',
+    JPEG_2000_PART_2_MULTICOMPONENT_IMAGE_COMPRESSION_RETIRED: '1.2.840.10008.1.2.4.93R',
+};
+export default transferSyntaxes;

package/dist/esm/src/decodeImageFrameWorker.d.ts

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

package/dist/esm/src/decodeImageFrameWorker.js

@@ -0,0 +1,262 @@
+import bilinear from './shared/scaling/bilinear';
+import replicate from './shared/scaling/replicate';
+import { expose } from 'comlink';
+import decodeLittleEndian from './shared/decoders/decodeLittleEndian';
+import decodeBigEndian from './shared/decoders/decodeBigEndian';
+import decodeRLE from './shared/decoders/decodeRLE';
+import decodeJPEGBaseline8Bit from './shared/decoders/decodeJPEGBaseline8Bit';
+import decodeJPEGBaseline12Bit from './shared/decoders/decodeJPEGBaseline12Bit-js';
+import decodeJPEGLossless from './shared/decoders/decodeJPEGLossless';
+import decodeJPEGLS from './shared/decoders/decodeJPEGLS';
+import decodeJPEG2000 from './shared/decoders/decodeJPEG2000';
+import decodeHTJ2K from './shared/decoders/decodeHTJ2K';
+import applyModalityLUT from './shared/scaling/scaleArray';
+import getMinMax from './shared/getMinMax';
+import getPixelDataTypeFromMinMax from './shared/getPixelDataTypeFromMinMax';
+import isColorImage from './shared/isColorImage';
+const imageUtils = {
+    bilinear,
+    replicate,
+};
+async function decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn) {
+    const start = new Date().getTime();
+    let decodePromise = null;
+    let opts;
+    switch (transferSyntax) {
+        case '1.2.840.10008.1.2':
+        case '1.2.840.10008.1.2.1':
+            decodePromise = decodeLittleEndian(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.2':
+            decodePromise = decodeBigEndian(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.1.99':
+            decodePromise = decodeLittleEndian(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.5':
+            decodePromise = decodeRLE(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.50':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEGBaseline8Bit(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.51':
+            decodePromise = decodeJPEGBaseline12Bit(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.57':
+            decodePromise = decodeJPEGLossless(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.70':
+            decodePromise = decodeJPEGLossless(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.80':
+            opts = {
+                signed: imageFrame.pixelRepresentation === 1,
+                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEGLS(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.81':
+            opts = {
+                signed: imageFrame.pixelRepresentation === 1,
+                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEGLS(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.90':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEG2000(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.91':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = decodeJPEG2000(pixelData, opts);
+            break;
+        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':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = decodeHTJ2K(pixelData, opts);
+            break;
+        default:
+            throw new Error(`no decoder for transfer syntax ${transferSyntax}`);
+    }
+    if (!decodePromise) {
+        throw new Error('decodePromise not defined');
+    }
+    const decodedFrame = await decodePromise;
+    const postProcessed = postProcessDecodedPixels(decodedFrame, options, start, decodeConfig);
+    callbackFn?.(postProcessed);
+    return postProcessed;
+}
+function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
+    const shouldShift = imageFrame.pixelRepresentation !== undefined &&
+        imageFrame.pixelRepresentation === 1;
+    const shift = shouldShift && imageFrame.bitsStored !== undefined
+        ? 32 - imageFrame.bitsStored
+        : undefined;
+    if (shouldShift && shift !== undefined) {
+        for (let i = 0; i < imageFrame.pixelData.length; i++) {
+            imageFrame.pixelData[i] = (imageFrame.pixelData[i] << shift) >> shift;
+        }
+    }
+    let pixelDataArray = imageFrame.pixelData;
+    imageFrame.pixelDataLength = imageFrame.pixelData.length;
+    const { min: minBeforeScale, max: maxBeforeScale } = getMinMax(imageFrame.pixelData);
+    const typedArrayConstructors = {
+        Uint8Array,
+        Uint16Array,
+        Int16Array,
+        Float32Array,
+    };
+    const type = options.targetBuffer?.type;
+    const canRenderFloat = typeof options.allowFloatRendering !== 'undefined'
+        ? options.allowFloatRendering
+        : true;
+    const invalidType = isColorImage(imageFrame.photometricInterpretation) &&
+        options.targetBuffer?.offset === undefined;
+    const willScale = options.preScale?.enabled;
+    const hasFloatRescale = willScale &&
+        Object.values(options.preScale.scalingParameters).some((v) => typeof v === 'number' && !Number.isInteger(v));
+    const disableScale = !options.preScale.enabled || (!canRenderFloat && hasFloatRescale);
+    if (type && !invalidType) {
+        pixelDataArray = _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelDataArray);
+    }
+    else if (options.preScale.enabled && !disableScale) {
+        pixelDataArray = _handlePreScaleSetup(options, minBeforeScale, maxBeforeScale, imageFrame);
+    }
+    else {
+        pixelDataArray = _getDefaultPixelDataArray(minBeforeScale, maxBeforeScale, imageFrame);
+    }
+    let minAfterScale = minBeforeScale;
+    let maxAfterScale = maxBeforeScale;
+    if (options.preScale.enabled && !disableScale) {
+        const scalingParameters = options.preScale.scalingParameters;
+        _validateScalingParameters(scalingParameters);
+        const { rescaleSlope, rescaleIntercept } = scalingParameters;
+        const isSlopeAndInterceptNumbers = typeof rescaleSlope === 'number' && typeof rescaleIntercept === 'number';
+        if (isSlopeAndInterceptNumbers) {
+            applyModalityLUT(pixelDataArray, scalingParameters);
+            imageFrame.preScale = {
+                ...options.preScale,
+                scaled: true,
+            };
+            const { rescaleIntercept, rescaleSlope, suvbw } = scalingParameters;
+            minAfterScale = rescaleSlope * minBeforeScale + rescaleIntercept;
+            maxAfterScale = rescaleSlope * maxBeforeScale + rescaleIntercept;
+            if (suvbw) {
+                minAfterScale = minAfterScale * suvbw;
+                maxAfterScale = maxAfterScale * suvbw;
+            }
+        }
+    }
+    else if (disableScale) {
+        imageFrame.preScale = {
+            enabled: true,
+            scaled: false,
+        };
+        minAfterScale = minBeforeScale;
+        maxAfterScale = maxBeforeScale;
+    }
+    imageFrame.pixelData = pixelDataArray;
+    imageFrame.smallestPixelValue = minAfterScale;
+    imageFrame.largestPixelValue = maxAfterScale;
+    const end = new Date().getTime();
+    imageFrame.decodeTimeInMS = end - start;
+    return imageFrame;
+}
+function _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelDataArray) {
+    const { arrayBuffer, type, offset: rawOffset = 0, length: rawLength, rows, } = options.targetBuffer;
+    const TypedArrayConstructor = typedArrayConstructors[type];
+    if (!TypedArrayConstructor) {
+        throw new Error(`target array ${type} is not supported, or doesn't exist.`);
+    }
+    if (rows && rows != imageFrame.rows) {
+        scaleImageFrame(imageFrame, options.targetBuffer, TypedArrayConstructor);
+    }
+    const imageFrameLength = imageFrame.pixelDataLength;
+    const offset = rawOffset;
+    const length = rawLength !== null && rawLength !== undefined
+        ? rawLength
+        : imageFrameLength - offset;
+    const imageFramePixelData = imageFrame.pixelData;
+    if (length !== imageFramePixelData.length) {
+        throw new Error(`target array for image does not have the same length (${length}) as the decoded image length (${imageFramePixelData.length}).`);
+    }
+    const typedArray = arrayBuffer
+        ? new TypedArrayConstructor(arrayBuffer, offset, length)
+        : new TypedArrayConstructor(length);
+    typedArray.set(imageFramePixelData, 0);
+    pixelDataArray = typedArray;
+    return pixelDataArray;
+}
+function _handlePreScaleSetup(options, minBeforeScale, maxBeforeScale, imageFrame) {
+    const scalingParameters = options.preScale.scalingParameters;
+    _validateScalingParameters(scalingParameters);
+    const { rescaleSlope, rescaleIntercept } = scalingParameters;
+    const areSlopeAndInterceptNumbers = typeof rescaleSlope === 'number' && typeof rescaleIntercept === 'number';
+    let scaledMin = minBeforeScale;
+    let scaledMax = maxBeforeScale;
+    if (areSlopeAndInterceptNumbers) {
+        scaledMin = rescaleSlope * minBeforeScale + rescaleIntercept;
+        scaledMax = rescaleSlope * maxBeforeScale + rescaleIntercept;
+    }
+    return _getDefaultPixelDataArray(scaledMin, scaledMax, imageFrame);
+}
+function _getDefaultPixelDataArray(min, max, imageFrame) {
+    const TypedArrayConstructor = getPixelDataTypeFromMinMax(min, max);
+    const typedArray = new TypedArrayConstructor(imageFrame.pixelData.length);
+    typedArray.set(imageFrame.pixelData, 0);
+    return typedArray;
+}
+function _validateScalingParameters(scalingParameters) {
+    if (!scalingParameters) {
+        throw new Error('options.preScale.scalingParameters must be defined if preScale.enabled is true, and scalingParameters cannot be derived from the metadata providers.');
+    }
+}
+function createDestinationImage(imageFrame, targetBuffer, TypedArrayConstructor) {
+    const { samplesPerPixel } = imageFrame;
+    const { rows, columns } = targetBuffer;
+    const typedLength = rows * columns * samplesPerPixel;
+    const pixelData = new TypedArrayConstructor(typedLength);
+    const bytesPerPixel = pixelData.byteLength / typedLength;
+    return {
+        pixelData,
+        rows,
+        columns,
+        frameInfo: {
+            ...imageFrame.frameInfo,
+            rows,
+            columns,
+        },
+        imageInfo: {
+            ...imageFrame.imageInfo,
+            rows,
+            columns,
+            bytesPerPixel,
+        },
+    };
+}
+function scaleImageFrame(imageFrame, targetBuffer, TypedArrayConstructor) {
+    const dest = createDestinationImage(imageFrame, targetBuffer, TypedArrayConstructor);
+    const { scalingType = 'replicate' } = targetBuffer;
+    imageUtils[scalingType](imageFrame, dest);
+    Object.assign(imageFrame, dest);
+    return imageFrame;
+}
+const obj = {
+    decodeTask({ imageFrame, transferSyntax, decodeConfig, options, pixelData, callbackFn, }) {
+        return decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn);
+    },
+};
+expose(obj);

package/dist/esm/src/externalModules.d.ts

@@ -0,0 +1,5 @@
+declare const external: {
+    cornerstone: any;
+    dicomParser: any;
+};
+export default external;

package/dist/esm/src/externalModules.js

@@ -0,0 +1,44 @@
+import { getOptions } from './imageLoader/internal';
+import registerLoaders from './imageLoader/registerLoaders';
+let cornerstone;
+let dicomParser;
+const workerFn = () => {
+    const instance = new Worker(new URL('./decodeImageFrameWorker.js', import.meta.url), { type: 'module' });
+    return instance;
+};
+const external = {
+    set cornerstone(cs) {
+        cornerstone = cs;
+        registerLoaders(cornerstone);
+        const options = getOptions();
+        const workerManager = external.cornerstone.getWebWorkerManager();
+        workerManager.registerWorker('dicomImageLoader', workerFn, {
+            maxWorkerInstances: options.maxWebWorkers || 1,
+        });
+    },
+    get cornerstone() {
+        if (!cornerstone) {
+            cornerstone = window && window.cornerstone;
+            if (!cornerstone) {
+                throw new Error('cornerstoneDICOMImageLoader requires a copy of Cornerstone to work properly. Please add cornerstoneDICOMImageLoader.external.cornerstone = cornerstone; to your application.');
+            }
+            registerLoaders(cornerstone);
+        }
+        return cornerstone;
+    },
+    set dicomParser(dp) {
+        dicomParser = dp;
+    },
+    get dicomParser() {
+        if (!dicomParser) {
+            if (window && window.dicomParser) {
+                dicomParser = window.dicomParser;
+            }
+            else {
+                throw new Error('cornerstoneDICOMImageLoader requires a copy of dicomParser to work properly. Please add cornerstoneDICOMImageLoader.external.dicomParser = dicomParser; to your application.');
+            }
+        }
+        return dicomParser;
+    },
+};
+export default external;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertPALETTECOLOR.d.ts

@@ -0,0 +1,3 @@
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+export default function (imageFrame: Types.IImageFrame, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertPALETTECOLOR.js

@@ -0,0 +1,77 @@
+import external from '../../externalModules';
+function convertLUTto8Bit(lut, shift) {
+    const numEntries = lut.length;
+    const cleanedLUT = new Uint8ClampedArray(numEntries);
+    for (let i = 0; i < numEntries; ++i) {
+        cleanedLUT[i] = lut[i] >> shift;
+    }
+    return cleanedLUT;
+}
+function fetchPaletteData(imageFrame, color, fallback) {
+    const data = imageFrame[`${color}PaletteColorLookupTableData`];
+    if (data) {
+        return Promise.resolve(data);
+    }
+    const result = external.cornerstone.metaData.get('imagePixelModule', imageFrame.imageId);
+    if (result && typeof result.then === 'function') {
+        return result.then((module) => module ? module[`${color}PaletteColorLookupTableData`] : fallback);
+    }
+    else {
+        return Promise.resolve(result ? result[`${color}PaletteColorLookupTableData`] : fallback);
+    }
+}
+export default function (imageFrame, colorBuffer, useRGBA) {
+    const numPixels = imageFrame.columns * imageFrame.rows;
+    const pixelData = imageFrame.pixelData;
+    Promise.all([
+        fetchPaletteData(imageFrame, 'red', null),
+        fetchPaletteData(imageFrame, 'green', null),
+        fetchPaletteData(imageFrame, 'blue', null),
+    ]).then(([rData, gData, bData]) => {
+        if (!rData || !gData || !bData) {
+            throw new Error('The image does not have a complete color palette. R, G, and B palette data are required.');
+        }
+        const len = rData.length;
+        let palIndex = 0;
+        let bufferIndex = 0;
+        const start = imageFrame.redPaletteColorLookupTableDescriptor[1];
+        const shift = imageFrame.redPaletteColorLookupTableDescriptor[2] === 8 ? 0 : 8;
+        const rDataCleaned = convertLUTto8Bit(rData, shift);
+        const gDataCleaned = convertLUTto8Bit(gData, shift);
+        const bDataCleaned = convertLUTto8Bit(bData, shift);
+        if (useRGBA) {
+            for (let i = 0; i < numPixels; ++i) {
+                let value = pixelData[palIndex++];
+                if (value < start) {
+                    value = 0;
+                }
+                else if (value > start + len - 1) {
+                    value = len - 1;
+                }
+                else {
+                    value -= start;
+                }
+                colorBuffer[bufferIndex++] = rDataCleaned[value];
+                colorBuffer[bufferIndex++] = gDataCleaned[value];
+                colorBuffer[bufferIndex++] = bDataCleaned[value];
+                colorBuffer[bufferIndex++] = 255;
+            }
+            return;
+        }
+        for (let i = 0; i < numPixels; ++i) {
+            let value = pixelData[palIndex++];
+            if (value < start) {
+                value = 0;
+            }
+            else if (value > start + len - 1) {
+                value = len - 1;
+            }
+            else {
+                value -= start;
+            }
+            colorBuffer[bufferIndex++] = rDataCleaned[value];
+            colorBuffer[bufferIndex++] = gDataCleaned[value];
+            colorBuffer[bufferIndex++] = bDataCleaned[value];
+        }
+    });
+}

package/dist/esm/src/imageLoader/colorSpaceConverters/convertRGBColorByPixel.d.ts

@@ -0,0 +1,2 @@
+import type { ByteArray } from 'dicom-parser';
+export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertRGBColorByPixel.js

@@ -0,0 +1,21 @@
+export default function (imageFrame, colorBuffer, useRGBA) {
+    if (imageFrame === undefined) {
+        throw new Error('decodeRGB: rgbBuffer must be defined');
+    }
+    if (imageFrame.length % 3 !== 0) {
+        throw new Error(`decodeRGB: rgbBuffer length ${imageFrame.length} must be divisible by 3`);
+    }
+    const numPixels = imageFrame.length / 3;
+    let rgbIndex = 0;
+    let bufferIndex = 0;
+    if (useRGBA) {
+        for (let i = 0; i < numPixels; i++) {
+            colorBuffer[bufferIndex++] = imageFrame[rgbIndex++];
+            colorBuffer[bufferIndex++] = imageFrame[rgbIndex++];
+            colorBuffer[bufferIndex++] = imageFrame[rgbIndex++];
+            colorBuffer[bufferIndex++] = 255;
+        }
+        return;
+    }
+    colorBuffer.set(imageFrame);
+}

package/dist/esm/src/imageLoader/colorSpaceConverters/convertRGBColorByPlane.d.ts

@@ -0,0 +1,2 @@
+import type { ByteArray } from 'dicom-parser';
+export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertRGBColorByPlane.js

@@ -0,0 +1,28 @@
+export default function (imageFrame, colorBuffer, useRGBA) {
+    if (imageFrame === undefined) {
+        throw new Error('decodeRGB: rgbBuffer must be defined');
+    }
+    if (imageFrame.length % 3 !== 0) {
+        throw new Error(`decodeRGB: rgbBuffer length ${imageFrame.length} must be divisible by 3`);
+    }
+    const numPixels = imageFrame.length / 3;
+    let bufferIndex = 0;
+    let rIndex = 0;
+    let gIndex = numPixels;
+    let bIndex = numPixels * 2;
+    if (useRGBA) {
+        for (let i = 0; i < numPixels; i++) {
+            colorBuffer[bufferIndex++] = imageFrame[rIndex++];
+            colorBuffer[bufferIndex++] = imageFrame[gIndex++];
+            colorBuffer[bufferIndex++] = imageFrame[bIndex++];
+            colorBuffer[bufferIndex++] = 255;
+        }
+    }
+    else {
+        for (let i = 0; i < numPixels; i++) {
+            colorBuffer[bufferIndex++] = imageFrame[rIndex++];
+            colorBuffer[bufferIndex++] = imageFrame[gIndex++];
+            colorBuffer[bufferIndex++] = imageFrame[bIndex++];
+        }
+    }
+}

package/dist/esm/src/imageLoader/colorSpaceConverters/convertYBRFull422ByPixel.d.ts

@@ -0,0 +1,2 @@
+import type { ByteArray } from 'dicom-parser';
+export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertYBRFull422ByPixel.js

@@ -0,0 +1,44 @@
+export default function (imageFrame, colorBuffer, useRGBA) {
+    if (imageFrame === undefined) {
+        throw new Error('convertYBRFull422ByPixel: ybrBuffer must be defined');
+    }
+    if (imageFrame.length % 2 !== 0) {
+        throw new Error(`convertYBRFull422ByPixel: ybrBuffer length ${imageFrame.length} must be divisible by 2`);
+    }
+    const numPixels = imageFrame.length / 2;
+    let ybrIndex = 0;
+    let bufferIndex = 0;
+    if (useRGBA) {
+        for (let i = 0; i < numPixels; i += 2) {
+            const y1 = imageFrame[ybrIndex++];
+            const y2 = imageFrame[ybrIndex++];
+            const cb = imageFrame[ybrIndex++];
+            const cr = imageFrame[ybrIndex++];
+            colorBuffer[bufferIndex++] = y1 + 1.402 * (cr - 128);
+            colorBuffer[bufferIndex++] =
+                y1 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128);
+            colorBuffer[bufferIndex++] = y1 + 1.772 * (cb - 128);
+            colorBuffer[bufferIndex++] = 255;
+            colorBuffer[bufferIndex++] = y2 + 1.402 * (cr - 128);
+            colorBuffer[bufferIndex++] =
+                y2 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128);
+            colorBuffer[bufferIndex++] = y2 + 1.772 * (cb - 128);
+            colorBuffer[bufferIndex++] = 255;
+        }
+        return;
+    }
+    for (let i = 0; i < numPixels; i += 2) {
+        const y1 = imageFrame[ybrIndex++];
+        const y2 = imageFrame[ybrIndex++];
+        const cb = imageFrame[ybrIndex++];
+        const cr = imageFrame[ybrIndex++];
+        colorBuffer[bufferIndex++] = y1 + 1.402 * (cr - 128);
+        colorBuffer[bufferIndex++] =
+            y1 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128);
+        colorBuffer[bufferIndex++] = y1 + 1.772 * (cb - 128);
+        colorBuffer[bufferIndex++] = y2 + 1.402 * (cr - 128);
+        colorBuffer[bufferIndex++] =
+            y2 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128);
+        colorBuffer[bufferIndex++] = y2 + 1.772 * (cb - 128);
+    }
+}

package/dist/esm/src/imageLoader/colorSpaceConverters/convertYBRFullByPixel.d.ts

@@ -0,0 +1,2 @@
+import type { ByteArray } from 'dicom-parser';
+export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertYBRFullByPixel.js

@@ -0,0 +1,33 @@
+export default function (imageFrame, colorBuffer, useRGBA) {
+    if (imageFrame === undefined) {
+        throw new Error('convertYBRFullByPixel: ybrBuffer must be defined');
+    }
+    if (imageFrame.length % 3 !== 0) {
+        throw new Error(`convertYBRFullByPixel: ybrBuffer length ${imageFrame.length} must be divisible by 3`);
+    }
+    const numPixels = imageFrame.length / 3;
+    let ybrIndex = 0;
+    let bufferIndex = 0;
+    if (useRGBA) {
+        for (let i = 0; i < numPixels; i++) {
+            const y = imageFrame[ybrIndex++];
+            const cb = imageFrame[ybrIndex++];
+            const cr = imageFrame[ybrIndex++];
+            colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128);
+            colorBuffer[bufferIndex++] =
+                y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128);
+            colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128);
+            colorBuffer[bufferIndex++] = 255;
+        }
+        return;
+    }
+    for (let i = 0; i < numPixels; i++) {
+        const y = imageFrame[ybrIndex++];
+        const cb = imageFrame[ybrIndex++];
+        const cr = imageFrame[ybrIndex++];
+        colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128);
+        colorBuffer[bufferIndex++] =
+            y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128);
+        colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128);
+    }
+}

package/dist/esm/src/imageLoader/colorSpaceConverters/convertYBRFullByPlane.d.ts

@@ -0,0 +1,2 @@
+import type { ByteArray } from 'dicom-parser';
+export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;