@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

package/src/utilities/math/line/isPointOnLineSegment.ts

@@ -1,44 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-const ORIENTATION_TOLERANCE = 1e-2;
-
-/**
- * Test if a point is on a line segment
- * @param lineStart - Line segment start point
- * @param lineEnd - Line segment end point
- * @param point - Point to test
- * @returns True if the point lies on the line segment or false otherwise
- */
-export default function isPointOnLineSegment(
-  lineStart: Types.Point2,
-  lineEnd: Types.Point2,
-  point: Types.Point2
-): boolean {
-  // The code below runs ~4x faster than calling `line.distanceToPointSquared()` (155 vs 598 ms)
-
-  // No Math.min/max call for better performance when testing thousands of points
-  const minX = lineStart[0] <= lineEnd[0] ? lineStart[0] : lineEnd[0];
-  const maxX = lineStart[0] >= lineEnd[0] ? lineStart[0] : lineEnd[0];
-  const minY = lineStart[1] <= lineEnd[1] ? lineStart[1] : lineEnd[1];
-  const maxY = lineStart[1] >= lineEnd[1] ? lineStart[1] : lineEnd[1];
-
-  // Checks if the point lies inside the AABB
-  const aabbContainsPoint =
-    point[0] >= minX - ORIENTATION_TOLERANCE &&
-    point[0] <= maxX + ORIENTATION_TOLERANCE &&
-    point[1] >= minY - ORIENTATION_TOLERANCE &&
-    point[1] <= maxY + ORIENTATION_TOLERANCE;
-
-  if (!aabbContainsPoint) {
-    return false;
-  }
-
-  // Now that we know the point is inside the AABB we check if it lies on the line segment
-  const orientation =
-    (lineEnd[1] - lineStart[1]) * (point[0] - lineEnd[0]) -
-    (lineEnd[0] - lineStart[0]) * (point[1] - lineEnd[1]);
-  const absOrientation = orientation >= 0 ? orientation : -orientation;
-
-  // The orientation must be zero for points that lies on the same line
-  return absOrientation <= ORIENTATION_TOLERANCE;
-}

package/src/utilities/math/midPoint.ts

@@ -1,26 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-
-/**
- * Return the midpoint (think average) of all the provided points.
- */
-const midPoint = (
-  ...args: (Types.Point2 | Types.Point3)[]
-): Types.Point2 | Types.Point3 => {
-  const ret =
-    args[0].length === 2 ? <Types.Point2>[0, 0] : <Types.Point3>[0, 0, 0];
-  const len = args.length;
-  for (const arg of args) {
-    ret[0] += arg[0] / len;
-    ret[1] += arg[1] / len;
-    if (ret.length === 3) {
-      ret[2] += arg[2] / len;
-    }
-  }
-  return ret;
-};
-
-const midPoint2 = midPoint as (...args: Types.Point2[]) => Types.Point2;
-
-export default midPoint;
-
-export { midPoint2 };

package/src/utilities/math/point/distanceToPoint.ts

@@ -1,15 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import distanceToPointSquared from './distanceToPointSquared';
-
-type Point = Types.Point2 | Types.Point3;
-
-/**
- * Calculates the distance of a point to another point
- *
- * @param p1 - x,y or x,y,z of the point
- * @param p2 - x,y or x,y,z of the point
- * @returns distance
- */
-export default function distanceToPoint(p1: Point, p2: Point): number {
-  return Math.sqrt(distanceToPointSquared(p1, p2));
-}

package/src/utilities/math/point/distanceToPointSquared.ts

@@ -1,26 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-type Point = Types.Point2 | Types.Point3;
-
-/**
- * Calculates the distance squared of a point to another point
- *
- * @param p1 - x,y or x,y,z of the point
- * @param p2 - x,y or x,y,z of the point
- * @returns distance
- */
-export default function distanceToPointSquared(p1: Point, p2: Point): number {
-  if (p1.length !== p2.length) {
-    throw Error('Both points should have the same dimensionality');
-  }
-
-  const [x1, y1, z1 = 0] = p1;
-  const [x2, y2, z2 = 0] = p2;
-  const dx = x2 - x1;
-  const dy = y2 - y1;
-  const dz = z2 - z1;
-
-  // Time to square 10M numbers:
-  //   (n * n) = 161ms | (n ** 2) = 199ms | Math.pow(n, 2) = 29529ms
-  return dx * dx + dy * dy + dz * dz;
-}

package/src/utilities/math/point/mirror.ts

@@ -1,21 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-
-/**
- * Get a mirrored point along the line created by two points where one of them
- * is the static ("anchor") point and the other one is the point to be mirroed.
- * @param mirrorPoint - 2D Point to be mirroed
- * @param staticPoint - Static 2D point
- * @returns Mirroed 2D point
- */
-export default function mirror(
-  mirrorPoint: Types.Point2,
-  staticPoint: Types.Point2
-): Types.Point2 {
-  const [x1, y1] = mirrorPoint;
-  const [x2, y2] = staticPoint;
-
-  const newX = 2 * x2 - x1;
-  const newY = 2 * y2 - y1;
-
-  return [newX, newY];
-}

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

@@ -1,67 +0,0 @@
-import { getEnabledElement } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
-import { vec2, vec3 } from 'gl-matrix';
-import { PlanarFreehandROICommonData } from './planarFreehandROIInternalTypes';
-
-/**
- * Adds one or more points to the array at a resolution defined by the underlying image.
- */
-const addCanvasPointsToArray = (
-  element: HTMLDivElement,
-  canvasPoints: Types.Point2[],
-  newCanvasPoint: Types.Point2,
-  commonData: PlanarFreehandROICommonData
-): number => {
-  const { xDir, yDir, spacing } = commonData;
-  const enabledElement = getEnabledElement(element);
-  const { viewport } = enabledElement;
-
-  if (!canvasPoints.length) {
-    canvasPoints.push(newCanvasPoint);
-    console.log('>>>>> !canvasPoints. :: RETURN');
-    return 1;
-  }
-
-  const lastWorldPos = viewport.canvasToWorld(
-    canvasPoints[canvasPoints.length - 1]
-  );
-  const newWorldPos = viewport.canvasToWorld(newCanvasPoint);
-  const worldPosDiff = vec3.create();
-
-  vec3.subtract(worldPosDiff, newWorldPos, lastWorldPos);
-
-  const xDist = Math.abs(vec3.dot(worldPosDiff, xDir));
-  const yDist = Math.abs(vec3.dot(worldPosDiff, yDir));
-
-  const numPointsToAdd = Math.max(
-    Math.floor(xDist / spacing[0]),
-    Math.floor(yDist / spacing[0])
-  );
-
-  if (numPointsToAdd > 1) {
-    const lastCanvasPoint = canvasPoints[canvasPoints.length - 1];
-
-    const canvasDist = vec2.dist(lastCanvasPoint, newCanvasPoint);
-
-    const canvasDir = vec2.create();
-
-    vec2.subtract(canvasDir, newCanvasPoint, lastCanvasPoint);
-
-    vec2.set(canvasDir, canvasDir[0] / canvasDist, canvasDir[1] / canvasDist);
-
-    const distPerPoint = canvasDist / numPointsToAdd;
-
-    for (let i = 1; i <= numPointsToAdd; i++) {
-      canvasPoints.push([
-        lastCanvasPoint[0] + distPerPoint * canvasDir[0] * i,
-        lastCanvasPoint[1] + distPerPoint * canvasDir[1] * i,
-      ]);
-    }
-  } else {
-    canvasPoints.push(newCanvasPoint);
-  }
-
-  return numPointsToAdd;
-};
-
-export default addCanvasPointsToArray;

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

@@ -1,118 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-// ATTENTION: this is an internal function and it should not be added to "polyline"
-// namespace.
-//
-// TODO: there is a similar function in math.lineSegment.intersectLine but we
-// need to investigate why it is 6x slower than this one when thousands of
-// intersections are calculated. Also that one may return [NaN, NaN] for
-// collinear points.
-
-/**
- * Checks whether the line (`p1`,`q1`) intersects the line (`p2`,`q2`) via an
- * orientation algorithm.
- *
- * Credit and details: geeksforgeeks.org/check-if-two-given-line-segments-intersect/
- *
- * @param p1 - Start point of line segment 1
- * @param q1 - End point of line segment 1
- * @param p2 - Start point of line segment 2
- * @param q2 - End point of line segment 2
- * @returns True if the line segments intersect or false otherwise
- */
-export default function areLineSegmentsIntersecting(
-  p1: Types.Point2,
-  q1: Types.Point2,
-  p2: Types.Point2,
-  q2: Types.Point2
-): boolean {
-  let result = false;
-
-  // Line 1 AABB
-  const line1MinX = p1[0] < q1[0] ? p1[0] : q1[0];
-  const line1MinY = p1[1] < q1[1] ? p1[1] : q1[1];
-  const line1MaxX = p1[0] > q1[0] ? p1[0] : q1[0];
-  const line1MaxY = p1[1] > q1[1] ? p1[1] : q1[1];
-
-  // Line 2 AABB
-  const line2MinX = p2[0] < q2[0] ? p2[0] : q2[0];
-  const line2MinY = p2[1] < q2[1] ? p2[1] : q2[1];
-  const line2MaxX = p2[0] > q2[0] ? p2[0] : q2[0];
-  const line2MaxY = p2[1] > q2[1] ? p2[1] : q2[1];
-
-  // If AABBs do not intersect it is impossible for the lines to intersect.
-  // Checking AABB before doing any math makes it run ~12% faster.
-  if (
-    line1MinX > line2MaxX ||
-    line1MaxX < line2MinX ||
-    line1MinY > line2MaxY ||
-    line1MaxY < line2MinY
-  ) {
-    return false;
-  }
-
-  const orient = [
-    orientation(p1, q1, p2),
-    orientation(p1, q1, q2),
-    orientation(p2, q2, p1),
-    orientation(p2, q2, q1),
-  ];
-
-  // General Case
-  if (orient[0] !== orient[1] && orient[2] !== orient[3]) {
-    return true;
-  }
-
-  // Special Cases
-  if (orient[0] === 0 && onSegment(p1, p2, q1)) {
-    // If p1, q1 and p2 are colinear and p2 lies on segment p1q1
-    result = true;
-  } else if (orient[1] === 0 && onSegment(p1, q2, q1)) {
-    // If p1, q1 and p2 are colinear and q2 lies on segment p1q1
-    result = true;
-  } else if (orient[2] === 0 && onSegment(p2, p1, q2)) {
-    // If p2, q2 and p1 are colinear and p1 lies on segment p2q2
-    result = true;
-  } else if (orient[3] === 0 && onSegment(p2, q1, q2)) {
-    // If p2, q2 and q1 are colinear and q1 lies on segment p2q2
-    result = true;
-  }
-
-  return result;
-}
-
-/**
- * Checks the orientation of 3 points, returns a 0, 1 or 2 based on
- * the orientation of the points.
- */
-function orientation(
-  p: Types.Point2,
-  q: Types.Point2,
-  r: Types.Point2
-): number {
-  // Take the cross product between vectors PQ and QR
-  const orientationValue =
-    (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]);
-
-  if (orientationValue === 0) {
-    return 0; // Colinear
-  }
-
-  return orientationValue > 0 ? 1 : 2;
-}
-
-/**
- * Checks if point `q` lies on the segment (`p`,`r`).
- */
-function onSegment(p: Types.Point2, q: Types.Point2, r: Types.Point2): boolean {
-  if (
-    q[0] <= Math.max(p[0], r[0]) &&
-    q[0] >= Math.min(p[0], r[0]) &&
-    q[1] <= Math.max(p[1], r[1]) &&
-    q[1] >= Math.min(p[1], r[1])
-  ) {
-    return true;
-  }
-
-  return false;
-}

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

@@ -1,348 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-import * as mathPoint from '../point';
-import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
-import containsPoint from './containsPoint';
-import getNormal2 from './getNormal2';
-import { glMatrix, vec3 } from 'gl-matrix';
-import getLinesIntersection from './getLinesIntersection';
-
-enum PolylinePointType {
-  Vertex,
-  Intersection,
-}
-
-// Position of the point related to the intersection region
-enum PolylinePointPosition {
-  Outside = -1,
-  Edge = 0,
-  Inside = 1,
-}
-
-// Direction from last point to the intersection point to know if it is entering
-// or exiting the intersection region
-enum PolylinePointDirection {
-  Exiting = -1,
-  Unknown = 0,
-  Entering = 1,
-}
-
-type PolylinePoint = {
-  type: PolylinePointType;
-  coordinates: Types.Point2;
-  position?: PolylinePointPosition;
-  visited: boolean;
-  next: PolylinePoint;
-};
-
-type PolylineIntersectionPoint = PolylinePoint & {
-  direction: PolylinePointDirection;
-  cloned?: boolean;
-};
-
-/**
- * Ensure all polyline point objects are pointing to the next object in case
- * it is still not point to anyone.
- * @param polylinePoints - Array that contains all polyline points (vertices and intersections)
- */
-function ensuresNextPointers(polylinePoints: PolylinePoint[]) {
-  // Make sure all nodes point to a valid node
-  for (let i = 0, len = polylinePoints.length; i < len; i++) {
-    const currentPoint = polylinePoints[i];
-
-    if (!currentPoint.next) {
-      currentPoint.next = polylinePoints[i === len - 1 ? 0 : i + 1];
-    }
-  }
-}
-
-/**
- * Creates one linked list per polyline that contains all vertices and intersections
- * found while walking along the edges.
- *
- * @param targetPolyline - Target polyline
- * @param sourcePolyline - Source polyline
- * @returns Two linked lists with all vertices and intersections.
- */
-function getSourceAndTargetPointsList(
-  targetPolyline: Types.Point2[],
-  sourcePolyline: Types.Point2[]
-) {
-  const targetPolylinePoints: PolylinePoint[] = [];
-  const sourcePolylinePoints: PolylinePoint[] = [];
-  const sourceIntersectionsCache = new Map<
-    number,
-    PolylineIntersectionPoint[]
-  >();
-
-  const isFirstPointInside = containsPoint(sourcePolyline, targetPolyline[0]);
-
-  let intersectionPointDirection = isFirstPointInside
-    ? PolylinePointDirection.Exiting
-    : PolylinePointDirection.Entering;
-
-  // Store all vertices and intersection for target contour
-  for (let i = 0, len = targetPolyline.length; i < len; i++) {
-    const p1 = targetPolyline[i];
-    const pointInside = containsPoint(sourcePolyline, p1);
-    const vertexPoint: PolylinePoint = {
-      type: PolylinePointType.Vertex,
-      coordinates: p1,
-      position: pointInside
-        ? PolylinePointPosition.Inside
-        : PolylinePointPosition.Outside,
-      visited: false,
-      next: null,
-    };
-
-    targetPolylinePoints.push(vertexPoint);
-
-    const q1 = targetPolyline[i === len - 1 ? 0 : i + 1];
-    const intersectionsInfo = getLineSegmentIntersectionsIndexes(
-      sourcePolyline,
-      p1,
-      q1
-    ).map((intersectedLineSegment) => {
-      const sourceLineSegmentId: number = intersectedLineSegment[0];
-      const p2 = sourcePolyline[intersectedLineSegment[0]];
-      const q2 = sourcePolyline[intersectedLineSegment[1]];
-
-      // lineSegment.intersectLine returns the midpoint of the four points
-      // when the lines are parallel or co-incident.  Otherwise it will return
-      // an extension of the line.
-      const intersectionCoordinate = getLinesIntersection(
-        p1,
-        q1,
-        p2,
-        q2
-      ) as Types.Point2;
-
-      const targetStartPointDistSquared = mathPoint.distanceToPointSquared(
-        p1,
-        intersectionCoordinate
-      );
-
-      return {
-        sourceLineSegmentId,
-        coordinate: intersectionCoordinate,
-        targetStartPointDistSquared,
-      };
-    });
-
-    intersectionsInfo.sort(
-      (left, right) =>
-        left.targetStartPointDistSquared - right.targetStartPointDistSquared
-    );
-
-    intersectionsInfo.forEach((intersectionInfo) => {
-      const { sourceLineSegmentId, coordinate: intersectionCoordinate } =
-        intersectionInfo;
-
-      // Intersection point to be added to the target polyline list
-      const targetEdgePoint: PolylineIntersectionPoint = {
-        type: PolylinePointType.Intersection,
-        coordinates: intersectionCoordinate,
-        position: PolylinePointPosition.Edge,
-        direction: intersectionPointDirection,
-        visited: false,
-        next: null,
-      };
-
-      // Intersection point to be added to the source polyline list.
-      // At this point there is no way to know if the point is entering or
-      // exiting the intersection region but that is not going to be used
-      // hence it is set to "unknown".
-      const sourceEdgePoint: PolylineIntersectionPoint = {
-        ...targetEdgePoint,
-        direction: PolylinePointDirection.Unknown,
-        cloned: true,
-      };
-
-      if (intersectionPointDirection === PolylinePointDirection.Entering) {
-        targetEdgePoint.next = sourceEdgePoint;
-      } else {
-        sourceEdgePoint.next = targetEdgePoint;
-      }
-
-      let sourceIntersectionPoints =
-        sourceIntersectionsCache.get(sourceLineSegmentId);
-
-      if (!sourceIntersectionPoints) {
-        sourceIntersectionPoints = [];
-        sourceIntersectionsCache.set(
-          sourceLineSegmentId,
-          sourceIntersectionPoints
-        );
-      }
-
-      targetPolylinePoints.push(targetEdgePoint);
-      sourceIntersectionPoints.push(sourceEdgePoint);
-
-      // Switches from "exiting" to "entering" and vice-versa
-      intersectionPointDirection *= -1;
-    });
-  }
-
-  // Store all vertices and intersections for source contour
-  for (let i = 0, len = sourcePolyline.length; i < len; i++) {
-    const lineSegmentId: number = i;
-    const p1 = sourcePolyline[i];
-    const vertexPoint: PolylinePoint = {
-      type: PolylinePointType.Vertex,
-      coordinates: p1,
-      visited: false,
-      next: null,
-    };
-
-    sourcePolylinePoints.push(vertexPoint);
-
-    const sourceIntersectionPoints =
-      sourceIntersectionsCache.get(lineSegmentId);
-
-    if (!sourceIntersectionPoints?.length) {
-      continue;
-    }
-
-    // Calculate the distance between each intersection point to the start point
-    // of the line segment, sort them by distance and return a sorted array that
-    // contains all intersection points.
-    sourceIntersectionPoints
-      .map((intersectionPoint) => ({
-        intersectionPoint,
-        lineSegStartDistSquared: mathPoint.distanceToPointSquared(
-          p1,
-          intersectionPoint.coordinates
-        ),
-      }))
-      .sort(
-        (left, right) =>
-          left.lineSegStartDistSquared - right.lineSegStartDistSquared
-      )
-      .map(({ intersectionPoint }) => intersectionPoint)
-      .forEach((intersectionPoint) =>
-        sourcePolylinePoints.push(intersectionPoint)
-      );
-  }
-
-  ensuresNextPointers(targetPolylinePoints);
-  ensuresNextPointers(sourcePolylinePoints);
-
-  return { targetPolylinePoints, sourcePolylinePoints };
-}
-
-/**
- * Get the next unvisited polyline points that is outside the intersection region.
- * @param polylinePoints - All polyline points (vertices and intersections)
- * @returns Any unvisited point that is outside the intersection region if it
- * exists or `undefined` otherwise
- */
-function getUnvisitedOutsidePoint(polylinePoints: PolylinePoint[]) {
-  for (let i = 0, len = polylinePoints.length; i < len; i++) {
-    const point = polylinePoints[i];
-
-    if (!point.visited && point.position === PolylinePointPosition.Outside) {
-      return point;
-    }
-  }
-}
-
-/**
- * Merge two planar polylines (2D)
- */
-function mergePolylines(
-  targetPolyline: Types.Point2[],
-  sourcePolyline: Types.Point2[]
-) {
-  const targetNormal = getNormal2(targetPolyline);
-  const sourceNormal = getNormal2(sourcePolyline);
-  const dotNormals = vec3.dot(sourceNormal, targetNormal);
-
-  // Both polylines need to be CW or CCW to be merged and one of them needs to
-  // be reversed if theirs orientation are not the same
-  if (!glMatrix.equals(1, dotNormals)) {
-    sourcePolyline = sourcePolyline.slice().reverse();
-  }
-
-  const { targetPolylinePoints } = getSourceAndTargetPointsList(
-    targetPolyline,
-    sourcePolyline
-  );
-  const startPoint: PolylinePoint =
-    getUnvisitedOutsidePoint(targetPolylinePoints);
-
-  // Source polyline contains target polyline
-  if (!startPoint) {
-    return targetPolyline.slice();
-  }
-
-  const mergedPolyline = [startPoint.coordinates];
-  let currentPoint = startPoint.next;
-
-  while (currentPoint !== startPoint) {
-    if (
-      currentPoint.type === PolylinePointType.Intersection &&
-      (<PolylineIntersectionPoint>currentPoint).cloned
-    ) {
-      currentPoint = currentPoint.next;
-      continue;
-    }
-
-    mergedPolyline.push(currentPoint.coordinates);
-    currentPoint = currentPoint.next;
-  }
-
-  return mergedPolyline;
-}
-
-/**
- * Subtract two planar polylines (2D)
- */
-function subtractPolylines(
-  targetPolyline: Types.Point2[],
-  sourcePolyline: Types.Point2[]
-): Types.Point2[][] {
-  const targetNormal = getNormal2(targetPolyline);
-  const sourceNormal = getNormal2(sourcePolyline);
-  const dotNormals = vec3.dot(sourceNormal, targetNormal);
-
-  // The polylines need to have different orientation (CW+CCW or CCW+CW) to be
-  // subtracted and one of them needs to be reversed if theirs orientation are
-  // the same
-  if (!glMatrix.equals(-1, dotNormals)) {
-    sourcePolyline = sourcePolyline.slice().reverse();
-  }
-
-  const { targetPolylinePoints } = getSourceAndTargetPointsList(
-    targetPolyline,
-    sourcePolyline
-  );
-  let startPoint: PolylinePoint = null;
-  const subtractedPolylines = [];
-
-  while ((startPoint = getUnvisitedOutsidePoint(targetPolylinePoints))) {
-    const subtractedPolyline = [startPoint.coordinates];
-    let currentPoint = startPoint.next;
-
-    startPoint.visited = true;
-
-    while (currentPoint !== startPoint) {
-      currentPoint.visited = true;
-
-      if (
-        currentPoint.type === PolylinePointType.Intersection &&
-        (<PolylineIntersectionPoint>currentPoint).cloned
-      ) {
-        currentPoint = currentPoint.next;
-        continue;
-      }
-
-      subtractedPolyline.push(currentPoint.coordinates);
-      currentPoint = currentPoint.next;
-    }
-
-    subtractedPolylines.push(subtractedPolyline);
-  }
-
-  return subtractedPolylines;
-}
-
-export { mergePolylines, subtractPolylines };