@cornerstonejs/tools 5.1.3 → 5.1.4

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.js

@@ -1,11 +1,8 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import getViewportsForAnnotation from '../../../utilities/getViewportsForAnnotation';
-import { getAllAnnotations } from '../../../stateManagement/annotation/annotationState';
-import { areSameSegment, isContourSegmentationAnnotation, } from '../../../utilities/contourSegmentation';
+import isContourSegmentationAnnotation from '../../../utilities/contourSegmentation/isContourSegmentationAnnotation';
 import { getToolGroupForViewport } from '../../../store/ToolGroupManager';
-import { findAllIntersectingContours } from '../../../utilities/contourSegmentation/getIntersectingAnnotations';
-import { processMultipleIntersections } from '../../../utilities/contourSegmentation/mergeMultipleAnnotations';
-import { convertContourPolylineToCanvasSpace, createPolylineHole, combinePolylines, } from '../../../utilities/contourSegmentation/sharedOperations';
+import { addContourStroke, removeContourStroke, } from '../../../utilities/contourSegmentation/applyContourStroke';
 import { Events } from '../../../enums';
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export default async function contourSegmentationCompletedListener(evt) {
@@ -15,41 +12,20 @@ export default async function contourSegmentationCompletedListener(evt) {
         return;
     }
     const viewport = getViewport(sourceAnnotation);
-    const contourSegmentationAnnotations = getValidContourSegmentationAnnotations(viewport, sourceAnnotation);
-    if (!contourSegmentationAnnotations.length) {
-        triggerEvent(eventTarget, Events.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, {
-            element: viewport.element,
-            sourceAnnotation,
-        });
-        return;
-    }
-    const sourcePolyline = convertContourPolylineToCanvasSpace(sourceAnnotation.data.contour.polyline, viewport);
-    const intersectingContours = findAllIntersectingContours(viewport, sourcePolyline, contourSegmentationAnnotations);
-    if (!intersectingContours.length) {
-        triggerEvent(eventTarget, Events.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, {
-            element: viewport.element,
-            sourceAnnotation,
-        });
-        return;
-    }
-    if (intersectingContours.length > 1) {
-        processMultipleIntersections(viewport, sourceAnnotation, sourcePolyline, intersectingContours);
-        return;
-    }
-    const { targetAnnotation, targetPolyline, isContourHole } = intersectingContours[0];
-    if (isContourHole) {
-        const { contourHoleProcessingEnabled = false } = evt.detail;
-        if (!contourHoleProcessingEnabled) {
-            return;
-        }
-        createPolylineHole(viewport, targetAnnotation, sourceAnnotation);
+    const { contourHoleProcessingEnabled = false } = evt.detail;
+    if (contourHoleProcessingEnabled) {
+        removeContourStroke(viewport, sourceAnnotation);
     }
     else {
-        combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnnotation, sourcePolyline);
+        addContourStroke(viewport, sourceAnnotation);
     }
+    triggerEvent(eventTarget, Events.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, {
+        element: viewport.element,
+        sourceAnnotation,
+    });
 }
 function isFreehandContourSegToolRegisteredForViewport(viewport, silent = false) {
-    const toolName = 'PlanarFreehandContourSegmentationTool';
+    const toolName = DEFAULT_CONTOUR_SEG_TOOL_NAME;
     const toolGroup = getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
     let errorMessage;
     if (!toolGroup) {
@@ -71,12 +47,3 @@ function getViewport(annotation) {
     const viewportWithToolRegistered = viewports.find((viewport) => isFreehandContourSegToolRegisteredForViewport(viewport, true));
     return viewportWithToolRegistered ?? viewports[0];
 }
-function getValidContourSegmentationAnnotations(viewport, sourceAnnotation) {
-    const { annotationUID: sourceAnnotationUID } = sourceAnnotation;
-    const allAnnotations = getAllAnnotations();
-    return allAnnotations.filter((targetAnnotation) => targetAnnotation.annotationUID &&
-        targetAnnotation.annotationUID !== sourceAnnotationUID &&
-        isContourSegmentationAnnotation(targetAnnotation) &&
-        areSameSegment(targetAnnotation, sourceAnnotation) &&
-        viewport.isReferenceViewable(targetAnnotation.metadata));
-}

package/dist/esm/tools/annotation/planarFreehandROITool/drawLoop.js

@@ -11,6 +11,7 @@ import { resolveVectorToPeak } from './findOpenUShapedContourVectorToPeak';
 import { polyline } from '../../../utilities/math';
 import { removeAnnotation } from '../../../stateManagement/annotation/annotationState';
 import { ContourWindingDirection } from '../../../types/ContourAnnotation';
+import { bridgeSelfIntersectingPolyline } from '../../../utilities/contourSegmentation/bridgeWeaklyConnected';
 const { addCanvasPointsToArray, pointsAreWithinCloseContourProximity, getFirstLineSegmentIntersectionIndexes, getSubPixelSpacingAndXYDirections, } = polyline;
 function activateDraw(evt, annotation, viewportIdsToRender) {
     const eventDetail = evt.detail;
@@ -90,7 +91,9 @@ function mouseDragDrawCallback(evt) {
     }
     else {
         const crossingIndex = this.findCrossingIndexDuringCreate(evt);
-        if (crossingIndex !== undefined) {
+        const crossingClosesContour = crossingIndex !== undefined &&
+            pointsAreWithinCloseContourProximity(canvasPoints[0], canvasPoints[crossingIndex], this.configuration.closeContourProximity);
+        if (crossingClosesContour) {
             this.applyCreateOnCross(evt, crossingIndex);
         }
         else {
@@ -136,9 +139,10 @@ function completeDrawClosedContour(element, options) {
     const { viewport } = enabledElement;
     addCanvasPointsToArray(element, canvasPoints, canvasPoints[0], this.commonData);
     canvasPoints.pop();
-    const updatedPoints = shouldSmooth(this.configuration, annotation)
+    const smoothedPoints = shouldSmooth(this.configuration, annotation)
         ? getInterpolatedPoints(this.configuration, canvasPoints)
         : canvasPoints;
+    const updatedPoints = bridgeSelfIntersectingPolyline(smoothedPoints);
     this.updateContourPolyline(annotation, {
         points: updatedPoints,
         closed: true,

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

@@ -1,39 +1,66 @@
 import { utilities } from '@cornerstonejs/core';
 import { addAnnotation } from '../../stateManagement';
+import { addChildAnnotation } from '../../stateManagement/annotation/annotationState';
+import updateContourPolyline from '../contours/updateContourPolyline';
+import { ContourWindingDirection } from '../../types/ContourAnnotation';
 const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
 export default function addPolylinesToSegmentation(viewport, annotationUIDsMap, segmentationId, polylinesInfo, segmentIndex) {
-    polylinesInfo.forEach(({ polyline, viewReference }) => {
+    polylinesInfo.forEach(({ polyline, viewReference, holePolylines }) => {
         if (polyline.length < 3) {
             return;
         }
-        const contourSegmentationAnnotation = {
-            annotationUID: utilities.uuidv4(),
-            data: {
-                contour: {
-                    closed: true,
-                    polyline,
-                },
-                segmentation: {
-                    segmentationId,
-                    segmentIndex,
-                },
-                handles: {},
-            },
-            handles: {},
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: DEFAULT_CONTOUR_SEG_TOOLNAME,
-                ...viewReference,
-            },
-        };
-        addAnnotation(contourSegmentationAnnotation, viewport.element);
+        const parentAnnotation = createContourSegmentationAnnotation(segmentationId, segmentIndex, viewReference);
+        addAnnotation(parentAnnotation, viewport.element);
+        const parentPolylineCanvas = polyline.map((point) => viewport.worldToCanvas(point));
+        updateContourPolyline(parentAnnotation, {
+            points: parentPolylineCanvas,
+            closed: true,
+            targetWindingDirection: ContourWindingDirection.Clockwise,
+        }, viewport);
         const currentSet = annotationUIDsMap?.get(segmentIndex) || new Set();
-        currentSet.add(contourSegmentationAnnotation.annotationUID);
+        currentSet.add(parentAnnotation.annotationUID);
         annotationUIDsMap.set(segmentIndex, currentSet);
+        holePolylines?.forEach((holePolyline) => {
+            if (holePolyline.length < 3) {
+                return;
+            }
+            const holeAnnotation = createContourSegmentationAnnotation(segmentationId, segmentIndex, viewReference);
+            addAnnotation(holeAnnotation, viewport.element);
+            addChildAnnotation(parentAnnotation, holeAnnotation);
+            const holePolylineCanvas = holePolyline.map((point) => viewport.worldToCanvas(point));
+            updateContourPolyline(holeAnnotation, {
+                points: holePolylineCanvas,
+                closed: true,
+                targetWindingDirection: ContourWindingDirection.CounterClockwise,
+            }, viewport);
+        });
     });
     return annotationUIDsMap;
 }
+function createContourSegmentationAnnotation(segmentationId, segmentIndex, viewReference) {
+    return {
+        annotationUID: utilities.uuidv4(),
+        data: {
+            contour: {
+                closed: true,
+                polyline: [],
+            },
+            segmentation: {
+                segmentationId,
+                segmentIndex,
+            },
+            handles: {},
+            cachedStats: {},
+        },
+        handles: {},
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            toolName: DEFAULT_CONTOUR_SEG_TOOLNAME,
+            ...viewReference,
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../types';
+export declare function addContourStroke(viewport: Types.IViewport, sourceAnnotation: ContourSegmentationAnnotation): void;
+export declare function removeContourStroke(viewport: Types.IViewport, sourceAnnotation: ContourSegmentationAnnotation): void;

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

@@ -0,0 +1,102 @@
+import { ContourWindingDirection } from '../../types/ContourAnnotation';
+import { applyBoolean, BooleanOp, splitSelfIntersections, } from './clipperBooleanOps';
+import { unifyWeaklyConnectedPolygons } from './bridgeWeaklyConnected';
+import { convertContourPolylineToCanvasSpace, createNewAnnotationFromPolyline, getContourHolesData, updateViewportsForAnnotations, } from './sharedOperations';
+import { getAllAnnotations } from '../../stateManagement/annotation/annotationState';
+import { addAnnotation, addChildAnnotation, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { addContourSegmentationAnnotation } from './addContourSegmentationAnnotation';
+import { removeContourSegmentationAnnotation } from './removeContourSegmentationAnnotation';
+import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
+import areSameSegment from './areSameSegment';
+import isContourSegmentationAnnotation from './isContourSegmentationAnnotation';
+import { hasToolByName } from '../../store/addTool';
+const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
+export function addContourStroke(viewport, sourceAnnotation) {
+    applyStroke(viewport, sourceAnnotation, BooleanOp.Union);
+}
+export function removeContourStroke(viewport, sourceAnnotation) {
+    applyStroke(viewport, sourceAnnotation, BooleanOp.Difference);
+}
+function applyStroke(viewport, sourceAnnotation, op) {
+    if (!hasToolByName(DEFAULT_CONTOUR_SEG_TOOL_NAME)) {
+        console.warn(`${DEFAULT_CONTOUR_SEG_TOOL_NAME} is not registered. Cannot apply stroke.`);
+        removeAnnotationCompletely(sourceAnnotation);
+        return;
+    }
+    const sourcePolyline = convertContourPolylineToCanvasSpace(sourceAnnotation.data.contour.polyline, viewport);
+    if (sourcePolyline.length < 3) {
+        removeAnnotationCompletely(sourceAnnotation);
+        return;
+    }
+    const targets = collectSamePlaneSegmentTargets(viewport, sourceAnnotation);
+    const subjects = targets.map((t) => {
+        const outer = convertContourPolylineToCanvasSpace(t.data.contour.polyline, viewport);
+        const holes = getContourHolesData(viewport, t).map((h) => h.polyline);
+        return { outer, holes: holes.length ? holes : undefined };
+    });
+    const clips = splitSelfIntersections(sourcePolyline);
+    if (clips.length === 0) {
+        removeAnnotationCompletely(sourceAnnotation);
+        return;
+    }
+    const booleanResult = applyBoolean(subjects, clips, op);
+    const resultPolygons = op === BooleanOp.Union
+        ? unifyWeaklyConnectedPolygons(booleanResult)
+        : booleanResult;
+    const toRemove = [sourceAnnotation];
+    for (const t of targets) {
+        toRemove.push(t);
+        for (const h of getContourHolesData(viewport, t)) {
+            toRemove.push(h.annotation);
+        }
+    }
+    for (const annotation of toRemove) {
+        removeAnnotationCompletely(annotation);
+    }
+    const template = targets[0] ?? sourceAnnotation;
+    const { element } = viewport;
+    for (const polygon of resultPolygons) {
+        if (polygon.outer.length < 3) {
+            continue;
+        }
+        const parent = createNewAnnotationFromPolyline(viewport, template, polygon.outer, ContourWindingDirection.Clockwise);
+        addAnnotation(parent, element);
+        addContourSegmentationAnnotation(parent);
+        polygon.holes?.forEach((holePolyline) => {
+            if (holePolyline.length < 3) {
+                return;
+            }
+            const hole = createNewAnnotationFromPolyline(viewport, template, holePolyline, ContourWindingDirection.CounterClockwise);
+            addAnnotation(hole, element);
+            addChildAnnotation(parent, hole);
+            triggerAnnotationModified(hole, element);
+        });
+        triggerAnnotationModified(parent, element);
+    }
+    updateViewportsForAnnotations(viewport, toRemove);
+}
+function collectSamePlaneSegmentTargets(viewport, sourceAnnotation) {
+    const sourceUID = sourceAnnotation.annotationUID;
+    return getAllAnnotations().filter((candidate) => {
+        if (!candidate.annotationUID || candidate.annotationUID === sourceUID) {
+            return false;
+        }
+        if (!isContourSegmentationAnnotation(candidate)) {
+            return false;
+        }
+        if (!areSameSegment(candidate, sourceAnnotation)) {
+            return false;
+        }
+        if (!viewport.isReferenceViewable(candidate.metadata)) {
+            return false;
+        }
+        if (candidate.parentAnnotationUID) {
+            return false;
+        }
+        return true;
+    });
+}
+function removeAnnotationCompletely(annotation) {
+    removeAnnotation(annotation.annotationUID);
+    removeContourSegmentationAnnotation(annotation);
+}

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

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import { type PolygonWithHoles } from './clipperBooleanOps';
+export declare function unifyWeaklyConnectedPolygons(polygons: PolygonWithHoles[]): PolygonWithHoles[];
+export declare function bridgeSelfIntersectingPolyline(line: Types.Point2[]): Types.Point2[];

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

@@ -0,0 +1,126 @@
+import * as math from '../math';
+import { splitSelfIntersections, } from './clipperBooleanOps';
+const TOUCH_EPS = 1e-2;
+const TOUCH_EPS_SQ = TOUCH_EPS * TOUCH_EPS;
+function dist2(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    return dx * dx + dy * dy;
+}
+function boxesWithinEps(a, b) {
+    return (a.minX <= b.maxX + TOUCH_EPS &&
+        b.minX <= a.maxX + TOUCH_EPS &&
+        a.minY <= b.maxY + TOUCH_EPS &&
+        b.minY <= a.maxY + TOUCH_EPS);
+}
+function ringsTouch(a, b) {
+    for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < b.length; j++) {
+            if (dist2(a[i], b[j]) <= TOUCH_EPS_SQ) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function spliceTwoRings(a, b) {
+    const bb = math.polyline.getWindingDirection(b) !==
+        math.polyline.getWindingDirection(a)
+        ? [...b].reverse()
+        : b;
+    let best = Infinity;
+    let ai = 0;
+    let bj = 0;
+    for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < bb.length; j++) {
+            const d = dist2(a[i], bb[j]);
+            if (d < best) {
+                best = d;
+                ai = i;
+                bj = j;
+            }
+        }
+    }
+    const loop = [...bb.slice(bj), ...bb.slice(0, bj)];
+    return [...a.slice(0, ai + 1), ...loop, loop[0], ...a.slice(ai + 1)];
+}
+function groupTouchingOuters(outers) {
+    const n = outers.length;
+    const parent = Array.from({ length: n }, (_, i) => i);
+    const find = (x) => {
+        let root = x;
+        while (parent[root] !== root) {
+            root = parent[root];
+        }
+        while (parent[x] !== root) {
+            const next = parent[x];
+            parent[x] = root;
+            x = next;
+        }
+        return root;
+    };
+    const union = (x, y) => {
+        parent[find(x)] = find(y);
+    };
+    const boxes = outers.map((o) => math.polyline.getAABB(o));
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            if (boxesWithinEps(boxes[i], boxes[j]) &&
+                ringsTouch(outers[i], outers[j])) {
+                union(i, j);
+            }
+        }
+    }
+    const groups = new Map();
+    for (let i = 0; i < n; i++) {
+        const root = find(i);
+        const group = groups.get(root);
+        if (group) {
+            group.push(i);
+        }
+        else {
+            groups.set(root, [i]);
+        }
+    }
+    return [...groups.values()];
+}
+export function unifyWeaklyConnectedPolygons(polygons) {
+    if (polygons.length < 2) {
+        return polygons;
+    }
+    const outers = polygons.map((p) => p.outer);
+    const groups = groupTouchingOuters(outers);
+    if (groups.length === polygons.length) {
+        return polygons;
+    }
+    return groups.map((group) => {
+        if (group.length === 1) {
+            return polygons[group[0]];
+        }
+        let outer = polygons[group[0]].outer;
+        for (let k = 1; k < group.length; k++) {
+            outer = spliceTwoRings(outer, polygons[group[k]].outer);
+        }
+        const holes = group.flatMap((idx) => polygons[idx].holes ?? []);
+        return holes.length ? { outer, holes } : { outer };
+    });
+}
+export function bridgeSelfIntersectingPolyline(line) {
+    const polygons = splitSelfIntersections(line);
+    if (polygons.length === 0) {
+        return line;
+    }
+    if (polygons.length === 1 && !polygons[0].holes?.length) {
+        return line;
+    }
+    const unified = unifyWeaklyConnectedPolygons(polygons);
+    const main = unified.reduce((largest, candidate) => math.polyline.getArea(candidate.outer) >
+        math.polyline.getArea(largest.outer)
+        ? candidate
+        : largest);
+    let outer = main.outer;
+    for (const hole of main.holes ?? []) {
+        outer = spliceTwoRings(outer, hole);
+    }
+    return outer;
+}

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

@@ -0,0 +1,13 @@
+import type { Types } from '@cornerstonejs/core';
+export type PolygonWithHoles = {
+    outer: Types.Point2[];
+    holes?: Types.Point2[][];
+};
+export declare enum BooleanOp {
+    Union = 0,
+    Difference = 1,
+    Intersection = 2,
+    Xor = 3
+}
+export declare function applyBoolean(subjects: PolygonWithHoles[], clips: PolygonWithHoles[], op: BooleanOp): PolygonWithHoles[];
+export declare function splitSelfIntersections(polyline: Types.Point2[]): PolygonWithHoles[];

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

@@ -0,0 +1,126 @@
+import { Clipper, ClipType, FillRule, PolyTreeD, } from 'clipper2-ts';
+const PRECISION = 4;
+export var BooleanOp;
+(function (BooleanOp) {
+    BooleanOp[BooleanOp["Union"] = 0] = "Union";
+    BooleanOp[BooleanOp["Difference"] = 1] = "Difference";
+    BooleanOp[BooleanOp["Intersection"] = 2] = "Intersection";
+    BooleanOp[BooleanOp["Xor"] = 3] = "Xor";
+})(BooleanOp || (BooleanOp = {}));
+const opToClipType = {
+    [BooleanOp.Union]: ClipType.Union,
+    [BooleanOp.Difference]: ClipType.Difference,
+    [BooleanOp.Intersection]: ClipType.Intersection,
+    [BooleanOp.Xor]: ClipType.Xor,
+};
+function point2ToPathD(polyline) {
+    const len = polyline.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; i++) {
+        out[i] = { x: polyline[i][0], y: polyline[i][1] };
+    }
+    return out;
+}
+function pathDToPoint2(path) {
+    const len = path.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; i++) {
+        out[i] = [path[i].x, path[i].y];
+    }
+    return out;
+}
+function polygonsToPathsD(polygons) {
+    const paths = [];
+    for (const p of polygons) {
+        if (p.outer.length >= 3) {
+            paths.push(point2ToPathD(p.outer));
+        }
+        if (p.holes) {
+            for (const hole of p.holes) {
+                if (hole.length >= 3) {
+                    paths.push(point2ToPathD(hole));
+                }
+            }
+        }
+    }
+    return paths;
+}
+function polyTreeToPolygons(tree) {
+    const out = [];
+    collectOuters(tree, out);
+    return out;
+}
+function collectOuters(node, out) {
+    for (let i = 0; i < node.count; i++) {
+        const child = node.child(i);
+        if (child.isHole) {
+            collectOuters(child, out);
+            continue;
+        }
+        const outerPoly = child.poly;
+        if (!outerPoly || outerPoly.length < 3) {
+            continue;
+        }
+        const polygon = { outer: pathDToPoint2(outerPoly) };
+        const holes = [];
+        for (let j = 0; j < child.count; j++) {
+            const grand = child.child(j);
+            if (grand.isHole) {
+                const holePoly = grand.poly;
+                if (holePoly && holePoly.length >= 3) {
+                    holes.push(pathDToPoint2(holePoly));
+                }
+                collectOuters(grand, out);
+            }
+        }
+        if (holes.length > 0) {
+            polygon.holes = holes;
+        }
+        out.push(polygon);
+    }
+}
+function clonePolygons(polygons) {
+    return polygons.map((p) => ({
+        outer: p.outer.map((pt) => [pt[0], pt[1]]),
+        holes: p.holes?.map((h) => h.map((pt) => [pt[0], pt[1]])),
+    }));
+}
+export function applyBoolean(subjects, clips, op) {
+    if (subjects.length === 0) {
+        if (op === BooleanOp.Union || op === BooleanOp.Xor) {
+            return clonePolygons(clips);
+        }
+        return [];
+    }
+    if (clips.length === 0) {
+        if (op === BooleanOp.Intersection) {
+            return [];
+        }
+        return clonePolygons(subjects);
+    }
+    const subjectPaths = polygonsToPathsD(subjects);
+    const clipPaths = polygonsToPathsD(clips);
+    if (subjectPaths.length === 0) {
+        if (op === BooleanOp.Union || op === BooleanOp.Xor) {
+            return clonePolygons(clips);
+        }
+        return [];
+    }
+    if (clipPaths.length === 0) {
+        if (op === BooleanOp.Intersection) {
+            return [];
+        }
+        return clonePolygons(subjects);
+    }
+    const tree = new PolyTreeD();
+    Clipper.booleanOpDWithPolyTree(opToClipType[op], subjectPaths, clipPaths, tree, FillRule.EvenOdd, PRECISION);
+    return polyTreeToPolygons(tree);
+}
+export function splitSelfIntersections(polyline) {
+    if (polyline.length < 3) {
+        return [];
+    }
+    const tree = new PolyTreeD();
+    Clipper.booleanOpDWithPolyTree(ClipType.Union, [point2ToPathD(polyline)], null, tree, FillRule.EvenOdd, PRECISION);
+    return polyTreeToPolygons(tree);
+}

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

@@ -1,4 +1,4 @@
-import { getAnnotation, removeAnnotation } from '../../stateManagement';
+import { getAnnotation, removeAnnotation, getChildAnnotations, } from '../../stateManagement';
 import { convertContourPolylineToCanvasSpace, convertContourPolylineToWorld, } from './sharedOperations';
 import addPolylinesToSegmentation from './addPolylinesToSegmentation';
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
@@ -29,9 +29,14 @@ function getPolylinesInfoWorld(contourRepresentationData, segmentIndex) {
     for (const annotationUID of annotationUIDs) {
         const annotation = getAnnotation(annotationUID);
         const { polyline } = annotation.data.contour;
+        const childAnnotations = getChildAnnotations(annotation);
+        const holePolylines = childAnnotations.length > 0
+            ? childAnnotations.map((child) => child.data.contour.polyline)
+            : undefined;
         polylinesInfo.push({
             polyline,
             viewReference: getViewReferenceFromAnnotation(annotation),
+            ...(holePolylines ? { holePolylines } : {}),
         });
     }
     return polylinesInfo;
@@ -51,16 +56,26 @@ function extractPolylinesInCanvasSpace(viewport, segment1, segment2) {
     if (!polyLinesInfoWorld1 || !polyLinesInfoWorld2) {
         return;
     }
-    const polyLinesInfoCanvas1 = polyLinesInfoWorld1.map(({ polyline, viewReference }) => {
+    const polyLinesInfoCanvas1 = polyLinesInfoWorld1.map(({ polyline, viewReference, holePolylines }) => {
         return {
             polyline: convertContourPolylineToCanvasSpace(polyline, viewport),
             viewReference,
+            ...(holePolylines?.length
+                ? {
+                    holePolylines: holePolylines.map((hole) => convertContourPolylineToCanvasSpace(hole, viewport)),
+                }
+                : {}),
         };
     });
-    const polyLinesInfoCanvas2 = polyLinesInfoWorld2.map(({ polyline, viewReference }) => {
+    const polyLinesInfoCanvas2 = polyLinesInfoWorld2.map(({ polyline, viewReference, holePolylines }) => {
         return {
             polyline: convertContourPolylineToCanvasSpace(polyline, viewport),
             viewReference,
+            ...(holePolylines?.length
+                ? {
+                    holePolylines: holePolylines.map((hole) => convertContourPolylineToCanvasSpace(hole, viewport)),
+                }
+                : {}),
         };
     });
     return { polyLinesInfoCanvas1, polyLinesInfoCanvas2 };
@@ -120,12 +135,15 @@ function applyLogicalOperation(segment1, segment2, options, operation) {
             polylinesMerged = unifyPolylineSets(polyLinesInfoCanvas1, polyLinesInfoCanvas2);
             break;
     }
-    const polyLinesWorld = polylinesMerged.map(({ polyline, viewReference }) => {
-        return {
-            polyline: convertContourPolylineToWorld(polyline, viewport),
-            viewReference,
-        };
-    });
+    const polyLinesWorld = polylinesMerged.map(({ polyline, viewReference, holePolylines }) => ({
+        polyline: convertContourPolylineToWorld(polyline, viewport),
+        viewReference,
+        ...(holePolylines?.length
+            ? {
+                holePolylines: holePolylines.map((hole) => convertContourPolylineToWorld(hole, viewport)),
+            }
+            : {}),
+    }));
     const resultSegment = options;
     const segmentation = getSegmentation(resultSegment.segmentationId);
     const segmentIndex = resultSegment.segmentIndex;