@cornerstonejs/tools 1.52.0 → 1.53.0

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

@@ -4,6 +4,9 @@ import mergePoints from './mergePoints';
 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';
@@ -15,6 +18,9 @@ export {
   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/math/polyline/containsPoint.ts

@@ -10,7 +10,7 @@ import isClosed from './isClosed';
  *
  * @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[],

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';
@@ -19,9 +21,11 @@ import pointCanProjectOnLine from './pointCanProjectOnLine';
 export {
   isClosed,
   containsPoint,
+  containsPoints,
   getAABB,
   getArea,
   getSignedArea,
+  getWindingDirection,
   getNormal3,
   getNormal2,
   intersectPolyline,

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 = {