@cornerstonejs/tools 1.52.0 → 1.53.0

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

@@ -11,6 +11,7 @@ import {
   AnnotationAddedEventDetail,
   AnnotationModifiedEventDetail,
   AnnotationCompletedEventDetail,
+  ContourAnnotationCompletedEventDetail,
 } from '../../../types/EventTypes';
 
 /**
@@ -105,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);
 }
 
@@ -118,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

@@ -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/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.

package/src/tools/annotation/SplineROITool.ts

@@ -6,7 +6,10 @@ import {
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
-import { removeAnnotation } from '../../stateManagement/annotation/annotationState';
+import {
+  getChildAnnotations,
+  removeAnnotation,
+} from '../../stateManagement/annotation/annotationState';
 import {
   drawHandles as drawHandlesSvg,
   drawPolyline as drawPolylineSvg,
@@ -37,13 +40,15 @@ import {
   getCalibratedScale,
   getCalibratedAreaUnits,
 } from '../../utilities';
+import getMouseModifierKey from '../../eventDispatchers/shared/getMouseModifier';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 
-import { SplineROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
-import {
-  AnnotationCompletedEventDetail,
+import { ContourWindingDirection } from '../../types/ContourAnnotation';
+import type { SplineROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type {
   AnnotationModifiedEventDetail,
+  ContourAnnotationCompletedEventDetail,
 } from '../../types/EventTypes';
 import { ISpline } from '../../types/ISpline';
 import { CardinalSpline } from './splines/CardinalSpline';
@@ -51,7 +56,7 @@ import { LinearSpline } from './splines/LinearSpline';
 import { CatmullRomSpline } from './splines/CatmullRomSpline';
 import { BSpline } from './splines/BSpline';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
-import reverseIfAntiClockwise from '../../utilities/contours/reverseIfAntiClockwise';
+import updateContourPolyline from '../../utilities/contours/updateContourPolyline';
 
 const SPLINE_MIN_POINTS = 3;
 const SPLINE_CLICK_CLOSE_CURVE_DIST = 10;
@@ -93,12 +98,14 @@ class SplineROITool extends ContourSegmentationBaseTool {
     newAnnotation?: boolean;
     hasMoved?: boolean;
     lastCanvasPoint?: Types.Point2;
+    contourHoleProcessingEnabled?: boolean;
   } | null;
   isDrawing: boolean;
   isHandleOutsideImage = false;
   fireChangeOnUpdate: {
     annotationUID: string;
     changeType: ChangeTypes;
+    contourHoleProcessingEnabled: boolean;
   } = null;
 
   constructor(
@@ -109,6 +116,11 @@ class SplineROITool extends ContourSegmentationBaseTool {
         preventHandleOutsideImage: false,
         calculateStats: true,
         getTextLines: defaultGetTextLines,
+        /**
+         * 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,
         spline: {
           configuration: {
             [SplineTypesEnum.Cardinal]: {
@@ -176,6 +188,9 @@ class SplineROITool extends ContourSegmentationBaseTool {
     const eventDetail = evt.detail;
     const { currentPoints, element } = eventDetail;
     const { canvas: canvasPos } = currentPoints;
+    const contourHoleProcessingEnabled =
+      getMouseModifierKey(evt.detail.event) ===
+      this.configuration.contourHoleAdditionModifierKey;
 
     const enabledElement = getEnabledElement(element);
     const { renderingEngine } = enabledElement;
@@ -196,6 +211,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
       newAnnotation: true,
       hasMoved: false,
       lastCanvasPoint: canvasPos,
+      contourHoleProcessingEnabled,
     };
 
     this._activateDraw(element);
@@ -303,7 +319,12 @@ class SplineROITool 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;
     annotation.autoGenerated = false;
 
@@ -338,6 +359,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
       changeType: newAnnotation
         ? ChangeTypes.Completed
         : ChangeTypes.HandlesUpdated,
+      contourHoleProcessingEnabled,
     };
 
     triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
@@ -466,14 +488,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
       const { deltaPoints } = eventDetail as EventTypes.MouseDragEventDetail;
       const worldPosDelta = deltaPoints.world;
 
-      const points = data.handles.points;
-
-      points.forEach((point) => {
-        point[0] += worldPosDelta[0];
-        point[1] += worldPosDelta[1];
-        point[2] += worldPosDelta[2];
-      });
-      annotation.invalidated = true;
+      this.moveAnnotation(annotation, worldPosDelta);
     } else {
       // Move mode - after double click, and mouse move to draw
       const { currentPoints } = eventDetail;
@@ -522,11 +537,15 @@ class SplineROITool extends ContourSegmentationBaseTool {
   /**
    * Triggers an annotation completed event.
    */
-  triggerAnnotationCompleted = (annotation: SplineROIAnnotation): void => {
+  triggerAnnotationCompleted = (
+    annotation: SplineROIAnnotation,
+    contourHoleProcessingEnabled: boolean
+  ): void => {
     const eventType = Events.ANNOTATION_COMPLETED;
-    const eventDetail: AnnotationCompletedEventDetail = {
+    const eventDetail: ContourAnnotationCompletedEventDetail = {
       annotation,
       changeType: ChangeTypes.Completed,
+      contourHoleProcessingEnabled,
     };
 
     triggerEvent(eventTarget, eventType, eventDetail);
@@ -558,10 +577,11 @@ class SplineROITool extends ContourSegmentationBaseTool {
   triggerChangeEvent = (
     annotation: SplineROIAnnotation,
     enabledElement: Types.IEnabledElement,
-    changeType = ChangeTypes.StatsUpdated
+    changeType = ChangeTypes.StatsUpdated,
+    contourHoleProcessingEnabled
   ): void => {
     if (changeType === ChangeTypes.Completed) {
-      this.triggerAnnotationCompleted(annotation);
+      this.triggerAnnotationCompleted(annotation, contourHoleProcessingEnabled);
     } else {
       this.triggerAnnotationModified(annotation, enabledElement, changeType);
     }
@@ -658,15 +678,32 @@ class SplineROITool extends ContourSegmentationBaseTool {
     const { drawPreviewEnabled } = this.configuration.spline;
     const splineType = annotation.data.spline.type;
     const splineConfig = this._getSplineConfig(splineType);
-    const spline = this._updateSplineInstance(element, annotation);
-    const splinePolylineCanvas = reverseIfAntiClockwise(
-      spline.getPolylinePoints()
-    );
-    const splinePolylineWorld = splinePolylineCanvas.map((point2) =>
-      viewport.canvasToWorld(point2)
-    );
+    const spline = annotation.data.spline.instance;
 
-    data.contour.polyline = splinePolylineWorld;
+    // Update current and all child annotations/splines
+    if (annotation.invalidated) {
+      const splineAnnotationsGroup = [
+        annotation,
+        ...getChildAnnotations(annotation),
+      ].filter((annotation) =>
+        this._isSplineROIAnnotation(annotation)
+      ) as SplineROIAnnotation[];
+
+      splineAnnotationsGroup.forEach((annotation) => {
+        const spline = this._updateSplineInstance(element, annotation);
+        const splinePolylineCanvas = spline.getPolylinePoints();
+
+        updateContourPolyline(
+          annotation,
+          {
+            points: splinePolylineCanvas,
+            closed: data.contour.closed,
+            targetWindingDirection: ContourWindingDirection.Clockwise,
+          },
+          viewport
+        );
+      });
+    }
 
     // Let the base class render the contour
     super.renderAnnotationInstance(renderContext);
@@ -768,7 +805,8 @@ class SplineROITool extends ContourSegmentationBaseTool {
       this.triggerChangeEvent(
         annotation,
         enabledElement,
-        this.fireChangeOnUpdate.changeType
+        this.fireChangeOnUpdate.changeType,
+        this.fireChangeOnUpdate.contourHoleProcessingEnabled
       );
       this.fireChangeOnUpdate = null;
     }
@@ -990,6 +1028,12 @@ class SplineROITool extends ContourSegmentationBaseTool {
     );
   };
 
+  _isSplineROIAnnotation(
+    annotation: Annotation
+  ): annotation is SplineROIAnnotation {
+    return !!(<SplineROIAnnotation>annotation).data?.spline;
+  }
+
   /**
    * Get a spline config merged with the default settings.
    * @param type - Spline type (CARDINAL, CATMULLROM, LINEAR or BSPLINE)
@@ -1019,7 +1063,10 @@ class SplineROITool extends ContourSegmentationBaseTool {
     spline.closed = !!data.contour.closed;
 
     // Update spline resolution in case it has changed
-    if (spline.resolution !== splineConfig.resolution) {
+    if (
+      !spline.fixedResolution &&
+      spline.resolution !== splineConfig.resolution
+    ) {
       spline.resolution = parseInt(splineConfig.resolution);
       annotation.invalidated = true;
     }

package/src/tools/annotation/planarFreehandROITool/closedContourEditLoop.ts

@@ -7,14 +7,16 @@ import {
   resetElementCursor,
   hideElementCursor,
 } from '../../../cursors/elementCursor';
-import { EventTypes } from '../../../types';
+import type { EventTypes } from '../../../types';
 import { polyline } from '../../../utilities/math';
-import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import { ContourWindingDirection } from '../../../types/ContourAnnotation';
+import type { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 import {
   getInterpolatedPoints,
   shouldSmooth,
 } from '../../../utilities/planarFreehandROITool/smoothPoints';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
+import updateContourPolyline from '../../../utilities/contours/updateContourPolyline';
 import { triggerAnnotationModified } from '../../../stateManagement/annotation/helpers/state';
 
 const { getSubPixelSpacingAndXYDirections, addCanvasPointsToArray, getArea } =
@@ -223,12 +225,16 @@ function finishEditAndStartNewEdit(evt: EventTypes.InteractionEventType): void {
   const { annotation, viewportIdsToRender } = this.commonData;
   const { fusedCanvasPoints, editCanvasPoints } = this.editData;
 
-  const worldPoints = fusedCanvasPoints.map((canvasPoint) =>
-    viewport.canvasToWorld(canvasPoint)
+  updateContourPolyline(
+    annotation,
+    {
+      points: fusedCanvasPoints,
+      closed: true,
+      targetWindingDirection: ContourWindingDirection.Clockwise,
+    },
+    viewport
   );
 
-  annotation.data.contour.polyline = worldPoints;
-  annotation.data.contour.closed = true;
   // If any manual update, triggered on an annotation, then it will be treated as non-autogenerated.
   if (annotation.autoGenerated) {
     annotation.autoGenerated = false;
@@ -446,12 +452,15 @@ function completeClosedContourEdit(element: HTMLDivElement) {
         )
       : fusedCanvasPoints;
 
-    const worldPoints = updatedPoints.map((canvasPoint) =>
-      viewport.canvasToWorld(canvasPoint)
+    updateContourPolyline(
+      annotation,
+      {
+        points: updatedPoints,
+        closed: true,
+        targetWindingDirection: ContourWindingDirection.Clockwise,
+      },
+      viewport
     );
-    annotation.data.contour.polyline = worldPoints;
-    annotation.data.contour.closed = true;
-    annotation.invalidated = true;
 
     // If any manual update, triggered on an annotation, then it will be treated as non-autogenerated.
     if (annotation.autoGenerated) {