@cornerstonejs/tools 1.51.4 → 1.52.0

package/src/utilities/contours/interpolation/selectHandles.ts

@@ -0,0 +1,240 @@
+import { vec3 } from 'gl-matrix';
+import { utilities } from '@cornerstonejs/core';
+import type { PointsArray3 } from './interpolate';
+import { add } from '@kitware/vtk.js/Common/Core/Math';
+
+const { PointsManager } = utilities;
+
+/**
+ * Selects handles by looking for local maximums in the angle that the local
+ * vector makes
+ *
+ * @param polyline - an array of points, usually the polyline for the contour to
+ *        select handles from.
+ * @param handleCount - a guideline for how many handles to create
+ */
+export default function selectHandles(
+  polyline: PointsArray3,
+  handleCount = 8
+): PointsArray3 {
+  const handles = PointsManager.create3(handleCount) as PointsArray3;
+  handles.sources = [];
+  const { sources: destPoints } = handles;
+  const { length, sources: sourcePoints = [] } = polyline;
+  const distance = 6;
+  if (length < distance * 3) {
+    console.log('Adding subselect handles', handleCount, length);
+    return polyline.subselect(handleCount);
+  }
+  const interval = Math.min(30, Math.floor(length / 3));
+  sourcePoints.forEach(() =>
+    destPoints.push(PointsManager.create3(handleCount))
+  );
+
+  const dotValues = createDotValues(polyline, distance);
+
+  const minimumRegions = findMinimumRegions(dotValues, handleCount);
+  const indices = [];
+  if (minimumRegions?.length > 2) {
+    let lastHandle = -1;
+    const thirdInterval = interval / 3;
+    minimumRegions.forEach((region) => {
+      const [start, , end] = region;
+      const midIndex = Math.ceil((start + end) / 2);
+      if (end - lastHandle < thirdInterval) {
+        return;
+      }
+      if (midIndex - start > 2 * thirdInterval) {
+        addInterval(indices, lastHandle, start, interval, length);
+        lastHandle = addInterval(indices, start, midIndex, interval, length);
+      } else {
+        lastHandle = addInterval(
+          indices,
+          lastHandle,
+          midIndex,
+          interval,
+          length
+        );
+      }
+      if (end - lastHandle > thirdInterval) {
+        lastHandle = addInterval(indices, lastHandle, end, interval, length);
+      }
+    });
+    const firstHandle = indices[0];
+    const lastDistance = indexValue(firstHandle + length - lastHandle, length);
+    // Check that there is enough space between the last and first handle to
+    // need an extra handle.
+    if (lastDistance > 2 * thirdInterval) {
+      addInterval(
+        indices,
+        lastHandle,
+        // Don't add a point too close to the first handle
+        firstHandle - thirdInterval,
+        interval,
+        length
+      );
+    }
+  } else {
+    const interval = Math.floor(length / handleCount);
+    addInterval(indices, -1, length - interval, interval, length);
+  }
+
+  indices.forEach((index) => {
+    const point = polyline.getPointArray(index);
+    handles.push(point);
+    sourcePoints.forEach((source, destSourceIndex) =>
+      destPoints[destSourceIndex].push(source.getPoint(index))
+    );
+  });
+  return handles;
+}
+
+/**
+ * Creates an array of the dot products between each point in the points array
+ * and a point +/- distance from that point, unitized to vector length 1.
+ * That is, this is a measure of the angle at the given point, where 1 is a
+ * straight line, and -1 is a 180 degree angle change.
+ *
+ * @param polyline - the array of Point3 values
+ * @param distance - previous/next distance to use for the vectors for the dot product
+ * @returns - Float32Array of dot products, one per point in the source array.
+ */
+export function createDotValues(
+  polyline: PointsArray3,
+  distance = 6
+): Float32Array {
+  const { length } = polyline;
+  const prevVec3 = vec3.create();
+  const nextVec3 = vec3.create();
+  const dotValues = new Float32Array(length);
+
+  for (let i = 0; i < length; i++) {
+    const point = polyline.getPoint(i);
+    const prevPoint = polyline.getPoint(i - distance);
+    const nextPoint = polyline.getPoint((i + distance) % length);
+    vec3.sub(prevVec3, point, prevPoint);
+    vec3.sub(nextVec3, nextPoint, point);
+    const dot =
+      vec3.dot(prevVec3, nextVec3) / (vec3.len(prevVec3) * vec3.len(nextVec3));
+    dotValues[i] = dot;
+  }
+
+  return dotValues;
+}
+
+/**
+ * Finds minimum regions in the dot products.  These are detected as
+ * center points of the dot values regions having a minimum value - that is,
+ * where the direction of the line is changing fastest.
+ */
+function findMinimumRegions(dotValues, handleCount) {
+  const { max, deviation } = getStats(dotValues);
+  const { length } = dotValues;
+  // Fallback for very uniform ojects.
+  if (deviation < 0.01 || length < handleCount * 3) {
+    // TODO - create handleCount evenly spaced handles
+    return [0, Math.floor(length / 3), Math.floor((length * 2) / 3)];
+  }
+
+  const inflection = [];
+  let pair = null;
+  let minValue;
+  let minIndex = 0;
+
+  for (let i = 0; i < length; i++) {
+    const dot = dotValues[i];
+    if (dot < max - deviation) {
+      if (pair) {
+        pair[2] = i;
+        if (dot < minValue) {
+          minValue = dot;
+          minIndex = i;
+        }
+        pair[1] = minIndex;
+      } else {
+        minValue = dot;
+        minIndex = i;
+        pair = [i, i, i];
+      }
+    } else {
+      if (pair) {
+        inflection.push(pair);
+        pair = null;
+      }
+    }
+  }
+  if (pair) {
+    if (inflection[0][0] === 0) {
+      inflection[0][0] = pair[0];
+    } else {
+      pair[1] = minIndex;
+      pair[2] = length - 1;
+      inflection.push(pair);
+    }
+  }
+
+  return inflection;
+}
+
+/**
+ * Adds points in between the start and finish.
+ * This is currently just the center point for short values and the start/center/end
+ * for ranges where the distance between these is at least the increment.
+ */
+export function addInterval(indices, start, finish, interval, length) {
+  if (finish < start) {
+    // Always want a positive distance even if the long way round
+    finish += length;
+  }
+  const distance = finish - start;
+  const count = Math.ceil(distance / interval);
+  if (count <= 0) {
+    if (indices[indices.length - 1] !== finish) {
+      indices.push(indexValue(finish, length));
+    }
+    return finish;
+  }
+  // Don't add the start index, and always add the end index
+  for (let i = 1; i <= count; i++) {
+    const index = indexValue(start + (i * distance) / count, length);
+    indices.push(index);
+  }
+  return indices[indices.length - 1];
+}
+
+/**
+ * Gets the index value of a closed polyline, rounding the value and
+ * doing the module operation as required.
+ */
+function indexValue(v, length) {
+  return (Math.round(v) + length) % length;
+}
+
+/**
+ * Gets statistics on the provided array numbers.
+ */
+function getStats(dotValues) {
+  const { length } = dotValues;
+  let sum = 0;
+  let min = Infinity;
+  let max = -Infinity;
+  let sumSq = 0;
+  for (let i = 0; i < length; i++) {
+    const dot = dotValues[i];
+    sum += dot;
+    min = Math.min(min, dot);
+    max = Math.max(max, dot);
+  }
+  const mean = sum / length;
+  for (let i = 0; i < length; i++) {
+    const valueDiff = dotValues[i] - mean;
+    sumSq += valueDiff * valueDiff;
+  }
+  return {
+    mean,
+    max,
+    min,
+    sumSq,
+    deviation: Math.sqrt(sumSq / length),
+  };
+}

package/src/utilities/livewire/LivewireScissors.ts

@@ -105,45 +105,47 @@ export class LivewireScissors {
   }
 
   /**
-   * Returns a smoothing path count for how many items to remove.
-   * This will remove points, up to count which have a high gradient, up to
-   * count of them where the clip value is larger than that provided.
+   * Finds a nearby point with a minimum cost nearby
    *
-   * @returns Count of items to remove from the path.
+   * @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 smoothPathCount(
-    pathPoints: Types.Point2[],
-    lastPoint: Types.Point2,
-    count = 5,
-    clipValue = 0.85
-  ) {
-    const lastIndex =
-      (lastPoint &&
-        pathPoints.findIndex((point) => isEqual(point, lastPoint))) ||
-      -1;
-    if (pathPoints.length - lastIndex < count * 2) {
-      // If a nearby point is clicked, just add it anyways, because that means
-      // the user actually wants the given point
-      return 0;
-    }
-    let removeCount = 0;
-    for (
-      let i = pathPoints.length - 1;
-      i > pathPoints.length - count && i > 0;
-      i--
-    ) {
-      const weighted = this._getWeightedDistance(
-        pathPoints[i],
-        pathPoints[i - 1]
-      );
-      if (weighted < clipValue) {
-        return removeCount ? removeCount + 2 : 0;
+  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;
+        }
       }
-      removeCount++;
     }
-    // Tried all of them, they were all too big, so assume they are really moving
-    // along a high gradient.
-    return 0;
+    return minPoint;
   }
 
   /**
@@ -281,7 +283,7 @@ export class LivewireScissors {
 
     // If it is at the end, back up one
     if (y + 1 === height) {
-      index -= height;
+      index -= width;
     }
 
     return data[index] - data[index + width];
@@ -420,14 +422,9 @@ export class LivewireScissors {
     let pixelIndex = 0;
 
     for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width - 1; x++) {
+      for (let x = 0; x < width; x++) {
         gradX[pixelIndex++] = this._getDeltaX(x, y);
       }
-
-      // 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
-      gradX[pixelIndex] = gradX[pixelIndex - 1];
-      pixelIndex++;
     }
 
     return gradX;
@@ -444,18 +441,12 @@ export class LivewireScissors {
     const gradY = new Float32Array(width * height);
     let pixelIndex = 0;
 
-    for (let y = 0; y < height - 1; y++) {
+    for (let y = 0; y < height; y++) {
       for (let x = 0; x < width; x++) {
         gradY[pixelIndex++] = this._getDeltaY(x, y);
       }
     }
 
-    // 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 = gradY.length; pixelIndex < len; pixelIndex++) {
-      gradY[pixelIndex] = gradY[pixelIndex - width];
-    }
-
     return gradY;
   }
 
@@ -481,7 +472,7 @@ export class LivewireScissors {
   }
 
   /**
-   * Compute the gradiant direction, in radians, between to points
+   * 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.
@@ -506,23 +497,44 @@ export class LivewireScissors {
       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;
+  }
 
-    return TWO_THIRD_PI * (Math.acos(dp) + Math.acos(dq));
+  /** 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 } = this;
+    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

package/src/utilities/segmentation/InterpolationManager/InterpolationManager.ts

@@ -20,6 +20,11 @@ import getViewportForAnnotation from '../../getViewportForAnnotation';
 
 const { uuidv4 } = csUtils;
 
+const ChangeTypesForInterpolation = [
+  ChangeTypes.HandlesUpdated,
+  ChangeTypes.InterpolationUpdated,
+];
+
 export default class InterpolationManager {
   static toolNames = [];
 
@@ -31,13 +36,35 @@ export default class InterpolationManager {
 
   /**
    * Accepts the autogenerated interpolations, marking them as non-autogenerated.
-   * Can provide a selector to choose which ones to accept
+   * Can provide a selector to choose which ones to accept.
+   *
+   * Rules for which items to select:
+   * 1. Only choose annotations having the same segment index and segmentationID
+   * 2. Exclude all contours having the same interpolation UID as any other contours
+   *    on the same slice.
+   * 3. Exclude autogenerated annotations
+   * 4. Exclude any reset interpolationUIDs (this is a manual operation to allow
+   *    creating a new interpolation)
+   * 5. Find the set of interpolationUID's remaining
+   *    a. If the set is of size 0, assign a new interpolationUID
+   *    b. If the set is of size 1, assign that interpolationUID
+   *    c. Otherwise (optional, otherwise do b for size>1 randomly),
+   *       for every remaining annotation, find the one whose center
+   *       point is closest to the center point of the new annotation.
+   *       Choose that interpolationUID
+   *
+   * To allow creating new interpolated groups, the idea is to just use a new
+   * segment index, then have an operation to update the segment index of an
+   * interpolation set.  That way the user can easily draw/see the difference,
+   * and then merge them as required.
+   * However, the base rules allow creating two contours on a single image to
+   * create a separate set.
    */
   static acceptAutoGenerated(
     annotationGroupSelector: AnnotationGroupSelector,
     selector: AcceptInterpolationSelector = {}
   ) {
-    const { toolNames, segmentationId, segmentIndex } = selector;
+    const { toolNames, segmentationId, segmentIndex, sliceIndex } = selector;
     for (const toolName of toolNames || InterpolationManager.toolNames) {
       const annotations = annotationState.getAnnotations(
         toolName,
@@ -47,13 +74,20 @@ export default class InterpolationManager {
         continue;
       }
       for (const annotation of annotations) {
-        const { data, autoGenerated } = annotation;
+        const { data, autoGenerated, metadata } = annotation;
         if (!autoGenerated) {
           continue;
         }
         if (segmentIndex && segmentIndex !== data.segmentation.segmentIndex) {
           continue;
         }
+        if (
+          sliceIndex !== undefined &&
+          metadata &&
+          sliceIndex !== (metadata as any).referencedSliceIndex
+        ) {
+          continue;
+        }
         if (
           segmentationId &&
           segmentationId !== data.segmentation.segmentationId
@@ -141,7 +175,7 @@ export default class InterpolationManager {
 
     if (
       !this.toolNames.includes(toolName) ||
-      changeType !== ChangeTypes.HandlesUpdated
+      !ChangeTypesForInterpolation.includes(changeType)
     ) {
       return;
     }
@@ -162,6 +196,7 @@ export default class InterpolationManager {
       sliceData,
       annotation,
       interpolationUID: annotation.interpolationUID,
+      isInterpolationUpdate: changeType === ChangeTypes.InterpolationUpdated,
     };
     interpolate(viewportData);
   };

package/dist/cjs/utilities/contours/PointsArray.d.ts

@@ -1,29 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-export declare type PolyDataPointConfiguration = {
-    dimensions?: 2 | 3;
-    initialSize?: number;
-};
-export declare abstract class PointsArray<T> {
-    data: Float32Array;
-    dimensions: number;
-    length: number;
-    constructor(configuration?: PolyDataPointConfiguration);
-    protected forEach(func: (value: T, index: number) => void, point: T): void;
-    abstract getPoint(index: number, point: T): T;
-    reverse(): void;
-    protected map(f: (value: any, index: number) => T, factory: (index: number) => T): any[];
-    static fromXYZ({ x, y, z }: Types.PointsXYZ): PointsArray3;
-}
-export declare class PointsArray2 extends PointsArray<Types.Point2> {
-    constructor(configuration?: {});
-    forEach(func: (value: Types.Point2, index: number) => void, point?: Types.Point2): void;
-    getPoint(index: number, point?: Types.Point2): Types.Point2;
-    get points(): any[];
-}
-export declare class PointsArray3 extends PointsArray<Types.Point3> {
-    constructor(configuration?: {});
-    forEach(func: (value: Types.Point3, index: number) => void, point?: Types.Point3): void;
-    getPoint(index: number, point?: Types.Point3): Types.Point3;
-    get points(): any[];
-    getXYZ(): Types.PointsXYZ;
-}

package/dist/cjs/utilities/contours/PointsArray.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PointsArray3 = exports.PointsArray2 = exports.PointsArray = void 0;
-const gl_matrix_1 = require("gl-matrix");
-class PointsArray {
-    constructor(configuration = {}) {
-        this.dimensions = 3;
-        this.length = 0;
-        const { initialSize = 1024, dimensions = 3 } = configuration;
-        this.data = new Float32Array(initialSize * dimensions);
-        this.dimensions = dimensions;
-    }
-    forEach(func, point) {
-        for (let i = 0; i < this.length; i++) {
-            func(this.getPoint(i, point), i);
-        }
-    }
-    reverse() {
-        const midLength = Math.floor(this.length / 2);
-        for (let i = 0; i < midLength; i++) {
-            const indexStart = i * this.dimensions;
-            const indexEnd = (this.length - 1 - i) * this.dimensions;
-            for (let dimension = 0; dimension < this.dimensions; dimension++) {
-                const valueStart = this.data[indexStart + dimension];
-                this.data[indexStart + dimension] = this.data[indexEnd + dimension];
-                this.data[indexEnd + dimension] = valueStart;
-            }
-        }
-    }
-    map(f, factory) {
-        const mapData = [];
-        for (let i = 0; i < this.length; i++) {
-            mapData.push(f(this.getPoint(i, factory(i)), i));
-        }
-        return mapData;
-    }
-    static fromXYZ({ x, y, z }) {
-        const array = new PointsArray3({ initialSize: x.length });
-        let offset = 0;
-        for (let i = 0; i < x.length; i++) {
-            array.data[offset++] = x[i];
-            array.data[offset++] = y[i];
-            array.data[offset++] = z[i];
-        }
-        array.length = x.length;
-        return array;
-    }
-}
-exports.PointsArray = PointsArray;
-class PointsArray2 extends PointsArray {
-    constructor(configuration = {}) {
-        super(Object.assign(Object.assign({}, configuration), { dimensions: 2 }));
-    }
-    forEach(func, point = gl_matrix_1.vec2.create()) {
-        super.forEach(func, point);
-    }
-    getPoint(index, point = gl_matrix_1.vec2.create()) {
-        if (index >= this.length) {
-            return;
-        }
-        const index2 = index * 2;
-        point[0] = this.data[index2];
-        point[1] = this.data[index2 + 1];
-        return point;
-    }
-    get points() {
-        return this.map((point) => point, () => gl_matrix_1.vec2.create());
-    }
-}
-exports.PointsArray2 = PointsArray2;
-class PointsArray3 extends PointsArray {
-    constructor(configuration = {}) {
-        super(Object.assign(Object.assign({}, configuration), { dimensions: 3 }));
-    }
-    forEach(func, point = gl_matrix_1.vec3.create()) {
-        super.forEach(func, point);
-    }
-    getPoint(index, point = gl_matrix_1.vec3.create()) {
-        if (index >= this.length) {
-            return;
-        }
-        const index2 = index * 3;
-        point[0] = this.data[index2];
-        point[1] = this.data[index2 + 1];
-        point[2] = this.data[index2 + 2];
-        return point;
-    }
-    get points() {
-        return this.map((point) => point, () => gl_matrix_1.vec3.create());
-    }
-    getXYZ() {
-        const x = [];
-        const y = [];
-        const z = [];
-        this.forEach((point) => {
-            x.push(point[0]);
-            y.push(point[1]);
-            z.push(point[2]);
-        });
-        return { x, y, z };
-    }
-}
-exports.PointsArray3 = PointsArray3;
-//# sourceMappingURL=PointsArray.js.map

package/dist/cjs/utilities/contours/PointsArray.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PointsArray.js","sourceRoot":"","sources":["../../../../src/utilities/contours/PointsArray.ts"],"names":[],"mappings":"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"}