larvitar 2.0.4 → 2.0.6

package/imaging/imageAnonymization.ts

@@ -1,135 +0,0 @@
-/** @module imaging/imageAnonymization
- *  @desc This file provides anonymization functionalities on DICOM images
- */
-
-// internal libraries
-import { MetaDataTypes } from "./MetaDataTypes";
-import { MetaData, Series } from "./types";
-
-/*
- * This module provides the following functions to be exported:
- * anonymize(series: Series): Series
- */
-
-/**
- * Anonymize a series by replacing all metadata with random values
- * @function anonymize
- * @param {Series} series - series to anonymize
- * @returns {Series} anonymized series
- */
-export const anonymize = function (series: Series): Series {
-  // anonymize series bytearray
-  for (const id in series.imageIds) {
-    const imageId = series.imageIds[id];
-    let image = series.instances[imageId];
-    if (image.dataSet) {
-      for (const tag in image.dataSet.elements) {
-        let element = image.dataSet.elements[tag];
-        let text = "";
-        const vr = element.vr;
-        if (element !== undefined) {
-          let str = image.dataSet.string(tag);
-          if (str !== undefined) {
-            text = str;
-          }
-        }
-        if (vr) {
-          const deIdentifiedValue = makeDeIdentifiedValue(text.length, vr);
-          if (deIdentifiedValue !== undefined) {
-            for (let i: number = 0; i < element.length; i++) {
-              const char =
-                deIdentifiedValue.length > i
-                  ? deIdentifiedValue.charCodeAt(i)
-                  : 32;
-              image.dataSet.byteArray[element.dataOffset + i] = char;
-            }
-            // @ts-ignore always string
-            image.metadata[tag] = deIdentifiedValue;
-          }
-        }
-      }
-      image.metadata.seriesUID = image.metadata["x0020000e"];
-      image.metadata.instanceUID = image.metadata["x00080018"];
-      image.metadata.studyUID = image.metadata["x0020000d"];
-      image.metadata.accessionNumber = image.metadata["x00080050"];
-      image.metadata.studyDescription = image.metadata["x00081030"];
-      image.metadata.patientName = image.metadata["x00100010"] as string;
-      image.metadata.patientBirthdate = image.metadata["x00100030"];
-      image.metadata.seriesDescription = image.metadata["x0008103e"] as string;
-      image.metadata.anonymized = true;
-    } else {
-      console.warn(`No dataset found for image ${imageId}`);
-    }
-  }
-
-  // update parsed metadata
-  series.anonymized = true;
-  series.seriesDescription = series.instances[series.imageIds[0]].metadata[
-    "x0008103e"
-  ] as string;
-
-  return series;
-};
-
-// Internal functions
-
-/**
- * Generate a random string of a given length
- * @function makeRandomString
- * @param {number} length - length of the string to generate
- * @returns {string} random string
- */
-const makeRandomString = function (length: number): string {
-  let text: string = "";
-  const possible: string =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  for (let i: number = 0; i < length; i++) {
-    text += possible.charAt(Math.floor(Math.random() * possible.length));
-  }
-  return text;
-};
-
-/**
- * Pad a number with 0s to a given size
- * @function pad
- * @param {number} num - number to pad
- * @param {number} size - size of the padded number
- * @returns {string} padded number
- */
-const pad = function (num: number, size: number): string {
-  var s: string = num + "";
-  while (s.length < size) s = "0" + s;
-  return s;
-};
-
-/**
- * Make a de-identified value for a given length and VR
- * @function makeDeIdentifiedValue
- * @param {number} length - length of the value to generate
- * @param {string} vr - VR of the value to generate
- * @returns {string} de-identified value
- */
-const makeDeIdentifiedValue = function (
-  length: number,
-  vr: string
-): string | undefined {
-  if (vr === "LO" || vr === "SH" || vr === "PN") {
-    return makeRandomString(length);
-  } else if (vr === "DA") {
-    let oldDate = new Date(1900, 0, 1);
-    return (
-      oldDate.getFullYear() +
-      pad(oldDate.getMonth() + 1, 2) +
-      pad(oldDate.getDate(), 2)
-    );
-  } else if (vr === "TM") {
-    var now = new Date();
-    return (
-      pad(now.getHours(), 2) +
-      pad(now.getMinutes(), 2) +
-      pad(now.getSeconds(), 2)
-    );
-  } else {
-    return undefined;
-  }
-};

package/imaging/imageColormaps.ts

@@ -1,217 +0,0 @@
-/** @module imaging/imageColormaps
- *  @desc  This file provides functionalities for
- *         handling colormaps
- */
-
-import cornerstone from "cornerstone-core";
-import { EnabledElementLayer } from "cornerstone-core";
-import { each } from "lodash";
-
-/*
- * This module provides the following functions to be exported:
- * getColormapsList()
- * addColorMap(colormapId, colormapName, colors)
- * fillPixelData(canvas, colormapId)
- * applyColorMap(colormapId)
- * HSVToRGB(hue, sat, val)
- */
-
-/**
- * Fill a canvas with pixelData representing the colormap
- * @instance
- * @function getColormapsList
- * @returns {Array} A list of cornerstone colormaps
- */
-export function getColormapsList() {
-  return cornerstone.colors.getColormapsList();
-}
-
-/**
- * Add a custom color map to cornerstone list
- * @instance
- * @function addColorMap
- * @param {String} colormapId - the new colormap id
- * @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: string,
-  colormapName: string,
-  colors: Array<Array<number>>
-) {
-  const colormap = cornerstone.colors.getColormap(colormapId, null);
-  colormap.setColorSchemeName(colormapName);
-  let noc = colors.length;
-  colormap.setNumberOfColors(noc);
-
-  for (let i = 0; i < noc; i++) {
-    let rgb = colors[i];
-    colormap.insertColor(i, rgb);
-  }
-
-  return colormap;
-}
-
-/**
- * Fill a canvas with pixelData representing the colormap
- * @instance
- * @function fillPixelData
- * @param {HTMLCanvasElement} canvas - target canvas
- * @param {String} colormapId - the colormap name
- */
-export function fillPixelData(canvas: HTMLCanvasElement, colormapId: string) {
-  const ctx = canvas.getContext("2d");
-  const height = canvas.height;
-  const width = canvas.width;
-  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);
-  }
-}
-
-/**
- * Apply a color map on a viewport
- * @instance
- * @function applyColorMap
- * @param {String} colormapId - the colormap name
- * @param {Array} viewportNames - List of viewports where to apply preset
- */
-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, {});
-
-  each(viewportNames, viewportName => {
-    let element = document.getElementById(viewportName);
-
-    if (!element) {
-      console.error("No element with id:", viewportName);
-      return;
-    }
-
-    let enabledElement: EnabledElementLayer;
-
-    try {
-      enabledElement = cornerstone.getEnabledElement(element);
-    } catch {
-      console.error("No enabledElement with id", viewportName);
-      return;
-    }
-
-    enabledElement.options = {}; // HACK to bypass cornerstone bug
-
-    if (!enabledElement) {
-    }
-
-    const viewport = cornerstone.getViewport(element);
-    if (viewport) {
-      viewport.colormap = colormap;
-      cornerstone.setViewport(element, viewport);
-      cornerstone.updateImage(element, true);
-    }
-  });
-
-  return colormap;
-}
-
-/**
- * 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 {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: number, sat: number, val: number) {
-  if (hue > 1) {
-    throw new Error("HSVToRGB expects hue < 1");
-  }
-
-  const rgb = [];
-
-  if (sat === 0) {
-    rgb[0] = val;
-    rgb[1] = val;
-    rgb[2] = val;
-
-    return rgb;
-  }
-
-  const hueCase = Math.floor(hue * 6);
-  const frac = 6 * hue - hueCase;
-  const lx = val * (1 - sat);
-  const ly = val * (1 - sat * frac);
-  const lz = val * (1 - sat * (1 - frac));
-
-  switch (hueCase) {
-    /* 0<hue<1/6 */
-    case 0:
-    case 6:
-      rgb[0] = val;
-      rgb[1] = lz;
-      rgb[2] = lx;
-      break;
-
-    /* 1/6<hue<2/6 */
-    case 1:
-      rgb[0] = ly;
-      rgb[1] = val;
-      rgb[2] = lx;
-      break;
-
-    /* 2/6<hue<3/6 */
-    case 2:
-      rgb[0] = lx;
-      rgb[1] = val;
-      rgb[2] = lz;
-      break;
-
-    /* 3/6<hue/4/6 */
-    case 3:
-      rgb[0] = lx;
-      rgb[1] = ly;
-      rgb[2] = val;
-      break;
-
-    /* 4/6<hue<5/6 */
-    case 4:
-      rgb[0] = lz;
-      rgb[1] = lx;
-      rgb[2] = val;
-      break;
-
-    /* 5/6<hue<1 */
-    case 5:
-      rgb[0] = val;
-      rgb[1] = lx;
-      rgb[2] = ly;
-      break;
-  }
-
-  return rgb;
-}

package/imaging/imageContours.ts

@@ -1,196 +0,0 @@
-/** @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).
- */
-
-// 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:
- * parseContours(contoursData,pointBatchSize,segmentationName, viewports)
- */
-
-/**
- * Parse raw data to contours object for each viewport
- * @export
- * @function parseContours
- * @param {Array} contoursData - Raw data
- * @param {Number} pointBatchSize - Number of points that defines a contour segment (default to 2)
- * @param {String} segmentationName - Mask object name
- * @param {Array} viewports - Viewport array ids
- * @returns {Number} Number of array elements consumed
- */
-export const parseContours = function (
-  contoursData: { [key: string]: Uint8Array }, // TODO-ts: check if this is correct @mronzoni
-  pointBatchSize: number,
-  segmentationName: string,
-  viewports: Array<string>
-) {
-  let contours: Contours = {};
-  each(viewports, viewport => {
-    contours[viewport] = {};
-    contours[viewport][segmentationName] = [];
-    let points = contoursData[viewport];
-
-    if (!points) {
-      return;
-    }
-
-    let numberOfSlices = points[0];
-    points = points.slice(1);
-
-    each(range(numberOfSlices), function () {
-      let sliceSize = extractSlicePoints(
-        contours,
-        pointBatchSize,
-        points,
-        segmentationName,
-        viewport
-      );
-      points = points.slice(sliceSize);
-    });
-  });
-
-  return contours;
-};
-
-/* Internal module functions */
-
-/**
- * From raw data, fill cornerstone tool data structure for ContoursTool for a single slice
- * @instance
- * @function populateContoursObject
- * @param {Number} pointBatchSize - Number of points that defines a contour segment
- * @param {Object} contours - Main contour tool object dict (to be filled)
- * @param {Number} lineNumber - Number of line to be rendered (a contour is made of n lines)
- * @param {Number} sliceNumber - Number of the slice in which the contour should be rendered
- * @param {String} segmentationName - Mask object name
- * @param {String} viewport - Viewport id
- * @param {Array} data - Raw data (array of pixel values)
- */
-const populateContoursObject = function (
-  pointBatchSize: number,
-  contours: Contours,
-  lineNumber: number,
-  sliceNumber: number,
-  segmentationName: string,
-  viewport: string,
-  data: Uint8Array
-) {
-  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);
-
-    // always add the first item
-    if (!coords.length) {
-      coords.push({
-        x: xy[0],
-        y: xy[1],
-        lines: []
-      });
-    }
-
-    // add new items if different from the previous one
-    else {
-      //if (coords[coords.length - 1].x !== xy[0] &&
-      //   coords[coords.length - 1].y !== xy[1]) {
-      coords.push({
-        x: xy[0],
-        y: xy[1],
-        lines: [
-          {
-            x: coords[coords.length - 1].x,
-            y: coords[coords.length - 1].y
-          }
-        ]
-      });
-    }
-  }
-
-  // add line element to the first item
-  if (coords[0]) {
-    coords[0].lines = [
-      {
-        x: coords[coords.length - 1].x,
-        y: coords[coords.length - 1].y
-      }
-    ];
-  }
-
-  contours[viewport][segmentationName][sliceNumber].lines[lineNumber] = coords;
-};
-
-/**
- * Extract each slice points from raw data array
- * @instance
- * @function extractSlicePoints
- * @param {Object} contours - Main contour tool object dict (to be filled)
- * @param {Number} pointBatchSize - Number of points that defines a contour segment (default to 2)
- * @param {Number} slicePoints - Number of contour points on a slice
- * @param {String} segmentationName - Mask object name
- * @param {String} viewport - Viewport id
- * @returns {Number} Number of array elements consumed
- */
-const extractSlicePoints = function (
-  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];
-  let numberOfLines = slicePoints[1];
-
-  try {
-    slicePoints = slicePoints.subarray(2);
-  } catch (err) {
-    slicePoints = slicePoints.slice(2);
-  }
-
-  let numberOfPoints = 0;
-  contours[viewport][segmentationName][sliceNumber] = {
-    lines: [] as vec2[][]
-  };
-
-  if (numberOfLines) {
-    // for each line
-    each(range(numberOfLines), function (l: number) {
-      // get number of points for current line
-      let numberOfPointsPerLine = slicePoints[0];
-      // compute coordinates size
-      let lineCoordSize = numberOfPointsPerLine * pointBatchSize;
-
-      // remove numberOfPointsPerLine and the coordinates for this line
-      let subCoords;
-      try {
-        subCoords = slicePoints.subarray(1, lineCoordSize + 1);
-      } catch (err) {
-        subCoords = slicePoints.slice(1, lineCoordSize + 1);
-      }
-      populateContoursObject(
-        pointBatchSize,
-        contours,
-        l,
-        sliceNumber,
-        segmentationName,
-        viewport,
-        subCoords
-      );
-
-      let lineSize = 1 + lineCoordSize;
-      numberOfPoints += lineSize;
-      try {
-        slicePoints = slicePoints.subarray(lineSize);
-      } catch (err) {
-        slicePoints = slicePoints.slice(lineSize);
-      }
-    });
-  }
-
-  return 2 + numberOfPoints;
-};