larvitar 1.1.2 → 1.2.3

package/.github/workflows/build-docs.yml

@@ -1,4 +1,4 @@
-name: CI
+name: CI-docs
 
 # Controls when the action will run. Triggers the workflow on push or pull request
 # events but only for the master branch

package/.github/workflows/deploy.yml

@@ -1,6 +1,6 @@
 # This is a basic workflow to help you get started with Actions
 
-name: CI
+name: CI-Release
 
 # Controls when the action will run. Triggers the workflow on push or pull request
 # events but only for the master branch
@@ -30,17 +30,8 @@ jobs:
           cd ${{ github.workspace }}
           rm -rf docs
 
-      # Install npm-cli-login
-      - name: Install npm-cli-login
-        run: |
-          npm install -g npm-cli-login
-
-      # Login to npm
-      - name: Login to npm
-        run: |
-          npm-cli-login -u '${{ secrets.NPM_USERNAME }}' -p '${{ secrets.NPM_PASSWORD }}' -e '${{ secrets.NPM_EMAIL }}'
-
       # Publish to npm
       - name: Publish to npm
         run: |
+          echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > ~/.npmrc
           npm publish

package/README.md

@@ -6,11 +6,11 @@
 
 ## Dicom Image Toolkit for CornestoneJS
 
-### Current version: 1.1.2
+### Current version: 1.2.3
 
-### Latest Stable version: 1.1.2
+### Latest Stable version: 1.2.3
 
-### Latest Published Release: 1.1.2
+### Latest Published Release: 1.2.3
 
 This library provides common DICOM functionalities to be used in web-applications: it's wrapper that simplifies the use of cornestone-js environment.
 Orthogonal multiplanar reformat is included as well as custom loader/exporter for nrrd files and [Vuex](https://vuex.vuejs.org/) custom integration.

package/imaging/imageParsing.js

@@ -278,6 +278,7 @@ let parseFile = function (file) {
               imageObject.metadata.frameTime = metadata["x00181063"];
               imageObject.metadata.frameDelay = metadata["x00181066"];
             }
+            imageObject.metadata.isMultiframe = isMultiframe;
             imageObject.metadata.windowCenter = metadata["x00281050"];
             imageObject.metadata.windowWidth = metadata["x00281051"];
             imageObject.metadata.minPixelValue = metadata["x00280106"];

package/imaging/imageStore.js

@@ -171,6 +171,22 @@ class Larvitar_Store {
     }
   }
 
+  /**
+   * Removes all the series from the store
+   * @function resetSeriesIds
+   */
+  resetSeriesIds(seriesId) {
+    if (this.VUEX_STORE) {
+      let dispatch = "resetSeriesIds";
+      let route = this.vuex_module
+        ? this.vuex_module + "/" + dispatch
+        : dispatch;
+      this.vuex_store.dispatch(route, seriesId);
+    } else {
+      delete this.state.series[seriesId];
+    }
+  }
+
   /**
    * Set a value into store
    * @function set

package/imaging/loaders/commonLoader.js

@@ -38,10 +38,14 @@ export const updateLarvitarManager = function (imageObject, customId) {
   if (larvitarManager === null) {
     larvitarManager = {};
   }
+
   let seriesId = customId || imageObject.seriesUID;
   let data = { ...imageObject };
-  if (data.isMultiframe) {
-    buildMultiFrameImage(seriesId, data);
+
+  if (data.metadata.isMultiframe) {
+    seriesId = customId || imageObject.metadata.seriesUID;
+    updateLoadedStack(data, larvitarManager, customId);
+    buildMultiFrameImage(seriesId, larvitarManager[seriesId]);
   } else {
     updateLoadedStack(data, larvitarManager, customId);
   }

package/imaging/tools/segmentation.js

@@ -14,6 +14,11 @@ const { getters, setters } = segModule;
 import { setToolActive, setToolDisabled } from "./main";
 import { isElement } from "../imageUtils";
 
+// custom code
+import { setLabelmap3DForElement } from "./setLabelMap3D";
+// override function
+setters.labelmap3DForElement = setLabelmap3DForElement;
+
 // General segmentation cs tools module configuration
 const config = {
   arrayType: 0,
@@ -172,7 +177,7 @@ export function initSegmentationModule(customConfig) {
  * @returns {Promise} - Return a promise which will resolve when segmentation mask is added
  */
 export function addSegmentationMask(props, data, elementId) {
-  let promise = new Promise(resolve => {
+  let promise = new Promise(async resolve => {
     let element = isElement(elementId)
       ? elementId
       : document.getElementById(elementId);
@@ -180,7 +185,12 @@ export function addSegmentationMask(props, data, elementId) {
       console.error("invalid html element: " + elementId);
       return;
     }
-    setters.labelmap3DForElement(element, data.buffer, props.labelId);
+
+    const res = await setters.labelmap3DForElement(
+      element,
+      data.buffer,
+      props.labelId
+    );
     // if user set a color property, use that color for all segments on the labelmap
     let lut = props.color
       ? generateUniformLUT(props.color, props.opacity)

package/imaging/tools/segmentations.md

@@ -30,3 +30,9 @@ TODO
 # Larvitar segmentation API
 
 TODO
+
+# Customization
+
+Some function in larvitar overrides the default behaviour of cornerstone tools, here is a list of them:
+
+- `setters.labelmap3DForElement` is overridden to have a non-blocking behaviour, the custom code is in ./setLabelMap3D.js, same as original code in cs tools repo.

package/imaging/tools/setLabelMap3D.js

@@ -0,0 +1,248 @@
+/**
+ * This is a custom version of setLabelMap3D from cs tools source code
+ * This let us implement a non-blocking version of the for loop that loads 3d labelmaps on a volume
+ * @ronzim
+ */
+
+// import getElement from "./getElement";
+// import { getToolState } from "../../../stateManagement/toolState.js";
+// import state from "./state";
+// import getSegmentsOnPixelData from "./getSegmentsOnPixeldata";
+// import { triggerLabelmapModifiedEvent } from "../../../util/segmentation";
+// import ARRAY_TYPES from "./arrayTypes";
+// import { getModule } from "../../index.js";
+
+const ARRAY_TYPES = {
+  UINT_16_ARRAY: 0,
+  FLOAT_32_ARRAY: 1
+};
+const { UINT_16_ARRAY, FLOAT_32_ARRAY } = ARRAY_TYPES;
+
+import cornerstoneTools from "cornerstone-tools/dist/cornerstoneTools.js";
+const { triggerLabelmapModifiedEvent } = cornerstoneTools.importInternal(
+  "util/segmentationUtils"
+);
+const getModule = cornerstoneTools.getModule;
+const getToolState = cornerstoneTools.getToolState;
+const storeGetters = cornerstoneTools.store.getters;
+const state = getModule("segmentation").state;
+
+/**
+ * These function are reported since they are not exposed by cs tools
+ *
+ */
+
+// from getSegmentsOnPixelData.js
+function getSegmentsOnPixelData(pixelData) {
+  return [...new Set(pixelData)];
+}
+
+// from getElement.js
+function getElement(elementOrEnabledElementUID) {
+  if (elementOrEnabledElementUID instanceof HTMLElement) {
+    return elementOrEnabledElementUID;
+  }
+
+  return storeGetters.enabledElementByUID(elementOrEnabledElementUID);
+}
+
+/**
+ * Takes a 16-bit encoded `ArrayBuffer` and stores it as a `Labelmap3D` for the
+ * `BrushStackState` associated with the element.
+ *
+ * @param  {HTMLElement|string} elementOrEnabledElementUID The cornerstone
+ *                                                  enabled element or its UUID.
+ * @param  {ArrayBuffer} buffer
+ * @param  {number} labelmapIndex The index to store the labelmap under.
+ * @param  {Object[]} metadata = [] Any metadata about the segments.
+ * @param  {number[][]} [segmentsOnLabelmapArray] An array of array of segments on each imageIdIndex.
+ *                       If not present, is calculated.
+ * @param  {colorLUTIndex} [colorLUTIndex = 0] The index of the colorLUT to use to render the segmentation.
+ * @returns {null}
+ */
+async function setLabelmap3DForElement(
+  elementOrEnabledElementUID,
+  buffer,
+  labelmapIndex,
+  metadata = [],
+  segmentsOnLabelmapArray,
+  colorLUTIndex = 0
+) {
+  const element = getElement(elementOrEnabledElementUID);
+
+  if (!element) {
+    return;
+  }
+
+  const stackState = getToolState(element, "stack");
+  const numberOfFrames = stackState.data[0].imageIds.length;
+  const firstImageId = stackState.data[0].imageIds[0];
+
+  const res = await setLabelmap3DByFirstImageId(
+    firstImageId,
+    buffer,
+    labelmapIndex,
+    metadata,
+    numberOfFrames,
+    segmentsOnLabelmapArray,
+    colorLUTIndex
+  );
+
+  triggerLabelmapModifiedEvent(element, labelmapIndex);
+
+  return res;
+}
+
+/**
+ * Takes an 16-bit encoded `ArrayBuffer` and stores it as a `Labelmap3D` for
+ * the `BrushStackState` associated with the firstImageId.
+ *
+ * @param  {HTMLElement|string} firstImageId  The firstImageId of the series to
+ *                                            store the segmentation on.
+ * @param  {ArrayBuffer} buffer
+ * @param  {number} labelmapIndex The index to store the labelmap under.
+ * @param  {Object[]} metadata = [] Any metadata about the segments.
+ * @param  {number} numberOfFrames The number of frames, required to set up the
+ *                                 relevant labelmap2D views.
+ * @param  {number[][]} [segmentsOnLabelmapArray] An array of array of segments on each imageIdIndex.
+ *                       If not present, is calculated.
+ * @param  {colorLUTIndex} [colorLUTIndex = 0] The index of the colorLUT to use to render the segmentation.
+ * @returns {null}
+ */
+function setLabelmap3DByFirstImageId(
+  firstImageId,
+  buffer,
+  labelmapIndex,
+  metadata = [],
+  numberOfFrames,
+  segmentsOnLabelmapArray,
+  colorLUTIndex = 0
+) {
+  const { configuration } = getModule("segmentation");
+
+  let brushStackState = state.series[firstImageId];
+
+  if (!brushStackState) {
+    state.series[firstImageId] = {
+      activeLabelmapIndex: labelmapIndex,
+      labelmaps3D: []
+    };
+
+    brushStackState = state.series[firstImageId];
+  }
+
+  brushStackState.labelmaps3D[labelmapIndex] = {
+    buffer,
+    labelmaps2D: [],
+    metadata,
+    activeSegmentIndex: 1,
+    colorLUTIndex,
+    segmentsHidden: [],
+    undo: [],
+    redo: []
+  };
+
+  const labelmaps2D = brushStackState.labelmaps3D[labelmapIndex].labelmaps2D;
+  const slicelengthInBytes = buffer.byteLength / numberOfFrames;
+
+  /* non-blocking implementation by @ronzim */
+
+  return new Promise(resolve => {
+    function setSingleSlice(i, numberOfFrames) {
+      var pixelData = void 0;
+
+      switch (configuration.arrayType) {
+        case UINT_16_ARRAY:
+          pixelData = new Uint16Array(
+            buffer,
+            slicelengthInBytes * i, // 2 bytes/voxel
+            slicelengthInBytes / 2
+          );
+          break;
+
+        case FLOAT_32_ARRAY:
+          pixelData = new Float32Array(
+            buffer,
+            slicelengthInBytes * i,
+            slicelengthInBytes / 4
+          );
+          break;
+
+        default:
+          throw new Error(
+            "Unsupported Array Type ".concat(configuration.arrayType)
+          );
+      }
+
+      var segmentsOnLabelmap = segmentsOnLabelmapArray
+        ? segmentsOnLabelmapArray[i]
+        : getSegmentsOnPixelData(pixelData);
+
+      if (
+        segmentsOnLabelmap &&
+        segmentsOnLabelmap.some(function (segment) {
+          return segment;
+        })
+      ) {
+        labelmaps2D[i] = {
+          pixelData: pixelData,
+          segmentsOnLabelmap: segmentsOnLabelmap
+        };
+      }
+
+      ++i;
+
+      if (i < numberOfFrames) {
+        setTimeout(() => {
+          setSingleSlice(i, numberOfFrames);
+        }, 0);
+      } else {
+        resolve("OK");
+      }
+    }
+
+    setSingleSlice(0, numberOfFrames);
+  });
+
+  /* original implementation 
+
+  for (let i = 0; i < numberOfFrames; i++) {
+    let pixelData;
+
+    switch (configuration.arrayType) {
+      case UINT_16_ARRAY:
+        pixelData = new Uint16Array(
+          buffer,
+          slicelengthInBytes * i, // 2 bytes/voxel
+          slicelengthInBytes / 2
+        );
+
+        break;
+
+      case FLOAT_32_ARRAY:
+        pixelData = new Float32Array(
+          buffer,
+          slicelengthInBytes * i,
+          slicelengthInBytes / 4
+        );
+        break;
+
+      default:
+        throw new Error(`Unsupported Array Type ${configuration.arrayType}`);
+    }
+
+    const segmentsOnLabelmap = segmentsOnLabelmapArray
+      ? segmentsOnLabelmapArray[i]
+      : getSegmentsOnPixelData(pixelData);
+
+    if (segmentsOnLabelmap && segmentsOnLabelmap.some(segment => segment)) {
+      labelmaps2D[i] = {
+        pixelData,
+        segmentsOnLabelmap
+      };
+    }
+  }
+  */
+}
+
+export { setLabelmap3DByFirstImageId, setLabelmap3DForElement };

package/modules/vuex/larvitar.js

@@ -99,6 +99,7 @@ export default {
     },
     removeSeriesIds: ({ state }, seriesId) =>
       Vue.delete(state.series, seriesId),
+    resetSeriesIds: ({ state }) => Vue.set(state.series, {}),
     setErrorLog: () => {}, // TODO LT pass elementId
 
     // Series fields setters

package/package.json

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