@cornerstonejs/tools 0.56.2 → 0.56.4

package/src/utilities/segmentation/floodFill.ts

@@ -0,0 +1,194 @@
+import type {
+  FloodFillResult,
+  FloodFillGetter,
+  FloodFillOptions,
+} from '../../types';
+import { Types } from '@cornerstonejs/core';
+
+/**
+ * floodFill.js - Taken from MIT OSS lib - https://github.com/tuzz/n-dimensional-flood-fill
+ * Refactored to ES6.
+ *
+ * @param {function} getter The getter to the elements of your data structure,
+ *                          e.g. getter(x,y) for a 2D interprettation of your structure.
+ * @param {number[]} seed The seed for your fill. The dimensionality is infered
+ *                        by the number of dimensions of the seed.
+ * @param {function} [options.onFlood] An optional callback to execute when each pixel is flooded.
+ *                             e.g. onFlood(x,y).
+ * @param {function} [options.onBoundary] An optional callback to execute whenever a boundary is reached.
+ *                                a boundary could be another segmentIndex, or the edge of your
+ *                                data structure (i.e. when your getter returns undefined).
+ * @param {function} [options.equals] An optional equality method for your datastructure.
+ *                            Default is simply value1 = value2.
+ * @param {boolean} [options.diagonals] Whether you allow flooding through diagonals. Defaults to false.
+ *
+ * @returns {Object}
+ */
+function floodFill(
+  getter: FloodFillGetter,
+  seed: Types.Point2 | Types.Point3,
+  options: FloodFillOptions = {}
+): FloodFillResult {
+  const onFlood = options.onFlood;
+  const onBoundary = options.onBoundary;
+  const equals = options.equals || defaultEquals;
+  const diagonals = options.diagonals || false;
+  const startNode = get(seed);
+  const permutations = prunedPermutations();
+  const stack = [];
+  const flooded = [];
+  const visits = {};
+  const bounds = {};
+
+  stack.push({ currentArgs: seed });
+
+  while (stack.length > 0) {
+    flood(stack.pop());
+  }
+
+  return {
+    flooded,
+    boundaries: boundaries(),
+  };
+
+  function flood(job) {
+    const getArgs = job.currentArgs;
+    const prevArgs = job.previousArgs;
+
+    if (visited(getArgs)) {
+      return;
+    }
+    markAsVisited(getArgs);
+
+    if (member(getArgs)) {
+      markAsFlooded(getArgs);
+      pushAdjacent(getArgs);
+    } else {
+      markAsBoundary(prevArgs);
+    }
+  }
+
+  function visited(key) {
+    return visits[key] === true;
+  }
+
+  function markAsVisited(key) {
+    visits[key] = true;
+  }
+
+  function member(getArgs) {
+    const node = safely(get, [getArgs]);
+
+    return safely(equals, [node, startNode]);
+  }
+
+  function markAsFlooded(getArgs) {
+    flooded.push(getArgs);
+    if (onFlood) {
+      //@ts-ignore
+      onFlood(...getArgs);
+    }
+  }
+
+  function markAsBoundary(prevArgs) {
+    bounds[prevArgs] = prevArgs;
+    if (onBoundary) {
+      //@ts-ignore
+      onBoundary(...prevArgs);
+    }
+  }
+
+  function pushAdjacent(getArgs) {
+    for (let i = 0; i < permutations.length; i += 1) {
+      const perm = permutations[i];
+      const nextArgs = getArgs.slice(0);
+
+      for (let j = 0; j < getArgs.length; j += 1) {
+        nextArgs[j] += perm[j];
+      }
+
+      stack.push({
+        currentArgs: nextArgs,
+        previousArgs: getArgs,
+      });
+    }
+  }
+
+  function get(getArgs) {
+    //@ts-ignore
+    return getter(...getArgs);
+  }
+
+  function safely(f, args) {
+    try {
+      return f(...args);
+    } catch (error) {
+      return;
+    }
+  }
+
+  function prunedPermutations() {
+    const permutations = permute(seed.length);
+
+    return permutations.filter(function (perm) {
+      const count = countNonZeroes(perm);
+
+      return count !== 0 && (count === 1 || diagonals);
+    });
+  }
+
+  function permute(length) {
+    const perms = [];
+
+    const permutation = function (string) {
+      return string.split('').map(function (c) {
+        return parseInt(c, 10) - 1;
+      });
+    };
+
+    for (let i = 0; i < Math.pow(3, length); i += 1) {
+      const string = lpad(i.toString(3), '0', length);
+
+      perms.push(permutation(string));
+    }
+
+    return perms;
+  }
+
+  function boundaries() {
+    const array = [];
+
+    for (const key in bounds) {
+      if (bounds[key] !== undefined) {
+        array.unshift(bounds[key]);
+      }
+    }
+
+    return array;
+  }
+}
+
+function defaultEquals(a, b) {
+  return a === b;
+}
+
+function countNonZeroes(array) {
+  let count = 0;
+
+  for (let i = 0; i < array.length; i += 1) {
+    if (array[i] !== 0) {
+      count += 1;
+    }
+  }
+
+  return count;
+}
+
+function lpad(string, character, length) {
+  const array = new Array(length + 1);
+  const pad = array.join(character);
+
+  return (pad + string).slice(-length);
+}
+
+export default floodFill;

package/src/utilities/segmentation/getDefaultRepresentationConfig.ts

@@ -0,0 +1,20 @@
+import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
+import SegmentationRepresentation from '../../enums/SegmentationRepresentations';
+import { Segmentation } from '../../types/SegmentationStateTypes';
+
+/**
+ * It returns a configuration object for the given representation type.
+ * @param representationType - The type of segmentation representation
+ * @returns A representation configuration object.
+ */
+export default function getDefaultRepresentationConfig(
+  segmentation: Segmentation
+) {
+  const { type: representationType } = segmentation;
+  switch (representationType) {
+    case SegmentationRepresentation.Labelmap:
+      return getDefaultLabelmapConfig();
+    default:
+      throw new Error(`Unknown representation type: ${representationType}`);
+  }
+}

package/src/utilities/segmentation/index.ts

@@ -0,0 +1,33 @@
+import thresholdVolumeByRange from './thresholdVolumeByRange';
+import rectangleROIThresholdVolumeByRange from './rectangleROIThresholdVolumeByRange';
+import createMergedLabelmapForIndex from './createMergedLabelmapForIndex';
+import isValidRepresentationConfig from './isValidRepresentationConfig';
+import getDefaultRepresentationConfig from './getDefaultRepresentationConfig';
+import createLabelmapVolumeForViewport from './createLabelmapVolumeForViewport';
+import { triggerSegmentationRender } from './triggerSegmentationRender';
+import floodFill from './floodFill';
+import {
+  getBrushSizeForToolGroup,
+  setBrushSizeForToolGroup,
+} from './brushSizeForToolGroup';
+import {
+  getBrushThresholdForToolGroup,
+  setBrushThresholdForToolGroup,
+} from './brushThresholdForToolGroup';
+import thresholdSegmentationByRange from './thresholdSegmentationByRange';
+
+export {
+  thresholdVolumeByRange,
+  createMergedLabelmapForIndex,
+  isValidRepresentationConfig,
+  getDefaultRepresentationConfig,
+  createLabelmapVolumeForViewport,
+  rectangleROIThresholdVolumeByRange,
+  triggerSegmentationRender,
+  floodFill,
+  getBrushSizeForToolGroup,
+  setBrushSizeForToolGroup,
+  getBrushThresholdForToolGroup,
+  setBrushThresholdForToolGroup,
+  thresholdSegmentationByRange,
+};

package/src/utilities/segmentation/isValidRepresentationConfig.ts

@@ -0,0 +1,22 @@
+import { isValidLabelmapConfig } from '../../tools/displayTools/Labelmap/labelmapConfig';
+import SegmentationRepresentation from '../../enums/SegmentationRepresentations';
+import { RepresentationConfig } from '../../types/SegmentationStateTypes';
+
+/**
+ * Given a representation type and a configuration, return true if the
+ * configuration is valid for that representation type
+ * @param representationType - The type of segmentation representation
+ * @param config - RepresentationConfig
+ * @returns A boolean value.
+ */
+export default function isValidRepresentationConfig(
+  representationType: string,
+  config: RepresentationConfig
+): boolean {
+  switch (representationType) {
+    case SegmentationRepresentation.Labelmap:
+      return isValidLabelmapConfig(config);
+    default:
+      throw new Error(`Unknown representation type: ${representationType}`);
+  }
+}

package/src/utilities/segmentation/rectangleROIThresholdVolumeByRange.ts

@@ -0,0 +1,91 @@
+import type { Types } from '@cornerstonejs/core';
+import { state } from '../../stateManagement/annotation';
+import {
+  RectangleROIStartEndThresholdTool,
+  RectangleROIThresholdTool,
+} from '../../tools';
+
+import thresholdVolumeByRange from './thresholdVolumeByRange';
+import getBoundsIJKFromRectangleAnnotations from '../rectangleROITool/getBoundsIJKFromRectangleAnnotations';
+import { ThresholdInformation } from './utilities';
+
+export type ThresholdOptions = {
+  numSlicesToProject?: number; // number of slices to project before and after current slice
+  overwrite: boolean;
+  overlapType?: number; // type of the voxel overlap
+};
+
+export type AnnotationForThresholding = {
+  data: {
+    handles: {
+      points: Types.Point3[];
+    };
+    cachedStats?: {
+      projectionPoints?: Types.Point3[][];
+    };
+  };
+};
+
+/**
+ * It uses the provided rectangleROI annotations (either RectangleROIThreshold, or
+ * RectangleROIStartEndThreshold) to compute an ROI that is the intersection of
+ * all the annotations. Then it uses the rectangleROIThreshold utility to threshold
+ * the volume.
+ * @param annotationUIDs - rectangleROI annotationsUIDs to use for ROI
+ * @param segmentationVolume - the segmentation volume
+ * @param thresholdVolumeInformation - object array containing the volume data and range threshold values
+ * @param options - options for thresholding
+ * @returns
+ */
+function rectangleROIThresholdVolumeByRange(
+  annotationUIDs: string[],
+  segmentationVolume: Types.IImageVolume,
+  thresholdVolumeInformation: ThresholdInformation[],
+  options: ThresholdOptions
+): Types.IImageVolume {
+  const annotations = annotationUIDs.map((annotationUID) => {
+    return state.getAnnotation(annotationUID);
+  });
+
+  _validateAnnotations(annotations);
+
+  let boundsIJK;
+  for (let i = 0; i < thresholdVolumeInformation.length; i++) {
+    // make sure that the boundsIJK are generated by the correct volume
+    const volumeSize =
+      thresholdVolumeInformation[i].volume.getScalarData().length;
+    if (volumeSize === segmentationVolume.getScalarData().length || i === 0) {
+      boundsIJK = getBoundsIJKFromRectangleAnnotations(
+        annotations,
+        thresholdVolumeInformation[i].volume,
+        options
+      );
+    }
+  }
+
+  const outputSegmentationVolume = thresholdVolumeByRange(
+    segmentationVolume,
+    thresholdVolumeInformation,
+    { ...options, boundsIJK }
+  );
+
+  return outputSegmentationVolume;
+}
+
+function _validateAnnotations(annotations) {
+  const validToolNames = [
+    RectangleROIThresholdTool.toolName,
+    RectangleROIStartEndThresholdTool.toolName,
+  ];
+
+  for (const annotation of annotations) {
+    const name = annotation.metadata.toolName;
+    if (!validToolNames.includes(name)) {
+      throw new Error(
+        'rectangleROIThresholdVolumeByRange only supports RectangleROIThreshold and RectangleROIStartEndThreshold annotations'
+      );
+    }
+  }
+}
+
+export default rectangleROIThresholdVolumeByRange;

package/src/utilities/segmentation/thresholdSegmentationByRange.ts

@@ -0,0 +1,129 @@
+import { Types } from '@cornerstonejs/core';
+import { pointInShapeCallback } from '../../utilities';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import {
+  getVoxelOverlap,
+  processVolumes,
+  ThresholdInformation,
+} from './utilities';
+
+/**
+ * It thresholds a segmentation volume based on a set of threshold values with
+ * respect to a list of volumes and respective threshold ranges.
+ * @param segmentationVolume - the segmentation volume to be modified
+ * @param segmentationIndex - the index of the segmentation to modify
+ * @param thresholdVolumeInformation - array of objects containing volume data
+ * and a range (lower and upper values) to threshold
+ * @param overlapType - indicates if the user requires all voxels pass
+ * (overlapType = 1) or any voxel pass (overlapType = 0)
+ * @returns
+ */
+function thresholdSegmentationByRange(
+  segmentationVolume: Types.IImageVolume,
+  segmentationIndex: number,
+  thresholdVolumeInformation: ThresholdInformation[],
+  overlapType: number
+): Types.IImageVolume {
+  const scalarData = segmentationVolume.getScalarData();
+
+  // prepare a list of volume information objects for callback functions
+  const { baseVolumeIdx, volumeInfoList } = processVolumes(
+    segmentationVolume,
+    thresholdVolumeInformation
+  );
+
+  /**
+   * This function will test all overlaps between a voxel in base volume
+   * (the reference for segmentation volume creation) and voxels in other
+   * volumes.
+   * If the segmentation volume and the image volume are the same size,
+   * checks if the scalar data at each point is within the threshold values.
+   * If the segmentation volume and the image volume are different sizes,
+   * checks the voxel overlap
+   */
+  volumeInfoList.forEach((volumeInfo) => {
+    const { volumeSize } = volumeInfo;
+
+    if (volumeSize === scalarData.length) {
+      _handleSameSizeVolume(scalarData, segmentationIndex, volumeInfo);
+    } else {
+      _handleDifferentSizeVolume(
+        scalarData,
+        segmentationIndex,
+        volumeInfo,
+        volumeInfoList,
+        baseVolumeIdx,
+        overlapType
+      );
+    }
+  });
+
+  triggerSegmentationDataModified(segmentationVolume.volumeId);
+
+  return segmentationVolume;
+}
+
+function _handleDifferentSizeVolume(
+  scalarData: Types.VolumeScalarData,
+  segmentationIndex: number,
+  volumeInfo: any,
+  volumeInfoList: any,
+  baseVolumeIdx: number,
+  overlapType: number
+) {
+  const { imageData, lower, upper, dimensions } = volumeInfo;
+
+  let total, overlaps, range;
+
+  for (let i = 0; i < scalarData.length; i++) {
+    if (scalarData[i] === segmentationIndex) {
+      const overlapBounds = getVoxelOverlap(
+        imageData,
+        dimensions,
+        volumeInfoList[baseVolumeIdx].spacing,
+        volumeInfoList[baseVolumeIdx].imageData.getPoint(i)
+      );
+
+      const callbackOverlap = ({ value }) => {
+        total = total + 1;
+        if (value >= range.lower && value <= range.upper) {
+          overlaps = overlaps + 1;
+        }
+      };
+
+      total = 0;
+      overlaps = 0;
+      range = { lower, upper };
+      let overlapTest = false;
+
+      // check all voxel overlaps
+      pointInShapeCallback(
+        imageData,
+        () => true,
+        callbackOverlap,
+        overlapBounds
+      );
+
+      overlapTest = overlapType === 0 ? overlaps > 0 : overlaps === total;
+      scalarData[i] = overlapTest ? segmentationIndex : 0;
+    }
+  }
+  return { total, range, overlaps };
+}
+
+function _handleSameSizeVolume(
+  scalarData: Types.VolumeScalarData,
+  segmentationIndex: number,
+  volumeInfo: any
+) {
+  const { referenceValues, lower, upper } = volumeInfo;
+
+  for (let i = 0; i < scalarData.length; i++) {
+    if (scalarData[i] === segmentationIndex) {
+      const value = referenceValues[i];
+      scalarData[i] = value >= lower && value <= upper ? segmentationIndex : 0;
+    }
+  }
+}
+
+export default thresholdSegmentationByRange;

package/src/utilities/segmentation/thresholdVolumeByRange.ts

@@ -0,0 +1,150 @@
+import { Types } from '@cornerstonejs/core';
+import { pointInShapeCallback } from '../../utilities';
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { BoundsIJK } from '../../types';
+import {
+  getVoxelOverlap,
+  processVolumes,
+  ThresholdInformation,
+} from './utilities';
+
+export type ThresholdRangeOptions = {
+  overwrite: boolean;
+  boundsIJK: BoundsIJK;
+  overlapType?: number;
+};
+
+/**
+ * It thresholds a segmentation volume based on a set of threshold values with
+ * respect to a list of volumes and respective threshold ranges.
+ * @param segmentationVolume - the segmentation volume to be modified
+ * @param thresholdVolumeInformation - array of objects containing volume data
+ * and a range (lower and upper values) to threshold
+ * @param options - the options for thresholding
+ * As there is a chance the volumes might have different dimensions and spacing,
+ * could be the case of no 1 to 1 mapping. So we need to work with the idea of
+ * voxel overlaps (1 to many mappings). We consider all intersections valid, to
+ * avoid the complexity to calculate a minimum voxel intersection percentage.
+ * This function, given a voxel center and spacing, calculates the overlap of
+ * the voxel with another volume and range check the voxels in the overlap.
+ * Three situations can occur: all voxels pass the range check, some voxels pass
+ * or none voxels pass. The overlapType parameter indicates if the user requires
+ * all voxels pass (overlapType = 1) or any voxel pass (overlapType = 0)
+ *
+ * @returns segmented volume
+ */
+function thresholdVolumeByRange(
+  segmentationVolume: Types.IImageVolume,
+  thresholdVolumeInformation: ThresholdInformation[],
+  options: ThresholdRangeOptions
+): Types.IImageVolume {
+  const { imageData: segmentationImageData } = segmentationVolume;
+  const scalarData = segmentationVolume.getScalarData();
+
+  const { overwrite, boundsIJK } = options;
+  const overlapType = options?.overlapType || 0;
+
+  // set the segmentation to all zeros
+  if (overwrite) {
+    for (let i = 0; i < scalarData.length; i++) {
+      scalarData[i] = 0;
+    }
+  }
+
+  const { baseVolumeIdx, volumeInfoList } = processVolumes(
+    segmentationVolume,
+    thresholdVolumeInformation
+  );
+
+  // global variables used in callbackOverlap function
+  let overlaps, total, range;
+
+  const testOverlapRange = (volumeInfo, voxelSpacing, voxelCenter) => {
+    /**
+     * This callback function will test all overlaps between a voxel in base
+     * volume (the reference for segmentation volume creation) and voxels in other
+     * volumes.
+     */
+    const callbackOverlap = ({ value }) => {
+      total = total + 1;
+      if (value >= range.lower && value <= range.upper) {
+        overlaps = overlaps + 1;
+      }
+    };
+
+    const { imageData, dimensions, lower, upper } = volumeInfo;
+
+    const overlapBounds = getVoxelOverlap(
+      imageData,
+      dimensions,
+      voxelSpacing,
+      voxelCenter
+    );
+
+    // reset global variables and setting the range check
+    total = 0;
+    overlaps = 0;
+    range = { lower, upper };
+
+    let overlapTest = false;
+
+    // check all voxel overlaps
+    pointInShapeCallback(imageData, () => true, callbackOverlap, overlapBounds);
+
+    if (overlapType === 0) {
+      overlapTest = overlaps > 0; // any voxel overlap is accepted
+    } else if (overlapType == 1) {
+      overlapTest = overlaps === total; // require all voxel overlaps
+    }
+    return overlapTest;
+  };
+
+  // range checks a voxel in a volume with same dimension as the segmentation
+  const testRange = (volumeInfo, pointIJK) => {
+    const { imageData, referenceValues, lower, upper } = volumeInfo;
+    const offset = imageData.computeOffsetIndex(pointIJK);
+
+    const value = referenceValues[offset];
+    if (value <= lower || value >= upper) {
+      return false;
+    } else {
+      return true;
+    }
+  };
+
+  /**
+   * This callback function will test all overlaps between a voxel in base
+   * volume (the reference for segmentation volume creation) and voxels in other
+   * volumes.
+   */
+  const callback = ({ index, pointIJK, pointLPS }) => {
+    let insert = volumeInfoList.length > 0;
+    for (let i = 0; i < volumeInfoList.length; i++) {
+      // if volume has the same size as segmentation volume, just range check
+      if (volumeInfoList[i].volumeSize === scalarData.length) {
+        insert = testRange(volumeInfoList[i], pointIJK);
+      } else {
+        // if not, need to calculate overlaps
+        insert = testOverlapRange(
+          volumeInfoList[i],
+          volumeInfoList[baseVolumeIdx].spacing,
+          pointLPS
+        );
+      }
+      if (!insert) {
+        break;
+      }
+    }
+
+    // Todo: make the segmentIndex a parameter
+    if (insert) scalarData[index] = 1;
+  };
+
+  pointInShapeCallback(segmentationImageData, () => true, callback, boundsIJK);
+
+  triggerSegmentationDataModified(segmentationVolume.volumeId);
+
+  return segmentationVolume;
+}
+
+export default thresholdVolumeByRange;