larvitar 0.18.2 → 1.2.0

package/imaging/imageAnonymization.js

@@ -0,0 +1,161 @@
+/** @module imaging/imageAnonymization
+ *  @desc This file provides anonymization functionalities on DICOM images
+ * following http://dicom.nema.org/medical/dicom/current/output/html/part15.html#chapter_E
+ */
+
+// external libraries
+import aes from "crypto-js/aes";
+import sha256 from "crypto-js/sha256";
+import Hex from "crypto-js/enc-hex";
+import { forEach } from "lodash";
+
+// global vars
+const TAGS = [
+  "x00080014", // Instance Creator UID
+  "x00080018", // SOP Instance UID
+  "x00080050", // Accession Number
+  "x00080080", // Institution Name
+  "x00080081", // Institution Address
+  "x00080081", // Institution Address
+  "x00080090", // Referring Physician's Name
+  "x00080092", // Referring Physician's Address
+  "x00080094", // Referring Physician's Telephone numbers
+  "x00081010", // Station Name
+  "x00081030", // Study Description
+  "x0008103e", // Series Description
+  "x00081040", // Institutional Department name
+  "x00081048", // Physician(s) of Record
+  "x00081050", // Performing Physicians' Name
+  "x00081060", // Name of Physician(s) Reading study
+  "x00081070", // Operator's Name
+  "x00081080", // Admitting Diagnoses Description
+  "x00081155", // Referenced SOP Instance UID
+  "x00082111", // Derivation Description
+  "x00100010", // Patient's Name
+  "x00100020", // Patient ID
+  "x00100030", // Patient's Birth Date
+  "x00100032", // Patient's Birth Time
+  "x00100040", // Patient's Sex
+  "x00101000", // Other Patient Ids
+  "x00101001", // Other Patient Names
+  "x00101010", // Patient's Age
+  "x00101020", // Patient's Size
+  "x00101030", // Patient's Weight
+  "x00101090", // Medical Record Locator
+  "x00102160", // Ethnic Group
+  "x00102180", // Occupation
+  "x001021b0", // Additional Patient's History
+  "x00104000", // Patient Comments
+  "x00181000", // Device Serial Number
+  "x00181030", // Protocol Name
+  "x0020000d", // Study Instance UID
+  "x0020000e", // Series Instance UID
+  "x00200010", // Study ID
+  "x00200052", // Frame of Reference UID
+  "x00200200", // Synchronization Frame of Reference UID
+  "x00204000", // Image Comments
+  "x00400275", // Request Attributes Sequence
+  "x0040a124", // UID
+  "x0040a730", // Content Sequence
+  "x00880140", // Storage Media File-set UID
+  "x30060024", // Referenced Frame of Reference UID
+  "x300600c2" // Related Frame of Reference UID
+];
+
+/*
+ * This module provides the following functions to be exported:
+ * anonymize(series)
+ * encrypt(series, passphrase)
+ */
+
+/**
+ * Anonymize DICOM series' metadata using sha256
+ * @function anonymize
+ * @param {Object} series - Cornerstone series object
+ * @returns {Object} anonymized_series: Cornerstone anonymized series object
+ */
+export const anonymize = function (series) {
+  forEach(series.instances, function (instance) {
+    forEach(TAGS, function (tag) {
+      if (tag in instance.metadata) {
+        let anonymized_value = sha256(instance.metadata[tag]).toString(Hex);
+        instance.metadata[tag] = anonymized_value;
+      }
+    });
+    instance.metadata.seriesUID = instance.metadata["x0020000e"];
+    instance.metadata.instanceUID = instance.metadata["x00080018"];
+    instance.metadata.studyUID = instance.metadata["x0020000d"];
+    instance.metadata.accessionNumber = instance.metadata["x00080050"];
+    instance.metadata.studyDescription = instance.metadata["x00081030"];
+    instance.metadata.patientName = instance.metadata["x00100010"];
+    instance.metadata.patientBirthdate = instance.metadata["x00100030"];
+    instance.metadata.seriesDescription = instance.metadata["x0008103e"];
+  });
+
+  delete series["instanceUIDs"];
+  series.instanceUIDs = {};
+
+  forEach(series.imageIds, function (imageId) {
+    series.instanceUIDs[series.instances[imageId].metadata.instanceUID] =
+      imageId;
+  });
+
+  series.larvitarSeriesInstanceUID = sha256(
+    series.larvitarSeriesInstanceUID
+  ).toString(Hex);
+  series.seriesUID = sha256(series.seriesUID).toString(Hex);
+  series.seriesDescription = sha256(series.seriesDescription).toString(Hex);
+  series.studyUID = sha256(series.studyUID).toString(Hex);
+
+  return series;
+};
+
+/**
+ * Encrypt DICOM series' metadata using AES
+ * @function encrypt
+ * @param {Object} series - Cornerstone series object
+ * @param {String} passphrase - AES passphrase
+ * @returns {Object} anonymized_series: Cornerstone encrypted series object
+ */
+export const encrypt = function (series, passphrase) {
+  if (!passphrase) {
+    return "Error, provide a valid passphrase";
+  }
+  forEach(series.instances, function (instance) {
+    forEach(TAGS, function (tag) {
+      if (tag in instance.metadata) {
+        let anonymized_value = aes
+          .encrypt(instance.metadata[tag], passphrase)
+          .toString();
+        instance.metadata[tag] = anonymized_value;
+      }
+    });
+    instance.metadata.seriesUID = instance.metadata["x0020000e"];
+    instance.metadata.instanceUID = instance.metadata["x00080018"];
+    instance.metadata.studyUID = instance.metadata["x0020000d"];
+    instance.metadata.accessionNumber = instance.metadata["x00080050"];
+    instance.metadata.studyDescription = instance.metadata["x00081030"];
+    instance.metadata.patientName = instance.metadata["x00100010"];
+    instance.metadata.patientBirthdate = instance.metadata["x00100030"];
+    instance.metadata.seriesDescription = instance.metadata["x0008103e"];
+  });
+
+  delete series["instanceUIDs"];
+  series.instanceUIDs = {};
+
+  forEach(series.imageIds, function (imageId) {
+    series.instanceUIDs[series.instances[imageId].metadata.instanceUID] =
+      imageId;
+  });
+
+  series.larvitarSeriesInstanceUID = aes
+    .encrypt(series.larvitarSeriesInstanceUID, passphrase)
+    .toString();
+  series.seriesUID = aes.encrypt(series.seriesUID, passphrase).toString();
+  series.seriesDescription = aes
+    .encrypt(series.seriesDescription, passphrase)
+    .toString();
+  series.studyUID = aes.encrypt(series.studyUID, passphrase).toString();
+
+  return series;
+};

package/imaging/{image_colormaps.js → imageColormaps.js}

@@ -1,6 +1,6 @@
-/** @module imaging/rendering
+/** @module imaging/imageColormaps
  *  @desc  This file provides functionalities for
- *         rendering images in html canvas using cornerstone
+ *         handling colormaps
  */
 
 import cornerstone from "cornerstone-core";

package/imaging/{image_contours.js → imageContours.js}

@@ -1,4 +1,4 @@
-/** @module imaging/contours
+/** @module imaging/imageContours
  *  @desc This file provides functionalities to render a set of points on a canvas.
  *        Use this in order to render image contours (e.g. from binary masks).
  */
@@ -21,7 +21,6 @@ import { each, range } from "lodash";
  * @param {Array} viewports - Viewport array ids
  * @returns {Number} Number of array elements consumed
  */
-
 export const parseContours = function (
   contoursData,
   pointBatchSize,

package/imaging/{image_io.js → imageIo.js}

@@ -1,4 +1,4 @@
-/** @module imaging/io
+/** @module imaging/imageIo
  *  @desc This file provides I/O functionalities on NRRD files and DICOM images
  */
 
@@ -11,8 +11,8 @@ import {
   getMeanValue,
   getDistanceBetweenSlices,
   getTypedArrayFromDataType
-} from "./image_utils.js";
-import { larvitar_store } from "./image_store";
+} from "./imageUtils.js";
+import { larvitar_store } from "./imageStore";
 import { parse } from "./parsers/nrrd";
 import { checkMemoryAllocation } from "./monitors/memory";
 
@@ -71,22 +71,25 @@ export const buildHeader = function (series) {
  * Get cached pixel data
  * @function getCachedPixelData
  * @param {String} imageId - ImageId of the cached image
- * @returns {Array} Pixel data array or null if not cached
+ * @returns {Promise} A promise which will resolve to a pixel data array or fail if an error occurs
  */
 
-export const getCachedPixelData = function (imageId, callback) {
+export const getCachedPixelData = function (imageId) {
   let cachedImage = find(cornerstone.imageCache.cachedImages, [
     "imageId",
     imageId
   ]);
-  if (cachedImage && cachedImage.image) {
-    callback(cachedImage.image.getPixelData());
-  } else {
-    cornerstone.loadAndCacheImage(imageId).then(function (image) {
-      callback(image.getPixelData());
-      cornerstone.imageCache.removeImageLoadObject(imageId);
-    });
-  }
+  let promise = new Promise((resolve, reject) => {
+    if (cachedImage && cachedImage.image) {
+      resolve(cachedImage.image.getPixelData());
+    } else {
+      cornerstone
+        .loadImage(imageId)
+        .then(image => resolve(image.getPixelData()))
+        .catch(err => reject(err));
+    }
+  });
+  return promise;
 };
 
 /**
@@ -122,7 +125,7 @@ export const buildData = function (series, useSeriesData) {
     } else {
       larvitar_store.addSeriesIds(series.seriesUID, series.imageIds);
       forEach(series.imageIds, function (imageId) {
-        getCachedPixelData(imageId, function (sliceData) {
+        getCachedPixelData(imageId).then(sliceData => {
           data.set(sliceData, offsetData);
           offsetData += sliceData.length;
         });
@@ -166,7 +169,7 @@ export const buildDataAsync = function (series, time, resolve, reject) {
     function runFillPixelData(data) {
       let imageId = imageIds.shift();
       if (imageId) {
-        getCachedPixelData(imageId, function (sliceData) {
+        getCachedPixelData(imageId).then(sliceData => {
           data.set(sliceData, offsetData);
           offsetData += sliceData.length;
           // this does the trick: delay next computation to next tick

package/imaging/{image_layers.js → imageLayers.js}

@@ -1,4 +1,4 @@
-/** @module imaging/layers
+/** @module imaging/imageLayers
  *  @desc This file provides functionalities for
  *        rendering image layers using cornerstone stack
  */
@@ -7,7 +7,7 @@
 import cornerstone from "cornerstone-core";
 
 // internal libraries
-import { isElement } from "./image_utils";
+import { isElement } from "./imageUtils";
 
 /*
  * This module provides the following functions to be exported:

package/imaging/{image_loading.js → imageLoading.js}

@@ -1,4 +1,4 @@
-/** @module imaging/loading
+/** @module imaging/imageLoading
  *  @desc This file provides functionalities for
  *        initialize, configure and update WadoImageLoader
  */
@@ -12,8 +12,8 @@ import cornerstoneFileImageLoader from "cornerstone-file-image-loader";
 import { forEach } from "lodash";
 
 // internal libraries
-import { larvitar_store } from "./image_store";
-import { getSortedStack, getSortedUIDs } from "./image_utils";
+import { larvitar_store } from "./imageStore";
+import { getSortedStack, getSortedUIDs } from "./imageUtils";
 import { loadNrrdImage } from "./loaders/nrrdLoader";
 import { loadReslicedImage } from "./loaders/resliceLoader";
 import { loadMultiFrameImage } from "./loaders/multiframeLoader";
@@ -26,16 +26,19 @@ import { loadMultiFrameImage } from "./loaders/multiframeLoader";
  * @property {String} webWorkerPath - path to default WADO web worker
  * @property {} - see https://github.com/cornerstonejs/cornerstoneWADOImageLoader/blob/master/docs/WebWorkers.md
  */
+
 const globalConfig = {
   maxWebWorkers: navigator.hardwareConcurrency || 1,
-  webWorkerPath: "/cornerstoneWADOImageLoaderWebWorker.js",
   startWebWorkersOnDemand: true,
+  webWorkerTaskPaths: [
+    "https://unpkg.com/cornerstone-wado-image-loader@4.1.0/dist/610.bundle.min.worker.js",
+    "https://unpkg.com/cornerstone-wado-image-loader@4.1.0/dist/888.bundle.min.worker.js"
+  ],
   taskConfiguration: {
     decodeTask: {
       loadCodecsOnStartup: true,
       initializeCodecsOnStartup: false,
-      codecsPath: "/cornerstoneWADOImageLoaderCodecs.js",
-      usePDFJS: false
+      strict: true
     }
   }
 };

package/imaging/imageParsing.js

@@ -0,0 +1,301 @@
+/** @module imaging/imageParsing
+ *  @desc  This file provides functionalities for parsing DICOM image files
+ */
+
+// external libraries
+import { parseDicom } from "dicom-parser";
+import { forEach, each, has, pick } from "lodash";
+
+// internal libraries
+import { getPixelRepresentation, randomId, parseTag } from "./imageUtils.js";
+import { updateLoadedStack } from "./imageLoading.js";
+import { checkMemoryAllocation } from "./monitors/memory.js";
+
+// global module variables
+var t0 = null; // t0 variable for timing debugging purpose
+
+/*
+ * This module provides the following functions to be exported:
+ * readFiles(fileList)
+ * readFile(file)
+ * parseDataSet(dataSet, metadata, customFilter)
+ * clearImageParsing(seriesStack)
+ */
+
+/**
+ * Reset series stack object and its internal data
+ * @instance
+ * @function clearImageParsing
+ * @param {Object} seriesStack - Parsed series stack object
+ */
+export const clearImageParsing = function (seriesStack) {
+  each(seriesStack, function (stack) {
+    each(stack.instances, function (instance) {
+      if (instance.dataSet) {
+        instance.dataSet.byteArray = null;
+      }
+      instance.dataSet = null;
+      instance.file = null;
+      instance.metadata = null;
+    });
+  });
+  seriesStack = null;
+};
+
+/**
+ * Read dicom files and return allSeriesStack object
+ * @instance
+ * @function readFiles
+ * @param {Array} entries - List of file objects
+ * @returns {Promise} - Return a promise which will resolve to a image object list or fail if an error occurs
+ */
+export const readFiles = function (entries) {
+  let promise = new Promise((resolve, reject) => {
+    parseFiles(entries).then(resolve).catch(reject);
+  });
+  return promise;
+};
+
+/**
+ * Read a single dicom file and return parsed object
+ * @instance
+ * @function readFile
+ * @param {File} entry - File object
+ * @returns {Promise} - Return a promise which will resolve to a image object or fail if an error occurs
+ */
+export const readFile = function (entry) {
+  let promise = new Promise((resolve, reject) => {
+    parseFile(entry).then(resolve).catch(reject);
+  });
+  return promise;
+};
+
+/* Internal module functions */
+
+/**
+ * Parse metadata from dicom parser dataSet object
+ * @instance
+ * @function parseDataSet
+ * @param {Object} dataSet - dicom parser dataSet object
+ * @param {Array} metadata - Initialized metadata object
+ * @param {Array} customFilter - Optional filter: {tags:[], frameId: 0}
+ */
+// This function iterates through dataSet recursively and adds new HTML strings
+// to the output array passed into it
+export const parseDataSet = function (dataSet, metadata, customFilter) {
+  // customFilter= {tags:[], frameId:xxx}
+  // the dataSet.elements object contains properties for each element parsed.  The name of the property
+  // is based on the elements tag and looks like 'xGGGGEEEE' where GGGG is the group number and EEEE is the
+  // element number both with lowercase hexadecimal letters.  For example, the Series Description DICOM element 0008,103E would
+  // be named 'x0008103e'.  Here we iterate over each property (element) so we can build a string describing its
+  // contents to add to the output array
+  try {
+    let elements =
+      customFilter && has(customFilter, "tags")
+        ? pick(dataSet.elements, customFilter.tags)
+        : dataSet.elements;
+    for (let propertyName in elements) {
+      let element = elements[propertyName];
+      // Here we check for Sequence items and iterate over them if present.  items will not be set in the
+      // element object for elements that don't have SQ VR type.  Note that implicit little endian
+      // sequences will are currently not parsed.
+      if (element.items) {
+        // each item contains its own data set so we iterate over the items
+        // and recursively call this function
+        if (customFilter && has(customFilter, "frameId")) {
+          let item = element.items[customFilter.frameId];
+          parseDataSet(item.dataSet, metadata);
+        } else {
+          element.items.forEach(function (item) {
+            parseDataSet(item.dataSet, metadata);
+          });
+        }
+      } else {
+        let tagValue = parseTag(dataSet, propertyName, element);
+        metadata[propertyName] = tagValue;
+      }
+    }
+  } catch (err) {
+    console.log(err);
+  }
+};
+
+/**
+ * Manage the parsing process waiting for the parsed object before proceeding with the next parse request
+ * @inner
+ * @function parseNextFile
+ * @param {Array} parsingQueue - Array of queued files to be parsed
+ * @param {Object} allSeriesStack - Series stack object to be populated
+ * @param {Function} resolve - Promise resolve function
+ * @param {Function} reject - Promise reject function
+ */
+let parseNextFile = function (parsingQueue, allSeriesStack, resolve, reject) {
+  // initialize t0 on first file of the queue
+  if (
+    Object.keys(allSeriesStack).length === 0 &&
+    allSeriesStack.constructor === Object
+  ) {
+    t0 = performance.now();
+  }
+
+  if (parsingQueue.length === 0) {
+    let t1 = performance.now();
+    console.log(`Call to readFiles took ${t1 - t0} milliseconds.`);
+    resolve(allSeriesStack);
+    return;
+  }
+
+  // remove and return first item from queue
+  let file = parsingQueue.shift();
+
+  // Check if there is enough memory to parse the file
+  if (checkMemoryAllocation(file.size) === false) {
+    // do not parse the file and stop parsing
+    clearImageParsing(allSeriesStack);
+    let t1 = performance.now();
+    console.log(`Call to readFiles took ${t1 - t0} milliseconds.`);
+    file = null;
+    reject(allSeriesStack, "Available memory is not enough");
+    return;
+  } else {
+    // parse the file and wait for results
+    parseFile(file)
+      .then(seriesData => {
+        // add file to cornerstoneWADOImageLoader file manager
+        updateLoadedStack(seriesData, allSeriesStack);
+        // proceed with the next file to parse
+        parseNextFile(parsingQueue, allSeriesStack, resolve, reject);
+        seriesData = null;
+        file = null;
+      })
+      .catch(err => {
+        console.warn(err);
+        parseNextFile(parsingQueue, allSeriesStack, resolve, reject);
+        file = null;
+      });
+  }
+};
+
+/**
+ * Push files in queue and start parsing next file
+ * @inner
+ * @function parseFiles
+ * @param {Array} fileList - Array of file objects
+ * @returns {Promise} - Return a promise which will resolve to a image object list or fail if an error occurs
+ */
+let parseFiles = function (fileList) {
+  let allSeriesStack = {};
+  let parsingQueue = [];
+
+  forEach(fileList, function (file) {
+    if (!file.name.startsWith(".") && !file.name.startsWith("DICOMDIR")) {
+      parsingQueue.push(file);
+    }
+  });
+  return new Promise((resolve, reject) => {
+    parseNextFile(parsingQueue, allSeriesStack, resolve, reject);
+  });
+};
+
+/**
+ * Parse a single DICOM File (metaData and pixelData)
+ * @inner
+ * @function parseFile
+ * @param {File} file - File object to be parsed
+ * @returns {Promise} - Return a promise which will resolve to a image object or fail if an error occurs
+ */
+let parseFile = function (file) {
+  let parsePromise = new Promise((resolve, reject) => {
+    let reader = new FileReader();
+    reader.onload = function () {
+      let arrayBuffer = reader.result;
+      // Here we have the file data as an ArrayBuffer.
+      // dicomParser requires as input a Uint8Array so we create that here.
+      let byteArray = new Uint8Array(arrayBuffer);
+      let dataSet;
+
+      try {
+        dataSet = parseDicom(byteArray);
+        byteArray = null;
+        let metadata = {};
+        parseDataSet(dataSet, metadata);
+
+        let numberOfFrames = metadata["x00280008"];
+        let isMultiframe = numberOfFrames > 1 ? true : false;
+        // Overwrite SOPInstanceUID to manage multiframes.
+        // Usually different SeriesInstanceUID means different series and that value
+        // is used into the application to group different instances into the same series,
+        // but if a DICOM file contains a multiframe series, then the SeriesInstanceUID
+        // can be shared by other files of the same study.
+        // In multiframe cases, the SOPInstanceUID (unique) is used as SeriesInstanceUID.
+        let seriesInstanceUID = isMultiframe
+          ? metadata["x00080018"]
+          : metadata["x0020000e"];
+        let pixelSpacing = metadata["x00280030"];
+        let imageOrientation = metadata["x00200037"];
+        let imagePosition = metadata["x00200032"];
+        let sliceThickness = metadata["x00180050"];
+
+        if (dataSet.warnings.length > 0) {
+          // warnings
+          reject(dataSet.warnings);
+        } else {
+          let pixelDataElement = dataSet.elements.x7fe00010;
+
+          if (pixelDataElement) {
+            // done, pixelDataElement found
+            let instanceUID = metadata["x00080018"] || randomId();
+            let imageObject = {
+              // data needed for rendering
+              file: file,
+              dataSet: dataSet
+            };
+            imageObject.metadata = metadata;
+            imageObject.metadata.seriesUID = seriesInstanceUID;
+            imageObject.metadata.instanceUID = instanceUID;
+            imageObject.metadata.studyUID = metadata["x0020000d"];
+            imageObject.metadata.accessionNumber = metadata["x00080050"];
+            imageObject.metadata.studyDescription = metadata["x00081030"];
+            imageObject.metadata.patientName = metadata["x00100010"];
+            imageObject.metadata.patientBirthdate = metadata["x00100030"];
+            imageObject.metadata.seriesDescription = metadata["x0008103e"];
+            imageObject.metadata.seriesDate = metadata["x00080021"];
+            imageObject.metadata.seriesModality =
+              metadata["x00080060"].toLowerCase();
+            imageObject.metadata.intercept = metadata["x00281052"];
+            imageObject.metadata.slope = metadata["x00281053"];
+            imageObject.metadata.pixelSpacing = pixelSpacing;
+            imageObject.metadata.sliceThickness = sliceThickness;
+            imageObject.metadata.imageOrientation = imageOrientation;
+            imageObject.metadata.imagePosition = imagePosition;
+            imageObject.metadata.rows = metadata["x00280010"];
+            imageObject.metadata.cols = metadata["x00280011"];
+            imageObject.metadata.numberOfSlices = metadata["x00540081"]
+              ? metadata["x00540081"] // number of slices
+              : metadata["x00201002"]; // number of instances
+            imageObject.metadata.numberOfFrames = numberOfFrames;
+            if (isMultiframe) {
+              imageObject.metadata.frameTime = metadata["x00181063"];
+              imageObject.metadata.frameDelay = metadata["x00181066"];
+            }
+            imageObject.metadata.windowCenter = metadata["x00281050"];
+            imageObject.metadata.windowWidth = metadata["x00281051"];
+            imageObject.metadata.minPixelValue = metadata["x00280106"];
+            imageObject.metadata.maxPixelValue = metadata["x00280107"];
+            imageObject.metadata.length = pixelDataElement.length;
+            imageObject.metadata.repr = getPixelRepresentation(dataSet);
+            resolve(imageObject);
+          } else {
+            // done, no pixelData
+            reject("no pixelData");
+          }
+        }
+      } catch (err) {
+        console.error(err);
+        reject("can not read this file");
+      }
+    };
+    reader.readAsArrayBuffer(file);
+  });
+  return parsePromise;
+};

package/imaging/{image_presets.js → imagePresets.js}

@@ -1,4 +1,4 @@
-/** @module imaging/presets
+/** @module imaging/imagePresets
  *  @desc  This file provides functionalities for
  *         image presets for ww and wc
  */
@@ -8,7 +8,7 @@ import cornerstone from "cornerstone-core";
 import { each, find } from "lodash";
 
 // internal libraries
-import { larvitar_store } from "./image_store";
+import { larvitar_store } from "./imageStore";
 
 /**
  * Object used to list image presets