@cornerstonejs/tools 1.38.1 → 1.39.0

package/src/tools/index.ts

@@ -28,6 +28,7 @@ import EllipticalROITool from './annotation/EllipticalROITool';
 import CircleROITool from './annotation/CircleROITool';
 import SplineROITool from './annotation/SplineROITool';
 import PlanarFreehandROITool from './annotation/PlanarFreehandROITool';
+import LivewireContourTool from './annotation/LivewireContourTool';
 import ArrowAnnotateTool from './annotation/ArrowAnnotateTool';
 import AngleTool from './annotation/AngleTool';
 import CobbAngleTool from './annotation/CobbAngleTool';
@@ -76,6 +77,7 @@ export {
   CircleROITool,
   SplineROITool,
   PlanarFreehandROITool,
+  LivewireContourTool,
   ArrowAnnotateTool,
   AngleTool,
   CobbAngleTool,

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { Annotation } from './AnnotationTypes';
 import { ISpline } from './';
+import { LivewirePath } from '../utilities/livewire/LiveWirePath';
 
 interface ROICachedStats {
   [targetId: string]: {
@@ -152,6 +153,17 @@ export interface SplineROIAnnotation extends Annotation {
   };
 }
 
+export interface LivewireContourAnnotation extends Annotation {
+  data: {
+    polyline: Types.Point3[];
+    label?: string;
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+    };
+  };
+}
+
 export interface EllipticalROIAnnotation extends Annotation {
   data: {
     handles: {

package/src/utilities/BucketQueue.ts

@@ -0,0 +1,154 @@
+type BucketNode<T> = {
+  value: T;
+  next: BucketNode<T>;
+};
+
+/**
+ * Circular Bucket Queue.
+ *
+ * Returns input'd points in sorted order. All operations run in roughly O(1)
+ * time (for input with small cost values), but it has a strict requirement:
+ *
+ * If the most recent point had a cost of c, any points added should have a cost
+ * c' in the range c <= c' <= c + (capacity - 1).
+ */
+export class BucketQueue<T> {
+  private _bucketCount: number;
+  private _mask: number;
+  private _size: number;
+  private _currentBucketIndex: number;
+  private _getPriority: (item: T) => number;
+  private _areEqual: (itemA: T, itemB: T) => boolean;
+  private _buckets: BucketNode<T>[];
+
+  /**
+   * @param bits - Number of bits.
+   * @param getPriority - A function that returns the priority of an item
+   */
+  constructor({
+    numBits,
+    getPriority,
+    areEqual,
+  }: {
+    numBits: number;
+    getPriority?: (item: T) => number;
+    areEqual?: (itemA: T, itemB: T) => boolean;
+  }) {
+    this._bucketCount = 1 << numBits; // # of buckets = 2^numBits
+    this._mask = this._bucketCount - 1; // 2^numBits - 1 = index mask
+    this._size = 0;
+    this._currentBucketIndex = 0;
+    this._buckets = this._buildArray(this._bucketCount);
+
+    this._getPriority =
+      typeof getPriority !== 'undefined'
+        ? getPriority
+        : (item) => item as unknown as number;
+
+    this._areEqual =
+      typeof areEqual === 'function'
+        ? areEqual
+        : (itemA, itemB) => itemA === itemB;
+  }
+
+  /**
+   * Prepend item to the list in the appropriate bucket
+   * @param item - Item to be added to the queue based on its priority
+   */
+  public push(item: T) {
+    const bucketIndex = this._getBucketIndex(item);
+    const oldHead = this._buckets[bucketIndex];
+    const newHead: BucketNode<T> = {
+      value: item,
+      next: oldHead,
+    };
+
+    this._buckets[bucketIndex] = newHead;
+    this._size++;
+  }
+
+  public pop(): T {
+    if (this._size === 0) {
+      throw new Error('Cannot pop because the queue is empty.');
+    }
+
+    // Find first empty bucket
+    while (this._buckets[this._currentBucketIndex] === null) {
+      this._currentBucketIndex =
+        (this._currentBucketIndex + 1) % this._bucketCount;
+    }
+
+    // All items in bucket have same cost, return the first one
+    const ret = this._buckets[this._currentBucketIndex];
+
+    this._buckets[this._currentBucketIndex] = ret.next;
+    this._size--;
+
+    return ret.value;
+  }
+
+  /**
+   * Tries to remove item from queue.
+   * @param item - Item to be removed from the queue
+   * @returns True if the item is found and removed or false otherwise
+   */
+  public remove(item: T): boolean {
+    if (!item) {
+      return false;
+    }
+
+    // To find node, go to bucket and search through unsorted list.
+    const bucketIndex = this._getBucketIndex(item);
+    const firstBucketNode = this._buckets[bucketIndex];
+    let node = firstBucketNode;
+    let prevNode: BucketNode<T>;
+
+    while (node !== null) {
+      if (this._areEqual(item, node.value)) {
+        break;
+      }
+
+      prevNode = node;
+      node = node.next;
+    }
+
+    // Item not found
+    if (node === null) {
+      return false;
+    }
+
+    // Item found and it needs to be removed from the list
+    if (node === firstBucketNode) {
+      this._buckets[bucketIndex] = node.next;
+    } else {
+      prevNode.next = node.next;
+    }
+
+    this._size--;
+    return true;
+  }
+
+  public isEmpty(): boolean {
+    return this._size === 0;
+  }
+
+  /**
+   * Return the bucket index
+   * @param item - Item for which the bucket shall be returned
+   * @returns Bucket index for the item provided
+   */
+  private _getBucketIndex(item): number {
+    return this._getPriority(item) & this._mask;
+  }
+
+  /**
+   * Create array and initialze pointers to null
+   * @param size - Size of the new array
+   * @returns An array with `N` buckets pointing to null
+   */
+  private _buildArray(size) {
+    const buckets = new Array(size);
+    buckets.fill(null);
+    return buckets;
+  }
+}

package/src/utilities/livewire/LiveWirePath.ts

@@ -0,0 +1,131 @@
+import { Types } from '@cornerstonejs/core';
+/**
+ * Path that contains points and control points to draw a path
+ * used by the livewire tool
+ */
+export class LivewirePath {
+  /**
+   * List of points.
+   */
+  public pointArray: Types.Point2[];
+
+  /**
+   * List of control points indexes
+   */
+  private _controlPointIndexes: number[];
+
+  /**
+   * @param inputPointArray - The list of Point2D that make the path (optional).
+   * @param inputControlPointIndexArray - The list of control point of path, as indexes (optional).
+   *   Note: first and last point do not need to be equal.
+   */
+  constructor(
+    inputPointArray?: Types.Point2[],
+    inputControlPointIndexArray?: number[]
+  ) {
+    this.pointArray = inputPointArray ? inputPointArray.slice() : [];
+    this._controlPointIndexes = inputControlPointIndexArray
+      ? inputControlPointIndexArray.slice()
+      : [];
+  }
+
+  /**
+   * Get a point of the list.
+   *
+   * @param index - The index of the point to get
+   * @returns The Point2D at the given index.
+   */
+  public getPoint(index: number): Types.Point2 {
+    return this.pointArray[index];
+  }
+
+  /**
+   * Get the last point of the list.
+   *
+   * @returns The last point of the list.
+   */
+  public getLastPoint(): Types.Point2 {
+    return this.pointArray[this.pointArray.length - 1];
+  }
+
+  /**
+   * Is the given point a control point.
+   *
+   * @param point - The 2D point to check.
+   * @returns True if a control point, false otherwise.
+   */
+  public isControlPoint(point: Types.Point2): boolean {
+    const index = this.pointArray.indexOf(point);
+    if (index !== -1) {
+      return this._controlPointIndexes.indexOf(index) !== -1;
+    } else {
+      throw new Error('Error: isControlPoint called with not in list point.');
+    }
+  }
+
+  /**
+   * Add a point to the path.
+   *
+   * @param point - The 2D point to add.
+   */
+  public addPoint(point: Types.Point2) {
+    this.pointArray.push(point);
+  }
+
+  /**
+   * Add a control point to the path.
+   *
+   * @param point - The 2D point to make a control point.
+   */
+  public addControlPoint(point: Types.Point2) {
+    const index = this.pointArray.indexOf(point);
+
+    if (index !== -1) {
+      this._controlPointIndexes.push(index);
+    } else {
+      throw new Error('Cannot mark a non registered point as control point.');
+    }
+  }
+
+  public getControlPoints() {
+    return this._controlPointIndexes.map((i) => this.pointArray[i]);
+  }
+
+  public getNumControlPoints(): number {
+    return this._controlPointIndexes.length;
+  }
+
+  public removeLastControlPoint(): void {
+    if (this._controlPointIndexes.length) {
+      this._controlPointIndexes.pop();
+    }
+  }
+
+  /**
+   * Add points to the path.
+   *
+   * @param newPointArray - The list of 2D points to add.
+   */
+  public addPoints(newPointArray: Types.Point2[]) {
+    this.pointArray = this.pointArray.concat(newPointArray);
+  }
+
+  /**
+   * Prepend a path to this one.
+   *
+   * @param other - The path to append.
+   */
+  public prependPath(other: LivewirePath): void {
+    const otherSize = other.pointArray.length;
+    const shiftedIndexArray: number[] = [];
+
+    this.pointArray = other.pointArray.concat(this.pointArray);
+
+    for (let i = 0; i < this._controlPointIndexes.length; ++i) {
+      shiftedIndexArray[i] = this._controlPointIndexes[i] + otherSize;
+    }
+
+    this._controlPointIndexes =
+      other._controlPointIndexes.concat(shiftedIndexArray);
+  }
+}