larvitar 0.20.0 → 1.2.2

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

@@ -1,4 +1,4 @@
-/** @module imaging/anonymization
+/** @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
  */

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

package/imaging/{image_rendering.js → imageRendering.js}

@@ -1,4 +1,4 @@
-/** @module imaging/rendering
+/** @module imaging/imageRendering
  *  @desc  This file provides functionalities for
  *         rendering images in html canvas using cornerstone
  */
@@ -10,16 +10,16 @@ import { each, has } from "lodash";
 
 // internal libraries
 import { getFileImageId } from "./loaders/fileLoader";
-import { csToolsCreateStack } from "./tools/tools.main";
-import { toggleMouseToolsListeners } from "./tools/tools.interaction";
-import { larvitar_store } from "./image_store";
-import { applyColorMap } from "./image_colormaps";
-import { isElement } from "./image_utils";
+import { csToolsCreateStack } from "./tools/main";
+import { toggleMouseToolsListeners } from "./tools/interaction";
+import { larvitar_store } from "./imageStore";
+import { applyColorMap } from "./imageColormaps";
+import { isElement } from "./imageUtils";
 
 /*
  * This module provides the following functions to be exported:
  * clearImageCache(seriesId)
- * loadAndCacheImages(seriesData, callback)
+ * loadAndCacheImages(seriesData)
  * renderFileImage(file, elementId)
  * renderWebImage(url, elementId)
  * disableViewport(elementId)
@@ -121,9 +121,9 @@ export function loadAndCacheImages(series, callback) {
  * @function renderWebImage
  * @param {Object} file - The image File object
  * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
- * @param {Function} callback - Optional callback function with image object
+ * @returns {Promise} - Return a promise which will resolve when image is displayed
  */
-export const renderFileImage = function (file, elementId, callback) {
+export const renderFileImage = function (file, elementId) {
   let element = isElement(elementId)
     ? elementId
     : document.getElementById(elementId);
@@ -136,23 +136,23 @@ export const renderFileImage = function (file, elementId, callback) {
     cornerstone.enable(element);
   }
 
-  // check if imageId is already stored in fileManager
-  const imageId = getFileImageId(file);
-  if (imageId) {
-    cornerstone.loadImage(imageId).then(function (image) {
-      cornerstone.displayImage(element, image);
-      let viewport = cornerstone.getViewport(element);
-      viewport.displayedArea.brhc.x = image.width;
-      viewport.displayedArea.brhc.y = image.height;
-      cornerstone.setViewport(element, viewport);
-      cornerstone.fitToWindow(element);
-
-      csToolsCreateStack(element);
-      if (callback) {
-        callback(image);
-      }
-    });
-  }
+  let renderPromise = new Promise(resolve => {
+    // check if imageId is already stored in fileManager
+    const imageId = getFileImageId(file);
+    if (imageId) {
+      cornerstone.loadImage(imageId).then(function (image) {
+        cornerstone.displayImage(element, image);
+        let viewport = cornerstone.getViewport(element);
+        viewport.displayedArea.brhc.x = image.width;
+        viewport.displayedArea.brhc.y = image.height;
+        cornerstone.setViewport(element, viewport);
+        cornerstone.fitToWindow(element);
+        csToolsCreateStack(element);
+        resolve(image);
+      });
+    }
+  });
+  return renderPromise;
 };
 
 /**
@@ -161,6 +161,7 @@ export const renderFileImage = function (file, elementId, callback) {
  * @function renderWebImage
  * @param {String} url - The image data url
  * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
+ * @returns {Promise} - Return a promise which will resolve when image is displayed
  */
 export const renderWebImage = function (url, elementId) {
   let element = isElement(elementId)
@@ -170,12 +171,15 @@ export const renderWebImage = function (url, elementId) {
     console.error("invalid html element: " + elementId);
     return;
   }
-
-  cornerstone.enable(element);
-  cornerstone.loadImage(url).then(function (image) {
-    cornerstone.displayImage(element, image);
-    csToolsCreateStack(element);
+  let renderPromise = new Promise(resolve => {
+    cornerstone.enable(element);
+    cornerstone.loadImage(url).then(function (image) {
+      cornerstone.displayImage(element, image);
+      csToolsCreateStack(element);
+      resolve(image);
+    });
   });
+  return renderPromise;
 };
 
 /**
@@ -245,7 +249,7 @@ export const resizeViewport = function (elementId) {
  * @param {Object} seriesStack - The original series data object
  * @param {String} elementId - The html div id used for rendering or its DOM HTMLElement
  * @param {Object} defaultProps - Optional default props
- * @return {Promise} Return a promise when the image has been rendered succesfully
+ * @return {Promise} Return a promise which will resolve when image is displayed
  */
 export const renderImage = function (seriesStack, elementId, defaultProps) {
   let t0 = performance.now();

package/imaging/imageReslice.js

@@ -0,0 +1,78 @@
+/** @module imaging/imageReslice
+ *  @desc  This file provides functionalities for
+ *         image reslice in orthogonal directions
+ */
+
+// external libraries
+import { v4 as uuidv4 } from "uuid";
+import { each } from "lodash";
+
+// internal libraries
+import { getReslicedMetadata, getReslicedPixeldata } from "./imageUtils";
+import {
+  getLarvitarImageTracker,
+  getLarvitarManager
+} from "./loaders/commonLoader";
+import { larvitar_store } from "./imageStore";
+
+/*
+ * This module provides the following functions to be exported:
+ * resliceSeries(seriesId, seriesData, orientation)
+ */
+
+/**
+ * Reslice a serie from native orientation to coronal or sagittal orientation
+ * @instance
+ * @function resliceSeries
+ * @param {Object} seriesData the original series data
+ * @param {String} orientation the reslice orientation [coronal or sagittal]
+ * @param {String} seriesId the series id
+ * @returns {Promise} - Return a promise which will resolve when data is available
+ */
+export function resliceSeries(seriesData, orientation) {
+  let reslicePromise = new Promise(resolve => {
+    let reslicedSeries = {};
+    let reslicedSeriesId = uuidv4();
+    let reslicedMetaData = getReslicedMetadata(
+      reslicedSeriesId,
+      "axial",
+      orientation,
+      seriesData,
+      "resliceLoader"
+    );
+
+    reslicedSeries.imageIds = reslicedMetaData.imageIds;
+    reslicedSeries.instances = reslicedMetaData.instances;
+
+    reslicedSeries.currentImageIdIndex = Math.floor(
+      reslicedSeries.imageIds.length / 2
+    );
+
+    function computeReslice(seriesData, reslicedSeriesId, reslicedSeries) {
+      let t0 = performance.now();
+      let imageTracker = getLarvitarImageTracker();
+      let manager = getLarvitarManager();
+      each(reslicedSeries.imageIds, function (imageId) {
+        reslicedSeries.instances[imageId].pixelData = getReslicedPixeldata(
+          imageId,
+          seriesData,
+          reslicedSeries
+        );
+        imageTracker[imageId] = reslicedSeriesId;
+      });
+      larvitar_store.addSeriesIds(reslicedSeriesId, reslicedSeries.imageIds);
+      reslicedSeries.numberOfImages = reslicedSeries.imageIds.length;
+      reslicedSeries.seriesUID = reslicedSeriesId;
+      reslicedSeries.seriesDescription = seriesData.seriesDescription;
+      reslicedSeries.orientation = orientation;
+      manager[reslicedSeriesId] = reslicedSeries;
+      manager[seriesData.seriesUID][orientation] = reslicedSeriesId;
+      let t1 = performance.now();
+      console.log(`Call to resliceSeries took ${t1 - t0} milliseconds.`);
+      resolve(reslicedSeries);
+    }
+    // reslice the data
+    computeReslice(seriesData, reslicedSeriesId, reslicedSeries);
+  });
+  return reslicePromise;
+}