@cornerstonejs/tools 1.52.0 → 1.54.0

package/src/stateManagement/segmentation/segmentIndex.ts

@@ -21,6 +21,11 @@ function setActiveSegmentIndex(
 ): void {
   const segmentation = getSegmentation(segmentationId);
 
+  if (typeof segmentIndex === 'string') {
+    console.warn('segmentIndex is a string, converting to number');
+    segmentIndex = Number(segmentIndex);
+  }
+
   if (segmentation?.activeSegmentIndex !== segmentIndex) {
     segmentation.activeSegmentIndex = segmentIndex;
 

package/src/stateManagement/segmentation/segmentationState.ts

@@ -97,6 +97,65 @@ function getAllSegmentationRepresentations(): Record<
   return segmentationStateManager.getAllSegmentationRepresentations();
 }
 
+/**
+ * Finds all segmentation representations with the given segmentationId.
+ * @param segmentationId - The ID of the segmentation.
+ * @returns An array of found segmentation representations.
+ */
+function getSegmentationIdRepresentations(segmentationId) {
+  const allRepresentations = getAllSegmentationRepresentations() || {};
+  const foundRepresentations = [];
+
+  for (const toolGroupId in allRepresentations) {
+    const toolGroupRepresentations = allRepresentations[toolGroupId];
+
+    const foundRepresentation = toolGroupRepresentations.find(
+      (representation) => representation.segmentationId === segmentationId
+    );
+
+    if (foundRepresentation) {
+      foundRepresentations.push(foundRepresentation);
+    }
+  }
+
+  return foundRepresentations;
+}
+
+/**
+ * Finds a segmentation representation by its UID.
+ *
+ * @param segmentationRepresentationUID - The UID of the segmentation representation to find.
+ * @returns The found segmentation representation, or undefined if not found.
+ */
+function findSegmentationRepresentationByUID(
+  segmentationRepresentationUID: string
+): {
+  toolGroupId: string;
+  segmentationRepresentation: ToolGroupSpecificRepresentation;
+} {
+  const allToolGroupRepresentations = getAllSegmentationRepresentations() || [];
+
+  const toolGroupIds = Object.keys(allToolGroupRepresentations);
+
+  for (const toolGroupId of toolGroupIds) {
+    const toolGroupRepresentations =
+      getAllSegmentationRepresentations()[toolGroupId];
+
+    const foundRepresentation = toolGroupRepresentations.find(
+      (representation) =>
+        representation.segmentationRepresentationUID ===
+        segmentationRepresentationUID
+    );
+
+    if (foundRepresentation) {
+      return {
+        segmentationRepresentation: foundRepresentation,
+        toolGroupId,
+      };
+    }
+  }
+}
+
 /**
  * Get the tool group IDs that have a segmentation representation with the given
  * segmentationId
@@ -445,9 +504,12 @@ export {
   getToolGroupIdsWithSegmentation,
   getAllSegmentationRepresentations,
   getSegmentationRepresentationByUID,
+  getSegmentationIdRepresentations,
   // color
   addColorLUT,
   getColorLUT,
   getNextColorLUTIndex,
   removeColorLUT,
+  //
+  findSegmentationRepresentationByUID,
 };

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/ScaleOverlayTool.ts

@@ -139,7 +139,10 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
 
       addAnnotation(newAnnotation, viewport.element);
       annotation = newAnnotation;
-    } else if (this.editData.annotation && this.editData.annotation.data.viewportId == viewport.id) {
+    } else if (
+      this.editData.annotation &&
+      this.editData.annotation.data.viewportId == viewport.id
+    ) {
       this.editData.annotation.data.handles.points =
         viewportCanvasCornersInWorld;
       this.editData.annotation.data.viewportId = viewport.id;

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

@@ -94,7 +94,7 @@ class LivewireContourSegmentationTool extends LivewireContourTool {
       }
 
       // Now, update the rendering
-      this.updateAnnotation(element, acceptedPath);
+      this.updateAnnotation(acceptedPath);
       this.scissors = null;
       this.scissorsRight = null;
       this.editData = null;

package/src/tools/annotation/LivewireContourTool.ts

@@ -9,7 +9,7 @@ import type { Types } from '@cornerstonejs/core';
 import { removeAnnotation } from '../../stateManagement/annotation/annotationState';
 import { drawHandles as drawHandlesSvg } from '../../drawingSvg';
 import { state } from '../../store';
-import { Events, ChangeTypes } from '../../enums';
+import { Events, KeyboardBindings, ChangeTypes } from '../../enums';
 import { resetElementCursor } from '../../cursors/elementCursor';
 import type {
   EventTypes,
@@ -18,19 +18,21 @@ import type {
   ToolProps,
   SVGDrawingHelper,
 } from '../../types';
+import getMouseModifierKey from '../../eventDispatchers/shared/getMouseModifier';
 import { math, triggerAnnotationRenderForViewportIds } from '../../utilities';
 import findHandlePolylineIndex from '../../utilities/contours/findHandlePolylineIndex';
 import { LivewireContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import { ContourWindingDirection } from '../../types/ContourAnnotation';
 import {
   triggerAnnotationModified,
-  triggerAnnotationCompleted,
+  triggerContourAnnotationCompleted,
 } from '../../stateManagement/annotation/helpers/state';
-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';
+import updateContourPolyline from '../../utilities/contours/updateContourPolyline';
 
 const CLICK_CLOSE_CURVE_SQR_DIST = 10 ** 2; // px
 
@@ -57,6 +59,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     worldToSlice?: (point: Types.Point3) => Types.Point2;
     sliceToWorld?: (point: Types.Point2) => Types.Point3;
     originalPath?: Types.Point3[];
+    contourHoleProcessingEnabled?: boolean;
   } | null;
   isDrawing: boolean;
   isHandleOutsideImage = false;
@@ -67,6 +70,12 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
       supportedInteractionTypes: ['Mouse', 'Touch'],
       configuration: {
         preventHandleOutsideImage: false,
+        /**
+         * Specify which modifier key is used to add a hole to a contour. The
+         * modifier must be pressed when the first point of a new contour is added.
+         */
+        contourHoleAdditionModifierKey: KeyboardBindings.Shift,
+
         /**
          * Configuring this to a value larger than 0 will snap handles to nearby
          * livewire points, within the given rectangle surrounding the clicked point.
@@ -115,7 +124,13 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     super(toolProps, defaultToolProps);
   }
 
-  protected setupBaseEditData(worldPos, element, annotation, rightPos?) {
+  protected setupBaseEditData(
+    worldPos,
+    element,
+    annotation,
+    rightPos?,
+    contourHoleProcessingEnabled?
+  ) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
 
@@ -233,6 +248,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         this.editData?.handleIndex ?? annotation.handles?.activeHandleIndex,
       worldToSlice,
       sliceToWorld,
+      contourHoleProcessingEnabled,
     };
   }
 
@@ -252,8 +268,17 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     const { world: worldPos } = currentPoints;
     const { renderingEngine } = getEnabledElement(element);
     const annotation = this.createAnnotation(evt);
+    const contourHoleProcessingEnabled =
+      getMouseModifierKey(evt.detail.event) ===
+      this.configuration.contourHoleAdditionModifierKey;
 
-    this.setupBaseEditData(worldPos, element, annotation);
+    this.setupBaseEditData(
+      worldPos,
+      element,
+      annotation,
+      undefined,
+      contourHoleProcessingEnabled
+    );
     this.addAnnotation(annotation, element);
 
     this._activateDraw(element);
@@ -379,7 +404,12 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     const eventDetail = evt.detail;
     const { element } = eventDetail;
 
-    const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
+    const {
+      annotation,
+      viewportIdsToRender,
+      newAnnotation,
+      contourHoleProcessingEnabled,
+    } = this.editData;
     const { data } = annotation;
 
     data.handles.activeHandleIndex = null;
@@ -406,24 +436,18 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
       return;
     }
 
-    // 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);
 
     const changeType = newAnnotation
       ? ChangeTypes.Completed
       : ChangeTypes.HandlesUpdated;
 
-    this.triggerChangeEvent(annotation, enabledElement, changeType);
+    this.triggerChangeEvent(
+      annotation,
+      enabledElement,
+      changeType,
+      contourHoleProcessingEnabled
+    );
     this.clearEditData();
   };
 
@@ -440,10 +464,14 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
   triggerChangeEvent = (
     annotation: LivewireContourAnnotation,
     enabledElement: Types.IEnabledElement,
-    changeType = ChangeTypes.StatsUpdated
+    changeType = ChangeTypes.StatsUpdated,
+    contourHoleProcessingEnabled = false
   ): void => {
     if (changeType === ChangeTypes.Completed) {
-      triggerAnnotationCompleted(annotation);
+      triggerContourAnnotationCompleted(
+        annotation,
+        contourHoleProcessingEnabled
+      );
     } else {
       triggerAnnotationModified(
         annotation,
@@ -536,7 +564,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
 
     if (this.editData.closed) {
       // Update the annotation because `editData` will be set to null
-      this.updateAnnotation(element, this.editData.confirmedPath);
+      this.updateAnnotation(this.editData.confirmedPath);
       this._endCallback(evt);
     }
 
@@ -787,11 +815,8 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     enabledElement: Types.IEnabledElement,
     svgDrawingHelper: SVGDrawingHelper
   ): boolean {
-    const { viewport } = enabledElement;
-    const { element } = viewport;
-
     // Update the annotation that is in editData (being edited)
-    this.updateAnnotation(element, this.editData?.currentPath);
+    this.updateAnnotation(this.editData?.currentPath);
 
     return super.renderAnnotation(enabledElement, svgDrawingHelper);
   }
@@ -885,27 +910,29 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
     return true;
   }
 
-  protected updateAnnotation(_, livewirePath: LivewirePath) {
+  protected updateAnnotation(livewirePath: LivewirePath) {
     if (!this.editData || !livewirePath) {
       return;
     }
 
     const { annotation, sliceToWorld } = this.editData;
+    let { pointArray: imagePoints } = livewirePath;
 
-    const { pointArray: imagePoints } = livewirePath;
-    const worldPolylinePoints: Types.Point3[] = [];
-
-    for (let i = 0, len = imagePoints.length; i < len; i++) {
-      const imagePoint = imagePoints[i];
-      const worldPoint = sliceToWorld(imagePoint);
-      worldPolylinePoints.push(worldPoint);
+    if (imagePoints.length > 1) {
+      imagePoints = [...imagePoints, imagePoints[0]];
     }
 
-    if (worldPolylinePoints.length > 1) {
-      worldPolylinePoints.push([...worldPolylinePoints[0]]);
-    }
-
-    annotation.data.contour.polyline = worldPolylinePoints;
+    updateContourPolyline(
+      annotation,
+      {
+        points: imagePoints,
+        closed: annotation.data.contour.closed,
+        targetWindingDirection: ContourWindingDirection.Clockwise,
+      },
+      {
+        canvasToWorld: sliceToWorld,
+      }
+    );
   }
 }
 

package/src/tools/annotation/PlanarFreehandContourSegmentationTool.ts

@@ -1,8 +1,6 @@
-import type { SplineContourSegmentationAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import { utilities } from '@cornerstonejs/core';
-import type { PublicToolProps, AnnotationRenderContext } from '../../types';
+import type { PublicToolProps } from '../../types';
 import PlanarFreehandROITool from './PlanarFreehandROITool';
-import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 
 class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool {
   static toolName;
@@ -30,25 +28,6 @@ class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool {
     // Re-enable contour segmentation behavior disabled by PlanarFreehandROITool
     return true;
   }
-
-  protected renderAnnotationInstance(
-    renderContext: AnnotationRenderContext
-  ): boolean {
-    const { annotation } = renderContext;
-    const { invalidated } = annotation;
-    const renderResult = super.renderAnnotationInstance(renderContext);
-
-    // Trigger the event only for invalid annotations
-    if (invalidated) {
-      const { segmentationId } = (<SplineContourSegmentationAnnotation>(
-        annotation
-      )).data.segmentation;
-
-      triggerSegmentationDataModified(segmentationId);
-    }
-
-    return renderResult;
-  }
 }
 
 PlanarFreehandContourSegmentationTool.toolName =

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -46,7 +46,7 @@ import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScale
 import { getModalityUnit } from '../../utilities/getModalityUnit';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
-import { ChangeTypes } from '../../enums';
+import { KeyboardBindings, ChangeTypes } from '../../enums';
 
 const { pointCanProjectOnLine } = polyline;
 const { EPSILON } = CONSTANTS;
@@ -178,6 +178,11 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
       configuration: {
         shadow: true,
         preventHandleOutsideImage: false,
+        /**
+         * Specify which modifier key is used to add a hole to a contour. The
+         * modifier must be pressed when the first point of a new contour is added.
+         */
+        contourHoleAdditionModifierKey: KeyboardBindings.Shift,
         alwaysRenderOpenContourHandles: {
           // When true, always render end points when you have an open contour, rather
           // than just rendering a line.
@@ -505,7 +510,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
   }
 
   protected isContourSegmentationTool(): boolean {
-    // Disable contour segmenatation behavior because it shall be activated only
+    // Disable contour segmentation behavior because it shall be activated only
     // for PlanarFreehandContourSegmentationTool
     return false;
   }
@@ -534,8 +539,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
   protected renderAnnotationInstance(
     renderContext: AnnotationRenderContext
   ): boolean {
-    const { enabledElement, targetId, svgDrawingHelper, annotationStyle } =
-      renderContext;
+    const { enabledElement, targetId, svgDrawingHelper } = renderContext;
     const annotation = renderContext.annotation as PlanarFreehandROIAnnotation;
 
     let renderStatus = false;
@@ -659,7 +663,6 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     enabledElement
   ) => {
     const { data } = annotation;
-    const { element } = viewport;
     const { cachedStats } = data;
     const { polyline: points } = data.contour;
 

package/src/tools/annotation/ProbeTool.ts

@@ -425,6 +425,10 @@ class ProbeTool extends AnnotationTool {
 
       const { color } = this.getAnnotationStyle({ annotation, styleSpecifier });
 
+      if (!data.cachedStats) {
+        data.cachedStats = {};
+      }
+
       if (
         !data.cachedStats[targetId] ||
         data.cachedStats[targetId].value == null