@cornerstonejs/tools 1.49.2 → 1.50.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.49.2",
+  "version": "1.50.0",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.49.2",
+    "@cornerstonejs/core": "^1.50.0",
     "comlink": "^4.4.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
@@ -53,5 +53,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "c405ce8a57e5e3d67fab7f1b02e105a6a689ae93"
+  "gitHead": "20550ac144790828fae0b1358e9cbcfcf7af6eb6"
 }

package/src/tools/annotation/EllipticalROITool.ts

@@ -1045,7 +1045,7 @@ class EllipticalROITool extends AnnotationTool {
 
       if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
         this.isHandleOutsideImage = false;
-        
+
         const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
         const iMax = Math.max(worldPos1Index[0], worldPos2Index[0]);
 

package/src/tools/annotation/LivewireContourTool.ts

@@ -22,22 +22,25 @@ import type {
   SVGDrawingHelper,
 } from '../../types';
 import { math, triggerAnnotationRenderForViewportIds } from '../../utilities';
+import findHandlePolylineIndex from '../../utilities/contours/findHandlePolylineIndex';
 import { LivewireContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
-import {
-  AnnotationCompletedEventDetail,
-  AnnotationModifiedEventDetail,
-} from '../../types/EventTypes';
+import { AnnotationModifiedEventDetail } from '../../types/EventTypes';
+import reverseIfAntiClockwise from '../../utilities/contours/reverseIfAntiClockwise';
 
 import { LivewireScissors } from '../../utilities/livewire/LivewireScissors';
 import { LivewirePath } from '../../utilities/livewire/LiveWirePath';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 
+const { isEqual } = csUtils;
+
 const CLICK_CLOSE_CURVE_SQR_DIST = 10 ** 2; // px
 
 class LivewireContourTool extends ContourSegmentationBaseTool {
   public static toolName: string;
   private scissors: LivewireScissors;
+  /** The scissors from the right handle, used for editing */
+  private scissorsRight: LivewireScissors;
 
   touchDragCallback: any;
   mouseDragCallback: any;
@@ -50,9 +53,12 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     lastCanvasPoint?: Types.Point2;
     confirmedPath?: LivewirePath;
     currentPath?: LivewirePath;
+    /** The next path segment, on the other side of the handle */
+    confirmedPathRight?: LivewirePath;
     closed?: boolean;
     worldToSlice?: (point: Types.Point3) => Types.Point2;
     sliceToWorld?: (point: Types.Point2) => Types.Point3;
+    originalPath?: Types.Point3[];
   } | null;
   isDrawing: boolean;
   isHandleOutsideImage = false;
@@ -69,23 +75,9 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     super(toolProps, defaultToolProps);
   }
 
-  /**
-   * Based on the current position of the mouse and the current imageId to create
-   * a CircleROI Annotation and stores it in the annotationManager
-   *
-   * @param evt -  EventTypes.NormalizedMouseEventType
-   * @returns The annotation object.
-   *
-   */
-  addNewAnnotation(
-    evt: EventTypes.InteractionEventType
-  ): LivewireContourAnnotation {
-    const eventDetail = evt.detail;
-    const { currentPoints, element } = eventDetail;
-    const { world: worldPos, canvas: canvasPos } = currentPoints;
-
+  protected setupBaseEditData(worldPos, element, annotation, rightPos?) {
     const enabledElement = getEnabledElement(element);
-    const { viewport, renderingEngine } = enabledElement;
+    const { viewport } = enabledElement;
 
     this.isDrawing = true;
 
@@ -157,40 +149,79 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
       height,
       voiRange
     );
+    if (rightPos) {
+      this.scissorsRight = LivewireScissors.createInstanceFromRawPixelData(
+        scalarData as Float32Array,
+        width,
+        height,
+        voiRange
+      );
+      this.scissorsRight.startSearch(worldToSlice(rightPos));
+    }
 
+    // Scissors always start at the startPos for both editing handles and
+    // for initial rendering
     this.scissors.startSearch(startPos);
 
+    const newAnnotation = !rightPos;
+
     const confirmedPath = new LivewirePath();
     const currentPath = new LivewirePath();
+    const currentPathNext = newAnnotation ? undefined : new LivewirePath();
 
     confirmedPath.addPoint(startPos);
     confirmedPath.addControlPoint(startPos);
 
-    const annotation = this.createAnnotation(evt) as LivewireContourAnnotation;
-
-    this.addAnnotation(annotation, element);
-
     const viewportIdsToRender = getViewportIdsWithToolToRender(
       element,
       this.getToolName()
     );
 
+    const lastCanvasPoint = viewport.worldToCanvas(worldPos);
+
     this.editData = {
       annotation,
       viewportIdsToRender,
-      newAnnotation: true,
+      newAnnotation,
       hasMoved: false,
-      lastCanvasPoint: canvasPos,
-      confirmedPath: confirmedPath,
-      currentPath: currentPath,
+      lastCanvasPoint,
+      confirmedPath,
+      currentPath,
+      confirmedPathRight: currentPathNext,
       closed: false,
+      handleIndex:
+        this.editData?.handleIndex ?? annotation.handles?.activeHandleIndex,
       worldToSlice,
       sliceToWorld,
     };
+  }
+
+  /**
+   * Based on the current position of the mouse and the current imageId to create
+   * a CircleROI Annotation and stores it in the annotationManager
+   *
+   * @param evt -  EventTypes.NormalizedMouseEventType
+   * @returns The annotation object.
+   *
+   */
+  addNewAnnotation(
+    evt: EventTypes.InteractionEventType
+  ): LivewireContourAnnotation {
+    const eventDetail = evt.detail;
+    const { currentPoints, element } = eventDetail;
+    const { world: worldPos } = currentPoints;
+    const { renderingEngine } = getEnabledElement(element);
+    const annotation = this.createAnnotation(evt) as LivewireContourAnnotation;
+
+    this.setupBaseEditData(worldPos, element, annotation);
+    this.addAnnotation(annotation, element);
 
     this._activateDraw(element);
     evt.preventDefault();
-    triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+    triggerAnnotationRenderForViewportIds(
+      renderingEngine,
+      this.editData.viewportIdsToRender
+    );
 
     return annotation;
   }
@@ -325,20 +356,37 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
       removeAnnotation(annotation.annotationUID);
     }
 
+    // Reverse the points if needed, ensuring both the handles and the
+    // polyline is also reversed.
+    const { worldToSlice } = this.editData;
+    if (worldToSlice) {
+      reverseIfAntiClockwise(
+        data.handles.points.map(worldToSlice),
+        data.handles.points,
+        data.contour.polyline
+      );
+    }
+
     triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
 
-    if (newAnnotation) {
-      const eventType = Events.ANNOTATION_COMPLETED;
-      const eventDetail: AnnotationCompletedEventDetail = {
-        annotation,
-        changeType: ChangeTypes.Completed,
-      };
+    const eventType = newAnnotation
+      ? Events.ANNOTATION_COMPLETED
+      : Events.ANNOTATION_MODIFIED;
+    const { viewportId, renderingEngineId } = enabledElement;
+    const eventDetailModified: AnnotationModifiedEventDetail = {
+      annotation,
+      viewportId,
+      renderingEngineId,
+      changeType: newAnnotation
+        ? ChangeTypes.Completed
+        : ChangeTypes.HandlesUpdated,
+    };
 
-      triggerEvent(eventTarget, eventType, eventDetail);
-    }
+    triggerEvent(eventTarget, eventType, eventDetailModified);
 
     this.editData = null;
     this.scissors = null;
+    this.scissorsRight = null;
     this.isDrawing = false;
   };
 
@@ -354,7 +402,8 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     const eventDetail = evt.detail;
     const { element } = eventDetail;
     const { currentPoints } = eventDetail;
-    const { canvas: canvasPos, world: worldPos } = currentPoints;
+    const { canvas: canvasPos, world: worldPosOriginal } = currentPoints;
+    let worldPos = worldPosOriginal;
     const enabledElement = getEnabledElement(element);
     const { viewport, renderingEngine } = enabledElement;
     const controlPoints = this.editData.currentPath.getControlPoints();
@@ -395,10 +444,27 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     this.editData.closed = this.editData.closed || closePath;
     this.editData.confirmedPath = this.editData.currentPath;
 
-    // Add the current cursor position as a new control point after clicking
-    this.editData.confirmedPath.addControlPoint(
-      this.editData.currentPath.getLastPoint()
+    const smoothPathCount = this.scissors.smoothPathCount(
+      this.editData.confirmedPath.pointArray,
+      this.editData.currentPath.getLastControlPoint()
     );
+    if (smoothPathCount) {
+      this.editData.currentPath.removeLastPoints(smoothPathCount);
+      annotation.data.contour.polyline.splice(
+        annotation.data.contour.polyline.length - smoothPathCount,
+        smoothPathCount
+      );
+      worldPos =
+        annotation.data.contour.polyline[
+          annotation.data.contour.polyline.length - 1
+        ];
+    }
+
+    // Add the current cursor position as a new control point after clicking
+    const lastPoint = this.editData.currentPath.getLastPoint();
+
+    this.editData.confirmedPath.addControlPoint(lastPoint);
+    annotation.data.handles.points.push(sliceToWorld(lastPoint));
 
     // Start a new search starting at the last control point
     this.scissors.startSearch(worldToSlice(worldPos));
@@ -442,10 +508,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
 
     const pathPoints = this.scissors.findPathToPoint(slicePoint);
     const currentPath = new LivewirePath();
-
-    for (let i = 0, len = pathPoints.length; i < len; i++) {
-      currentPath.addPoint(pathPoints[i]);
-    }
+    currentPath.addPoints(pathPoints);
 
     // Merge the "confirmed" path that goes from the first control point to the
     // last one with the current path that goes from the last control point to
@@ -459,38 +522,122 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     evt.preventDefault();
   };
 
+  public editHandle(
+    worldPos: Types.Point3,
+    element,
+    annotation,
+    handleIndex: number
+  ) {
+    const { data } = annotation;
+    const { points: handlePoints } = data.handles;
+    const { length: numHandles } = handlePoints;
+    const previousHandle =
+      handlePoints[(handleIndex - 1 + numHandles) % numHandles];
+    const nextHandle = handlePoints[(handleIndex + 1) % numHandles];
+
+    if (!this.editData?.confirmedPathRight) {
+      this.setupBaseEditData(previousHandle, element, annotation, nextHandle);
+      const { polyline } = data.contour;
+      const confirmedPath = new LivewirePath();
+      const confirmedPathRight = new LivewirePath();
+      const { worldToSlice } = this.editData;
+      const previousIndex = findHandlePolylineIndex(
+        annotation,
+        handleIndex - 1
+      );
+      const nextIndex = findHandlePolylineIndex(annotation, handleIndex + 1);
+      if (nextIndex === -1 || previousIndex === -1) {
+        throw new Error(
+          `Can't find handle index ${nextIndex === -1 && nextHandle} ${
+            previousIndex === -1 && previousHandle
+          }`
+        );
+      }
+      if (handleIndex === 0) {
+        // For this case, the next/previous indices are swapped, and the
+        // path data gets inserted in between the newly generated data, so
+        // handle this case specially
+        confirmedPathRight.addPoints(
+          polyline.slice(nextIndex + 1, previousIndex).map(worldToSlice)
+        );
+      } else if (nextIndex < previousIndex) {
+        throw new Error(
+          `Expected right index after left index, but were: ${previousIndex} ${nextIndex}`
+        );
+      } else {
+        confirmedPath.addPoints(
+          polyline.slice(0, previousIndex + 1).map(worldToSlice)
+        );
+        confirmedPathRight.addPoints(
+          polyline.slice(nextIndex, polyline.length).map(worldToSlice)
+        );
+      }
+      this.editData.confirmedPath = confirmedPath;
+      this.editData.confirmedPathRight = confirmedPathRight;
+    }
+    const { editData, scissors } = this;
+    const { worldToSlice, sliceToWorld } = editData;
+
+    const { activeHandleIndex } = data.handles;
+    if (activeHandleIndex === null || activeHandleIndex === undefined) {
+      data.handle.activeHandleIndex = handleIndex;
+    } else if (activeHandleIndex !== handleIndex) {
+      throw new Error(
+        `Trying to edit a different handle than the one currently being edited ${handleIndex}!==${data.handles.activeHandleIndex}`
+      );
+    }
+    const slicePos = worldToSlice(worldPos);
+    if (
+      slicePos[0] < 0 ||
+      slicePos[0] >= scissors.width ||
+      slicePos[1] < 0 ||
+      slicePos[1] >= scissors.height
+    ) {
+      // Find path to point hangs if the position is outside the image data
+      return;
+    }
+    handlePoints[handleIndex] = sliceToWorld(slicePos);
+
+    const pathPointsLeft = scissors.findPathToPoint(slicePos);
+    const pathPointsRight = this.scissorsRight.findPathToPoint(slicePos);
+    const currentPath = new LivewirePath();
+
+    // Merge the "confirmed" path that goes from the first control point to the
+    // last one with the current path that goes from the last control point to
+    // the cursor point
+    currentPath.prependPath(editData.confirmedPath);
+    if (handleIndex !== 0) {
+      currentPath.addPoints(pathPointsLeft);
+    }
+    currentPath.addPoints(pathPointsRight.reverse());
+    currentPath.appendPath(editData.confirmedPathRight);
+    if (handleIndex === 0) {
+      currentPath.addPoints(pathPointsLeft);
+    }
+
+    // Store the new path
+    editData.currentPath = currentPath;
+
+    annotation.invalidated = true;
+    editData.hasMoved = true;
+  }
+
   private _dragCallback = (evt: EventTypes.InteractionEventType): void => {
     this.isDrawing = true;
     const eventDetail = evt.detail;
     const { element } = eventDetail;
 
     const { annotation, viewportIdsToRender, handleIndex } = this.editData;
-    const { data } = annotation;
-
     if (handleIndex === undefined) {
-      // Drag mode - moving handle
-      const { deltaPoints } = eventDetail as EventTypes.MouseDragEventDetail;
-      const worldPosDelta = deltaPoints.world;
-
-      const points = data.contour.polyline;
-
-      points.forEach((point) => {
-        point[0] += worldPosDelta[0];
-        point[1] += worldPosDelta[1];
-        point[2] += worldPosDelta[2];
-      });
-      annotation.invalidated = true;
+      // Drag mode - moving object
+      console.warn('No drag implemented for livewire');
     } else {
       // Move mode - after double click, and mouse move to draw
       const { currentPoints } = eventDetail;
       const worldPos = currentPoints.world;
-
-      data.handles.points[handleIndex] = [...worldPos];
-      annotation.invalidated = true;
+      this.editHandle(worldPos, element, annotation, handleIndex);
     }
 
-    this.editData.hasMoved = true;
-
     const enabledElement = getEnabledElement(element);
     const { renderingEngine } = enabledElement;
 
@@ -644,26 +791,27 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     const { viewport } = enabledElement;
     const { worldToCanvas } = viewport;
     const annotation = renderContext.annotation as LivewireContourAnnotation;
-    const { annotationUID, data } = annotation;
+    const { annotationUID, data, highlighted } = annotation;
     const { handles } = data;
     const newAnnotation = this.editData?.newAnnotation;
     const { lineWidth, lineDash, color } = annotationStyle;
 
-    // Render the first control point only when the annotaion is drawn for the
+    // Render the first control point only when the annotation is drawn for the
     // first time to make it easier to know where the user needs to click to
     // to close the ROI.
     if (
-      newAnnotation &&
-      annotation.annotationUID === this.editData?.annotation?.annotationUID
+      highlighted ||
+      (newAnnotation &&
+        annotation.annotationUID === this.editData?.annotation?.annotationUID)
     ) {
       const handleGroupUID = '0';
-      const startPoint = worldToCanvas(handles.points[0]);
+      const canvasHandles = handles.points.map(worldToCanvas);
 
       drawHandlesSvg(
         svgDrawingHelper,
         annotationUID,
         handleGroupUID,
-        [startPoint],
+        canvasHandles,
         {
           color,
           lineDash,
@@ -686,9 +834,10 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
       return;
     }
 
+    const { annotation, sliceToWorld } = this.editData;
+
     const { pointArray: imagePoints } = livewirePath;
     const worldPolylinePoints: Types.Point3[] = [];
-    const { annotation, sliceToWorld } = this.editData;
 
     for (let i = 0, len = imagePoints.length; i < len; i++) {
       const imagePoint = imagePoints[i];

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -444,3 +444,5 @@ export interface VideoRedactionAnnotation extends Annotation {
     active: boolean;
   };
 }
+
+export type { ContourAnnotation };

package/src/utilities/contours/findHandlePolylineIndex.ts

@@ -0,0 +1,52 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+
+import { ContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+
+const { isEqual } = csUtils;
+
+/**
+ * Finds the index in the polyline of the specified handle.  If the handle
+ * doesn't match a polyline point, then finds the closest polyline point.
+ *
+ * Assumes polyline is in the same orientation as the handles.
+ *
+ * @param annotation - to find the polyline and handles in
+ * @param handleIndex - the index of hte handle to look for.
+ *     Negative values are treated relative to the end of the handle index.
+ * @returns Index in polyline of the closest handle
+ *     * 0 for handleIndex 0
+ *     * length for `handleIndex===handles length`
+ */
+export default function findHandlePolylineIndex(
+  annotation: ContourAnnotation,
+  handleIndex: number
+): number {
+  const { polyline } = annotation.data.contour;
+  const { points } = annotation.data.handles;
+  const { length } = points;
+  if (handleIndex === length) {
+    return polyline.length;
+  }
+  if (handleIndex < 0) {
+    handleIndex = (handleIndex + length) % length;
+  }
+  if (handleIndex === 0) {
+    return 0;
+  }
+  const handle = points[handleIndex];
+  const index = polyline.findIndex((point) => isEqual(handle, point));
+  if (index !== -1) {
+    return index;
+  }
+  // Need to find nearest
+  let closestDistance = Infinity;
+  return polyline.reduce((closestIndex, point, testIndex) => {
+    const distance = vec3.squaredDistance(point, handle);
+    if (distance < closestDistance) {
+      closestDistance = distance;
+      return testIndex;
+    }
+    return closestIndex;
+  }, -1);
+}

package/src/utilities/contours/index.ts

@@ -5,6 +5,7 @@ import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelm
 import AnnotationToPointData from './AnnotationToPointData';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
 import * as interpolation from './interpolation';
+import findHandlePolylineIndex from './findHandlePolylineIndex';
 
 export {
   contourFinder,
@@ -14,4 +15,5 @@ export {
   AnnotationToPointData,
   interpolation,
   acceptAutogeneratedInterpolations,
+  findHandlePolylineIndex,
 };

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

@@ -167,8 +167,9 @@ function _linearlyInterpolateContour(
   const handleCount = Math.round(
     Math.max(
       8,
-      interpolationData.get(startIndex)[0].data.handles.points.length * 2,
-      interpolationData.get(endIndex)[0].data.handles.points.length * 2
+      interpolationData.get(startIndex)[0].data.handles.points.length,
+      interpolationData.get(endIndex)[0].data.handles.points.length,
+      interpolated3DPoints.x.length / 50
     )
   );
   const handlePoints = _subselect(interpolated3DPoints, handleCount);

package/src/utilities/contours/reverseIfAntiClockwise.ts

@@ -1,24 +1,18 @@
 import { Types } from '@cornerstonejs/core';
 
-/**
- * getSumReducer - A reducer function that calculates the sum of an array.
- *
- * @param total - The running total.
- * @param num - The numerical value of the array element.
- * @returns The updated running total.
- */
-function getSumReducer(total: number, num: number): number {
-  return total + num;
-}
-
 /**
  * _reverseIfAntiClockwise - If the contour's nodes run anti-clockwise,
  * reverse them.
  *
  * @param points - The points array.
+ * @param otherListsToReverse - any number of additional lists to also reverse
+ *       when the primary list is anti-clockwise.
  * @returns The contour, corrected to be clockwise if appropriate.
  */
-export default function reverseIfAntiClockwise(points: Types.Point2[]) {
+export default function reverseIfAntiClockwise(
+  points: Types.Point2[],
+  ...otherListsToReverse: unknown[][]
+) {
   const length = points.length;
   if (!length) {
     return points;
@@ -43,7 +37,11 @@ export default function reverseIfAntiClockwise(points: Types.Point2[]) {
     }
   }
 
-  if (checkSum > 0) {
+  // Checksum will be less than zero for anti-clockwise
+  if (checkSum < 0) {
+    if (otherListsToReverse) {
+      otherListsToReverse.forEach((list) => list.reverse());
+    }
     return points.slice().reverse();
   }
   return points;

package/src/utilities/livewire/LiveWirePath.ts

@@ -101,6 +101,18 @@ export class LivewirePath {
     }
   }
 
+  public getLastControlPoint(): Types.Point2 {
+    if (this._controlPointIndexes.length) {
+      return this.pointArray[
+        this._controlPointIndexes[this._controlPointIndexes.length - 1]
+      ];
+    }
+  }
+
+  public removeLastPoints(count: number) {
+    this.pointArray.splice(this.pointArray.length - count, count);
+  }
+
   /**
    * Add points to the path.
    *
@@ -128,4 +140,16 @@ export class LivewirePath {
     this._controlPointIndexes =
       other._controlPointIndexes.concat(shiftedIndexArray);
   }
+
+  /**
+   * Append a path to this one.
+   *
+   * @param other - The path to append.
+   */
+  public appendPath(other: LivewirePath): void {
+    this.addPoints(other.pointArray);
+    other._controlPointIndexes.forEach((point) =>
+      this._controlPointIndexes.push(point)
+    );
+  }
 }