larvitar 2.0.4 → 2.0.6

package/imaging/loaders/commonLoader.ts

@@ -1,275 +0,0 @@
-/** @module loaders/commonLoader
- *  @desc This file provides functionalities for
- *        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: LarvitarManager = null;
-var imageTracker: ImageTracker = null;
-
-/*
- * This module provides the following functions to be exported:
- * updateLarvitarManager(imageObject)
- * populateLarvitarManager(seriesId, seriesData)
- * getLarvitarManager()
- * getLarvitarImageTracker()
- * resetLarvitarManager()
- * removeSeriesFromLarvitarManager(seriesId)
- * getSeriesDataFromLarvitarManager(seriesId)
- * getImageFrame(metadata, dataSet)
- * getSopInstanceUIDFromLarvitarManager(larvitarSeriesInstanceUID, imageId)
- */
-
-/**
- * Update and initialize larvitar manager in order to parse and load a single dicom object
- * @instance
- * @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: ImageObject,
-  customId?: string,
-  sliceIndex?: number
-) {
-  if (larvitarManager === null) {
-    larvitarManager = {};
-  }
-
-  let data = { ...imageObject };
-
-  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, sliceIndex);
-  }
-  return larvitarManager;
-};
-
-/**
- * This function can be called in order to populate the Larvitar manager
- * @instance
- * @function populateLarvitarManager
- * @param {String} seriesId The Id of the series
- * @param {Object} seriesData The series data
- * @returns {manager} the Larvitar manager
- */
-export const populateLarvitarManager = function (
-  seriesId: string,
-  seriesData: Series
-) {
-  if (larvitarManager === null) {
-    larvitarManager = {};
-  }
-  let data = { ...seriesData };
-  if (data.isMultiframe) {
-    buildMultiFrameImage(seriesId, data);
-  } else {
-    larvitarManager[seriesId] = data;
-  }
-  return larvitarManager;
-};
-
-/**
- * Return the common data loader manager
- * @instance
- * @function getLarvitarManager
- * @returns {Object} the loader manager
- */
-export const getLarvitarManager = function () {
-  if (larvitarManager == null) {
-    larvitarManager = {};
-  }
-  return larvitarManager;
-};
-
-/**
- * Return the common image tracker
- * @instance
- * @function getLarvitarImageTracker
- * @returns {Object} the image tracker
- */
-export const getLarvitarImageTracker = function () {
-  if (imageTracker == null) {
-    imageTracker = {};
-  }
-  return imageTracker;
-};
-
-/**
- * Reset the Larvitar Manager store
- * @instance
- * @function resetLarvitarManager
- */
-export const resetLarvitarManager = function () {
-  each(larvitarManager, function (stack) {
-    if ((stack as Series).isMultiframe) {
-      if ((stack as Series).dataSet) {
-        //@ts-ignore for memory leak
-        (stack as Series).dataSet!.byteArray = 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;
-    });
-  });
-  larvitarManager = null;
-  imageTracker = null;
-};
-
-/**
- * Remove a stored seriesId from the larvitar Manager
- * @instance
- * @function removeSeriesFromLarvitarManager
- * @param {String} seriesId The Id of the series
- */
-export const removeSeriesFromLarvitarManager = function (seriesId: string) {
-  if (larvitarManager && larvitarManager[seriesId]) {
-    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];
-  }
-};
-
-/**
- * Return the data of a specific seriesId stored in the DICOM Manager
- * @instance
- * @function getSeriesDataFromLarvitarManager
- * @param {String} seriesId The Id of the series
- * @return {Object} larvitar manager data
- */
-export const getSeriesDataFromLarvitarManager = function (seriesId: string) {
-  return larvitarManager ? larvitarManager[seriesId] : null;
-};
-
-/**
- * Compute and return image frame
- * @instance
- * @function getImageFrame
- * @param {Object} metadata metadata object
- * @param {Object} dataSet dicom dataset
- * @returns {Object} specific image frame
- */
-export const getImageFrame = function (metadata: MetaData, dataSet: DataSet) {
-  let imagePixelModule;
-
-  if (dataSet) {
-    imagePixelModule =
-      cornerstoneDICOMImageLoader.wadouri.metaData.getImagePixelModule(dataSet);
-  } else {
-    imagePixelModule = {
-      samplesPerPixel: metadata.x00280002,
-      photometricInterpretation: metadata.x00280004,
-      planarConfiguration: metadata.x00280006,
-      rows: metadata.x00280010,
-      columns: metadata.x00280011,
-      bitsAllocated: metadata.x00280100,
-      pixelRepresentation: metadata.x00280103,
-      smallestPixelValue: metadata.x00280106,
-      largestPixelValue: metadata.x00280107,
-      redPaletteColorLookupTableDescriptor: metadata.x00281101,
-      greenPaletteColorLookupTableDescriptor: metadata.x00281102,
-      bluePaletteColorLookupTableDescriptor: metadata.x00281103,
-      redPaletteColorLookupTableData: metadata.x00281201,
-      greenPaletteColorLookupTableData: metadata.x00281202,
-      bluePaletteColorLookupTableData: metadata.x00281203
-    };
-  }
-
-  return {
-    samplesPerPixel: imagePixelModule.samplesPerPixel,
-    photometricInterpretation: imagePixelModule.photometricInterpretation,
-    planarConfiguration: imagePixelModule.planarConfiguration,
-    rows: imagePixelModule.rows,
-    columns: imagePixelModule.columns,
-    bitsAllocated: imagePixelModule.bitsAllocated,
-    pixelRepresentation: imagePixelModule.pixelRepresentation, // 0 = unsigned,
-    smallestPixelValue: imagePixelModule.smallestPixelValue,
-    largestPixelValue: imagePixelModule.largestPixelValue,
-    redPaletteColorLookupTableDescriptor:
-      imagePixelModule.redPaletteColorLookupTableDescriptor,
-    greenPaletteColorLookupTableDescriptor:
-      imagePixelModule.greenPaletteColorLookupTableDescriptor,
-    bluePaletteColorLookupTableDescriptor:
-      imagePixelModule.bluePaletteColorLookupTableDescriptor,
-    redPaletteColorLookupTableData:
-      imagePixelModule.redPaletteColorLookupTableData,
-    greenPaletteColorLookupTableData:
-      imagePixelModule.greenPaletteColorLookupTableData,
-    bluePaletteColorLookupTableData:
-      imagePixelModule.bluePaletteColorLookupTableData,
-    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.ts

@@ -1,66 +0,0 @@
-/** @module loaders/dicomLoader
- *  @desc This file provides functionalities for
- *        custom DICOM Loader
- */
-
-// internal libraries
-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 Optional callback function
- */
-export const cacheImages = async function (
-  seriesData: Series,
-  callback?: Function
-) {
-  loadAndCacheImages(seriesData, function (resp: CachingResponse) {
-    if (resp.loading == 100) {
-      imageLoaderCounter += seriesData.imageIds.length;
-    }
-    if (callback) {
-      callback(resp);
-    }
-  });
-};
-
-/**
- * Get the dicom imageId from dicom loader
- * @instance
- * @function getDicomImageId
- * @param {String} dicomLoaderName dicom loader name
- * @return {String} current dicom image id
- */
-export const getDicomImageId = function (dicomLoaderName: string) {
-  let imageId = dicomLoaderName + ":" + imageLoaderCounter;
-  imageLoaderCounter++;
-  return imageId;
-};

package/imaging/loaders/fileLoader.ts

@@ -1,71 +0,0 @@
-/** @module loaders/fileLoader
- *  @desc This file provides functionalities for
- *        custom File Loader
- */
-
-// external libraries
-import cornerstoneFileImageLoader from "cornerstone-file-image-loader";
-import { has } from "lodash";
-
-// internal libraries
-import { clearImageCache } from "../imageRendering";
-import { clearCornerstoneElements } from "../imageTools";
-
-// global variables
-export var fileManager: {
-  [key: string]: string;
-} = {};
-
-/*
- * This module provides the following functions to be exported:
- * resetFileLoader()
- * resetFileManager()
- * populateFileManager(file)
- * getFileImageId(file)
- */
-
-/**
- * Reset the Custom File Loader
- * @instance
- * @function resetFileLoader
- */
-export const resetFileLoader = function () {
-  clearCornerstoneElements();
-  resetFileManager();
-  clearImageCache();
-};
-
-/**
- * Reset the File Manager store
- * @instance
- * @function resetFileManager
- */
-export const resetFileManager = function () {
-  fileManager = {};
-};
-
-/**
- * Populate File Manager
- * @instance
- * @function populateFileManager
- * @return {String} current file image id
- */
-export const populateFileManager = function (file: File) {
-  let uuid = file.webkitRelativePath || file.name;
-  if (!has(fileManager, uuid)) {
-    const imageId = cornerstoneFileImageLoader.fileManager.add(file);
-    fileManager[uuid] = imageId;
-  }
-};
-
-/**
- * Get the file imageId from file loader
- * @instance
- * @function getFileImageId
- * @return {String} current file image id
- */
-export const getFileImageId = function (file: File) {
-  let uuid = file.webkitRelativePath || file.name;
-  const imageId = has(fileManager, uuid) ? fileManager[uuid] : null;
-  return imageId;
-};