@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.10

package/src/utilities/livewire/LivewireScissors.ts

@@ -0,0 +1,612 @@
+import { Types, utilities } from '@cornerstonejs/core';
+
+import { BucketQueue } from '../BucketQueue';
+
+const { isEqual } = utilities;
+const MAX_UINT32 = 4294967295;
+const TWO_THIRD_PI = 2 / (3 * Math.PI);
+
+/**
+ * Scissors
+ *
+ * Ref: Eric N. Mortensen, William A. Barrett, Interactive Segmentation with
+ *   Intelligent Scissors, Graphical Models and Image Processing, Volume 60,
+ *   Issue 5, September 1998, Pages 349-384, ISSN 1077-3169,
+ *   DOI: 10.1006/gmip.1998.0480.
+ *
+ * {@link http://www.sciencedirect.com/science/article/B6WG4-45JB8WN-9/2/6fe59d8089fd1892c2bfb82283065579}
+ *
+ * Implementation based on MIT licensed code at:
+ * {@link http://code.google.com/p/livewire-javascript/}
+ */
+export class LivewireScissors {
+  private searchGranularityBits: number;
+  private searchGranularity: number;
+
+  /** Width of the image */
+  public readonly width: number;
+
+  /** Height of the image */
+  public readonly height: number;
+
+  /** Grayscale image */
+  private grayscalePixelData: Types.PixelDataTypedArray;
+
+  // Laplace zero-crossings (either 0 or 1).
+  private laplace: Float32Array;
+
+  /** Gradient vector magnitude for each pixel */
+  private gradMagnitude: Float32Array;
+
+  /** Gradient of each pixel in the x-direction */
+  private gradXNew: Float32Array;
+
+  /** Gradient of each pixel in the y-direction */
+  private gradYNew: Float32Array;
+
+  /** Dijkstra - start point */
+  private startPoint: Types.Point2;
+
+  /** Dijkstra - store the state of a pixel (visited/unvisited) */
+  private visited: boolean[];
+
+  /** Dijkstra - map a point to its parent along the shortest path to root (start point) */
+  private parents: Uint32Array;
+
+  /** Dijkstra - store the cost to go from the start point to each node */
+  private costs: Float32Array;
+
+  /** Dijkstra - BucketQueue to sort items by priority */
+  private priorityQueueNew: BucketQueue<number>;
+
+  constructor(
+    grayscalePixelData: Types.PixelDataTypedArray,
+    width: number,
+    height: number
+  ) {
+    const numPixels = grayscalePixelData.length;
+
+    this.searchGranularityBits = 8; // Bits of resolution for BucketQueue.
+    this.searchGranularity = 1 << this.searchGranularityBits; //bits.
+
+    this.width = width;
+    this.height = height;
+
+    this.grayscalePixelData = grayscalePixelData;
+    this.laplace = null;
+    this.gradXNew = null;
+    this.gradYNew = null;
+
+    this.laplace = this._computeLaplace();
+    this.gradMagnitude = this._computeGradient();
+    this.gradXNew = this._computeGradientX();
+    this.gradYNew = this._computeGradientY();
+
+    this.visited = new Array(numPixels);
+    this.parents = new Uint32Array(numPixels);
+    this.costs = new Float32Array(numPixels);
+  }
+
+  public startSearch(startPoint: Types.Point2): void {
+    const startPointIndex = this._getPointIndex(startPoint[1], startPoint[0]);
+
+    this.startPoint = null;
+    this.visited.fill(false);
+    this.parents.fill(MAX_UINT32);
+    this.costs.fill(Infinity);
+    this.priorityQueueNew = new BucketQueue<number>({
+      numBits: this.searchGranularityBits,
+      getPriority: this._getPointCost,
+    });
+
+    this.startPoint = startPoint;
+    this.costs[startPointIndex] = 0;
+    this.priorityQueueNew.push(startPointIndex);
+  }
+
+  /**
+   * Finds a nearby point with a minimum cost nearby
+   *
+   * @param testPoint - to look nearby
+   * @param delta - how long a distance to look
+   * @returns A point having the minimum weighted distance from the testPoint
+   */
+  public findMinNearby(testPoint: Types.Point2, delta = 2) {
+    const [x, y] = testPoint;
+    const { costs } = this;
+
+    const xRange = [
+      Math.max(0, x - delta),
+      Math.min(x + delta + 1, this.width),
+    ];
+    const yRange = [
+      Math.max(0, y - delta),
+      Math.min(y + delta + 1, this.height),
+    ];
+    let minValue = costs[this._getPointIndex(y, x)] * 0.8;
+
+    let minPoint = testPoint;
+    for (let xTest = xRange[0]; xTest < xRange[1]; xTest++) {
+      for (let yTest = yRange[0]; yTest < yRange[1]; yTest++) {
+        // Cost values are 0...1, with 1 being a poor choice for the
+        // livewire fitting - thus, we want to minimize our value, so the
+        // distance cost should be low for the center point.
+        const distanceCost =
+          1 -
+          (Math.abs(xTest - testPoint[0]) + Math.abs(yTest - testPoint[1])) /
+            delta /
+            2;
+        const weightCost = costs[this._getPointIndex(yTest, xTest)];
+
+        const weight = weightCost * 0.8 + distanceCost * 0.2;
+        if (weight < minValue) {
+          minPoint = [xTest, yTest];
+          minValue = weight;
+        }
+      }
+    }
+    return minPoint;
+  }
+
+  /**
+   * Runs Dijsktra until it finds a path from the start point to the target
+   * point. Once it reaches the target point all the state is preserved in order
+   * to save processing time the next time the method is called for a new target
+   * point. The search is restarted whenever `startSearch` is called.
+   * @param targetPoint - Target point
+   * @returns An array with all points for the shortest path found that goes
+   * from startPoint to targetPoint.
+   */
+  public findPathToPoint(targetPoint: Types.Point2): Types.Point2[] {
+    if (!this.startPoint) {
+      throw new Error('There is no search in progress');
+    }
+
+    const {
+      startPoint,
+      _getPointIndex: index,
+      _getPointCoordinate: coord,
+    } = this;
+    const startPointIndex = index(startPoint[1], startPoint[0]);
+    const targetPointIndex = index(targetPoint[1], targetPoint[0]);
+    const {
+      visited: visited,
+      parents: parents,
+      costs: cost,
+      priorityQueueNew: priorityQueue,
+    } = this;
+
+    if (targetPointIndex === startPointIndex) {
+      return [];
+    }
+
+    // Stop searching until there are no more items in the queue or it has
+    // reached the target point. In case it reaches the target all the remaining
+    // items will stay in the queue then once the user moves the mouse to a new
+    // location the search can continue from where it left off.
+    while (
+      !priorityQueue.isEmpty() &&
+      parents[targetPointIndex] === MAX_UINT32
+    ) {
+      const pointIndex = priorityQueue.pop();
+
+      if (visited[pointIndex]) {
+        continue;
+      }
+
+      const point = coord(pointIndex);
+      const neighborsPoints = this._getNeighborPoints(point);
+
+      visited[pointIndex] = true;
+
+      // Update the cost of all neighbors that have higher costs
+      for (let i = 0, len = neighborsPoints.length; i < len; i++) {
+        const neighborPoint = neighborsPoints[i];
+        const neighborPointIndex = index(neighborPoint[1], neighborPoint[0]);
+        const dist = this._getWeightedDistance(point, neighborPoint);
+        const neighborCost = cost[pointIndex] + dist;
+
+        if (neighborCost < cost[neighborPointIndex]) {
+          if (cost[neighborPointIndex] !== Infinity) {
+            // The item needs to be removed from the priority queue and
+            // re-added in order to be moved to the right bucket.
+            priorityQueue.remove(neighborPointIndex);
+          }
+
+          cost[neighborPointIndex] = neighborCost;
+          parents[neighborPointIndex] = pointIndex;
+          priorityQueue.push(neighborPointIndex);
+        }
+      }
+    }
+
+    const pathPoints = [];
+    let pathPointIndex = targetPointIndex;
+
+    while (pathPointIndex !== MAX_UINT32) {
+      pathPoints.push(coord(pathPointIndex));
+      pathPointIndex = parents[pathPointIndex];
+    }
+
+    return pathPoints.reverse();
+  }
+
+  /**
+   * Convert a point coordinate (x,y) into a point index
+   * @param index - Point index
+   * @returns Point coordinate (x,y)
+   */
+  private _getPointIndex = (row: number, col: number) => {
+    const { width } = this;
+    return row * width + col;
+  };
+
+  /**
+   * Convert a point index into a point coordinate (x,y)
+   * @param index - Point index
+   * @returns Point coordinate (x,y)
+   */
+  private _getPointCoordinate = (index: number): Types.Point2 => {
+    const x = index % this.width;
+    const y = Math.floor(index / this.width);
+
+    return [x, y];
+  };
+
+  /**
+   * Calculate the delta X between a given point and its neighbor at the right
+   * @param x - Point x-coordinate
+   * @param y - Point y-coordinate
+   * @returns Delta Y between the given point and its neighbor at the right
+   */
+  private _getDeltaX(x: number, y: number) {
+    const { grayscalePixelData: data, width } = this;
+    let index = this._getPointIndex(y, x);
+
+    // If it is at the end, back up one
+    if (x + 1 === width) {
+      index--;
+    }
+
+    return data[index + 1] - data[index];
+  }
+
+  /**
+   * Calculate the delta Y between a given point and its neighbor at the bottom
+   * @param x - Point x-coordinate
+   * @param y - Point y-coordinate
+   * @returns Delta Y between the given point and its neighbor at the bottom
+   */
+  private _getDeltaY(x: number, y: number) {
+    const { grayscalePixelData: data, width, height } = this;
+    let index = this._getPointIndex(y, x);
+
+    // If it is at the end, back up one
+    if (y + 1 === height) {
+      index -= width;
+    }
+
+    return data[index] - data[index + width];
+  }
+
+  private _getGradientMagnitude(x: number, y: number): number {
+    const dx = this._getDeltaX(x, y);
+    const dy = this._getDeltaY(x, y);
+
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+
+  /**
+   *  Calculate the Laplacian of Gaussian (LoG) value for a given pixel
+   *
+   *     Kernel Indexes           Laplacian of Gaussian Kernel
+   *   __  __  02  __  __              0   0   1   0   0
+   *   __  11  12  13  __              0   1   2   1   0
+   *   20  21  22  23  24              1   2 -16   2   1
+   *   __  31  32  33  __              0   1   2   1   0
+   *   __  __  42  __  __              0   0   1   0   0
+   */
+  private _getLaplace(x: number, y: number): number {
+    const { grayscalePixelData: data, _getPointIndex: index } = this;
+
+    // Points related to the kernel indexes
+    const p02 = data[index(y - 2, x)];
+    const p11 = data[index(y - 1, x - 1)];
+    const p12 = data[index(y - 1, x)];
+    const p13 = data[index(y - 1, x + 1)];
+    const p20 = data[index(y, x - 2)];
+    const p21 = data[index(y, x - 1)];
+    const p22 = data[index(y, x)];
+    const p23 = data[index(y, x + 1)];
+    const p24 = data[index(y, x + 2)];
+    const p31 = data[index(y + 1, x - 1)];
+    const p32 = data[index(y + 1, x)];
+    const p33 = data[index(y + 1, x + 1)];
+    const p42 = data[index(y + 2, x)];
+
+    // Laplacian of Gaussian
+    let lap = p02;
+    lap += p11 + 2 * p12 + p13;
+    lap += p20 + 2 * p21 - 16 * p22 + 2 * p23 + p24;
+    lap += p31 + 2 * p32 + p33;
+    lap += p42;
+
+    return lap;
+  }
+
+  /**
+   * Returns a 2D array of gradient magnitude values for grayscale. The values
+   * are scaled between 0 and 1, and then flipped, so that it works as a cost
+   * function.
+   * @returns A gradient object
+   */
+  private _computeGradient(): Float32Array {
+    const { width, height } = this;
+    const gradient = new Float32Array(width * height);
+
+    let pixelIndex = 0;
+    let max = 0;
+    let x = 0;
+    let y = 0;
+
+    for (y = 0; y < height - 1; y++) {
+      for (x = 0; x < width - 1; x++) {
+        gradient[pixelIndex] = this._getGradientMagnitude(x, y);
+        max = Math.max(gradient[pixelIndex], max);
+        pixelIndex++;
+      }
+
+      // Make the last column the same as the previous one because there is
+      // no way to calculate `dx` since x+1 gets out of bounds
+      gradient[pixelIndex] = gradient[pixelIndex - 1];
+      pixelIndex++;
+    }
+
+    // Make the last row the same as the previous one because there is
+    // no way to calculate `dy` since y+1 gets out of bounds
+    for (let len = gradient.length; pixelIndex < len; pixelIndex++) {
+      gradient[pixelIndex] = gradient[pixelIndex - width];
+    }
+
+    // Flip and scale
+    for (let i = 0, len = gradient.length; i < len; i++) {
+      gradient[i] = 1 - gradient[i] / max;
+    }
+
+    return gradient;
+  }
+
+  /**
+   * Returns a 2D array of Laplacian of Gaussian values
+   *
+   * @param grayscale - The input grayscale
+   * @returns A laplace object
+   */
+  private _computeLaplace(): Float32Array {
+    const { width, height, _getPointIndex: index } = this;
+    const laplace = new Float32Array(width * height);
+
+    // Make the first two rows low cost
+    laplace.fill(1, 0, index(2, 0));
+
+    for (let y = 2; y < height - 2; y++) {
+      // Make the first two columns low cost
+      laplace[index(y, 0)] = 1;
+      laplace[index(y, 1)] = 1;
+
+      for (let x = 2; x < width - 2; x++) {
+        // Threshold needed to get rid of clutter.
+        laplace[index(y, x)] = this._getLaplace(x, y) > 0.33 ? 0 : 1;
+      }
+
+      // Make the last two columns low cost
+      laplace[index(y, width - 2)] = 1;
+      laplace[index(y, width - 1)] = 1;
+    }
+
+    // Make the last two rows low cost
+    laplace.fill(1, index(height - 2, 0));
+
+    return laplace;
+  }
+
+  /**
+   * Returns 2D array of x-gradient values for grayscale
+   *
+   * @param grayscale - Grayscale pixel data
+   * @returns 2D x-gradient array
+   */
+  private _computeGradientX(): Float32Array {
+    const { width, height } = this;
+    const gradX = new Float32Array(width * height);
+    let pixelIndex = 0;
+
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        gradX[pixelIndex++] = this._getDeltaX(x, y);
+      }
+    }
+
+    return gradX;
+  }
+
+  /**
+   * Compute the Y gradient.
+   *
+   * @param grayscale - Grayscale pixel data
+   * @returns 2D array of y-gradient values for grayscale
+   */
+  private _computeGradientY(): Float32Array {
+    const { width, height } = this;
+    const gradY = new Float32Array(width * height);
+    let pixelIndex = 0;
+
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        gradY[pixelIndex++] = this._getDeltaY(x, y);
+      }
+    }
+
+    return gradY;
+  }
+
+  /**
+   * Compute the gradient unit vector.
+   * @param px - Point x-coordinate
+   * @param py - Point y-coordinate
+   * @returns Gradient vector at (px, py), scaled to a magnitude of 1
+   */
+  private _getGradientUnitVector(px: number, py: number) {
+    const { gradXNew, gradYNew, _getPointIndex: index } = this;
+
+    const pointGradX = gradXNew[index(py, px)];
+    const pointGradY = gradYNew[index(py, px)];
+    let gradVecLen = Math.sqrt(
+      pointGradX * pointGradX + pointGradY * pointGradY
+    );
+
+    // To avoid possible divide-by-0 errors
+    gradVecLen = Math.max(gradVecLen, 1e-100);
+
+    return [pointGradX / gradVecLen, pointGradY / gradVecLen];
+  }
+
+  /**
+   * Compute the gradient direction, in radians, between two points
+   *
+   * @param px - Point `p` x-coordinate of point p.
+   * @param py - Point `p` y-coordinate of point p.
+   * @param qx - Point `q` x-coordinate of point q.
+   * @param qy - Point `q` y-coordinate of point q.
+   * @returns Gradient direction
+   */
+  private _getGradientDirection(
+    px: number,
+    py: number,
+    qx: number,
+    qy: number
+  ): number {
+    const dgpUnitVec = this._getGradientUnitVector(px, py);
+    const gdqUnitVec = this._getGradientUnitVector(qx, qy);
+
+    let dp = dgpUnitVec[1] * (qx - px) - dgpUnitVec[0] * (qy - py);
+    let dq = gdqUnitVec[1] * (qx - px) - gdqUnitVec[0] * (qy - py);
+
+    // Make sure dp is positive, to keep things consistent
+    if (dp < 0) {
+      dp = -dp;
+      dq = -dq;
+    }
+    if (px !== qx && py !== qy) {
+      // It's going diagonally between pixels
+      dp *= Math.SQRT1_2;
+      dq *= Math.SQRT1_2;
+    }
+    dq = Math.min(Math.max(dq, -1), 1);
+
+    const direction =
+      TWO_THIRD_PI * (Math.acos(Math.min(dp, 1)) + Math.acos(dq));
+    if (isNaN(direction) || !isFinite(direction)) {
+      console.warn('Found non-direction:', px, py, qx, qy, dp, dq, direction);
+      return 1;
+    }
+    return direction;
+  }
+
+  /** Gets the cost to go from A to B */
+  public getCost(pointA, pointB): number {
+    return this._getWeightedDistance(pointA, pointB);
+  }
+
+  /**
+   * Return a weighted distance between two points
+   */
+  private _getWeightedDistance(pointA: Types.Point2, pointB: Types.Point2) {
+    const { _getPointIndex: index, width, height } = this;
+    const [aX, aY] = pointA;
+    const [bX, bY] = pointB;
+    // Assign a cost of 1 to any points outside the image, prevents using invalid
+    // points
+    if (bX < 0 || bX >= width || bY < 0 || bY >= height) {
+      return 1;
+    }
+    // Use a cost of 0 if the point was outside and is now going inside
+    if (aX < 0 || aY < 0 || aX >= width || aY >= height) {
+      return 0;
+    }
+
+    const bIndex = index(bY, bX);
+
+    // Weighted distance function
+    let gradient = this.gradMagnitude[bIndex];
+
+    if (aX === bX || aY === bY) {
+      // The distance is Euclidean-ish; non-diagonal edges should be shorter
+      gradient *= Math.SQRT1_2;
+    }
+
+    const laplace = this.laplace[bIndex];
+    const direction = this._getGradientDirection(aX, aY, bX, bY);
+
+    return 0.43 * gradient + 0.43 * laplace + 0.11 * direction;
+  }
+
+  /**
+   * Get up to 8 neighbors points
+   * @param point - Reference point
+   * @returns Up to eight neighbor points
+   */
+  private _getNeighborPoints(point: Types.Point2): Types.Point2[] {
+    const { width, height } = this;
+    const list: Types.Point2[] = [];
+
+    const sx = Math.max(point[0] - 1, 0);
+    const sy = Math.max(point[1] - 1, 0);
+    const ex = Math.min(point[0] + 1, width - 1);
+    const ey = Math.min(point[1] + 1, height - 1);
+
+    for (let y = sy; y <= ey; y++) {
+      for (let x = sx; x <= ex; x++) {
+        if (x !== point[0] || y !== point[1]) {
+          list.push([x, y]);
+        }
+      }
+    }
+
+    return list;
+  }
+
+  private _getPointCost = (pointIndex: number): number => {
+    return Math.round(this.searchGranularity * this.costs[pointIndex]);
+  };
+
+  /**
+   * Create a livewire scissor instance from RAW pixel data
+   * @param pixelData - Raw pixel data
+   * @param width - Width of the image
+   * @param height - Height of the image
+   * @param voiRange - VOI Range
+   * @returns A LivewireScissors instance
+   */
+  public static createInstanceFromRawPixelData(
+    pixelData: Float32Array,
+    width: number,
+    height: number,
+    voiRange: Types.VOIRange
+  ) {
+    const numPixels = pixelData.length;
+    const grayscalePixelData = new Float32Array(numPixels);
+    const { lower: minPixelValue, upper: maxPixelValue } = voiRange;
+    const pixelRange = maxPixelValue - minPixelValue;
+
+    for (let i = 0, len = pixelData.length; i < len; i++) {
+      // Grayscale values must be between 0 and 1
+      grayscalePixelData[i] = Math.max(
+        0,
+        Math.min(1, (pixelData[i] - minPixelValue) / pixelRange)
+      );
+    }
+
+    return new LivewireScissors(grayscalePixelData, width, height);
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Types } from '@cornerstonejs/core';
+import distanceToPointSquared from './distanceToPointSquared';
+
+/**
+ * Calculates the squared distance of a point to an AABB using
+ * 2D Box SDF (Signed Distance Field)
+ *
+ * The SDF of a Box
+ * https://www.youtube.com/watch?v=62-pRVZuS5c
+ *
+ * @param aabb - Axis-aligned bound box (minX, minY, maxX and maxY)
+ * @param point - 2D point
+ * @returns The squared distance between the 2D point and the AABB
+ */
+export default function distanceToPoint(
+  aabb: Types.AABB2,
+  point: Types.Point2
+): number {
+  return Math.sqrt(distanceToPointSquared(aabb, point));
+}

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

@@ -0,0 +1,47 @@
+import { Types } from '@cornerstonejs/core';
+
+/**
+ * Calculates the distance of a point to an AABB using 2D Box SDF (Signed Distance Field)
+ *
+ * The SDF of a Box
+ * https://www.youtube.com/watch?v=62-pRVZuS5c
+ *
+ * @param aabb - Axis-aligned bound box
+ * @param point - 2D point
+ * @returns The closest distance between the 2D point and the AABB
+ */
+export default function distanceToPointSquared(
+  aabb: Types.AABB2,
+  point: Types.Point2
+): number {
+  const aabbWidth = aabb.maxX - aabb.minX;
+  const aabbHeight = aabb.maxY - aabb.minY;
+  const aabbSize = [aabbWidth, aabbHeight];
+  const aabbCenter: Types.Point2 = [
+    aabb.minX + aabbWidth / 2,
+    aabb.minY + aabbHeight / 2,
+  ];
+
+  // Translates the point as the center of the AABB is the new origin.
+  // THe point is also mirroed to the first quadrant to simplify the math.
+  const translatedPoint = [
+    Math.abs(point[0] - aabbCenter[0]),
+    Math.abs(point[1] - aabbCenter[1]),
+  ];
+
+  // Calculate the distance from the point to the vertical and horizontal AABB borders
+  const dx = translatedPoint[0] - aabbSize[0] * 0.5;
+  const dy = translatedPoint[1] - aabbSize[1] * 0.5;
+
+  // dx >  0 && dy >  0: diagonal line connecting the point to AABB's corner
+  // dx >  0 && dy <= 0: a line parallel to x-axis connecting the point to AABB's right side
+  // dx <= 0 && dy >  0: a line parallel to y-axis connecting the point to AABB's top side
+  // dx <= 0 && dy <= 0: the point is inside the AABB
+  if (dx > 0 && dy > 0) {
+    return dx * dx + dy * dy;
+  }
+
+  const dist = Math.max(dx, 0) + Math.max(dy, 0);
+
+  return dist * dist;
+}

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

@@ -0,0 +1,3 @@
+export { default as intersectAABB } from './intersectAABB';
+export { default as distanceToPoint } from './distanceToPoint';
+export { default as distanceToPointSquared } from './distanceToPointSquared';

package/src/utilities/math/aabb/intersectAABB.ts

@@ -0,0 +1,19 @@
+import { Types } from '@cornerstonejs/core';
+
+/**
+ * Check if two axis-aligned bounding boxes intersect
+ * @param aabb1 - First AABB
+ * @param aabb2 - Second AABB
+ * @returns True if they intersect or false otherwise
+ */
+export default function intersectAABB(
+  aabb1: Types.AABB2,
+  aabb2: Types.AABB2
+): boolean {
+  return (
+    aabb1.minX <= aabb2.maxX &&
+    aabb1.maxX >= aabb2.minX &&
+    aabb1.minY <= aabb2.maxY &&
+    aabb1.maxY >= aabb2.minY
+  );
+}