@cornerstonejs/tools 3.24.0 → 3.26.0

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[][];

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

@@ -0,0 +1,210 @@
+import { vec2 } from 'gl-matrix';
+import getSignedArea from './getSignedArea';
+import { EPSILON, IntersectionDirection, pointsAreEqual, PolylineNodeType, robustSegmentIntersection, } from './robustSegmentIntersection';
+import containsPoint from './containsPoint';
+import arePolylinesIdentical from './arePolylinesIdentical';
+export default function subtractPolylines(targetPolylineCoords, sourcePolylineCoordsInput) {
+    if (targetPolylineCoords.length < 3) {
+        return [];
+    }
+    if (sourcePolylineCoordsInput.length < 3) {
+        return [targetPolylineCoords.slice()];
+    }
+    const sourcePolylineCoords = sourcePolylineCoordsInput.slice();
+    if (arePolylinesIdentical(targetPolylineCoords, sourcePolylineCoordsInput)) {
+        return [];
+    }
+    const targetArea = getSignedArea(targetPolylineCoords);
+    const sourceArea = getSignedArea(sourcePolylineCoords);
+    if (Math.sign(targetArea) === Math.sign(sourceArea) &&
+        Math.abs(sourceArea) > EPSILON) {
+        sourcePolylineCoords.reverse();
+    }
+    const intersections = [];
+    for (let i = 0; i < targetPolylineCoords.length; i++) {
+        const p1 = targetPolylineCoords[i];
+        const p2 = targetPolylineCoords[(i + 1) % targetPolylineCoords.length];
+        for (let j = 0; j < sourcePolylineCoords.length; j++) {
+            const q1 = sourcePolylineCoords[j];
+            const q2 = sourcePolylineCoords[(j + 1) % sourcePolylineCoords.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,
+                });
+            }
+        }
+    }
+    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,
+            });
+            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)) {
+                    if (!augmentedList[augmentedList.length - 1].isIntersection) {
+                        augmentedList[augmentedList.length - 1].isIntersection = true;
+                        augmentedList[augmentedList.length - 1].intersectionInfo = isect;
+                        augmentedList[augmentedList.length - 1].alpha =
+                            polyIndex === 0 ? isect.alpha1 : isect.alpha2;
+                    }
+                    continue;
+                }
+                augmentedList.push({
+                    id: `${polyIndex}_i${nodeIdCounter++}`,
+                    coordinates: isect.coord,
+                    type: PolylineNodeType.Intersection,
+                    originalPolyIndex: polyIndex,
+                    next: null,
+                    prev: null,
+                    isIntersection: true,
+                    visited: false,
+                    alpha: polyIndex === 0 ? isect.alpha1 : isect.alpha2,
+                    intersectionInfo: isect,
+                });
+            }
+        }
+        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 {
+                    if (augmentedList[i].isIntersection) {
+                        finalList[finalList.length - 1].isIntersection = true;
+                        finalList[finalList.length - 1].intersectionInfo =
+                            augmentedList[i].intersectionInfo;
+                        finalList[finalList.length - 1].alpha = augmentedList[i].alpha;
+                    }
+                }
+            }
+        }
+        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 targetAugmented = buildAugmentedList(targetPolylineCoords, 0, intersections);
+    const sourceAugmented = buildAugmentedList(sourcePolylineCoords, 1, intersections);
+    targetAugmented.forEach((tnode) => {
+        if (tnode.isIntersection) {
+            const tData = tnode.intersectionInfo;
+            const partner = sourceAugmented.find((snode) => snode.isIntersection &&
+                pointsAreEqual(snode.coordinates, tnode.coordinates) &&
+                snode.intersectionInfo.seg1Idx ===
+                    tData.seg1Idx &&
+                snode.intersectionInfo.seg2Idx === tData.seg2Idx);
+            if (partner) {
+                tnode.partnerNode = partner;
+                partner.partnerNode = tnode;
+                const p_prev = tnode.prev.coordinates;
+                const p_curr = tnode.coordinates;
+                const p_next_source = partner.next.coordinates;
+                const v_target_arrival = vec2.subtract(vec2.create(), p_curr, p_prev);
+                const v_source_departure = vec2.subtract(vec2.create(), p_next_source, p_curr);
+                const midPrevTargetSeg = [
+                    (tnode.prev.coordinates[0] + tnode.coordinates[0]) / 2,
+                    (tnode.prev.coordinates[1] + tnode.coordinates[1]) / 2,
+                ];
+                const prevSegMidpointInsideSource = containsPoint(sourcePolylineCoordsInput, midPrevTargetSeg);
+                if (prevSegMidpointInsideSource) {
+                    tnode.intersectionDir = IntersectionDirection.Exiting;
+                }
+                else {
+                    tnode.intersectionDir = IntersectionDirection.Entering;
+                }
+            }
+            else {
+                tnode.isIntersection = false;
+            }
+        }
+    });
+    targetAugmented.forEach((n) => delete n.intersectionInfo);
+    sourceAugmented.forEach((n) => delete n.intersectionInfo);
+    const resultPolylines = [];
+    for (let i = 0; i < targetAugmented.length; i++) {
+        const startNode = targetAugmented[i];
+        if (startNode.visited || startNode.isIntersection) {
+            continue;
+        }
+        if (containsPoint(sourcePolylineCoordsInput, startNode.coordinates)) {
+            continue;
+        }
+        const currentPathCoords = [];
+        let currentNode = startNode;
+        let onTargetList = true;
+        let safetyBreak = 0;
+        const maxIter = (targetAugmented.length + sourceAugmented.length) * 2;
+        do {
+            if (safetyBreak++ > maxIter) {
+                console.warn('Subtraction: Max iterations reached, possible infinite loop.');
+                break;
+            }
+            currentNode.visited = true;
+            if (currentPathCoords.length === 0 ||
+                !pointsAreEqual(currentPathCoords[currentPathCoords.length - 1], currentNode.coordinates)) {
+                currentPathCoords.push(currentNode.coordinates);
+            }
+            if (currentNode.isIntersection) {
+                if (onTargetList) {
+                    if (currentNode.intersectionDir === IntersectionDirection.Entering &&
+                        currentNode.partnerNode) {
+                        currentNode = currentNode.partnerNode;
+                        onTargetList = false;
+                    }
+                }
+                else {
+                    if (currentNode.partnerNode) {
+                        currentNode = currentNode.partnerNode;
+                        onTargetList = true;
+                    }
+                    else {
+                        console.warn('Subtraction: Intersection on source without partner.');
+                    }
+                }
+            }
+            currentNode = currentNode.next;
+        } while (currentNode !== startNode || !onTargetList);
+        if (currentPathCoords.length >= 3) {
+            if (pointsAreEqual(currentPathCoords[0], currentPathCoords[currentPathCoords.length - 1])) {
+                currentPathCoords.pop();
+            }
+            if (currentPathCoords.length >= 3) {
+                resultPolylines.push(currentPathCoords);
+            }
+        }
+    }
+    return resultPolylines;
+}

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.24.0";
+export declare const version = "3.26.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.24.0';
+export const version = '3.26.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.24.0",
+  "version": "3.26.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.24.0",
+    "@cornerstonejs/core": "^3.26.0",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "c5fbc9b942368afc0e6835ca3f3747b1e4510182"
+  "gitHead": "a851443310a66ee3620011723733112128c2a7ba"
 }

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

@@ -1,31 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-export declare function unifyPolylineSets(polylinesSetA: Types.Point2[][], polylinesSetB: Types.Point2[][]): Types.Point2[][];
-export declare function unifyMultiplePolylineSets(polylineSets: Types.Point2[][][]): Types.Point2[][];
-export declare function unifyAnnotationPolylines(annotationsSetA: Array<{
-    data: {
-        contour: {
-            polyline: Types.Point3[];
-        };
-    };
-}>, annotationsSetB: Array<{
-    data: {
-        contour: {
-            polyline: Types.Point3[];
-        };
-    };
-}>, viewport: Types.IViewport): Types.Point2[][];
-export declare function subtractPolylineSets(polylinesSetA: Types.Point2[][], polylinesSetB: Types.Point2[][]): Types.Point2[][];
-export declare function subtractMultiplePolylineSets(basePolylineSet: Types.Point2[][], subtractorSets: Types.Point2[][][]): Types.Point2[][];
-export declare function subtractAnnotationPolylines(baseAnnotations: Array<{
-    data: {
-        contour: {
-            polyline: Types.Point3[];
-        };
-    };
-}>, subtractorAnnotations: Array<{
-    data: {
-        contour: {
-            polyline: Types.Point3[];
-        };
-    };
-}>, viewport: Types.IViewport): Types.Point2[][];

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

@@ -1,110 +0,0 @@
-import * as math from '../math';
-import { checkIntersection } from './sharedOperations';
-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];
-            const intersection = checkIntersection(polylineA, polylineB);
-            if (intersection.hasIntersection && !intersection.isContourHole) {
-                const mergedPolyline = math.polyline.mergePolylines(polylineA, polylineB);
-                result.push(mergedPolyline);
-                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].map((polyline) => [...polyline]);
-    }
-    let result = polylineSets[0].map((polyline) => [...polyline]);
-    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) => convertPolylineToCanvasSpace(annotation.data.contour.polyline, viewport));
-    const polylinesSetB = annotationsSetB.map((annotation) => convertPolylineToCanvasSpace(annotation.data.contour.polyline, viewport));
-    return unifyPolylineSets(polylinesSetA, polylinesSetB);
-}
-function convertPolylineToCanvasSpace(polyline, viewport) {
-    const numPoints = polyline.length;
-    const projectedPolyline = new Array(numPoints);
-    for (let i = 0; i < numPoints; i++) {
-        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
-    }
-    return projectedPolyline;
-}
-export function subtractPolylineSets(polylinesSetA, polylinesSetB) {
-    const result = [];
-    const processedFromA = new Set();
-    for (let i = 0; i < polylinesSetA.length; i++) {
-        if (processedFromA.has(i)) {
-            continue;
-        }
-        let currentPolylines = [polylinesSetA[i]];
-        let wasSubtracted = false;
-        for (let j = 0; j < polylinesSetB.length; j++) {
-            const polylineB = polylinesSetB[j];
-            const newPolylines = [];
-            for (const currentPolyline of currentPolylines) {
-                const intersection = checkIntersection(currentPolyline, polylineB);
-                if (intersection.hasIntersection && !intersection.isContourHole) {
-                    const subtractedPolylines = math.polyline.subtractPolylines(currentPolyline, polylineB);
-                    newPolylines.push(...subtractedPolylines);
-                    wasSubtracted = true;
-                }
-                else {
-                    newPolylines.push(currentPolyline);
-                }
-            }
-            currentPolylines = newPolylines;
-        }
-        result.push(...currentPolylines);
-        processedFromA.add(i);
-    }
-    return result;
-}
-export function subtractMultiplePolylineSets(basePolylineSet, subtractorSets) {
-    if (subtractorSets.length === 0) {
-        return basePolylineSet.map((polyline) => [...polyline]);
-    }
-    let result = basePolylineSet.map((polyline) => [...polyline]);
-    for (let i = 0; i < subtractorSets.length; i++) {
-        result = subtractPolylineSets(result, subtractorSets[i]);
-    }
-    return result;
-}
-export function subtractAnnotationPolylines(baseAnnotations, subtractorAnnotations, viewport) {
-    const basePolylines = baseAnnotations.map((annotation) => convertPolylineToCanvasSpace(annotation.data.contour.polyline, viewport));
-    const subtractorPolylines = subtractorAnnotations.map((annotation) => convertPolylineToCanvasSpace(annotation.data.contour.polyline, viewport));
-    return subtractPolylineSets(basePolylines, subtractorPolylines);
-}