@cornerstonejs/tools 3.24.0 → 3.26.0

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

@@ -0,0 +1,79 @@
+import * as math from '../math';
+import { checkIntersection, convertContourPolylineToCanvasSpace, } from './sharedOperations';
+import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
+import { getViewReferenceFromAnnotation } from './getViewReferenceFromAnnotation';
+import { areViewReferencesEqual } from './areViewReferencesEqual';
+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;
+}
+export function unifyMultiplePolylineSets(polylineSets) {
+    if (polylineSets.length === 0) {
+        return [];
+    }
+    if (polylineSets.length === 1) {
+        return [...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);
+}

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

@@ -0,0 +1,2 @@
+import type { PolylineInfoCanvas } from './polylineInfoTypes';
+export declare function xorPolylinesSets(polylinesSetA: PolylineInfoCanvas[], polylinesSetB: PolylineInfoCanvas[]): PolylineInfoCanvas[];

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

@@ -0,0 +1,41 @@
+import { cleanupPolylines } from './sharedOperations';
+import arePolylinesIdentical from '../math/polyline/arePolylinesIdentical';
+import { subtractPolylineSets } from './polylineSubtract';
+import { areViewReferencesEqual } from './areViewReferencesEqual';
+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;
+}

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

@@ -14,3 +14,5 @@ export declare function createPolylineHole(viewport: Types.IViewport, targetAnno
 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 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

@@ -9,6 +9,7 @@ import { triggerAnnotationModified } from '../../stateManagement/annotation/help
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getViewportIdsWithToolToRender } from '../viewportFilters';
 import { hasToolByName } from '../../store/addTool';
+const TOLERANCE = 1e-10;
 const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export function convertContourPolylineToCanvasSpace(polyline, viewport) {
     const numPoints = polyline.length;
@@ -181,3 +182,46 @@ export function updateViewportsForAnnotations(viewport, annotations) {
         }
     }
 }
+export function removeDuplicatePoints(polyline) {
+    if (!polyline || polyline.length < 2) {
+        return polyline;
+    }
+    const cleaned = [polyline[0]];
+    for (let i = 1; i < polyline.length; i++) {
+        const currentPoint = polyline[i];
+        const lastPoint = cleaned[cleaned.length - 1];
+        const dx = Math.abs(currentPoint[0] - lastPoint[0]);
+        const dy = Math.abs(currentPoint[1] - lastPoint[1]);
+        if (dx > TOLERANCE || dy > TOLERANCE) {
+            cleaned.push(currentPoint);
+        }
+    }
+    return cleaned;
+}
+export function cleanupPolylines(polylines) {
+    const validPolylines = [];
+    const seenPolylines = new Set();
+    for (let polyline of polylines) {
+        if (!polyline || polyline.length < 3) {
+            continue;
+        }
+        polyline = removeDuplicatePoints(polyline);
+        if (polyline.length < 3) {
+            continue;
+        }
+        const sortedPoints = [...polyline].sort((a, b) => {
+            if (a[0] !== b[0]) {
+                return a[0] - b[0];
+            }
+            return a[1] - b[1];
+        });
+        const polylineKey = sortedPoints
+            .map((p) => `${p[0].toFixed(6)},${p[1].toFixed(6)}`)
+            .join('|');
+        if (!seenPolylines.has(polylineKey)) {
+            seenPolylines.add(polylineKey);
+            validPolylines.push(polyline);
+        }
+    }
+    return validPolylines;
+}

package/dist/esm/utilities/math/polyline/arePolylinesIdentical.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function arePolylinesIdentical(poly1: Types.Point2[], poly2: Types.Point2[]): boolean;

package/dist/esm/utilities/math/polyline/arePolylinesIdentical.js

@@ -0,0 +1,53 @@
+import { pointsAreEqual } from './robustSegmentIntersection';
+export default function arePolylinesIdentical(poly1, poly2) {
+    if (poly1.length !== poly2.length) {
+        return false;
+    }
+    const len = poly1.length;
+    if (len === 0) {
+        return true;
+    }
+    let identicalForward = true;
+    for (let i = 0; i < len; i++) {
+        if (!pointsAreEqual(poly1[i], poly2[i])) {
+            identicalForward = false;
+            break;
+        }
+    }
+    if (identicalForward) {
+        return true;
+    }
+    let identicalReverse = true;
+    for (let i = 0; i < len; i++) {
+        if (!pointsAreEqual(poly1[i], poly2[len - 1 - i])) {
+            identicalReverse = false;
+            break;
+        }
+    }
+    if (identicalReverse) {
+        return true;
+    }
+    for (let offset = 1; offset < len; offset++) {
+        let cyclicForward = true;
+        for (let i = 0; i < len; i++) {
+            if (!pointsAreEqual(poly1[i], poly2[(i + offset) % len])) {
+                cyclicForward = false;
+                break;
+            }
+        }
+        if (cyclicForward) {
+            return true;
+        }
+        let cyclicReverse = true;
+        for (let i = 0; i < len; i++) {
+            if (!pointsAreEqual(poly1[i], poly2[(len - 1 - i + offset) % len])) {
+                cyclicReverse = false;
+                break;
+            }
+        }
+        if (cyclicReverse) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/esm/utilities/math/polyline/combinePolyline.d.ts

@@ -1,4 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
 declare function mergePolylines(targetPolyline: Types.Point2[], sourcePolyline: Types.Point2[]): Types.Point2[];
-declare function subtractPolylines(targetPolyline: Types.Point2[], sourcePolyline: Types.Point2[]): Types.Point2[][];
-export { mergePolylines, subtractPolylines };
+export { mergePolylines };

package/dist/esm/utilities/math/polyline/combinePolyline.js

@@ -1,6 +1,8 @@
 import * as mathPoint from '../point';
 import getLineSegmentIntersectionsIndexes from './getLineSegmentIntersectionsIndexes';
 import containsPoint from './containsPoint';
+import containsPoints from './containsPoints';
+import intersectPolyline from './intersectPolyline';
 import getNormal2 from './getNormal2';
 import { glMatrix, vec3 } from 'gl-matrix';
 import getLinesIntersection from './getLinesIntersection';
@@ -123,12 +125,21 @@ function getSourceAndTargetPointsList(targetPolyline, sourcePolyline) {
     return { targetPolylinePoints, sourcePolylinePoints };
 }
 function getUnvisitedOutsidePoint(polylinePoints) {
+    for (let i = 0, len = polylinePoints.length; i < len; i++) {
+        const point = polylinePoints[i];
+        if (!point.visited &&
+            point.position === PolylinePointPosition.Outside &&
+            point.type === PolylinePointType.Vertex) {
+            return point;
+        }
+    }
     for (let i = 0, len = polylinePoints.length; i < len; i++) {
         const point = polylinePoints[i];
         if (!point.visited && point.position === PolylinePointPosition.Outside) {
             return point;
         }
     }
+    return undefined;
 }
 function mergePolylines(targetPolyline, sourcePolyline) {
     const targetNormal = getNormal2(targetPolyline);
@@ -137,6 +148,11 @@ function mergePolylines(targetPolyline, sourcePolyline) {
     if (!glMatrix.equals(1, dotNormals)) {
         sourcePolyline = sourcePolyline.slice().reverse();
     }
+    const lineSegmentsIntersect = intersectPolyline(sourcePolyline, targetPolyline);
+    const targetContainedInSource = !lineSegmentsIntersect && containsPoints(sourcePolyline, targetPolyline);
+    if (targetContainedInSource) {
+        return sourcePolyline.slice();
+    }
     const { targetPolylinePoints } = getSourceAndTargetPointsList(targetPolyline, sourcePolyline);
     const startPoint = getUnvisitedOutsidePoint(targetPolylinePoints);
     if (!startPoint) {
@@ -165,50 +181,4 @@ function mergePolylines(targetPolyline, sourcePolyline) {
     }
     return mergedPolyline;
 }
-function subtractPolylines(targetPolyline, sourcePolyline) {
-    const targetNormal = getNormal2(targetPolyline);
-    const sourceNormal = getNormal2(sourcePolyline);
-    const dotNormals = vec3.dot(sourceNormal, targetNormal);
-    if (!glMatrix.equals(-1, dotNormals)) {
-        sourcePolyline = sourcePolyline.slice().reverse();
-    }
-    const { targetPolylinePoints } = getSourceAndTargetPointsList(targetPolyline, sourcePolyline);
-    let startPoint = null;
-    const subtractedPolylines = [];
-    let outerIterationCount = 0;
-    const maxOuterIterations = targetPolyline.length * 2;
-    while ((startPoint = getUnvisitedOutsidePoint(targetPolylinePoints)) &&
-        outerIterationCount < maxOuterIterations) {
-        outerIterationCount++;
-        const subtractedPolyline = [startPoint.coordinates];
-        let currentPoint = startPoint.next;
-        let innerIterationCount = 0;
-        const maxInnerIterations = targetPolyline.length + sourcePolyline.length + 1000;
-        startPoint.visited = true;
-        while (currentPoint !== startPoint &&
-            innerIterationCount < maxInnerIterations) {
-            innerIterationCount++;
-            currentPoint.visited = true;
-            if (currentPoint.type === PolylinePointType.Intersection &&
-                currentPoint.cloned) {
-                currentPoint = currentPoint.next;
-                continue;
-            }
-            subtractedPolyline.push(currentPoint.coordinates);
-            currentPoint = currentPoint.next;
-            if (!currentPoint) {
-                console.warn('Broken linked list detected in subtractPolylines, breaking inner loop');
-                break;
-            }
-        }
-        if (innerIterationCount >= maxInnerIterations) {
-            console.warn('Maximum inner iterations reached in subtractPolylines, possible infinite loop detected');
-        }
-        subtractedPolylines.push(subtractedPolyline);
-    }
-    if (outerIterationCount >= maxOuterIterations) {
-        console.warn('Maximum outer iterations reached in subtractPolylines, possible infinite loop detected');
-    }
-    return subtractedPolylines;
-}
-export { mergePolylines, subtractPolylines };
+export { mergePolylines };

package/dist/esm/utilities/math/polyline/index.d.ts

@@ -7,7 +7,9 @@ import getSignedArea from './getSignedArea';
 import getWindingDirection from './getWindingDirection';
 import getNormal3 from './getNormal3';
 import getNormal2 from './getNormal2';
-import { mergePolylines, subtractPolylines } from './combinePolyline';
+import subtractPolylines from './subtractPolylines';
+import intersectPolylines from './intersectPolylines';
+import { mergePolylines } from './combinePolyline';
 import intersectPolyline from './intersectPolyline';
 import decimate from './decimate';
 import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
@@ -21,4 +23,5 @@ import pointCanProjectOnLine from './pointCanProjectOnLine';
 import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
 import { projectTo2D } from './projectTo2D';
 import convexHull from './convexHull';
-export { isClosed, containsPoint, containsPoints, getAABB, getArea, getSignedArea, getWindingDirection, getNormal3, getNormal2, intersectPolyline, decimate, getFirstLineSegmentIntersectionIndexes, getLineSegmentIntersectionsIndexes, getLineSegmentIntersectionsCoordinates, getClosestLineSegmentIntersection, getSubPixelSpacingAndXYDirections, pointsAreWithinCloseContourProximity, addCanvasPointsToArray, pointCanProjectOnLine, mergePolylines, subtractPolylines, isPointInsidePolyline3D, projectTo2D, convexHull, };
+import arePolylinesIdentical from './arePolylinesIdentical';
+export { isClosed, containsPoint, containsPoints, getAABB, getArea, getSignedArea, getWindingDirection, getNormal3, getNormal2, intersectPolyline, decimate, getFirstLineSegmentIntersectionIndexes, getLineSegmentIntersectionsIndexes, getLineSegmentIntersectionsCoordinates, getClosestLineSegmentIntersection, getSubPixelSpacingAndXYDirections, pointsAreWithinCloseContourProximity, addCanvasPointsToArray, pointCanProjectOnLine, mergePolylines, subtractPolylines, intersectPolylines, isPointInsidePolyline3D, projectTo2D, convexHull, arePolylinesIdentical, };

package/dist/esm/utilities/math/polyline/index.js

@@ -7,7 +7,9 @@ import getSignedArea from './getSignedArea';
 import getWindingDirection from './getWindingDirection';
 import getNormal3 from './getNormal3';
 import getNormal2 from './getNormal2';
-import { mergePolylines, subtractPolylines } from './combinePolyline';
+import subtractPolylines from './subtractPolylines';
+import intersectPolylines from './intersectPolylines';
+import { mergePolylines } from './combinePolyline';
 import intersectPolyline from './intersectPolyline';
 import decimate from './decimate';
 import getFirstLineSegmentIntersectionIndexes from './getFirstLineSegmentIntersectionIndexes';
@@ -21,4 +23,5 @@ import pointCanProjectOnLine from './pointCanProjectOnLine';
 import { isPointInsidePolyline3D } from './isPointInsidePolyline3D';
 import { projectTo2D } from './projectTo2D';
 import convexHull from './convexHull';
-export { isClosed, containsPoint, containsPoints, getAABB, getArea, getSignedArea, getWindingDirection, getNormal3, getNormal2, intersectPolyline, decimate, getFirstLineSegmentIntersectionIndexes, getLineSegmentIntersectionsIndexes, getLineSegmentIntersectionsCoordinates, getClosestLineSegmentIntersection, getSubPixelSpacingAndXYDirections, pointsAreWithinCloseContourProximity, addCanvasPointsToArray, pointCanProjectOnLine, mergePolylines, subtractPolylines, isPointInsidePolyline3D, projectTo2D, convexHull, };
+import arePolylinesIdentical from './arePolylinesIdentical';
+export { isClosed, containsPoint, containsPoints, getAABB, getArea, getSignedArea, getWindingDirection, getNormal3, getNormal2, intersectPolyline, decimate, getFirstLineSegmentIntersectionIndexes, getLineSegmentIntersectionsIndexes, getLineSegmentIntersectionsCoordinates, getClosestLineSegmentIntersection, getSubPixelSpacingAndXYDirections, pointsAreWithinCloseContourProximity, addCanvasPointsToArray, pointCanProjectOnLine, mergePolylines, subtractPolylines, intersectPolylines, isPointInsidePolyline3D, projectTo2D, convexHull, arePolylinesIdentical, };

package/dist/esm/utilities/math/polyline/intersectPolylines.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function intersectPolylines(mainPolyCoords: Types.Point2[], clipPolyCoordsInput: Types.Point2[]): Types.Point2[][];

package/dist/esm/utilities/math/polyline/intersectPolylines.js

@@ -0,0 +1,271 @@
+import { vec2 } from 'gl-matrix';
+import containsPoint from './containsPoint';
+import getSignedArea from './getSignedArea';
+import { EPSILON, IntersectionDirection, pointsAreEqual, PolylineNodeType, robustSegmentIntersection, } from './robustSegmentIntersection';
+export default function intersectPolylines(mainPolyCoords, clipPolyCoordsInput) {
+    if (mainPolyCoords.length < 3 || clipPolyCoordsInput.length < 3) {
+        return [];
+    }
+    let clipPolyCoords = clipPolyCoordsInput.slice();
+    const mainArea = getSignedArea(mainPolyCoords);
+    const clipArea = getSignedArea(clipPolyCoords);
+    if (Math.abs(mainArea) < EPSILON || Math.abs(clipArea) < EPSILON) {
+        return [];
+    }
+    if (mainArea < 0) {
+        mainPolyCoords = mainPolyCoords.slice().reverse();
+    }
+    if (clipArea < 0) {
+        clipPolyCoords = clipPolyCoords.slice().reverse();
+    }
+    const currentClipPolyForPIP = clipPolyCoords;
+    const intersections = [];
+    for (let i = 0; i < mainPolyCoords.length; i++) {
+        const p1 = mainPolyCoords[i];
+        const p2 = mainPolyCoords[(i + 1) % mainPolyCoords.length];
+        for (let j = 0; j < clipPolyCoords.length; j++) {
+            const q1 = clipPolyCoords[j];
+            const q2 = clipPolyCoords[(j + 1) % clipPolyCoords.length];
+            const intersectPt = robustSegmentIntersection(p1, p2, q1, q2);
+            if (intersectPt) {
+                const lenP = Math.sqrt(vec2.squaredDistance(p1, p2));
+                const lenQ = Math.sqrt(vec2.squaredDistance(q1, q2));
+                intersections.push({
+                    coord: [...intersectPt],
+                    seg1Idx: i,
+                    seg2Idx: j,
+                    alpha1: lenP < EPSILON
+                        ? 0
+                        : Math.sqrt(vec2.squaredDistance(p1, intersectPt)) / lenP,
+                    alpha2: lenQ < EPSILON
+                        ? 0
+                        : Math.sqrt(vec2.squaredDistance(q1, intersectPt)) / lenQ,
+                });
+            }
+        }
+    }
+    if (intersections.length === 0) {
+        if (containsPoint(currentClipPolyForPIP, mainPolyCoords[0]) &&
+            mainPolyCoords.every((pt) => containsPoint(currentClipPolyForPIP, pt))) {
+            return [[...mainPolyCoords.map((p) => [...p])]];
+        }
+        if (containsPoint(mainPolyCoords, clipPolyCoords[0]) &&
+            clipPolyCoords.every((pt) => containsPoint(mainPolyCoords, pt))) {
+            return [[...clipPolyCoords.map((p) => [...p])]];
+        }
+        return [];
+    }
+    const buildAugmentedList = (polyCoords, polyIndex, allIntersections) => {
+        const augmentedList = [];
+        let nodeIdCounter = 0;
+        for (let i = 0; i < polyCoords.length; i++) {
+            const p1 = polyCoords[i];
+            augmentedList.push({
+                id: `${polyIndex}_v${nodeIdCounter++}`,
+                coordinates: [...p1],
+                type: PolylineNodeType.Vertex,
+                originalPolyIndex: polyIndex,
+                originalVertexIndex: i,
+                next: null,
+                prev: null,
+                isIntersection: false,
+                visited: false,
+                processedInPath: false,
+                intersectionDir: IntersectionDirection.Unknown,
+            });
+            const segmentIntersections = allIntersections
+                .filter((isect) => (polyIndex === 0 ? isect.seg1Idx : isect.seg2Idx) === i)
+                .sort((a, b) => (polyIndex === 0 ? a.alpha1 : a.alpha2) -
+                (polyIndex === 0 ? b.alpha1 : b.alpha2));
+            for (const isect of segmentIntersections) {
+                if (augmentedList.length > 0 &&
+                    pointsAreEqual(augmentedList[augmentedList.length - 1].coordinates, isect.coord)) {
+                    const lastNode = augmentedList[augmentedList.length - 1];
+                    if (!lastNode.isIntersection) {
+                        lastNode.isIntersection = true;
+                        lastNode.intersectionInfo = isect;
+                        lastNode.alpha = polyIndex === 0 ? isect.alpha1 : isect.alpha2;
+                        lastNode.type = PolylineNodeType.Intersection;
+                    }
+                    continue;
+                }
+                augmentedList.push({
+                    id: `${polyIndex}_i${nodeIdCounter++}`,
+                    coordinates: [...isect.coord],
+                    type: PolylineNodeType.Intersection,
+                    originalPolyIndex: polyIndex,
+                    next: null,
+                    prev: null,
+                    isIntersection: true,
+                    visited: false,
+                    processedInPath: false,
+                    alpha: polyIndex === 0 ? isect.alpha1 : isect.alpha2,
+                    intersectionInfo: isect,
+                    intersectionDir: IntersectionDirection.Unknown,
+                });
+            }
+        }
+        const finalList = [];
+        if (augmentedList.length > 0) {
+            finalList.push(augmentedList[0]);
+            for (let i = 1; i < augmentedList.length; i++) {
+                if (!pointsAreEqual(augmentedList[i].coordinates, finalList[finalList.length - 1].coordinates)) {
+                    finalList.push(augmentedList[i]);
+                }
+                else {
+                    const lastNodeInFinal = finalList[finalList.length - 1];
+                    if (augmentedList[i].isIntersection &&
+                        augmentedList[i].intersectionInfo) {
+                        lastNodeInFinal.isIntersection = true;
+                        lastNodeInFinal.intersectionInfo =
+                            augmentedList[i].intersectionInfo;
+                        lastNodeInFinal.alpha = augmentedList[i].alpha;
+                        lastNodeInFinal.type = PolylineNodeType.Intersection;
+                    }
+                }
+            }
+        }
+        if (finalList.length > 1 &&
+            pointsAreEqual(finalList[0].coordinates, finalList[finalList.length - 1].coordinates)) {
+            const firstNode = finalList[0];
+            const lastNodePopped = finalList.pop();
+            if (lastNodePopped.isIntersection &&
+                !firstNode.isIntersection &&
+                lastNodePopped.intersectionInfo) {
+                firstNode.isIntersection = true;
+                firstNode.intersectionInfo = lastNodePopped.intersectionInfo;
+                firstNode.alpha = lastNodePopped.alpha;
+                firstNode.type = PolylineNodeType.Intersection;
+            }
+        }
+        if (finalList.length > 0) {
+            for (let i = 0; i < finalList.length; i++) {
+                finalList[i].next = finalList[(i + 1) % finalList.length];
+                finalList[i].prev =
+                    finalList[(i - 1 + finalList.length) % finalList.length];
+            }
+        }
+        return finalList;
+    };
+    const mainAugmented = buildAugmentedList(mainPolyCoords, 0, intersections);
+    const clipAugmented = buildAugmentedList(clipPolyCoords, 1, intersections);
+    if (mainAugmented.length === 0 || clipAugmented.length === 0) {
+        return [];
+    }
+    mainAugmented.forEach((mainNode) => {
+        if (mainNode.isIntersection && mainNode.intersectionInfo) {
+            const mainIntersectData = mainNode.intersectionInfo;
+            const partnerNode = clipAugmented.find((clipNode) => clipNode.isIntersection &&
+                clipNode.intersectionInfo &&
+                pointsAreEqual(clipNode.coordinates, mainNode.coordinates) &&
+                clipNode.intersectionInfo.seg1Idx === mainIntersectData.seg1Idx &&
+                clipNode.intersectionInfo.seg2Idx === mainIntersectData.seg2Idx);
+            if (partnerNode) {
+                mainNode.partnerNode = partnerNode;
+                partnerNode.partnerNode = mainNode;
+                const v_arrival_main = vec2.subtract(vec2.create(), mainNode.coordinates, mainNode.prev.coordinates);
+                const v_departure_clip = vec2.subtract(vec2.create(), partnerNode.next.coordinates, partnerNode.coordinates);
+                const crossZ = v_arrival_main[0] * v_departure_clip[1] -
+                    v_arrival_main[1] * v_departure_clip[0];
+                if (crossZ > EPSILON) {
+                    mainNode.intersectionDir = IntersectionDirection.Entering;
+                    partnerNode.intersectionDir = IntersectionDirection.Exiting;
+                }
+                else if (crossZ < -EPSILON) {
+                    mainNode.intersectionDir = IntersectionDirection.Exiting;
+                    partnerNode.intersectionDir = IntersectionDirection.Entering;
+                }
+                else {
+                    const midPrevMainSeg = [
+                        (mainNode.prev.coordinates[0] + mainNode.coordinates[0]) / 2,
+                        (mainNode.prev.coordinates[1] + mainNode.coordinates[1]) / 2,
+                    ];
+                    if (containsPoint(currentClipPolyForPIP, midPrevMainSeg)) {
+                        mainNode.intersectionDir = IntersectionDirection.Exiting;
+                        partnerNode.intersectionDir = IntersectionDirection.Entering;
+                    }
+                    else {
+                        mainNode.intersectionDir = IntersectionDirection.Entering;
+                        partnerNode.intersectionDir = IntersectionDirection.Exiting;
+                    }
+                }
+            }
+            else {
+                mainNode.isIntersection = false;
+                mainNode.intersectionInfo = undefined;
+            }
+        }
+    });
+    const resultPolygons = [];
+    for (const startCand of mainAugmented) {
+        if (!startCand.isIntersection ||
+            startCand.visited ||
+            startCand.intersectionDir !== IntersectionDirection.Entering) {
+            continue;
+        }
+        let currentPathCoords = [];
+        let currentNode = startCand;
+        let onMainList = true;
+        const pathStartNode = startCand;
+        let safetyBreak = 0;
+        const maxIter = (mainAugmented.length + clipAugmented.length) * 2;
+        mainAugmented.forEach((n) => (n.processedInPath = false));
+        clipAugmented.forEach((n) => (n.processedInPath = false));
+        do {
+            if (safetyBreak++ > maxIter) {
+                console.warn('Intersection: Max iterations in path tracing.', pathStartNode.id, currentNode.id);
+                currentPathCoords = [];
+                break;
+            }
+            if (currentNode.processedInPath && currentNode !== pathStartNode) {
+                console.warn('Intersection: Path processing loop detected, discarding path segment.', pathStartNode.id, currentNode.id);
+                currentPathCoords = [];
+                break;
+            }
+            currentNode.processedInPath = true;
+            currentNode.visited = true;
+            if (currentPathCoords.length === 0 ||
+                !pointsAreEqual(currentPathCoords[currentPathCoords.length - 1], currentNode.coordinates)) {
+                currentPathCoords.push([...currentNode.coordinates]);
+            }
+            let switchedList = false;
+            if (currentNode.isIntersection && currentNode.partnerNode) {
+                if (onMainList) {
+                    currentNode = currentNode.partnerNode;
+                    onMainList = false;
+                    switchedList = true;
+                }
+                else {
+                    currentNode = currentNode.partnerNode;
+                    onMainList = true;
+                    switchedList = true;
+                }
+            }
+            if (!switchedList) {
+                currentNode = currentNode.next;
+            }
+            else {
+                currentNode = currentNode.next;
+            }
+        } while (currentNode !== pathStartNode ||
+            (onMainList && currentNode.originalPolyIndex !== 0) ||
+            (!onMainList && currentNode.originalPolyIndex !== 1));
+        if (safetyBreak > maxIter || currentPathCoords.length === 0) {
+        }
+        else if (currentPathCoords.length > 0 &&
+            pointsAreEqual(currentPathCoords[0], currentPathCoords[currentPathCoords.length - 1])) {
+            currentPathCoords.pop();
+        }
+        if (currentPathCoords.length >= 3) {
+            const resultArea = getSignedArea(currentPathCoords);
+            if (mainArea > 0 && resultArea < 0) {
+                currentPathCoords.reverse();
+            }
+            else if (mainArea < 0 && resultArea > 0) {
+                currentPathCoords.reverse();
+            }
+            resultPolygons.push(currentPathCoords.map((p) => [...p]));
+        }
+    }
+    return resultPolygons;
+}