@cornerstonejs/nifti-volume-loader 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/constants/index.js

@@ -1,3 +1,2 @@
 import NIFTI_LOADER_SCHEME from './niftiLoaderScheme';
 export { NIFTI_LOADER_SCHEME };
-//# sourceMappingURL=index.js.map

package/dist/esm/constants/niftiLoaderScheme.js

@@ -1,3 +1,2 @@
 const niftiLoaderScheme = 'nifti';
 export default niftiLoaderScheme;
-//# sourceMappingURL=niftiLoaderScheme.js.map

package/dist/esm/cornerstoneNiftiImageLoader.d.ts

@@ -1,7 +1,2 @@
-import NiftiImageVolume from './NiftiImageVolume';
-interface IVolumeLoader {
-    promise: Promise<NiftiImageVolume>;
-    cancel: () => void;
-}
-export default function cornerstoneNiftiImageVolumeLoader(volumeId: string): IVolumeLoader;
-export {};
+import type { Types } from '@cornerstonejs/core';
+export default function cornerstoneNiftiImageLoader(imageId: string): Types.IImageLoadObject;

package/dist/esm/cornerstoneNiftiImageLoader.js

@@ -1,10 +1,126 @@
-import { fetchAndAllocateNiftiVolume } from './helpers';
-export default function cornerstoneNiftiImageVolumeLoader(volumeId) {
-    const niftiVolumePromise = fetchAndAllocateNiftiVolume(volumeId);
+import { Enums, eventTarget, metaData, triggerEvent, utilities, } from '@cornerstonejs/core';
+import * as NiftiReader from 'nifti-reader-js';
+import { Events } from './enums';
+import { modalityScaleNifti } from './helpers';
+const fetchStarted = new Map();
+let niftiScalarData = null;
+function fetchArrayBuffer({ url, signal, onload, }) {
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', url, true);
+        xhr.responseType = 'arraybuffer';
+        const onLoadHandler = function (e) {
+            if (onload && typeof onload === 'function') {
+                onload();
+            }
+            if (signal) {
+                signal.removeEventListener('abort', onAbortHandler);
+            }
+            resolve(xhr.response);
+        };
+        const onAbortHandler = () => {
+            xhr.abort();
+            xhr.removeEventListener('load', onLoadHandler);
+            reject(new Error('Request aborted'));
+        };
+        xhr.addEventListener('load', onLoadHandler);
+        const onProgress = (loaded, total) => {
+            const data = { url, loaded, total };
+            triggerEvent(eventTarget, Events.NIFTI_VOLUME_PROGRESS, { data });
+        };
+        xhr.onprogress = function (e) {
+            onProgress(e.loaded, e.total);
+        };
+        if (signal && signal.aborted) {
+            xhr.abort();
+            reject(new Error('Request aborted'));
+        }
+        else if (signal) {
+            signal.addEventListener('abort', onAbortHandler);
+        }
+        xhr.send();
+    });
+}
+export default function cornerstoneNiftiImageLoader(imageId) {
+    const [url, frame] = imageId.substring(6).split('?frame=');
+    const sliceIndex = parseInt(frame, 10);
+    const imagePixelModule = metaData.get(Enums.MetadataModules.IMAGE_PIXEL, imageId);
+    const imagePlaneModule = metaData.get(Enums.MetadataModules.IMAGE_PLANE, imageId);
+    const promise = new Promise((resolve, reject) => {
+        if (!fetchStarted.get(url)) {
+            fetchStarted.set(url, true);
+            fetchAndProcessNiftiData(imageId, url, sliceIndex, imagePixelModule, imagePlaneModule)
+                .then(resolve)
+                .catch(reject);
+        }
+        else {
+            waitForNiftiData(imageId, sliceIndex, imagePixelModule, imagePlaneModule)
+                .then(resolve)
+                .catch(reject);
+        }
+    });
+    return {
+        promise: promise,
+        cancelFn: undefined,
+    };
+}
+async function fetchAndProcessNiftiData(imageId, url, sliceIndex, imagePixelModule, imagePlaneModule) {
+    let niftiBuffer = await fetchArrayBuffer({ url });
+    let niftiHeader = null;
+    let niftiImage = null;
+    if (NiftiReader.isCompressed(niftiBuffer)) {
+        niftiBuffer = NiftiReader.decompress(niftiBuffer);
+    }
+    if (NiftiReader.isNIFTI(niftiBuffer)) {
+        niftiHeader = NiftiReader.readHeader(niftiBuffer);
+        niftiImage = NiftiReader.readImage(niftiHeader, niftiBuffer);
+    }
+    else {
+        const errorMessage = 'The provided buffer is not a valid NIFTI file.';
+        console.warn(errorMessage);
+        throw new Error(errorMessage);
+    }
+    const { scalarData } = modalityScaleNifti(niftiHeader, niftiImage);
+    niftiScalarData = scalarData;
+    return createImage(imageId, sliceIndex, imagePixelModule, imagePlaneModule);
+}
+function waitForNiftiData(imageId, sliceIndex, imagePixelModule, imagePlaneModule) {
+    return new Promise((resolve) => {
+        const intervalId = setInterval(() => {
+            if (niftiScalarData) {
+                clearInterval(intervalId);
+                resolve(createImage(imageId, sliceIndex, imagePixelModule, imagePlaneModule));
+            }
+        }, 10);
+    });
+}
+function createImage(imageId, sliceIndex, imagePixelModule, imagePlaneModule) {
+    const { rows, columns } = imagePlaneModule;
+    const numVoxels = rows * columns;
+    const sliceOffset = numVoxels * sliceIndex;
+    const pixelData = new niftiScalarData.constructor(numVoxels);
+    pixelData.set(niftiScalarData.subarray(sliceOffset, sliceOffset + numVoxels));
+    const voxelManager = utilities.VoxelManager.createImageVoxelManager({
+        width: columns,
+        height: rows,
+        numberOfComponents: 1,
+        scalarData: pixelData,
+    });
     return {
-        promise: niftiVolumePromise,
-        cancel: () => {
-        },
+        imageId,
+        dataType: niftiScalarData.constructor
+            .name,
+        columnPixelSpacing: imagePlaneModule.columnPixelSpacing,
+        columns: imagePlaneModule.columns,
+        height: imagePlaneModule.rows,
+        invert: imagePixelModule.photometricInterpretation === 'MONOCHROME1',
+        rowPixelSpacing: imagePlaneModule.rowPixelSpacing,
+        rows: imagePlaneModule.rows,
+        sizeInBytes: rows * columns * niftiScalarData.BYTES_PER_ELEMENT,
+        width: imagePlaneModule.columns,
+        getPixelData: () => voxelManager.getScalarData(),
+        getCanvas: undefined,
+        numberOfComponents: undefined,
+        voxelManager,
     };
 }
-//# sourceMappingURL=cornerstoneNiftiImageLoader.js.map

package/dist/esm/createNiftiImageIdsAndCacheMetadata.d.ts

@@ -0,0 +1,17 @@
+export declare const urlsMap: Map<any, any>;
+export declare function fetchArrayBuffer({ url, onProgress, controller, onLoad, onHeader, loadFullVolume, }: {
+    url: any;
+    onProgress: any;
+    controller: any;
+    onLoad: any;
+    onHeader: any;
+    loadFullVolume?: boolean;
+}): Promise<{
+    data: Uint8Array;
+    headerInfo: any;
+    sliceInfo: any;
+}>;
+declare function createNiftiImageIdsAndCacheMetadata({ url }: {
+    url: any;
+}): Promise<any[]>;
+export { createNiftiImageIdsAndCacheMetadata };

package/dist/esm/createNiftiImageIdsAndCacheMetadata.js

@@ -0,0 +1,250 @@
+import * as NiftiReader from 'nifti-reader-js';
+import { eventTarget, triggerEvent, utilities } from '@cornerstonejs/core';
+import { rasToLps } from './helpers/convert';
+import Events from './enums/Events';
+import { NIFTI_LOADER_SCHEME } from './constants';
+import makeVolumeMetadata from './helpers/makeVolumeMetadata';
+import { getArrayConstructor } from './helpers/dataTypeCodeHelper';
+export const urlsMap = new Map();
+const NIFTI1_HEADER_SIZE = 348;
+const NIFTI2_HEADER_SIZE = 540;
+const HEADER_CHECK_SIZE = Math.max(NIFTI1_HEADER_SIZE, NIFTI2_HEADER_SIZE);
+export async function fetchArrayBuffer({ url, onProgress, controller, onLoad, onHeader, loadFullVolume = false, }) {
+    const isCompressed = url.endsWith('.gz');
+    let receivedData = new Uint8Array(0);
+    let niftiHeader = null;
+    const sliceInfo = null;
+    let contentLength;
+    const receivedLength = 0;
+    const signal = controller.signal;
+    try {
+        const response = await fetch(url, { signal });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        contentLength = response.headers.get('Content-Length');
+        const reader = response.body.getReader();
+        const decompressionStream = isCompressed
+            ? new DecompressionStream('gzip')
+            : null;
+        const decompressionWriter = decompressionStream
+            ? decompressionStream.writable.getWriter()
+            : null;
+        readStream(reader, decompressionWriter, isCompressed, receivedLength, processChunk, controller).catch(console.error);
+        if (isCompressed) {
+            const decompressedStream = decompressionStream.readable.getReader();
+            while (true) {
+                const { done, value } = await decompressedStream.read();
+                if (done) {
+                    break;
+                }
+                processChunk(value);
+                if (niftiHeader && !loadFullVolume) {
+                    controller.abort();
+                    break;
+                }
+            }
+        }
+        if (onLoad && typeof onLoad === 'function') {
+            onLoad();
+        }
+        return { data: receivedData, headerInfo: niftiHeader, sliceInfo };
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            console.log('Fetch aborted');
+        }
+        else {
+            console.error('Fetch error:', error);
+        }
+        throw error;
+    }
+    function processChunk(chunk) {
+        appendData(chunk);
+        if (onProgress && typeof onProgress === 'function') {
+            onProgress(receivedLength, contentLength);
+        }
+    }
+    function appendData(data) {
+        const newData = new Uint8Array(receivedData.length + data.length);
+        newData.set(receivedData);
+        newData.set(data, receivedData.length);
+        receivedData = newData;
+        if (!loadFullVolume &&
+            !niftiHeader &&
+            receivedData.length >= HEADER_CHECK_SIZE) {
+            niftiHeader = handleNiftiHeader(receivedData);
+            if (niftiHeader && niftiHeader.isValid) {
+                controller.abort();
+            }
+            onHeader?.(niftiHeader);
+        }
+    }
+}
+async function readStream(reader, decompressionWriter, isCompressed, receivedLength, processChunk, controller) {
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            if (isCompressed) {
+                decompressionWriter.close();
+            }
+            break;
+        }
+        receivedLength += value.length;
+        if (isCompressed) {
+            await decompressionWriter.write(value);
+        }
+        else {
+            processChunk(value);
+        }
+        if (controller.signal.aborted) {
+            break;
+        }
+    }
+}
+function handleNiftiHeader(data) {
+    if (data.length < HEADER_CHECK_SIZE) {
+        return { isValid: false, message: 'Not enough data to check header' };
+    }
+    try {
+        const headerBuffer = data.slice(0, HEADER_CHECK_SIZE).buffer;
+        const header = NiftiReader.readHeader(headerBuffer);
+        const version = header.sizeof_hdr === NIFTI2_HEADER_SIZE ? 2 : 1;
+        const { orientation, origin, spacing } = rasToLps(header);
+        const { dimensions, direction } = makeVolumeMetadata(header, orientation, 1);
+        const arrayConstructor = getArrayConstructor(header.datatypeCode);
+        return {
+            dimensions,
+            direction,
+            isValid: true,
+            message: `Valid Nifti-${version} header detected`,
+            origin,
+            version,
+            orientation,
+            spacing,
+            header,
+            arrayConstructor,
+        };
+    }
+    catch (error) {
+        console.error('Error reading Nifti header:', error);
+        return { isValid: false, message: 'Error reading Nifti header' };
+    }
+}
+async function fetchAndAllocateNiftiVolume(volumeId) {
+    const niftiURL = volumeId.substring(NIFTI_LOADER_SCHEME.length + 1);
+    const onProgress = (loaded, total) => {
+        const data = { volumeId, loaded, total };
+        triggerEvent(eventTarget, Events.NIFTI_VOLUME_PROGRESS, { data });
+    };
+    const onLoad = () => {
+        const data = { volumeId };
+        triggerEvent(eventTarget, Events.NIFTI_VOLUME_LOADED, { data });
+    };
+    const controller = new AbortController();
+    urlsMap.set(niftiURL, { controller, loading: true });
+    const niftiHeader = (await new Promise((resolve) => {
+        fetchArrayBuffer({
+            url: niftiURL,
+            onProgress,
+            controller,
+            onLoad,
+            onHeader: resolve,
+        });
+    }));
+    const { dimensions, direction, isValid, message, origin, version, header, spacing, arrayConstructor, } = niftiHeader;
+    const numImages = dimensions[2];
+    if (!isValid) {
+        console.error(message);
+        return;
+    }
+    const imageIds = [];
+    for (let i = 0; i < numImages; i++) {
+        const imageId = `nifti:${niftiURL}?frame=${i}`;
+        const imageIdIndex = i;
+        imageIds.push(imageId);
+        const imageOrientationPatient = [
+            direction[0],
+            direction[1],
+            direction[2],
+            direction[3],
+            direction[4],
+            direction[5],
+        ];
+        const precision = 6;
+        const imagePositionPatient = [
+            parseFloat((origin[0] + imageIdIndex * direction[6] * spacing[0]).toFixed(precision)),
+            parseFloat((origin[1] + imageIdIndex * direction[7] * spacing[1]).toFixed(precision)),
+            parseFloat((origin[2] + imageIdIndex * direction[8] * spacing[2]).toFixed(precision)),
+        ];
+        const imagePlaneMetadata = {
+            frameOfReferenceUID: '1.2.840.10008.1.4',
+            rows: dimensions[1],
+            columns: dimensions[0],
+            imageOrientationPatient,
+            rowCosines: direction.slice(0, 3),
+            columnCosines: direction.slice(3, 6),
+            imagePositionPatient,
+            sliceThickness: spacing[2],
+            sliceLocation: origin[2] + i * spacing[2],
+            pixelSpacing: [spacing[0], spacing[1]],
+            rowPixelSpacing: spacing[1],
+            columnPixelSpacing: spacing[0],
+        };
+        const imagePixelMetadata = {
+            samplesPerPixel: 1,
+            photometricInterpretation: 'MONOCHROME2',
+            rows: dimensions[1],
+            columns: dimensions[0],
+            bitsAllocated: arrayConstructor.BYTES_PER_ELEMENT * 8,
+            bitsStored: arrayConstructor.BYTES_PER_ELEMENT * 8,
+            highBit: arrayConstructor.BYTES_PER_ELEMENT * 8 - 1,
+            pixelRepresentation: 1,
+            planarConfiguration: 0,
+            pixelAspectRatio: '1\\1',
+            redPaletteColorLookupTableDescriptor: [],
+            greenPaletteColorLookupTableDescriptor: [],
+            bluePaletteColorLookupTableDescriptor: [],
+            redPaletteColorLookupTableData: [],
+            greenPaletteColorLookupTableData: [],
+            bluePaletteColorLookupTableData: [],
+            smallestPixelValue: undefined,
+            largestPixelValue: undefined,
+        };
+        const generalSeriesMetadata = {
+            seriesDate: new Date(),
+            seriesTime: new Date(),
+        };
+        utilities.genericMetadataProvider.add(imageId, {
+            type: 'imagePixelModule',
+            metadata: imagePixelMetadata,
+        });
+        utilities.genericMetadataProvider.add(imageId, {
+            type: 'imagePlaneModule',
+            metadata: imagePlaneMetadata,
+        });
+        utilities.genericMetadataProvider.add(imageId, {
+            type: 'generalSeriesModule',
+            metadata: generalSeriesMetadata,
+        });
+        utilities.genericMetadataProvider.add(imageId, {
+            type: 'niftiVersion',
+            metadata: {
+                version,
+            },
+        });
+        utilities.genericMetadataProvider.addRaw(imageId, {
+            type: 'niftiHeader',
+            metadata: {
+                header,
+            },
+        });
+    }
+    urlsMap.delete(niftiURL);
+    return imageIds;
+}
+async function createNiftiImageIdsAndCacheMetadata({ url }) {
+    const imageIds = await fetchAndAllocateNiftiVolume(url);
+    return imageIds;
+}
+export { createNiftiImageIdsAndCacheMetadata };

package/dist/esm/enums/Events.js

@@ -4,4 +4,3 @@ var Events;
     Events["NIFTI_VOLUME_PROGRESS"] = "CORNERSTONE_NIFTI_VOLUME_PROGRESS";
 })(Events || (Events = {}));
 export default Events;
-//# sourceMappingURL=Events.js.map

package/dist/esm/enums/index.js

@@ -1,3 +1,2 @@
 import Events from './Events';
 export { Events };
-//# sourceMappingURL=index.js.map

package/dist/esm/helpers/affineUtilities.js

@@ -42,4 +42,3 @@ function parseAffineMatrix(affine) {
     return { origin, orientation, spacing };
 }
 export { generateAffineMatrix, parseAffineMatrix };
-//# sourceMappingURL=affineUtilities.js.map

package/dist/esm/helpers/convert.js

@@ -3,8 +3,7 @@ const invertDataPerFrame = (dimensions, imageDataArray) => {
     let TypedArrayConstructor;
     let bytesPerVoxel;
     if (imageDataArray instanceof Uint8Array ||
-        imageDataArray instanceof ArrayBuffer ||
-        imageDataArray instanceof SharedArrayBuffer) {
+        imageDataArray instanceof ArrayBuffer) {
         TypedArrayConstructor = Uint8Array;
         bytesPerVoxel = 1;
     }
@@ -80,4 +79,3 @@ function lpsToRas(header) {
     };
 }
 export { lpsToRas, rasToLps, invertDataPerFrame };
-//# sourceMappingURL=convert.js.map

package/dist/esm/helpers/dataTypeCodeHelper.d.ts

@@ -0,0 +1 @@
+export declare function getArrayConstructor(datatypeCode: number): unknown;

package/dist/esm/helpers/dataTypeCodeHelper.js

@@ -0,0 +1,22 @@
+import * as NIFTICONSTANTS from './niftiConstants';
+export function getArrayConstructor(datatypeCode) {
+    switch (datatypeCode) {
+        case NIFTICONSTANTS.NIFTI_TYPE_UINT8:
+            return Uint8Array;
+        case NIFTICONSTANTS.NIFTI_TYPE_INT16:
+            return Int16Array;
+        case NIFTICONSTANTS.NIFTI_TYPE_INT32:
+            return Int32Array;
+        case NIFTICONSTANTS.NIFTI_TYPE_FLOAT32: {
+            return Float32Array;
+        }
+        case NIFTICONSTANTS.NIFTI_TYPE_INT8:
+            return Int8Array;
+        case NIFTICONSTANTS.NIFTI_TYPE_UINT16:
+            return Uint16Array;
+        case NIFTICONSTANTS.NIFTI_TYPE_UINT32:
+            return Uint32Array;
+        default:
+            throw new Error(`NIFTI datatypeCode ${datatypeCode} is not yet supported`);
+    }
+}

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

@@ -1,4 +1,3 @@
 import makeVolumeMetadata from './makeVolumeMetadata';
 import modalityScaleNifti from './modalityScaleNifti';
-import fetchAndAllocateNiftiVolume from './fetchAndAllocateNiftiVolume';
-export { modalityScaleNifti, makeVolumeMetadata, fetchAndAllocateNiftiVolume };
+export { modalityScaleNifti, makeVolumeMetadata };

package/dist/esm/helpers/index.js

@@ -1,5 +1,3 @@
 import makeVolumeMetadata from './makeVolumeMetadata';
 import modalityScaleNifti from './modalityScaleNifti';
-import fetchAndAllocateNiftiVolume from './fetchAndAllocateNiftiVolume';
-export { modalityScaleNifti, makeVolumeMetadata, fetchAndAllocateNiftiVolume };
-//# sourceMappingURL=index.js.map
+export { modalityScaleNifti, makeVolumeMetadata };

package/dist/esm/helpers/makeVolumeMetadata.d.ts

@@ -1,2 +1,6 @@
-import { Types } from '@cornerstonejs/core';
-export default function makeVolumeMetadata(niftiHeader: any, orientation: any, scalarData: any): Types.Metadata;
+import type { Types } from '@cornerstonejs/core';
+export default function makeVolumeMetadata(niftiHeader: any, orientation: any, pixelRepresentation: any): {
+    volumeMetadata: Types.Metadata;
+    dimensions: Types.Point3;
+    direction: Types.Mat3;
+};

package/dist/esm/helpers/makeVolumeMetadata.js

@@ -1,51 +1,55 @@
+import { utilities } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
-export default function makeVolumeMetadata(niftiHeader, orientation, scalarData) {
+const { windowLevel } = utilities;
+export default function makeVolumeMetadata(niftiHeader, orientation, pixelRepresentation) {
     const { numBitsPerVoxel, littleEndian, pixDims, dims } = niftiHeader;
+    const min = Infinity;
+    const max = -Infinity;
+    const frameLength = dims[1] * dims[2];
+    const middleFrameIndex = Math.floor(dims[3] / 2);
+    const offset = frameLength * middleFrameIndex;
+    const { windowWidth, windowCenter } = { windowWidth: 400, windowCenter: 40 };
     const rowCosines = vec3.create();
     const columnCosines = vec3.create();
+    const scanAxisNormal = vec3.create();
     vec3.set(rowCosines, orientation[0], orientation[1], orientation[2]);
     vec3.set(columnCosines, orientation[3], orientation[4], orientation[5]);
-    let min = Infinity;
-    let max = -Infinity;
-    const xDim = dims[1];
-    const yDim = dims[2];
-    const zDim = dims[3];
-    const frameLength = xDim * yDim;
-    const middleFrameIndex = Math.floor(zDim / 2);
-    const offset = frameLength * middleFrameIndex;
-    for (let voxelIndex = offset; voxelIndex < offset + frameLength; voxelIndex++) {
-        const voxelValue = scalarData[voxelIndex];
-        if (voxelValue > max) {
-            max = voxelValue;
-        }
-        if (voxelValue < min) {
-            min = voxelValue;
-        }
-    }
-    const windowCenter = (max + min) / 2;
-    const windowWidth = max - min;
+    vec3.set(scanAxisNormal, orientation[6], orientation[7], orientation[8]);
     return {
-        BitsAllocated: numBitsPerVoxel,
-        BitsStored: numBitsPerVoxel,
-        SamplesPerPixel: 1,
-        HighBit: littleEndian ? numBitsPerVoxel - 1 : 1,
-        PhotometricInterpretation: 'MONOCHROME2',
-        PixelRepresentation: 1,
-        ImageOrientationPatient: [
+        volumeMetadata: {
+            BitsAllocated: numBitsPerVoxel,
+            BitsStored: numBitsPerVoxel,
+            SamplesPerPixel: 1,
+            HighBit: littleEndian ? numBitsPerVoxel - 1 : 1,
+            PhotometricInterpretation: 'MONOCHROME2',
+            PixelRepresentation: pixelRepresentation,
+            ImageOrientationPatient: [
+                rowCosines[0],
+                rowCosines[1],
+                rowCosines[2],
+                columnCosines[0],
+                columnCosines[1],
+                columnCosines[2],
+            ],
+            PixelSpacing: [pixDims[1], pixDims[2]],
+            Columns: dims[1],
+            Rows: dims[2],
+            voiLut: [{ windowCenter, windowWidth }],
+            FrameOfReferenceUID: '1.2.3',
+            Modality: 'MR',
+            VOILUTFunction: 'LINEAR',
+        },
+        dimensions: [dims[1], dims[2], dims[3]],
+        direction: new Float32Array([
             rowCosines[0],
             rowCosines[1],
             rowCosines[2],
             columnCosines[0],
             columnCosines[1],
             columnCosines[2],
-        ],
-        PixelSpacing: [pixDims[1], pixDims[2]],
-        Columns: xDim,
-        Rows: yDim,
-        voiLut: [{ windowCenter, windowWidth }],
-        FrameOfReferenceUID: '1.2.3',
-        Modality: 'MR',
-        VOILUTFunction: 'LINEAR',
+            scanAxisNormal[0],
+            scanAxisNormal[1],
+            scanAxisNormal[2],
+        ]),
     };
 }
-//# sourceMappingURL=makeVolumeMetadata.js.map

package/dist/esm/helpers/modalityScaleNifti.d.ts

@@ -1 +1,5 @@
-export default function modalityScaleNifti(array: Float32Array | Int16Array | Uint8Array, niftiHeader: any): void;
+import type { Types } from '@cornerstonejs/core';
+export default function modalityScaleNifti(niftiHeader: any, niftiImageBuffer: any): {
+    scalarData: Types.PixelDataTypedArray;
+    pixelRepresentation: number;
+};