@cornerstonejs/nifti-volume-loader 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/esm/NiftiImageVolume.d.ts

@@ -1,18 +1,18 @@
 import { ImageVolume } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
-declare type LoadStatus = {
+type LoadStatus = {
     loaded: boolean;
     loading: boolean;
     callbacks: Array<(...args: unknown[]) => void>;
 };
-declare type NiftiImageProperties = {
+type NiftiImageProperties = {
     loadStatus: LoadStatus;
     controller: AbortController;
 };
 export default class NiftiImageVolume extends ImageVolume {
     loadStatus: LoadStatus;
     controller: AbortController;
-    constructor(imageVolumeProperties: Types.IVolume, streamingProperties: NiftiImageProperties);
+    constructor(imageVolumeProperties: Types.ImageVolumeProps, streamingProperties: NiftiImageProperties);
     cancelLoading: () => void;
     clearLoadCallbacks(): void;
     load: (callback: (...args: unknown[]) => void, priority?: number) => void;

package/dist/esm/NiftiImageVolume.js

@@ -23,4 +23,3 @@ export default class NiftiImageVolume extends ImageVolume {
         cache.removeVolumeLoadObject(this.volumeId);
     }
 }
-//# sourceMappingURL=NiftiImageVolume.js.map

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.js

@@ -7,4 +7,3 @@ export default function cornerstoneNiftiImageVolumeLoader(volumeId) {
         },
     };
 }
-//# sourceMappingURL=cornerstoneNiftiImageLoader.js.map

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.d.ts

@@ -1,4 +1,4 @@
-import type { Types } from '@cornerstonejs/core';
+import { Types } from '@cornerstonejs/core';
 declare const invertDataPerFrame: (dimensions: any, imageDataArray: any) => any;
 declare function rasToLps(niftiHeader: any): {
     origin: Types.Point3;

package/dist/esm/helpers/convert.js

@@ -1,10 +1,12 @@
+import { getShouldUseSharedArrayBuffer } from '@cornerstonejs/core';
 import { parseAffineMatrix } from './affineUtilities';
 const invertDataPerFrame = (dimensions, imageDataArray) => {
     let TypedArrayConstructor;
     let bytesPerVoxel;
     if (imageDataArray instanceof Uint8Array ||
         imageDataArray instanceof ArrayBuffer ||
-        imageDataArray instanceof SharedArrayBuffer) {
+        (getShouldUseSharedArrayBuffer() &&
+            imageDataArray instanceof SharedArrayBuffer)) {
         TypedArrayConstructor = Uint8Array;
         bytesPerVoxel = 1;
     }
@@ -80,4 +82,3 @@ function lpsToRas(header) {
     };
 }
 export { lpsToRas, rasToLps, invertDataPerFrame };
-//# sourceMappingURL=convert.js.map

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

@@ -1,4 +1,3 @@
 import NiftiImageVolume from '../NiftiImageVolume';
 export declare const urlsMap: Map<any, any>;
-export declare const getTypedNiftiArray: (datatypeCode: any, niftiImageBuffer: any) => Float32Array | Int16Array | Uint8Array;
 export default function fetchAndAllocateNiftiVolume(volumeId: string): Promise<NiftiImageVolume>;

package/dist/esm/helpers/fetchAndAllocateNiftiVolume.js

@@ -1,14 +1,11 @@
 import * as NiftiReader from 'nifti-reader-js';
-import { cache, utilities, Enums, eventTarget, triggerEvent, } from '@cornerstonejs/core';
-import { vec3 } from 'gl-matrix';
-import makeVolumeMetadata from './makeVolumeMetadata';
+import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import NiftiImageVolume from '../NiftiImageVolume';
-import * as NIFTICONSTANTS from './niftiConstants';
-import { invertDataPerFrame, rasToLps } from './convert';
-import modalityScaleNifti from './modalityScaleNifti';
+import { rasToLps } from './convert';
 import Events from '../enums/Events';
 import { NIFTI_LOADER_SCHEME } from '../constants';
-const { createUint8SharedArray, createFloat32SharedArray } = utilities;
+import makeVolumeMetadata from './makeVolumeMetadata';
+import modalityScaleNifti from './modalityScaleNifti';
 export const urlsMap = new Map();
 function fetchArrayBuffer(url, onProgress, signal, onload) {
     return new Promise((resolve, reject) => {
@@ -45,18 +42,6 @@ function fetchArrayBuffer(url, onProgress, signal, onload) {
         xhr.send();
     });
 }
-export const getTypedNiftiArray = (datatypeCode, niftiImageBuffer) => {
-    switch (datatypeCode) {
-        case NIFTICONSTANTS.NIFTI_TYPE_UINT8:
-            return new Uint8Array(niftiImageBuffer);
-        case NIFTICONSTANTS.NIFTI_TYPE_FLOAT32:
-            return new Float32Array(niftiImageBuffer);
-        case NIFTICONSTANTS.NIFTI_TYPE_INT16:
-            return new Int16Array(niftiImageBuffer);
-        default:
-            throw new Error(`datatypeCode ${datatypeCode} is not yet supported`);
-    }
-};
 export default async function fetchAndAllocateNiftiVolume(volumeId) {
     const niftiURL = volumeId.substring(NIFTI_LOADER_SCHEME.length + 1);
     const progress = (loaded, total) => {
@@ -85,63 +70,10 @@ export default async function fetchAndAllocateNiftiVolume(volumeId) {
         niftiHeader = NiftiReader.readHeader(niftiBuffer);
         niftiImage = NiftiReader.readImage(niftiHeader, niftiBuffer);
     }
-    const typedNiftiArray = getTypedNiftiArray(niftiHeader.datatypeCode, niftiImage);
+    const { scalarData, pixelRepresentation } = modalityScaleNifti(niftiHeader, niftiImage);
     const { orientation, origin, spacing } = rasToLps(niftiHeader);
-    invertDataPerFrame(niftiHeader.dims.slice(1, 4), typedNiftiArray);
-    modalityScaleNifti(typedNiftiArray, niftiHeader);
-    const volumeMetadata = makeVolumeMetadata(niftiHeader, orientation, typedNiftiArray);
-    const scanAxisNormal = vec3.create();
-    vec3.set(scanAxisNormal, orientation[6], orientation[7], orientation[8]);
-    const { BitsAllocated, PixelRepresentation, PhotometricInterpretation, ImageOrientationPatient, Columns, Rows, } = volumeMetadata;
-    const rowCosineVec = vec3.fromValues(ImageOrientationPatient[0], ImageOrientationPatient[1], ImageOrientationPatient[2]);
-    const colCosineVec = vec3.fromValues(ImageOrientationPatient[3], ImageOrientationPatient[4], ImageOrientationPatient[5]);
-    const { dims } = niftiHeader;
-    const numFrames = dims[3];
-    const dimensions = [Columns, Rows, numFrames];
-    const direction = new Float32Array([
-        rowCosineVec[0],
-        rowCosineVec[1],
-        rowCosineVec[2],
-        colCosineVec[0],
-        colCosineVec[1],
-        colCosineVec[2],
-        scanAxisNormal[0],
-        scanAxisNormal[1],
-        scanAxisNormal[2],
-    ]);
-    const signed = PixelRepresentation === 1;
-    let bytesPerVoxel = 1;
-    if (BitsAllocated === 16 || BitsAllocated === 32) {
-        bytesPerVoxel = 4;
-    }
-    const sizeInBytesPerComponent = bytesPerVoxel * dimensions[0] * dimensions[1] * dimensions[2];
-    let numComponents = 1;
-    if (PhotometricInterpretation === 'RGB') {
-        numComponents = 3;
-    }
-    const sizeInBytes = sizeInBytesPerComponent * numComponents;
-    const isCacheable = cache.isCacheable(sizeInBytes);
-    if (!isCacheable) {
-        throw new Error(Enums.Events.CACHE_SIZE_EXCEEDED);
-    }
-    cache.decacheIfNecessaryUntilBytesAvailable(sizeInBytes);
-    let scalarData;
-    switch (BitsAllocated) {
-        case 8:
-            if (signed) {
-                throw new Error('8 Bit signed images are not yet supported by this plugin.');
-            }
-            else {
-                scalarData = createUint8SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
-            }
-            break;
-        case 16:
-        case 32:
-            scalarData = createFloat32SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
-            break;
-    }
-    scalarData.set(typedNiftiArray);
-    const niftiImageVolume = new NiftiImageVolume({
+    const { volumeMetadata, dimensions, direction } = makeVolumeMetadata(niftiHeader, orientation, scalarData, pixelRepresentation);
+    return new NiftiImageVolume({
         volumeId,
         metadata: volumeMetadata,
         dimensions,
@@ -149,7 +81,8 @@ export default async function fetchAndAllocateNiftiVolume(volumeId) {
         origin,
         direction,
         scalarData,
-        sizeInBytes,
+        sizeInBytes: scalarData.byteLength,
+        imageIds: [],
     }, {
         loadStatus: {
             loaded: false,
@@ -158,6 +91,4 @@ export default async function fetchAndAllocateNiftiVolume(volumeId) {
         },
         controller,
     });
-    return niftiImageVolume;
 }
-//# sourceMappingURL=fetchAndAllocateNiftiVolume.js.map

package/dist/esm/helpers/index.js

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

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;
+export default function makeVolumeMetadata(niftiHeader: any, orientation: any, scalarData: any, pixelRepresentation: any): {
+    volumeMetadata: Types.Metadata;
+    dimensions: Types.Point3;
+    direction: Types.Mat3;
+};

package/dist/esm/helpers/makeVolumeMetadata.js

@@ -1,17 +1,12 @@
+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, scalarData, pixelRepresentation) {
     const { numBitsPerVoxel, littleEndian, pixDims, dims } = niftiHeader;
-    const rowCosines = vec3.create();
-    const columnCosines = 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 frameLength = dims[1] * dims[2];
+    const middleFrameIndex = Math.floor(dims[3] / 2);
     const offset = frameLength * middleFrameIndex;
     for (let voxelIndex = offset; voxelIndex < offset + frameLength; voxelIndex++) {
         const voxelValue = scalarData[voxelIndex];
@@ -22,30 +17,48 @@ export default function makeVolumeMetadata(niftiHeader, orientation, scalarData)
             min = voxelValue;
         }
     }
-    const windowCenter = (max + min) / 2;
-    const windowWidth = max - min;
+    const { windowWidth, windowCenter } = windowLevel.toWindowLevel(min, max);
+    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]);
+    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 { Types } from '@cornerstonejs/core';
+export default function modalityScaleNifti(niftiHeader: any, niftiImageBuffer: any): {
+    scalarData: Types.PixelDataTypedArray;
+    pixelRepresentation: number;
+};

package/dist/esm/helpers/modalityScaleNifti.js

@@ -1,11 +1,147 @@
-export default function modalityScaleNifti(array, niftiHeader) {
-    const arrayLength = array.length;
-    const { scl_slope, scl_inter } = niftiHeader;
+import { cache, Enums, getShouldUseSharedArrayBuffer, utilities, } from '@cornerstonejs/core';
+import * as NIFTICONSTANTS from './niftiConstants';
+const { createFloat32SharedArray, createInt16SharedArray, createUint8SharedArray, createUint16SharedArray, } = utilities;
+export default function modalityScaleNifti(niftiHeader, niftiImageBuffer) {
+    const { datatypeCode, scl_slope, scl_inter } = niftiHeader;
+    let slope = scl_slope;
+    let inter = scl_inter;
     if (!scl_slope || scl_slope === 0 || Number.isNaN(scl_slope)) {
-        return;
+        slope = 1;
     }
-    for (let i = 0; i < arrayLength; i++) {
-        array[i] = array[i] * scl_slope + scl_inter;
+    if (!scl_inter || Number.isNaN(scl_inter)) {
+        inter = 0;
     }
+    const hasNegativeRescale = inter < 0 || slope < 0;
+    const hasFloatRescale = inter % 1 !== 0 || slope % 1 !== 0;
+    let niiBuffer;
+    let scalarData;
+    let pixelRepresentation = 1;
+    switch (datatypeCode) {
+        case NIFTICONSTANTS.NIFTI_TYPE_UINT8:
+            niiBuffer = new Uint8Array(niftiImageBuffer);
+            if (hasFloatRescale) {
+                scalarData = allocateScalarData('Float32Array', niiBuffer);
+            }
+            else if (hasNegativeRescale) {
+                scalarData = allocateScalarData('Int16Array', niiBuffer);
+            }
+            else {
+                pixelRepresentation = 0;
+                scalarData = allocateScalarData('Uint8Array', niiBuffer);
+            }
+            break;
+        case NIFTICONSTANTS.NIFTI_TYPE_INT16:
+            niiBuffer = new Int16Array(niftiImageBuffer);
+            if (hasFloatRescale) {
+                scalarData = allocateScalarData('Float32Array', niiBuffer);
+            }
+            else {
+                scalarData = allocateScalarData('Int16Array', niiBuffer);
+            }
+            break;
+        case NIFTICONSTANTS.NIFTI_TYPE_INT32:
+            niiBuffer = new Int32Array(niftiImageBuffer);
+            scalarData = allocateScalarData('Float32Array', niiBuffer);
+            break;
+        case NIFTICONSTANTS.NIFTI_TYPE_FLOAT32: {
+            niiBuffer = new Float32Array(niftiImageBuffer);
+            scalarData = allocateScalarData('Float32Array', niiBuffer);
+            break;
+        }
+        case NIFTICONSTANTS.NIFTI_TYPE_INT8:
+            niiBuffer = new Int8Array(niftiImageBuffer);
+            if (hasFloatRescale) {
+                scalarData = allocateScalarData('Float32Array', niiBuffer);
+            }
+            else {
+                scalarData = allocateScalarData('Int8Array', niiBuffer);
+            }
+            break;
+        case NIFTICONSTANTS.NIFTI_TYPE_UINT16:
+            niiBuffer = new Uint16Array(niftiImageBuffer);
+            if (hasFloatRescale || hasNegativeRescale) {
+                scalarData = allocateScalarData('Float32Array', niiBuffer);
+            }
+            else {
+                pixelRepresentation = 0;
+                scalarData = allocateScalarData('Uint16Array', niiBuffer);
+            }
+            break;
+        case NIFTICONSTANTS.NIFTI_TYPE_UINT32:
+            niiBuffer = new Uint32Array(niftiImageBuffer);
+            scalarData = allocateScalarData('Float32Array', niiBuffer);
+            break;
+        default:
+            throw new Error(`NIFTI datatypeCode ${datatypeCode} is not yet supported`);
+    }
+    const nVox = scalarData.length;
+    if (slope !== 1 && inter !== 0) {
+        for (let i = 0; i < nVox; i++) {
+            scalarData[i] = intensityRaw2Scaled(scalarData[i], slope, inter);
+        }
+    }
+    niftiHeader.numBitsPerVoxel = (scalarData.byteLength / scalarData.length) * 8;
+    return {
+        scalarData,
+        pixelRepresentation,
+    };
+}
+function intensityRaw2Scaled(raw, scl_slope, scl_inter) {
+    return raw * scl_slope + scl_inter;
+}
+function checkCacheAvailable(bitsAllocated, length) {
+    const sizeInBytes = (bitsAllocated / 8) * length;
+    const isCacheable = cache.isCacheable(sizeInBytes);
+    if (!isCacheable) {
+        throw new Error(Enums.Events.CACHE_SIZE_EXCEEDED);
+    }
+    cache.decacheIfNecessaryUntilBytesAvailable(sizeInBytes);
+    return sizeInBytes;
+}
+function allocateScalarData(types, niiBuffer) {
+    let bitsAllocated;
+    let scalarData;
+    const useSharedArrayBuffer = getShouldUseSharedArrayBuffer();
+    const nVox = niiBuffer.length;
+    switch (types) {
+        case 'Float32Array':
+            bitsAllocated = 32;
+            checkCacheAvailable(bitsAllocated, nVox);
+            scalarData = useSharedArrayBuffer
+                ? createFloat32SharedArray(nVox)
+                : new Float32Array(nVox);
+            break;
+        case 'Int16Array':
+            bitsAllocated = 16;
+            checkCacheAvailable(bitsAllocated, nVox);
+            scalarData = useSharedArrayBuffer
+                ? createInt16SharedArray(nVox)
+                : new Int16Array(nVox);
+            break;
+        case 'Int8Array':
+            bitsAllocated = 8;
+            checkCacheAvailable(bitsAllocated, nVox);
+            scalarData = useSharedArrayBuffer
+                ? createInt16SharedArray(nVox)
+                : new Int16Array(nVox);
+            break;
+        case 'Uint16Array':
+            bitsAllocated = 16;
+            checkCacheAvailable(bitsAllocated, nVox);
+            scalarData = useSharedArrayBuffer
+                ? createUint16SharedArray(nVox)
+                : new Uint16Array(nVox);
+            break;
+        case 'Uint8Array':
+            bitsAllocated = 8;
+            checkCacheAvailable(bitsAllocated, nVox);
+            scalarData = useSharedArrayBuffer
+                ? createUint8SharedArray(nVox)
+                : new Uint8Array(nVox);
+            break;
+        default:
+            throw new Error(`TypedArray ${types} is not yet supported`);
+    }
+    scalarData.set(niiBuffer);
+    return scalarData;
 }
-//# sourceMappingURL=modalityScaleNifti.js.map

package/dist/esm/helpers/niftiConstants.js

@@ -41,4 +41,3 @@ const NIFTI1_HEADER_ENDOFFILE_STRING = '0000';
 const NIFTI1_ALIGNED_ANAT = 2;
 const NIFTI1_XYZT_UNITS_UNKNOWN = 0;
 export { NIFTI_TYPE_UINT8, NIFTI_TYPE_INT16, NIFTI_TYPE_INT32, NIFTI_TYPE_FLOAT32, NIFTI_TYPE_COMPLEX64, NIFTI_TYPE_FLOAT64, NIFTI_TYPE_RGB24, NIFTI_TYPE_INT8, NIFTI_TYPE_UINT16, NIFTI_TYPE_UINT32, NIFTI_TYPE_INT64, NIFTI_TYPE_UINT64, NIFTI_TYPE_FLOAT128, NIFTI_TYPE_COMPLEX128, NIFTI_TYPE_COMPLEX256, NIFTI_TYPE_RGBA32, NIFTI2_HEADER_TOTAL_LENGTH_BYTES, NIFTI2_HEADER_TOTAL_LENGTH_BITS, NIFTI2_HEADER_MAGIC_LENGTH_BYTES, NIFTI2_HEADER_DESCRIPTION_LENGTH_BYTES, NIFTI2_HEADER_AUX_FILE_LENGTH_BYTES, NIFTI2_HEADER_INTENT_NAME_LENGTH_BYTES, NIFTI2_HEADER_DIM_INFO_LENGTH_BYTES, NIFTI2_HEADER_ENDOFFILE_LENGTH_BYTES, NIFTI2_VOX_OFFSET_BYTES, NIFTI2_HEADER_MAGIC_STRING, NIFTI2_HEADER_ENDOFFILE_STRING, NIFTI2_ALIGNED_ANAT, NIFTI2_XYZT_UNITS_UNKNOWN, NIFTI1_HEADER_TOTAL_LENGTH_BYTES, NIFTI1_HEADER_TOTAL_LENGTH_BITS, NIFTI1_HEADER_MAGIC_LENGTH_BYTES, NIFTI1_HEADER_DESCRIPTION_LENGTH_BYTES, NIFTI1_HEADER_AUX_FILE_LENGTH_BYTES, NIFTI1_HEADER_INTENT_NAME_LENGTH_BYTES, NIFTI1_HEADER_DIM_INFO_LENGTH_BYTES, NIFTI1_HEADER_ENDOFFILE_LENGTH_BYTES, NIFTI1_VOX_OFFSET_BYTES, NIFTI1_HEADER_MAGIC_STRING, NIFTI1_HEADER_ENDOFFILE_STRING, NIFTI1_ALIGNED_ANAT, NIFTI1_XYZT_UNITS_UNKNOWN, };
-//# sourceMappingURL=niftiConstants.js.map

package/dist/esm/index.js

@@ -3,4 +3,3 @@ import NiftiImageVolume from './NiftiImageVolume';
 import * as helpers from './helpers';
 import * as Enums from './enums';
 export { cornerstoneNiftiImageVolumeLoader, NiftiImageVolume, helpers, Enums };
-//# sourceMappingURL=index.js.map