@cornerstonejs/tools 2.0.0-beta.5 → 2.0.0-beta.7

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

@@ -1,3 +1,4 @@
+import { vec3, vec2 } from 'gl-matrix';
 import { getEnabledElement } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import { state } from '../../../store';
@@ -6,21 +7,20 @@ import {
   resetElementCursor,
   hideElementCursor,
 } from '../../../cursors/elementCursor';
-import { EventTypes } from '../../../types';
+import type { EventTypes } from '../../../types';
 import { polyline } from '../../../utilities/math';
-import { vec3, vec2 } from 'gl-matrix';
-import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import { ContourWindingDirection } from '../../../types/ContourAnnotation';
+import type { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 import {
   getInterpolatedPoints,
-  shouldInterpolate,
-} from '../../../utilities/planarFreehandROITool/interpolatePoints';
+  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,
-  calculateAreaOfPoints,
-} = polyline;
+const { getSubPixelSpacingAndXYDirections, addCanvasPointsToArray, getArea } =
+  polyline;
 
 /**
  * Activates the closed contour edit event loop.
@@ -36,9 +36,15 @@ function activateClosedContourEdit(
   const { currentPoints, element } = eventDetail;
   const canvasPos = currentPoints.canvas;
   const enabledElement = getEnabledElement(element);
+  if (!enabledElement) {
+    // Occurs on shutdown
+    return;
+  }
   const { viewport } = enabledElement;
 
-  const prevCanvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+  const prevCanvasPoints = annotation.data.contour.polyline.map(
+    viewport.worldToCanvas
+  );
 
   const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(
     viewport,
@@ -219,14 +225,22 @@ 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.polyline = worldPoints;
-  annotation.data.isOpenContour = false;
+  // If any manual update, triggered on an annotation, then it will be treated as non-autogenerated.
+  if (annotation.autoGenerated) {
+    annotation.autoGenerated = false;
+  }
 
-  this.triggerAnnotationModified(annotation, enabledElement);
+  triggerAnnotationModified(annotation, element);
 
   const lastEditCanvasPoint = editCanvasPoints.pop();
 
@@ -398,8 +412,8 @@ function fuseEditPointsWithClosedContour(
     }
   }
 
-  const areaPointSet1 = calculateAreaOfPoints(pointSet1);
-  const areaPointSet2 = calculateAreaOfPoints(pointSet2);
+  const areaPointSet1 = getArea(pointSet1);
+  const areaPointSet2 = getArea(pointSet2);
 
   const pointsToRender: Types.Point2[] =
     areaPointSet1 > areaPointSet2 ? pointSet1 : pointSet2;
@@ -430,7 +444,7 @@ function completeClosedContourEdit(element: HTMLDivElement) {
   const { fusedCanvasPoints, prevCanvasPoints } = this.editData;
 
   if (fusedCanvasPoints) {
-    const updatedPoints = shouldInterpolate(this.configuration)
+    const updatedPoints = shouldSmooth(this.configuration, annotation)
       ? getInterpolatedPoints(
           this.configuration,
           fusedCanvasPoints,
@@ -438,15 +452,30 @@ function completeClosedContourEdit(element: HTMLDivElement) {
         )
       : fusedCanvasPoints;
 
-    const worldPoints = updatedPoints.map((canvasPoint) =>
-      viewport.canvasToWorld(canvasPoint)
+    const decimateConfig = this.configuration?.decimate || {};
+
+    updateContourPolyline(
+      annotation,
+      {
+        points: updatedPoints,
+        closed: true,
+        targetWindingDirection: ContourWindingDirection.Clockwise,
+      },
+      viewport,
+      {
+        decimate: {
+          enabled: !!decimateConfig.enabled,
+          epsilon: decimateConfig.epsilon,
+        },
+      }
     );
-    annotation.data.polyline = worldPoints;
-    annotation.data.isOpenContour = false;
 
-    annotation.invalidated = true;
+    // If any manual update, triggered on an annotation, then it will be treated as non-autogenerated.
+    if (annotation.autoGenerated) {
+      annotation.autoGenerated = false;
+    }
 
-    this.triggerAnnotationModified(annotation, enabledElement);
+    triggerAnnotationModified(annotation, element);
   }
 
   this.isEditingClosed = false;

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

@@ -1,5 +1,4 @@
-import { getEnabledElement } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import {
   resetElementCursor,
   hideElementCursor,
@@ -9,19 +8,22 @@ import { EventTypes } from '../../../types';
 import { state } from '../../../store';
 import { vec3 } from 'gl-matrix';
 import {
-  shouldInterpolate,
+  shouldSmooth,
   getInterpolatedPoints,
-} from '../../../utilities/planarFreehandROITool/interpolatePoints';
+} from '../../../utilities/planarFreehandROITool/smoothPoints';
+import getMouseModifierKey from '../../../eventDispatchers/shared/getMouseModifier';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
+import { triggerContourAnnotationCompleted } from '../../../stateManagement/annotation/helpers/state';
 import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
 import { polyline } from '../../../utilities/math';
 import { removeAnnotation } from '../../../stateManagement/annotation/annotationState';
+import { ContourWindingDirection } from '../../../types/ContourAnnotation';
 
 const {
   addCanvasPointsToArray,
   pointsAreWithinCloseContourProximity,
-  getFirstIntersectionWithPolyline,
+  getFirstLineSegmentIntersectionIndexes,
   getSubPixelSpacingAndXYDirections,
 } = polyline;
 
@@ -40,6 +42,9 @@ function activateDraw(
   const canvasPos = currentPoints.canvas;
   const enabledElement = getEnabledElement(element);
   const { viewport } = enabledElement;
+  const contourHoleProcessingEnabled =
+    getMouseModifierKey(evt.detail.event) ===
+    this.configuration.contourHoleAdditionModifierKey;
 
   const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(
     viewport,
@@ -49,6 +54,7 @@ function activateDraw(
   this.drawData = {
     canvasPoints: [canvasPos],
     polylineIndex: 0,
+    contourHoleProcessingEnabled,
   };
 
   this.commonData = {
@@ -170,7 +176,7 @@ function mouseDragDrawCallback(evt: EventTypes.InteractionEventType): void {
  */
 function mouseUpDrawCallback(evt: EventTypes.InteractionEventType): void {
   const { allowOpenContours } = this.configuration;
-  const { canvasPoints } = this.drawData;
+  const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
   const firstPoint = canvasPoints[0];
   const lastPoint = canvasPoints[canvasPoints.length - 1];
   const eventDetail = evt.detail;
@@ -184,18 +190,30 @@ function mouseUpDrawCallback(evt: EventTypes.InteractionEventType): void {
       this.configuration.closeContourProximity
     )
   ) {
-    this.completeDrawOpenContour(element);
+    this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
   } else {
-    this.completeDrawClosedContour(element);
+    this.completeDrawClosedContour(element, { contourHoleProcessingEnabled });
   }
 }
 
 /**
  * Completes the contour being drawn, creating a closed contour annotation. It will return true if contour is completed or false in case contour drawing is halted.
  */
-function completeDrawClosedContour(element: HTMLDivElement): boolean {
+function completeDrawClosedContour(
+  element: HTMLDivElement,
+  options: {
+    contourHoleProcessingEnabled: boolean;
+    minPointsToSave: number;
+  }
+): boolean {
   this.removeCrossedLinesOnCompleteDraw();
+
   const { canvasPoints } = this.drawData;
+  const { contourHoleProcessingEnabled, minPointsToSave } = options ?? {};
+
+  if (minPointsToSave && canvasPoints.length < minPointsToSave) {
+    return false;
+  }
 
   // check and halt if necessary the drawing process, last chance to complete drawing and fire events.
   if (this.haltDrawing(element, canvasPoints)) {
@@ -216,23 +234,24 @@ function completeDrawClosedContour(element: HTMLDivElement): boolean {
   // Remove last point which will be a duplicate now.
   canvasPoints.pop();
 
-  const updatedPoints = shouldInterpolate(this.configuration)
+  const updatedPoints = shouldSmooth(this.configuration, annotation)
     ? getInterpolatedPoints(this.configuration, canvasPoints)
     : canvasPoints;
 
-  // Note: -> This is pretty expensive and may not scale well with hundreds of
-  // contours. A future optimisation if we use this for segmentation is to re-do
-  // this rendering with the GPU rather than SVG.
-  const worldPoints = updatedPoints.map((canvasPoint) =>
-    viewport.canvasToWorld(canvasPoint)
+  this.updateContourPolyline(
+    annotation,
+    {
+      points: updatedPoints,
+      closed: true,
+      targetWindingDirection: ContourWindingDirection.Clockwise,
+    },
+    viewport
   );
 
-  annotation.data.polyline = worldPoints;
-  annotation.data.isOpenContour = false;
   const { textBox } = annotation.data.handles;
 
-  if (!textBox.hasMoved) {
-    this.triggerAnnotationCompleted(annotation);
+  if (!textBox?.hasMoved) {
+    triggerContourAnnotationCompleted(annotation, contourHoleProcessingEnabled);
   }
 
   this.isDrawing = false;
@@ -257,7 +276,7 @@ function removeCrossedLinesOnCompleteDraw(): void {
   const endToStart = [canvasPoints[0], canvasPoints[numPoints - 1]];
   const canvasPointsMinusEnds = canvasPoints.slice(0, -1).slice(1);
 
-  const lineSegment = getFirstIntersectionWithPolyline(
+  const lineSegment = getFirstLineSegmentIntersectionIndexes(
     canvasPointsMinusEnds,
     endToStart[0],
     endToStart[1],
@@ -267,15 +286,27 @@ function removeCrossedLinesOnCompleteDraw(): void {
   if (lineSegment) {
     const indexToRemoveUpTo = lineSegment[1];
 
-    this.drawData.canvasPoints = canvasPoints.splice(0, indexToRemoveUpTo);
+    // It is better to remove the last point when the user just moved the mouse
+    // cursor back than deleting the entire contour
+    if (indexToRemoveUpTo === 1) {
+      this.drawData.canvasPoints = canvasPoints.splice(1);
+    } else {
+      this.drawData.canvasPoints = canvasPoints.splice(0, indexToRemoveUpTo);
+    }
   }
 }
 
 /**
  * Completes the contour being drawn, creating an open contour annotation. It will return true if contour is completed or false in case contour drawing is halted.
  */
-function completeDrawOpenContour(element: HTMLDivElement): boolean {
+function completeDrawOpenContour(
+  element: HTMLDivElement,
+  options: {
+    contourHoleProcessingEnabled: boolean;
+  }
+): boolean {
   const { canvasPoints } = this.drawData;
+  const { contourHoleProcessingEnabled } = options ?? {};
 
   // check and halt if necessary the drawing process, last chance to complete drawing and fire events.
   if (this.haltDrawing(element, canvasPoints)) {
@@ -286,20 +317,25 @@ function completeDrawOpenContour(element: HTMLDivElement): boolean {
   const enabledElement = getEnabledElement(element);
   const { viewport, renderingEngine } = enabledElement;
 
-  const updatedPoints = shouldInterpolate(this.configuration)
+  const updatedPoints = shouldSmooth(this.configuration, annotation)
     ? getInterpolatedPoints(this.configuration, canvasPoints)
     : canvasPoints;
 
   // Note: -> This is pretty expensive and may not scale well with hundreds of
   // contours. A future optimisation if we use this for segmentation is to re-do
   // this rendering with the GPU rather than SVG.
-  const worldPoints = updatedPoints.map((canvasPoint) =>
-    viewport.canvasToWorld(canvasPoint)
+
+  this.updateContourPolyline(
+    annotation,
+    {
+      points: updatedPoints,
+      closed: false,
+    },
+    viewport
   );
 
-  annotation.data.polyline = worldPoints;
-  annotation.data.isOpenContour = true;
   const { textBox } = annotation.data.handles;
+  const worldPoints = annotation.data.contour.polyline;
 
   // Add the first and last points to the list of handles. These means they
   // will render handles on mouse hover.
@@ -315,7 +351,7 @@ function completeDrawOpenContour(element: HTMLDivElement): boolean {
   }
 
   if (!textBox.hasMoved) {
-    this.triggerAnnotationCompleted(annotation);
+    triggerContourAnnotationCompleted(annotation, contourHoleProcessingEnabled);
   }
 
   this.isDrawing = false;
@@ -345,7 +381,7 @@ function findCrossingIndexDuringCreate(
   const { canvasPoints } = this.drawData;
   const pointsLessLastOne = canvasPoints.slice(0, -1);
 
-  const lineSegment = getFirstIntersectionWithPolyline(
+  const lineSegment = getFirstLineSegmentIntersectionIndexes(
     pointsLessLastOne,
     canvasPos,
     lastCanvasPoint,
@@ -371,7 +407,7 @@ function applyCreateOnCross(
 ): void {
   const eventDetail = evt.detail;
   const { element } = eventDetail;
-  const { canvasPoints } = this.drawData;
+  const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
   const { annotation, viewportIdsToRender } = this.commonData;
 
   // Add points between the end point and crossing point
@@ -384,12 +420,24 @@ function applyCreateOnCross(
   // Remove last point which will be a duplicate now.
   canvasPoints.pop();
 
-  // Remove points up to just before the crossing index
-  for (let i = 0; i < crossingIndex; i++) {
-    canvasPoints.shift();
+  const remainingPoints = canvasPoints.slice(crossingIndex);
+  const newArea = polyline.getArea(remainingPoints);
+
+  // User just moved the mouse back and the last points must be removed
+  // otherwise the entire contour drawn would be lost.
+  if (utilities.isEqual(newArea, 0)) {
+    canvasPoints.splice(crossingIndex + 1);
+    return;
   }
 
-  if (this.completeDrawClosedContour(element)) {
+  canvasPoints.splice(0, crossingIndex);
+
+  // There is no contour with less than 3 points.
+  // It's possible to have a contour with very few points after removing
+  // crossed lines which is not enough to save as a contour.
+  const options = { contourHoleProcessingEnabled, minPointsToSave: 3 };
+
+  if (this.completeDrawClosedContour(element, options)) {
     // pos complete operation
     this.activateClosedContourEdit(evt, annotation, viewportIdsToRender);
   }
@@ -400,7 +448,7 @@ function applyCreateOnCross(
  */
 function cancelDrawing(element: HTMLElement) {
   const { allowOpenContours } = this.configuration;
-  const { canvasPoints } = this.drawData;
+  const { canvasPoints, contourHoleProcessingEnabled } = this.drawData;
   const firstPoint = canvasPoints[0];
   const lastPoint = canvasPoints[canvasPoints.length - 1];
 
@@ -412,9 +460,9 @@ function cancelDrawing(element: HTMLElement) {
       this.configuration.closeContourProximity
     )
   ) {
-    this.completeDrawOpenContour(element);
+    this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
   } else {
-    this.completeDrawClosedContour(element);
+    this.completeDrawClosedContour(element, { contourHoleProcessingEnabled });
   }
 }
 

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

@@ -3,7 +3,8 @@ import { vec2 } from 'gl-matrix';
 import { polyline } from '../../../utilities/math';
 import { EventTypes } from '../../../types';
 
-const { addCanvasPointsToArray, getFirstIntersectionWithPolyline } = polyline;
+const { addCanvasPointsToArray, getFirstLineSegmentIntersectionIndexes } =
+  polyline;
 
 /**
  * Check if the `editCanvasPoints` have crossed the `prevCanvasPoints` during
@@ -28,7 +29,7 @@ function checkForFirstCrossing(
   const lastCanvasPoint = lastPoints.canvas;
   const { editCanvasPoints, prevCanvasPoints } = this.editData;
 
-  const crossedLineSegment = getFirstIntersectionWithPolyline(
+  const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(
     prevCanvasPoints,
     canvasPos,
     lastCanvasPoint,
@@ -91,7 +92,7 @@ function checkForFirstCrossing(
       ];
 
       const crossedLineSegmentFromExtendedPoint =
-        getFirstIntersectionWithPolyline(
+        getFirstLineSegmentIntersectionIndexes(
           prevCanvasPoints,
           extendedPoint,
           editCanvasPoints[0],
@@ -133,7 +134,7 @@ function removePointsUpUntilFirstCrossing(isClosedContour: boolean): void {
   for (let i = 0; i < editCanvasPoints.length - 1; i++) {
     const firstLine = [editCanvasPoints[i], editCanvasPoints[i + 1]];
 
-    const didCrossLine = !!getFirstIntersectionWithPolyline(
+    const didCrossLine = !!getFirstLineSegmentIntersectionIndexes(
       prevCanvasPoints,
       firstLine[0],
       firstLine[1],
@@ -173,7 +174,7 @@ function checkForSecondCrossing(
   // for the second crossing of the prevCanvasPoints, by checking if the last
   // mouse drag crossed these. This class method is only called if the edit loop
   // has already has a crossing earlier in the edit.
-  const crossedLineSegment = getFirstIntersectionWithPolyline(
+  const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(
     prevCanvasPoints,
     canvasPos,
     lastCanvasPoint,
@@ -199,7 +200,7 @@ function removePointsAfterSecondCrossing(isClosedContour: boolean): void {
   for (let i = editCanvasPoints.length - 1; i > 0; i--) {
     const lastLine = [editCanvasPoints[i], editCanvasPoints[i - 1]];
 
-    const didCrossLine = !!getFirstIntersectionWithPolyline(
+    const didCrossLine = !!getFirstLineSegmentIntersectionIndexes(
       prevCanvasPoints,
       lastLine[0],
       lastLine[1],
@@ -255,7 +256,7 @@ function findSnapIndex(): number {
     const snapCanvasPosition = prevCanvasPoints[index];
     const lastEditCanvasPoint = editCanvasPoints[editCanvasPoints.length - 1];
 
-    const crossedLineSegment = getFirstIntersectionWithPolyline(
+    const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(
       editCanvasPointsLessLastOne,
       snapCanvasPosition,
       lastEditCanvasPoint,
@@ -290,7 +291,7 @@ function checkAndRemoveCrossesOnEditLine(
 
   const editCanvasPointsLessLastOne = editCanvasPoints.slice(0, -2);
 
-  const crossedLineSegment = getFirstIntersectionWithPolyline(
+  const crossedLineSegment = getFirstLineSegmentIntersectionIndexes(
     editCanvasPointsLessLastOne,
     canvasPos,
     lastCanvasPoint,

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

@@ -68,7 +68,9 @@ export function findOpenUShapedContourVectorToPeakOnRender(
   annotation: PlanarFreehandROIAnnotation
 ): Types.Point3[] {
   const { viewport } = enabledElement;
-  const canvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+  const canvasPoints = annotation.data.contour.polyline.map(
+    viewport.worldToCanvas
+  );
 
   return findOpenUShapedContourVectorToPeak(canvasPoints, viewport);
 }

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

@@ -1,3 +1,4 @@
+import { vec3, vec2 } from 'gl-matrix';
 import { getEnabledElement } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import { state } from '../../../store';
@@ -6,15 +7,17 @@ import {
   resetElementCursor,
   hideElementCursor,
 } from '../../../cursors/elementCursor';
-import type { EventTypes, Annotation } from '../../../types';
-import { vec3, vec2 } from 'gl-matrix';
+import type { EventTypes } from '../../../types';
+import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 import { polyline } from '../../../utilities/math';
 import {
-  shouldInterpolate,
+  shouldSmooth,
   getInterpolatedPoints,
-} from '../../../utilities/planarFreehandROITool/interpolatePoints';
+} from '../../../utilities/planarFreehandROITool/smoothPoints';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
+import { updateContourPolyline } from '../../../utilities/contours';
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
+import { triggerAnnotationModified } from '../../../stateManagement/annotation/helpers/state';
 
 const { addCanvasPointsToArray, getSubPixelSpacingAndXYDirections } = polyline;
 
@@ -23,7 +26,7 @@ const { addCanvasPointsToArray, getSubPixelSpacingAndXYDirections } = polyline;
  */
 function activateOpenContourEdit(
   evt: EventTypes.InteractionEventType,
-  annotation: Annotation,
+  annotation: PlanarFreehandROIAnnotation,
   viewportIdsToRender: string[]
 ): void {
   this.isEditingOpen = true;
@@ -34,7 +37,9 @@ function activateOpenContourEdit(
   const enabledElement = getEnabledElement(element);
   const { viewport } = enabledElement;
 
-  const prevCanvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+  const prevCanvasPoints = annotation.data.contour.polyline.map(
+    viewport.worldToCanvas
+  );
 
   const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(
     viewport,
@@ -209,12 +214,17 @@ function openContourEditOverwriteEnd(
   const { annotation, viewportIdsToRender } = this.commonData;
   const fusedCanvasPoints = this.fuseEditPointsForOpenContourEndEdit();
 
-  const worldPoints = fusedCanvasPoints.map((canvasPoint) =>
-    viewport.canvasToWorld(canvasPoint)
+  updateContourPolyline(
+    annotation,
+    {
+      points: fusedCanvasPoints,
+      closed: false,
+    },
+    viewport
   );
 
-  annotation.data.polyline = worldPoints;
-  annotation.data.isOpenContour = true;
+  const worldPoints = annotation.data.contour.polyline;
+
   // Note: Contours generate from fusedCanvasPoints will be in the direction
   // with the last point being the current mouse position
   annotation.data.handles.points = [
@@ -223,7 +233,7 @@ function openContourEditOverwriteEnd(
   ];
   annotation.data.handles.activeHandleIndex = 1;
 
-  this.triggerAnnotationModified(annotation, enabledElement);
+  triggerAnnotationModified(annotation, element);
 
   this.isEditingOpen = false;
   this.editData = undefined;
@@ -491,18 +501,23 @@ function finishEditOpenOnSecondCrossing(
   const { annotation, viewportIdsToRender } = this.commonData;
   const { fusedCanvasPoints, editCanvasPoints } = this.editData;
 
-  const worldPoints = fusedCanvasPoints.map((canvasPoint) =>
-    viewport.canvasToWorld(canvasPoint)
+  updateContourPolyline(
+    annotation,
+    {
+      points: fusedCanvasPoints,
+      closed: false,
+    },
+    viewport
   );
 
-  annotation.data.polyline = worldPoints;
-  annotation.data.isOpenContour = true;
+  const worldPoints = annotation.data.contour.polyline;
+
   annotation.data.handles.points = [
     worldPoints[0],
     worldPoints[worldPoints.length - 1],
   ];
 
-  this.triggerAnnotationModified(annotation, enabledElement);
+  triggerAnnotationModified(annotation, element);
 
   const lastEditCanvasPoint = editCanvasPoints.pop();
 
@@ -539,7 +554,7 @@ function completeOpenContourEdit(element: HTMLDivElement) {
   const { fusedCanvasPoints, prevCanvasPoints } = this.editData;
 
   if (fusedCanvasPoints) {
-    const updatedPoints = shouldInterpolate(this.configuration)
+    const updatedPoints = shouldSmooth(this.configuration)
       ? getInterpolatedPoints(
           this.configuration,
           fusedCanvasPoints,
@@ -547,11 +562,25 @@ function completeOpenContourEdit(element: HTMLDivElement) {
         )
       : fusedCanvasPoints;
 
-    const worldPoints = updatedPoints.map((canvasPoint) =>
-      viewport.canvasToWorld(canvasPoint)
+    const decimateConfig = this.configuration?.decimate || {};
+
+    updateContourPolyline(
+      annotation,
+      {
+        points: updatedPoints,
+        closed: false,
+      },
+      viewport,
+      {
+        decimate: {
+          enabled: !!decimateConfig.enabled,
+          epsilon: decimateConfig.epsilon,
+        },
+      }
     );
-    annotation.data.polyline = worldPoints;
-    annotation.data.isOpenContour = true;
+
+    const worldPoints = annotation.data.contour.polyline;
+
     annotation.data.handles.points = [
       worldPoints[0],
       worldPoints[worldPoints.length - 1],
@@ -563,9 +592,7 @@ function completeOpenContourEdit(element: HTMLDivElement) {
         findOpenUShapedContourVectorToPeak(fusedCanvasPoints, viewport);
     }
 
-    annotation.invalidated = true;
-
-    this.triggerAnnotationModified(annotation, enabledElement);
+    triggerAnnotationModified(annotation, element);
   }
 
   this.isEditingOpen = false;

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

@@ -8,6 +8,7 @@ import type {
   ToolHandle,
   TextBoxHandle,
 } from '../../../types';
+import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 import { polyline } from '../../../utilities/math';
 
 const { getSubPixelSpacingAndXYDirections } = polyline;
@@ -18,7 +19,7 @@ const { getSubPixelSpacingAndXYDirections } = polyline;
  */
 function activateOpenContourEndEdit(
   evt: EventTypes.InteractionEventType,
-  annotation: Annotation,
+  annotation: PlanarFreehandROIAnnotation,
   viewportIdsToRender: string[],
   handle: ToolHandle | null
 ): void {
@@ -34,7 +35,9 @@ function activateOpenContourEndEdit(
     this.configuration.subPixelResolution
   );
 
-  const canvasPoints = annotation.data.polyline.map(viewport.worldToCanvas);
+  const canvasPoints = annotation.data.contour.polyline.map(
+    viewport.worldToCanvas
+  );
   const handleIndexGrabbed = annotation.data.handles.activeHandleIndex;
 
   // If 0, invert point direction, if 1, keep point direction the same.
@@ -44,7 +47,7 @@ function activateOpenContourEndEdit(
   }
 
   let movingTextBox = false;
-  if ((handle as TextBoxHandle).worldPosition) {
+  if ((handle as TextBoxHandle)?.worldPosition) {
     movingTextBox = true;
   }