@cornerstonejs/tools 5.1.2 → 5.1.4

package/dist/esm/utilities/contourSegmentation/mergeMultipleAnnotations.js

@@ -2,13 +2,14 @@ import { utilities as csUtils, getEnabledElement } from '@cornerstonejs/core';
 import { ContourWindingDirection } from '../../types/ContourAnnotation';
 import * as math from '../math';
 import updateContourPolyline from '../contours/updateContourPolyline';
-import { addAnnotation, removeAnnotation, getChildAnnotations, addChildAnnotation, clearParentAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { addAnnotation, removeAnnotation, getChildAnnotations, addChildAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
 import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
 import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getViewportIdsWithToolToRender } from '../viewportFilters';
 import { hasToolByName, hasTool } from '../../store/addTool';
+import { applyBoolean, BooleanOp, } from './clipperBooleanOps';
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 function processMultipleIntersections(viewport, sourceAnnotation, sourcePolyline, intersectingContours) {
     const holeOperations = intersectingContours.filter((item) => item.isContourHole);
@@ -33,51 +34,52 @@ function processMultipleIntersections(viewport, sourceAnnotation, sourcePolyline
 }
 function processSequentialIntersections(viewport, sourceAnnotation, sourcePolyline, mergeOperations) {
     const { element } = viewport;
-    const allAnnotationsToRemove = [sourceAnnotation];
-    const allResultPolylines = [];
-    const allHoles = [];
-    mergeOperations.forEach(({ targetAnnotation }) => {
-        const holes = getContourHolesData(viewport, targetAnnotation);
-        allHoles.push(...holes);
-        allAnnotationsToRemove.push(targetAnnotation);
+    const subjects = mergeOperations.map(({ targetAnnotation, targetPolyline }) => {
+        const holes = getContourHolesData(viewport, targetAnnotation).map((h) => h.polyline);
+        return {
+            outer: targetPolyline,
+            holes: holes.length ? holes : undefined,
+        };
     });
+    const clips = [{ outer: sourcePolyline }];
     const sourceStartPoint = sourcePolyline[0];
     const shouldMerge = mergeOperations.some(({ targetPolyline }) => math.polyline.containsPoint(targetPolyline, sourceStartPoint));
-    if (shouldMerge) {
-        let resultPolyline = sourcePolyline;
-        mergeOperations.forEach(({ targetPolyline }) => {
-            resultPolyline = math.polyline.mergePolylines(resultPolyline, targetPolyline);
-        });
-        allResultPolylines.push(resultPolyline);
-    }
-    else {
-        mergeOperations.forEach(({ targetPolyline }) => {
-            const subtractedPolylines = math.polyline.subtractPolylines(targetPolyline, sourcePolyline);
-            allResultPolylines.push(...subtractedPolylines);
-        });
-    }
-    allAnnotationsToRemove.forEach((annotation) => {
+    const op = shouldMerge ? BooleanOp.Union : BooleanOp.Difference;
+    const resultPolygons = applyBoolean(subjects, clips, op);
+    const allHoleAnnotations = [];
+    const allAnnotationsToRemove = [
+        sourceAnnotation,
+    ];
+    mergeOperations.forEach(({ targetAnnotation }) => {
+        allAnnotationsToRemove.push(targetAnnotation);
+        getContourHolesData(viewport, targetAnnotation).forEach((h) => allHoleAnnotations.push(h.annotation));
+    });
+    [...allAnnotationsToRemove, ...allHoleAnnotations].forEach((annotation) => {
         removeAnnotation(annotation.annotationUID);
         removeContourSegmentationAnnotation(annotation);
     });
-    allHoles.forEach((holeData) => clearParentAnnotation(holeData.annotation));
     const baseAnnotation = mergeOperations[0].targetAnnotation;
-    const newAnnotations = [];
-    allResultPolylines.forEach((polyline) => {
-        if (!polyline || polyline.length < 3) {
-            console.warn('Skipping creation of new annotation due to invalid polyline:', polyline);
+    resultPolygons.forEach((polygon) => {
+        if (polygon.outer.length < 3) {
             return;
         }
-        const newAnnotation = createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline);
-        addAnnotation(newAnnotation, element);
-        addContourSegmentationAnnotation(newAnnotation);
-        triggerAnnotationModified(newAnnotation, viewport.element);
-        newAnnotations.push(newAnnotation);
+        const parent = createNewAnnotationFromPolyline(viewport, baseAnnotation, polygon.outer, ContourWindingDirection.Clockwise);
+        addAnnotation(parent, element);
+        addContourSegmentationAnnotation(parent);
+        triggerAnnotationModified(parent, element);
+        polygon.holes?.forEach((holePolyline) => {
+            if (holePolyline.length < 3) {
+                return;
+            }
+            const hole = createNewAnnotationFromPolyline(viewport, baseAnnotation, holePolyline, ContourWindingDirection.CounterClockwise);
+            addAnnotation(hole, element);
+            addChildAnnotation(parent, hole);
+            triggerAnnotationModified(hole, element);
+        });
     });
-    reassignHolesToNewAnnotations(viewport, allHoles, newAnnotations);
     updateViewportsForAnnotations(viewport, allAnnotationsToRemove);
 }
-function createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline) {
+function createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline, windingDirection = ContourWindingDirection.Clockwise) {
     const startPointWorld = viewport.canvasToWorld(polyline[0]);
     const endPointWorld = viewport.canvasToWorld(polyline[polyline.length - 1]);
     const newAnnotation = {
@@ -115,21 +117,10 @@ function createNewAnnotationFromPolyline(viewport, baseAnnotation, polyline) {
     updateContourPolyline(newAnnotation, {
         points: polyline,
         closed: true,
-        targetWindingDirection: ContourWindingDirection.Clockwise,
+        targetWindingDirection: windingDirection,
     }, viewport);
     return newAnnotation;
 }
-function reassignHolesToNewAnnotations(viewport, holes, newAnnotations) {
-    holes.forEach((holeData) => {
-        const parentAnnotation = newAnnotations.find((annotation) => {
-            const parentPolyline = convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport);
-            return math.polyline.containsPoints(parentPolyline, holeData.polyline);
-        });
-        if (parentAnnotation) {
-            addChildAnnotation(parentAnnotation, holeData.annotation);
-        }
-    });
-}
 function getContourHolesData(viewport, annotation) {
     return getChildAnnotations(annotation).map((holeAnnotation) => {
         const contourHoleAnnotation = holeAnnotation;

package/dist/esm/utilities/contourSegmentation/polylineInfoTypes.d.ts

@@ -2,8 +2,10 @@ import type { Types } from '@cornerstonejs/core';
 export type PolylineInfoWorld = {
     polyline: Types.Point3[];
     viewReference: Types.ViewReference;
+    holePolylines?: Types.Point3[][];
 };
 export type PolylineInfoCanvas = {
     polyline: Types.Point2[];
     viewReference: Types.ViewReference;
+    holePolylines?: Types.Point2[][];
 };

package/dist/esm/utilities/contourSegmentation/polylineIntersect.js

@@ -1,34 +1,5 @@
-import { checkIntersection, cleanupPolylines } from './sharedOperations';
-import { intersectPolylines } from '../math/polyline';
-import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
-import { areViewReferencesEqual } from './areViewReferencesEqual';
+import { runBooleanOpByView } from './polylineSetOps';
+import { BooleanOp } from './clipperBooleanOps';
 export function intersectPolylinesSets(set1, set2) {
-    if (!set1.length || !set2.length) {
-        return [];
-    }
-    const result = [];
-    for (const polyA of set1) {
-        for (const polyB of set2) {
-            if (!areViewReferencesEqual(polyA.viewReference, polyB.viewReference)) {
-                continue;
-            }
-            if (arePolylinesIdentical(polyA.polyline, polyB.polyline)) {
-                result.push({ ...polyA });
-                continue;
-            }
-            const intersection = checkIntersection(polyA.polyline, polyB.polyline);
-            if (intersection.hasIntersection && !intersection.isContourHole) {
-                const intersectionRegions = cleanupPolylines(intersectPolylines(polyA.polyline, polyB.polyline));
-                if (intersectionRegions && intersectionRegions.length > 0) {
-                    intersectionRegions.forEach((region) => {
-                        result.push({
-                            polyline: region,
-                            viewReference: polyA.viewReference,
-                        });
-                    });
-                }
-            }
-        }
-    }
-    return result;
+    return runBooleanOpByView(set1, set2, BooleanOp.Intersection);
 }

package/dist/esm/utilities/contourSegmentation/polylineSetOps.d.ts

@@ -0,0 +1,3 @@
+import type { PolylineInfoCanvas } from './polylineInfoTypes';
+import { BooleanOp } from './clipperBooleanOps';
+export declare function runBooleanOpByView(setA: PolylineInfoCanvas[], setB: PolylineInfoCanvas[], op: BooleanOp): PolylineInfoCanvas[];

package/dist/esm/utilities/contourSegmentation/polylineSetOps.js

@@ -0,0 +1,62 @@
+import { areViewReferencesEqual } from './areViewReferencesEqual';
+import { applyBoolean, BooleanOp, } from './clipperBooleanOps';
+function toPolygon(info) {
+    return {
+        outer: info.polyline,
+        holes: info.holePolylines?.length ? info.holePolylines : undefined,
+    };
+}
+function groupByViewReference(set) {
+    const groups = [];
+    for (const info of set) {
+        if (info.polyline.length < 3) {
+            continue;
+        }
+        const existing = groups.find((g) => areViewReferencesEqual(g.viewReference, info.viewReference));
+        if (existing) {
+            existing.polygons.push(toPolygon(info));
+        }
+        else {
+            groups.push({
+                viewReference: info.viewReference,
+                polygons: [toPolygon(info)],
+            });
+        }
+    }
+    return groups;
+}
+function flatten(result, viewReference) {
+    return result.map((p) => ({
+        polyline: p.outer,
+        viewReference,
+        ...(p.holes?.length ? { holePolylines: p.holes } : {}),
+    }));
+}
+export function runBooleanOpByView(setA, setB, op) {
+    const aGroups = groupByViewReference(setA);
+    const bGroups = groupByViewReference(setB);
+    const out = [];
+    const matchedB = new Set();
+    for (const aGroup of aGroups) {
+        const bGroup = bGroups.find((g) => areViewReferencesEqual(g.viewReference, aGroup.viewReference));
+        if (bGroup) {
+            matchedB.add(bGroup);
+            const result = applyBoolean(aGroup.polygons, bGroup.polygons, op);
+            out.push(...flatten(result, aGroup.viewReference));
+        }
+        else if (op === BooleanOp.Intersection) {
+        }
+        else {
+            out.push(...flatten(aGroup.polygons, aGroup.viewReference));
+        }
+    }
+    if (op === BooleanOp.Union || op === BooleanOp.Xor) {
+        for (const bGroup of bGroups) {
+            if (matchedB.has(bGroup)) {
+                continue;
+            }
+            out.push(...flatten(bGroup.polygons, bGroup.viewReference));
+        }
+    }
+    return out;
+}

package/dist/esm/utilities/contourSegmentation/polylineSubtract.js

@@ -1,67 +1,29 @@
-import * as math from '../math';
-import { checkIntersection, cleanupPolylines, convertContourPolylineToCanvasSpace, removeDuplicatePoints, } from './sharedOperations';
-import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
+import { convertContourPolylineToCanvasSpace } from './sharedOperations';
 import { getViewReferenceFromAnnotation } from './getViewReferenceFromAnnotation';
-import { areViewReferencesEqual } from './areViewReferencesEqual';
+import { runBooleanOpByView } from './polylineSetOps';
+import { BooleanOp } from './clipperBooleanOps';
+import { getChildAnnotations } from '../../stateManagement/annotation/annotationState';
 export function subtractPolylineSets(polylinesSetA, polylinesSetB) {
-    const result = [];
-    for (let i = 0; i < polylinesSetA.length; i++) {
-        let currentPolylines = [polylinesSetA[i]];
-        for (let j = 0; j < polylinesSetB.length; j++) {
-            const polylineB = polylinesSetB[j];
-            const newPolylines = [];
-            for (const currentPolyline of currentPolylines) {
-                if (!areViewReferencesEqual(currentPolyline.viewReference, polylineB.viewReference)) {
-                    newPolylines.push(currentPolyline);
-                    continue;
-                }
-                if (arePolylinesIdentical(currentPolyline.polyline, polylineB.polyline)) {
-                    continue;
-                }
-                const intersection = checkIntersection(currentPolyline.polyline, polylineB.polyline);
-                if (intersection.hasIntersection && !intersection.isContourHole) {
-                    const subtractedPolylines = cleanupPolylines(math.polyline.subtractPolylines(currentPolyline.polyline, polylineB.polyline));
-                    for (const subtractedPolyline of subtractedPolylines) {
-                        const cleaned = removeDuplicatePoints(subtractedPolyline);
-                        if (cleaned.length >= 3) {
-                            newPolylines.push({
-                                polyline: cleaned,
-                                viewReference: currentPolyline.viewReference,
-                            });
-                        }
-                    }
-                }
-                else {
-                    newPolylines.push({
-                        polyline: currentPolyline.polyline,
-                        viewReference: currentPolyline.viewReference,
-                    });
-                }
-            }
-            currentPolylines = newPolylines;
-        }
-        result.push(...currentPolylines);
-    }
-    return result;
+    return runBooleanOpByView(polylinesSetA, polylinesSetB, BooleanOp.Difference);
 }
 export function subtractMultiplePolylineSets(basePolylineSet, subtractorSets) {
     if (subtractorSets.length === 0) {
         return [...basePolylineSet];
     }
-    let result = [...basePolylineSet];
-    for (let i = 0; i < subtractorSets.length; i++) {
-        result = subtractPolylineSets(result, subtractorSets[i]);
+    let result = basePolylineSet;
+    for (const subtractor of subtractorSets) {
+        result = subtractPolylineSets(result, subtractor);
     }
     return result;
 }
 export function subtractAnnotationPolylines(baseAnnotations, subtractorAnnotations, viewport) {
-    const basePolylines = baseAnnotations.map((annotation) => ({
-        polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
-        viewReference: getViewReferenceFromAnnotation(annotation),
-    }));
-    const subtractorPolylines = subtractorAnnotations.map((annotation) => ({
-        polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
-        viewReference: getViewReferenceFromAnnotation(annotation),
-    }));
-    return subtractPolylineSets(basePolylines, subtractorPolylines);
+    const toInfo = (annotation) => {
+        const holePolylines = getChildAnnotations(annotation).map((child) => convertContourPolylineToCanvasSpace(child.data.contour.polyline, viewport));
+        return {
+            polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
+            viewReference: getViewReferenceFromAnnotation(annotation),
+            ...(holePolylines.length ? { holePolylines } : {}),
+        };
+    };
+    return subtractPolylineSets(baseAnnotations.map(toInfo), subtractorAnnotations.map(toInfo));
 }

package/dist/esm/utilities/contourSegmentation/polylineUnify.js

@@ -1,57 +1,10 @@
-import * as math from '../math';
-import { checkIntersection, convertContourPolylineToCanvasSpace, } from './sharedOperations';
-import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
+import { convertContourPolylineToCanvasSpace } from './sharedOperations';
 import { getViewReferenceFromAnnotation } from './getViewReferenceFromAnnotation';
-import { areViewReferencesEqual } from './areViewReferencesEqual';
+import { runBooleanOpByView } from './polylineSetOps';
+import { BooleanOp } from './clipperBooleanOps';
+import { getChildAnnotations } from '../../stateManagement/annotation/annotationState';
 export function unifyPolylineSets(polylinesSetA, polylinesSetB) {
-    const result = [];
-    const processedFromA = new Set();
-    const processedFromB = new Set();
-    for (let i = 0; i < polylinesSetA.length; i++) {
-        if (processedFromA.has(i)) {
-            continue;
-        }
-        const polylineA = polylinesSetA[i];
-        let merged = false;
-        for (let j = 0; j < polylinesSetB.length; j++) {
-            if (processedFromB.has(j)) {
-                continue;
-            }
-            const polylineB = polylinesSetB[j];
-            if (!areViewReferencesEqual(polylineA.viewReference, polylineB.viewReference)) {
-                continue;
-            }
-            if (arePolylinesIdentical(polylineA.polyline, polylineB.polyline)) {
-                result.push(polylineA);
-                processedFromA.add(i);
-                processedFromB.add(j);
-                merged = true;
-                break;
-            }
-            const intersection = checkIntersection(polylineA.polyline, polylineB.polyline);
-            if (intersection.hasIntersection && !intersection.isContourHole) {
-                const mergedPolyline = math.polyline.mergePolylines(polylineA.polyline, polylineB.polyline);
-                result.push({
-                    polyline: mergedPolyline,
-                    viewReference: polylineA.viewReference,
-                });
-                processedFromA.add(i);
-                processedFromB.add(j);
-                merged = true;
-                break;
-            }
-        }
-        if (!merged) {
-            result.push(polylineA);
-            processedFromA.add(i);
-        }
-    }
-    for (let j = 0; j < polylinesSetB.length; j++) {
-        if (!processedFromB.has(j)) {
-            result.push(polylinesSetB[j]);
-        }
-    }
-    return result;
+    return runBooleanOpByView(polylinesSetA, polylinesSetB, BooleanOp.Union);
 }
 export function unifyMultiplePolylineSets(polylineSets) {
     if (polylineSets.length === 0) {
@@ -60,20 +13,20 @@ export function unifyMultiplePolylineSets(polylineSets) {
     if (polylineSets.length === 1) {
         return [...polylineSets[0]];
     }
-    let result = [...polylineSets[0]];
+    let result = polylineSets[0];
     for (let i = 1; i < polylineSets.length; i++) {
         result = unifyPolylineSets(result, polylineSets[i]);
     }
     return result;
 }
 export function unifyAnnotationPolylines(annotationsSetA, annotationsSetB, viewport) {
-    const polylinesSetA = annotationsSetA.map((annotation) => ({
-        polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
-        viewReference: getViewReferenceFromAnnotation(annotation),
-    }));
-    const polylinesSetB = annotationsSetB.map((annotation) => ({
-        polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
-        viewReference: getViewReferenceFromAnnotation(annotation),
-    }));
-    return unifyPolylineSets(polylinesSetA, polylinesSetB);
+    const toInfo = (annotation) => {
+        const holePolylines = getChildAnnotations(annotation).map((child) => convertContourPolylineToCanvasSpace(child.data.contour.polyline, viewport));
+        return {
+            polyline: convertContourPolylineToCanvasSpace(annotation.data.contour.polyline, viewport),
+            viewReference: getViewReferenceFromAnnotation(annotation),
+            ...(holePolylines.length ? { holePolylines } : {}),
+        };
+    };
+    return unifyPolylineSets(annotationsSetA.map(toInfo), annotationsSetB.map(toInfo));
 }

package/dist/esm/utilities/contourSegmentation/polylineXor.js

@@ -1,41 +1,5 @@
-import { cleanupPolylines } from './sharedOperations';
-import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
-import { subtractPolylineSets } from './polylineSubtract';
-import { areViewReferencesEqual } from './areViewReferencesEqual';
+import { runBooleanOpByView } from './polylineSetOps';
+import { BooleanOp } from './clipperBooleanOps';
 export function xorPolylinesSets(polylinesSetA, polylinesSetB) {
-    if (!polylinesSetA.length && !polylinesSetB.length) {
-        return [];
-    }
-    if (!polylinesSetA.length) {
-        return polylinesSetB;
-    }
-    if (!polylinesSetB.length) {
-        return polylinesSetA;
-    }
-    if (polylinesSetA.length === polylinesSetB.length) {
-        let allIdentical = true;
-        for (let i = 0; i < polylinesSetA.length; i++) {
-            let foundMatch = false;
-            for (let j = 0; j < polylinesSetB.length; j++) {
-                if (!areViewReferencesEqual(polylinesSetA[i].viewReference, polylinesSetB[j].viewReference)) {
-                    continue;
-                }
-                if (arePolylinesIdentical(polylinesSetA[i].polyline, polylinesSetB[j].polyline)) {
-                    foundMatch = true;
-                    break;
-                }
-            }
-            if (!foundMatch) {
-                allIdentical = false;
-                break;
-            }
-        }
-        if (allIdentical) {
-            return [];
-        }
-    }
-    const aMinusB = subtractPolylineSets(polylinesSetA, polylinesSetB);
-    const bMinusA = subtractPolylineSets(polylinesSetB, polylinesSetA);
-    const xorResult = [...aMinusB, ...bMinusA];
-    return xorResult;
+    return runBooleanOpByView(polylinesSetA, polylinesSetB, BooleanOp.Xor);
 }

package/dist/esm/utilities/contourSegmentation/sharedOperations.d.ts

@@ -1,10 +1,12 @@
 import type { Types } from '@cornerstonejs/core';
 import type { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAnnotation';
+import { ContourWindingDirection } from '../../types/ContourAnnotation';
 export declare function convertContourPolylineToCanvasSpace(polyline: Types.Point3[], viewport: Types.IViewport): Types.Point2[];
 export declare function convertContourPolylineToWorld(polyline: Types.Point2[], viewport: Types.IViewport): Types.Point3[];
 export declare function checkIntersection(sourcePolyline: Types.Point2[], targetPolyline: Types.Point2[]): {
     hasIntersection: boolean;
     isContourHole: boolean;
+    isTargetInsideSource: boolean;
 };
 export declare function getContourHolesData(viewport: Types.IViewport, annotation: ContourSegmentationAnnotation): Array<{
     annotation: ContourSegmentationAnnotation;
@@ -12,7 +14,7 @@ export declare function getContourHolesData(viewport: Types.IViewport, annotatio
 }>;
 export declare function createPolylineHole(viewport: Types.IViewport, targetAnnotation: ContourSegmentationAnnotation, holeAnnotation: ContourSegmentationAnnotation): void;
 export declare function combinePolylines(viewport: Types.IViewport, targetAnnotation: ContourSegmentationAnnotation, targetPolyline: Types.Point2[], sourceAnnotation: ContourSegmentationAnnotation, sourcePolyline: Types.Point2[]): void;
-export declare function createNewAnnotationFromPolyline(viewport: Types.IViewport, templateAnnotation: ContourSegmentationAnnotation, polyline: Types.Point2[]): ContourSegmentationAnnotation;
+export declare function createNewAnnotationFromPolyline(viewport: Types.IViewport, templateAnnotation: ContourSegmentationAnnotation, polyline: Types.Point2[], windingDirection?: ContourWindingDirection): ContourSegmentationAnnotation;
 export declare function updateViewportsForAnnotations(viewport: Types.IViewport, annotations: ContourSegmentationAnnotation[]): void;
 export declare function removeDuplicatePoints(polyline: Types.Point2[]): Types.Point2[];
 export declare function cleanupPolylines(polylines: Types.Point2[][]): Types.Point2[][];

package/dist/esm/utilities/contourSegmentation/sharedOperations.js

@@ -2,13 +2,14 @@ import { getEnabledElement, utilities as csUtils } from '@cornerstonejs/core';
 import { ContourWindingDirection } from '../../types/ContourAnnotation';
 import * as math from '../math';
 import updateContourPolyline from '../contours/updateContourPolyline';
-import { addAnnotation, removeAnnotation, getChildAnnotations, addChildAnnotation, clearParentAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { addAnnotation, removeAnnotation, getChildAnnotations, addChildAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
 import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
 import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getViewportIdsWithToolToRender } from '../viewportFilters';
 import { hasToolByName } from '../../store/addTool';
+import { applyBoolean, BooleanOp, } from './clipperBooleanOps';
 const TOLERANCE = 1e-10;
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export function convertContourPolylineToCanvasSpace(polyline, viewport) {
@@ -32,13 +33,20 @@ export function checkIntersection(sourcePolyline, targetPolyline) {
     const targetAABB = math.polyline.getAABB(targetPolyline);
     const aabbIntersect = math.aabb.intersectAABB(sourceAABB, targetAABB);
     if (!aabbIntersect) {
-        return { hasIntersection: false, isContourHole: false };
+        return {
+            hasIntersection: false,
+            isContourHole: false,
+            isTargetInsideSource: false,
+        };
     }
     const lineSegmentsIntersect = math.polyline.intersectPolyline(sourcePolyline, targetPolyline);
     const isContourHole = !lineSegmentsIntersect &&
         math.polyline.containsPoints(targetPolyline, sourcePolyline);
-    const hasIntersection = lineSegmentsIntersect || isContourHole;
-    return { hasIntersection, isContourHole };
+    const isTargetInsideSource = !lineSegmentsIntersect &&
+        !isContourHole &&
+        math.polyline.containsPoints(sourcePolyline, targetPolyline);
+    const hasIntersection = lineSegmentsIntersect || isContourHole || isTargetInsideSource;
+    return { hasIntersection, isContourHole, isTargetInsideSource };
 }
 export function getContourHolesData(viewport, annotation) {
     return getChildAnnotations(annotation).map((holeAnnotation) => {
@@ -71,63 +79,47 @@ export function combinePolylines(viewport, targetAnnotation, targetPolyline, sou
     const sourceStartPoint = sourcePolyline[0];
     const mergePolylines = math.polyline.containsPoint(targetPolyline, sourceStartPoint);
     const contourHolesData = getContourHolesData(viewport, targetAnnotation);
-    const unassignedContourHolesSet = new Set(contourHolesData);
-    const reassignedContourHolesMap = new Map();
-    const assignHoleToPolyline = (parentPolyline, holeData) => {
-        let holes = reassignedContourHolesMap.get(parentPolyline);
-        if (!holes) {
-            holes = [];
-            reassignedContourHolesMap.set(parentPolyline, holes);
-        }
-        holes.push(holeData);
-        unassignedContourHolesSet.delete(holeData);
-    };
-    const newPolylines = [];
-    if (mergePolylines) {
-        const mergedPolyline = math.polyline.mergePolylines(targetPolyline, sourcePolyline);
-        newPolylines.push(mergedPolyline);
-        Array.from(unassignedContourHolesSet.keys()).forEach((holeData) => assignHoleToPolyline(mergedPolyline, holeData));
-    }
-    else {
-        const subtractedPolylines = math.polyline.subtractPolylines(targetPolyline, sourcePolyline);
-        subtractedPolylines.forEach((newPolyline) => {
-            newPolylines.push(newPolyline);
-            Array.from(unassignedContourHolesSet.keys()).forEach((holeData) => {
-                const containsHole = math.polyline.containsPoints(newPolyline, holeData.polyline);
-                if (containsHole) {
-                    assignHoleToPolyline(newPolyline, holeData);
-                }
-            });
-        });
-    }
-    Array.from(reassignedContourHolesMap.values()).forEach((contourHolesDataArray) => contourHolesDataArray.forEach((contourHoleData) => clearParentAnnotation(contourHoleData.annotation)));
+    const subjects = [
+        {
+            outer: targetPolyline,
+            holes: contourHolesData.length
+                ? contourHolesData.map((h) => h.polyline)
+                : undefined,
+        },
+    ];
+    const clips = [{ outer: sourcePolyline }];
+    const resultPolygons = applyBoolean(subjects, clips, mergePolylines ? BooleanOp.Union : BooleanOp.Difference);
     const { element } = viewport;
-    const { metadata, data } = targetAnnotation;
-    const { handles, segmentation } = data;
-    const { textBox } = handles;
-    removeAnnotation(sourceAnnotation.annotationUID);
-    removeAnnotation(targetAnnotation.annotationUID);
-    removeContourSegmentationAnnotation(sourceAnnotation);
-    removeContourSegmentationAnnotation(targetAnnotation);
-    const newAnnotations = [];
-    for (let i = 0; i < newPolylines.length; i++) {
-        const polyline = newPolylines[i];
-        if (!polyline || polyline.length < 3) {
-            console.warn('Skipping creation of new annotation due to invalid polyline:', polyline);
-            continue;
+    const annotationsToRemove = [
+        sourceAnnotation,
+        targetAnnotation,
+        ...contourHolesData.map((h) => h.annotation),
+    ];
+    annotationsToRemove.forEach((annotation) => {
+        removeAnnotation(annotation.annotationUID);
+        removeContourSegmentationAnnotation(annotation);
+    });
+    resultPolygons.forEach((polygon) => {
+        if (polygon.outer.length < 3) {
+            return;
         }
-        const newAnnotation = createNewAnnotationFromPolyline(viewport, targetAnnotation, polyline);
-        addAnnotation(newAnnotation, element);
-        addContourSegmentationAnnotation(newAnnotation);
-        triggerAnnotationModified(newAnnotation, viewport.element);
-        newAnnotations.push(newAnnotation);
-        reassignedContourHolesMap
-            .get(polyline)
-            ?.forEach((holeData) => addChildAnnotation(newAnnotation, holeData.annotation));
-    }
+        const parent = createNewAnnotationFromPolyline(viewport, targetAnnotation, polygon.outer, ContourWindingDirection.Clockwise);
+        addAnnotation(parent, element);
+        addContourSegmentationAnnotation(parent);
+        triggerAnnotationModified(parent, element);
+        polygon.holes?.forEach((holePolyline) => {
+            if (holePolyline.length < 3) {
+                return;
+            }
+            const hole = createNewAnnotationFromPolyline(viewport, targetAnnotation, holePolyline, ContourWindingDirection.CounterClockwise);
+            addAnnotation(hole, element);
+            addChildAnnotation(parent, hole);
+            triggerAnnotationModified(hole, element);
+        });
+    });
     updateViewportsForAnnotations(viewport, [targetAnnotation, sourceAnnotation]);
 }
-export function createNewAnnotationFromPolyline(viewport, templateAnnotation, polyline) {
+export function createNewAnnotationFromPolyline(viewport, templateAnnotation, polyline, windingDirection = ContourWindingDirection.Clockwise) {
     const startPointWorld = viewport.canvasToWorld(polyline[0]);
     const endPointWorld = viewport.canvasToWorld(polyline[polyline.length - 1]);
     const newAnnotation = {
@@ -165,7 +157,7 @@ export function createNewAnnotationFromPolyline(viewport, templateAnnotation, po
     updateContourPolyline(newAnnotation, {
         points: polyline,
         closed: true,
-        targetWindingDirection: ContourWindingDirection.Clockwise,
+        targetWindingDirection: windingDirection,
     }, viewport);
     return newAnnotation;
 }