@cornerstonejs/tools 0.56.1 → 0.56.3

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

@@ -0,0 +1,44 @@
+import { Types } from '@cornerstonejs/core';
+
+function dist2(p1: Types.Point2, p2: Types.Point2): number {
+  return (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]);
+}
+
+/**
+ * Calculates the distance-squared of a point to a line
+ *
+ * @param lineStart - x,y coordinates of the start of the line
+ * @param lineEnd - x,y coordinates of the end of the line
+ * @param point - x,y of the point
+ * @returns distance-squared
+ */
+export default function distanceToPointSquared(
+  lineStart: Types.Point2,
+  lineEnd: Types.Point2,
+  point: Types.Point2
+): number {
+  const d2 = dist2(lineStart, lineEnd);
+
+  if (d2 === 0) {
+    return dist2(point, lineStart);
+  }
+
+  const t =
+    ((point[0] - lineStart[0]) * (lineEnd[0] - lineStart[0]) +
+      (point[1] - lineStart[1]) * (lineEnd[1] - lineStart[1])) /
+    d2;
+
+  if (t < 0) {
+    return dist2(point, lineStart);
+  }
+  if (t > 1) {
+    return dist2(point, lineEnd);
+  }
+
+  const pt: Types.Point2 = [
+    lineStart[0] + t * (lineEnd[0] - lineStart[0]),
+    lineStart[1] + t * (lineEnd[1] - lineStart[1]),
+  ];
+
+  return dist2(point, pt);
+}

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

@@ -0,0 +1,5 @@
+import distanceToPoint from './distanceToPoint';
+import distanceToPointSquared from './distanceToPointSquared';
+import intersectLine from './intersectLine';
+
+export { distanceToPoint, distanceToPointSquared, intersectLine };

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

@@ -0,0 +1,92 @@
+import type { Types } from '@cornerstonejs/core';
+
+// Returns sign of number
+function sign(x: any) {
+  return typeof x === 'number'
+    ? x
+      ? x < 0
+        ? -1
+        : 1
+      : x === x
+      ? 0
+      : NaN
+    : NaN;
+}
+
+/**
+ * Calculates the intersection point between two lines in the 2D plane
+ *
+ * @param line1Start - x,y coordinates of the start of the first line
+ * @param line1End - x,y coordinates of the end of the first line
+ * @param line2Start - x,y coordinates of the start of the second line
+ * @param line2End - x,y coordinates of the end of the second line
+ * @returns [x,y] - point x,y of the point
+ */
+
+export default function intersectLine(
+  line1Start: Types.Point2,
+  line1End: Types.Point2,
+  line2Start: Types.Point2,
+  line2End: Types.Point2
+): number[] {
+  const [x1, y1] = line1Start;
+  const [x2, y2] = line1End;
+  const [x3, y3] = line2Start;
+  const [x4, y4] = line2End;
+
+  // Compute a1, b1, c1, where line joining points 1 and 2 is "a1 x  +  b1 y  +  c1  =  0"
+  const a1 = y2 - y1;
+  const b1 = x1 - x2;
+  const c1 = x2 * y1 - x1 * y2;
+
+  // Compute r3 and r4
+  const r3 = a1 * x3 + b1 * y3 + c1;
+  const r4 = a1 * x4 + b1 * y4 + c1;
+
+  /* Check signs of r3 and r4.  If both point 3 and point 4 lie on
+   * same side of line 1, the line segments do not intersect.
+   */
+
+  if (r3 !== 0 && r4 !== 0 && sign(r3) === sign(r4)) {
+    return;
+  }
+
+  // Compute a2, b2, c2
+  const a2 = y4 - y3;
+  const b2 = x3 - x4;
+  const c2 = x4 * y3 - x3 * y4;
+
+  // Compute r1 and r2
+  const r1 = a2 * x1 + b2 * y1 + c2;
+  const r2 = a2 * x2 + b2 * y2 + c2;
+
+  /* Check signs of r1 and r2.  If both point 1 and point 2 lie
+   * on same side of second line segment, the line segments do
+   * not intersect.
+   */
+
+  if (r1 !== 0 && r2 !== 0 && sign(r1) === sign(r2)) {
+    return;
+  }
+
+  /* Line segments intersect: compute intersection point.
+   */
+
+  const denom = a1 * b2 - a2 * b1;
+  let num;
+
+  /* The denom/2 is to get rounding instead of truncating.  It
+   * is added or subtracted to the numerator, depending upon the
+   * sign of the numerator.
+   */
+
+  num = b1 * c2 - b2 * c1;
+  const x = num / denom;
+
+  num = a2 * c1 - a1 * c2;
+  const y = num / denom;
+
+  const intersectionPoint = [x, y];
+
+  return intersectionPoint;
+}

package/src/utilities/math/midPoint.ts

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

@@ -0,0 +1,22 @@
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Calculates the distance of a point to another point
+ *
+ * @param p1 - x,y of the point
+ * @param p2 - x,y of the point
+ * @returns distance
+ */
+export default function distanceToPoint(
+  p1: Types.Point2,
+  p2: Types.Point2
+): number {
+  if (p1?.length !== 2 || p2?.length !== 2) {
+    throw Error('points should have 2 elements of [x, y]');
+  }
+
+  const [x1, y1] = p1;
+  const [x2, y2] = p2;
+
+  return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+}

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

@@ -0,0 +1,3 @@
+import distanceToPoint from './distanceToPoint';
+
+export { distanceToPoint };

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

@@ -0,0 +1,62 @@
+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;
+
+  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/calculateAreaOfPoints.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 calculateAreaOfPoints(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/getIntersectionWithPolyline.ts

@@ -0,0 +1,182 @@
+import { vec2 } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Orientation algoritm to determine if two lines cross.
+ * Credit and details: geeksforgeeks.org/check-if-two-given-line-segments-intersect/
+ */
+
+/**
+ * Checks whether the line (`p1`,`q1`) intersects any of the other lines in the
+ * `points`, and returns the first value.
+ */
+function getFirstIntersectionWithPolyline(
+  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 (doesIntersect(p1, q1, p2, q2)) {
+      return [j, i];
+    }
+
+    j = i;
+  }
+}
+
+/**
+ * Checks whether the line (`p1`,`q1`) intersects any of the other lines in the
+ * `points`, and returns the closest value.
+ */
+function getClosestIntersectionWithPolyline(
+  points: Types.Point2[],
+  p1: Types.Point2,
+  q1: Types.Point2,
+  closed = true
+): { segment: Types.Point2; distance: number } | undefined {
+  let initialI;
+  let j;
+
+  if (closed) {
+    j = points.length - 1;
+    initialI = 0;
+  } else {
+    j = 0;
+    initialI = 1;
+  }
+
+  const intersections = [];
+
+  for (let i = initialI; i < points.length; i++) {
+    const p2 = points[j];
+    const q2 = points[i];
+
+    if (doesIntersect(p1, q1, p2, q2)) {
+      intersections.push([j, i]);
+    }
+
+    j = i;
+  }
+
+  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,
+  };
+}
+
+/**
+ * Checks whether the line (`p1`,`q1`) intersects the line (`p2`,`q2`) via an orientation algorithm.
+ */
+function doesIntersect(
+  p1: Types.Point2,
+  q1: Types.Point2,
+  p2: Types.Point2,
+  q2: Types.Point2
+): boolean {
+  let result = 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 {
+  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;
+}
+
+export { getFirstIntersectionWithPolyline, getClosestIntersectionWithPolyline };

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

@@ -0,0 +1,99 @@
+import { StackViewport } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+
+const EPSILON = 1e-3;
+
+/**
+ * Gets the desired spacing for points in the polyline for the
+ * `PlanarFreehandROITool` in the x and y canvas directions, as well as
+ * returning these canvas directions in world space.
+ *
+ * @param viewport - The Cornerstone3D `StackViewport` or `VolumeViewport`.
+ * @param subPixelResolution - The number to divide the image pixel spacing by
+ * to get the sub pixel spacing. E.g. `10` will return spacings 10x smaller than
+ * the native image spacing.
+ * @returns The spacings of the X and Y directions, and the 3D directions of the
+ * x and y directions.
+ */
+const getSubPixelSpacingAndXYDirections = (
+  viewport: Types.IStackViewport | Types.IVolumeViewport,
+  subPixelResolution: number
+): { spacing: Types.Point2; xDir: Types.Point3; yDir: Types.Point3 } => {
+  let spacing;
+  let xDir;
+  let yDir;
+
+  if (viewport instanceof StackViewport) {
+    // Check XY directions
+    const imageData = viewport.getImageData();
+
+    xDir = imageData.direction.slice(0, 3);
+    yDir = imageData.direction.slice(3, 6);
+
+    spacing = imageData.spacing;
+  } else {
+    // Check volume directions
+    const imageData = viewport.getImageData();
+    const { direction, spacing: volumeSpacing } = imageData;
+    const { viewPlaneNormal, viewUp } = viewport.getCamera();
+
+    // Calculate size of spacing vector in normal direction
+    const iVector = direction.slice(0, 3) as Types.Point3;
+    const jVector = direction.slice(3, 6) as Types.Point3;
+    const kVector = direction.slice(6, 9) as Types.Point3;
+
+    const viewRight = vec3.create(); // Get the X direction of the viewport
+
+    vec3.cross(viewRight, <vec3>viewUp, <vec3>viewPlaneNormal);
+
+    const absViewRightDotI = Math.abs(vec3.dot(viewRight, iVector));
+    const absViewRightDotJ = Math.abs(vec3.dot(viewRight, jVector));
+    const absViewRightDotK = Math.abs(vec3.dot(viewRight, kVector));
+
+    // Get X spacing
+    let xSpacing;
+    if (Math.abs(1 - absViewRightDotI) < EPSILON) {
+      xSpacing = volumeSpacing[0];
+      xDir = iVector;
+    } else if (Math.abs(1 - absViewRightDotJ) < EPSILON) {
+      xSpacing = volumeSpacing[1];
+      xDir = jVector;
+    } else if (Math.abs(1 - absViewRightDotK) < EPSILON) {
+      xSpacing = volumeSpacing[2];
+      xDir = kVector;
+    } else {
+      throw new Error('No support yet for oblique plane planar contours');
+    }
+
+    const absViewPlaneNormalDotI = Math.abs(vec3.dot(viewPlaneNormal, iVector));
+    const absViewPlaneNormalDotJ = Math.abs(vec3.dot(viewPlaneNormal, jVector));
+    const absViewPlaneNormalDotK = Math.abs(vec3.dot(viewPlaneNormal, kVector));
+
+    // Get Y spacing
+    let ySpacing;
+    if (Math.abs(1 - absViewPlaneNormalDotI) < EPSILON) {
+      ySpacing = volumeSpacing[0];
+      yDir = iVector;
+    } else if (Math.abs(1 - absViewPlaneNormalDotJ) < EPSILON) {
+      ySpacing = volumeSpacing[1];
+      yDir = jVector;
+    } else if (Math.abs(1 - absViewPlaneNormalDotK) < EPSILON) {
+      ySpacing = volumeSpacing[2];
+      yDir = kVector;
+    } else {
+      throw new Error('No support yet for oblique plane planar contours');
+    }
+
+    spacing = [xSpacing, ySpacing];
+  }
+
+  const subPixelSpacing: Types.Point2 = [
+    spacing[0] / subPixelResolution,
+    spacing[1] / subPixelResolution,
+  ];
+
+  return { spacing: subPixelSpacing, xDir, yDir };
+};
+
+export default getSubPixelSpacingAndXYDirections;

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

@@ -0,0 +1,19 @@
+import {
+  getFirstIntersectionWithPolyline,
+  getClosestIntersectionWithPolyline,
+} from './getIntersectionWithPolyline';
+import getSubPixelSpacingAndXYDirections from './getSubPixelSpacingAndXYDirections';
+import pointsAreWithinCloseContourProximity from './pointsAreWithinCloseContourProximity';
+import addCanvasPointsToArray from './addCanvasPointsToArray';
+import pointCanProjectOnLine from './pointCanProjectOnLine';
+import calculateAreaOfPoints from './calculateAreaOfPoints';
+
+export {
+  getFirstIntersectionWithPolyline,
+  getClosestIntersectionWithPolyline,
+  getSubPixelSpacingAndXYDirections,
+  pointsAreWithinCloseContourProximity,
+  addCanvasPointsToArray,
+  pointCanProjectOnLine,
+  calculateAreaOfPoints,
+};

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

@@ -0,0 +1,36 @@
+import type { Types } from '@cornerstonejs/core';
+import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+
+// Note: These types are internal to the drawing/editing processes of the tool.
+
+type PlanarFreehandROIDrawData = {
+  polylineIndex: number;
+  canvasPoints: Types.Point2[];
+};
+
+type PlanarFreehandROIEditData = {
+  prevCanvasPoints: Types.Point2[];
+  editCanvasPoints: Types.Point2[];
+  fusedCanvasPoints: Types.Point2[];
+  startCrossingIndex?: Types.Point2;
+  // The current index of the last node added to the (invisible) edit line being
+  // used to calculate the edit preview.
+  editIndex: number;
+  // The index on the prevCanvasPoints that the edit line should snap to in the
+  // edit preview.
+  snapIndex?: number;
+};
+
+type PlanarFreehandROICommonData = {
+  annotation: PlanarFreehandROIAnnotation;
+  viewportIdsToRender: string[];
+  spacing: Types.Point2;
+  xDir: Types.Point3;
+  yDir: Types.Point3;
+};
+
+export {
+  PlanarFreehandROIDrawData,
+  PlanarFreehandROIEditData,
+  PlanarFreehandROICommonData,
+};

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

@@ -0,0 +1,57 @@
+import type { Types } from '@cornerstonejs/core';
+import { vec2 } from 'gl-matrix';
+
+/**
+ * Returns `true` if the point `p` can project onto point (`p1`, `p2`), and if
+ * this projected point is less than `proximity` units away.
+ */
+const pointCanProjectOnLine = (
+  p: Types.Point2,
+  p1: Types.Point2,
+  p2: Types.Point2,
+  proximity: number
+): boolean => {
+  // Perfom checks in order of computational complexity.
+  const p1p = [p[0] - p1[0], p[1] - p1[1]];
+  const p1p2 = [p2[0] - p1[0], p2[1] - p1[1]];
+
+  const dot = p1p[0] * p1p2[0] + p1p[1] * p1p2[1];
+
+  // Dot product needs to be positive to be a candidate for projection onto line segment.
+  if (dot < 0) {
+    return false;
+  }
+
+  const p1p2Mag = Math.sqrt(p1p2[0] * p1p2[0] + p1p2[1] * p1p2[1]);
+
+  if (p1p2Mag === 0) {
+    return false;
+  }
+
+  const projectionVectorMag = dot / p1p2Mag;
+  const p1p2UnitVector = [p1p2[0] / p1p2Mag, p1p2[1] / p1p2Mag];
+  const projectionVector = [
+    p1p2UnitVector[0] * projectionVectorMag,
+    p1p2UnitVector[1] * projectionVectorMag,
+  ];
+  const projectionPoint = <Types.Point2>[
+    p1[0] + projectionVector[0],
+    p1[1] + projectionVector[1],
+  ];
+
+  const distance = vec2.distance(p, projectionPoint);
+
+  if (distance > proximity) {
+    // point is too far away.
+    return false;
+  }
+
+  // Check projects onto line segment.
+  if (vec2.distance(p1, projectionPoint) > vec2.distance(p1, p2)) {
+    return false;
+  }
+
+  return true;
+};
+
+export default pointCanProjectOnLine;

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

@@ -0,0 +1,15 @@
+import { vec2 } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Returns true if points `p1` and `p2` are within `closeContourProximity`.
+ */
+const pointsAreWithinCloseContourProximity = (
+  p1: Types.Point2,
+  p2: Types.Point2,
+  closeContourProximity: number
+): boolean => {
+  return vec2.dist(p1, p2) < closeContourProximity;
+};
+
+export default pointsAreWithinCloseContourProximity;