@cornerstonejs/tools 0.56.1 → 0.56.3

package/src/utilities/planar/getWorldWidthAndHeightFromTwoPoints.ts

@@ -0,0 +1,51 @@
+import { vec3 } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Given two world positions and an orthogonal view to an `imageVolume` defined by
+ * a `viewPlaneNormal` and a `viewUp`, get the width and height in world coordinates of the rectangle
+ * defined by the two points. The implementation works both with orthogonal
+ * non-orthogonal rectangles.
+ *
+ * @param viewPlaneNormal - The normal of the view.
+ * @param viewUp - The up direction of the view.
+ * @param imageVolume - The imageVolume to use to measure.
+ * @param worldPos1 - The first world position.
+ * @param worldPos2 - The second world position.
+ *
+ * @returns The `worldWidth` and `worldHeight`.
+ */
+export default function getWorldWidthAndHeightFromTwoPoints(
+  viewPlaneNormal: Types.Point3,
+  viewUp: Types.Point3,
+  worldPos1: Types.Point3,
+  worldPos2: Types.Point3
+): { worldWidth: number; worldHeight: number } {
+  const viewRight = vec3.create();
+
+  vec3.cross(viewRight, <vec3>viewUp, <vec3>viewPlaneNormal);
+
+  const pos1 = vec3.fromValues(...worldPos1);
+  const pos2 = vec3.fromValues(...worldPos2);
+
+  const diagonal = vec3.create();
+  vec3.subtract(diagonal, pos1, pos2);
+
+  const diagonalLength = vec3.length(diagonal);
+
+  // When the two points are very close to each other return width as 0
+  // to avoid NaN the cosTheta formula calculation
+  if (diagonalLength < 0.0001) {
+    return { worldWidth: 0, worldHeight: 0 };
+  }
+
+  const cosTheta =
+    vec3.dot(diagonal, viewRight) / (diagonalLength * vec3.length(viewRight));
+
+  const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
+
+  const worldWidth = sinTheta * diagonalLength;
+  const worldHeight = cosTheta * diagonalLength;
+
+  return { worldWidth, worldHeight };
+}

package/src/utilities/planar/index.ts

@@ -0,0 +1,18 @@
+import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
+import getWorldWidthAndHeightFromCorners from './getWorldWidthAndHeightFromCorners';
+import filterAnnotationsForDisplay from './filterAnnotationsForDisplay';
+import getPointInLineOfSightWithCriteria from './getPointInLineOfSightWithCriteria';
+
+export default {
+  filterAnnotationsWithinSlice,
+  getWorldWidthAndHeightFromCorners,
+  filterAnnotationsForDisplay,
+  getPointInLineOfSightWithCriteria,
+};
+
+export {
+  filterAnnotationsWithinSlice,
+  getWorldWidthAndHeightFromCorners,
+  filterAnnotationsForDisplay,
+  getPointInLineOfSightWithCriteria,
+};

package/src/utilities/planarFreehandROITool/index.ts

@@ -0,0 +1,7 @@
+import interpolateAnnotation from './interpolateAnnotation';
+
+export default {
+  interpolateAnnotation,
+};
+
+export { interpolateAnnotation };

package/src/utilities/planarFreehandROITool/interpolateAnnotation.ts

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

@@ -0,0 +1,214 @@
+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/planarFreehandROITool/interpolation/algorithms/bspline.ts

@@ -0,0 +1,55 @@
+import {
+  interpolateBasis as d3InterpolateBasis,
+  quantize as d3Quantize,
+} from 'd3-interpolate';
+import { zip as d3Zip } from 'd3-array';
+import { Types } from '@cornerstonejs/core';
+
+function isPoints3D(
+  points: (Types.Point2 | Types.Point3)[]
+): points is Types.Point3[] {
+  return (points as Types.Point3[])[0]?.length === 3;
+}
+
+/**
+ * Returns an array of the originalPoints length containing the interpolated data.
+ * It interpolates a set of points indexed by knotsIndexes.
+ * That is, it DISCARDS all points except those in knotsIndexes. Then, a new set of points is created by using a b-spline on the remaining points, in order to re-create a new set of points.
+ */
+export function interpolatePoints(
+  originalPoints: (Types.Point2 | Types.Point3)[],
+  knotsIndexes: number[]
+): (Types.Point2 | Types.Point3)[] {
+  if (
+    !knotsIndexes ||
+    knotsIndexes.length === 0 ||
+    knotsIndexes.length === originalPoints.length
+  ) {
+    return originalPoints;
+  }
+
+  const n = knotsIndexes[knotsIndexes.length - 1] - knotsIndexes[0] + 1;
+  const xInterpolator = d3InterpolateBasis(
+    knotsIndexes.map((k) => originalPoints[k][0])
+  );
+  const yInterpolator = d3InterpolateBasis(
+    knotsIndexes.map((k) => originalPoints[k][1])
+  );
+
+  if (isPoints3D(originalPoints)) {
+    const zInterpolator = d3InterpolateBasis(
+      knotsIndexes.map((k) => originalPoints[k][2])
+    );
+    return <Types.Point3[]>(
+      d3Zip(
+        d3Quantize(xInterpolator, n),
+        d3Quantize(yInterpolator, n),
+        d3Quantize(zInterpolator, n)
+      )
+    );
+  } else {
+    return <Types.Point2[]>(
+      d3Zip(d3Quantize(xInterpolator, n), d3Quantize(yInterpolator, n))
+    );
+  }
+}

package/src/utilities/planarFreehandROITool/interpolation/interpolateSegmentPoints.ts

@@ -0,0 +1,90 @@
+import { Types } from '@cornerstonejs/core';
+import { interpolatePoints } from './algorithms/bspline';
+
+/**
+ * Returns a list of uniform distributed values. This list contains the max amount of values which has at least a minimum distance between two consecutive values.
+ * minDistributionDistance means the min distance between two consecutive distributed values.
+ * Closed interval contains the min/max values.
+ *
+ * Formula for reference
+ * For given {x ∈ R | x ≥ 0} and {minDis ∈ R | minDis ≥ 0}, ∃ D(x) where D(x) ≥ a and D(x) ≤ b  =>
+ *         |
+ * D(x)  = |                  (b - a)
+ *         |  round( ------------------------ * x  )   + a
+ *         |                (b - a + 1)
+ *         |        round( -----------  )
+ *         |                 minDis
+ */
+function getContinuousUniformDistributionValues(
+  minDistributionDistance: number,
+  closedInterval: [number, number]
+): number[] {
+  const result = [];
+  const [intervalIni, intervalEnd] = closedInterval;
+
+  const intervalSize = intervalEnd - intervalIni + 1;
+  const intensity = Math.floor(intervalSize / minDistributionDistance);
+
+  let x = 0;
+  let continuosDistributionValue =
+    Math.round(((intervalSize - 1) / (intensity - 1)) * x) + intervalIni;
+
+  while (continuosDistributionValue <= intervalEnd) {
+    result.push(continuosDistributionValue);
+    x++;
+    continuosDistributionValue =
+      Math.round(((intervalSize - 1) / (intensity - 1)) * x) + intervalIni;
+  }
+
+  return result;
+}
+
+/**
+ * Interpolates a segment of points from iniIndex until endIndex.
+ * The process of interpolation considers the param knotsRatioPercentage as being the percentage of points from Segment that are likely to be considered.
+ * By default it uses b-spline algorithm.
+ * The result total of points is equal to original points.
+ */
+export default function interpolateSegmentPoints(
+  points: (Types.Point2 | Types.Point3)[],
+  iniIndex: number,
+  endIndex: number,
+  knotsRatioPercentage: number
+): (Types.Point2 | Types.Point3)[] {
+  const segmentSize = endIndex - iniIndex + 1;
+
+  const amountOfKnots =
+    Math.floor((knotsRatioPercentage / 100) * segmentSize) ?? 1;
+  const minKnotDistance = Math.floor(segmentSize / amountOfKnots) ?? 1;
+
+  if (isNaN(segmentSize) || !segmentSize || !minKnotDistance) {
+    return points;
+  }
+
+  // segment should be at least the double of desired minKnot distance. This will ensure at there will enough knots to interpolate.
+  if (segmentSize / minKnotDistance < 2) {
+    return points;
+  }
+
+  const interpolationIniIndex = Math.max(0, iniIndex);
+  const interpolationEndIndex = Math.min(points.length - 1, endIndex);
+  const segmentPointsUnchangedBeg = points.slice(0, interpolationIniIndex);
+
+  const segmentPointsUnchangedEnd = points.slice(
+    interpolationEndIndex + 1,
+    points.length
+  );
+
+  const knotsIndexes = getContinuousUniformDistributionValues(minKnotDistance, [
+    interpolationIniIndex,
+    interpolationEndIndex,
+  ]);
+
+  const interpolatedPoints = interpolatePoints(points, knotsIndexes);
+
+  return [
+    ...segmentPointsUnchangedBeg,
+    ...interpolatedPoints,
+    ...segmentPointsUnchangedEnd,
+  ];
+}

package/src/utilities/pointInShapeCallback.ts

@@ -0,0 +1,138 @@
+import { vec3 } from 'gl-matrix';
+import type { Types } from '@cornerstonejs/core';
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import BoundsIJK from '../types/BoundsIJK';
+
+export type PointInShapeCallback = ({
+  value,
+  index,
+  pointIJK,
+  pointLPS,
+}: {
+  value: number;
+  index: number;
+  pointIJK: Types.Point3;
+  pointLPS: Types.Point3;
+}) => void;
+
+export type ShapeFnCriteria = (
+  pointIJK: Types.Point3,
+  pointLPS: Types.Point3
+) => boolean;
+
+/**
+ * For each point in the image (If boundsIJK is not provided, otherwise, for each
+ * point in the provided bounding box), It runs the provided callback IF the point
+ * passes the provided criteria to be inside the shape (which is defined by the
+ * provided pointInShapeFn)
+ *
+ * @param imageData - The image data object.
+ * @param dimensions - The dimensions of the image.
+ * @param pointInShapeFn - A function that takes a point in LPS space and returns
+ * true if the point is in the shape and false if it is not.
+ * @param callback - A function that will be called for
+ * every point in the shape.
+ * @param boundsIJK - The bounds of the volume in IJK coordinates.
+ */
+export default function pointInShapeCallback(
+  imageData: vtkImageData | Types.CPUImageData,
+  pointInShapeFn: ShapeFnCriteria,
+  callback: PointInShapeCallback,
+  boundsIJK?: BoundsIJK
+): void {
+  let iMin, iMax, jMin, jMax, kMin, kMax;
+
+  let scalarData;
+
+  // if getScalarData is a method on imageData
+  if ((imageData as Types.CPUImageData).getScalarData) {
+    scalarData = (imageData as Types.CPUImageData).getScalarData();
+  } else {
+    scalarData = (imageData as vtkImageData)
+      .getPointData()
+      .getScalars()
+      .getData();
+  }
+
+  const dimensions = imageData.getDimensions();
+
+  if (!boundsIJK) {
+    iMin = 0;
+    iMax = dimensions[0];
+    jMin = 0;
+    jMax = dimensions[1];
+    kMin = 0;
+    kMax = dimensions[2];
+  } else {
+    [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = boundsIJK;
+  }
+
+  const start = vec3.fromValues(iMin, jMin, kMin);
+
+  const direction = imageData.getDirection();
+  const rowCosines = direction.slice(0, 3);
+  const columnCosines = direction.slice(3, 6);
+  const scanAxisNormal = direction.slice(6, 9);
+
+  const spacing = imageData.getSpacing();
+  const [rowSpacing, columnSpacing, scanAxisSpacing] = spacing;
+
+  // @ts-ignore will be fixed in vtk-master
+  const worldPosStart = imageData.indexToWorld(start);
+
+  const rowStep = vec3.fromValues(
+    rowCosines[0] * rowSpacing,
+    rowCosines[1] * rowSpacing,
+    rowCosines[2] * rowSpacing
+  );
+
+  const columnStep = vec3.fromValues(
+    columnCosines[0] * columnSpacing,
+    columnCosines[1] * columnSpacing,
+    columnCosines[2] * columnSpacing
+  );
+
+  const scanAxisStep = vec3.fromValues(
+    scanAxisNormal[0] * scanAxisSpacing,
+    scanAxisNormal[1] * scanAxisSpacing,
+    scanAxisNormal[2] * scanAxisSpacing
+  );
+
+  const yMultiple = dimensions[0];
+  const zMultiple = dimensions[0] * dimensions[1];
+
+  for (let k = kMin; k <= kMax; k++) {
+    for (let j = jMin; j <= jMax; j++) {
+      for (let i = iMin; i <= iMax; i++) {
+        const pointIJK: Types.Point3 = [i, j, k];
+        const dI = i - iMin;
+        const dJ = j - jMin;
+        const dK = k - kMin;
+
+        const startWorld = worldPosStart;
+
+        const pointLPS: Types.Point3 = [
+          startWorld[0] +
+            dI * rowStep[0] +
+            dJ * columnStep[0] +
+            dK * scanAxisStep[0],
+          startWorld[1] +
+            dI * rowStep[1] +
+            dJ * columnStep[1] +
+            dK * scanAxisStep[1],
+          startWorld[2] +
+            dI * rowStep[2] +
+            dJ * columnStep[2] +
+            dK * scanAxisStep[2],
+        ];
+
+        if (pointInShapeFn(pointLPS, pointIJK)) {
+          const index = k * zMultiple + j * yMultiple + i;
+          const value = scalarData[index];
+
+          callback({ value, index, pointIJK, pointLPS });
+        }
+      }
+    }
+  }
+}