@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

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

@@ -1,80 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import isClosed from './isClosed';
-
-/**
- * Checks if a 2D point is inside the polyline.
- *
- * A point is inside a curve/polygon if the number of intersections between the horizontal
- * 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
- */
-export default function containsPoint(
-  polyline: Types.Point2[],
-  point: Types.Point2,
-  options: {
-    closed?: boolean;
-    holes?: Types.Point2[][];
-  } = {
-    closed: undefined,
-  }
-): boolean {
-  if (polyline.length < 3) {
-    return false;
-  }
-
-  const numPolylinePoints = polyline.length;
-  let numIntersections = 0;
-
-  const { closed, holes } = options;
-
-  if (holes?.length) {
-    for (const hole of holes) {
-      if (containsPoint(hole, point)) {
-        return false;
-      }
-    }
-  }
-
-  // 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);
-
-  for (let i = 0; i <= maxSegmentIndex; i++) {
-    const p1 = polyline[i];
-
-    // Calculating the next point index without using % (mod) operator like in
-    // `(i + 1) % numPolylinePoints` to make it 20% faster
-    const p2Index = i === numPolylinePoints - 1 ? 0 : i + 1;
-    const p2 = polyline[p2Index];
-
-    // Calculating min/max without using Math.min/max to make it ~3% faster
-    const maxX = p1[0] >= p2[0] ? p1[0] : p2[0];
-    const maxY = p1[1] >= p2[1] ? p1[1] : p2[1];
-    const minY = p1[1] <= p2[1] ? p1[1] : p2[1];
-
-    const mayIntersectLineSegment =
-      point[0] <= maxX && point[1] >= minY && point[1] < maxY;
-
-    if (mayIntersectLineSegment) {
-      const isVerticalLine = p1[0] === p2[0];
-      let intersects = isVerticalLine;
-
-      if (!intersects) {
-        const xIntersection =
-          ((point[1] - p1[1]) * (p2[0] - p1[0])) / (p2[1] - p1[1]) + p1[0];
-
-        intersects = point[0] <= xIntersection;
-      }
-
-      numIntersections += intersects ? 1 : 0;
-    }
-  }
-
-  return !!(numIntersections % 2);
-}

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

@@ -1,22 +0,0 @@
-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/decimate.ts

@@ -1,105 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import * as mathLine from '../line';
-
-const DEFAULT_EPSILON = 0.1;
-
-/**
- * Ramer–Douglas–Peucker algorithm implementation to decimate a polyline
- * to a similar polyline with fewer points
- *
- * https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm
- * https://rosettacode.org/wiki/Ramer-Douglas-Peucker_line_simplification
- * https://karthaus.nl/rdp/
- *
- * @param polyline - Polyline to decimate
- * @param epsilon - A maximum given distance 'epsilon' to decide if a point
- * should or shouldn't be added the decimated polyline version. In each
- * iteration the polyline is split into two polylines and the distance of each
- * point from those new polylines are checked against the line that connects
- * the first and last points.
- * @returns Decimated polyline
- */
-export default function decimate(
-  polyline: Types.Point2[],
-  epsilon = DEFAULT_EPSILON
-) {
-  const numPoints = polyline.length;
-
-  // The polyline must have at least a start and end points
-  if (numPoints < 3) {
-    return polyline;
-  }
-
-  const epsilonSquared = epsilon * epsilon;
-  const partitionQueue = [[0, numPoints - 1]];
-
-  // Used a boolean array to set each point that will be in the decimated polyline
-  // because pre-allocated arrays are 3-4x faster than thousands of push() calls
-  // to add all points to a new array.
-  const polylinePointFlags = new Array(numPoints).fill(false);
-
-  // Start and end points are always added to the decimated polyline
-  let numDecimatedPoints = 2;
-
-  // Add start and end points to the decimated polyline
-  polylinePointFlags[0] = true;
-  polylinePointFlags[numPoints - 1] = true;
-
-  // Iterative approach using a queue instead of recursion to reduce the number
-  // of function calls (performance)
-  while (partitionQueue.length) {
-    const [startIndex, endIndex] = partitionQueue.pop();
-
-    // Return if there is no point between the start and end points
-    if (endIndex - startIndex === 1) {
-      continue;
-    }
-
-    const startPoint = polyline[startIndex];
-    const endPoint = polyline[endIndex];
-    let maxDistSquared = -Infinity;
-    let maxDistIndex = -1;
-
-    // Search for the furthest point
-    for (let i = startIndex + 1; i < endIndex; i++) {
-      const currentPoint = polyline[i];
-      const distSquared = mathLine.distanceToPointSquared(
-        startPoint,
-        endPoint,
-        currentPoint
-      );
-
-      if (distSquared > maxDistSquared) {
-        maxDistSquared = distSquared;
-        maxDistIndex = i;
-      }
-    }
-
-    // Do not add any of the points because the fursthest one is very close to
-    // the line based on the epsilon value
-    if (maxDistSquared < epsilonSquared) {
-      continue;
-    }
-
-    // Update the flag for the furthest point because it will be added to the
-    // decimated polyline
-    polylinePointFlags[maxDistIndex] = true;
-    numDecimatedPoints++;
-
-    // Partition the points into two parts using maxDistIndex as the pivot point
-    // and process both sides
-    partitionQueue.push([maxDistIndex, endIndex]);
-    partitionQueue.push([startIndex, maxDistIndex]);
-  }
-
-  // A pre-allocated array is 3-4x faster then multiple push() calls
-  const decimatedPolyline: Types.Point2[] = new Array(numDecimatedPoints);
-
-  for (let srcIndex = 0, dstIndex = 0; srcIndex < numPoints; srcIndex++) {
-    if (polylinePointFlags[srcIndex]) {
-      decimatedPolyline[dstIndex++] = polyline[srcIndex];
-    }
-  }
-
-  return decimatedPolyline;
-}

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

@@ -1,74 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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;
-}