@cornerstonejs/tools 3.24.0 → 3.25.0

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;
+}

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

@@ -0,0 +1,37 @@
+import { type Types } from '@cornerstonejs/core';
+export declare const EPSILON = 1e-7;
+export declare function vec2CrossZ(a: Types.Point2, b: Types.Point2): number;
+export declare function pointsAreEqual(p1: Types.Point2, p2: Types.Point2): boolean;
+export declare function robustSegmentIntersection(p1: Types.Point2, p2: Types.Point2, q1: Types.Point2, q2: Types.Point2): Types.Point2 | null;
+export declare enum PolylineNodeType {
+    Vertex = 0,
+    Intersection = 1
+}
+export declare enum IntersectionDirection {
+    Entering = 0,
+    Exiting = 1,
+    Unknown = 2
+}
+export interface AugmentedPolyNode {
+    id: string;
+    coordinates: Types.Point2;
+    type: PolylineNodeType;
+    originalPolyIndex: 0 | 1;
+    originalVertexIndex?: number;
+    next: AugmentedPolyNode;
+    prev: AugmentedPolyNode;
+    isIntersection: boolean;
+    partnerNode?: AugmentedPolyNode;
+    intersectionDir?: IntersectionDirection;
+    intersectionInfo?: IntersectionInfo;
+    alpha?: number;
+    processedInPath?: boolean;
+    visited: boolean;
+}
+export type IntersectionInfo = {
+    coord: Types.Point2;
+    seg1Idx: number;
+    seg2Idx: number;
+    alpha1: number;
+    alpha2: number;
+};

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

@@ -0,0 +1,78 @@
+import { utilities } from '@cornerstonejs/core';
+import { vec2 } from 'gl-matrix';
+export const EPSILON = 1e-7;
+export function vec2CrossZ(a, b) {
+    return a[0] * b[1] - a[1] * b[0];
+}
+export function pointsAreEqual(p1, p2) {
+    return utilities.isEqual(p1, p2, EPSILON);
+}
+export function robustSegmentIntersection(p1, p2, q1, q2) {
+    const r = vec2.subtract(vec2.create(), p2, p1);
+    const s = vec2.subtract(vec2.create(), q2, q1);
+    const rxs = vec2CrossZ(r, s);
+    const qmp = vec2.subtract(vec2.create(), q1, p1);
+    const qmpxr = vec2CrossZ(qmp, r);
+    if (Math.abs(rxs) < EPSILON) {
+        if (Math.abs(qmpxr) < EPSILON) {
+            const rDotR = vec2.dot(r, r);
+            const sDotS = vec2.dot(s, s);
+            if (rDotR < EPSILON || sDotS < EPSILON) {
+                if (pointsAreEqual(p1, q1) || pointsAreEqual(p1, q2)) {
+                    return p1;
+                }
+                if (pointsAreEqual(p2, q1) || pointsAreEqual(p2, q2)) {
+                    return p2;
+                }
+                return null;
+            }
+            const t0 = vec2.dot(vec2.subtract(vec2.create(), q1, p1), r) / rDotR;
+            const t1 = vec2.dot(vec2.subtract(vec2.create(), q2, p1), r) / rDotR;
+            const u0 = vec2.dot(vec2.subtract(vec2.create(), p1, q1), s) / sDotS;
+            const u1 = vec2.dot(vec2.subtract(vec2.create(), p2, q1), s) / sDotS;
+            const isInRange = (t) => t >= -EPSILON && t <= 1 + EPSILON;
+            if (isInRange(t0)) {
+                const projectedPoint = vec2.scaleAndAdd(vec2.create(), p1, r, t0);
+                if (pointsAreEqual(q1, projectedPoint)) {
+                    return q1;
+                }
+            }
+            if (isInRange(t1)) {
+                const projectedPoint = vec2.scaleAndAdd(vec2.create(), p1, r, t1);
+                if (pointsAreEqual(q2, projectedPoint)) {
+                    return q2;
+                }
+            }
+            if (isInRange(u0)) {
+                const projectedPoint = vec2.scaleAndAdd(vec2.create(), q1, s, u0);
+                if (pointsAreEqual(p1, projectedPoint)) {
+                    return p1;
+                }
+            }
+            if (isInRange(u1)) {
+                const projectedPoint = vec2.scaleAndAdd(vec2.create(), q1, s, u1);
+                if (pointsAreEqual(p2, projectedPoint)) {
+                    return p2;
+                }
+            }
+        }
+        return null;
+    }
+    const t = vec2CrossZ(qmp, s) / rxs;
+    const u = qmpxr / rxs;
+    if (t >= -EPSILON && t <= 1 + EPSILON && u >= -EPSILON && u <= 1 + EPSILON) {
+        return [p1[0] + t * r[0], p1[1] + t * r[1]];
+    }
+    return null;
+}
+export var PolylineNodeType;
+(function (PolylineNodeType) {
+    PolylineNodeType[PolylineNodeType["Vertex"] = 0] = "Vertex";
+    PolylineNodeType[PolylineNodeType["Intersection"] = 1] = "Intersection";
+})(PolylineNodeType || (PolylineNodeType = {}));
+export var IntersectionDirection;
+(function (IntersectionDirection) {
+    IntersectionDirection[IntersectionDirection["Entering"] = 0] = "Entering";
+    IntersectionDirection[IntersectionDirection["Exiting"] = 1] = "Exiting";
+    IntersectionDirection[IntersectionDirection["Unknown"] = 2] = "Unknown";
+})(IntersectionDirection || (IntersectionDirection = {}));

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

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