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

package/src/utilities/math/polyline/calculateAreaOfPoints.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 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

@@ -1,275 +0,0 @@
-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/
- */
-
-function getAllIntersectionsWithPolyline(
-  points: Types.Point2[],
-  p1: Types.Point2,
-  q1: Types.Point2,
-  closed = true
-): Types.Point2[] {
-  let initialI;
-  let j;
-  const intersections: Types.Point2[] = [];
-
-  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)) {
-      intersections.push([j, i]);
-    }
-
-    j = i;
-  }
-
-  return intersections;
-}
-
-/**
- * Returns all intersections points
- * between a line and a polyline
- */
-function getIntersectionCoordinatesWithPolyline(
-  points: Types.Point2[],
-  p1: Types.Point2,
-  q1: Types.Point2,
-  closed = true
-): Types.Point2[] {
-  const result = [];
-  const polylineIndexes = getAllIntersectionsWithPolyline(
-    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 = getIntersection(p1, q1, p2, q2);
-    result.push(intersection);
-  }
-  return result;
-}
-
-/**
- * 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;
-}
-
-/**
- * Gets the intersection between the line (`p1`,`q1`) and the line (`p2`,`q2`)
- * http://jsfiddle.net/justin_c_rounds/Gd2S2/light/
- * https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection#Given_two_points_on_each_line
- */
-function getIntersection(
-  p1: Types.Point2,
-  q1: Types.Point2,
-  p2: Types.Point2,
-  q2: Types.Point2
-): Types.Point2 {
-  const denominator =
-    (q2[1] - p2[1]) * (q1[0] - p1[0]) - (q2[0] - p2[0]) * (q1[1] - p1[1]);
-  if (denominator == 0) {
-    return;
-  }
-  let a = p1[1] - p2[1];
-  let b = p1[0] - p2[0];
-  const numerator1 = (q2[0] - p2[0]) * a - (q2[1] - p2[1]) * b;
-  const numerator2 = (q1[0] - p1[0]) * a - (q1[1] - p1[1]) * b;
-  a = numerator1 / denominator;
-  b = numerator2 / denominator;
-
-  const resultX = p1[0] + a * (q1[0] - p1[0]);
-  const resultY = p1[1] + a * (q1[1] - p1[1]);
-
-  return [resultX, resultY];
-}
-
-export {
-  getAllIntersectionsWithPolyline,
-  getFirstIntersectionWithPolyline,
-  getClosestIntersectionWithPolyline,
-  getIntersectionCoordinatesWithPolyline,
-};

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

@@ -1,19 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { getAllIntersectionsWithPolyline } from './getIntersectionWithPolyline';
-
-export default function pointInPolyline(
-  points: Types.Point2[],
-  point: Types.Point2,
-  pointEnd: Types.Point2
-): boolean {
-  const intersections = getAllIntersectionsWithPolyline(points, point, [
-    point[0],
-    pointEnd[1],
-  ]);
-
-  if (intersections.length % 2 === 0) {
-    return false;
-  }
-
-  return true;
-}

package/src/utilities/planarFreehandROITool/interpolateAnnotation.ts

@@ -1,87 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-import { PlanarFreehandROITool } from '../../tools';
-import { ToolGroupManager } from '../../store';
-import { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
-import interpolateSegmentPoints from './interpolation/interpolateSegmentPoints';
-
-function shouldPreventInterpolation(
-  enabledElement: Types.IEnabledElement,
-  annotation: PlanarFreehandROIAnnotation,
-  knotsRatioPercentage: number
-): boolean {
-  if (!annotation?.data?.polyline || knotsRatioPercentage <= 0) {
-    return true;
-  }
-
-  if (!enabledElement.viewport) {
-    return true;
-  }
-
-  const { renderingEngineId, viewportId, FrameOfReferenceUID } = enabledElement;
-  const toolGroup = ToolGroupManager.getToolGroupForViewport(
-    viewportId,
-    renderingEngineId
-  );
-
-  if (annotation.metadata.FrameOfReferenceUID !== FrameOfReferenceUID) {
-    return true;
-  }
-
-  if (!toolGroup) {
-    return true;
-  }
-
-  const toolInstance = toolGroup.getToolInstance(annotation.metadata.toolName);
-
-  // strategy to prevent non PlanarFreehandTool
-  if (!(toolInstance instanceof PlanarFreehandROITool)) {
-    return true;
-  }
-
-  return (
-    toolInstance.isDrawing ||
-    toolInstance.isEditingOpen ||
-    toolInstance.isEditingClosed
-  );
-}
-/**
- * Interpolates a given annotation from a given enabledElement.
- * It mutates annotation param.
- * The param knotsRatioPercentage defines the percentage of points to be considered as knots on the interpolation process.
- * Interpolation will be skipped in case: annotation is not present in enabledElement (or there is no toolGroup associated with it), related tool is being modified.
- */
-export default function interpolateAnnotation(
-  enabledElement: Types.IEnabledElement,
-  annotation: PlanarFreehandROIAnnotation,
-  knotsRatioPercentage: number
-): boolean {
-  // prevent running while there is any tool annotation being modified
-  if (
-    shouldPreventInterpolation(enabledElement, annotation, knotsRatioPercentage)
-  ) {
-    return false;
-  }
-
-  const { viewport } = enabledElement;
-  // use only 2 dimensions on interpolation (what visually matters),
-  // otherwise a 3d interpolation might have a totally different output as it consider one more dimension.
-  const canvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
-  const interpolatedCanvasPoints = <Types.Point2[]>(
-    interpolateSegmentPoints(
-      canvasPoints,
-      0,
-      canvasPoints.length,
-      knotsRatioPercentage
-    )
-  );
-
-  if (interpolatedCanvasPoints === canvasPoints) {
-    return false;
-  }
-
-  annotation.data.polyline = interpolatedCanvasPoints.map(
-    viewport.canvasToWorld
-  );
-
-  return true;
-}

package/src/utilities/planarFreehandROITool/interpolatePoints.ts

@@ -1,214 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-import { point } from '../math';
-import interpolateSegmentPoints from './interpolation/interpolateSegmentPoints';
-
-export function shouldInterpolate(configuration: Record<any, any>): boolean {
-  return (
-    configuration?.interpolation?.interpolateOnAdd === true ||
-    configuration?.interpolation?.interpolateOnEdit === true
-  );
-}
-
-/**
- * Tells whether two points are equal by proximity or not as far as interpolation goes.
- */
-function isEqualByProximity(pointA, pointB) {
-  return point.distanceToPoint(pointA, pointB) < 0.001;
-}
-
-/**
- * Tells whether two points are strictly equal or not as far as interpolation goes.
- */
-function isEqual(pointA, pointB) {
-  return point.distanceToPoint(pointA, pointB) === 0;
-}
-
-/**
- * Finds the indexes of points list and otherPoints list that points are identical.
- */
-function findMatchIndexes(
-  points: Types.Point2[],
-  otherPoints: Types.Point2[]
-): [number, number] | undefined {
-  for (let i = 0; i < points.length; i++) {
-    for (let j = 0; j < otherPoints.length; j++) {
-      if (isEqual(points[i], otherPoints[j])) {
-        return [i, j];
-      }
-    }
-  }
-}
-/**
- * Returns the following index value (on circular basis) of index param on the given direction.
- */
-function followingIndex(
-  index: number,
-  size: number,
-  direction: number
-): number {
-  return (index + size + direction) % size;
-}
-/**
- * Array of params to be used on circular find next index.
- * The values respresent start index, indexDelimiter, list of points
- */
-type ListParamsType = [number, number, Types.Point2[]];
-
-/**
- * Circular finding that returns the next index for two list where the criteria is met.
- *
- * It can compare two lists out of sync considering it does a circular iteration over them.
- *
- * @example
- *
- * ```
- * const pointsA = [[0, 1], [1, 3], [1, 5], [1,2]];
- * const pointsB = [[1, 2], [1, 5], [1, 3], [0,0]];
- * let firstParam = [0, 0, pointsA]
- * let secondParam = [1, 1, pointsB]
- * const criteria = (pointA, pointB) => areSamePosition(pointA, pointB)
- * const direction = 1;
- * let result = circularFindNextIndexBy(firstParam, secondParam, criteria,direction);
- * console.log(result);
- * // prints [1, 2]
- * // use this result and find again
- * firstParam = [result[0]+1, result[0], pointsA]
- * secondParam = [result[1]+1, result[1], pointsB]
- * result = circularFindNextIndexBy(firstParam, secondParam, criteria,direction);
- * * // prints [3, 0]
- *
- */
-function circularFindNextIndexBy(
-  listParams: ListParamsType,
-  otherListParams: ListParamsType,
-  criteria: (pointA: Types.Point2, pointB: Types.Point2) => boolean,
-  direction: number
-): [number | undefined, number | undefined] {
-  const [, indexDelimiter, points] = listParams;
-  const [, otherIndexDelimiter, otherPoints] = otherListParams;
-
-  const pointsLength = points.length;
-  const otherPointsLength = otherPoints.length;
-
-  let startIndex = listParams[0];
-  let otherStartIndex = otherListParams[0];
-
-  if (
-    !points[startIndex] ||
-    !otherPoints[otherStartIndex] ||
-    !points[indexDelimiter] ||
-    !otherPoints[otherIndexDelimiter]
-  ) {
-    return [undefined, undefined];
-  }
-
-  while (
-    startIndex !== indexDelimiter &&
-    otherStartIndex !== otherIndexDelimiter
-  ) {
-    if (criteria(otherPoints[otherStartIndex], points[startIndex])) {
-      return [startIndex, otherStartIndex];
-    }
-
-    startIndex = followingIndex(startIndex, pointsLength, direction);
-    otherStartIndex = followingIndex(
-      otherStartIndex,
-      otherPointsLength,
-      direction
-    );
-  }
-
-  return [undefined, undefined];
-}
-
-/**
- * Given two list it will find the first and last index of segment from points that diverges from previousPoints
- */
-function findChangedSegment(
-  points: Types.Point2[],
-  previousPoints: Types.Point2[]
-): [number, number] {
-  const [firstMatchIndex, previousFirstMatchIndex] =
-    findMatchIndexes(points, previousPoints) || [];
-
-  const toBeNotEqualCriteria = (pointA, pointB) =>
-    isEqualByProximity(pointA, pointB) === false;
-
-  const [lowDiffIndex, lowOtherDiffIndex] = circularFindNextIndexBy(
-    [
-      followingIndex(firstMatchIndex, points.length, 1),
-      firstMatchIndex,
-      points,
-    ],
-    [
-      followingIndex(previousFirstMatchIndex, previousPoints.length, 1),
-      previousFirstMatchIndex,
-      previousPoints,
-    ],
-    toBeNotEqualCriteria,
-    1
-  );
-
-  const [highIndex] = circularFindNextIndexBy(
-    [followingIndex(lowDiffIndex, points.length, -1), lowDiffIndex, points],
-    [
-      followingIndex(lowOtherDiffIndex, previousPoints.length, -1),
-      lowOtherDiffIndex,
-      previousPoints,
-    ],
-    toBeNotEqualCriteria,
-    -1
-  );
-
-  return [lowDiffIndex, highIndex];
-}
-
-/**
- * Interpolates the given list of points. In case there is a pointsOfReference the interpolation will occur only on segment disjoint of two list. I.e list of points from param points that are not on list of points from param pointsOfReference.
- */
-export function getInterpolatedPoints(
-  configuration: Record<any, any>,
-  points: Types.Point2[],
-  pointsOfReference?: Types.Point2[]
-): Types.Point2[] {
-  const { interpolation } = configuration;
-
-  const result = points;
-
-  if (interpolation) {
-    const {
-      knotsRatioPercentageOnAdd,
-      knotsRatioPercentageOnEdit,
-      interpolateOnAdd = false,
-      interpolateOnEdit = false,
-    } = interpolation;
-
-    const knotsRatioPercentage = pointsOfReference
-      ? knotsRatioPercentageOnEdit
-      : knotsRatioPercentageOnAdd;
-    const isEnabled = pointsOfReference ? interpolateOnEdit : interpolateOnAdd;
-
-    if (isEnabled) {
-      // partial or total interpolation
-      const [changedIniIndex, changedEndIndex] = pointsOfReference
-        ? findChangedSegment(points, pointsOfReference)
-        : [0, points.length - 1];
-
-      // do not interpolate if there is no valid segment
-      if (!points[changedIniIndex] || !points[changedEndIndex]) {
-        return points;
-      }
-
-      return <Types.Point2[]>(
-        interpolateSegmentPoints(
-          points,
-          changedIniIndex,
-          changedEndIndex,
-          knotsRatioPercentage
-        )
-      );
-    }
-  }
-
-  return result;
-}

package/src/utilities/roundNumber.ts

@@ -1,38 +0,0 @@
-/**
- * Truncates decimal points to that there is at least 1+precision significant
- * digits.
- *
- * For example, with the default precision 2 (3 significant digits)
- * * Values larger than 100 show no information after the decimal point
- * * Values between 10 and 99 show 1 decimal point
- * * Values between 1 and 9 show 2 decimal points
- *
- * @param value - to return a fixed measurement value from
- * @param precision - defining how many digits after 1..9 are desired
- */
-function roundNumber(value: string | number, precision = 2): string {
-  if (value === undefined || value === null || value === '') {
-    return 'NaN';
-  }
-  value = Number(value);
-  if (value < 0.0001) {
-    return `${value}`;
-  }
-  const fixedPrecision =
-    value >= 100
-      ? precision - 2
-      : value >= 10
-      ? precision - 1
-      : value >= 1
-      ? precision
-      : value >= 0.1
-      ? precision + 1
-      : value >= 0.01
-      ? precision + 2
-      : value >= 0.001
-      ? precision + 3
-      : precision + 4;
-  return value.toFixed(fixedPrecision);
-}
-
-export default roundNumber;