@cornerstonejs/tools 1.53.0 → 1.54.0

package/src/utilities/contourSegmentation/removeContourSegmentationAnnotation.ts

@@ -0,0 +1,30 @@
+import { state } from '../../stateManagement/segmentation';
+import { ContourSegmentationAnnotation } from '../../types';
+
+/**
+ * Removes a contour segmentation annotation from the given annotation.
+ * If the annotation does not have a segmentation data, an error is thrown.
+ * @param annotation - The contour segmentation annotation to remove.
+ * @throws Error if the annotation does not have a segmentation data.
+ */
+export function removeContourSegmentationAnnotation(
+  annotation: ContourSegmentationAnnotation
+) {
+  if (!annotation.data.segmentation) {
+    throw new Error(
+      'removeContourSegmentationAnnotation: annotation does not have a segmentation data'
+    );
+  }
+
+  const { segmentationId, segmentIndex } = annotation.data.segmentation;
+  const segmentation = state.getSegmentation(segmentationId);
+  const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+  const annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+
+  annotationsUIDsSet.delete(annotation.annotationUID);
+
+  // Delete segmentIndex Set if there is no more annotations
+  if (!annotationsUIDsSet.size) {
+    annotationUIDsMap.delete(segmentIndex);
+  }
+}

package/src/utilities/contours/detectContourHoles.ts

@@ -18,6 +18,8 @@
  * @returns
  */
 const getIsPointInsidePolygon = (point, vertices) => {
+  // Todo: this is a duplicated logic we should merge it with the other one
+  // which is containsPoint in the utilities
   const x = point[0];
   const y = point[1];
 

package/src/utilities/contours/generateContourSetsFromLabelmap.ts

@@ -3,7 +3,7 @@ import vtkImageMarchingSquares from '@kitware/vtk.js/Filters/General/ImageMarchi
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 
-import { removeDuplicatePoints } from './mergePoints';
+import { getDeduplicatedVTKPolyDataPoints } from '../contours';
 import { findContoursFromReducedSet } from './contourFinder';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 
@@ -107,7 +107,7 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         const msOutput = mSquares.getOutputData();
 
         // Clean up output from marching squares
-        const reducedSet = removeDuplicatePoints(msOutput);
+        const reducedSet = getDeduplicatedVTKPolyDataPoints(msOutput);
         if (reducedSet.points?.length) {
           const contours = findContoursFromReducedSet(reducedSet.lines);
 

package/src/utilities/contours/getDeduplicatedVTKPolyDataPoints.ts

@@ -0,0 +1,66 @@
+/**
+ * Iterate through polyData from vtkjs and merge any points that are the same
+ * then update merged point references within lines array
+ * @param polyData - vtkPolyData
+ * @param bypass - bypass the duplicate point removal
+ * @returns the updated polyData
+ */
+export function getDeduplicatedVTKPolyDataPoints(polyData, bypass = false) {
+  const points = polyData.getPoints();
+  const lines = polyData.getLines();
+
+  // Todo: This is cloning which is not ideal, we should move to use the PointsArrayManager
+  // that will get merged soon
+  const pointsArray = new Array(points.getNumberOfPoints())
+    .fill(0)
+    .map((_, i) => points.getPoint(i).slice());
+
+  const linesArray = new Array(lines.getNumberOfCells()).fill(0).map((_, i) => {
+    const cell = lines.getCell(i * 3).slice();
+    return { a: cell[0], b: cell[1] };
+  });
+
+  if (bypass) {
+    return { points: pointsArray, lines: linesArray };
+  }
+
+  const newPoints = [];
+  for (const [i, pt] of pointsArray.entries()) {
+    // Todo: This is an n^2 algorithm - consider using a Map<string,Point3>.
+    // Generates a reasonable amount of garbage, but I think the performance
+    //  of that is better than doing repeated compares across the entire array.
+    const index = newPoints.findIndex(
+      (point) => point[0] === pt[0] && point[1] === pt[1] && point[2] === pt[2]
+    );
+
+    if (index >= 0) {
+      linesArray.map((line) => {
+        if (line.a === i) {
+          line.a = index;
+        }
+        if (line.b === i) {
+          line.b = index;
+        }
+        return line;
+      });
+    } else {
+      const newIndex = newPoints.length;
+      newPoints.push(pt);
+      linesArray.map((line) => {
+        if (line.a === i) {
+          line.a = newIndex;
+        }
+        if (line.b === i) {
+          line.b = newIndex;
+        }
+        return line;
+      });
+    }
+  }
+
+  const newLines = linesArray.filter((line) => line.a !== line.b);
+
+  return { points: newPoints, lines: newLines };
+}
+
+export default { getDeduplicatedVTKPolyDataPoints };

package/src/utilities/contours/index.ts

@@ -1,6 +1,6 @@
 import areCoplanarContours from './areCoplanarContours';
 import contourFinder from './contourFinder';
-import mergePoints from './mergePoints';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
 import detectContourHoles from './detectContourHoles';
 import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
 import AnnotationToPointData from './AnnotationToPointData';
@@ -14,7 +14,7 @@ import findHandlePolylineIndex from './findHandlePolylineIndex';
 export {
   areCoplanarContours,
   contourFinder,
-  mergePoints,
+  getDeduplicatedVTKPolyDataPoints,
   detectContourHoles,
   generateContourSetsFromLabelmap,
   AnnotationToPointData,

package/src/utilities/index.ts

@@ -17,6 +17,7 @@ import {
   getCalibratedScale,
 } from './getCalibratedUnits';
 import triggerAnnotationRenderForViewportIds from './triggerAnnotationRenderForViewportIds';
+import triggerAnnotationRenderForToolGroupIds from './triggerAnnotationRenderForToolGroupIds';
 import triggerAnnotationRender from './triggerAnnotationRender';
 import jumpToSlice from './viewport/jumpToSlice';
 
@@ -46,6 +47,7 @@ import * as touch from './touch';
 import * as dynamicVolume from './dynamicVolume';
 import * as polyDataUtils from './polyData/utils';
 import * as voi from './voi';
+import * as contourSegmentation from './contourSegmentation';
 
 const roundNumber = utilities.roundNumber;
 
@@ -71,6 +73,7 @@ export {
   segmentation,
   contours,
   triggerAnnotationRenderForViewportIds,
+  triggerAnnotationRenderForToolGroupIds,
   triggerAnnotationRender,
   pointInShapeCallback,
   getSphereBoundsInfo,
@@ -93,4 +96,5 @@ export {
   polyDataUtils,
   voi,
   annotationFrameRange,
+  contourSegmentation,
 };

package/src/utilities/math/polyline/containsPoint.ts

@@ -8,6 +8,8 @@ import isClosed from './isClosed';
  * ray emanating from the given point and to the right and the line segments is odd.
  * https://www.eecs.umich.edu/courses/eecs380/HANDOUTS/PROJ2/InsidePoly.html
  *
+ * Note that a point on the polyline is considered inside.
+ *
  * @param polyline - Polyline points (2D)
  * @param point - 2D Point
  * @returns True if the point is inside the polyline or false otherwise
@@ -24,7 +26,7 @@ export default function containsPoint(
   const numPolylinePoints = polyline.length;
   let numIntersections = 0;
 
-  // Test intersection agains [end, start] line segment if it should be closed
+  // Test intersection against [end, start] line segment if it should be closed
   const shouldClose = !(closed === undefined ? isClosed(polyline) : closed);
   const maxSegmentIndex = polyline.length - (shouldClose ? 1 : 2);
 

package/src/utilities/math/polyline/index.ts

@@ -17,6 +17,7 @@ import getSubPixelSpacingAndXYDirections from './getSubPixelSpacingAndXYDirectio
 import pointsAreWithinCloseContourProximity from './pointsAreWithinCloseContourProximity';
 import addCanvasPointsToArray from './addCanvasPointsToArray';
 import pointCanProjectOnLine from './pointCanProjectOnLine';
+import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
 
 export {
   isClosed,
@@ -39,4 +40,5 @@ export {
   pointCanProjectOnLine,
   mergePolylines,
   subtractPolylines,
+  isPointInsidePolyline3D,
 };

package/src/utilities/math/polyline/isPointInsidePolyline3D.ts

@@ -0,0 +1,56 @@
+import type { Types } from '@cornerstonejs/core';
+import containsPoint from './containsPoint';
+
+/**
+ * Determines whether a 3D point is inside a polyline in 3D space.
+ *
+ * The algorithm works by reducing the polyline and point to 2D space, and then
+ * using the 2D algorithm to determine whether the point is inside the polyline.
+ *
+ * @param point - The 3D point to test.
+ * @param polyline - The polyline represented as an array of 3D points.
+ * @returns A boolean indicating whether the point is inside the polyline.
+ * @throws An error if a shared dimension index cannot be found for the polyline points.
+ */
+export function isPointInsidePolyline3D(
+  point: Types.Point3,
+  polyline: Types.Point3[]
+) {
+  // Todo: handle oblique planes
+
+  // We need to reduce one dimension to 2D, so basically
+  // we need to find the dimension index that is shared by all points
+  // Use the first three points, two is enough but three is more robust
+  let sharedDimensionIndex;
+
+  const testPoints = polyline.slice(0, 3);
+  for (let i = 0; i < 3; i++) {
+    if (testPoints.every((point, index, array) => point[i] === array[0][i])) {
+      sharedDimensionIndex = i;
+      break;
+    }
+  }
+
+  if (sharedDimensionIndex === undefined) {
+    throw new Error(
+      'Cannot find a shared dimension index for polyline, probably oblique plane'
+    );
+  }
+
+  // convert polyline list and point to 2D
+  const points2D = [] as Types.Point2[];
+
+  for (let i = 0; i < polyline.length; i++) {
+    points2D.push([
+      polyline[i][(sharedDimensionIndex + 1) % 3],
+      polyline[i][(sharedDimensionIndex + 2) % 3],
+    ]);
+  }
+
+  const point2D = [
+    point[(sharedDimensionIndex + 1) % 3],
+    point[(sharedDimensionIndex + 2) % 3],
+  ] as Types.Point2;
+
+  return containsPoint(points2D, point2D);
+}

package/src/utilities/segmentation/contourAndFindLargestBidirectional.ts

@@ -2,7 +2,6 @@ import { generateContourSetsFromLabelmap } from '../contours';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import findLargestBidirectional from './findLargestBidirectional';
 
-const EPSILON = 1e-2;
 const { Labelmap } = SegmentationRepresentations;
 
 /**

package/src/utilities/segmentation/getHoveredContourSegmentationAnnotation.ts

@@ -0,0 +1,25 @@
+import { getAnnotation } from '../../stateManagement';
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+
+/**
+ * Retrieves the index of the hovered contour segmentation annotation for a given segmentation ID.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @returns The index of the hovered contour segmentation annotation, or undefined if none is found.
+ */
+export function getHoveredContourSegmentationAnnotation(segmentationId) {
+  const segmentation = getSegmentation(segmentationId);
+  const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+
+  for (const [segmentIndex, annotationUIDs] of annotationUIDsMap.entries()) {
+    const highlightedAnnotationUID = Array.from(annotationUIDs).find(
+      (annotationUID) => getAnnotation(annotationUID).highlighted
+    );
+
+    if (highlightedAnnotationUID) {
+      return segmentIndex;
+    }
+  }
+
+  return undefined;
+}

package/src/utilities/segmentation/getSegmentAtLabelmapBorder.ts

@@ -0,0 +1,179 @@
+import { cache, utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import {
+  getSegmentation,
+  getSegmentationIdRepresentations,
+} from '../../stateManagement/segmentation/segmentationState';
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../types/LabelmapTypes';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+
+type Options = {
+  viewport?: Types.IViewport;
+  searchRadius?: number;
+};
+
+/**
+ * Retrieves the segment index at the border of a labelmap in a segmentation.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @param worldPoint - The world coordinates of the point.
+ * @param options - Additional options.
+ * @param options.viewport - The viewport to use.
+ * @param options.searchRadius - The search radius to use.
+ * @returns The segment index at the labelmap border, or undefined if not found.
+ */
+export function getSegmentAtLabelmapBorder(
+  segmentationId: string,
+  worldPoint: Types.Point3,
+  { viewport, searchRadius }: Options
+): number {
+  const segmentation = getSegmentation(segmentationId);
+
+  const labelmapData = segmentation.representationData.LABELMAP;
+
+  if (isVolumeSegmentation(labelmapData)) {
+    const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
+    const segmentationVolume = cache.getVolume(volumeId);
+
+    if (!segmentationVolume) {
+      return;
+    }
+
+    const imageData = segmentationVolume.imageData;
+
+    const segmentIndex = imageData.getScalarValueFromWorld(worldPoint);
+
+    const canvasPoint = viewport.worldToCanvas(worldPoint);
+
+    const onEdge = isSegmentOnEdgeCanvas(
+      canvasPoint as Types.Point2,
+      segmentIndex,
+      viewport,
+      imageData,
+      searchRadius
+    );
+
+    return onEdge ? segmentIndex : undefined;
+  }
+
+  // stack segmentation case
+  const { imageIdReferenceMap } = labelmapData as LabelmapSegmentationDataStack;
+
+  const currentImageId = (viewport as Types.IStackViewport).getCurrentImageId();
+
+  const segmentationImageId = imageIdReferenceMap.get(currentImageId);
+  const image = cache.getImage(segmentationImageId);
+
+  if (!image) {
+    return;
+  }
+
+  // find the first segmentationRepresentationUID for the segmentationId, since
+  // that is what we use as actorUID in the viewport
+
+  const segmentationRepresentations = getSegmentationIdRepresentations(
+    segmentation.segmentationId
+  );
+
+  const { segmentationRepresentationUID } = segmentationRepresentations[0];
+  const segmentationActor = viewport.getActor(segmentationRepresentationUID);
+  const imageData = segmentationActor?.actor.getMapper().getInputData();
+  const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+
+  const dimensions = imageData.getDimensions();
+  const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
+    dimensions,
+    imageData.getPointData().getScalars().getData()
+  );
+
+  const segmentIndex = voxelManager.getAtIJK(...(indexIJK as Types.Point3));
+
+  const onEdge = isSegmentOnEdgeIJK(
+    indexIJK as Types.Point3,
+    dimensions,
+    voxelManager,
+    segmentIndex
+  );
+
+  return onEdge ? segmentIndex : undefined;
+}
+
+/**
+ * Checks if a segment is on the edge of a labelmap.
+ * @param getNeighborIndex - A function that returns the neighbor index given the delta values.
+ * @param segmentIndex - The index of the segment to check.
+ * @param searchRadius - The radius within which to search for neighboring segments. Default is 1.
+ * @returns A boolean indicating whether the segment is on the edge.
+ */
+function isSegmentOnEdge(
+  getNeighborIndex: (
+    deltaI: number,
+    deltaJ: number,
+    deltaK: number
+  ) => number | undefined,
+  segmentIndex: number,
+  searchRadius = 1 // Default search radius
+): boolean {
+  const neighborRange = Array.from(
+    { length: 2 * searchRadius + 1 },
+    (_, i) => i - searchRadius
+  );
+
+  for (const deltaI of neighborRange) {
+    for (const deltaJ of neighborRange) {
+      for (const deltaK of neighborRange) {
+        if (deltaI === 0 && deltaJ === 0 && deltaK === 0) {
+          continue; // Skipping the central point
+        }
+
+        const neighborIndex = getNeighborIndex(deltaI, deltaJ, deltaK);
+
+        if (neighborIndex !== undefined && segmentIndex !== neighborIndex) {
+          return true; // On the edge
+        }
+      }
+    }
+  }
+
+  return false; // No edge neighbors found
+}
+
+function isSegmentOnEdgeIJK(
+  indexIJK: Types.Point3,
+  dimensions: Types.Point3,
+  voxelManager: any,
+  segmentIndex: number,
+  searchRadius?: number
+): boolean {
+  const getNeighborIndex = (deltaI: number, deltaJ: number, deltaK: number) => {
+    const neighborIJK = [
+      indexIJK[0] + deltaI,
+      indexIJK[1] + deltaJ,
+      indexIJK[2] + deltaK,
+    ];
+
+    return voxelManager.getAtIJK(...neighborIJK);
+  };
+
+  return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
+}
+
+function isSegmentOnEdgeCanvas(
+  canvasPoint: Types.Point2,
+  segmentIndex: number,
+  viewport: Types.IViewport,
+  imageData: any,
+  searchRadius?: number
+): boolean {
+  const getNeighborIndex = (deltaI: number, deltaJ: number) => {
+    const neighborCanvas = [canvasPoint[0] + deltaI, canvasPoint[1] + deltaJ];
+
+    const worldPoint = viewport.canvasToWorld(neighborCanvas as Types.Point2);
+    return imageData.getScalarValueFromWorld(worldPoint);
+  };
+
+  return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
+}

package/src/utilities/segmentation/getSegmentAtWorldPoint.ts

@@ -0,0 +1,173 @@
+import { cache, utilities } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import {
+  getSegmentation,
+  getSegmentationIdRepresentations,
+} from '../../stateManagement/segmentation/segmentationState';
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../types/LabelmapTypes';
+import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
+import { ContourSegmentationAnnotation, Segmentation } from '../../types';
+import { getAnnotation } from '../../stateManagement';
+import { isPointInsidePolyline3D } from '../math/polyline';
+
+type Options = {
+  representationType?: SegmentationRepresentations;
+  viewport?: Types.IViewport;
+};
+
+/**
+ * Get the segment at the specified world point in the viewport.
+ * @param segmentationId - The ID of the segmentation to get the segment for.
+ * @param worldPoint - The world point to get the segment for.
+ *
+ * @returns The index of the segment at the world point, or undefined if not found.
+ */
+export function getSegmentAtWorldPoint(
+  segmentationId: string,
+  worldPoint: Types.Point3,
+  options = {} as Options
+): number {
+  const segmentation = getSegmentation(segmentationId);
+
+  const representationData = segmentation.representationData;
+
+  // if representationType is not provided, we will use the first representation
+  const desiredRepresentation =
+    options?.representationType ?? Object.keys(representationData)[0];
+
+  if (!desiredRepresentation) {
+    throw new Error(
+      `Segmentation ${segmentationId} does not have any representations`
+    );
+  }
+
+  switch (desiredRepresentation) {
+    case SegmentationRepresentations.Labelmap:
+      return getSegmentAtWorldForLabelmap(segmentation, worldPoint, options);
+    case SegmentationRepresentations.Contour:
+      return getSegmentAtWorldForContour(segmentation, worldPoint, options);
+    default:
+      return;
+  }
+}
+
+/**
+ * Retrieves the segment index at a given world point for a labelmap.
+ *
+ * @param labelmapData - The labelmap segmentation data.
+ * @param worldPoint - The world point to retrieve the segment at.
+ *
+ * @returns The segment index at the given world point, or undefined if not found.
+ */
+export function getSegmentAtWorldForLabelmap(
+  segmentation: Segmentation,
+  worldPoint: Types.Point3,
+  { viewport }: Options
+): number | undefined {
+  const labelmapData = segmentation.representationData.LABELMAP;
+
+  if (isVolumeSegmentation(labelmapData)) {
+    const { volumeId } = labelmapData as LabelmapSegmentationDataVolume;
+    const segmentationVolume = cache.getVolume(volumeId);
+
+    if (!segmentationVolume) {
+      return;
+    }
+
+    const segmentIndex =
+      segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
+
+    return segmentIndex;
+  }
+
+  // stack segmentation case
+  const { imageIdReferenceMap } = labelmapData as LabelmapSegmentationDataStack;
+
+  const currentImageId = (viewport as Types.IStackViewport).getCurrentImageId();
+
+  const segmentationImageId = imageIdReferenceMap.get(currentImageId);
+  const image = cache.getImage(segmentationImageId);
+
+  if (!image) {
+    return;
+  }
+
+  // find the first segmentationRepresentationUID for the segmentationId, since
+  // that is what we use as actorUID in the viewport
+
+  const segmentationRepresentations = getSegmentationIdRepresentations(
+    segmentation.segmentationId
+  );
+
+  const { segmentationRepresentationUID } = segmentationRepresentations[0];
+
+  const segmentationActor = viewport.getActor(segmentationRepresentationUID);
+  const imageData = segmentationActor?.actor.getMapper().getInputData();
+  const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+
+  const dimensions = imageData.getDimensions();
+  const voxelManager = utilities.VoxelManager.createVolumeVoxelManager(
+    dimensions,
+    imageData.getPointData().getScalars().getData()
+  );
+
+  const segmentIndex = voxelManager.getAtIJK(...(indexIJK as Types.Point3));
+
+  return segmentIndex;
+}
+
+/**
+ * Retrieves the segment index at a given world point for contour segmentation.
+ *
+ * @param segmentation - The segmentation data.
+ * @param worldPoint - The world point to check.
+ * @param options - The options for segmentation.
+ * @returns The segment index at the given world point, or undefined if not found.
+ */
+export function getSegmentAtWorldForContour(
+  segmentation: Segmentation,
+  worldPoint: Types.Point3,
+  { viewport }: Options
+): number {
+  const contourData = segmentation.representationData.CONTOUR;
+
+  const segmentIndices = Array.from(contourData.annotationUIDsMap.keys());
+  const { viewPlaneNormal } = viewport.getCamera();
+
+  for (const segmentIndex of segmentIndices) {
+    const annotationsSet = contourData.annotationUIDsMap.get(segmentIndex);
+
+    if (!annotationsSet) {
+      continue;
+    }
+
+    for (const annotationUID of annotationsSet) {
+      const annotation = getAnnotation(
+        annotationUID
+      ) as ContourSegmentationAnnotation;
+
+      if (!annotation) {
+        continue;
+      }
+
+      const { polyline } = annotation.data.contour;
+
+      if (
+        !utilities.isEqual(viewPlaneNormal, annotation.metadata.viewPlaneNormal)
+      ) {
+        continue;
+      }
+
+      // This function checks whether we are inside the contour. It does not
+      // check if we are exactly on the contour, which is highly unlikely given
+      // the canvas pixel resolution of 1 decimal place we have by design.
+      if (isPointInsidePolyline3D(worldPoint, polyline)) {
+        return Number(segmentIndex);
+      }
+    }
+  }
+}