@cornerstonejs/tools 1.52.0 → 1.54.0

package/src/utilities/contourSegmentation/addContourSegmentationAnnotation.ts

@@ -0,0 +1,29 @@
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { ContourSegmentationAnnotation } from '../../types';
+
+/**
+ * Adds a contour segmentation annotation to the specified segmentation.
+ * @param annotation - The contour segmentation annotation to add.
+ */
+export function addContourSegmentationAnnotation(
+  annotation: ContourSegmentationAnnotation
+) {
+  if (!annotation.data.segmentation) {
+    throw new Error(
+      'addContourSegmentationAnnotation: annotation does not have a segmentation data'
+    );
+  }
+
+  const { segmentationId, segmentIndex } = annotation.data.segmentation;
+  const segmentation = getSegmentation(segmentationId);
+  const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+
+  let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+
+  if (!annotationsUIDsSet) {
+    annotationsUIDsSet = new Set();
+    annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
+  }
+
+  annotationsUIDsSet.add(annotation.annotationUID);
+}

package/src/utilities/contourSegmentation/areSameSegment.ts

@@ -17,8 +17,6 @@ export default function areSameSegment(
 
   return (
     firstSegmentation.segmentationId === secondSegmentation.segmentationId &&
-    firstSegmentation.segmentationRepresentationUID ===
-      secondSegmentation.segmentationRepresentationUID &&
     firstSegmentation.segmentIndex === secondSegmentation.segmentIndex
   );
 }

package/src/utilities/contourSegmentation/index.ts

@@ -1,2 +1,4 @@
 export { default as areSameSegment } from './areSameSegment';
 export { default as isContourSegmentationAnnotation } from './isContourSegmentationAnnotation';
+export { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
+export { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';

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/getContourHolesDataCanvas.ts

@@ -0,0 +1,33 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation } from '../../types';
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+
+/**
+ * Get the polylines for the child annotations (holes)
+ * @param annotation - Annotation
+ * @param viewport - Viewport used to convert the points from world to canvas space
+ * @returns An array that contains all child polylines
+ */
+export default function getContourHolesDataCanvas(
+  annotation: Annotation,
+  viewport: Types.IViewport
+): Types.Point2[][] {
+  const worldHoleContours = getContourHolesDataWorld(annotation);
+  const canvasHoleContours = [];
+
+  worldHoleContours.forEach((worldHoleContour) => {
+    const numPoints = worldHoleContour.length;
+
+    // Pre-allocated arrays are 3-4x faster than multiple "push()" calls
+    const canvasHoleContour: Types.Point2[] = new Array(numPoints);
+
+    // Using FOR loop instead of map() for better performance when processing large arrays
+    for (let i = 0; i < numPoints; i++) {
+      canvasHoleContour[i] = viewport.worldToCanvas(worldHoleContour[i]);
+    }
+
+    canvasHoleContours.push(canvasHoleContour);
+  });
+
+  return canvasHoleContours;
+}

package/src/utilities/contours/getContourHolesDataWorld.ts

@@ -0,0 +1,19 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Annotation, ContourAnnotation } from '../../types';
+import { getAnnotation } from '../../stateManagement';
+
+/**
+ * Get child polylines data in world space for contour annotations that represent the holes
+ * @param annotation - Annotation
+ * @param viewport - Viewport used to convert the points from world to canvas space
+ * @returns An array that contains all child polylines (holes) in world space
+ */
+export default function getContourHolesDataWorld(
+  annotation: Annotation
+): Types.Point3[][] {
+  const childAnnotationUIDs = annotation.childAnnotationUIDs ?? [];
+
+  return childAnnotationUIDs.map(
+    (uid) => (getAnnotation(uid) as ContourAnnotation).data.contour.polyline
+  );
+}

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,9 +1,12 @@
 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';
+import getContourHolesDataWorld from './getContourHolesDataWorld';
+import getContourHolesDataCanvas from './getContourHolesDataCanvas';
+import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
 import * as interpolation from './interpolation';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
@@ -11,10 +14,13 @@ import findHandlePolylineIndex from './findHandlePolylineIndex';
 export {
   areCoplanarContours,
   contourFinder,
-  mergePoints,
+  getDeduplicatedVTKPolyDataPoints,
   detectContourHoles,
   generateContourSetsFromLabelmap,
   AnnotationToPointData,
+  getContourHolesDataWorld,
+  getContourHolesDataCanvas,
+  updateContourPolyline,
   interpolation,
   acceptAutogeneratedInterpolations,
   findHandlePolylineIndex,

package/src/utilities/contours/updateContourPolyline.ts

@@ -0,0 +1,74 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { Types } from '@cornerstonejs/core';
+import type { ContourAnnotation } from '../../types';
+import type { ContourWindingDirection } from '../../types/ContourAnnotation';
+import * as math from '../math';
+import {
+  getParentAnnotation,
+  invalidateAnnotation,
+} from '../../stateManagement';
+
+/**
+ * Update the contour polyline data
+ * @param annotation - Contour annotation
+ * @param viewport - Viewport
+ * @param polylineData - Polyline data (points, winding direction and closed)
+ * @param transforms - Methods to convert points to/from canvas and world spaces
+ */
+export default function updateContourPolyline(
+  annotation: ContourAnnotation,
+  polylineData: {
+    points: Types.Point2[];
+    closed?: boolean;
+    targetWindingDirection?: ContourWindingDirection;
+  },
+  transforms: {
+    canvasToWorld: (point: Types.Point2) => Types.Point3;
+  }
+) {
+  const { canvasToWorld } = transforms;
+  const { data } = annotation;
+  const { points: polyline, targetWindingDirection } = polylineData;
+  let { closed } = polylineData;
+  const numPoints = polyline.length;
+  const polylineWorldPoints = new Array(numPoints);
+  const currentWindingDirection = math.polyline.getWindingDirection(polyline);
+  const parentAnnotation = getParentAnnotation(annotation) as ContourAnnotation;
+
+  if (closed === undefined) {
+    let currentClosedState = false;
+
+    // With two points it is just a line and do not make sense to consider it closed
+    if (polyline.length > 3) {
+      const lastToFirstDist = math.point.distanceToPointSquared(
+        polyline[0],
+        polyline[numPoints - 1]
+      );
+
+      currentClosedState = csUtils.isEqual(0, lastToFirstDist);
+    }
+
+    closed = currentClosedState;
+  }
+
+  // It must be in the opposite direction if it is a child annotation (hole)
+  let windingDirection = parentAnnotation
+    ? parentAnnotation.data.contour.windingDirection * -1
+    : targetWindingDirection;
+
+  if (windingDirection === undefined) {
+    windingDirection = currentWindingDirection;
+  } else if (windingDirection !== currentWindingDirection) {
+    polyline.reverse();
+  }
+
+  for (let i = 0; i < numPoints; i++) {
+    polylineWorldPoints[i] = canvasToWorld(polyline[i]);
+  }
+
+  data.contour.polyline = polylineWorldPoints;
+  data.contour.closed = closed;
+  data.contour.windingDirection = windingDirection;
+
+  invalidateAnnotation(annotation);
+}

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,9 +8,11 @@ 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 is the point is inside the polyline or false otherwise
+ * @returns True if the point is inside the polyline or false otherwise
  */
 export default function containsPoint(
   polyline: Types.Point2[],
@@ -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/containsPoints.ts

@@ -0,0 +1,22 @@
+import type { Types } from '@cornerstonejs/core';
+import containsPoint from './containsPoint';
+
+/**
+ * Checks if a polyline contains a set of points.
+ *
+ * @param polyline - Polyline points (2D)
+ * @param points - 2D points to verify
+ * @returns True if all points are inside the polyline or false otherwise
+ */
+export default function containsPoints(
+  polyline: Types.Point2[],
+  points: Types.Point2[]
+): boolean {
+  for (let i = 0, numPoint = points.length; i < numPoint; i++) {
+    if (!containsPoint(polyline, points[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}

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

@@ -0,0 +1,14 @@
+import type { Types } from '@cornerstonejs/core';
+import getSignedArea from './getSignedArea';
+
+/**
+ * Calculate the winding direction (CW or CCW) of a polyline
+ * @param polyline - Polyline (2D)
+ * @returns 1 for CW or -1 for CCW polylines
+ */
+export default function getWindingDirection(polyline: Types.Point2[]): number {
+  const signedArea = getSignedArea(polyline);
+
+  // Return 1 or -1 which is also possible to convert into ContourOrientation
+  return signedArea >= 0 ? 1 : -1;
+}

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

@@ -1,8 +1,10 @@
 import isClosed from './isClosed';
 import containsPoint from './containsPoint';
+import containsPoints from './containsPoints';
 import getAABB from './getAABB';
 import getArea from './getArea';
 import getSignedArea from './getSignedArea';
+import getWindingDirection from './getWindingDirection';
 import getNormal3 from './getNormal3';
 import getNormal2 from './getNormal2';
 import { mergePolylines, subtractPolylines } from './combinePolyline';
@@ -15,13 +17,16 @@ import getSubPixelSpacingAndXYDirections from './getSubPixelSpacingAndXYDirectio
 import pointsAreWithinCloseContourProximity from './pointsAreWithinCloseContourProximity';
 import addCanvasPointsToArray from './addCanvasPointsToArray';
 import pointCanProjectOnLine from './pointCanProjectOnLine';
+import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
 
 export {
   isClosed,
   containsPoint,
+  containsPoints,
   getAABB,
   getArea,
   getSignedArea,
+  getWindingDirection,
   getNormal3,
   getNormal2,
   intersectPolyline,
@@ -35,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/math/polyline/planarFreehandROIInternalTypes.ts

@@ -6,6 +6,7 @@ import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotati
 type PlanarFreehandROIDrawData = {
   polylineIndex: number;
   canvasPoints: Types.Point2[];
+  contourHoleProcessingEnabled: boolean;
 };
 
 type PlanarFreehandROIEditData = {

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;
+}