@cornerstonejs/tools 2.0.0-beta.6 → 2.0.0-beta.8

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

@@ -0,0 +1,74 @@
+import { Types } from '@cornerstonejs/core';
+
+/**
+ * Calculates the axis-aligned bounding box (AABB) of a polyline.
+ *
+ * @param polyline - The polyline represented as an array of points.
+ * @param options - Additional options for calculating the AABB.
+ * @param options.isWorld - Indicates whether the polyline represents points in 3D space (true) or 2D space (false).
+ *
+ * @returns The AABB of the polyline. If the polyline represents points in 3D space, returns an AABB3 object with properties minX, maxX, minY, maxY, minZ, and maxZ. If the polyline represents points in 2D space, returns an AABB2 object with properties minX, maxX, minY, and maxY.
+ */
+export default function getAABB(
+  polyline: Types.Point2[] | Types.Point3[] | number[],
+  options?: {
+    numDimensions: number;
+  }
+): Types.AABB2 | Types.AABB3 {
+  // need to check if the polyline is array of arrays or just
+  // a flat array of numbers
+  let polylineToUse = polyline;
+  const numDimensions = options?.numDimensions || 2;
+  const is3D = numDimensions === 3;
+
+  if (!Array.isArray(polyline[0])) {
+    const currentPolyline = polyline as number[];
+    // check the isWorld flag is provided or not which means every
+    // 3 elements in the array represent a point in 3D space
+    // otherwise, every 2 elements in the array represent a point in 2D space
+    const totalPoints = currentPolyline.length / numDimensions;
+
+    polylineToUse = new Array(currentPolyline.length / numDimensions) as
+      | Types.Point2[]
+      | Types.Point3[];
+
+    for (let i = 0, len = totalPoints; i < len; i++) {
+      polylineToUse[i] = [
+        currentPolyline[i * numDimensions],
+        currentPolyline[i * numDimensions + 1],
+      ];
+
+      if (is3D) {
+        polylineToUse[i].push(currentPolyline[i * numDimensions + 2]);
+      }
+    }
+  }
+
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let minZ = Infinity;
+  let maxZ = -Infinity;
+
+  polylineToUse = polylineToUse as Types.Point2[] | Types.Point3[];
+
+  for (let i = 0, len = polylineToUse.length; i < len; i++) {
+    const [x, y, z] = polylineToUse[i];
+
+    // No Math.min/max calls for better performance
+    minX = minX < x ? minX : x;
+    minY = minY < y ? minY : y;
+    maxX = maxX > x ? maxX : x;
+    maxY = maxY > y ? maxY : y;
+
+    if (is3D) {
+      minZ = minZ < z ? minZ : z;
+      maxZ = maxZ > z ? maxZ : z;
+    }
+  }
+
+  return is3D
+    ? { minX, maxX, minY, maxY, minZ, maxZ } // AABB3
+    : { minX, maxX, minY, maxY }; // AABB2
+}

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

@@ -0,0 +1,23 @@
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Calculates the area of an array of `Point2` points using the shoelace algorithm.
+ *
+ * The units of the area are in the same units as the points are in. E.g. if
+ * the points are in canvas, then the result is in canvas pixels ^2; If they are
+ * in mm, then the result is in mm^2; etc.
+ */
+export default function getArea(points: Types.Point2[]): number {
+  // Shoelace algorithm.
+  const n = points.length;
+  let area = 0.0;
+  let j = n - 1;
+
+  for (let i = 0; i < n; i++) {
+    area += (points[j][0] + points[i][0]) * (points[j][1] - points[i][1]);
+    j = i; // j is previous vertex to i
+  }
+
+  // Return absolute value of half the sum (half as summing up traingles).
+  return Math.abs(area / 2.0);
+}

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

@@ -0,0 +1,72 @@
+import { vec2 } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
+import areLineSegmentsIntersecting from './areLineSegmentsIntersecting';
+
+/**
+ * Checks whether the line (`p1`,`q1`) intersects any of the other lines in the
+ * `points`, and returns the closest value.
+ * @param points - Polyline points
+ * @param p1 - Start point of the line segment
+ * @param q1 - End point of the line segment
+ * @param closed - Test the intersection against the line that connects the first to the last when closed
+ * @returns The closest line segment from polyline that intersects the line segment [p1, q1]
+ */
+export default function getClosestLineSegmentIntersection(
+  points: Types.Point2[],
+  p1: Types.Point2,
+  q1: Types.Point2,
+  closed = true
+): { segment: Types.Point2; distance: number } | undefined {
+  let initialQ2Index;
+  let p2Index;
+
+  if (closed) {
+    p2Index = points.length - 1;
+    initialQ2Index = 0;
+  } else {
+    p2Index = 0;
+    initialQ2Index = 1;
+  }
+
+  const intersections = [];
+
+  for (let q2Index = initialQ2Index; q2Index < points.length; q2Index++) {
+    const p2 = points[p2Index];
+    const q2 = points[q2Index];
+
+    if (areLineSegmentsIntersecting(p1, q1, p2, q2)) {
+      intersections.push([p2Index, q2Index]);
+    }
+
+    p2Index = q2Index;
+  }
+
+  if (intersections.length === 0) {
+    return;
+  }
+
+  // Find intersection closest to the start point
+  const distances = [];
+
+  intersections.forEach((intersection) => {
+    const intersectionPoints = [
+      points[intersection[0]],
+      points[intersection[1]],
+    ];
+
+    const midpoint = [
+      (intersectionPoints[0][0] + intersectionPoints[1][0]) / 2,
+      (intersectionPoints[0][1] + intersectionPoints[1][1]) / 2,
+    ];
+
+    distances.push(vec2.distance(<vec2>midpoint, p1));
+  });
+
+  const minDistance = Math.min(...distances);
+  const indexOfMinDistance = distances.indexOf(minDistance);
+
+  return {
+    segment: intersections[indexOfMinDistance],
+    distance: minDistance,
+  };
+}

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

@@ -0,0 +1,42 @@
+import type { Types } from '@cornerstonejs/core';
+import areLineSegmentsIntersecting from './areLineSegmentsIntersecting';
+
+/**
+ * Checks whether the line (`p1`,`q1`) intersects any of the other lines in the
+ * `points`, and returns the first value.
+ *
+ * @param points - Polyline points
+ * @param p1 - First point of the line segment that is being tested
+ * @param q1 - Second point of the line segment that is being tested
+ * @param closed - Test the intersection with the line segment that connects
+ *   the last and first points of the polyline
+ * @returns Indexes of the line segment points from the polyline that intersects [p1, q1]
+ */
+export default function getFirstLineSegmentIntersectionIndexes(
+  points: Types.Point2[],
+  p1: Types.Point2,
+  q1: Types.Point2,
+  closed = true
+): Types.Point2 | undefined {
+  let initialI;
+  let j;
+
+  if (closed) {
+    j = points.length - 1;
+    initialI = 0;
+  } else {
+    j = 0;
+    initialI = 1;
+  }
+
+  for (let i = initialI; i < points.length; i++) {
+    const p2 = points[j];
+    const q2 = points[i];
+
+    if (areLineSegmentsIntersecting(p1, q1, p2, q2)) {
+      return [j, i];
+    }
+
+    j = i;
+  }
+}

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

@@ -0,0 +1,30 @@
+import type { Types } from '@cornerstonejs/core';
+import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
+import getLinesIntersection from './getLinesIntersection';
+
+/**
+ * Returns all intersections points between a line segment and a polyline
+ */
+export default function getLineSegmentIntersectionsCoordinates(
+  points: Types.Point2[],
+  p1: Types.Point2,
+  q1: Types.Point2,
+  closed = true
+): Types.Point2[] {
+  const result = [];
+  const polylineIndexes = getLineSegmentIntersectionsIndexes(
+    points,
+    p1,
+    q1,
+    closed
+  );
+
+  for (let i = 0; i < polylineIndexes.length; i++) {
+    const p2 = points[polylineIndexes[i][0]];
+    const q2 = points[polylineIndexes[i][1]];
+    const intersection = getLinesIntersection(p1, q1, p2, q2);
+    result.push(intersection);
+  }
+
+  return result;
+}

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

@@ -0,0 +1,35 @@
+import type { Types } from '@cornerstonejs/core';
+import areLineSegmentsIntersecting from './areLineSegmentsIntersecting';
+
+/**
+ * Get all intersections between a polyline and a line segment.
+ * @param polyline - Polyline points
+ * @param p1 - Start point of line segment
+ * @param q1 - End point of line segment
+ * @param closed - Test the intersection against the line segment that connects
+ * the last to the first point when set to true
+ * @returns Start/end point indexes of all line segments that intersect (p1, q1)
+ */
+export default function getLineSegmentIntersectionsIndexes(
+  polyline: Types.Point2[],
+  p1: Types.Point2,
+  q1: Types.Point2,
+  closed = true
+): Types.Point2[] {
+  const intersections: Types.Point2[] = [];
+  const numPoints = polyline.length;
+  const maxI = numPoints - (closed ? 1 : 2);
+
+  for (let i = 0; i <= maxI; i++) {
+    const p2 = polyline[i];
+    // Do not use % operator for better performance
+    const j = i === numPoints - 1 ? 0 : i + 1;
+    const q2 = polyline[j];
+
+    if (areLineSegmentsIntersecting(p1, q1, p2, q2)) {
+      intersections.push([i, j]);
+    }
+  }
+
+  return intersections;
+}

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

@@ -0,0 +1,94 @@
+import { Types } from '@cornerstonejs/core';
+import * as mathLine from '../line';
+
+// ATTENTION: this is an internal function and it should not be added to "polyline" namespace
+
+// Tested with +1M random overlapping line segments and any tolerance below this
+// one may return invalid results.
+const PARALLEL_LINES_TOLERANCE = 1e-2;
+
+/**
+ * It returns the intersection between two lines (not line segments) or a midpoint
+ * when the line segments overlap. This function calculates the intersection between
+ * lines because it considers that getFirstLineSegmentIntersectionIndexes,
+ * getLineSegmentIntersectionsCoordinates or getLineSegmentIntersectionsIndexes
+ * has already been called first which guarantees.
+ *
+ * @param p1 - Line segment 1 start
+ * @param q1 - Line segment 1 end
+ * @param p2 - Line segment 2 start
+ * @param q2 - Line segment 21 end
+ * @returns The intersection between two lines or a midpoint when they overlap
+ */
+export default function getLinesIntersection(
+  p1: Types.Point2,
+  q1: Types.Point2,
+  p2: Types.Point2,
+  q2: Types.Point2
+) {
+  const diffQ1P1 = [q1[0] - p1[0], q1[1] - p1[1]];
+  const diffQ2P2 = [q2[0] - p2[0], q2[1] - p2[1]];
+  const denominator = diffQ2P2[1] * diffQ1P1[0] - diffQ2P2[0] * diffQ1P1[1];
+  const absDenominator = denominator >= 0 ? denominator : -denominator;
+
+  if (absDenominator < PARALLEL_LINES_TOLERANCE) {
+    // No Math.min/max calls for better performance.
+    const line1AABB = [
+      p1[0] < q1[0] ? p1[0] : q1[0], // 0: minX
+      p1[0] > q1[0] ? p1[0] : q1[0], // 1: maxX
+      p1[1] < q1[1] ? p1[1] : q1[1], // 2: minY
+      p1[1] > q1[1] ? p1[1] : q1[1], // 3: maxY
+    ];
+
+    // No Math.min/max calls for better performance.
+    const line2AABB = [
+      p2[0] < q2[0] ? p2[0] : q2[0], // 0: minX
+      p2[0] > q2[0] ? p2[0] : q2[0], // 1: maxX
+      p2[1] < q2[1] ? p2[1] : q2[1], // 2: minY
+      p2[1] > q2[1] ? p2[1] : q2[1], // 3: maxY
+    ];
+
+    const aabbIntersects =
+      line1AABB[0] <= line2AABB[1] && // minX1 <= maxX2
+      line1AABB[1] >= line2AABB[0] && // maxX1 >= minX2
+      line1AABB[2] <= line2AABB[3] && // minY1 <= maxY2
+      line1AABB[3] >= line2AABB[2]; // maxY1 >= minY2
+
+    if (!aabbIntersects) {
+      return;
+    }
+
+    // Three tests are enough to know if the lines overlap
+    const overlap =
+      mathLine.isPointOnLineSegment(p1, q1, p2) ||
+      mathLine.isPointOnLineSegment(p1, q1, q2) ||
+      mathLine.isPointOnLineSegment(p2, q2, p1);
+
+    if (!overlap) {
+      return;
+    }
+
+    // min/max seems to be inverted but that is correct because it is looking
+    // for the intersection range. No Math.min/max calls for better performance.
+    const minX = line1AABB[0] > line2AABB[0] ? line1AABB[0] : line2AABB[0];
+    const maxX = line1AABB[1] < line2AABB[1] ? line1AABB[1] : line2AABB[1];
+    const minY = line1AABB[2] > line2AABB[2] ? line1AABB[2] : line2AABB[2];
+    const maxY = line1AABB[3] < line2AABB[3] ? line1AABB[3] : line2AABB[3];
+    const midX = (minX + maxX) * 0.5;
+    const midY = (minY + maxY) * 0.5;
+
+    return [midX, midY];
+  }
+
+  let a = p1[1] - p2[1];
+  let b = p1[0] - p2[0];
+  const numerator1 = diffQ2P2[0] * a - diffQ2P2[1] * b;
+  const numerator2 = diffQ1P1[0] * a - diffQ1P1[1] * b;
+  a = numerator1 / denominator;
+  b = numerator2 / denominator;
+
+  const resultX = p1[0] + a * diffQ1P1[0];
+  const resultY = p1[1] + a * diffQ1P1[1];
+
+  return [resultX, resultY];
+}

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

@@ -0,0 +1,17 @@
+import { Types } from '@cornerstonejs/core';
+import getSignedArea from './getSignedArea';
+
+/**
+ * Calculate the normal of a 2D polyline
+ * https://www.youtube.com/watch?v=GpsKrAipXm8&t=1982s
+ *
+ * @param polyline - Planar polyline in 2D space
+ * @returns Normal of the 2D planar polyline
+ */
+export default function getNormal2(polyline: Types.Point2[]): Types.Point3 {
+  const area = getSignedArea(polyline);
+
+  // The normal of a 2D polyline is (0, 0, 1) or (0, 0, -1) depending if it
+  // is CW or CCW polyline
+  return [0, 0, area / Math.abs(area)] as Types.Point3;
+}

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

@@ -0,0 +1,53 @@
+import { vec3 } from 'gl-matrix';
+import { Types } from '@cornerstonejs/core';
+
+function _getAreaVector(polyline: Types.Point3[]): Types.Point3 {
+  const vecArea = vec3.create();
+
+  // Reference point can be any point on the same plane
+  const refPoint = polyline[0];
+
+  // Takes three points, reference point and two other points from each line
+  // segment, and calculate the area with cross product. The magnitude of the
+  // vector returned by a cross product is equal to the area of the parallelogram
+  // that the vectors span which is two times the area of the triangle.
+  //
+  // Not calling vec3 mathods makes the function run much faster since polylines
+  // may have thousands of points when using freehand ROI tool and that would
+  // increase considerably the number of function calls.
+  for (let i = 0, len = polyline.length; i < len; i++) {
+    const p1 = polyline[i];
+    // Using ternary instead of % (mod) operator to make it faster
+    const p2Index = i === len - 1 ? 0 : i + 1;
+    const p2 = polyline[p2Index];
+
+    const aX = p1[0] - refPoint[0];
+    const aY = p1[1] - refPoint[1];
+    const aZ = p1[2] - refPoint[2];
+    const bX = p2[0] - refPoint[0];
+    const bY = p2[1] - refPoint[1];
+    const bZ = p2[2] - refPoint[2];
+
+    // Cross product without calling vec3.cross() for better performance
+    vecArea[0] += aY * bZ - aZ * bY;
+    vecArea[1] += aZ * bX - aX * bZ;
+    vecArea[2] += aX * bY - aY * bX;
+  }
+
+  // Divide by two because cross product returns two times the area for each triangle
+  vec3.scale(vecArea, vecArea, 0.5);
+
+  // The magnitude of the vector is the area of the polyline
+  return <Types.Point3>vecArea;
+}
+
+/**
+ * Calculate the normal of a 3D planar polyline
+ * @param polyline - Planar polyline in 3D space
+ * @returns Normal of the 3D planar polyline
+ */
+export default function getNormal3(polyline: Types.Point3[]): Types.Point3 {
+  const vecArea = _getAreaVector(polyline);
+
+  return vec3.normalize(vecArea, vecArea) as Types.Point3;
+}

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

@@ -0,0 +1,51 @@
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Returns the area with signal of a 2D polyline
+ * https://www.youtube.com/watch?v=GpsKrAipXm8&t=1900s
+ *
+ * This functions has a runtime very close to `getArea` and it is recommended to
+ * be called only if you need the area signal (eg: calculate polygon normal or
+ * winding direction). If you do not need the area signal you should always call
+ * `getArea`.
+ *
+ * @param polyline - Polyline points (2D)
+ * @returns Area of the polyline (with signal)
+ */
+export default function getSignedArea(polyline: Types.Point2[]): number {
+  if (polyline.length < 3) {
+    return 0;
+  }
+
+  // Reference point can be any point on the same plane
+  const refPoint = polyline[0];
+  let area = 0;
+
+  // Takes three points (reference point and two other points from each line
+  // segment) and calculate the area with cross product. The magnitude of the
+  // vector returned by a cross product is equal to the area of the parallelogram
+  // that the vectors span which is two times the area of the triangle.
+  //
+  // Not calling vec3 mathods makes the function run much faster since polylines
+  // may have thousands of points when using freehand ROI tool and that would
+  // increase considerably the number of function calls.
+  for (let i = 0, len = polyline.length; i < len; i++) {
+    const p1 = polyline[i];
+    // Using ternary instead of % (mod) operator to make it faster
+    const p2Index = i === len - 1 ? 0 : i + 1;
+    const p2 = polyline[p2Index];
+    const aX = p1[0] - refPoint[0];
+    const aY = p1[1] - refPoint[1];
+    const bX = p2[0] - refPoint[0];
+    const bY = p2[1] - refPoint[1];
+
+    // Cross product between vectors "a" and "b" which returns (0, 0, crossProd)
+    // for 2D vectors.
+    area += aX * bY - aY * bX;
+  }
+
+  // Divide by two because cross product returns two times the area for each triangle
+  area *= 0.5;
+
+  return area;
+}

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,19 +1,48 @@
-import {
-  getFirstIntersectionWithPolyline,
-  getClosestIntersectionWithPolyline,
-} from './getIntersectionWithPolyline';
+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';
+import intersectPolyline from './intersectPolyline';
+import decimate from './decimate';
+import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
+import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
+import getLineSegmentIntersectionsCoordinates from './getLineSegmentIntersectionsCoordinates';
+import getClosestLineSegmentIntersection from './getClosestLineSegmentIntersection';
 import getSubPixelSpacingAndXYDirections from './getSubPixelSpacingAndXYDirections';
 import pointsAreWithinCloseContourProximity from './pointsAreWithinCloseContourProximity';
 import addCanvasPointsToArray from './addCanvasPointsToArray';
 import pointCanProjectOnLine from './pointCanProjectOnLine';
-import calculateAreaOfPoints from './calculateAreaOfPoints';
+import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
+import { projectTo2D } from './projectTo2D';
 
 export {
-  getFirstIntersectionWithPolyline,
-  getClosestIntersectionWithPolyline,
+  isClosed,
+  containsPoint,
+  containsPoints,
+  getAABB,
+  getArea,
+  getSignedArea,
+  getWindingDirection,
+  getNormal3,
+  getNormal2,
+  intersectPolyline,
+  decimate,
+  getFirstLineSegmentIntersectionIndexes,
+  getLineSegmentIntersectionsIndexes,
+  getLineSegmentIntersectionsCoordinates,
+  getClosestLineSegmentIntersection,
   getSubPixelSpacingAndXYDirections,
   pointsAreWithinCloseContourProximity,
   addCanvasPointsToArray,
   pointCanProjectOnLine,
-  calculateAreaOfPoints,
+  mergePolylines,
+  subtractPolylines,
+  isPointInsidePolyline3D,
+  projectTo2D,
 };

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

@@ -0,0 +1,34 @@
+import { Types } from '@cornerstonejs/core';
+import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
+
+/**
+ * Check if two polylines intersect comparing line segment by line segment.
+ * @param sourcePolyline - Source polyline
+ * @param targetPolyline - Target polyline
+ * @returns True if the polylines intersect or false otherwise
+ */
+export default function intersectPolyline(
+  sourcePolyline: Types.Point2[],
+  targetPolyline: Types.Point2[]
+): boolean {
+  // Naive way to detect intersection between polylines in O(n^2).
+  // TODO: Implement Bentley Ottmann sweep line algorithm or maybe some
+  // algorithm that uses r-tree may make it run faster
+  for (let i = 0, sourceLen = sourcePolyline.length; i < sourceLen; i++) {
+    const sourceP1 = sourcePolyline[i];
+    const sourceP2Index = i === sourceLen - 1 ? 0 : i + 1;
+    const sourceP2 = sourcePolyline[sourceP2Index];
+
+    const intersectionPointIndexes = getFirstLineSegmentIntersectionIndexes(
+      targetPolyline,
+      sourceP1,
+      sourceP2
+    );
+
+    if (intersectionPointIndexes?.length === 2) {
+      return true;
+    }
+  }
+
+  return false;
+}

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

@@ -0,0 +1,26 @@
+import { glMatrix } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
+import * as math from '..';
+
+/**
+ * A polyline is considered closed if the start and end points are at the same position
+ *
+ * @param polyline - Polyline points (2D)
+ * @returns True if the polyline is already closed or false otherwise
+ */
+export default function isClosed(polyline: Types.Point2[]): boolean {
+  if (polyline.length < 3) {
+    return false;
+  }
+
+  const numPolylinePoints = polyline.length;
+
+  const firstPoint = polyline[0];
+  const lastPoint = polyline[numPolylinePoints - 1];
+  const distFirstToLastPoints = math.point.distanceToPointSquared(
+    firstPoint,
+    lastPoint
+  );
+
+  return glMatrix.equals(0, distFirstToLastPoints);
+}

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

@@ -0,0 +1,50 @@
+import type { Types } from '@cornerstonejs/core';
+import containsPoint from './containsPoint';
+import { projectTo2D } from './projectTo2D';
+
+/**
+ * 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.
+ * @param options.holesPolyline - An array of polylines representing each hole, so it
+ * is an array of arrays 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[],
+  options: { holes?: Types.Point3[][] } = {}
+) {
+  const { sharedDimensionIndex, projectedPolyline } = projectTo2D(polyline);
+
+  const { holes } = options;
+  const projectedHoles = [] as Types.Point2[][];
+
+  if (holes) {
+    for (let i = 0; i < holes.length; i++) {
+      const hole = holes[i];
+      const hole2D = [] as Types.Point2[];
+
+      for (let j = 0; j < hole.length; j++) {
+        hole2D.push([
+          hole[j][(sharedDimensionIndex + 1) % 3],
+          hole[j][(sharedDimensionIndex + 2) % 3],
+        ]);
+      }
+
+      projectedHoles.push(hole2D);
+    }
+  }
+
+  const point2D = [
+    point[(sharedDimensionIndex + 1) % 3],
+    point[(sharedDimensionIndex + 2) % 3],
+  ] as Types.Point2;
+
+  return containsPoint(projectedPolyline, point2D, { holes: projectedHoles });
+}