@cornerstonejs/tools 1.48.2 → 1.49.1

package/src/utilities/contours/interpolation/findAnnotationForInterpolation.ts

@@ -0,0 +1,225 @@
+import getInterpolationData from './getInterpolationData';
+import type { InterpolationViewportData, Annotation } from '../../../types';
+
+/**
+ * A pair of slice indices for contours, typically indicating the
+ * pair of contours to interpolate between, or for a possible range to
+ * compare against.
+ */
+export type ContourPair = [number, number];
+
+/**
+ * Finds the list of contours to interpolate,
+ * including whether they are new contours, or auto generated contours that need
+ * to be updated.
+ *
+ * @param toolData - object, The tool data of the roi contour.
+ * @param viewportData - the annotation/viewport to start the interpolation from
+ * @returns An object containing the interpolationData and the
+ *       interpolationList.
+ */
+
+function findAnnotationsForInterpolation(
+  toolData,
+  viewportData: InterpolationViewportData
+) {
+  const interpolationData = getInterpolationData(viewportData, [
+    {
+      key: 'interpolationUID',
+      value: viewportData.interpolationUID,
+    },
+  ]);
+  const rangeToInterpolate = getRangeToInterpolate(interpolationData);
+  const sliceEdited = _getSlicePositionOfToolData(
+    interpolationData,
+    toolData.annotationUID
+  );
+  const interpolationList = [];
+
+  // Check if contours between the extent can be interpolated.
+  for (let i = rangeToInterpolate[0] + 1; i < rangeToInterpolate[1]; i++) {
+    if (_sliceNeedsInterpolating(interpolationData, i)) {
+      const contourPair = _getBoundingPair(
+        i,
+        rangeToInterpolate,
+        interpolationData
+      );
+
+      if (
+        contourPair?.[0] === sliceEdited ||
+        contourPair?.[1] === sliceEdited
+      ) {
+        _appendInterpolationList(contourPair, interpolationList, i);
+      }
+    }
+  }
+
+  return {
+    interpolationData,
+    interpolationList,
+  };
+}
+
+/**
+ * Gets the range of interpolation data which has
+ * annotations in it, as indices into the interpolationData
+ *
+ * @param interpolationData - Data on the slice location of contours to be
+ *       interpolated.
+ * @returns Number[], The slice locations of the top and bottom polygon of the ROIContour.
+ */
+
+function getRangeToInterpolate(
+  interpolationData: Map<number, Annotation[]>
+): ContourPair {
+  let first = Infinity;
+  let last = -Infinity;
+  let found = false;
+
+  for (const [sliceIndex, annotations] of interpolationData.entries()) {
+    if (annotations.length) {
+      first = Math.min(sliceIndex, first);
+      last = Math.max(sliceIndex, last);
+      found = true;
+    }
+  }
+  if (!found) {
+    return;
+  }
+
+  return [first, last];
+}
+
+/**
+ * _getSlicePositionOfToolData - Finds the slice that was edited.
+ *
+ * @param interpolationData - Data on the slice location of contours to be
+ *       interpolated.
+ * @param annotationUID - the UID to find the slice position for
+ * @returns index in the interpolationData containing that annotationUID
+ */
+function _getSlicePositionOfToolData(
+  interpolationData: Map<number, Annotation[]>,
+  annotationUID: string
+): number {
+  for (const [sliceIndex, annotations] of interpolationData) {
+    for (let j = 0; j < annotations.length; j++) {
+      if (annotations[j].annotationUID === annotationUID) {
+        return sliceIndex;
+      }
+    }
+  }
+
+  return;
+}
+
+/**
+ * Slices need interpolation when either:
+ *   * There are no contours on this slice
+ *   * There is a contour which is an interpolated contour.
+ *
+ * @param interpolationData - Data on the slice location of contours to be
+ *       interpolated.
+ * @param sliceIndex - The slice index.
+ * @returns Whether or not the slice needs interpolating.
+ */
+function _sliceNeedsInterpolating(
+  interpolationData: Map<number, Annotation[]>,
+  sliceIndex: number
+): boolean {
+  const annotations = interpolationData.get(sliceIndex);
+  return (
+    !annotations || (annotations.length === 1 && annotations[0].autoGenerated)
+  );
+}
+
+/**
+ * If the contour on slice i can be updated, add it to the
+ * interpolationList.
+ *
+ * @param contourPair - the pair of items to append to
+ * @param interpolationList - The list of contours to be interpolated.
+ * @param itemIndex - the item index to append data to
+ */
+function _appendInterpolationList(contourPair, interpolationList, itemIndex) {
+  const [startIndex] = contourPair;
+  interpolationList[startIndex] ||= {
+    pair: contourPair,
+    list: [],
+  };
+
+  interpolationList[startIndex].list.push(itemIndex);
+}
+
+/**
+ * _getBoundingPair - Given the slice index and range of indices to apply the contour to,
+ * get the pair of polygons to use for interpolation of the slice.
+ * Returns undefined if there is an ambiguity and interpolation can't take place.
+ *
+ * @param sliceIndex - The slice index.
+ * @param sliceRange - The extent of slice occupancy of the ROIContour.
+ * @param interpolationData - Data on the slice location of contours to be
+ *       interpolated.
+ * @returns The pair of slice indices, or undefined if
+ *       the contours to use for interpolation is ambiguous.
+ */
+
+function _getBoundingPair(
+  sliceIndex: number,
+  sliceRange: ContourPair,
+  interpolationData: Map<number, Annotation[]>
+): ContourPair {
+  const annotationPair = [];
+  let canInterpolate = true;
+
+  // Check for nearest lowest sliceIndex containing contours.
+  for (let i = sliceIndex - 1; i >= sliceRange[0]; i--) {
+    const annotations = interpolationData.get(i);
+    if (annotations?.length) {
+      if (annotations[0].autoGenerated) {
+        // This contour is interpolated. We need to find a solid contour to
+        // interpolate from.
+        continue;
+      }
+
+      if (annotations.length > 1) {
+        canInterpolate = false;
+      }
+
+      // Found single, non interpolated contour to interpolate from.
+      annotationPair.push(i);
+      break;
+    }
+  }
+
+  if (!canInterpolate || !annotationPair.length) {
+    return;
+  }
+
+  // Check for nearest upper sliceIndex containing contours.
+  for (let i = sliceIndex + 1; i <= sliceRange[1]; i++) {
+    const annotations = interpolationData.get(i);
+    if (annotations?.length) {
+      if (annotations[0].autoGenerated) {
+        // This contour is interpolated. We need to
+        // Find a solid contour to interpolate from.
+        continue;
+      }
+
+      if (annotations.length > 1) {
+        canInterpolate = false;
+      }
+
+      annotationPair.push(i);
+      break;
+    }
+  }
+
+  if (!canInterpolate || annotationPair.length < 2) {
+    return;
+  }
+
+  return annotationPair as ContourPair;
+}
+
+export default findAnnotationsForInterpolation;

package/src/utilities/contours/interpolation/getInterpolationData.ts

@@ -0,0 +1,75 @@
+import type { InterpolationViewportData, Annotation } from '../../../types';
+import { getAnnotations } from '../../../stateManagement/annotation/annotationState';
+import { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+
+export type FilterParam = {
+  /**
+   * Selects a parent value from the given annotation to get the comparison values from.
+   * Was originally a key name, but this became too limited to match multiple levels
+   * of selection, so was changed to a function returning the values.
+   */
+  parentKey?: (annotation) => any;
+
+  /**
+   * The attribute to extract the value from the parent object, compared with
+   * value to see if the filter matches.
+   */
+  key: string;
+
+  /**
+   * The comparison value to compare against.  If an array, will compare sub-values.
+   */
+  value: unknown;
+};
+
+/**
+ * getInterpolationData - Gets the list of the slice locations of the 2D
+ * polygons that make up the interpolated annotation, along with the annotations
+ * which match the specified filterParams on that slice.
+ *
+ * @param viewportData - the annotation/viewport to start the interpolation from
+ * @param filterParams - A selector for annotations for interpolation
+ * @returns The list of interpolated locations in the stack
+ */
+
+export default function getInterpolationData(
+  viewportData: InterpolationViewportData,
+  filterParams = []
+): Map<number, Annotation[]> {
+  const { viewport, sliceData, annotation } = viewportData;
+  const interpolationDatas = new Map<number, Annotation[]>();
+  const annotations = getAnnotations(
+    annotation.metadata.toolName,
+    viewport.element
+  );
+
+  for (let i = 0; i < sliceData.numberOfSlices; i++) {
+    const imageAnnotations = annotations.filter(
+      (x) =>
+        (x as InterpolationROIAnnotation).metadata.referencedSliceIndex === i
+    );
+
+    if (!imageAnnotations?.length) {
+      continue;
+    }
+
+    const filteredInterpolatedAnnotations = imageAnnotations.filter(
+      (imageAnnotation) => {
+        return filterParams.every((x) => {
+          const parent = x.parentKey
+            ? x.parentKey(imageAnnotation)
+            : imageAnnotation;
+          const value = parent?.[x.key];
+          if (Array.isArray(value)) {
+            return value.every((item, index) => item === x.value[index]);
+          }
+          return value === x.value;
+        });
+      }
+    );
+
+    interpolationDatas.set(i, filteredInterpolatedAnnotations);
+  }
+
+  return interpolationDatas;
+}

package/src/utilities/contours/interpolation/getInterpolationDataCollection.ts

@@ -0,0 +1,31 @@
+import getInterpolationData from './getInterpolationData';
+import type { InterpolationViewportData } from '../../../types';
+import type { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import type { FilterParam } from './getInterpolationData';
+
+/**
+ * getInterpolationDataCollection - Gets the array of annotations which match the
+ * filter parameters, mapped by slice index.
+ *
+ * @param viewportData - the annotation/viewport to start the interpolation from
+ * @param filterParams - A selector for annotations for interpolation
+ * @param onlyAnnotationImage - boolean, if true include interpolated annotation existing images only.
+ * @returns The list of interpolated locations in the stack.
+ */
+
+export default function getInterpolationDataCollection(
+  viewportData: InterpolationViewportData,
+  filterParams: FilterParam[]
+): InterpolationROIAnnotation[] {
+  const imageAnnotations = getInterpolationData(viewportData, filterParams);
+  const interpolatedDataCollection = [];
+  if (!imageAnnotations?.size) {
+    return interpolatedDataCollection;
+  }
+  for (const annotations of imageAnnotations.values()) {
+    annotations.forEach((annotation) => {
+      interpolatedDataCollection.push(annotation);
+    });
+  }
+  return interpolatedDataCollection;
+}

package/src/utilities/contours/interpolation/index.ts

@@ -0,0 +1,3 @@
+import InterpolationManager from '../../segmentation/InterpolationManager/InterpolationManager';
+
+export { InterpolationManager };