@cornerstonejs/tools 1.22.0 → 1.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.22.0",
+  "version": "1.22.1",
   "description": "Cornerstone3D Tools",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.22.0",
+    "@cornerstonejs/core": "^1.22.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
@@ -52,5 +52,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "ff226c7a2ed426dc568b8043d3bbbb1cdc993281"
+  "gitHead": "c7e6f091ac9fc1e38fcaca23599b75d62af605e6"
 }

package/src/utilities/dynamicVolume/generateImageFromTimeData.ts

@@ -5,10 +5,10 @@ import { Enums, Types } from '@cornerstonejs/core';
  * array of scalar data after performing AVERAGE, SUM or SUBTRACT to be used to
  * create a 3D volume
  *
- * @param dynamicVolume4D: volume to compute time frame data from
- * @param operation: operation to perform on time frame data, operations include
+ * @param dynamicVolume4D - volume to compute time frame data from
+ * @param operation - operation to perform on time frame data, operations include
  * SUM, AVERAGE, and SUBTRACT (can only be used with 2 time frames provided)
- * @param frameNumbers: an array of frame indexs to perform the operation on, if
+ * @param frameNumbers - an array of frame indices to perform the operation on, if
  * left empty, all frames will be used
  * @returns
  */

package/src/utilities/dynamicVolume/getDataInTime.ts

@@ -1,12 +1,14 @@
 import { utilities, cache, Types } from '@cornerstonejs/core';
+import { getVoxelOverlap } from '../segmentation/utilities';
+import pointInShapeCallback from '../pointInShapeCallback';
 
 /**
  * Gets the scalar data for a series of time points for either a single
  * coordinate or a segmentation mask, it will return the an array of scalar
  * data for a single coordinate or an array of arrays for a segmentation.
  *
- * @param dynamicVolume: 4D volume to compute time point data from
- * @param options: frameNumbers: which frames to use as timepoints, if left
+ * @param dynamicVolume - 4D volume to compute time point data from
+ * @param options - frameNumbers: which frames to use as timepoints, if left
  * blank, gets data timepoints over all frames
  * maskVolumeId: segmentationId to get timepoint data of
  * imageCoordinate: world coordinate to get timepoint data of
@@ -31,26 +33,23 @@ function getDataInTime(
   // Throws error if neither maskVolumeId or imageCoordinate is given,
   // throws error if BOTH maskVolumeId and imageCoordinate is given
   if (!options.maskVolumeId && !options.imageCoordinate) {
-    throw new Error('No ROI provided');
+    throw new Error(
+      'You should provide either maskVolumeId or imageCoordinate'
+    );
   }
 
   if (options.maskVolumeId && options.imageCoordinate) {
-    throw new Error('Please provide only one ROI');
+    throw new Error('You can only use one of maskVolumeId or imageCoordinate');
   }
 
   if (options.maskVolumeId) {
     const segmentationVolume = cache.getVolume(options.maskVolumeId);
-    const segScalarData = segmentationVolume.getScalarData();
-    const indexArray = [];
-
-    // Get the index of every non-zero voxel in mask
-    for (let i = 0, len = segScalarData.length; i < len; i++) {
-      if (segScalarData[i] !== 0) {
-        indexArray.push(i);
-      }
-    }
 
-    const dataInTime = _getTimePointDataMask(frames, indexArray, dynamicVolume);
+    const dataInTime = _getTimePointDataMask(
+      frames,
+      dynamicVolume,
+      segmentationVolume
+    );
 
     return dataInTime;
   }
@@ -95,19 +94,110 @@ function _getTimePointDataCoordinate(frames, coordinate, volume) {
   return value;
 }
 
-function _getTimePointDataMask(frames, indexArray, volume) {
-  const allScalarData = volume.getScalarDataArrays();
-  const value = [];
+function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
+  const { imageData: maskImageData } = segmentationVolume;
+  const segScalarData = segmentationVolume.getScalarData();
 
-  for (let i = 0; i < indexArray.length; i++) {
-    const indexValues = [];
-    frames.forEach((frame) => {
-      const activeScalarData = allScalarData[frame];
-      indexValues.push(activeScalarData[indexArray[i]]);
-    });
-    value.push(indexValues);
+  const len = segScalarData.length;
+
+  // Pre-allocate memory for array
+  const nonZeroVoxelIndices = [];
+  nonZeroVoxelIndices.length = len;
+
+  // Get the index of every non-zero voxel in mask
+  let actualLen = 0;
+  for (let i = 0, len = segScalarData.length; i < len; i++) {
+    if (segScalarData[i] !== 0) {
+      nonZeroVoxelIndices[actualLen++] = i;
+    }
   }
-  return value;
+
+  // Trim the array to actual size
+  nonZeroVoxelIndices.length = actualLen;
+
+  const dynamicVolumeScalarDataArray = dynamicVolume.getScalarDataArrays();
+  const values = [];
+  const isSameVolume =
+    dynamicVolumeScalarDataArray[0].length === len &&
+    JSON.stringify(dynamicVolume.spacing) ===
+      JSON.stringify(segmentationVolume.spacing);
+
+  // if the segmentation mask is the same size as the dynamic volume (one frame)
+  // means we can just return the scalar data for the non-zero voxels
+  if (isSameVolume) {
+    for (let i = 0; i < nonZeroVoxelIndices.length; i++) {
+      const indexValues = [];
+      frames.forEach((frame) => {
+        const activeScalarData = dynamicVolumeScalarDataArray[frame];
+        indexValues.push(activeScalarData[nonZeroVoxelIndices[i]]);
+      });
+      values.push(indexValues);
+    }
+
+    return values;
+  }
+
+  // In case that the segmentation mask is not the same size as the dynamic volume (one frame)
+  // then we need to consider each voxel in the segmentation mask and check if it
+  // overlaps with the other volume, and if so we need to average the values of the
+  // overlapping voxels.
+  const callback = ({ pointLPS: segPointLPS, value: segValue }) => {
+    // see if the value is non-zero
+    if (segValue === 0) {
+      // not interested
+      return;
+    }
+
+    // Then for each non-zero voxel in the segmentation mask, we should
+    // again perform the pointInShapeCallback to run the averaging callback
+    // function to get the average value of the overlapping voxels.
+    const overlapIJKMinMax = getVoxelOverlap(
+      dynamicVolume.imageData,
+      dynamicVolume.dimensions,
+      dynamicVolume.spacing,
+      segPointLPS
+    );
+
+    // count represents the number of voxels of the dynamic volume that represents
+    // one voxel of the segmentation mask
+    let count = 0;
+    const perFrameSum = new Map();
+
+    // Pre-initialize the Map
+    frames.forEach((frame) => perFrameSum.set(frame, 0));
+
+    const averageCallback = ({ index }) => {
+      for (let i = 0; i < frames.length; i++) {
+        const value = dynamicVolumeScalarDataArray[i][index];
+        const frame = frames[i];
+        perFrameSum.set(frame, perFrameSum.get(frame) + value);
+      }
+      count++;
+    };
+
+    pointInShapeCallback(
+      dynamicVolume.imageData,
+      () => true,
+      averageCallback,
+      overlapIJKMinMax
+    );
+
+    // average the values
+    const averageValues = [];
+    perFrameSum.forEach((sum) => {
+      averageValues.push(sum / count);
+    });
+
+    values.push(averageValues);
+  };
+
+  // Since we have the non-zero voxel indices of the segmentation mask,
+  // we theoretically can use them, however, we kind of need to compute the
+  // pointLPS for each of the non-zero voxel indices, which is a bit of a pain.
+  // Todo: consider using the nonZeroVoxelIndices to compute the pointLPS
+  pointInShapeCallback(maskImageData, () => true, callback);
+
+  return values;
 }
 
 export default getDataInTime;

package/src/utilities/segmentation/utilities.ts

@@ -56,7 +56,7 @@ export function getVoxelOverlap(
   for (let i = 0; i < 2; i++) {
     for (let j = 0; j < 2; j++) {
       for (let k = 0; k < 2; k++) {
-        const point = voxelCenter;
+        const point = [...voxelCenter]; // Create a new point from voxelCenter
         point[0] = point[0] + ((i * 2 - 1) * voxelSpacing[0]) / 2;
         point[1] = point[1] + ((j * 2 - 1) * voxelSpacing[1]) / 2;
         point[2] = point[2] + ((k * 2 - 1) * voxelSpacing[2]) / 2;
@@ -79,8 +79,7 @@ export function processVolumes(
   segmentationVolume: Types.IImageVolume,
   thresholdVolumeInformation: ThresholdInformation[]
 ) {
-  const { spacing: segmentationSpacing, imageData: segmentationImageData } =
-    segmentationVolume;
+  const { spacing: segmentationSpacing } = segmentationVolume;
   const scalarData = segmentationVolume.getScalarData();
 
   // prepare a list of volume information objects for callback functions