Remove annotations after operation

Author: rodrigobasilio2022

packages/tools/examples/logicalOperators/index.ts

@@ -124,11 +124,12 @@ const contourToolsNames = [
 let selectedToolName = contourToolsNames[0];
 
 const segmentIndices = [1, 2, 3, 4, 5];
-let sourceSegmentIndex = segmentIndices[0];
-let targetSegmentIndex = segmentIndices[1];
+let firstSegmentIndex = segmentIndices[0];
+let secondSegmentIndex = segmentIndices[1];
+let outputSegmentIndex = segmentIndices[0];
 
 addDropdownToToolbar({
-  labelText: 'Active segment',
+  labelText: 'Drawing segment',
   options: { values: segmentIndices, defaultValue: segmentIndices[0] },
   onSelectedValueChange: (nameAsStringOrNumber) => {
     const segmentIndex = Number(nameAsStringOrNumber);
@@ -158,10 +159,10 @@ addDropdownToToolbar({
 });
 
 addDropdownToToolbar({
-  labelText: 'Source segment',
+  labelText: 'First segment',
   options: { values: segmentIndices, defaultValue: segmentIndices[0] },
   onSelectedValueChange: (nameAsStringOrNumber) => {
-    sourceSegmentIndex = Number(nameAsStringOrNumber);
+    firstSegmentIndex = Number(nameAsStringOrNumber);
   },
 });
 
@@ -189,55 +190,57 @@ addDropdownToToolbar({
         selectedOperation = LogicalOperation.Delete;
         break;
     }
-    // Enable/disable the target segment dropdown based on operation
-    const targetDropdown = document.getElementById(
-      'targetSegmentIndex'
+    // Enable/disable the second segment dropdown based on operation
+    const secondDropdown = document.getElementById(
+      'secondSegmentIndex'
     ) as HTMLSelectElement | null;
-    if (targetDropdown) {
+    if (secondDropdown) {
       if (
         selectedOperation === LogicalOperation.Copy ||
         selectedOperation === LogicalOperation.Delete
       ) {
-        targetDropdown.disabled = true;
+        secondDropdown.disabled = true;
       } else {
-        targetDropdown.disabled = false;
+        secondDropdown.disabled = false;
       }
     }
-    // Enable/disable the "Apply operation and create new segment" button for Copy/Delete
-    const applyAndCreateNewSegmentBtn = document.getElementById(
-      'applyAndCreateNewSegment'
-    ) as HTMLButtonElement | null;
-    if (applyAndCreateNewSegmentBtn) {
+
+    // Enable/disable the output segment dropdown based on operation
+    const outputDropDown = document.getElementById(
+      'outputSegmentIndex'
+    ) as HTMLSelectElement | null;
+    if (outputDropDown) {
       if (selectedOperation === LogicalOperation.Delete) {
-        applyAndCreateNewSegmentBtn.disabled = true;
+        outputDropDown.disabled = true;
       } else {
-        applyAndCreateNewSegmentBtn.disabled = false;
+        outputDropDown.disabled = false;
       }
     }
   },
 });
 
 addDropdownToToolbar({
-  id: 'targetSegmentIndex',
-  labelText: 'Target segment',
+  id: 'secondSegmentIndex',
+  labelText: 'Second segment',
   options: { values: segmentIndices, defaultValue: segmentIndices[1] },
   onSelectedValueChange: (nameAsStringOrNumber) => {
-    targetSegmentIndex = Number(nameAsStringOrNumber);
+    secondSegmentIndex = Number(nameAsStringOrNumber);
   },
 });
 
-addButtonToToolbar({
-  title: 'Apply operation',
-  onClick: function () {
-    performLogicalOperation(selectedOperation, false);
+addDropdownToToolbar({
+  id: 'outputSegmentIndex',
+  labelText: '= Output segment',
+  options: { values: segmentIndices, defaultValue: segmentIndices[0] },
+  onSelectedValueChange: (nameAsStringOrNumber) => {
+    outputSegmentIndex = Number(nameAsStringOrNumber);
   },
 });
 
 addButtonToToolbar({
-  id: 'applyAndCreateNewSegment',
-  title: 'Apply operation and create new segment',
+  title: 'Apply operation',
   onClick: function () {
-    performLogicalOperation(selectedOperation, true);
+    performLogicalOperation(selectedOperation, false);
   },
 });
 
@@ -262,16 +265,9 @@ function performLogicalOperation(
 
   if (annotationUIDsMap) {
     const segmentIndexes = Array.from(annotationUIDsMap.keys());
-    let newIndex = 0;
-    if (createNew) {
-      newIndex = Math.max(...segmentIndexes) + 1;
-    } else {
-      newIndex = targetSegmentIndex;
-    }
     const operatorOptions = {
       segmentationId: activeSeg.segmentationId,
-      label: 'Combined Addition',
-      segmentIndex: newIndex,
+      segmentIndex: outputSegmentIndex,
       color: 'rgb(50, 130, 162)',
     };
 
@@ -280,14 +276,14 @@ function performLogicalOperation(
         copy(
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: sourceSegmentIndex,
+            segmentIndex: firstSegmentIndex,
           },
           operatorOptions
         );
       } else if (operation === LogicalOperation.Delete) {
         deleteOperation({
           segmentationId: activeSeg.segmentationId,
-          segmentIndex: sourceSegmentIndex,
+          segmentIndex: firstSegmentIndex,
         });
       }
     }
@@ -296,47 +292,47 @@ function performLogicalOperation(
         add(
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: sourceSegmentIndex,
+            segmentIndex: firstSegmentIndex,
           },
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: targetSegmentIndex,
+            segmentIndex: secondSegmentIndex,
           },
           operatorOptions
         );
       } else if (operation === LogicalOperation.Subtract) {
         subtract(
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: sourceSegmentIndex,
+            segmentIndex: firstSegmentIndex,
           },
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: targetSegmentIndex,
+            segmentIndex: secondSegmentIndex,
           },
           operatorOptions
         );
       } else if (operation === LogicalOperation.Intersect) {
         intersect(
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: sourceSegmentIndex,
+            segmentIndex: firstSegmentIndex,
           },
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: targetSegmentIndex,
+            segmentIndex: secondSegmentIndex,
           },
           operatorOptions
         );
       } else if (operation === LogicalOperation.XOR) {
         xor(
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: sourceSegmentIndex,
+            segmentIndex: firstSegmentIndex,
           },
           {
             segmentationId: activeSeg.segmentationId,
-            segmentIndex: targetSegmentIndex,
+            segmentIndex: secondSegmentIndex,
           },
           operatorOptions
         );

packages/tools/src/utilities/contourSegmentation/logicalOperators.ts

@@ -20,7 +20,6 @@
  * - applyLogicalOperation: Internal function to apply a logical operation and update the segmentation
  *
  * Helper Functions:
- * - getViewReferenceFromAnnotation: Extracts view reference from annotation metadata
  * - getPolylinesInfoWorld: Gets world-space polylines and view references for a segment
  * - extractPolylinesInCanvasSpace: Converts world-space polylines to canvas space for two segments
  * - addSegmentInSegmentation: Adds a new segment to the segmentation object
@@ -175,6 +174,25 @@ function addSegmentInSegmentation(
   };
 }
 
+/**
+ * Removes all annotations for a given segment index from the segmentation.
+ * This function iterates through the provided annotationUIDList,
+ * retrieves each annotation, removes it from the state management,
+ * and also removes the corresponding contour segmentation annotation.
+ * After processing, it clears the annotationUIDList to avoid memory leaks or unintended reuse.
+ * @param annotationUIDList
+ */
+function removeAnnotations(annotationUIDList: Set<string>) {
+  annotationUIDList.forEach((annotationUID) => {
+    const annotation = getAnnotation(annotationUID);
+    removeAnnotation(annotationUID);
+    removeContourSegmentationAnnotation(
+      annotation as ContourSegmentationAnnotation
+    );
+  });
+  annotationUIDList.clear(); // Clear the set after removal
+}
+
 /**
  * Applies a logical operation (union, subtract, intersect, xor) between two segments,
  * converts the result back to world space, and updates the segmentation.
@@ -252,6 +270,18 @@ function applyLogicalOperation(
   if (!annotationUIDsMap) {
     return;
   }
+  if (
+    segment1.segmentationId === resultSegment.segmentationId &&
+    segment1.segmentIndex === segmentIndex
+  ) {
+    // If the segment being modified is the same as the result segment,
+    // we need to remove the existing annotations for that segment
+    // index before adding new ones.
+    const existingAnnotationUIDs = annotationUIDsMap.get(segmentIndex);
+    if (existingAnnotationUIDs) {
+      removeAnnotations(existingAnnotationUIDs);
+    }
+  }
   // Add polylines to segmentation, passing viewReference for each
   addPolylinesToSegmentation(
     viewport,
@@ -367,11 +397,5 @@ export function deleteOperation(segment: SegmentInfo) {
   }
 
   const annotationUIDList = annotationUIDsMap.get(segment.segmentIndex);
-  annotationUIDList.forEach((annotationUID) => {
-    const annotation = getAnnotation(annotationUID);
-    removeAnnotation(annotationUID);
-    removeContourSegmentationAnnotation(
-      annotation as ContourSegmentationAnnotation
-    );
-  });
+  removeAnnotations(annotationUIDList);
 }

packages/tools/src/utilities/contourSegmentation/polylineSubtract.ts

@@ -37,12 +37,14 @@ export function subtractPolylineSets(
             polylineB.viewReference
           )
         ) {
-          continue; // Skip if view references are not equal
+          // If viewReference does not match, keep the polyline for further checks
+          newPolylines.push(currentPolyline);
+          continue;
         }
-
         if (
           arePolylinesIdentical(currentPolyline.polyline, polylineB.polyline)
         ) {
+          // Polyline is identical, so it is subtracted (not added to newPolylines)
           continue;
         }
         const intersection = checkIntersection(
@@ -66,15 +68,10 @@ export function subtractPolylineSets(
             }
           }
         } else {
-          const cleaned = removeDuplicatePoints(
-            cleanupPolylines([currentPolyline.polyline])[0]
-          );
-          if (cleaned.length >= 3) {
-            newPolylines.push({
-              polyline: cleaned,
-              viewReference: currentPolyline.viewReference,
-            });
-          }
+          newPolylines.push({
+            polyline: currentPolyline.polyline,
+            viewReference: currentPolyline.viewReference,
+          });
         }
       }
       currentPolylines = newPolylines;