larvitar 1.5.13 → 2.0.0

package/imaging/monitors/{memory.js → memory.ts}

@@ -3,18 +3,60 @@
  *        monitoring memory usage
  */
 
+import {
+  getLarvitarManager,
+  removeSeriesFromLarvitarManager
+} from "../loaders/commonLoader";
+import { clearImageCache } from "../imageRendering";
+import store from "../imageStore";
+
+// Custom types for chrome
+interface Performance {
+  memory?: any;
+}
+
 // global module variables
 const backingMemory = 100 * 1048576; // 100 MB
-var customMemoryLimit = null;
+var customMemoryLimit: number | null = null;
 
 /*
  * This module provides the following functions to be exported:
- * checkMemoryAllocation()
+ * checkAndClearMemory(bytes, [seriesUUIDs])
+ * checkMemoryAllocation(bytes)
  * getUsedMemory()
  * getAvailableMemory()
  * setAvailableMemory()
  */
 
+/**
+ * Check memory allocation and clear memory if needed
+ * @instance
+ * @function checkAndClearMemory
+ * @param {Number} - Number of bytes to allocate
+ * @param {Array} - Rendered Series ids
+ */
+export const checkAndClearMemory = function (
+  bytes: number,
+  renderedSeriesIds: string[]
+) {
+  const isEnough = checkMemoryAllocation(bytes);
+  if (isEnough === false) {
+    const manager = getLarvitarManager();
+    // get all key of manager and create a list
+    const seriesIds = Object.keys(manager);
+    // create a list of non rendered series ids
+    const nonRenderedSeriesIds = seriesIds.filter(
+      seriesId => !renderedSeriesIds.includes(seriesId)
+    );
+    // remove non rendered series from manager
+    nonRenderedSeriesIds.forEach(seriesId => {
+      removeSeriesFromLarvitarManager(seriesId);
+      clearImageCache(seriesId);
+      store.removeSeriesId(seriesId);
+    });
+  }
+};
+
 /**
  * Check memory allocation and returns false if js Heap size has reached its limit
  * @instance
@@ -22,7 +64,7 @@ var customMemoryLimit = null;
  * @param {Number} - Number of bytes to allocate
  * @return {Boolean} - Returns a boolean flag to warn the user about memory allocation limit
  */
-export const checkMemoryAllocation = function (bytes) {
+export const checkMemoryAllocation = function (bytes: number) {
   if (checkMemorySupport()) {
     let usedMemory = getUsedMemory();
     let availableMemory = getAvailableMemory();
@@ -50,7 +92,9 @@ export const checkMemoryAllocation = function (bytes) {
  * @return {Number} - Returns used JSHeapSize in bytes or NaN if not supported
  */
 export const getUsedMemory = function () {
-  return checkMemorySupport() ? performance.memory.usedJSHeapSize : NaN;
+  return checkMemorySupport()
+    ? (performance as Performance).memory.usedJSHeapSize
+    : NaN;
 };
 
 /**
@@ -63,7 +107,7 @@ export const getAvailableMemory = function () {
   if (checkMemorySupport()) {
     return customMemoryLimit
       ? customMemoryLimit
-      : performance.memory.jsHeapSizeLimit - backingMemory;
+      : (performance as Performance).memory.jsHeapSizeLimit - backingMemory;
   } else {
     return NaN;
   }
@@ -75,7 +119,7 @@ export const getAvailableMemory = function () {
  * @function setAvailableMemory
  * @param {Number} - Number of GB to set as maximum custom memory limit
  */
-export const setAvailableMemory = function (value) {
+export const setAvailableMemory = function (value: number) {
   customMemoryLimit = value * 1024 * 1024 * 1024;
 };
 
@@ -90,7 +134,9 @@ export const setAvailableMemory = function (value) {
  * @return {Boolean} - Returns memory object or false if not supported
  */
 const checkMemorySupport = function () {
-  return performance.memory ? performance.memory : false;
+  return (performance as Performance).memory
+    ? (performance as Performance).memory
+    : false;
 };
 
 /**
@@ -100,6 +146,6 @@ const checkMemorySupport = function () {
  * @param {Number} bytes - Memory in bytes
  * @return {Number} - Memory in MB
  */
-const getMB = function (bytes) {
+const getMB = function (bytes: number) {
   return bytes / 1048576;
 };

package/imaging/monitors/performance.ts

@@ -0,0 +1,34 @@
+/** @module monitors/performance
+ *  @desc This file provides utility functions for
+ *        monitoring performance usage
+ */
+
+var PERFORMANCE_MONITOR = false;
+
+/**
+ * Get performance monitor
+ * @instance
+ * @function getPerformanceMonitor
+ * @returns {Boolean} - Performance monitor status
+ */
+export const getPerformanceMonitor = function () {
+  return PERFORMANCE_MONITOR;
+};
+
+/**
+ * Set performance monitor ON
+ * @instance
+ * @function activatePerformanceMonitor
+ */
+export const activatePerformanceMonitor = function () {
+  PERFORMANCE_MONITOR = true;
+};
+
+/**
+ * Set performance monitor OFF
+ * @instance
+ * @function deactivatePerformanceMonitor
+ */
+export const deactivatePerformanceMonitor = function () {
+  PERFORMANCE_MONITOR = false;
+};

package/imaging/parsers/ecg.ts

@@ -0,0 +1,51 @@
+/** @module imaging/parsers/ecg
+ *  @desc  This file provides functionalities for
+ *         handling ECG signales in DICOM files
+ */
+
+import { DataSet, Element } from "dicom-parser";
+
+/*
+ * This module provides the following functions to be exported:
+ * parseECG(dataSet, tag, nSampling)
+ */
+
+/**
+ * Generate an array of points representing the ECG signal
+ * @instance
+ * @function parseECG
+ * @param {DataSet} dataSet - the DICOM dataset
+ * @param {String} tag - the tag of the ECG signal
+ * @param {Number} nSampling - the sampling rate
+ * @returns {Array} An array of points representing the ECG signal
+ */
+export function parseECG(
+  dataSet: DataSet,
+  tag: string,
+  nSampling: number
+): number[] {
+  const element: Element = dataSet.elements[tag];
+  let data: Uint8Array = dataSet.byteArray.slice(
+    element.dataOffset,
+    element.dataOffset + element.length
+  );
+  let points: number[] = [];
+  const nCountFrom: number = data.length / 2;
+  const nCountTo: number = Math.floor(0.5 + nCountFrom / nSampling);
+  let values: number[] = [];
+  let nFrom: number = 0;
+  for (let nTo: number = 0; nTo < nCountTo; nTo++) {
+    let v: number = data[nFrom] + 255 * data[nFrom + 1];
+    values.push(v);
+    nFrom += nSampling * 2;
+  }
+
+  const nMax: number = Math.max(...values);
+  const nMin: number = Math.min(...values);
+
+  for (let nTo: number = 0; nTo < nCountTo; nTo++) {
+    let data: number = ((values[nTo] - nMin) / (nMax - nMin)) * 100;
+    points.push(data);
+  }
+  return points;
+}

package/imaging/tools/README.md

@@ -0,0 +1,27 @@
+# Tools Management
+
+## Default tools
+
+In `default.ts` the list of Larvitar default tools is exported as `DEFAULT_TOOLS`, along with their default configuration, that extendes the cornerstoneTools configuration with these properties:
+
+```
+{
+    name : toolName (string),
+    viewports : "all" or [array of target viewports],
+    configuration : configuration {object},
+    options : options {object},
+    class : cornerstone tool library class name (ie "LengthTool" for Length tool),
+    sync : cornerstone synchronizer name (ie "wwwcSynchronizer" for Wwwc sync tool),
+    cleanable : if true, this tool will be removed when calling "no tools",
+    defaultActive : if true, this tool will be activated when calling "addDefaultTools",
+    shortcut : keyboard shortcut [not implemented],
+    type : tool category inside Larvitar (one of: "utils", "annotation", "segmentation", "overlay"),
+    description: a string that describes the tool (eg to be shown in a tooltip)
+}
+```
+
+These are the tools that will be added calling `addDefaultTools`. User can override defaults calling `setDefaultToolsProps`.
+
+## External Tools
+
+User can add custom tools calling `registerExternalTool`. The tool will be registered in the dvTools object and in DEFAULT*TOOLS array. If done \_before* adding the tools with `addDefaultTools`, the tool will be added automatically along with the default ones. Otherwise, the user can simply add its tool using `addTool`.

package/imaging/tools/custom/4dSliceScrollTool.js

@@ -1,8 +1,8 @@
 /** @module imaging/tools/custom/4dSliceScrollTool
- *  @desc  This file provides functionalities for an alternative scroll tool 
+ *  @desc  This file provides functionalities for an alternative scroll tool
  *  to handle 4d exam and navigate to the correct slice
- *         
- *         
+ *
+ *
  */
 
 // external libraries
@@ -11,9 +11,9 @@ const external = cornerstoneTools.external;
 
 const BaseTool = cornerstoneTools.importInternal("base/BaseTool");
 const scroll = cornerstoneTools.importInternal("util/scroll");
-const  scrollToIndex = cornerstoneTools.importInternal("util/scrollToIndex");
+const scrollToIndex = cornerstoneTools.importInternal("util/scrollToIndex");
 const getToolState = cornerstoneTools.getToolState;
-const clip =  cornerstoneTools.importInternal("util/clip");
+const clip = cornerstoneTools.importInternal("util/clip");
 
 /**
  * @public
@@ -26,25 +26,23 @@ const clip =  cornerstoneTools.importInternal("util/clip");
 export default class Slice4DScrollMouseWheelTool extends BaseTool {
   constructor(props = {}) {
     const defaultProps = {
-      name: 'Slice4DScrollMouseWheel',
-      supportedInteractionTypes: ['MouseWheel'],
+      name: "Slice4DScrollMouseWheel",
+      supportedInteractionTypes: ["MouseWheel"],
       configuration: {
         loop: false,
         allowSkipping: true,
-        invert: false,
-      },
+        invert: false
+      }
     };
-    console.log('building wheel tool');
     super(props, defaultProps);
   }
 
   mouseWheelCallback(evt) {
     const { direction: images, element } = evt.detail;
     const { loop, allowSkipping, invert, framesNumber } = this.configuration;
-    const direction = invert ? (images * framesNumber)*(-1) : (images * framesNumber);
-    console.log('wheel callback');
-    console.log('Images ', images);
-    console.log('Direction ', direction);
+    const direction = invert
+      ? images * framesNumber * -1
+      : images * framesNumber;
     scroll(element, direction, loop, allowSkipping);
     // scroll4DSlices(element, direction, loop, allowSkipping);
   }
@@ -60,41 +58,44 @@ export default class Slice4DScrollMouseWheelTool extends BaseTool {
  * @param  {type} [allowSkipping = true]  Whether frames can be skipped.
  * @returns {void}
  */
-const scroll4DSlices = function(element, images, loop, allowSkipping, framesNumber) {
-    const toolData = getToolState(element, 'stack');
+const scroll4DSlices = function (
+  element,
+  images,
+  loop,
+  allowSkipping,
+  framesNumber
+) {
+  const toolData = getToolState(element, "stack");
+
+  if (!toolData || !toolData.data || !toolData.data.length) {
+    return;
+  }
 
-    if (!toolData || !toolData.data || !toolData.data.length) {
-        return;
-    }
+  const stackData = toolData.data[0];
 
-    const stackData = toolData.data[0];
+  if (!stackData.pending) {
+    stackData.pending = [];
+  }
 
-    if (!stackData.pending) {
-        stackData.pending = [];
-    }
-    
-    let newImageIdIndex = stackData.currentImageIdIndex + images ;//+ 1 + framesNumber;
-    console.log('currentImageIdIndex', stackData.currentImageIdIndex)
-    console.log('newImageIdIndex calculated ', newImageIdIndex);
-    if (loop) {
-        const nbImages = stackData.imageIds.length;
-        newImageIdIndex %= nbImages;
-    } else {
-        newImageIdIndex = clip(newImageIdIndex, 0, stackData.imageIds.length - 1);
-        console.log('newImageIdIndex after clip  ', newImageIdIndex);
-    }
+  let newImageIdIndex = stackData.currentImageIdIndex + images; //+ 1 + framesNumber;
+  if (loop) {
+    const nbImages = stackData.imageIds.length;
+    newImageIdIndex %= nbImages;
+  } else {
+    newImageIdIndex = clip(newImageIdIndex, 0, stackData.imageIds.length - 1);
+  }
 
-    if (allowSkipping) {
-        scrollToIndex(element, newImageIdIndex);
-    } else {
-        const pendingEvent = {
-          index: newImageIdIndex,
-        };
+  if (allowSkipping) {
+    scrollToIndex(element, newImageIdIndex);
+  } else {
+    const pendingEvent = {
+      index: newImageIdIndex
+    };
 
-        stackData.pending.push(pendingEvent);
-        scrollWithoutSkipping(stackData, pendingEvent, element);
-    }
-}
+    stackData.pending.push(pendingEvent);
+    scrollWithoutSkipping(stackData, pendingEvent, element);
+  }
+};
 
 /**
  * Recursively scrolls the stack until the desired image is reached.
@@ -119,7 +120,7 @@ function scrollWithoutSkipping(stackData, pendingEvent, element) {
       return;
     }
 
-    const newImageHandler = function(event) {
+    const newImageHandler = function (event) {
       const index = stackData.imageIds.indexOf(event.detail.image.imageId);
 
       if (index === pendingEvent.index) {
@@ -142,4 +143,4 @@ function scrollWithoutSkipping(stackData, pendingEvent, element) {
 
     scrollToIndex(element, pendingEvent.index);
   }
-}
+}