larvitar 1.5.13 → 2.0.0

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

@@ -21,16 +21,27 @@ import {
 } from "lodash";
 import { v4 as uuidv4 } from "uuid";
 import cornerstone from "cornerstone-core";
-import { convertBytes } from "dicom-character-set";
 
 // internal libraries
 import { getDicomImageId } from "./loaders/dicomLoader";
 import TAG_DICT from "./dataDictionary.json";
 import { getSeriesDataFromLarvitarManager } from "./loaders/commonLoader";
+import type {
+  CustomDataSet,
+  MetaData,
+  ReslicedInstance,
+  Series
+} from "./types";
+import { getTagValue } from "./imageTags";
+import { MetaDataTypes } from "./MetaDataTypes";
 
 // global module variables
 // variables used to manage the reslice functionality
-const resliceTable = {
+const resliceTable: {
+  [key: string]: {
+    [key: string]: [number, number, number];
+  };
+} = {
   sagittal: { coronal: [-2, 1, 0], axial: [-2, 0, -1] },
   coronal: { sagittal: [2, 1, -0], axial: [0, 2, -1] },
   axial: { sagittal: [1, -2, -0], coronal: [0, -2, 1] }
@@ -43,7 +54,6 @@ const resliceTable = {
  * getMaxPixelValue(defaultValue, pixelData)
  * getPixelRepresentation(dataset)
  * getTypedArrayFromDataType(dataType)
- * getPixelTypedArray(dataset, pixelDataElement)
  * getSortedStack(seriesData, sortPriorities, returnSuccessMethod)
  * getSortedUIDs(seriesData)
  * randomId()
@@ -52,7 +62,6 @@ const resliceTable = {
  * getCmprMetadata(reslicedSeriesId, imageLoaderName, header)
  * getReslicedPixeldata(imageId, originalData, reslicedData)
  * getDistanceBetweenSlices(seriesData, sliceIndex1, sliceIndex2)
- * parseTag(dataSet, propertyName, element)
  * isElement(o)
  * getImageMetadata(dataSet, imageId)
  */
@@ -70,7 +79,9 @@ const resliceTable = {
  * @function getNormalOrientation
  * @param {Array} el - The image_orientation dicom tag
  */
-export const getNormalOrientation = function (el) {
+export const getNormalOrientation = function (
+  el: [number, number, number, number, number, number]
+) {
   let a = [el[0], el[1], el[2]];
   let b = [el[3], el[4], el[5]];
 
@@ -90,7 +101,10 @@ export const getNormalOrientation = function (el) {
  * @param {Number} value - The min value
  * @param {Array} pixelData - Pixel data array
  */
-export const getMinPixelValue = function (value, pixelData) {
+export const getMinPixelValue = function (
+  value: number,
+  pixelData: Uint16Array
+) {
   if (value !== undefined) {
     return value;
   }
@@ -110,7 +124,10 @@ export const getMinPixelValue = function (value, pixelData) {
  * @param {Number} value - The max value
  * @param {Array} pixelData - Pixel data array
  */
-export const getMaxPixelValue = function (value, pixelData) {
+export const getMaxPixelValue = function (
+  value: string,
+  pixelData: Uint16Array
+) {
   if (value !== undefined) {
     return value;
   }
@@ -131,7 +148,7 @@ export const getMaxPixelValue = function (value, pixelData) {
  * @param {Object} dataSet - The dataset
  * @returns {String} The pixel representation in the form Sint / Uint + bytelength
  */
-export const getPixelRepresentation = function (dataSet) {
+export const getPixelRepresentation = function (dataSet: CustomDataSet) {
   if (dataSet.repr) {
     return dataSet.repr;
   } else {
@@ -156,50 +173,17 @@ export const getPixelRepresentation = function (dataSet) {
  * @param {Object} dataType - The data type
  * @returns {TypedArray} The typed array
  */
-export const getTypedArrayFromDataType = function (dataType) {
-  let repr = dataType.toLowerCase();
+export const getTypedArrayFromDataType = function (dataType: string) {
+  let repr = dataType.toLowerCase() as keyof typeof TYPES_TO_TYPEDARRAY;
   let typedArray = has(TYPES_TO_TYPEDARRAY, repr)
     ? TYPES_TO_TYPEDARRAY[repr]
     : null;
   if (!typedArray) {
-    console.error("invalida data type: ", dataType);
+    console.error("invalid data type: ", dataType);
   }
   return typedArray;
 };
 
-/**
- * Create and return a typed array from the pixel data
- * @instance
- * @function getPixelTypedArray
- * @param {Object} dataSet - The cornerstone serie object
- * @param {Object} pixelDataElement - The dataset metadata (dataSet.elements.x7fe00010)
- * @returns {TypedArray} The pixel array as proper typed array
- */
-export const getPixelTypedArray = function (dataSet, pixelDataElement) {
-  let buffer = dataSet.byteArray.buffer;
-  let offset = pixelDataElement.dataOffset;
-  let r = getPixelRepresentation(dataSet);
-  let typedArray = getTypedArrayFromDataType(r);
-  switch (typedArray) {
-    case Uint16Array:
-      length = pixelDataElement.length / 2;
-      break;
-    case Int16Array:
-      length = pixelDataElement.length / 2;
-      break;
-    case Uint32Array:
-      length = pixelDataElement.length / 4;
-      break;
-    case Int32Array:
-      length = pixelDataElement.length / 4;
-      break;
-    default:
-      length = pixelDataElement.length;
-      break;
-  }
-  return new typedArray(buffer, offset, length);
-};
-
 /**
  * Sort the array of images ids of a series trying with:
  * - content time order, if the series has cardiacNumberOfImages tag > 1
@@ -214,31 +198,30 @@ export const getPixelTypedArray = function (dataSet, pixelDataElement) {
  * @return {Object} The sorted stack
  */
 export const getSortedStack = function (
-  seriesData,
-  sortPriorities,
-  returnSuccessMethod
+  seriesData: Series,
+  sortPriorities: Array<"imagePosition" | "contentTime" | "instanceNumber">,
+  returnSuccessMethod: boolean
 ) {
-  let tryToSort = function (data, methods) {
+  let tryToSort = function (
+    data: Series,
+    methods: typeof sortPriorities
+  ): string[] {
     if (isEmpty(methods)) {
       if (returnSuccessMethod === true) {
-        return sorted;
+        return sorted!;
       } else {
-        return sorted;
+        return sorted!;
       }
     }
 
     let sortMethod = methods.shift();
-    try {
-      var sorted = sortBy(data.imageIds, function (imageId) {
-        return sortStackCallback(data, imageId, sortMethod);
-      });
-      if (returnSuccessMethod === true) {
-        return sorted;
-      } else {
-        return sorted;
-      }
-    } catch (ex) {
-      return tryToSort(data, methods);
+    var sorted = sortBy(data.imageIds, function (imageId: string) {
+      return sortStackCallback(data, imageId, sortMethod!);
+    });
+    if (returnSuccessMethod === true) {
+      return sorted;
+    } else {
+      return sorted;
     }
   };
 
@@ -254,10 +237,11 @@ export const getSortedStack = function (
  * @param {Object} seriesData - The dataset
  * @return {Object} The sorted instanceUIDs
  */
-export const getSortedUIDs = function (seriesData) {
-  let instanceUIDs = {};
-  forEach(seriesData.imageIds, function (imageId) {
-    instanceUIDs[seriesData.instances[imageId].metadata.instanceUID] = imageId;
+export const getSortedUIDs = function (seriesData: Series) {
+  let instanceUIDs: { [key: string]: string } = {};
+  forEach(seriesData.imageIds, function (imageId: string) {
+    let instanceUID = seriesData.instances[imageId].metadata.instanceUID!;
+    instanceUIDs[instanceUID] = imageId;
   });
   return instanceUIDs;
 };
@@ -281,35 +265,53 @@ export const randomId = function () {
  * @param {Bool} isArray - True if tag value is an array
  * @return {Number} - Tag mean value
  */
-export const getMeanValue = function (series, tag, isArray) {
-  let meanValue = isArray ? [] : 0;
-
-  forEach(series.imageIds, function (imageId) {
-    const tagValue = series.instances[imageId].metadata[tag];
-    if (tagValue.length === 2) {
-      meanValue[0] = meanValue[0] ? meanValue[0] + tagValue[0] : tagValue[0];
-      meanValue[1] = meanValue[1] ? meanValue[1] + tagValue[1] : tagValue[1];
-    } else if (tagValue.length === 3) {
-      meanValue[0] = meanValue[0] ? meanValue[0] + tagValue[0] : tagValue[0];
-      meanValue[1] = meanValue[1] ? meanValue[1] + tagValue[1] : tagValue[1];
-      meanValue[2] = meanValue[2] ? meanValue[2] + tagValue[2] : tagValue[2];
-    } else if (tagValue.length === 6) {
-      meanValue[0] = meanValue[0] ? meanValue[0] + tagValue[0] : tagValue[0];
-      meanValue[1] = meanValue[1] ? meanValue[1] + tagValue[1] : tagValue[1];
-      meanValue[2] = meanValue[2] ? meanValue[2] + tagValue[2] : tagValue[2];
-      meanValue[3] = meanValue[3] ? meanValue[3] + tagValue[3] : tagValue[3];
-      meanValue[4] = meanValue[4] ? meanValue[4] + tagValue[4] : tagValue[4];
-      meanValue[5] = meanValue[5] ? meanValue[5] + tagValue[5] : tagValue[5];
+export const getMeanValue = function (
+  series: Series,
+  tag: keyof MetaData,
+  isArray: boolean
+) {
+  let meanValue = isArray ? ([] as number[]) : (0 as number);
+
+  forEach(series.imageIds, function (imageId: string) {
+    let tagValue = series.instances[imageId].metadata[
+      tag
+    ] as MetaData[typeof tag];
+    if (Array.isArray(tagValue)) {
+      tagValue; //exclude array of metadatatypes
+      meanValue = meanValue as number[];
+
+      if (tagValue.length === 2) {
+        tagValue = tagValue as [number, number];
+        meanValue[0] = meanValue[0] ? meanValue[0] + tagValue[0] : tagValue[0];
+        meanValue[1] = meanValue[1] ? meanValue[1] + tagValue[1] : tagValue[1];
+      } else if (tagValue.length === 3) {
+        tagValue = tagValue as [number, number, number];
+        meanValue[0] = meanValue[0] ? meanValue[0] + tagValue[0] : tagValue[0];
+        meanValue[1] = meanValue[1] ? meanValue[1] + tagValue[1] : tagValue[1];
+        meanValue[2] = meanValue[2] ? meanValue[2] + tagValue[2] : tagValue[2];
+      } else if (tagValue.length === 6) {
+        tagValue = tagValue as [number, number, number, number, number, number];
+        meanValue[0] = meanValue[0] ? meanValue[0] + tagValue[0] : tagValue[0];
+        meanValue[1] = meanValue[1] ? meanValue[1] + tagValue[1] : tagValue[1];
+        meanValue[2] = meanValue[2] ? meanValue[2] + tagValue[2] : tagValue[2];
+        meanValue[3] = meanValue[3] ? meanValue[3] + tagValue[3] : tagValue[3];
+        meanValue[4] = meanValue[4] ? meanValue[4] + tagValue[4] : tagValue[4];
+        meanValue[5] = meanValue[5] ? meanValue[5] + tagValue[5] : tagValue[5];
+      }
     } else {
+      meanValue = meanValue as number;
+      tagValue = parseFloat(tagValue as string);
       meanValue += tagValue;
     }
   });
 
   if (isArray) {
+    meanValue = meanValue as number[];
     for (let i = 0; i < meanValue.length; i++) {
       meanValue[i] /= series.imageIds.length;
     }
   } else {
+    meanValue = meanValue as number;
     meanValue /= series.imageIds.length;
   }
   return meanValue;
@@ -327,11 +329,11 @@ export const getMeanValue = function (series, tag, isArray) {
  * @return {Object} - Cornerstone series object, filled only with metadata
  */
 export const getReslicedMetadata = function (
-  reslicedSeriesId,
-  fromOrientation,
-  toOrientation,
-  seriesData,
-  imageLoaderName
+  reslicedSeriesId: string,
+  fromOrientation: "axial" | "coronal" | "sagittal",
+  toOrientation: "axial" | "coronal" | "sagittal",
+  seriesData: Series,
+  imageLoaderName: string
 ) {
   // get reslice metadata and apply the reslice algorithm
   let permuteTable = resliceTable[fromOrientation][toOrientation];
@@ -340,20 +342,20 @@ export const getReslicedMetadata = function (
   });
 
   // orthogonal reslice algorithm
-  let reslicedImageIds = [];
-  let reslicedInstances = {};
+  let reslicedImageIds: string[] = [];
+  let reslicedInstances: { [key: string]: ReslicedInstance } = {};
 
   let sampleMetadata = seriesData.instances[seriesData.imageIds[0]].metadata;
 
   let fromSize = [
-    sampleMetadata.x00280011,
-    sampleMetadata.x00280010,
+    sampleMetadata.x00280011!,
+    sampleMetadata.x00280010!,
     seriesData.imageIds.length
   ];
   let toSize = permuteValues(permuteAbsTable, fromSize);
   let fromSpacing = spacingArray(seriesData, sampleMetadata);
-  let toSpacing = permuteValues(permuteAbsTable, fromSpacing);
-  let reslicedIOP = getReslicedIOP(sampleMetadata.x00200037, permuteTable);
+  let toSpacing = permuteValues(permuteAbsTable, fromSpacing as number[]);
+  let reslicedIOP = getReslicedIOP(sampleMetadata.x00200037!, permuteTable);
 
   for (let f = 0; f < toSize[2]; f++) {
     let reslicedImageId = getDicomImageId(imageLoaderName);
@@ -361,16 +363,16 @@ export const getReslicedMetadata = function (
 
     let instanceId = uuidv4();
     let reslicedIPP = getReslicedIPP(
-      sampleMetadata.x00200032,
-      sampleMetadata.x00200037,
+      sampleMetadata.x00200032 as [number, number, number],
+      sampleMetadata.x00200037!,
       reslicedIOP,
       permuteTable,
       f,
       fromSize,
       toSize,
-      fromSpacing
+      fromSpacing as number[]
     );
-    let metadata = extend(clone(sampleMetadata), {
+    let metadata: MetaData = extend(clone(sampleMetadata), {
       // pixel representation
       x00280100: sampleMetadata.x00280100,
       x00280103: sampleMetadata.x00280103,
@@ -413,12 +415,10 @@ export const getReslicedMetadata = function (
       // new image orientation
       x00200037: reslicedIOP,
       // new image position
-      x00200032: reslicedIPP,
-      x00280106: sampleMetadata.x00280106,
-      x00280107: sampleMetadata.x00280107
+      x00200032: reslicedIPP
     });
 
-    // set human readable metadata
+    // set human readable metadata.
     metadata.seriesUID = reslicedSeriesId;
     metadata.rows = metadata.x00280010;
     metadata.cols = metadata.x00280011;
@@ -454,12 +454,12 @@ export const getReslicedMetadata = function (
  * @return {Object} - Cornerstone series object, filled only with metadata
  */
 export const getCmprMetadata = function (
-  reslicedSeriesId,
-  imageLoaderName,
-  header
+  reslicedSeriesId: string,
+  imageLoaderName: string,
+  header: any // TODO-ts : type
 ) {
-  let reslicedImageIds = [];
-  let reslicedInstances = {};
+  let reslicedImageIds: string[] = [];
+  let reslicedInstances: { [key: string]: ReslicedInstance } = {};
 
   for (let f = 0; f < header.frames_number; f++) {
     let reslicedImageId = getDicomImageId(imageLoaderName);
@@ -467,7 +467,7 @@ export const getCmprMetadata = function (
 
     let instanceId = uuidv4();
 
-    let metadata = {
+    let metadata: MetaData = {
       // pixel representation
       x00280100: header.repr,
       // Bits Allocated
@@ -477,7 +477,7 @@ export const getCmprMetadata = function (
       x00280011: header.cols, // cols
       // resliced series spacing
       x00280030: [header.spacing[1], header.spacing[0]],
-      x00180050: [header.distance_btw_slices],
+      x00180050: [header.distance_btw_slices] as number[],
       // remove min and max pixelvalue from metadata before calling the createCustomImage function:
       // need to recalculate the min and max pixel values on the new instance pixelData
       x00280106: undefined,
@@ -506,8 +506,8 @@ export const getCmprMetadata = function (
       // data needed to obtain a good rendering
       x00281050: [header.wwwl[1] / 2], // [wl]
       x00281051: [header.wwwl[0]], // [ww]
-      x00281052: [header.intercept],
-      x00281053: [header.slope],
+      x00281052: header.intercept,
+      x00281053: header.slope,
       // new image orientation (IOP)
       x00200037: header.iop ? header.iop.slice(f * 6, (f + 1) * 6) : null,
       // new image position (IPP)
@@ -536,27 +536,30 @@ export const getCmprMetadata = function (
  * @return {Object} - A single resliced slice pixel array
  */
 export const getReslicedPixeldata = function (
-  imageId,
-  originalData,
-  reslicedData
+  imageId: string,
+  originalData: Series,
+  reslicedData: Series
 ) {
   // resliced metadata must be already available
-  let reslicedInstance = reslicedData.instances[imageId];
+  let reslicedInstance = reslicedData.instances[imageId] as ReslicedInstance;
   let reslicedMetadata = reslicedInstance.metadata;
+  if (!reslicedInstance.permuteTable) {
+    throw new Error("Resliced permuteTable not available");
+  }
   let permuteAbsTable = reslicedInstance.permuteTable.map(function (v) {
     return Math.abs(v);
   });
 
   // compute resliced series pixelData, use the correct typedarray
-  let rows = reslicedMetadata.x00280010;
-  let cols = reslicedMetadata.x00280011;
-  let reslicedSlice = getTypedArray(reslicedMetadata, rows * cols);
+  let rows = reslicedMetadata.x00280010 as number;
+  let cols = reslicedMetadata.x00280011 as number;
+  let reslicedSlice = getTypedArray(reslicedMetadata as any, rows * cols); // TODO-ts : type of reslicedMetadata?
 
   let frame = indexOf(reslicedData.imageIds, imageId);
   let originalInstance = originalData.instances[originalData.imageIds[0]];
-  let fromCols = originalInstance.metadata.x00280011;
+  let fromCols = originalInstance.metadata.x00280011 as number;
 
-  function getPixelValue(ijf) {
+  function getPixelValue(ijf: [number, number, number]) {
     let i = ijf[0];
     let j = ijf[1];
     let f = ijf[2];
@@ -577,7 +580,7 @@ export const getReslicedPixeldata = function (
 
   for (let j = 0; j < rows; j++) {
     for (let i = 0; i < cols; i++) {
-      let ijf = [0, 0, 0];
+      let ijf: [number, number, number] = [0, 0, 0];
       ijf[permuteAbsTable[0]] = i;
       ijf[permuteAbsTable[1]] = j;
       ijf[permuteAbsTable[2]] = frame;
@@ -607,9 +610,9 @@ export const getReslicedPixeldata = function (
  * @return {Number} - The distance value
  */
 export const getDistanceBetweenSlices = function (
-  seriesData,
-  sliceIndex1,
-  sliceIndex2
+  seriesData: Series,
+  sliceIndex1: number,
+  sliceIndex2: number
 ) {
   if (seriesData.imageIds.length <= 1) {
     return 0;
@@ -618,12 +621,8 @@ export const getDistanceBetweenSlices = function (
   let imageId1 = seriesData.imageIds[sliceIndex1];
   let instance1 = seriesData.instances[imageId1];
   let metadata1 = instance1.metadata;
-  let imageOrientation = metadata1.imageOrientation
-    ? metadata1.imageOrientation
-    : metadata1.x00200037;
-  let imagePosition = metadata1.imagePosition
-    ? metadata1.imagePosition
-    : metadata1.x00200032;
+  let imageOrientation = metadata1.x00200037;
+  let imagePosition = metadata1.x00200032 as [number, number, number];
 
   if (imageOrientation && imagePosition) {
     let normal = getNormalOrientation(imageOrientation);
@@ -635,223 +634,17 @@ export const getDistanceBetweenSlices = function (
     let imageId2 = seriesData.imageIds[sliceIndex2];
     let instance2 = seriesData.instances[imageId2];
     let metadata2 = instance2.metadata;
-    let imagePosition2 = metadata2.imagePosition
-      ? metadata2.imagePosition
-      : metadata2.x00200032;
+    let imagePosition2 = metadata2.x00200032!;
 
     let d2 =
       normal[0] * imagePosition2[0] +
       normal[1] * imagePosition2[1] +
-      normal[2] * imagePosition2[2];
+      normal[2] * imagePosition2[2]!;
 
     return Math.abs(d1 - d2);
   }
 };
 
-/**
- * Parse a DICOM Tag according to its type
- * @instance
- * @function parseTag
- * @param {Object} dataSet - The parsed dataset object from dicom parser
- * @param {String} propertyName - The tag name
- * @param {Object} element - The parsed dataset element
- * @return {String} - The DICOM Tag value
- */
-export const parseTag = function (dataSet, propertyName, element) {
-  // GET VR
-  var tagData = dataSet.elements[propertyName] || {};
-  var vr = tagData.vr;
-  if (!vr) {
-    // use dicom dict to get VR
-    var tag = getDICOMTag(propertyName);
-    if (tag && tag.vr) {
-      vr = tag.vr;
-    } else {
-      return element;
-    }
-  }
-
-  var value;
-
-  if (isStringVr(vr)) {
-    // We ask the dataset to give us the element's data in string form.
-    // Most elements are strings but some aren't so we do a quick check
-    // to make sure it actually has all ascii characters so we know it is
-    // reasonable to display it.
-    var str = dataSet.string(propertyName);
-    if (str === undefined) {
-      return undefined;
-    } else {
-      // the string will be undefined if the element is present but has no data
-      // (i.e. attribute is of type 2 or 3) so we only display the string if it has
-      // data. Note that the length of the element will be 0 to indicate "no data"
-      // so we don't put anything here for the value in that case.
-      value = str;
-    }
-
-    // A string of characters representing an Integer in base-10 (decimal),
-    // shall contain only the characters 0 - 9, with an optional leading "+" or "-".
-    // It may be padded with leading and/or trailing spaces. Embedded spaces
-    // are not allowed. The integer, n, represented shall be in the range:
-    // -231 <= n <= (231 - 1).
-    if (vr === "IS") {
-      value = parseInt(value);
-    }
-    // A string of characters representing either a fixed point number
-    // or a floating point number. A fixed point number shall contain only
-    // the characters 0-9 with an optional leading "+" or "-" and an optional "."
-    // to mark the decimal point. A floating point number shall be conveyed
-    // as defined in ANSI X3.9, with an "E" or "e" to indicate the start
-    // of the exponent. Decimal Strings may be padded with leading or trailing spaces.
-    // Embedded spaces are not allowed.
-    else if (vr === "DS") {
-      value = value.split("\\").map(Number);
-      if (propertyName == "x00281050" || propertyName == "x00281051") {
-        value = value.length > 0 ? value[0] : value;
-      } else {
-        value = value.length == 1 ? value[0] : value;
-      }
-    }
-    // A string of characters of the format YYYYMMDD; where YYYY shall contain year,
-    // MM shall contain the month, and DD shall contain the day,
-    // interpreted as a date of the Gregorian calendar system.
-    else if (vr === "DA") {
-      value = parseDateTag(value, false);
-    }
-    // A concatenated date-time character string in the format:
-    // YYYYMMDDHHMMSS.FFFFFF
-    else if (vr === "DT") {
-      value = parseDateTimeTag(value);
-    }
-    // A string of characters of the format HHMMSS.FFFFFF; where HH contains hours
-    // (range "00" - "23"), MM contains minutes (range "00" - "59"),
-    // SS contains seconds (range "00" - "60"), and FFFFFF contains a fractional
-    // part of a second as small as 1 millionth of a second (range "000000" - "999999").
-    else if (vr === "TM") {
-      value = parseTimeTag(value);
-    }
-    // Specific Character Set (0008,0005) identifies the Character Set that expands or
-    // replaces the Basic Graphic Set (ISO 646) for values of Data Elements that have
-    // Value Representation of SH, LO, ST, PN, LT, UC or UT.
-    // If the Attribute Specific Character Set (0008,0005) is not present or has only
-    // a single value, Code Extension techniques are not used. Defined Terms for the
-    // Attribute Specific Character Set (0008,0005), when single valued, are derived
-    // from the International Registration Number as per ISO 2375
-    // (e.g., ISO_IR 100 for Latin alphabet No. 1).
-    // See https://github.com/radialogica/dicom-character-set
-    else if (
-      vr == "PN" ||
-      vr == "SH" ||
-      vr == "LO" ||
-      vr == "ST" ||
-      vr == "LT" ||
-      vr == "UC" ||
-      vr == "UT"
-    ) {
-      // get character set
-      let characterSet = dataSet.string("x00080005");
-      if (characterSet) {
-        let data = dataSet.elements[propertyName];
-        let arr = new Uint8Array(
-          dataSet.byteArray.buffer,
-          data.dataOffset,
-          data.length
-        );
-        value = convertBytes(characterSet, arr, {
-          vr: vr
-        });
-        arr = null;
-      }
-      if (vr == "PN") {
-        // PatientName tag value is: "LastName^FirstName^MiddleName".
-        // Spaces inside each name component are permitted. If you don't know
-        // any of the three components, just leave it empty.
-        // Actually you may even append a name prefix (^professor) and
-        // a name suffix (^senior) so you have a maximum of 5 components.
-        value = parsePatientNameTag(value);
-      }
-      value = value.replace(/\0/g, ""); // remove null char (\u0000)
-    }
-    // A string of characters with one of the following formats
-    // -- nnnD, nnnW, nnnM, nnnY; where nnn shall contain the number of days for D,
-    // weeks for W, months for M, or years for Y.
-    else if (vr == "AS") {
-      value = parseAgeTag(value);
-    }
-
-    // A string of characters with leading or trailing spaces (20H) being non-significant.
-    else if (vr === "CS") {
-      if (propertyName === "x00041500") {
-        value = parseDICOMFileIDTag(value);
-      } else {
-        value = value.split("\\").join(", ");
-      }
-    }
-  } else if (vr === "US") {
-    value = dataSet.uint16(propertyName);
-  } else if (vr === "SS") {
-    value = dataSet.int16(propertyName);
-  } else if (vr === "US|SS") {
-    value = dataSet.int16(propertyName);
-  } else if (vr === "UL") {
-    value = dataSet.uint32(propertyName);
-  } else if (vr === "SL") {
-    value = dataSet.int32(propertyName);
-  } else if (vr == "FD") {
-    value = dataSet.double(propertyName);
-  } else if (vr == "FL") {
-    value = dataSet.float(propertyName);
-  } else if (
-    vr === "OB" ||
-    vr === "OW" ||
-    vr === "OW|OB" ||
-    vr === "US|OW" ||
-    vr === "UN" ||
-    vr === "OF" ||
-    vr === "UT"
-  ) {
-    // If it is some other length and we have no string
-    if (element.length === 2) {
-      value =
-        "binary data of length " +
-        element.length +
-        " as uint16: " +
-        dataSet.uint16(propertyName);
-    } else if (element.length === 4) {
-      value =
-        "binary data of length " +
-        element.length +
-        " as uint32: " +
-        dataSet.uint32(propertyName);
-    } else {
-      value = "binary data of length " + element.length + " and VR " + vr;
-    }
-  } else if (vr === "AT") {
-    var group = dataSet.uint16(propertyName, 0);
-    if (group) {
-      var groupHexStr = ("0000" + group.toString(16)).substr(-4);
-      var elm = dataSet.uint16(propertyName, 1);
-      var elmHexStr = ("0000" + elm.toString(16)).substr(-4);
-      value = "x" + groupHexStr + elmHexStr;
-    } else {
-      value = "";
-    }
-  } else if (vr === "SQ") {
-    // parse the nested tags
-    var subTags = map(element, function (obj) {
-      return map(obj, function (v, k) {
-        return parseTag(dataSet, k, v);
-      });
-    });
-
-    value = subTags;
-  } else {
-    // If it is some other length and we have no string
-    value = "no display code for VR " + vr;
-  }
-  return value;
-};
-
 /**
  * @instance
  * @function getImageMetadata
@@ -859,7 +652,10 @@ export const parseTag = function (dataSet, propertyName, element) {
  * @param {String} instanceUID - The SOPInstanceUID
  * @return {Array} - List of metadata objects: tag, name and value
  */
-export const getImageMetadata = function (seriesId, instanceUID) {
+export const getImageMetadata = function (
+  seriesId: string,
+  instanceUID: string
+) {
   const seriesData = getSeriesDataFromLarvitarManager(seriesId);
   if (seriesData === undefined || seriesData === null) {
     console.log(`Invalid Series ID: ${seriesId}`);
@@ -873,14 +669,15 @@ export const getImageMetadata = function (seriesId, instanceUID) {
 
   let metadata = seriesData.instances[imageId].metadata;
   // get elements from metadata where the key starts with x and is length 7
-  let metadata_keys = filter(keys(metadata), function (key) {
-    return key.length === 9 && key[0] === "x";
-  });
+  let metadata_keys = Object.keys(metadata);
   // loop metadata using metadata_keys and return list of key value pairs
-  let metadata_list = map(metadata_keys, function (key) {
+  let metadata_list = map(metadata_keys, function (key: string) {
     // if value is a dictionary return empty string
+    let KEY = key as keyof MetaDataTypes;
     const value =
-      metadata[key] && metadata[key].constructor == Object ? "" : metadata[key];
+      metadata[KEY] && metadata[KEY]!.constructor == Object
+        ? ""
+        : metadata[KEY];
     // convert key removing x and adding comma at position 4
     const tagKey = (
       "(" +
@@ -889,7 +686,14 @@ export const getImageMetadata = function (seriesId, instanceUID) {
       key.slice(5) +
       ")"
     ).toUpperCase();
-    const name = TAG_DICT[tagKey] ? TAG_DICT[tagKey].name : "";
+
+    if (!Object.keys(TAG_DICT).includes(tagKey)) {
+      console.debug(`Invalid tag key: ${tagKey}`);
+    }
+    // force type to keyof typeof TAG_DICT after having checked that it is a valid key
+    const name = TAG_DICT[tagKey as keyof typeof TAG_DICT]
+      ? TAG_DICT[tagKey as keyof typeof TAG_DICT].name
+      : "";
     return {
       tag: tagKey,
       name: name,
@@ -911,34 +715,31 @@ export const getImageMetadata = function (seriesId, instanceUID) {
  * @param {String} method - Orientation target
  * @return {Number} - The sorting value (float)
  */
-let sortStackCallback = function (seriesData, imageId, method) {
+let sortStackCallback = function (
+  seriesData: Series,
+  imageId: string,
+  method: "instanceNumber" | "contentTime" | "imagePosition"
+) {
   switch (method) {
     case "instanceNumber":
-      var instanceNumber = seriesData.instances[imageId].metadata.x00200013;
-      instanceNumber = parseInt(instanceNumber);
+      var instanceNumber = seriesData.instances[imageId].metadata.x00200013!;
       return instanceNumber;
 
     case "contentTime":
       return seriesData.instances[imageId].metadata.x00080033;
 
     case "imagePosition":
-      var p = seriesData.instances[imageId].metadata.imagePosition;
-
-      p = map(p, function (value) {
-        return parseFloat(value);
-      });
-
-      var o = seriesData.instances[imageId].metadata.imageOrientation;
-      o = map(o, function (value) {
-        return parseFloat(value);
-      });
+      let p = seriesData.instances[imageId].metadata.imagePosition!;
+      let pStr = p?.map(String);
+      let o = seriesData.instances[imageId].metadata.imageOrientation!;
+      let oStr = o?.map(String);
 
-      var v1, v2, v3;
+      var v1, v2, v3: number;
       v1 = o[0] * o[0] + o[3] * o[3];
       v2 = o[1] * o[1] + o[4] * o[4];
       v3 = o[2] * o[2] + o[5] * o[5];
 
-      var sortIndex;
+      var sortIndex = -1;
       if (v1 <= v2 && v2 <= v3) {
         sortIndex = 0;
       }
@@ -948,89 +749,17 @@ let sortStackCallback = function (seriesData, imageId, method) {
       if (v3 <= v1 && v3 <= v2) {
         sortIndex = 2;
       }
+
+      if (!sortIndex) {
+        throw new Error("Invalid sort index");
+      }
+
       return p[sortIndex];
     default:
       break;
   }
 };
 
-/**
- * Get the dicom tag code from dicom image
- * @instance
- * @function getDICOMTagCode
- * @param {String} dicomTag - The original DICOM tag code
- * @return {String} - The human readable DICOM tag code
- */
-let getDICOMTagCode = function (code) {
-  let re = /x(\w{4})(\w{4})/;
-  let result = re.exec(code);
-  if (!result) {
-    return code;
-  }
-  let newCode = "(" + result[1] + "," + result[2] + ")";
-  newCode = newCode.toUpperCase();
-  return newCode;
-};
-
-/**
- * Get the dicom tag from dicom tag code
- * @instance
- * @function getDICOMTag
- * @param {String} dicomTagCode - The original DICOM tag code
- * @return {String} - The human readable DICOM tag
- */
-let getDICOMTag = function (code) {
-  let newCode = getDICOMTagCode(code);
-  let tag = TAG_DICT[newCode];
-  return tag;
-};
-
-/**
- * Convert date from dicom tag
- * @instance
- * @function formatDate
- * @param {Date} dicomDate - A date from a DICOM tag
- * @return {String} - The human readable date
- */
-let formatDate = function (date) {
-  let yyyy = date.slice(0, 4);
-  let mm = date.slice(4, 6);
-  let dd = date.slice(6, 8);
-  return (
-    yyyy + "-" + (mm[1] ? mm : "0" + mm[0]) + "-" + (dd[1] ? dd : "0" + dd[0])
-  );
-};
-
-/**
- * Convert datetime from dicom tag
- * @instance
- * @function formatDateTime
- * @param {Date} dicomDateTime - A dateTime from a DICOM tag
- * @return {String} - The human readable dateTime
- */
-let formatDateTime = function (date) {
-  let yyyy = date.slice(0, 4);
-  let mm = date.slice(4, 6);
-  let dd = date.slice(6, 8);
-  let hh = date.slice(8, 10);
-  let m = date.slice(10, 12);
-  let ss = date.slice(12, 14);
-
-  return (
-    yyyy +
-    "-" +
-    (mm[1] ? mm : "0" + mm[0]) +
-    "-" +
-    (dd[1] ? dd : "0" + dd[0]) +
-    "/" +
-    hh +
-    ":" +
-    m +
-    ":" +
-    ss
-  );
-};
-
 /**
  * Generate a random number and convert it to base 36 (0-9a-z)
  * @instance
@@ -1049,7 +778,7 @@ let rand = function () {
  * @param {Array} sourceArray - The source array
  * @return {Array} - The converted array
  */
-let permuteValues = function (convertArray, sourceArray) {
+let permuteValues = function (convertArray: number[], sourceArray: number[]) {
   let outputArray = new Array(convertArray.length);
   for (let i = 0; i < convertArray.length; i++) {
     outputArray[i] = sourceArray[convertArray[i]];
@@ -1065,7 +794,7 @@ let permuteValues = function (convertArray, sourceArray) {
  * @param {Number} x - The number to check
  * @return {Boolean} - Is negative boolean response
  */
-let isNegativeSign = function (x) {
+let isNegativeSign = function (x: number) {
   return 1 / x !== 1 / Math.abs(x);
 };
 
@@ -1077,9 +806,12 @@ let isNegativeSign = function (x) {
  * @param {Number} size - The size of the array
  * @return {Array} - The typed array
  */
-let getTypedArray = function (tags, size) {
+let getTypedArray = function (tags: CustomDataSet, size: number) {
   let r = getPixelRepresentation(tags);
   let typedArray = getTypedArrayFromDataType(r);
+  if (!typedArray) {
+    throw new Error("Invalid typed array");
+  }
   return new typedArray(size);
 };
 
@@ -1091,7 +823,10 @@ let getTypedArray = function (tags, size) {
  * @param {Array} permuteTable - The matrix transformation
  * @return {Array} - The resliced image orientation array
  */
-let getReslicedIOP = function (iop, permuteTable) {
+let getReslicedIOP = function (
+  iop: [number, number, number, number, number, number],
+  permuteTable: number[]
+) {
   if (!iop) {
     return null;
   }
@@ -1126,29 +861,29 @@ let getReslicedIOP = function (iop, permuteTable) {
  * @return {Array} - The resliced image position array
  */
 let getReslicedIPP = function (
-  ipp,
-  iop,
-  reslicedIOP,
-  permuteTable,
-  imageIndex,
-  fromSize,
-  toSize,
-  fromSpacing
+  ipp: [number, number, number],
+  iop: [number, number, number, number, number, number],
+  reslicedIOP: [number, number, number, number, number, number],
+  permuteTable: number[],
+  imageIndex: number,
+  fromSize: number[],
+  toSize: number[],
+  fromSpacing: number[]
 ) {
   // compute resliced ipp
   let reslicedIPP = [];
 
-  // iop data
+  // iop data types??
   let u = iop.slice(0, 3);
   let v = iop.slice(3, 6);
   let w = getNormalOrientation(iop);
-  let absW = map(w, function (v) {
+  let absW = map(w, function (v: number) {
     return Math.abs(v);
   });
   let majorOriginalIndex = indexOf(absW, max(absW));
 
   let normalReslicedIop = getNormalOrientation(reslicedIOP);
-  normalReslicedIop = map(normalReslicedIop, function (v) {
+  normalReslicedIop = map(normalReslicedIop, function (v: number) {
     return Math.abs(v);
   });
 
@@ -1161,10 +896,11 @@ let getReslicedIPP = function (
   if (isNegativeSign(permuteTable[1])) {
     ipp = ipp.map(function (val, i) {
       return val + fromSize[2] * fromSpacing[2] * w[i];
-    });
+    }) as [number, number, number];
   }
 
-  let spacing, versor;
+  let spacing: number;
+  let versor: number[];
   // to sagittal
   if (majorIndex == 0) {
     // original x spacing
@@ -1203,7 +939,7 @@ let getReslicedIPP = function (
     return val + index * spacing * versor[i];
   });
 
-  return reslicedIPP;
+  return reslicedIPP as [number, number, number];
 };
 
 /**
@@ -1214,9 +950,12 @@ let getReslicedIPP = function (
  * @param {Array} reslicedIPP - The resliced image position array
  * @return {Array} - The slice location as normal orientation vector
  */
-let getReslicedSliceLocation = function (reslicedIOP, reslicedIPP) {
+let getReslicedSliceLocation = function (
+  reslicedIOP: [number, number, number, number, number, number],
+  reslicedIPP: [number, number, number]
+) {
   let normalReslicedIop = getNormalOrientation(reslicedIOP);
-  normalReslicedIop = map(normalReslicedIop, function (v) {
+  normalReslicedIop = map(normalReslicedIop, function (v: number) {
     return Math.abs(v);
   });
 
@@ -1232,22 +971,23 @@ let getReslicedSliceLocation = function (reslicedIOP, reslicedIPP) {
  * @param {Object} sampleMetadata - The medatata object
  * @return {Array} - The spacing array
  */
-let spacingArray = function (seriesData, sampleMetadata) {
+let spacingArray = function (
+  seriesData: Series,
+  sampleMetadata: MetaDataTypes
+) {
   // the spacingArray is as follows:
   // [0]: column pixelSpacing value (x00280030[1])
   // [1]: row pixelSpacing value (x00280030[0])
   // [2]: distance between slices, given the series imageOrientationPatient and
   //      imagePositionPatient of the first two slices
 
-  let distanceBetweenSlices = sampleMetadata.x00180050
-    ? sampleMetadata.x00180050
+  let distanceBetweenSlices = sampleMetadata["x00180050"]
+    ? sampleMetadata["x00180050"]
     : getDistanceBetweenSlices(seriesData, 0, 1);
 
-  return [
-    sampleMetadata.x00280030[1],
-    sampleMetadata.x00280030[0],
-    distanceBetweenSlices
-  ];
+  let spacing = sampleMetadata.x00280030!;
+
+  return [spacing[1], spacing[0], distanceBetweenSlices as number];
 };
 
 /**
@@ -1258,7 +998,10 @@ let spacingArray = function (seriesData, sampleMetadata) {
  * @param {Array} sourceArray - The source array
  * @return {Array} - The permuted array array
  */
-let permuteSignedArrays = function (convertArray, sourceArray) {
+let permuteSignedArrays = function (
+  convertArray: number[],
+  sourceArray: number[][]
+) {
   let outputArray = new Array(convertArray.length);
   for (let i = 0; i < convertArray.length; i++) {
     let sourceIndex = Math.abs(convertArray[i]);
@@ -1274,239 +1017,6 @@ let permuteSignedArrays = function (convertArray, sourceArray) {
   return outputArray;
 };
 
-/**
- * Check if argument is a valid Date Object
- * @instance
- * @function isValidDate
- * @param {Date} d - The date object to be checked
- * @return {Boolean} - Boolean result
- */
-const isValidDate = function (d) {
-  return d instanceof Date && !isNaN(d);
-};
-
-/**
- * Check if argument is a string of concatenated vrs
- * @instance
- * @function isStringVr
- * @param {String} vr - The string to be checked
- * @return {Boolean} - Boolean result
- */
-const isStringVr = function (vr) {
-  // vr can be a string of concatenated vrs
-  vr = vr || "";
-  vr = vr.split("|")[0];
-
-  if (
-    vr === "AT" ||
-    vr === "FL" ||
-    vr === "FD" ||
-    vr === "OB" ||
-    vr === "OF" ||
-    vr === "OW" ||
-    vr === "SI" ||
-    vr === "SQ" ||
-    vr === "SS" ||
-    vr === "UL" ||
-    vr === "US"
-  ) {
-    return false;
-  }
-  return true;
-};
-
-/**
- * Parse a dicom date tag into human readable format
- * @instance
- * @function parseDateTag
- * @param {String} tagValue - The string to be parsed
- * @return {String} - The parsed result
- */
-const parseDateTag = function (tagValue) {
-  if (!tagValue) return;
-  let year = tagValue.substring(0, 4);
-  let month = tagValue.substring(4, 6);
-  let day = tagValue.substring(6, 8);
-  let date = new Date(year, month - 1, day);
-  if (isValidDate(date) === true) {
-    return date.toISOString();
-  } else {
-    return tagValue;
-  }
-};
-
-/**
- * Parse a dicom datetime tag into human readable format
- * @instance
- * @function parseDateTimeTag
- * @param {String} tagValue - The string to be parsed
- * @return {String} - The parsed result
- */
-const parseDateTimeTag = function (tagValue) {
-  if (!tagValue) return;
-  let year = tagValue.substring(0, 4);
-  let month = tagValue.substring(4, 6);
-  let day = tagValue.substring(6, 8);
-  let hour = tagValue.substring(8, 10);
-  let min = tagValue.substring(10, 12);
-  let sec = tagValue.substring(12, 14);
-  let msec = tagValue.substring(15, 21);
-  let date = new Date(year, month - 1, day, hour, min, sec, msec);
-  if (isValidDate(date) === true) {
-    return date.toISOString();
-  } else {
-    return tagValue;
-  }
-};
-
-/**
- * Parse a dicom time tag into human readable format
- * @instance
- * @function parseTimeTag
- * @param {String} tagValue - The string to be parsed
- * @return {String} - The parsed result
- */
-const parseTimeTag = function (tagValue) {
-  if (!tagValue) return;
-  let hour = tagValue.substring(0, 2);
-  let min = tagValue.substring(2, 4);
-  let sec = tagValue.substring(4, 6);
-  let msec = tagValue.substring(7, 13) ? tagValue.substring(7, 13) : "0";
-  let result = hour + ":" + min + ":" + sec + "." + msec;
-  return result;
-};
-
-/**
- * Parse a dicom patient tag into human readable format
- * @instance
- * @function parsePatientNameTag
- * @param {String} tagValue - The string to be parsed
- * @return {String} - The parsed result
- */
-const parsePatientNameTag = function (tagValue) {
-  if (!tagValue) return;
-  return tagValue.replace(/\^/gi, " ");
-};
-
-/**
- * Parse a dicom age tag into human readable format
- * @instance
- * @function parseAgeTag
- * @param {String} tagValue - The string to be parsed
- * @return {String} - The parsed result
- */
-const parseAgeTag = function (tagValue) {
-  if (!tagValue) return;
-  let regs = /(\d{3})(D|W|M|Y)/gim.exec(tagValue);
-  if (regs) {
-    return parseInt(regs[1]) + " " + regs[2];
-  }
-};
-
-/**
- * Parse a dicom fileID tag into human readable format
- * @instance
- * @function parseDICOMFileIDTag
- * @param {String} tagValue - The string to be parsed
- * @return {String} - The parsed result
- */
-const parseDICOMFileIDTag = function (tagValue) {
-  // The DICOM File Service does not specify any "separator" between
-  // the Components of the File ID. This is a Value Representation issue that
-  // may be addressed in a specific manner by each Media Format Layer.
-  // In DICOM IODs, File ID Components are generally handled as multiple
-  // Values and separated by "backslashes".
-  // There is no requirement that Media Format Layers use this separator.
-  if (!tagValue) return;
-  return tagValue.split("\\").join(path.sep);
-};
-
-/**
- * Extract tag value according to its value rapresentation, see
- * {@link http://dicom.nema.org/dicom/2013/output/chtml/part05/sect_6.2.html}
- * @instance
- * @function getTagValue
- * @param {Object} dataSet - the dataset
- * @param {String} tag - the desired tag key
- * @return {Number | Array | String} - the desired tag value
- */
-const getTagValue = function (dataSet, tag) {
-  // tag value rapresentation
-  if (!getDICOMTag(tag)) {
-    return null;
-  }
-  let vr = getDICOMTag(tag).vr;
-
-  // parse value according to vr map
-  let vrParsingMap = {
-    // Date
-    // string of characters of the format YYYYMMDD; where YYYY shall contain year,
-    // MM shall contain the month, and DD shall contain the day,
-    // interpreted as a date of the Gregorian calendar system.
-    DA: function () {
-      let dateString = dataSet.string(tag);
-      return dateString ? formatDate(dateString) : "";
-    },
-    // Decimal String
-    // A string of characters representing either a fixed point number
-    // or a floating point number.
-    DS: function () {
-      let array = dataSet.string(tag)
-        ? dataSet.string(tag).split("\\").map(Number)
-        : null;
-      if (!array) {
-        return null;
-      }
-      return array.length === 1 ? array[0] : array;
-    },
-    // Date Time
-    // A concatenated date-time character string in the format:
-    // YYYYMMDDHHMMSS.FFFFFF&ZZXX
-    DT: function () {
-      let dateString = dataSet.string(tag);
-      return formatDateTime(dateString);
-    },
-    // Person Name
-    // A character string encoded using a 5 component convention.
-    // The character code 5CH (the BACKSLASH "\" in ISO-IR 6) shall
-    // not be present, as it is used as the delimiter between values
-    // in multiple valued data elements. The string may be padded
-    // with trailing spaces. For human use, the five components
-    // in their order of occurrence are: family name complex,
-    // given name complex, middle name, name prefix, name suffix.
-    PN: function () {
-      let pn = dataSet.string(tag) ? dataSet.string(tag).split("^") : null;
-      if (!pn) {
-        return null;
-      }
-
-      let pns = [pn[3], pn[0], pn[1], pn[2], pn[4]];
-      return pns.join(" ").trim();
-    },
-    // Signed Short
-    // Signed binary integer 16 bits long in 2's complement form
-    SS: function () {
-      return dataSet.uint16(tag);
-    },
-    // Unique Identifier
-    // A character string containing a UID that is used to uniquely
-    // identify a wide letiety of items. The UID is a series of numeric
-    // components separated by the period "." character.
-    UI: function () {
-      return dataSet.string(tag);
-    },
-    // Unsigned Short
-    // Unsigned binary integer 16 bits long.
-    US: function () {
-      return dataSet.uint16(tag);
-    },
-    "US|SS": function () {
-      return dataSet.uint16(tag);
-    }
-  };
-  return vrParsingMap[vr] ? vrParsingMap[vr]() : dataSet.string(tag);
-};
-
 /**
  * Object used to convert data type to typed array
  * @object
@@ -1558,7 +1068,7 @@ const TYPES_TO_TYPEDARRAY = {
  * @param {Object} o - The div tag
  * @return {Boolean} - True if is an element otherwise returns False
  */
-export const isElement = function (o) {
+export const isElement = function (o: any) {
   return typeof HTMLElement === "object"
     ? o instanceof HTMLElement //DOM2
     : o &&