larvitar 1.5.14 → 2.0.2

package/imaging/{imageAnonymization.js → imageAnonymization.ts}

@@ -7,6 +7,7 @@
 import sha256 from "crypto-js/sha256";
 import Hex from "crypto-js/enc-hex";
 import { forEach } from "lodash";
+import { Instance, MetaData, Series } from "./types";
 
 const SH = [
   "x00080050" // Accession Number,
@@ -111,43 +112,70 @@ const TAGS = [
  * @param {Object} series - Cornerstone series object
  * @returns {Object} anonymized_series: Cornerstone anonymized series object
  */
-export const anonymize = function (series) {
-  forEach(series.instances, function (instance) {
+export const anonymize = function (series: Series) {
+  forEach(series.instances, function (instance: Instance) {
     forEach(TAGS, function (tag) {
       if (tag in instance.metadata) {
-        let anonymized_value = sha256(instance.metadata[tag]).toString(Hex);
+        let tag_meta = tag as keyof MetaData;
+
+        let anonymized_value = sha256(
+          (instance.metadata[tag_meta] || "").toString()
+        ).toString(Hex);
+
         // Patient Tag Anonymization
-        if (tag === "x00100010") {
-          instance.metadata[tag] =
+        if (tag_meta === "x00100010") {
+          instance.metadata[tag_meta] =
             "Anonymized^" + anonymized_value.substring(0, 6);
         }
         // Short string
-        else if (SH.includes(tag) === true) {
-          instance.metadata[tag] = anonymized_value.substring(0, 16);
+        else if (tag_meta === "x00080050") {
+          instance.metadata[tag_meta] = anonymized_value.substring(0, 16);
         }
         // Required, empty if unknown
-        else if (OPTIONAL.includes(tag) === true) {
-          instance.metadata[tag] = "";
+        /*else if (OPTIONAL.includes(tag) === true) {
+          tag_meta = tag as keyof MetaData;
+          instance.metadata[tag_meta] = "";
+        }*/
+        else if (tag_meta === "x00100030") {
+          instance.metadata[tag_meta] = "";
+        } else if (tag_meta === "x00080090") {
+          instance.metadata[tag_meta] = "";
+        } else if (tag_meta === "x00100020") {
+          instance.metadata[tag_meta] = "";
+        } else if (tag_meta === "x00100040") {
+          instance.metadata[tag_meta] = "";
+        } else if (tag_meta === "x00200010") {
+          instance.metadata[tag_meta] = "";
         }
         // Optional
         else if (REMOVE.includes(tag) === true) {
-          delete instance.metadata[tag];
+          //tag_meta = tag as keyof MetaData;
+          delete instance.metadata[tag_meta];
         }
         // Default sha256
         else {
-          instance.metadata[tag] = anonymized_value;
+          tag_meta = tag as keyof MetaData;
+          if (instance.metadata[tag_meta] === "string") {
+            instance.metadata[tag_meta] = anonymized_value as any;
+          }
+          //TODO-ts: check if this case has to be applied only on strings
+          //or also on numbers and if any type could be correct to force solution
+          //or find another solution
         }
       }
     });
+
     instance.metadata["x00120062"] = "YES"; // Patient Identity Removed Attribute
     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.patientName = instance.metadata["x00100010"] as string;
     instance.metadata.patientBirthdate = instance.metadata["x00100030"];
-    instance.metadata.seriesDescription = instance.metadata["x0008103e"];
+    instance.metadata.seriesDescription = instance.metadata[
+      "x0008103e"
+    ] as string;
     instance.metadata.anonymized = true;
   });
 

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

@@ -4,6 +4,7 @@
  */
 
 import cornerstone from "cornerstone-core";
+import { EnabledElementLayer } from "cornerstone-core";
 import { each } from "lodash";
 
 /*
@@ -33,8 +34,12 @@ export function getColormapsList() {
  * @param {String} colormapName - the new colormap name
  * @param {Array} colors - array containing 255 rgb colors (ie [[r,g,b], [r,g,b], ...])
  */
-export function addColorMap(colormapId, colormapName, colors) {
-  const colormap = cornerstone.colors.getColormap(colormapId);
+export function addColorMap(
+  colormapId: string,
+  colormapName: string,
+  colors: Array<Array<number>>
+) {
+  const colormap = cornerstone.colors.getColormap(colormapId, null);
   colormap.setColorSchemeName(colormapName);
   let noc = colors.length;
   colormap.setNumberOfColors(noc);
@@ -54,31 +59,35 @@ export function addColorMap(colormapId, colormapName, colors) {
  * @param {HTMLCanvasElement} canvas - target canvas
  * @param {String} colormapId - the colormap name
  */
-export function fillPixelData(canvas, colormapId) {
+export function fillPixelData(canvas: HTMLCanvasElement, colormapId: string) {
   const ctx = canvas.getContext("2d");
   const height = canvas.height;
   const width = canvas.width;
-  const colorbar = ctx.createImageData(width, height);
-
-  const colormap = cornerstone.colors.getColormap(colormapId);
-  const lookupTable = colormap.createLookupTable();
-  // Set the min and max values then the lookup table
-  // will be able to return the right color for this range
-  lookupTable.setTableRange(0, width);
-
-  // Update the colorbar pixel by pixel
-  for (let col = 0; col < width; col++) {
-    const color = lookupTable.mapValue(col);
-
-    for (let row = 0; row < height; row++) {
-      const pixel = (col + row * width) * 4;
-      colorbar.data[pixel] = color[0];
-      colorbar.data[pixel + 1] = color[1];
-      colorbar.data[pixel + 2] = color[2];
-      colorbar.data[pixel + 3] = color[3];
+  if (ctx) {
+    const colorbar = ctx.createImageData(width, height);
+    const colormap = cornerstone.colors.getColormap(colormapId, {});
+    const lookupTable = colormap.createLookupTable();
+
+    // Set the min and max values then the lookup table
+    // will be able to return the right color for this range
+    lookupTable.setTableRange(0, width);
+
+    // Update the colorbar pixel by pixel
+    for (let col = 0; col < width; col++) {
+      const color = lookupTable.mapValue(col);
+
+      for (let row = 0; row < height; row++) {
+        const pixel = (col + row * width) * 4;
+        colorbar.data[pixel] = color[0];
+        colorbar.data[pixel + 1] = color[1];
+        colorbar.data[pixel + 2] = color[2];
+        colorbar.data[pixel + 3] = color[3];
+      }
     }
+    ctx.putImageData(colorbar, 0, 0);
+  } else {
+    console.error("No context found for canvas", canvas);
   }
-  ctx.putImageData(colorbar, 0, 0);
 }
 
 /**
@@ -88,21 +97,30 @@ export function fillPixelData(canvas, colormapId) {
  * @param {String} colormapId - the colormap name
  * @param {Array} viewportNames - List of viewports where to apply preset
  */
-export function applyColorMap(colormapId, viewportNames) {
+export function applyColorMap(
+  colormapId: string,
+  viewportNames?: Array<string>
+) {
   // for retro-compatibility
   if (!viewportNames) {
     viewportNames = cornerstone.getEnabledElements().map(e => e.element.id);
   }
-  let colormap = cornerstone.colors.getColormap(colormapId);
+  let colormap = cornerstone.colors.getColormap(colormapId, {});
 
   each(viewportNames, viewportName => {
     let element = document.getElementById(viewportName);
-    let enabledElement;
+
+    if (!element) {
+      console.error("No element with id:", viewportName);
+      return;
+    }
+
+    let enabledElement: EnabledElementLayer;
 
     try {
       enabledElement = cornerstone.getEnabledElement(element);
     } catch {
-      console.warn("No enabledElement with id", viewportName);
+      console.error("No enabledElement with id", viewportName);
       return;
     }
 
@@ -125,11 +143,11 @@ export function applyColorMap(colormapId, viewportNames) {
 /**
  * Converts an HSV  (Hue, Saturation, Value) color to RGB (Red, Green, Blue) color value
  * @param {Number} hue A number representing the hue color value
- * @param {any} sat A number representing the saturation color value
- * @param {any} val A number representing the value color value
- * @returns {Numberp[]} An RGB color array
+ * @param {Number} sat A number representing the saturation color value
+ * @param {Number} val A number representing the value color value
+ * @returns {Number[]} An RGB color array
  */
-export function HSVToRGB(hue, sat, val) {
+export function HSVToRGB(hue: number, sat: number, val: number) {
   if (hue > 1) {
     throw new Error("HSVToRGB expects hue < 1");
   }

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

@@ -5,6 +5,8 @@
 
 // external libraries
 import { each, range } from "lodash";
+import { vec2 } from "cornerstone-core";
+import { Contours } from "./types";
 
 /*
  * This module provides the following functions to be exported:
@@ -22,15 +24,15 @@ import { each, range } from "lodash";
  * @returns {Number} Number of array elements consumed
  */
 export const parseContours = function (
-  contoursData,
-  pointBatchSize,
-  segmentationName,
-  viewports
+  contoursData: { [key: string]: Uint8Array }, // TODO-ts: check if this is correct @mronzoni
+  pointBatchSize: number,
+  segmentationName: string,
+  viewports: Array<string>
 ) {
-  let contours = {};
+  let contours: Contours = {};
   each(viewports, viewport => {
-    contour[viewport] = {};
-    contour[viewport][segmentationName] = [];
+    contours[viewport] = {};
+    contours[viewport][segmentationName] = [];
     let points = contoursData[viewport];
 
     if (!points) {
@@ -70,15 +72,15 @@ export const parseContours = function (
  * @param {Array} data - Raw data (array of pixel values)
  */
 const populateContoursObject = function (
-  pointBatchSize,
-  contours,
-  lineNumber,
-  sliceNumber,
-  segmentationName,
-  viewport,
-  data
+  pointBatchSize: number,
+  contours: Contours,
+  lineNumber: number,
+  sliceNumber: number,
+  segmentationName: string,
+  viewport: string,
+  data: Uint8Array
 ) {
-  let coords = [];
+  let coords: Array<{ x: number; y: number; lines: Array<vec2> }> = [];
 
   for (let i = 0; i < data.length; i += pointBatchSize) {
     let xy = data.slice(i, pointBatchSize + i);
@@ -134,11 +136,11 @@ const populateContoursObject = function (
  * @returns {Number} Number of array elements consumed
  */
 const extractSlicePoints = function (
-  contours,
-  pointBatchSize,
-  slicePoints,
-  segmentationName,
-  viewport
+  contours: Contours,
+  pointBatchSize: number,
+  slicePoints: Uint8Array, // TODO-ts: check if this is correct @mronzoni
+  segmentationName: string,
+  viewport: string
 ) {
   // read slice number and number of lines for current slice, then remove from array
   let sliceNumber = slicePoints[0];
@@ -152,12 +154,12 @@ const extractSlicePoints = function (
 
   let numberOfPoints = 0;
   contours[viewport][segmentationName][sliceNumber] = {
-    lines: []
+    lines: [] as vec2[][]
   };
 
   if (numberOfLines) {
     // for each line
-    each(range(numberOfLines), function (l) {
+    each(range(numberOfLines), function (l: number) {
       // get number of points for current line
       let numberOfPointsPerLine = slicePoints[0];
       // compute coordinates size

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

@@ -11,10 +11,11 @@ import {
   getMeanValue,
   getDistanceBetweenSlices,
   getTypedArrayFromDataType
-} from "./imageUtils.js";
-import { larvitar_store } from "./imageStore";
+} from "./imageUtils";
+import store from "./imageStore";
 import { parse } from "./parsers/nrrd";
 import { checkMemoryAllocation } from "./monitors/memory";
+import { Series, Header, Volume, TypedArray } from "./types";
 
 /*
  * This module provides the following functions to be exported:
@@ -30,41 +31,50 @@ import { checkMemoryAllocation } from "./monitors/memory";
  * @param {Object} series - Cornerstone series object
  * @returns {Object} header: image metadata
  */
-export const buildHeader = function (series) {
-  let header = {};
-  header.volume = {};
-  header.volume.imageIds = series.imageIds;
-  header.volume.seriesId =
-    series.instances[series.imageIds[0]].metadata.seriesUID;
-  header.volume.rows =
+export const buildHeader = function (series: Series) {
+  let header: Partial<Header> = {};
+
+  forEach(series.imageIds, function (imageId: string) {
+    header[imageId] = series.instances[imageId].metadata;
+  });
+
+  let volume: Partial<Volume> = {};
+
+  volume.imageIds = series.imageIds;
+  volume.seriesId = series.instances[series.imageIds[0]].metadata.seriesUID;
+  volume.rows =
     series.instances[series.imageIds[0]].metadata.rows ||
     series.instances[series.imageIds[0]].metadata.x00280010;
-  header.volume.cols =
+  volume.cols =
     series.instances[series.imageIds[0]].metadata.cols ||
     series.instances[series.imageIds[0]].metadata.x00280011;
-  header.volume.slope = series.instances[series.imageIds[0]].metadata.slope;
-  header.volume.repr = series.instances[series.imageIds[0]].metadata.repr;
-  header.volume.intercept =
-    series.instances[series.imageIds[0]].metadata.intercept;
-  header.volume.imagePosition =
-    series.instances[series.imageIds[0]].metadata.imagePosition;
-  header.volume.numberOfSlices = series.imageIds.length;
-
-  header.volume.imageOrientation = getMeanValue(
+  volume.slope = series.instances[series.imageIds[0]].metadata.slope as number;
+  volume.repr = series.instances[series.imageIds[0]].metadata.repr as string;
+  volume.intercept = series.instances[series.imageIds[0]].metadata
+    .intercept as number;
+  volume.imagePosition = series.instances[series.imageIds[0]].metadata
+    .imagePosition as [number, number];
+  volume.numberOfSlices = series.imageIds.length;
+
+  // @ts-ignore
+  volume.imageOrientation = getMeanValue(
     series,
     "imageOrientation",
     true
-  );
+  ) as number[];
 
-  header.volume.pixelSpacing = getMeanValue(series, "pixelSpacing", true);
-  // header.volume.maxPixelValue = getMeanValue(series, "maxPixelValue", false);
-  // header.volume.minPixelValue = getMeanValue(series, "minPixelValue", false);
-  header.volume.sliceThickness = getDistanceBetweenSlices(series, 0, 1);
+  // @ts-ignore
+  volume.pixelSpacing = getMeanValue(series, "pixelSpacing", true) as [
+    number,
+    number
+  ];
+  // volume.maxPixelValue = getMeanValue(series, "maxPixelValue", false);
+  // volume.minPixelValue = getMeanValue(series, "minPixelValue", false);
+  volume.sliceThickness = getDistanceBetweenSlices(series, 0, 1);
 
-  forEach(series.imageIds, function (imageId) {
-    header[imageId] = series.instances[imageId].metadata;
-  });
-  return header;
+  header.volume = volume as Volume;
+
+  return header as Header;
 };
 
 /**
@@ -74,12 +84,12 @@ export const buildHeader = function (series) {
  * @returns {Promise} A promise which will resolve to a pixel data array or fail if an error occurs
  */
 
-export const getCachedPixelData = function (imageId) {
+export const getCachedPixelData = function (imageId: string) {
   let cachedImage = find(cornerstone.imageCache.cachedImages, [
     "imageId",
     imageId
   ]);
-  let promise = new Promise((resolve, reject) => {
+  let promise = new Promise<number[]>((resolve, reject) => {
     if (cachedImage && cachedImage.image) {
       resolve(cachedImage.image.getPixelData());
     } else {
@@ -99,37 +109,48 @@ export const getCachedPixelData = function (imageId) {
  * @param {Bool} useSeriesData - Flag to force using "series" data instead of cached ones
  * @returns {Array} Contiguous pixel array
  */
-export const buildData = function (series, useSeriesData) {
+export const buildData = function (series: Series, useSeriesData: boolean) {
   if (checkMemoryAllocation(series.bytes)) {
     let t0 = performance.now();
     let repr = series.instances[series.imageIds[0]].metadata.repr;
     let rows =
-      series.instances[series.imageIds[0]].metadata.rows ||
-      series.instances[series.imageIds[0]].metadata.x00280010;
+      (series.instances[series.imageIds[0]].metadata.rows as number) ||
+      (series.instances[series.imageIds[0]].metadata.x00280010 as number);
     let cols =
-      series.instances[series.imageIds[0]].metadata.cols ||
-      series.instances[series.imageIds[0]].metadata.x00280011;
+      (series.instances[series.imageIds[0]].metadata.cols as number) ||
+      (series.instances[series.imageIds[0]].metadata.x00280011 as number);
     let len = rows * cols * series.imageIds.length;
 
-    let typedArray = getTypedArrayFromDataType(repr);
+    if (!repr) {
+      throw new Error("Image representation metadata not found");
+    }
+
+    let typedArray = getTypedArrayFromDataType(repr as string);
+
+    if (!typedArray) {
+      throw new Error("Image representation not supported");
+    }
+
     let data = new typedArray(len);
     let offsetData = 0;
 
     // use input data or cached data
     if (useSeriesData) {
-      forEach(series.imageIds, function (imageId) {
+      forEach(series.imageIds, function (imageId: string) {
         const sliceData = series.instances[imageId].pixelData;
-        data.set(sliceData, offsetData);
-        offsetData += sliceData.length;
+        if (sliceData) {
+          data.set(sliceData, offsetData);
+          offsetData += sliceData.length;
+        }
       });
       let t1 = performance.now();
       console.log(`Call to buildData took ${t1 - t0} milliseconds.`);
       return data;
     } else {
-      larvitar_store.addSeriesIds(series.seriesUID, series.imageIds);
+      store.addSeriesId(series.seriesUID, series.imageIds);
       let image_counter = 0;
-      forEach(series.imageIds, function (imageId) {
-        getCachedPixelData(imageId).then(sliceData => {
+      forEach(series.imageIds, function (imageId: string) {
+        getCachedPixelData(imageId).then((sliceData: number[]) => {
           data.set(sliceData, offsetData);
           offsetData += sliceData.length;
           image_counter += 1;
@@ -154,26 +175,42 @@ export const buildData = function (series, useSeriesData) {
  * @param {Function} resolve - Promise resolve function
  * @param {Function} reject - Promise reject function
  */
-export const buildDataAsync = function (series, time, resolve, reject) {
+export const buildDataAsync = function (
+  series: Series,
+  time: number,
+  resolve: (response: TypedArray) => void,
+  reject: (response: string) => void
+) {
   const memoryAllocation = checkMemoryAllocation(series.bytes);
+
   if (memoryAllocation) {
     let t0 = performance.now();
     let repr = series.instances[series.imageIds[0]].metadata.repr;
     let rows =
-      series.instances[series.imageIds[0]].metadata.rows ||
-      series.instances[series.imageIds[0]].metadata.x00280010;
+      (series.instances[series.imageIds[0]].metadata.rows as number) ||
+      (series.instances[series.imageIds[0]].metadata.x00280010 as number);
     let cols =
-      series.instances[series.imageIds[0]].metadata.cols ||
-      series.instances[series.imageIds[0]].metadata.x00280011;
+      (series.instances[series.imageIds[0]].metadata.cols as number) ||
+      (series.instances[series.imageIds[0]].metadata.x00280011 as number);
     let len = rows * cols * series.imageIds.length;
-    let typedArray = getTypedArrayFromDataType(repr);
+
+    if (!repr) {
+      throw new Error("Image representation metadata not found");
+    }
+
+    let typedArray = getTypedArrayFromDataType(repr as string);
+
+    if (!typedArray) {
+      throw new Error("Image representation not supported");
+    }
+
     let data = new typedArray(len);
     let offsetData = 0;
 
     let imageIds = series.imageIds.slice();
-    larvitar_store.addSeriesIds(series.seriesUID, series.imageIds);
+    store.addSeriesId(series.seriesUID, series.imageIds);
 
-    function runFillPixelData(data) {
+    function runFillPixelData(data: TypedArray) {
       let imageId = imageIds.shift();
       if (imageId) {
         getCachedPixelData(imageId).then(sliceData => {
@@ -207,8 +244,8 @@ export const buildDataAsync = function (series, time, resolve, reject) {
  * @param {ArrayBuffer} bufferArray - buffer array from nrrd file
  * @returns {Array} Parsed pixel data array
  */
-export const importNRRDImage = function (bufferArray) {
+export const importNRRDImage = function (bufferArray: ArrayBuffer) {
   // get the data
-  let volume = parse(bufferArray, {});
+  let volume = parse(bufferArray, { headerOnly: false });
   return volume;
 };

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

@@ -8,6 +8,7 @@ import cornerstone from "cornerstone-core";
 
 // internal libraries
 import { isElement } from "./imageUtils";
+import { Series } from "./types";
 
 /*
  * This module provides the following functions to be exported:
@@ -25,17 +26,20 @@ import { isElement } from "./imageUtils";
  * @param {Object} options - layer options {opacity:float, colormap: str}
  * @returns {Object} Cornerstone layer object
  */
-export const buildLayer = function (series, tag, options) {
-  let layerOptions = options ? options : {};
+export const buildLayer = function (
+  series: Series,
+  tag: string,
+  options: { opacity: number; colormap: string }
+) {
   let layer = {
     imageIds: series.imageIds,
     currentImageIdIndex: Math.floor(series.imageIds.length / 2),
     options: {
       name: tag,
-      opacity: layerOptions.opacity ? layerOptions.opacity : 1.0,
+      opacity: options?.opacity ? options?.opacity : 1.0,
       visible: true,
       viewport: {
-        colormap: layerOptions.colormap ? layerOptions.colormap : "gray"
+        colormap: options?.colormap ? options?.colormap : "gray"
       }
     }
   };
@@ -47,18 +51,28 @@ export const buildLayer = function (series, tag, options) {
  * @instance
  * @function updateLayer
  * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
- * @param {Object} layer - The cornestone object layer
+ * @param {string} layer - The layer id
  * @param {Object} options - The new layer's options
  */
-export const updateLayer = function (elementId, layerId, options) {
+export const updateLayer = function (
+  elementId: string | HTMLElement,
+  layerId: string,
+  options: { opacity: number; colormap: string }
+) {
   let element = isElement(elementId)
-    ? elementId
-    : document.getElementById(elementId);
+    ? (elementId as HTMLElement)
+    : document.getElementById(elementId as string);
   if (!element) {
     console.log("not element");
     return;
   }
   let layer = cornerstone.getLayer(element, layerId);
+  if (!layer.options) {
+    layer["options"] = {};
+  }
+  if (!layer.viewport) {
+    layer["viewport"] = {};
+  }
   layer.options.opacity =
     options.opacity != null ? options.opacity : layer.options.opacity;
   layer.viewport.colormap = options.colormap
@@ -74,10 +88,10 @@ export const updateLayer = function (elementId, layerId, options) {
  * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
  * @returns {Object} layer - The active layer object
  */
-export const getActiveLayer = function (elementId) {
+export const getActiveLayer = function (elementId: string | HTMLElement) {
   let element = isElement(elementId)
-    ? elementId
-    : document.getElementById(elementId);
+    ? (elementId as HTMLElement)
+    : document.getElementById(elementId as string);
   if (!element) {
     console.log("not element");
     return;
@@ -92,10 +106,13 @@ export const getActiveLayer = function (elementId) {
  * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
  * @param {String} layerId - The id of the layer
  */
-export const setActiveLayer = function (elementId, layerId) {
+export const setActiveLayer = function (
+  elementId: string | HTMLElement,
+  layerId: string
+) {
   let element = isElement(elementId)
-    ? elementId
-    : document.getElementById(elementId);
+    ? (elementId as HTMLElement)
+    : document.getElementById(elementId as string);
   if (!element) {
     console.log("not element");
     return;