larvitar 1.5.13 → 2.0.0

package/imaging/loaders/{commonLoader.js → commonLoader.ts}

@@ -1,19 +1,27 @@
 /** @module loaders/commonLoader
  *  @desc This file provides functionalities for
- *        custom WadoImageLoaders
+ *        custom DICOMImageLoaders
  */
 
 // external libraries
 import { default as cornerstoneDICOMImageLoader } from "cornerstone-wado-image-loader";
+import { DataSet } from "dicom-parser";
 import { each } from "lodash";
 import { updateLoadedStack } from "../imageLoading";
+import type {
+  ImageObject,
+  ImageTracker,
+  LarvitarManager,
+  MetaData,
+  Series
+} from "../types";
 
 // internal libraries
 import { buildMultiFrameImage, clearMultiFrameCache } from "./multiframeLoader";
 
 // global variables
-var larvitarManager = null;
-var imageTracker = null;
+var larvitarManager: LarvitarManager = null;
+var imageTracker: ImageTracker = null;
 
 /*
  * This module provides the following functions to be exported:
@@ -25,6 +33,7 @@ var imageTracker = null;
  * removeSeriesFromLarvitarManager(seriesId)
  * getSeriesDataFromLarvitarManager(seriesId)
  * getImageFrame(metadata, dataSet)
+ * getSopInstanceUIDFromLarvitarManager(larvitarSeriesInstanceUID, imageId)
  */
 
 /**
@@ -33,21 +42,29 @@ var imageTracker = null;
  * @function updateLarvitarManager
  * @param {Object} imageObject The single dicom object
  * @param {String} customId - Optional custom id to overwrite seriesUID as default one
+ * @param {number} sliceIndex - Optional custom index to overwrite slice index as default one
  */
-export const updateLarvitarManager = function (imageObject, customId) {
+export const updateLarvitarManager = function (
+  imageObject: ImageObject,
+  customId?: string,
+  sliceIndex?: number
+) {
   if (larvitarManager === null) {
     larvitarManager = {};
   }
 
-  let seriesId = customId || imageObject.seriesUID;
   let data = { ...imageObject };
 
-  if (data.metadata.isMultiframe) {
-    seriesId = customId || imageObject.metadata.seriesUID;
-    updateLoadedStack(data, larvitarManager, customId);
-    buildMultiFrameImage(seriesId, larvitarManager[seriesId]);
+  if (data.metadata?.isMultiframe) {
+    let seriesId = customId || imageObject.metadata.seriesUID;
+    let loadedStack: ReturnType<typeof getLarvitarManager> = {};
+    updateLoadedStack(data, loadedStack, customId, sliceIndex);
+    buildMultiFrameImage(
+      seriesId as string,
+      loadedStack[seriesId as string] as Series
+    );
   } else {
-    updateLoadedStack(data, larvitarManager, customId);
+    updateLoadedStack(data, larvitarManager, customId, sliceIndex);
   }
   return larvitarManager;
 };
@@ -60,7 +77,10 @@ export const updateLarvitarManager = function (imageObject, customId) {
  * @param {Object} seriesData The series data
  * @returns {manager} the Larvitar manager
  */
-export const populateLarvitarManager = function (seriesId, seriesData) {
+export const populateLarvitarManager = function (
+  seriesId: string,
+  seriesData: Series
+) {
   if (larvitarManager === null) {
     larvitarManager = {};
   }
@@ -106,20 +126,23 @@ export const getLarvitarImageTracker = function () {
  */
 export const resetLarvitarManager = function () {
   each(larvitarManager, function (stack) {
-    if (stack.isMultiframe) {
-      if (stack.dataSet) {
-        stack.dataSet.byteArray = null;
+    if ((stack as Series).isMultiframe) {
+      if ((stack as Series).dataSet) {
+        //@ts-ignore for memory leak
+        (stack as Series).dataSet!.byteArray = null;
       }
-      stack.dataSet = null;
-      stack.elements = null;
+      (stack as Series).dataSet = null;
+      (stack as Series).elements = null;
       clearMultiFrameCache(stack.seriesUID);
     }
     each(stack.instances, function (instance) {
       if (instance.dataSet) {
+        //@ts-ignore for memory leak
         instance.dataSet.byteArray = null;
       }
       instance.dataSet = null;
       instance.file = null;
+      //@ts-ignore for memory leak
       instance.metadata = null;
     });
   });
@@ -133,22 +156,26 @@ export const resetLarvitarManager = function () {
  * @function removeSeriesFromLarvitarManager
  * @param {String} seriesId The Id of the series
  */
-export const removeSeriesFromLarvitarManager = function (seriesId) {
+export const removeSeriesFromLarvitarManager = function (seriesId: string) {
   if (larvitarManager && larvitarManager[seriesId]) {
-    if (larvitarManager[seriesId].isMultiframe) {
-      larvitarManager[seriesId].dataSet.byteArray = null;
-      larvitarManager[seriesId].dataSet = null;
-      larvitarManager[seriesId].elements = null;
+    if ((larvitarManager[seriesId] as Series).isMultiframe) {
+      //@ts-ignore for memory leak
+      (larvitarManager[seriesId] as Series).dataSet.byteArray = null;
+      (larvitarManager[seriesId] as Series).dataSet = null;
+      (larvitarManager[seriesId] as Series).elements = null;
       clearMultiFrameCache(seriesId);
     }
     each(larvitarManager[seriesId].instances, function (instance) {
       if (instance.dataSet) {
+        //@ts-ignore for memory leak
         instance.dataSet.byteArray = null;
       }
       instance.dataSet = null;
       instance.file = null;
+      //@ts-ignore for memory leak
       instance.metadata = null;
     });
+    //@ts-ignore for memory leak
     larvitarManager[seriesId] = null;
     delete larvitarManager[seriesId];
   }
@@ -161,7 +188,7 @@ export const removeSeriesFromLarvitarManager = function (seriesId) {
  * @param {String} seriesId The Id of the series
  * @return {Object} larvitar manager data
  */
-export const getSeriesDataFromLarvitarManager = function (seriesId) {
+export const getSeriesDataFromLarvitarManager = function (seriesId: string) {
   return larvitarManager ? larvitarManager[seriesId] : null;
 };
 
@@ -173,7 +200,7 @@ export const getSeriesDataFromLarvitarManager = function (seriesId) {
  * @param {Object} dataSet dicom dataset
  * @returns {Object} specific image frame
  */
-export const getImageFrame = function (metadata, dataSet) {
+export const getImageFrame = function (metadata: MetaData, dataSet: DataSet) {
   let imagePixelModule;
 
   if (dataSet) {
@@ -221,6 +248,28 @@ export const getImageFrame = function (metadata, dataSet) {
       imagePixelModule.greenPaletteColorLookupTableData,
     bluePaletteColorLookupTableData:
       imagePixelModule.bluePaletteColorLookupTableData,
-    pixelData: undefined // populated later after decoding
+    pixelData: undefined, // populated later after decoding,
+    ImageData: undefined
   };
 };
+
+/**
+ * Return the SOP Instance UID of a specific imageId stored in the Larvitar Manager
+ * @instance
+ * @function getSopInstanceUIDFromLarvitarManager
+ * @param {String} larvitarSeriesInstanceUID The Id of the series
+ * @param {String} imageId The Id of the image
+ * @returns {String} sopInstanceUID
+ */
+export const getSopInstanceUIDFromLarvitarManager = function (
+  larvitarSeriesInstanceUID: string,
+  imageId: string
+) {
+  if (larvitarManager === null) {
+    return null;
+  }
+  let series = larvitarManager[larvitarSeriesInstanceUID];
+  return Object.keys(series.instanceUIDs).find(
+    key => series.instanceUIDs[key] === imageId
+  );
+};

package/imaging/loaders/{dicomLoader.js → dicomLoader.ts}

@@ -4,25 +4,45 @@
  */
 
 // internal libraries
-import { loadAndCacheImages } from "../imageRendering";
+import { loadAndCacheImage, loadAndCacheImages } from "../imageRendering";
+import type { Series, CachingResponse } from "../types";
 
 /*
  * This module provides the following functions to be exported:
+ * cacheImage(seriesData, imageIndex)
  * cacheImages(seriesData, callback)
  * getDicomImageId(dicomLoaderName)
  */
 
 let imageLoaderCounter = 0;
 
+/**
+ * Load and cache a single image
+ * @instance
+ * @function cacheImage
+ * @param {Object} seriesData The series data
+ * @param {number} imageIndex The image index in the imageIds array
+ */
+
+export const cacheImage = async function (
+  seriesData: Series,
+  imageIndex: number
+) {
+  return loadAndCacheImage(seriesData, imageIndex);
+};
+
 /**
  * Load and cache images
  * @instance
  * @function cacheImages
  * @param {Object} seriesData The series data
- * @param {Function} callback An optional callback function
+ * @param {Function} callback Optional callback function
  */
-export const cacheImages = function (seriesData, callback) {
-  loadAndCacheImages(seriesData, function (resp) {
+export const cacheImages = async function (
+  seriesData: Series,
+  callback?: Function
+) {
+  loadAndCacheImages(seriesData, function (resp: CachingResponse) {
     if (resp.loading == 100) {
       imageLoaderCounter += seriesData.imageIds.length;
     }
@@ -39,7 +59,7 @@ export const cacheImages = function (seriesData, callback) {
  * @param {String} dicomLoaderName dicom loader name
  * @return {String} current dicom image id
  */
-export const getDicomImageId = function (dicomLoaderName) {
+export const getDicomImageId = function (dicomLoaderName: string) {
   let imageId = dicomLoaderName + ":" + imageLoaderCounter;
   imageLoaderCounter++;
   return imageId;

package/imaging/loaders/{fileLoader.js → fileLoader.ts}

@@ -12,7 +12,9 @@ import { clearImageCache } from "../imageRendering";
 import { clearCornerstoneElements } from "../imageTools";
 
 // global variables
-export var fileManager = {};
+export var fileManager: {
+  [key: string]: string;
+} = {};
 
 /*
  * This module provides the following functions to be exported:
@@ -48,7 +50,7 @@ export const resetFileManager = function () {
  * @function populateFileManager
  * @return {String} current file image id
  */
-export const populateFileManager = function (file) {
+export const populateFileManager = function (file: File) {
   let uuid = file.webkitRelativePath || file.name;
   if (!has(fileManager, uuid)) {
     const imageId = cornerstoneFileImageLoader.fileManager.add(file);
@@ -62,10 +64,8 @@ export const populateFileManager = function (file) {
  * @function getFileImageId
  * @return {String} current file image id
  */
-export const getFileImageId = function (file) {
+export const getFileImageId = function (file: File) {
   let uuid = file.webkitRelativePath || file.name;
   const imageId = has(fileManager, uuid) ? fileManager[uuid] : null;
   return imageId;
 };
-
-/* Internal module functions */