@cornerstonejs/dicom-image-loader 5.0.0-beta.1 → 5.0.0

package/dist/esm/decodeImageFrameWorker.js

@@ -81,10 +81,6 @@ export function postProcessDecodedPixels(imageFrame, options, start, decodeConfi
         }
     }
     else if (disableScale) {
-        imageFrame.preScale = {
-            enabled: true,
-            scaled: false,
-        };
         minAfterScale = minBeforeScale;
         maxAfterScale = maxBeforeScale;
     }

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

@@ -21,7 +21,7 @@ export default function convertPaletteColor(imageFrame, colorBuffer, useRGBA) {
     let bufferIndex = 0;
     const start = imageFrame.redPaletteColorLookupTableDescriptor[1];
     const bitsStored = imageFrame.redPaletteColorLookupTableDescriptor[2];
-    const shift = bitsStored > 8 || rData.some((num) => num > 255) ? 8 : 0;
+    const shift = bitsStored > 8 && rData.some((num) => num > 255) ? 8 : 0;
     const rDataCleaned = convertLUTto8Bit(rData, shift);
     const gDataCleaned = convertLUTto8Bit(gData, shift);
     const bDataCleaned = convertLUTto8Bit(bData, shift);

package/dist/esm/imageLoader/createImage.js

@@ -28,6 +28,13 @@ async function createImage(imageId, pixelData, transferSyntax, options = {}) {
     imageFrame.decodeLevel = options.decodeLevel;
     options.allowFloatRendering = canRenderFloatTextures();
     let redData, greenData, blueData;
+    const paletteDescriptors = imageFrame.photometricInterpretation === 'PALETTE COLOR'
+        ? {
+            red: imageFrame.redPaletteColorLookupTableDescriptor,
+            green: imageFrame.greenPaletteColorLookupTableDescriptor,
+            blue: imageFrame.bluePaletteColorLookupTableDescriptor,
+        }
+        : null;
     if (imageFrame.photometricInterpretation === 'PALETTE COLOR') {
         [redData, greenData, blueData] = await Promise.all([
             fetchPaletteData(imageFrame, 'red', null),
@@ -43,6 +50,9 @@ async function createImage(imageId, pixelData, transferSyntax, options = {}) {
                 scalingParameters: scalingParameters,
             };
         }
+        else {
+            options.preScale.enabled = false;
+        }
     }
     const { decodeConfig } = getOptions();
     Object.keys(imageFrame).forEach((key) => {
@@ -94,7 +104,42 @@ async function createImage(imageId, pixelData, transferSyntax, options = {}) {
             const sopCommonModule = metaData.get(MetadataModules.SOP_COMMON, imageId) || {};
             const calibrationModule = metaData.get(MetadataModules.CALIBRATION, imageId) || {};
             const { rows, columns } = imageFrame;
-            if (imageFrame.photometricInterpretation === 'PALETTE COLOR') {
+            if (imageFrame.photometricInterpretation === 'PALETTE COLOR' &&
+                paletteDescriptors) {
+                const normalizeLutIfBytes = (data, descriptor) => {
+                    if (data == null || !descriptor || descriptor.length < 3)
+                        return data;
+                    const tableLen = descriptor[0];
+                    const bits = descriptor[2];
+                    if (bits !== 16 || tableLen <= 0)
+                        return data;
+                    const expectedBytes = tableLen * 2;
+                    let view = null;
+                    if (Array.isArray(data) && data.length > 0) {
+                        const first = data[0];
+                        if (first instanceof ArrayBuffer) {
+                            view = new Uint8Array(first);
+                        }
+                        else if (ArrayBuffer.isView(first)) {
+                            view = first;
+                        }
+                    }
+                    else if (data instanceof ArrayBuffer) {
+                        view = new Uint8Array(data);
+                    }
+                    else if (ArrayBuffer.isView(data)) {
+                        view = data;
+                    }
+                    if (view && view.byteLength === expectedBytes) {
+                        return new Uint16Array(view.buffer, view.byteOffset, tableLen);
+                    }
+                    return data;
+                };
+                imageFrame.redPaletteColorLookupTableData = normalizeLutIfBytes(redData, paletteDescriptors.red);
+                imageFrame.greenPaletteColorLookupTableData = normalizeLutIfBytes(greenData, paletteDescriptors.green);
+                imageFrame.bluePaletteColorLookupTableData = normalizeLutIfBytes(blueData, paletteDescriptors.blue);
+            }
+            else if (imageFrame.photometricInterpretation === 'PALETTE COLOR') {
                 imageFrame.redPaletteColorLookupTableData = redData;
                 imageFrame.greenPaletteColorLookupTableData = greenData;
                 imageFrame.bluePaletteColorLookupTableData = blueData;
@@ -111,6 +156,55 @@ async function createImage(imageId, pixelData, transferSyntax, options = {}) {
                             data: new Uint8ClampedArray(3 * imageFrame.columns * imageFrame.rows),
                         };
                     }
+                    if (imageFrame.photometricInterpretation === 'PALETTE COLOR') {
+                        const pd = imageFrame.pixelData;
+                        const len = pd?.length ?? 0;
+                        const sliceSize = Math.min(40, len);
+                        const r = imageFrame.redPaletteColorLookupTableData;
+                        const g = imageFrame.greenPaletteColorLookupTableData;
+                        const b = imageFrame.bluePaletteColorLookupTableData;
+                        const desc = imageFrame.redPaletteColorLookupTableDescriptor;
+                        const lutLen = (x) => x != null &&
+                            typeof x.length === 'number'
+                            ? x.length
+                            : null;
+                        const lutByteLen = (x) => {
+                            if (x == null)
+                                return null;
+                            if (x instanceof ArrayBuffer)
+                                return x.byteLength;
+                            if (ArrayBuffer.isView(x))
+                                return x.byteLength;
+                            return null;
+                        };
+                        const first10 = (x) => x != null &&
+                            typeof x.length === 'number'
+                            ? Array.from(x).slice(0, 10)
+                            : null;
+                        console.log('[createImage] PALETTE COLOR before convertColorSpace', {
+                            imageId,
+                            descriptor: desc,
+                            pixelDataLength: len,
+                            pixelDataSlice: sliceSize > 0 && pd
+                                ? Array.from({ length: sliceSize }, (_, i) => pd[i])
+                                : [],
+                            redLUT: {
+                                length: lutLen(r),
+                                byteLength: lutByteLen(r),
+                                first10: first10(r),
+                            },
+                            greenLUT: {
+                                length: lutLen(g),
+                                byteLength: lutByteLen(g),
+                                first10: first10(g),
+                            },
+                            blueLUT: {
+                                length: lutLen(b),
+                                byteLength: lutByteLen(b),
+                                first10: first10(b),
+                            },
+                        });
+                    }
                     convertColorSpace(imageFrame, imageData.data, useRGBA);
                     imageFrame.imageData = imageData;
                     imageFrame.pixelData = imageData.data;
@@ -165,9 +259,10 @@ async function createImage(imageId, pixelData, transferSyntax, options = {}) {
                 windowWidth: voiLutModule.windowWidth
                     ? voiLutModule.windowWidth[0]
                     : undefined,
-                voiLUTFunction: voiLutModule.voiLUTFunction
-                    ? voiLutModule.voiLUTFunction
-                    : undefined,
+                voiLUTFunction: (voiLutModule.voiLUTFunction?.length &&
+                    voiLutModule.voiLUTFunction[0]) ||
+                    voiLutModule.voiLutFunction ||
+                    undefined,
                 decodeTimeInMS: imageFrame.decodeTimeInMS,
                 floatPixelData: undefined,
                 imageFrame,

package/dist/esm/imageLoader/getInstanceModule.js

@@ -25,8 +25,6 @@ const instanceModuleNames = [
     'multiframeModule',
     'generalSeriesModule',
     'patientStudyModule',
-    'imagePlaneModule',
-    'nmMultiframeGeometryModule',
     'imagePixelModule',
     'modalityLutModule',
     'voiLutModule',

package/dist/esm/imageLoader/getScalingParameters.js

@@ -3,9 +3,15 @@ export default function getScalingParameters(metaData, imageId) {
     const generalSeriesModule = (metaData.get('generalSeriesModule', imageId) ||
         {});
     const { modality } = generalSeriesModule;
+    const rescaleSlope = modalityLutModule.rescaleSlope;
+    const rescaleIntercept = modalityLutModule.rescaleIntercept;
+    if (rescaleSlope === 1 &&
+        (rescaleIntercept === 0 || rescaleIntercept == null)) {
+        return undefined;
+    }
     const scalingParameters = {
-        rescaleSlope: modalityLutModule.rescaleSlope,
-        rescaleIntercept: modalityLutModule.rescaleIntercept,
+        rescaleSlope,
+        rescaleIntercept,
         modality,
     };
     const scalingModules = metaData.get('scalingModule', imageId) || {};

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

@@ -53,7 +53,8 @@ declare const cornerstoneDICOMImageLoader: {
         loadImageFromPromise: typeof import("./wadouri/loadImage").loadImageFromPromise;
         getLoaderForScheme: typeof import("./wadouri/loadImage").getLoaderForScheme;
         getPixelData: typeof import("./wadouri/getPixelData").default;
-        loadImage: typeof import("./wadouri/loadImage").loadImage;
+        loadImage: (imageId: string, options?: import("../types").DICOMLoaderImageOptions) => import("packages/core/dist/esm/types").IImageLoadObject;
+        loadImageFromNaturalizedMetadata: typeof import("./wadouri/loadImage").loadImageFromNaturalizedMetadata;
         parseImageId: typeof import("./wadouri/parseImageId").default;
         unpackBinaryFrame: typeof import("./wadouri/unpackBinaryFrame").default;
         register: typeof import("./wadouri/register").default;

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

@@ -1,2 +1,4 @@
-declare function registerLoaders(): void;
+declare function registerLoaders(options?: {
+    useLegacyMetadataProvider?: boolean;
+}): void;
 export default registerLoaders;

package/dist/esm/imageLoader/registerLoaders.js

@@ -1,7 +1,15 @@
+import { cache } from '@cornerstonejs/core';
+import { utilities } from '@cornerstonejs/metadata';
+import dataSetCacheManager from './wadouri/dataSetCacheManager';
+import wadorsMetaDataManager from './wadors/metaDataManager';
 import wadouriRegister from './wadouri/register';
 import wadorsRegister from './wadors/register';
-function registerLoaders() {
-    wadorsRegister();
-    wadouriRegister();
+function registerLoaders(options) {
+    cache.purgeCache();
+    dataSetCacheManager.purge();
+    wadorsMetaDataManager.purge();
+    utilities.clearCacheData();
+    wadorsRegister(options);
+    wadouriRegister(options);
 }
 export default registerLoaders;

package/dist/esm/imageLoader/wadors/metaData/metaDataProvider.js

@@ -10,7 +10,6 @@ import { getImageTypeSubItemFromMetadata } from './NMHelpers';
 import isNMReconstructable from '../../isNMReconstructable';
 import { instanceModuleNames } from '../../getInstanceModule';
 import { getUSEnhancedRegions } from './USHelpers';
-import { getECGModule } from './ECGHelpers';
 function metaDataProvider(type, imageId) {
     const { MetadataModules } = Enums;
     if (type === MetadataModules.MULTIFRAME) {
@@ -154,20 +153,6 @@ function metaDataProvider(type, imageId) {
     if (type === MetadataModules.ULTRASOUND_ENHANCED_REGION) {
         return getUSEnhancedRegions(metaData);
     }
-    if (type === MetadataModules.ECG) {
-        const imageUri = imageId.replace('wadors:', '');
-        const studiesIndex = imageUri.indexOf('/studies/');
-        let wadoRsRoot;
-        let studyUID;
-        if (studiesIndex !== -1) {
-            wadoRsRoot = imageUri.substring(0, studiesIndex);
-            const afterStudies = imageUri.substring(studiesIndex + 9);
-            const nextSlash = afterStudies.indexOf('/');
-            studyUID =
-                nextSlash !== -1 ? afterStudies.substring(0, nextSlash) : afterStudies;
-        }
-        return getECGModule(metaData, wadoRsRoot, studyUID);
-    }
     if (type === MetadataModules.CALIBRATION) {
         const modality = getValue(metaData['00080060']);
         if (modality === 'US') {
@@ -176,42 +161,6 @@ function metaDataProvider(type, imageId) {
                 sequenceOfUltrasoundRegions: enhancedRegion,
             };
         }
-        const imageUri = imageId.replace('wadors:', '');
-        const studiesIndex = imageUri.indexOf('/studies/');
-        let wadoRsRoot;
-        let studyUID;
-        if (studiesIndex !== -1) {
-            wadoRsRoot = imageUri.substring(0, studiesIndex);
-            const afterStudies = imageUri.substring(studiesIndex + 9);
-            const nextSlash = afterStudies.indexOf('/');
-            studyUID =
-                nextSlash !== -1 ? afterStudies.substring(0, nextSlash) : afterStudies;
-        }
-        const ecgModule = getECGModule(metaData, wadoRsRoot, studyUID);
-        if (ecgModule) {
-            const { numberOfWaveformSamples, samplingFrequency } = ecgModule;
-            const physicalDeltaX = 1 / (samplingFrequency || 1);
-            const physicalDeltaY = 0.001;
-            const ECG_AMPLITUDE_INDEX_SIZE = 65536;
-            const ECG_AMPLITUDE_OFFSET = 32768;
-            return {
-                sequenceOfUltrasoundRegions: [
-                    {
-                        regionLocationMinX0: 0,
-                        regionLocationMaxX1: numberOfWaveformSamples,
-                        regionLocationMinY0: 0,
-                        regionLocationMaxY1: ECG_AMPLITUDE_INDEX_SIZE - 1,
-                        referencePixelX0: 0,
-                        referencePixelY0: ECG_AMPLITUDE_OFFSET,
-                        physicalDeltaX,
-                        physicalDeltaY,
-                        physicalUnitsXDirection: 4,
-                        physicalUnitsYDirection: -1,
-                        regionDataType: 1,
-                    },
-                ],
-            };
-        }
     }
     if (type === MetadataModules.IMAGE_URL) {
         return getImageUrlModule(imageId, metaData);

package/dist/esm/imageLoader/wadors/register.d.ts

@@ -1 +1,3 @@
-export default function (): void;
+export default function (options?: {
+    useLegacyMetadataProvider?: boolean;
+}): void;

package/dist/esm/imageLoader/wadors/register.js

@@ -1,7 +1,14 @@
 import { metaData, registerImageLoader } from '@cornerstonejs/core';
 import loadImage from './loadImage';
 import { metaDataProvider } from './metaData';
-export default function () {
+import { registerDefaultProviders } from '@cornerstonejs/metadata';
+export default function (options) {
     registerImageLoader('wadors', loadImage);
+    if (options?.useLegacyMetadataProvider) {
+        console.warn('wadors metaDataProvider is deprecated. Use addDicomWebInstance from @cornerstonejs/metadata instead.');
+        metaData.addProvider(metaDataProvider);
+        return;
+    }
+    registerDefaultProviders();
     metaData.addProvider(metaDataProvider);
 }

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

@@ -1,5 +1,5 @@
-import * as dicomParser from 'dicom-parser';
 import { xhrRequest } from '../internal/index';
+import { parseDicom } from './parseDicomWithInflater';
 import dataSetFromPartialContent from './dataset-from-partial-content';
 import { combineFrameInstanceDataset } from './combineFrameInstanceDataset';
 import multiframeDataset from './retrieveMultiframeDataset';
@@ -76,7 +76,7 @@ function load(uri, loadRequest = xhrRequest, imageId) {
                     });
                 }
                 else {
-                    dataSet = dicomParser.parseDicom(byteArray);
+                    dataSet = parseDicom(byteArray);
                 }
             }
             catch (error) {

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

@@ -1,4 +1,4 @@
-import * as dicomParser from 'dicom-parser';
+import { parseDicom } from './parseDicomWithInflater';
 function fixFragments(dataSet) {
     const fragments = dataSet.elements.x7fe00010.fragments;
     const totalLength = dataSet.byteArray.length;
@@ -12,7 +12,7 @@ function fixFragments(dataSet) {
     return dataSet;
 }
 function parsePartialByteArray(byteArray) {
-    let dataSet = dicomParser.parseDicom(byteArray, {
+    let dataSet = parseDicom(byteArray, {
         untilTag: 'x7fe00010',
     });
     if (!dataSet.elements.x7fe00010) {
@@ -20,7 +20,7 @@ function parsePartialByteArray(byteArray) {
     }
     let pixelDataSet;
     try {
-        pixelDataSet = dicomParser.parseDicom(byteArray);
+        pixelDataSet = parseDicom(byteArray);
     }
     catch (err) {
         console.error(err);

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

@@ -5,7 +5,7 @@ import getEncapsulatedImageFrame from './getEncapsulatedImageFrame';
 import getUncompressedImageFrame from './getUncompressedImageFrame';
 import loadFileRequest from './loadFileRequest';
 import getPixelData from './getPixelData';
-import { loadImageFromPromise, getLoaderForScheme, loadImage } from './loadImage';
+import { loadImageFromPromise, getLoaderForScheme, loadImage, loadImageFromNaturalizedMetadata } from './loadImage';
 import parseImageId from './parseImageId';
 import unpackBinaryFrame from './unpackBinaryFrame';
 import register from './register';
@@ -47,10 +47,11 @@ declare const _default: {
     loadImageFromPromise: typeof loadImageFromPromise;
     getLoaderForScheme: typeof getLoaderForScheme;
     getPixelData: typeof getPixelData;
-    loadImage: typeof loadImage;
+    loadImage: (imageId: string, options?: import("../../types").DICOMLoaderImageOptions) => import("packages/core/dist/esm/types").IImageLoadObject;
+    loadImageFromNaturalizedMetadata: typeof loadImageFromNaturalizedMetadata;
     parseImageId: typeof parseImageId;
     unpackBinaryFrame: typeof unpackBinaryFrame;
     register: typeof register;
 };
 export default _default;
-export { metaData, dataSetCacheManager, fileManager, getEncapsulatedImageFrame, getUncompressedImageFrame, loadFileRequest, loadImageFromPromise, getLoaderForScheme, getPixelData, loadImage, parseImageId, unpackBinaryFrame, register, };
+export { metaData, dataSetCacheManager, fileManager, getEncapsulatedImageFrame, getUncompressedImageFrame, loadFileRequest, loadImageFromPromise, getLoaderForScheme, getPixelData, loadImage, loadImageFromNaturalizedMetadata, parseImageId, unpackBinaryFrame, register, };

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

@@ -5,7 +5,7 @@ import getEncapsulatedImageFrame from './getEncapsulatedImageFrame';
 import getUncompressedImageFrame from './getUncompressedImageFrame';
 import loadFileRequest from './loadFileRequest';
 import getPixelData from './getPixelData';
-import { loadImageFromPromise, getLoaderForScheme, loadImage, } from './loadImage';
+import { loadImageFromPromise, getLoaderForScheme, loadImage, loadImageFromNaturalizedMetadata, } from './loadImage';
 import parseImageId from './parseImageId';
 import unpackBinaryFrame from './unpackBinaryFrame';
 import register from './register';
@@ -28,8 +28,9 @@ export default {
     getLoaderForScheme,
     getPixelData,
     loadImage,
+    loadImageFromNaturalizedMetadata,
     parseImageId,
     unpackBinaryFrame,
     register,
 };
-export { metaData, dataSetCacheManager, fileManager, getEncapsulatedImageFrame, getUncompressedImageFrame, loadFileRequest, loadImageFromPromise, getLoaderForScheme, getPixelData, loadImage, parseImageId, unpackBinaryFrame, register, };
+export { metaData, dataSetCacheManager, fileManager, getEncapsulatedImageFrame, getUncompressedImageFrame, loadFileRequest, loadImageFromPromise, getLoaderForScheme, getPixelData, loadImage, loadImageFromNaturalizedMetadata, parseImageId, unpackBinaryFrame, register, };

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

@@ -4,6 +4,8 @@ import type { LoadRequestFunction, DICOMLoaderIImage, DICOMLoaderImageOptions }
 declare function loadImageFromPromise(dataSetPromise: Promise<DataSet>, imageId: string, frame: number, sharedCacheKey: string, options: DICOMLoaderImageOptions, callbacks?: {
     imageDoneCallback: (image: DICOMLoaderIImage) => void;
 }): Types.IImageLoadObject;
+declare function loadImageFromDataSet(dataSet: any, imageId: string, frame: number, _sharedCacheKey: any, options: any): Types.IImageLoadObject;
 declare function getLoaderForScheme(scheme: string): LoadRequestFunction;
-declare function loadImage(imageId: string, options?: DICOMLoaderImageOptions): Types.IImageLoadObject;
-export { loadImageFromPromise, getLoaderForScheme, loadImage };
+declare function loadImageFromNaturalizedMetadata(imageId: string, options?: DICOMLoaderImageOptions): Types.IImageLoadObject;
+declare const loadImage: (imageId: string, options?: DICOMLoaderImageOptions) => Types.IImageLoadObject;
+export { loadImageFromPromise, getLoaderForScheme, loadImage, loadImageFromNaturalizedMetadata, loadImageFromDataSet, };

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

@@ -1,4 +1,5 @@
-import { Enums } from '@cornerstonejs/core';
+import { Enums, metaData } from '@cornerstonejs/core';
+import { Enums as MetadataEnums, utilities } from '@cornerstonejs/metadata';
 import createImage from '../createImage';
 import { xhrRequest } from '../internal/index';
 import dataSetCacheManager from './dataSetCacheManager';
@@ -6,6 +7,8 @@ import getPixelData from './getPixelData';
 import loadFileRequest from './loadFileRequest';
 import parseImageId from './parseImageId';
 const { ImageQualityStatus } = Enums;
+const { addDicomPart10Instance } = utilities;
+const NATURALIZED = MetadataEnums.MetadataModules.NATURALIZED;
 function addDecache(imageLoadObject, imageId) {
     imageLoadObject.decache = function () {
         const parsedImageId = parseImageId(imageId);
@@ -28,7 +31,6 @@ function loadImageFromPromise(dataSetPromise, imageId, frame = 0, sharedCacheKey
             imagePromise.then((image) => {
                 image = image;
                 image.data = dataSet;
-                image.sharedCacheKey = sharedCacheKey;
                 const end = new Date().getTime();
                 image.loadTimeInMS = loadEnd - start;
                 image.totalTimeInMS = end - start;
@@ -52,7 +54,7 @@ function loadImageFromPromise(dataSetPromise, imageId, frame = 0, sharedCacheKey
     });
     return imageLoadObject;
 }
-function loadImageFromDataSet(dataSet, imageId, frame = 0, sharedCacheKey, options) {
+function loadImageFromDataSet(dataSet, imageId, frame = 0, _sharedCacheKey, options) {
     const start = new Date().getTime();
     const promise = new Promise((resolve, reject) => {
         const loadEnd = new Date().getTime();
@@ -92,16 +94,88 @@ function getLoaderForScheme(scheme) {
         return loadFileRequest;
     }
 }
-function loadImage(imageId, options = {}) {
+const asByteArray = (data) => data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+function concatPixelData(pixelData) {
+    if (!Array.isArray(pixelData)) {
+        return asByteArray(pixelData);
+    }
+    if (pixelData.length === 0) {
+        return undefined;
+    }
+    if (pixelData.length === 1) {
+        return asByteArray(pixelData[0]);
+    }
+    let totalLength = 0;
+    for (const frame of pixelData) {
+        totalLength += asByteArray(frame).length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const frame of pixelData) {
+        const view = asByteArray(frame);
+        result.set(view, offset);
+        offset += view.length;
+    }
+    return result;
+}
+function loadImageFromNaturalizedMetadata(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 frameIndex = parsedImageId.pixelDataFrame !== undefined
+        ? parsedImageId.pixelDataFrame
+        : 0;
+    const promise = (async () => {
+        const start = Date.now();
+        console.log('[dicomImageLoader/wadouri] loadImageFromNaturalizedMetadata: start', {
+            imageId,
+            scheme: parsedImageId.scheme,
+            url: parsedImageId.url,
+            frameIndex,
+        });
+        let natural = metaData.get(NATURALIZED, imageId);
+        if (!natural) {
+            console.log('[dicomImageLoader/wadouri] loadImageFromNaturalizedMetadata: no NATURALIZED metadata, attempting to fetch and populate', { imageId });
+            if (!schemeLoader) {
+                throw new Error(`loadImageFromNaturalizedMetadata: no NATURALIZED cache and unknown scheme ${parsedImageId.scheme}`);
+            }
+            const result = (await schemeLoader(parsedImageId.url, imageId));
+            const arrayBuffer = result instanceof ArrayBuffer ? result : result.arrayBuffer;
+            const baseImageId = `${parsedImageId.scheme}:${parsedImageId.url}`;
+            await addDicomPart10Instance(baseImageId, arrayBuffer);
+            natural = metaData.get(NATURALIZED, imageId);
+        }
+        const loadEnd = Date.now();
+        const frameData = metaData.getTyped(MetadataEnums.MetadataModules.COMPRESSED_FRAME_DATA, imageId, { frameIndex });
+        if (!frameData) {
+            console.warn('[dicomImageLoader/wadouri] loadImageFromNaturalizedMetadata: no COMPRESSED_FRAME_DATA for imageId', { imageId, frameIndex });
+            throw new Error(`loadImageFromNaturalizedMetadata: no pixel data in NATURALIZED for imageId ${imageId}`);
+        }
+        const { pixelData, transferSyntaxUid } = frameData;
+        const concatenatedPixelData = concatPixelData(pixelData);
+        const image = await createImage(imageId, concatenatedPixelData, transferSyntaxUid, options);
+        const end = Date.now();
+        const out = image;
+        out.imageQualityStatus = ImageQualityStatus.FULL_RESOLUTION;
+        out.data = natural;
+        out.loadTimeInMS = loadEnd - start;
+        out.totalTimeInMS = end - start;
+        return out;
+    })();
+    return { promise };
+}
+const loadImage = (imageId, options = {}) => {
+    const parsedImageId = parseImageId(imageId);
+    const schemeLoader = getLoaderForScheme(parsedImageId.scheme);
+    if (!schemeLoader) {
+        throw new Error(`wadouri loadImage: no loader for scheme '${parsedImageId.scheme}'`);
     }
+    const frameIndex = parsedImageId.pixelDataFrame !== undefined
+        ? parsedImageId.pixelDataFrame
+        : 0;
+    const sharedCacheKey = parsedImageId.url;
     const dataSetPromise = dataSetCacheManager.load(parsedImageId.url, schemeLoader, imageId);
-    return loadImageFromPromise(dataSetPromise, imageId, parsedImageId.pixelDataFrame, parsedImageId.url, options);
-}
-export { loadImageFromPromise, getLoaderForScheme, loadImage };
+    return loadImageFromPromise(dataSetPromise, imageId, frameIndex, sharedCacheKey, options);
+};
+export { loadImageFromPromise, getLoaderForScheme, loadImage, loadImageFromNaturalizedMetadata, loadImageFromDataSet, };

package/dist/esm/imageLoader/wadouri/parseDicomWithInflater.d.ts

@@ -0,0 +1,7 @@
+import * as dicomParser from 'dicom-parser';
+declare function inflater(byteArray: Uint8Array, position: number): Uint8Array;
+export declare const parseDicomOptions: {
+    inflater: typeof inflater;
+};
+export declare function parseDicom(byteArray: Uint8Array, options?: dicomParser.ParseDicomOptions): dicomParser.DataSet;
+export {};

package/dist/esm/imageLoader/wadouri/parseDicomWithInflater.js

@@ -0,0 +1,17 @@
+import * as dicomParser from 'dicom-parser';
+import pako from 'pako';
+function inflater(byteArray, position) {
+    const deflated = byteArray.slice(position);
+    const inflated = pako.inflateRaw(deflated);
+    const fullByteArray = new Uint8Array(inflated.length + position);
+    fullByteArray.set(byteArray.slice(0, position), 0);
+    fullByteArray.set(inflated, position);
+    return fullByteArray;
+}
+export const parseDicomOptions = { inflater };
+export function parseDicom(byteArray, options) {
+    return dicomParser.parseDicom(byteArray, {
+        ...parseDicomOptions,
+        ...options,
+    });
+}

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

@@ -1 +1,4 @@
-export default function (): void;
+export default function (options?: {
+    useLegacyMetadataProvider?: boolean;
+}): void;
+export { loadImageFromNaturalizedMetadata as loadImage } from './loadImage';

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

@@ -1,9 +1,19 @@
 import { metaData, registerImageLoader } from '@cornerstonejs/core';
-import { loadImage } from './loadImage';
+import { registerDefaultProviders } from '@cornerstonejs/metadata';
+import { loadImage, loadImageFromNaturalizedMetadata } from './loadImage';
 import { metaDataProvider } from './metaData/index';
-export default function () {
-    registerImageLoader('dicomweb', loadImage);
-    registerImageLoader('wadouri', loadImage);
-    registerImageLoader('dicomfile', loadImage);
-    metaData.addProvider(metaDataProvider);
+export default function (options) {
+    if (options?.useLegacyMetadataProvider === true) {
+        console.warn('wadouri metaDataProvider is deprecated. Use registerMetadataProvider module from @cornerstonejs/metadata instead.');
+        registerImageLoader('dicomweb', loadImage);
+        registerImageLoader('wadouri', loadImage);
+        registerImageLoader('dicomfile', loadImage);
+        metaData.addProvider(metaDataProvider);
+        return;
+    }
+    registerImageLoader('dicomweb', loadImageFromNaturalizedMetadata);
+    registerImageLoader('wadouri', loadImageFromNaturalizedMetadata);
+    registerImageLoader('dicomfile', loadImageFromNaturalizedMetadata);
+    registerDefaultProviders();
 }
+export { loadImageFromNaturalizedMetadata as loadImage } from './loadImage';

package/dist/esm/index.d.ts

@@ -53,7 +53,8 @@ declare const cornerstoneDICOMImageLoader: {
         loadImageFromPromise: typeof import("./imageLoader/wadouri/loadImage").loadImageFromPromise;
         getLoaderForScheme: typeof import("./imageLoader/wadouri/loadImage").getLoaderForScheme;
         getPixelData: typeof import("./imageLoader/wadouri/getPixelData").default;
-        loadImage: typeof import("./imageLoader/wadouri/loadImage").loadImage;
+        loadImage: (imageId: string, options?: Types.DICOMLoaderImageOptions) => import("packages/core/dist/esm/types").IImageLoadObject;
+        loadImageFromNaturalizedMetadata: typeof import("./imageLoader/wadouri/loadImage").loadImageFromNaturalizedMetadata;
         parseImageId: typeof import("./imageLoader/wadouri/parseImageId").default;
         unpackBinaryFrame: typeof import("./imageLoader/wadouri/unpackBinaryFrame").default;
         register: typeof import("./imageLoader/wadouri/register").default;

package/dist/esm/init.js

@@ -7,7 +7,7 @@ const workerFn = () => {
 };
 function init(options = {}) {
     setOptions(options);
-    registerLoaders();
+    registerLoaders(options);
     const workerManager = getWebWorkerManager();
     const maxWorkers = options?.maxWebWorkers || getReasonableWorkerCount();
     workerManager.registerWorker('dicomImageLoader', workerFn, {

package/dist/esm/types/LoaderOptions.d.ts

@@ -13,4 +13,5 @@ export interface LoaderOptions {
     errorInterceptor?: (error: LoaderXhrRequestError) => void;
     strict?: boolean;
     decodeConfig?: LoaderDecodeOptions;
+    useLegacyMetadataProvider?: boolean;
 }

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.0.0-beta.1";
+export declare const version = "5.0.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '5.0.0-beta.1';
+export const version = '5.0.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/dicom-image-loader",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0",
   "description": "Cornerstone Image Loader for DICOM WADO-URI and WADO-RS and Local file",
   "keywords": [
     "DICOM",
@@ -65,15 +65,16 @@
     }
   },
   "scripts": {
-    "build:loader": "yarn run build:all && yarn run copy-dts",
+    "build:loader": "pnpm run build:all && pnpm run copy-dts",
+    "build": "pnpm run build:esm",
     "build:esm": "tsc --project ./tsconfig.json",
     "build:esm:watch": "tsc --project ./tsconfig.json --watch",
     "build:umd:dynamic": "cross-env NODE_ENV=production webpack --config .webpack/webpack-dynamic-import.js",
     "build:umd:bundle": "cross-env NODE_ENV=production webpack --config .webpack/webpack-bundle.js",
-    "build:all": "yarn run build:esm",
+    "build:all": "pnpm run build:esm",
     "copy-dts": "echo 'not implemented yet'",
     "clean": "shx rm -rf dist",
-    "clean:deep": "yarn run clean && shx rm -rf node_modules",
+    "clean:deep": "pnpm run clean && shx rm -rf node_modules",
     "api-check": "api-extractor --debug run ",
     "cm": "npx git-cz",
     "clean:dist": "shx rm -rf dist",
@@ -98,7 +99,7 @@
     "webpack:dynamic-import:watch": "webpack --progress --watch --config .webpack/webpack-dynamic-import",
     "webpack:dynamic-import:debug": "webpack --progress --watch --config .webpack/webpack-dynamic-import-debug",
     "webpack:watch": "webpack --progress --watch  --config .webpack",
-    "prepublishOnly": "yarn run build:loader"
+    "prepublishOnly": "pnpm run build:loader"
   },
   "dependencies": {
     "@cornerstonejs/codec-charls": "1.2.3",
@@ -111,8 +112,13 @@
     "pako": "2.1.0",
     "uuid": "9.0.1"
   },
+  "devDependencies": {
+    "@cornerstonejs/core": "5.0.0",
+    "@cornerstonejs/metadata": "5.0.0"
+  },
   "peerDependencies": {
-    "@cornerstonejs/core": "5.0.0-beta.1",
+    "@cornerstonejs/core": "5.0.0",
+    "@cornerstonejs/metadata": "5.0.0",
     "dicom-parser": "1.8.21"
   },
   "config": {
@@ -120,5 +126,5 @@
       "path": "./node_modules/cz-conventional-changelog"
     }
   },
-  "gitHead": "269b3089ffd45d016454fde74374389d03feebac"
+  "gitHead": "d6f3fba43abcbaaf7468ff534588f6a88720b875"
 }