@cornerstonejs/tools 1.41.0 → 1.42.0

package/src/utilities/contours/mergePoints.ts

@@ -0,0 +1,108 @@
+/**
+ * Checks if point is within array
+ * @param {*} array
+ * @param {*} pt
+ * @returns
+ */
+function ptInArray(array, pt) {
+  let index = -1;
+  for (let i = 0; i < array.length; i++) {
+    if (isSamePoint(pt, array[i])) {
+      index = i;
+    }
+  }
+  return index;
+}
+
+/**
+ * Checks if point A and point B contain same values
+ * @param {*} ptA
+ * @param {*} ptB
+ * @returns
+ */
+function isSamePoint(ptA, ptB) {
+  if (ptA[0] == ptB[0] && ptA[1] == ptB[1] && ptA[2] == ptB[2]) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Goes through linesArray and replaces all references of old index with new index
+ * @param {*} linesArray
+ * @param {*} oldIndex
+ * @param {*} newIndex
+ */
+function replacePointIndexReferences(linesArray, oldIndex, newIndex) {
+  for (let i = 0; i < linesArray.length; i++) {
+    const line = linesArray[i];
+    if (line.a == oldIndex) {
+      line.a = newIndex;
+    } else if (line.b == oldIndex) {
+      line.b = newIndex;
+    }
+  }
+}
+
+/**
+ * Iterate through polyData from vtkjs and merge any points that are the same
+ * then update merged point references within lines array
+ * @param {*} polyData
+ * @param {*} bypass
+ * @returns
+ */
+export function removeDuplicatePoints(polyData, bypass = false) {
+  const points = polyData.getPoints();
+  const lines = polyData.getLines();
+
+  const pointsArray = [];
+  for (let i = 0; i < points.getNumberOfPoints(); i++) {
+    const pt = points.getPoint(i).slice();
+    pointsArray.push(pt);
+  }
+  const linesArray = [];
+  for (let i = 0; i < lines.getNumberOfCells(); i++) {
+    const cell = lines.getCell(i * 3).slice();
+    //console.log(JSON.stringify(cell));
+    const a = cell[0];
+    const b = cell[1];
+    const line = {
+      a,
+      b,
+    };
+    linesArray.push(line);
+  }
+
+  if (bypass) {
+    return { points: pointsArray, lines: linesArray };
+  }
+
+  // Iterate through points and replace any duplicates
+  const newPoints = [];
+  for (let i = 0; i < pointsArray.length; i++) {
+    const pt = pointsArray[i];
+    let index = ptInArray(newPoints, pt);
+
+    if (index >= 0) {
+      // Duplicate Point -> replace references in lines
+      replacePointIndexReferences(linesArray, i, index);
+    } else {
+      index = newPoints.length;
+      newPoints.push(pt);
+      replacePointIndexReferences(linesArray, i, index);
+    }
+  }
+
+  // Final pass through lines, remove any that refer to exact same point
+  const newLines = [];
+  linesArray.forEach((line) => {
+    if (line.a != line.b) {
+      newLines.push(line);
+    }
+  });
+
+  return { points: newPoints, lines: newLines };
+}
+
+export default { removeDuplicatePoints };

package/src/utilities/index.ts

@@ -26,6 +26,7 @@ import { pointToString } from './pointToString';
 import annotationFrameRange from './annotationFrameRange';
 
 // name spaces
+import * as contours from './contours';
 import * as segmentation from './segmentation';
 import * as drawing from './drawing';
 import * as math from './math';
@@ -63,6 +64,7 @@ export {
   getCalibratedAreaUnits,
   getCalibratedScale,
   segmentation,
+  contours,
   triggerAnnotationRenderForViewportIds,
   triggerAnnotationRender,
   pointInShapeCallback,

package/src/utilities/segmentation/contourAndFindLargestBidirectional.ts

@@ -0,0 +1,46 @@
+import { generateContourSetsFromLabelmap } from '../contours';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import findLargestBidirectional from './findLargestBidirectional';
+
+const EPSILON = 1e-2;
+const { Labelmap } = SegmentationRepresentations;
+
+/**
+ * Generates a contour object over the segment, and then uses the contouring to
+ * find the largest bidirectional object that can be applied within the acquisition
+ * plane that is within the segment index, or the contained segment indices.
+ *
+ * @param segmentation.segments - a list of segments to apply the contour to.
+ * @param segmentation.segments.containedSegmentIndices - a set of segment indexes equivalent to the primary segment
+ * @param segmentation.segments.label - the label for the segment
+ * @param segmentation.segments.color - the color to use for the segment label
+ */
+export default function contourAndFindLargestBidirectional(segmentation) {
+  const contours = generateContourSetsFromLabelmap({
+    segmentations: segmentation,
+  });
+
+  if (!contours?.length || !contours[0].sliceContours.length) {
+    return;
+  }
+
+  const {
+    representationData,
+    segments = [
+      null,
+      { label: 'Unspecified', color: null, containedSegmentIndices: null },
+    ],
+  } = segmentation;
+  const { volumeId: segVolumeId } = representationData[Labelmap];
+
+  const segmentIndex = segments.findIndex((it) => !!it);
+  if (segmentIndex === -1) {
+    return;
+  }
+  segments[segmentIndex].segmentIndex = segmentIndex;
+  return findLargestBidirectional(
+    contours[0],
+    segVolumeId,
+    segments[segmentIndex]
+  );
+}

package/src/utilities/segmentation/createBidirectionalToolData.ts

@@ -0,0 +1,68 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../../types/AnnotationTypes';
+
+export type BidirectionalData = {
+  majorAxis: [Types.Point3, Types.Point3];
+  minorAxis: [Types.Point3, Types.Point3];
+  maxMajor: number;
+  maxMinor: number;
+  segmentIndex: number;
+  label?: string;
+  color?: string | number[];
+  referencedImageId: string;
+  FrameOfReferenceUID: string;
+};
+
+/**
+ * Creates data suitable for the BidirectionalTool from the basic bidirectional
+ * data object.
+ */
+export default function createBidirectionalToolData(
+  bidirectionalData: BidirectionalData,
+  viewport
+): Annotation {
+  const {
+    majorAxis,
+    minorAxis,
+    label = '',
+    FrameOfReferenceUID,
+    referencedImageId,
+  } = bidirectionalData;
+  const [major0, major1] = majorAxis;
+  const [minor0, minor1] = minorAxis;
+
+  const { viewUp, viewPlaneNormal } = viewport.getCamera();
+  const points = [major0, major1, minor0, minor1];
+  const bidirectionalToolData = {
+    highlighted: true,
+    invalidated: true,
+    metadata: {
+      toolName: 'Bidirectional',
+      viewPlaneNormal,
+      viewUp,
+      FrameOfReferenceUID,
+      referencedImageId,
+    },
+    data: {
+      handles: {
+        points,
+        textBox: {
+          hasMoved: false,
+          worldPosition: [0, 0, 0] as Types.Point3,
+          worldBoundingBox: {
+            topLeft: [0, 0, 0] as Types.Point3,
+            topRight: [0, 0, 0] as Types.Point3,
+            bottomLeft: [0, 0, 0] as Types.Point3,
+            bottomRight: [0, 0, 0] as Types.Point3,
+          },
+        },
+        activeHandleIndex: null,
+      },
+      label,
+      cachedStats: {},
+    },
+    isLocked: false,
+    isVisible: true,
+  };
+  return bidirectionalToolData;
+}

package/src/utilities/segmentation/findLargestBidirectional.ts

@@ -0,0 +1,159 @@
+import { vec3 } from 'gl-matrix';
+
+import { createIsInSegment, isLineInSegment } from './isLineInSegment';
+import type { BidirectionalData } from './createBidirectionalToolData';
+
+const EPSILON = 1e-2;
+
+/**
+ * Search in the contours for the given segment to find the largest bidirectional
+ * that will fit entirely within the slice contours inside the contours object.
+ * Assumptions/implementation details:
+ *
+ *   1. The major and minor bidirectional lines must not cross the contour
+ *   2. The center point for both major and minor bidirectional lines must be
+ *      within the segment, or the contained segment index.
+ *   3. The major/minor axis must be orthogonal
+ *
+ * Note this does NOT test that the major/minor axis intersect.  Normally they will, but
+ * it isn't a hard requirement.
+ *
+ * The way that islands within the contours are handled is to allow the island to be
+ * coloured with something that is contained - that way both open and closed islands
+ * can be handled correctly for finding the bidirectional  (an open island is a section
+ * inside the segment that is open to the outside - this can happen at bone endpoints or when
+ * one region flows into another)
+ */
+export default function findLargestBidirectional(
+  contours,
+  segVolumeId: string,
+  segment
+) {
+  const { sliceContours } = contours;
+  const { segmentIndex, containedSegmentIndices } = segment;
+  let maxBidirectional;
+  const isInSegment = createIsInSegment(
+    segVolumeId,
+    segmentIndex,
+    containedSegmentIndices
+  );
+  for (const sliceContour of sliceContours) {
+    const bidirectional = createBidirectionalForSlice(
+      sliceContour,
+      isInSegment,
+      maxBidirectional
+    );
+    if (!bidirectional) {
+      continue;
+    }
+    maxBidirectional = bidirectional;
+  }
+  if (maxBidirectional) {
+    Object.assign(maxBidirectional, segment);
+  }
+  return maxBidirectional;
+}
+
+/**
+ * This function creates a bidirectional data object for the given slice and
+ * slice contour, only when the major distance is larger than currentMax, or
+ * equal to current max and the minor is larger than currentMax's minor.
+ * It does this by looking at every pair of distances in sliceCountour to find
+ * those larger than the currentMax, and then finds the minor distance for those
+ * major distances.
+ *
+ */
+function createBidirectionalForSlice(
+  sliceContour,
+  isInSegment,
+  currentMax = { maxMajor: 0, maxMinor: 0 }
+) {
+  const { points } = sliceContour.polyData;
+  const { maxMinor: currentMaxMinor, maxMajor: currentMaxMajor } = currentMax;
+  let maxMajor = currentMaxMajor * currentMaxMajor;
+  let maxMinor = currentMaxMinor * currentMaxMinor;
+  let maxMajorPoints;
+  for (let index1 = 0; index1 < points.length; index1++) {
+    for (let index2 = index1 + 1; index2 < points.length; index2++) {
+      const point1 = points[index1];
+      const point2 = points[index2];
+      const distance2 = vec3.sqrDist(point1, point2);
+      if (distance2 < maxMajor) {
+        continue;
+      }
+      if (distance2 - EPSILON < maxMajor + EPSILON && maxMajorPoints) {
+        // Consider adding to the set of points rather than continuing here
+        // so that all minor axis can be tested
+        continue;
+      }
+      if (!isInSegment.testCenter(point1, point2)) {
+        // Center between the two points has to be in the segment, otherwise
+        // this is out of bounds.
+        continue;
+      }
+      if (!isLineInSegment(point1, point2, isInSegment)) {
+        // If the line intersects the segment boundary, then skip it
+        continue;
+      }
+      maxMajor = distance2 - EPSILON;
+      maxMajorPoints = [index1, index2];
+      maxMinor = 0;
+    }
+  }
+  if (!maxMajorPoints) {
+    return;
+  }
+
+  maxMajor = Math.sqrt(maxMajor + EPSILON);
+  const handle0 = points[maxMajorPoints[0]];
+  const handle1 = points[maxMajorPoints[1]];
+  const unitMajor = vec3.sub(vec3.create(), handle0, handle1);
+  vec3.scale(unitMajor, unitMajor, 1 / maxMajor);
+
+  let maxMinorPoints;
+
+  for (let index1 = 0; index1 < points.length; index1++) {
+    for (let index2 = index1 + 1; index2 < points.length; index2++) {
+      const point1 = points[index1];
+      const point2 = points[index2];
+      const distance2 = vec3.sqrDist(point1, point2);
+      if (distance2 <= maxMinor) {
+        continue;
+      }
+      const delta = vec3.sub(vec3.create(), point1, point2);
+
+      const dot = Math.abs(vec3.dot(delta, unitMajor)) / Math.sqrt(distance2);
+      if (dot > EPSILON) {
+        continue;
+      }
+
+      if (!isInSegment.testCenter(point1, point2)) {
+        // Center between the two points has to be in the segment, otherwise
+        // this is out of bounds.
+        continue;
+      }
+      if (!isLineInSegment(point1, point2, isInSegment)) {
+        continue;
+      }
+      maxMinor = distance2;
+      maxMinorPoints = [index1, index2];
+    }
+  }
+
+  if (!maxMinorPoints) {
+    // Didn't find a larger minor distance
+    return;
+  }
+  maxMinor = Math.sqrt(maxMinor);
+  const handle2 = points[maxMinorPoints[0]];
+  const handle3 = points[maxMinorPoints[1]];
+
+  const bidirectional = {
+    majorAxis: [handle0, handle1],
+    minorAxis: [handle2, handle3],
+    maxMajor,
+    maxMinor,
+    ...sliceContour,
+  } as BidirectionalData;
+  return bidirectional;
+}

package/src/utilities/segmentation/index.ts

@@ -15,6 +15,9 @@ import {
   setBrushThresholdForToolGroup,
 } from './brushThresholdForToolGroup';
 import thresholdSegmentationByRange from './thresholdSegmentationByRange';
+import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
+import createBidirectionalToolData from './createBidirectionalToolData';
+import segmentContourAction from './segmentContourAction';
 
 export {
   thresholdVolumeByRange,
@@ -30,4 +33,7 @@ export {
   getBrushThresholdForToolGroup,
   setBrushThresholdForToolGroup,
   thresholdSegmentationByRange,
+  contourAndFindLargestBidirectional,
+  createBidirectionalToolData,
+  segmentContourAction,
 };

package/src/utilities/segmentation/isLineInSegment.ts

@@ -0,0 +1,84 @@
+import type { Types } from '@cornerstonejs/core';
+import { cache } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+
+/**
+ * Determines if there is a point between point1 and point2 which is not
+ * contained in the segmentation
+ */
+export default function isLineInSegment(
+  point1: Types.Point3,
+  point2: Types.Point3,
+  isInSegment
+) {
+  const ijk1 = isInSegment.toIJK(point1);
+  const ijk2 = isInSegment.toIJK(point2);
+  const testPoint = vec3.create();
+  const { testIJK } = isInSegment;
+  const delta = vec3.sub(vec3.create(), ijk1, ijk2);
+
+  // Test once for index value between the two points, so the max of the
+  // difference in IJK values
+  const testSize = Math.round(Math.max(...delta.map(Math.abs)));
+  if (testSize < 2) {
+    // No need to test when there are only two points
+    return true;
+  }
+  const unitDelta = vec3.scale(vec3.create(), delta, 1 / testSize);
+
+  for (let i = 1; i < testSize; i++) {
+    vec3.scaleAndAdd(testPoint, ijk2, unitDelta, i);
+    if (!testIJK(testPoint)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Creates a function that tests to see if the provided line segment, specified
+ * in LPS space (as endpoints) is contained in the segment
+ */
+function createIsInSegment(
+  segVolumeId: string,
+  segmentIndex: number,
+  containedSegmentIndices?: Set<number>
+) {
+  // Get segmentation volume
+  const vol = cache.getVolume(segVolumeId);
+  if (!vol) {
+    console.warn(`No volume found for ${segVolumeId}`);
+    return;
+  }
+
+  const segData = vol.imageData.getPointData().getScalars().getData();
+  const width = vol.dimensions[0];
+  const pixelsPerSlice = width * vol.dimensions[1];
+
+  return {
+    /**
+     * Find the center point between point1 and point2, convert it to IJK space
+     * and test if the value at that location is in the segment
+     */
+    testCenter: (point1, point2) => {
+      const point = vec3.add(vec3.create(), point1, point2).map((it) => it / 2);
+      const ijk = vol.imageData.worldToIndex(point as vec3).map(Math.round);
+      const [i, j, k] = ijk;
+      const index = i + j * width + k * pixelsPerSlice;
+      const value = segData[index];
+      return value === segmentIndex || containedSegmentIndices?.has(value);
+    },
+
+    toIJK: (point) => vol.imageData.worldToIndex(point as vec3),
+
+    testIJK: (ijk) => {
+      const [i, j, k] = ijk;
+      const index =
+        Math.round(i) + Math.round(j) * width + Math.round(k) * pixelsPerSlice;
+      const value = segData[index];
+      return value === segmentIndex || containedSegmentIndices?.has(value);
+    },
+  };
+}
+
+export { createIsInSegment, isLineInSegment };

package/src/utilities/segmentation/segmentContourAction.ts

@@ -0,0 +1,169 @@
+import { getEnabledElement, type Types } from '@cornerstonejs/core';
+
+import type { Annotation } from '../../types/AnnotationTypes';
+import * as segmentation from '../../stateManagement/segmentation';
+import {
+  state as annotationState,
+  config as annotationConfig,
+} from '../../stateManagement/annotation';
+import { jumpToSlice } from '../viewport';
+import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
+import createBidirectionalToolData from './createBidirectionalToolData';
+import BidirectionalTool from '../../tools/annotation/BidirectionalTool';
+
+export type Segment = {
+  segmentationId: string;
+  segmentIndex: number;
+  label: string;
+
+  style?: any;
+  containedSegmentIndices?: (number) => boolean;
+};
+
+export type SegmentContourActionConfiguration = {
+  getSegment?: (
+    enabledElement: Types.IEnabledElement,
+    configuration: SegmentContourActionConfiguration
+  ) => Segment;
+
+  /**
+   * Optional map for data about each segment
+   */
+  segmentationId?: string;
+  segmentIndex?: number;
+  segmentData?: Map<number, Segment>;
+  toolGroupId?: string;
+};
+
+export default function segmentContourAction(
+  element: HTMLDivElement,
+  configuration
+) {
+  const { data: configurationData } = configuration;
+  const enabledElement = getEnabledElement(element);
+  const segment = (configurationData.getSegment || defaultGetSegment)(
+    enabledElement,
+    configurationData
+  );
+  if (!segment) {
+    return;
+  }
+  const FrameOfReferenceUID = enabledElement.viewport.getFrameOfReferenceUID();
+  const segmentationsList = segmentation.state.getSegmentations();
+  const { segmentIndex, segmentationId } = segment;
+  const bidirectionals = annotationState.getAnnotations(
+    this.toolName || BidirectionalTool.toolName,
+    FrameOfReferenceUID
+  );
+  let hasExistingActiveSegment = false;
+  const existingLargestBidirectionals = bidirectionals.filter(
+    (existingBidirectionalItem) => {
+      const { segment } = existingBidirectionalItem.data;
+      if (!segment) {
+        return;
+      }
+      if (
+        segment.segmentationId === segmentationId &&
+        segment.segmentIndex === segmentIndex
+      ) {
+        hasExistingActiveSegment = true;
+        existingBidirectionalItem.data.segment = segment;
+      }
+      return !!segment;
+    }
+  );
+  if (!hasExistingActiveSegment) {
+    // Just create a dummy annotation object containing just enough information
+    // to create a real one.
+    existingLargestBidirectionals.push({
+      data: { segment },
+    } as unknown as Annotation);
+  }
+
+  let newBidirectional;
+  existingLargestBidirectionals.forEach((existingLargestBidirectional) => {
+    const segments = [];
+    const { segment: updateSegment } = existingLargestBidirectional.data;
+    const { segmentIndex, segmentationId } = updateSegment;
+    segments[segmentIndex] = updateSegment;
+    annotationState.removeAnnotation(
+      existingLargestBidirectional.annotationUID
+    );
+    const bidirectionalData = contourAndFindLargestBidirectional({
+      ...segmentationsList.find(
+        (segmentation) => segmentation.segmentationId === segmentationId
+      ),
+      segments,
+    });
+
+    if (!bidirectionalData) {
+      return;
+    }
+    const bidirectionalToolData = createBidirectionalToolData(
+      bidirectionalData,
+      enabledElement.viewport
+    );
+    bidirectionalToolData.annotationUID =
+      existingLargestBidirectional.annotationUID;
+    bidirectionalToolData.data.segment = updateSegment;
+
+    const annotationUID = annotationState.addAnnotation(
+      bidirectionalToolData,
+      FrameOfReferenceUID
+    );
+
+    if (
+      updateSegment.segmentIndex === segment.segmentIndex &&
+      updateSegment.segmentationId === segment.segmentationId
+    ) {
+      newBidirectional = bidirectionalData;
+      const { style } = segment;
+      if (style) {
+        annotationConfig.style.setAnnotationStyles(annotationUID, style);
+      }
+    }
+  });
+
+  if (newBidirectional) {
+    const { referencedImageId } = newBidirectional;
+    const imageIds = enabledElement.viewport.getImageIds();
+    const imageIndex = imageIds.findIndex(
+      (imageId) => imageId === referencedImageId
+    );
+
+    // TODO - figure out why this is reversed
+    jumpToSlice(element, {
+      imageIndex: imageIds.length - 1 - imageIndex,
+    });
+    enabledElement.viewport.render();
+  } else {
+    console.warn('No bidirectional found');
+  }
+
+  return newBidirectional;
+}
+
+export function defaultGetSegment(
+  enabledElement: Types.IEnabledElement,
+  configuration: SegmentContourActionConfiguration
+): Segment {
+  const segmentationsList = segmentation.state.getSegmentations();
+  if (!segmentationsList.length) {
+    return;
+  }
+  const segmentationId =
+    configuration.segmentationId || segmentationsList[0].segmentationId;
+  const segmentIndex =
+    configuration.segmentIndex ??
+    segmentation.segmentIndex.getActiveSegmentIndex(segmentationId);
+  if (!segmentIndex) {
+    return;
+  }
+  const segmentData = configuration.segmentData?.get(segmentIndex);
+  return {
+    label: `Segment ${segmentIndex}`,
+    segmentIndex,
+    segmentationId,
+    ...segmentData,
+  };
+}