larvitar 1.5.8 → 1.5.10

package/README.md

@@ -6,9 +6,8 @@
 
 ## Dicom Image Toolkit for CornerstoneJS
 
-### Current version: 1.5.8
-
-### Latest Published Release: 1.5.8
+### Current version: 1.5.10
+### Latest Published Release: 1.5.10
 
 This library provides common DICOM functionalities to be used in web-applications: it's wrapper that simplifies the use of cornerstone-js environment.
 Orthogonal multiplanar reformat is included as well as custom loader/exporter for nrrd files and [Vuex](https://vuex.vuejs.org/) custom integration.
@@ -40,6 +39,7 @@ Orthogonal multiplanar reformat is included as well as custom loader/exporter fo
 - `tools/custom/editMaskTool` is a custom cornerstone tool for 2D visualization of segmentation masks with brush functionalities
 - `tools/custom/seedTool` is a custom cornerstone tool for 2D interactive seeding with custom colors and labels
 - `tools/custom/thresholdsBrushTool` is a custom cornerstone tool for handling thresholds in a brush tool
+- `tools/custom/Slice4DScrollMouseWheel` is a custom cornerstone tool for handling navigation of slices in a 4D DICOM series
 - `tools/default` default tools map and configuration
 - `tools/io` import and export functionalities for tools
 - `tools/main` tools main functionalities

package/imaging/imageStore.js

@@ -3,6 +3,7 @@
  *        for data config store.
  */
 
+import { defineVue } from "../modules/vuex/larvitar";
 import larvitar from "../modules/vuex/larvitar";
 
 // external libraries
@@ -312,7 +313,7 @@ export function initLarvitarStore(vuexStore, vuexModule, registerModule, _Vue) {
   if (vuexStore) {
     larvitar_store = new Larvitar_Store(vuexStore, vuexModule);
     if (registerModule) {
-      larvitar.defineVue(_Vue);
+      defineVue(_Vue);
       vuexStore.registerModule(vuexModule, larvitar);
     }
   } else {

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

@@ -0,0 +1,145 @@
+/** @module imaging/tools/custom/4dSliceScrollTool
+ *  @desc  This file provides functionalities for an alternative scroll tool 
+ *  to handle 4d exam and navigate to the correct slice
+ *         
+ *         
+ */
+
+// external libraries
+import cornerstoneTools from "cornerstone-tools";
+const external = cornerstoneTools.external;
+
+const BaseTool = cornerstoneTools.importInternal("base/BaseTool");
+const scroll = cornerstoneTools.importInternal("util/scroll");
+const  scrollToIndex = cornerstoneTools.importInternal("util/scrollToIndex");
+const getToolState = cornerstoneTools.getToolState;
+const clip =  cornerstoneTools.importInternal("util/clip");
+
+/**
+ * @public
+ * @class 4DScrollMouseWheelTool
+ * @memberof Tools
+ *
+ * @classdesc Tool for scrolling through a series using the mouse wheel.
+ * @extends Tools.Base.BaseTool
+ */
+export default class Slice4DScrollMouseWheelTool extends BaseTool {
+  constructor(props = {}) {
+    const defaultProps = {
+      name: 'Slice4DScrollMouseWheel',
+      supportedInteractionTypes: ['MouseWheel'],
+      configuration: {
+        loop: false,
+        allowSkipping: true,
+        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);
+    scroll(element, direction, loop, allowSkipping);
+    // scroll4DSlices(element, direction, loop, allowSkipping);
+  }
+}
+/**
+ * Scrolls through the slice of a 4D stack.
+ * @export @public @method
+ * @name scroll4DSlices
+ *
+ * @param  {HTMLElement} element          The element to scroll.
+ * @param  {number} images                The number of images to scroll through.
+ * @param  {type} [loop = false]          Whether to loop the scrolling.
+ * @param  {type} [allowSkipping = true]  Whether frames can be skipped.
+ * @returns {void}
+ */
+const scroll4DSlices = function(element, images, loop, allowSkipping, framesNumber) {
+    const toolData = getToolState(element, 'stack');
+
+    if (!toolData || !toolData.data || !toolData.data.length) {
+        return;
+    }
+
+    const stackData = toolData.data[0];
+
+    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);
+    }
+
+    if (allowSkipping) {
+        scrollToIndex(element, newImageIdIndex);
+    } else {
+        const pendingEvent = {
+          index: newImageIdIndex,
+        };
+
+        stackData.pending.push(pendingEvent);
+        scrollWithoutSkipping(stackData, pendingEvent, element);
+    }
+}
+
+/**
+ * Recursively scrolls the stack until the desired image is reached.
+ * @private
+ * @method
+ * @name scrollWithoutSkipping
+ *
+ * @param  {type} stackData    Data object containing information about the stack.
+ * @param  {Object} pendingEvent The event to process next.
+ * @param  {HTMLElement} element      The element being scrolled through.
+ * @returns {void}
+ */
+function scrollWithoutSkipping(stackData, pendingEvent, element) {
+  if (stackData.pending[0] === pendingEvent) {
+    if (stackData.currentImageIdIndex === pendingEvent.index) {
+      stackData.pending.splice(stackData.pending.indexOf(pendingEvent), 1);
+
+      if (stackData.pending.length > 0) {
+        scrollWithoutSkipping(stackData, stackData.pending[0], element);
+      }
+
+      return;
+    }
+
+    const newImageHandler = function(event) {
+      const index = stackData.imageIds.indexOf(event.detail.image.imageId);
+
+      if (index === pendingEvent.index) {
+        stackData.pending.splice(stackData.pending.indexOf(pendingEvent), 1);
+        element.removeEventListener(
+          external.cornerstone.EVENTS.NEW_IMAGE,
+          newImageHandler
+        );
+
+        if (stackData.pending.length > 0) {
+          scrollWithoutSkipping(stackData, stackData.pending[0], element);
+        }
+      }
+    };
+
+    element.addEventListener(
+      external.cornerstone.EVENTS.NEW_IMAGE,
+      newImageHandler
+    );
+
+    scrollToIndex(element, pendingEvent.index);
+  }
+}

package/imaging/tools/default.js

@@ -27,6 +27,7 @@
 
 import { filter, isArray } from "lodash";
 import ThresholdsBrushTool from "./custom/thresholdsBrushTool";
+import Slice4DScrollMouseWheelTool from "./custom/4dSliceScrollTool";
 import PolylineScissorsTool from "./custom/polylineScissorsTool";
 
 /**
@@ -108,9 +109,23 @@ const DEFAULT_TOOLS = {
       invert: false
     },
     cleanable: false,
-    defaultActive: true,
+    defaultActive: false,
     class: "StackScrollMouseWheelTool"
   },
+  Slice4DScrollMouseWheel: {
+    name: "Slice4DScrollMouseWheel",
+    viewports: "all",
+    configuration: {
+      loop: false, // default false
+      allowSkipping: false, // default true
+      invert: false,
+      framesNumber: 1
+    },
+    options: {},
+    cleanable: false,
+    defaultActive: true,
+    class: "Slice4DScrollMouseWheelTool"
+  },
   Pan: {
     name: "Pan",
     viewports: "all",
@@ -398,7 +413,8 @@ const DEFAULT_TOOLS = {
  */
 const dvTools = {
   ThresholdsBrushTool: ThresholdsBrushTool,
-  PolylineScissorsTool: PolylineScissorsTool
+  PolylineScissorsTool: PolylineScissorsTool,
+  Slice4DScrollMouseWheelTool: Slice4DScrollMouseWheelTool
 };
 
 /**
@@ -489,4 +505,4 @@ export {
   dvTools,
   getDefaultToolsByType,
   setDefaultToolsProps
-};
+};

package/package.json

@@ -6,7 +6,7 @@
     "medical",
     "cornerstone"
   ],
-  "version": "1.5.8",
+  "version": "1.5.10",
   "description": "javascript library for parsing, loading, rendering and interacting with DICOM images",
   "repository": {
     "url": "https://github.com/dvisionlab/Larvitar.git",