@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

package/src/utilities/math/angle/angleBetweenLines.ts

@@ -1,61 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { vec2, vec3 } from 'gl-matrix';
-
-type Line2D = [Types.Point2, Types.Point2];
-type Line3D = [Types.Point3, Types.Point3];
-type Line = Line2D | Line3D;
-
-/**
- * Calculates the angle between two 3D lines.
- */
-function angleBetween3DLines(line1: Line3D, line2: Line3D): number {
-  const [p1, p2] = line1;
-  const [p3, p4] = line2;
-
-  const v1 = vec3.sub(vec3.create(), p2, p1);
-  const v2 = vec3.sub(vec3.create(), p3, p4);
-
-  const dot = vec3.dot(v1, v2);
-
-  const v1Length = vec3.length(v1);
-  const v2Length = vec3.length(v2);
-
-  const cos = dot / (v1Length * v2Length);
-
-  const radian = Math.acos(cos);
-
-  return (radian * 180) / Math.PI;
-}
-
-/**
- * Calculates the angle between two 2D lines.
- */
-function angleBetween2DLines(line1: Line2D, line2: Line2D): number {
-  const [p1, p2] = line1;
-  const [p3, p4] = line2;
-
-  const v1 = vec2.sub(vec2.create(), p2, p1);
-  const v2 = vec2.sub(vec2.create(), p3, p4);
-
-  const dot = vec2.dot(v1, v2);
-  const v1Length = vec2.length(v1);
-  const v2Length = vec2.length(v2);
-
-  const cos = dot / (v1Length * v2Length);
-  return Math.acos(cos) * (180 / Math.PI);
-}
-
-/**
- * Returns the angle between two lines in degrees.
- * The angle measured is that between the vectors
- * line1[1]->line1[0] AND line2[0]->line2[1].
- * @param line1 - Line = [p1, p2]
- * @param line2 - Line = [p3, p4]
- * @returns The angle between two lines in degrees.
- */
-export default function angleBetweenLines(line1: Line, line2: Line): number {
-  const is3D = line1[0].length === 3;
-  return is3D
-    ? angleBetween3DLines(line1 as Line3D, line2 as Line3D)
-    : angleBetween2DLines(line1 as Line2D, line2 as Line2D);
-}

package/src/utilities/math/basic/BasicStatsCalculator.ts

@@ -1,148 +0,0 @@
-import { utilities } from '@cornerstonejs/core';
-import { NamedStatistics } from '../../../types';
-import Calculator from './Calculator';
-
-const { PointsManager } = utilities;
-
-export default class BasicStatsCalculator extends Calculator {
-  private static max = [-Infinity];
-  private static min = [Infinity];
-  private static sum = [0];
-  private static count = 0;
-
-  // private static sumSquares = [0];
-  // Values for Welford's algorithm
-  private static runMean = [0];
-  private static m2 = [0];
-
-  // Collect the points to be returned
-  private static pointsInShape = PointsManager.create3(1024);
-
-  public static statsInit(options: { noPointsCollection: boolean }) {
-    if (options.noPointsCollection) {
-      BasicStatsCalculator.pointsInShape = null;
-    }
-  }
-
-  /**
-   * This callback is used when we verify if the point is in the annotation drawn
-   * so we can get every point in the shape to calculate the statistics
-   */
-  static statsCallback = ({ value: newValue, pointLPS = null }): void => {
-    if (
-      Array.isArray(newValue) &&
-      newValue.length > 1 &&
-      this.max.length === 1
-    ) {
-      this.max.push(this.max[0], this.max[0]);
-      this.min.push(this.min[0], this.min[0]);
-      this.sum.push(this.sum[0], this.sum[0]);
-      this.runMean.push(0, 0);
-      // this.sumSquares.push(this.sumSquares[0], this.sumSquares[0]);
-      this.m2.push(this.m2[0], this.m2[0]);
-    }
-
-    this.pointsInShape?.push(pointLPS);
-    const newArray = Array.isArray(newValue) ? newValue : [newValue];
-
-    this.count += 1;
-    this.max.map((it, idx) => {
-      const value = newArray[idx];
-
-      const delta = value - this.runMean[idx];
-      this.sum[idx] += value;
-      this.runMean[idx] += delta / this.count;
-      const delta2 = value - this.runMean[idx];
-      this.m2[idx] += delta * delta2;
-      // this.sumSquares[idx] += value * value;
-
-      this.min[idx] = Math.min(this.min[idx], value);
-      this.max[idx] = Math.max(it, value);
-    });
-  };
-
-  /**
-   * Basic function that calculates statistics for a given array of points.
-   * @returns An object that contains :
-   * max : The maximum value of the array
-   * mean : mean of the array
-   * stdDev : standard deviation of the array
-   * array : An array of hte above values, in order.
-   */
-
-  static getStatistics = (options?: { unit: string }): NamedStatistics => {
-    const mean = this.sum.map((sum) => sum / this.count);
-    const stdDev = this.m2.map((squaredDiffSum) =>
-      Math.sqrt(squaredDiffSum / this.count)
-    );
-    // const stdDevWithSumSquare = this.sumSquares.map((it, idx) =>
-    //   Math.sqrt(this.sumSquares[idx] / this.count - mean[idx] ** 2)
-    // );
-
-    const unit = options?.unit || null;
-
-    const named: NamedStatistics = {
-      max: {
-        name: 'max',
-        label: 'Max Pixel',
-        value: singleArrayAsNumber(this.max),
-        unit,
-      },
-      min: {
-        name: 'min',
-        label: 'Min Pixel',
-        value: singleArrayAsNumber(this.min),
-        unit,
-      },
-      mean: {
-        name: 'mean',
-        label: 'Mean Pixel',
-        value: singleArrayAsNumber(mean),
-        unit,
-      },
-      stdDev: {
-        name: 'stdDev',
-        label: 'Standard Deviation',
-        value: singleArrayAsNumber(stdDev),
-        unit,
-      },
-      // stdDevWithSumSquare: {
-      //   name: 'stdDevWithSumSquare',
-      //   value: singleArrayAsNumber(stdDevWithSumSquare),
-      //   unit,
-      // },
-      count: {
-        name: 'count',
-        label: 'Pixel Count',
-        value: this.count,
-        unit: null,
-      },
-      pointsInShape: this.pointsInShape,
-      array: [],
-    };
-    named.array.push(
-      named.max,
-      named.mean,
-      named.stdDev,
-      // Use the stdDev twice to preserve old ordering - this is updated to be
-      // correct value with Welford's algorithm now.
-      named.stdDev,
-      named.count
-    );
-
-    this.max = [-Infinity];
-    this.min = [Infinity];
-    this.sum = [0];
-    // this.sumSquares = [0];
-    this.m2 = [0];
-    this.runMean = [0];
-    this.count = 0;
-    this.pointsInShape = PointsManager.create3(1024);
-
-    return named;
-  };
-}
-
-function singleArrayAsNumber(val: number[]) {
-  return val.length === 1 ? val[0] : val;
-}

package/src/utilities/math/basic/Calculator.ts

@@ -1,11 +0,0 @@
-import { NamedStatistics } from '../../../types';
-
-abstract class Calculator {
-  static run: ({ value }) => void;
-  /**
-   * Gets the statistics as both an array of values, as well as the named values.
-   */
-  static getStatistics: () => NamedStatistics;
-}
-
-export default Calculator;

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

@@ -1,4 +0,0 @@
-import BasicStatsCalculator from './BasicStatsCalculator';
-import Calculator from './Calculator';
-
-export { BasicStatsCalculator, Calculator };

package/src/utilities/math/circle/_types.ts

@@ -1,6 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-export type canvasCoordinates = [
-  Types.Point2, // center
-  Types.Point2 // end
-];

package/src/utilities/math/circle/getCanvasCircleCorners.ts

@@ -1,23 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { distanceToPoint } from '../point';
-import { canvasCoordinates } from './_types';
-
-/**
- * It takes the canvas coordinates of the circle corners (wrapping square rectangle)
- * and returns the top left and bottom right
- * corners of it
- *
- * @param circleCanvasPoints - The coordinates of the circle in the canvas.
- * @returns An array of two points.
- */
-export default function getCanvasCircleCorners(
-  circleCanvasPoints: canvasCoordinates
-): Array<Types.Point2> {
-  const [center, end] = circleCanvasPoints;
-  const radius = distanceToPoint(center, end);
-
-  const topLeft = <Types.Point2>[center[0] - radius, center[1] - radius];
-  const bottomRight = <Types.Point2>[center[0] + radius, center[1] + radius];
-
-  return [topLeft, bottomRight];
-}

package/src/utilities/math/circle/getCanvasCircleRadius.ts

@@ -1,16 +0,0 @@
-import { distanceToPoint } from '../point';
-import { canvasCoordinates } from './_types';
-
-/**
- * It takes the canvas coordinates of the circle corners and returns the top left and bottom right
- * corners of it
- *
- * @param circleCanvasPoints - The coordinates of the circle in the canvas.
- * @returns An array of two points.
- */
-export default function getCanvasCircleRadius(
-  circleCanvasPoints: canvasCoordinates
-): number {
-  const [center, end] = circleCanvasPoints;
-  return distanceToPoint(center, end);
-}

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

@@ -1,4 +0,0 @@
-import getCanvasCircleRadius from './getCanvasCircleRadius';
-import getCanvasCircleCorners from './getCanvasCircleCorners';
-
-export { getCanvasCircleRadius, getCanvasCircleCorners };

package/src/utilities/math/ellipse/getCanvasEllipseCorners.ts

@@ -1,26 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-export type CanvasCoordinates = [
-  Types.Point2, // bottom
-  Types.Point2, // top
-  Types.Point2, // left
-  Types.Point2 // right
-];
-
-/**
- * It takes the canvas coordinates of the ellipse corners and returns the top left and bottom right
- * corners of it
- *
- * @param ellipseCanvasPoints - The coordinates of the ellipse in the canvas.
- * @returns An array of two points.
- */
-export default function getCanvasEllipseCorners(
-  ellipseCanvasPoints: CanvasCoordinates
-): Array<Types.Point2> {
-  const [bottom, top, left, right] = ellipseCanvasPoints;
-
-  const topLeft = <Types.Point2>[left[0], top[1]];
-  const bottomRight = <Types.Point2>[right[0], bottom[1]];
-
-  return [topLeft, bottomRight];
-}

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

@@ -1,4 +0,0 @@
-import pointInEllipse, { precalculatePointInEllipse } from './pointInEllipse';
-import getCanvasEllipseCorners from './getCanvasEllipseCorners';
-
-export { pointInEllipse, precalculatePointInEllipse, getCanvasEllipseCorners };

package/src/utilities/math/ellipse/pointInEllipse.ts

@@ -1,94 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-interface Inverts {
-  invXRadiusSq?: number;
-  invYRadiusSq?: number;
-  invZRadiusSq?: number;
-  fast?: boolean;
-  /**
-   * If you call the pointInEllipse.precalculateInverts first, then you
-   * can call precalculated directly instead of having the extra time for
-   * the if conditions.
-   */
-  precalculated?: (pointLPS: Types.Point3) => boolean;
-}
-
-/**
- * Given an ellipse and a point, return true if the point is inside the ellipse
- * @param ellipse - The ellipse object to check against.
- * @param pointLPS - The point in LPS space to test.
- * @param inverts - An object to cache the inverted radius squared values, if you
- * are testing multiple points against the same ellipse then it is recommended to
- * pass in the same object to cache the values. However, there is a simpler way
- * to do this by passing in the fast flag as true, then on the first iteration
- * the values will be cached and on subsequent iterations the cached values will
- * be used.
- *
- * @returns A boolean value.
- */
-export default function pointInEllipse(
-  ellipse,
-  pointLPS,
-  inverts: Inverts = {}
-) {
-  if (!inverts.precalculated) {
-    precalculatePointInEllipse(ellipse, inverts);
-  }
-  return inverts.precalculated(pointLPS);
-}
-
-/**
- * This will perform some precalculations to make things faster.
- * Ideally, use the 'precalculated' function inside inverts to call the
- * test function.  This minimizes re-reading of variables and only needs the
- * LPS passed each time.
- * That is:
- *
- * ```
- *    const inverts = precalculatePointInEllipse(ellipse);
- *    if( inverts.precalculated(pointLPS) ) ...
- * ```
- */
-const precalculatePointInEllipse = (ellipse, inverts: Inverts = {}) => {
-  const { xRadius, yRadius, zRadius } = ellipse;
-
-  // This will run only once since we are caching the values in the same
-  // object that is passed in.
-  if (
-    inverts.invXRadiusSq === undefined ||
-    inverts.invYRadiusSq === undefined ||
-    inverts.invZRadiusSq === undefined
-  ) {
-    inverts.invXRadiusSq = xRadius !== 0 ? 1 / xRadius ** 2 : 0;
-    inverts.invYRadiusSq = yRadius !== 0 ? 1 / yRadius ** 2 : 0;
-    inverts.invZRadiusSq = zRadius !== 0 ? 1 / zRadius ** 2 : 0;
-  }
-
-  const { invXRadiusSq, invYRadiusSq, invZRadiusSq } = inverts;
-  const { center } = ellipse;
-  const [centerL, centerP, centerS] = center;
-
-  inverts.precalculated = (pointLPS) => {
-    // Calculate the sum of normalized squared distances
-    const dx = pointLPS[0] - centerL;
-    let inside = dx * dx * invXRadiusSq;
-    if (inside > 1) {
-      return false;
-    }
-
-    const dy = pointLPS[1] - centerP;
-    inside += dy * dy * invYRadiusSq;
-    if (inside > 1) {
-      return false;
-    }
-
-    const dz = pointLPS[2] - centerS;
-    inside += dz * dz * invZRadiusSq;
-
-    // Check if the point is inside the ellipse
-    return inside <= 1;
-  };
-
-  return inverts;
-};
-
-export { precalculatePointInEllipse };

package/src/utilities/math/ellipse/pointInEllipsoidWithConstraint.ts

@@ -1,35 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-
-type ellipsoid = {
-  center: [number, number, number];
-  width: number;
-  height: number;
-  depth: number;
-};
-
-/**
- * Checks whether the point is inside the provided ellipse with constraint of a plane (viewPlane).
- * @param ellipse - ellipse object including {center, width, height, depth}
- * @param point - [x,y,z] of the point
- * @param viewPlane - camera viewPlane
- * @returns whether the point is inside the ellipse
- */
-export default function pointInEllipsoidWithConstraint(
-  ellipsoid: ellipsoid,
-  point: Types.Point3,
-  viewPlane: Types.Point3 // constraint
-) {
-  // Todo: This implementation should be used for oblique planes segmentation tools
-  // but still not a priority
-  // const { center, width, height, depth } = ellipsoid
-  // const [x, y, z] = point
-  // const [x0, y0, z0] = center
-  // const inside =
-  //   ((x - x0) * (x - x0)) / (width * width) +
-  //     ((y - y0) * (y - y0)) / (height * height) +
-  //     ((z - z0) * (z - z0)) / (depth * depth) <=
-  //   1
-  // const onPlane =
-  //   Math.abs(n1 * (x - x0) + n2 * (y - y0) + n3 * (z - z0)) <= 1e-3
-  // return inside
-}

package/src/utilities/math/index.ts

@@ -1,19 +0,0 @@
-import * as aabb from './aabb';
-import * as BasicStatsCalculator from './basic';
-import * as ellipse from './ellipse';
-import * as lineSegment from './line';
-import * as point from './point';
-import * as polyline from './polyline';
-import * as rectangle from './rectangle';
-import * as vec2 from './vec2';
-
-export {
-  aabb,
-  BasicStatsCalculator,
-  ellipse,
-  lineSegment,
-  point,
-  polyline,
-  rectangle,
-  vec2,
-};

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

@@ -1,24 +0,0 @@
-import distanceToPointSquared from './distanceToPointSquared';
-import type { Types } from '@cornerstonejs/core';
-
-/**
- * Calculates the distance 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
- */
-export default function distanceToPoint(
-  lineStart: Types.Point2,
-  lineEnd: Types.Point2,
-  point: Types.Point2
-): number {
-  if (lineStart.length !== 2 || lineEnd.length !== 2 || point.length !== 2) {
-    throw Error(
-      'lineStart, lineEnd, and point should have 2 elements of [x, y]'
-    );
-  }
-
-  return Math.sqrt(distanceToPointSquared(lineStart, lineEnd, point));
-}

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

@@ -1,18 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-import distanceToPointSquaredInfo from './distanceToPointSquaredInfo';
-
-/**
- * Calculates the distance-squared of a point to a line segment
- *
- * @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 {
-  return distanceToPointSquaredInfo(lineStart, lineEnd, point).distanceSquared;
-}

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

@@ -1,55 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import * as math from '../';
-
-/**
- * Calculate the closest point and the squared distance between a reference point and a line segment.
- *
- * It projects the reference point onto the line segment but it shall be bounded by the
- * start/end points since this is a line segment and not a line which could be extended.
- *
- * @param lineStart - Start point of the line segment
- * @param lineEnd - End point of the line segment
- * @param point - Reference point
- * @returns Closest point and the squared distance between a `point` and a line
- *   segment defined by `lineStart` and `lineEnd` points
- */
-export default function distanceToPointSquaredInfo(
-  lineStart: Types.Point2,
-  lineEnd: Types.Point2,
-  point: Types.Point2
-): {
-  point: Types.Point2;
-  distanceSquared: number;
-} {
-  let closestPoint: Types.Point2;
-  const distanceSquared = math.point.distanceToPointSquared(lineStart, lineEnd);
-
-  // Check if lineStart equal to the lineEnd which means the closest point
-  // is any of these two points
-  if (lineStart[0] === lineEnd[0] && lineStart[1] === lineEnd[1]) {
-    closestPoint = lineStart;
-  }
-
-  if (!closestPoint) {
-    const dotProduct =
-      ((point[0] - lineStart[0]) * (lineEnd[0] - lineStart[0]) +
-        (point[1] - lineStart[1]) * (lineEnd[1] - lineStart[1])) /
-      distanceSquared;
-
-    if (dotProduct < 0) {
-      closestPoint = lineStart;
-    } else if (dotProduct > 1) {
-      closestPoint = lineEnd;
-    } else {
-      closestPoint = [
-        lineStart[0] + dotProduct * (lineEnd[0] - lineStart[0]),
-        lineStart[1] + dotProduct * (lineEnd[1] - lineStart[1]),
-      ];
-    }
-  }
-
-  return {
-    point: [...closestPoint],
-    distanceSquared: math.point.distanceToPointSquared(point, closestPoint),
-  };
-}

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

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

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

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