@cornerstonejs/tools 1.51.5 → 1.53.0

package/src/stateManagement/annotation/annotationState.ts

@@ -59,6 +59,81 @@ function getAnnotations(
   return manager.getAnnotations(groupKey, toolName) as Annotations;
 }
 
+/**
+ * Removes the association between the annotation passed as parameter and its
+ * parent in case it has one (eg: contour holes).
+ * @param annotation - Annotation
+ */
+function clearParentAnnotation(annotation: Annotation): void {
+  const { annotationUID: childUID, parentAnnotationUID } = annotation;
+
+  if (!parentAnnotationUID) {
+    return;
+  }
+
+  const parentAnnotation = getAnnotation(parentAnnotationUID);
+  const childUIDIndex = parentAnnotation.childAnnotationUIDs.indexOf(childUID);
+
+  parentAnnotation.childAnnotationUIDs.splice(childUIDIndex, 1);
+  annotation.parentAnnotationUID = undefined;
+}
+
+/**
+ * Creates a parent/child association between annotations.
+ * A annotation may have only one parent and multiple children (eg: a contour
+ * may have multiple holes in it).
+ * @param parentAnnotation - Parent annotation
+ * @param childAnnotation - Child annotation
+ */
+function addChildAnnotation(
+  parentAnnotation: Annotation,
+  childAnnotation: Annotation
+): void {
+  const { annotationUID: parentUID } = parentAnnotation;
+  const { annotationUID: childUID } = childAnnotation;
+
+  // Make sure it is not associated with any other tool
+  clearParentAnnotation(childAnnotation);
+
+  if (!parentAnnotation.childAnnotationUIDs) {
+    parentAnnotation.childAnnotationUIDs = [];
+  }
+
+  // Check if it is already a child
+  if (parentAnnotation.childAnnotationUIDs.includes(childUID)) {
+    return;
+  }
+
+  parentAnnotation.childAnnotationUIDs.push(childUID);
+  childAnnotation.parentAnnotationUID = parentUID;
+}
+
+/**
+ * Returns the parent annotation of a given one since annotations can be
+ * associated in a parent/child way (eg: polyline holes)
+ * @param annotation - Annotation
+ * @returns Parent annotation
+ */
+function getParentAnnotation(annotation: Annotation) {
+  return annotation.parentAnnotationUID
+    ? getAnnotation(annotation.parentAnnotationUID)
+    : undefined;
+}
+
+/**
+ * Returns all children annotation of a given one since annotations can be
+ * associated in a parent/child way (eg: polyline holes)
+ * @param annotation - Annotation
+ * @returns Child annotations
+ */
+function getChildAnnotations(annotation: Annotation) {
+  return (
+    annotation.childAnnotationUIDs?.map((childAnnotationUID) =>
+      getAnnotation(childAnnotationUID)
+    ) ?? []
+  );
+}
+
 /**
  * Add the annotation to the annotation manager along with the options that is
  * used to filter the annotation manager and the annotation group that
@@ -137,6 +212,11 @@ function removeAnnotation(annotationUID: string): void {
     return;
   }
 
+  // Remove all child annotations first
+  annotation.childAnnotationUIDs?.forEach((childAnnotationUID) =>
+    removeAnnotation(childAnnotationUID)
+  );
+
   manager.removeAnnotation(annotationUID);
 
   // trigger annotation removed
@@ -169,8 +249,28 @@ function removeAllAnnotations(): void {
   manager.removeAllAnnotations();
 }
 
+/**
+ * Invalidate current and all parent annotations (eg: contour holes)
+ * @param annotation - Annotation
+ */
+function invalidateAnnotation(annotation: Annotation): void {
+  let currAnnotation = annotation;
+
+  while (currAnnotation) {
+    currAnnotation.invalidated = true;
+
+    currAnnotation = currAnnotation.parentAnnotationUID
+      ? getAnnotation(currAnnotation.parentAnnotationUID)
+      : undefined;
+  }
+}
+
 export {
   getAnnotations,
+  getParentAnnotation,
+  getChildAnnotations,
+  clearParentAnnotation,
+  addChildAnnotation,
   getNumberOfAnnotations,
   addAnnotation,
   getAnnotation,
@@ -180,4 +280,5 @@ export {
   setAnnotationManager,
   getAnnotationManager,
   resetAnnotationManager,
+  invalidateAnnotation,
 };

package/src/stateManagement/annotation/helpers/state.ts

@@ -4,13 +4,14 @@ import {
   eventTarget,
   getEnabledElementByIds,
 } from '@cornerstonejs/core';
-import { Events } from '../../../enums';
+import { Events, ChangeTypes } from '../../../enums';
 import { Annotation } from '../../../types/AnnotationTypes';
 import { getToolGroupsWithToolName } from '../../../store/ToolGroupManager';
 import {
   AnnotationAddedEventDetail,
   AnnotationModifiedEventDetail,
   AnnotationCompletedEventDetail,
+  ContourAnnotationCompletedEventDetail,
 } from '../../../types/EventTypes';
 
 /**
@@ -85,7 +86,8 @@ function triggerAnnotationAddedForFOR(annotation: Annotation) {
  */
 function triggerAnnotationModified(
   annotation: Annotation,
-  element: HTMLDivElement
+  element: HTMLDivElement,
+  changeType = ChangeTypes.HandlesUpdated
 ): void {
   const enabledElement = getEnabledElement(element);
   const { viewportId, renderingEngineId } = enabledElement;
@@ -94,6 +96,7 @@ function triggerAnnotationModified(
     annotation,
     viewportId,
     renderingEngineId,
+    changeType,
   };
 
   triggerEvent(eventTarget, eventType, eventDetail);
@@ -103,11 +106,37 @@ function triggerAnnotationModified(
  * Triggers an annotation completed event.
  */
 function triggerAnnotationCompleted(annotation: Annotation): void {
-  const eventType = Events.ANNOTATION_COMPLETED;
   const eventDetail: AnnotationCompletedEventDetail = {
     annotation,
   };
 
+  _triggerAnnotationCompleted(eventDetail);
+}
+
+/**
+ * Triggers an annotation completed event for contours (same annotation completed
+ * event but with more specific details).
+ */
+function triggerContourAnnotationCompleted(
+  annotation: Annotation,
+  contourHoleProcessingEnabled = false
+): void {
+  const eventDetail: ContourAnnotationCompletedEventDetail = {
+    annotation,
+    contourHoleProcessingEnabled,
+  };
+
+  _triggerAnnotationCompleted(eventDetail);
+}
+
+/**
+ * Triggers an annotation completed event for the `detail` provided
+ * @param eventDetail - Event detail
+ */
+function _triggerAnnotationCompleted(
+  eventDetail: AnnotationCompletedEventDetail
+) {
+  const eventType = Events.ANNOTATION_COMPLETED;
   triggerEvent(eventTarget, eventType, eventDetail);
 }
 
@@ -116,4 +145,5 @@ export {
   triggerAnnotationAddedForFOR,
   triggerAnnotationModified,
   triggerAnnotationCompleted,
+  triggerContourAnnotationCompleted,
 };

package/src/stateManagement/index.js

@@ -9,10 +9,15 @@ import {
   addAnnotation,
   removeAnnotation,
   getAnnotation,
+  getParentAnnotation,
+  getChildAnnotations,
+  clearParentAnnotation,
+  addChildAnnotation,
   getNumberOfAnnotations,
   setAnnotationManager,
   getAnnotationManager,
   resetAnnotationManager,
+  invalidateAnnotation,
 } from './annotation/annotationState';
 
 import {
@@ -31,9 +36,14 @@ export {
   getNumberOfAnnotations,
   removeAnnotation,
   getAnnotation,
+  getParentAnnotation,
+  getChildAnnotations,
+  clearParentAnnotation,
+  addChildAnnotation,
   setAnnotationManager,
   getAnnotationManager,
   resetAnnotationManager,
+  invalidateAnnotation,
   // segmentations
   addSegmentationRepresentations,
   removeSegmentationsFromToolGroup,

package/src/store/ToolGroupManager/ToolGroup.ts

@@ -418,8 +418,14 @@ export default class ToolGroup implements IToolGroup {
    * - Renders data if the tool has a `renderAnnotation` method.
    *
    * @param toolName - tool name
+   * @param options - Options used when setting the tool as passive
+   *  - removeAllBindings: only the primary button bindings are removed but
+   *  if this parameter is set to true all bindings are removed.
    */
-  public setToolPassive(toolName: string): void {
+  public setToolPassive(
+    toolName: string,
+    options?: { removeAllBindings?: boolean }
+  ): void {
     const toolInstance = this._toolInstances[toolName];
 
     if (toolInstance === undefined) {
@@ -448,7 +454,8 @@ export default class ToolGroup implements IToolGroup {
     // Remove the primary button bindings without modifiers, if they exist
     toolOptions.bindings = toolOptions.bindings.filter(
       (binding) =>
-        binding.mouseButton !== defaultMousePrimary || binding.modifierKey
+        options?.removeAllBindings !== true &&
+        (binding.mouseButton !== defaultMousePrimary || binding.modifierKey)
     );
     // If there are other bindings, set the tool to be active
     let mode = Passive;

package/src/tools/SegmentationIntersectionTool.ts

@@ -146,7 +146,7 @@ class SegmentationIntersectionTool extends AnnotationDisplayTool {
           color: color,
           fillColor: color,
           fillOpacity: this.configuration.opacity,
-          connectLastToFirst: true,
+          closePath: true,
         };
 
         const polyLineUID = actorEntry.uid + '#' + polyLineIdx;

package/src/tools/annotation/LivewireContourSegmentationTool.ts

@@ -1,8 +1,159 @@
+import type { Types } from '@cornerstonejs/core';
+import { utilities as csUtils } from '@cornerstonejs/core';
+
 import LivewireContourTool from './LivewireContourTool';
+import { LivewirePath } from '../../utilities/livewire/LiveWirePath';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
+import { ChangeTypes } from '../../enums';
+import type { ContourSegmentationAnnotation } from '../../types';
+import { drawPolyline as drawPolylineSvg } from '../../drawingSvg';
 
 class LivewireContourSegmentationTool extends LivewireContourTool {
   static toolName;
 
+  /**
+   * Updates the interpolated annotations with the currently displayed image data,
+   * performing hte livewire on the image data as generated.
+   * Note - this function is only called for interpolated livewire SEGMENTATION
+   * objects, and will return immediately otherwise.
+   *
+   * The work for the interpolation is performed in a microtask, enabling this
+   * method to return quickly for faster render speeds, but ensuring that the
+   * annotation data isn't updated before the changes are performed.  The removes
+   * some irritating flickering on navigation.
+   */
+  public updateInterpolatedAnnotation(
+    annotation: ContourSegmentationAnnotation,
+    enabledElement: Types.IEnabledElement
+  ) {
+    // The interpolation sources is used as a flag here - a true livewire
+    // behaviour would be to perform a livewire between the two planes
+    // closest to this plane for each point, and use that handle.  That is
+    // oblique, however, which is not currently supported.
+    if (
+      this.editData ||
+      !annotation.invalidated ||
+      !annotation.data.handles.interpolationSources
+    ) {
+      return;
+    }
+    annotation.data.contour.originalPolyline = annotation.data.contour.polyline;
+
+    // See docs above for why this is a microtask
+    queueMicrotask(() => {
+      if (!annotation.data.handles.interpolationSources) {
+        return;
+      }
+      const { points } = annotation.data.handles;
+
+      const { element } = enabledElement.viewport;
+      this.setupBaseEditData(points[0], element, annotation);
+      const { length: count } = points;
+      const { scissors } = this;
+      const { nearestEdge, repeatInterpolation } =
+        this.configuration.interpolation;
+      annotation.data.handles.originalPoints = points;
+      const { worldToSlice, sliceToWorld } = this.editData;
+      const handleSmoothing = [];
+
+      // New path generation - go through the handles and regenerate the polyline
+      if (nearestEdge) {
+        let lastPoint = worldToSlice(points[points.length - 1]);
+        // Nearest edge handling
+        points.forEach((point, hIndex) => {
+          const testPoint = worldToSlice(point);
+          lastPoint = testPoint;
+          handleSmoothing.push(testPoint);
+
+          // Fill the costs buffer and then find the minimum cost
+          // This is a little too aggressive about pulling the line in
+          scissors.startSearch(lastPoint);
+          scissors.findPathToPoint(testPoint);
+          // Fill the costs for a point a bit further along by searching for a
+          // point further along.
+          scissors.findPathToPoint(
+            worldToSlice(points[(hIndex + 3) % points.length])
+          );
+          const minPoint = scissors.findMinNearby(testPoint, nearestEdge);
+          if (!csUtils.isEqual(testPoint, minPoint)) {
+            handleSmoothing[hIndex] = minPoint;
+            lastPoint = minPoint;
+            points[hIndex] = sliceToWorld(minPoint);
+          }
+        });
+      }
+
+      // Regenerate the updated data based on the updated handles
+      const acceptedPath = new LivewirePath();
+      for (let i = 0; i < count; i++) {
+        scissors.startSearch(worldToSlice(points[i]));
+        const path = scissors.findPathToPoint(
+          worldToSlice(points[(i + 1) % count])
+        );
+        acceptedPath.addPoints(path);
+      }
+
+      // Now, update the rendering
+      this.updateAnnotation(acceptedPath);
+      this.scissors = null;
+      this.scissorsRight = null;
+      this.editData = null;
+      annotation.data.handles.interpolationSources = null;
+
+      if (repeatInterpolation) {
+        triggerAnnotationModified(
+          annotation,
+          enabledElement.viewport.element,
+          ChangeTypes.InterpolationUpdated
+        );
+      }
+    });
+  }
+
+  /**
+   * Adds the update to the interpolated annotaiton on render an instance,
+   * but otherwise just calls the parent render annotation instance.
+   */
+  protected renderAnnotationInstance(renderContext): boolean {
+    const { enabledElement, svgDrawingHelper } = renderContext;
+    const annotation =
+      renderContext.annotation as ContourSegmentationAnnotation;
+    const { annotationUID } = annotation;
+    const { viewport } = enabledElement;
+    const { worldToCanvas } = viewport;
+    const { showInterpolationPolyline } =
+      this.configuration.interpolation || {};
+
+    this.updateInterpolatedAnnotation?.(annotation, enabledElement);
+    const { originalPolyline } = annotation.data.contour;
+
+    const rendered = super.renderAnnotationInstance(renderContext);
+
+    if (
+      showInterpolationPolyline &&
+      originalPolyline &&
+      annotation.autoGenerated
+    ) {
+      const polylineCanvasPoints = originalPolyline.map(
+        worldToCanvas
+      ) as Types.Point2[];
+      polylineCanvasPoints.push(polylineCanvasPoints[0]);
+      drawPolylineSvg(
+        svgDrawingHelper,
+        annotationUID,
+        'interpolationContour-0',
+        polylineCanvasPoints,
+        {
+          color: '#70ffff',
+          lineWidth: 1,
+          fillOpacity: 0,
+        }
+      );
+    }
+
+    return rendered;
+  }
+
   protected isContourSegmentationTool(): boolean {
     // Re-enable contour segmentation behavior disabled by LivewireContourTool
     return true;