WIP: read volume (3d image) data

Limitations:
- does not support compressed/encapsulated pixel data
(see non-raw dicom transfer syntaxes, ex: JPEG2000)
- assumes slicethickness is spacing
- harcode pixel type and dimension in imageType

Author: Alexis Girault

examples/Dicom/src/index.js

@@ -17,12 +17,21 @@ const outputFileInformation = curry(async function outputFileInformation (output
   // Select DICOM serie
   outputTextArea.textContent = "Please select serie..."
   setupDicomForm(patients, async (serie) => {
+    console.time('customRead:')
+    const image1 = serie.getImageData()
+    console.log(image1)
+    console.warn(image1.data.length)
+    console.timeEnd('customRead:')
     outputTextArea.textContent = "Loading..."
 
     // Read DICOM serie
+    console.time('itkRead:')
     const files = Object.values(serie.images).map((image) => image.file)
     const { image, webWorker } = await readImageDICOMFileSeries(null, files)
     webWorker.terminate()
+    console.log(image)
+    console.warn(image.data.length)
+    console.timeEnd('itkRead:')
 
     // Display
     function replacer (key, value) {

examples/Dicom/src/parseDicomFiles.js

@@ -5,6 +5,18 @@ import "regenerator-runtime/runtime";
 
 import DICOM_TAG_DICT from './dicomTags'
 
+function concatenate(resultConstructor, arrays) {
+  const totalLength = arrays.reduce((total, arr) => {
+    return total + arr.length
+  }, 0);
+  const result = new resultConstructor(totalLength);
+  arrays.reduce((offset, arr) => {
+    result.set(arr, offset);
+    return offset + arr.length;
+  }, 0);
+  return result;
+}
+
 class DICOMEntity {
   constructor() {
     this.metaData = {}
@@ -120,6 +132,138 @@ class DICOMSeries extends DICOMEntity {
     }
     this.images[imageNumber] = new DICOMImage(metaData, file)
   }
+
+  getImageData() {
+    function numArrayFromString(str, separator = '\\') {
+      const strArray = str.split(separator)
+      return strArray.map(Number)
+    }
+
+    const slices = Object.values(this.images)
+    const meta = slices[0].metaData
+
+    // Origin
+    let origin = [0, 0, 0]
+    if (meta.ImagePositionPatient !== undefined) {
+      origin = numArrayFromString(meta.ImagePositionPatient)
+    }
+
+    // Spacing
+    let spacing = [1, 1];
+    if (meta.PixelSpacing !== undefined) {
+      spacing = numArrayFromString(meta.PixelSpacing);
+    }
+    if (meta.SliceThickness !== undefined) {
+      spacing.push(Number(meta.SliceThickness))
+    } else {
+      spacing.push(1);
+    }
+
+    // Dimensions
+    const size = [
+      meta.Rows,
+      meta.Columns,
+      Object.keys(this.images).length,
+    ]
+
+    // Direction matrix (3x3)
+    let directionCosines = [1, 0, 0, 0, 1, 0]
+    if (meta.ImageOrientationPatient !== undefined) {
+      directionCosines = numArrayFromString(meta.ImageOrientationPatient)
+    }
+    const iDirCos = directionCosines.slice(0, 3)
+    const jDirCos = directionCosines.slice(3, 6)
+    const kDirCos = [
+      iDirCos[1] * jDirCos[2] - iDirCos[2] * jDirCos[1],
+      iDirCos[2] * jDirCos[0] - iDirCos[0] * jDirCos[2],
+      iDirCos[0] * jDirCos[1] - iDirCos[1] * jDirCos[0],
+    ]
+    const direction = {
+      rows: 3,
+      columns: 3,
+      data: [
+        iDirCos[0], jDirCos[0], kDirCos[0],
+        iDirCos[1], jDirCos[1], kDirCos[1],
+        iDirCos[2], jDirCos[2], kDirCos[2],
+      ],
+    }
+
+    // Pixel data type
+    let slope = 1
+    if (meta.RescaleSlope !== undefined) {
+      slope = Number(meta.RescaleSlope)
+    }
+    let intercept = 0
+    if (meta.RescaleIntercept !== undefined) {
+      intercept = Number(meta.RescaleIntercept)
+    }
+    let smallestValue = 0
+    if (meta.SmallestImagePixelValue !== undefined) {
+      smallestValue = Number(meta.SmallestImagePixelValue)
+    }
+    const hasNegativeValues = (slope < 0) || (smallestValue + intercept) < 0;
+    const unsigned = meta.PixelRepresentation === 0 && !hasNegativeValues;
+    const bits = meta.BitsAllocated
+    let ArrayType
+    let intType
+    switch (bits) {
+      case 8:
+        ArrayType = unsigned ? Uint8Array : Int8Array
+        intType = unsigned ? 'uint8_t' : 'int8_t'
+        break
+      case 16:
+        ArrayType = unsigned ? Uint16Array : Int16Array
+        intType = unsigned ? 'uint16_t' : 'int16_t'
+        break
+      case 32:
+        ArrayType = unsigned ? Uint32Array : Int32Array
+        intType = unsigned ? 'uint32_t' : 'int32_t'
+        break
+      default:
+        throw Error(`Unknown pixel bit type (${bits})`)
+    }
+
+    // Image info
+    const imageType = {
+      dimension: 3,
+      componentType: intType,
+      pixelType: 1, // TODO: based on meta.PhotometricInterpretation?
+      components: meta.SamplesPerPixel,
+    }
+
+    // Dataview on pixel data
+    const pixelDataArrays = slices.map((image) => {
+      const value = image.metaData.PixelData
+      return new ArrayType(value.buffer, value.offset)
+    })
+
+    // Concatenate all pixel data
+    const data = concatenate(ArrayType, pixelDataArrays)
+
+    // Rescale
+    const b = Number(meta.RescaleIntercept)
+    const m = Number(meta.RescaleSlope)
+    const hasIntercept = !Number.isNaN(b) && b !== 0
+    const hasSlope = !Number.isNaN(m) && m !== 1
+    let rescaleFunction
+    if (hasIntercept && hasSlope) {
+      data = data.map((value) => m * value + b)
+    } else if (hasIntercept) {
+      data = data.map((value) => value + b)
+    } else if (hasSlope) {
+      data = data.map((value) => m * value)
+    }
+
+    return {
+      imageType,
+      name: "Image",
+      origin,
+      spacing,
+      direction,
+      size,
+      data,
+    }
+  }
 }
 
 class DICOMImage extends DICOMEntity {
@@ -147,6 +291,9 @@ class DICOMImage extends DICOMEntity {
       'BitsStored',
       'HighBit',
       'PixelRepresentation',
+      'PixelData',
+      'RescaleIntercept',
+      'RescaleSlope',
       ]
     }
 
@@ -223,60 +370,68 @@ async function parseDicomFiles(fileList, ignoreFailedFiles = false) {
           return
         }
 
-        if (element.fragments) {
-          console.warn(`${tagName} contains fragments which isn't supported`)
-          return
-        }
+        let value = undefined
 
-        let vr = element.vr
-        if (vr === undefined) {
-          if (tagInfo === undefined || tagInfo.vr === undefined) {
-            console.warn(`${tagName} vr is unknown, skipping`)
+        if (tagName === 'PixelData') {
+          if (element.fragments) {
+            throw new Error('Fragments/encapsulated pixel data is not supported.');
+          } else {
+            value = {
+              buffer: dataSet.byteArray.buffer,
+              offset: element.dataOffset,
+              length: element.length,
+            }
+          }
+        } else {
+          let vr = element.vr
+          if (vr === undefined) {
+            if (tagInfo === undefined || tagInfo.vr === undefined) {
+              console.warn(`${tagName} vr is unknown, skipping`)
+            } else {
+              vr = tagInfo.vr
+            }
           }
-          vr = tagInfo.vr
-        }
 
-        let value = undefined
-        switch (vr) {
-          case 'US':
-            value = dataSet.uint16(tag)
-            break
-          case 'SS':
-            value = dataSet.int16(tag)
-            break
-          case 'UL':
-            value = dataSet.uint32(tag)
-            break
-          case 'US':
-            value = dataSet.int32(tag)
-            break
-          case 'FD':
-            value = dataSet.double(tag)
-            break
-          case 'FL':
-            value = dataSet.float(tag)
-            break
-          case 'AT':
-            value = `(${dataSet.uint16(tag, 0)},${dataSet.uint16(tag, 1)})`
-            break
-          case 'OB':
-          case 'OW':
-          case 'UN':
-          case 'OF':
-          case 'UT':
-            // TODO: binary data? is this correct?
-            if (element.length === 2) {
+          switch (vr) {
+            case 'US':
               value = dataSet.uint16(tag)
-            } else if (element.length === 4) {
+              break
+            case 'SS':
+              value = dataSet.int16(tag)
+              break
+            case 'UL':
               value = dataSet.uint32(tag)
-            } else {
-              // don't store binary data, only meta data
-              return
-            }
-            break
-          default: //string
-            value = dataSet.string(tag)
-            break
+              break
+            case 'US':
+              value = dataSet.int32(tag)
+              break
+            case 'FD':
+              value = dataSet.double(tag)
+              break
+            case 'FL':
+              value = dataSet.float(tag)
+              break
+            case 'AT':
+              value = `(${dataSet.uint16(tag, 0)},${dataSet.uint16(tag, 1)})`
+              break
+            case 'OB':
+            case 'OW':
+            case 'UN':
+            case 'OF':
+            case 'UT':
+              // TODO: binary data? is this correct?
+              if (element.length === 2) {
+                value = dataSet.uint16(tag)
+              } else if (element.length === 4) {
+                value = dataSet.uint32(tag)
+              } else {
+                return
+              }
+              break
+            default: //string
+              value = dataSet.string(tag)
+              break
+          }
         }
 
         metaData[tagName] = value