elksharp stabilization

src/__Libraries/StellaOps.ElkSharp/ElkEdgeRoutingGeometry.cs

@@ -92,6 +92,104 @@ internal static class ElkEdgeRoutingGeometry
         return false;
     }
 
+    internal static double ComputeSharedSegmentLength(
+        ElkPoint a1,
+        ElkPoint a2,
+        ElkPoint b1,
+        ElkPoint b2)
+    {
+        if (IsHorizontal(a1, a2) && IsHorizontal(b1, b2) && Math.Abs(a1.Y - b1.Y) <= CoordinateTolerance)
+        {
+            return Math.Max(0d, OverlapLength(
+                Math.Min(a1.X, a2.X),
+                Math.Max(a1.X, a2.X),
+                Math.Min(b1.X, b2.X),
+                Math.Max(b1.X, b2.X)));
+        }
+
+        if (IsVertical(a1, a2) && IsVertical(b1, b2) && Math.Abs(a1.X - b1.X) <= CoordinateTolerance)
+        {
+            return Math.Max(0d, OverlapLength(
+                Math.Min(a1.Y, a2.Y),
+                Math.Max(a1.Y, a2.Y),
+                Math.Min(b1.Y, b2.Y),
+                Math.Max(b1.Y, b2.Y)));
+        }
+
+        return 0d;
+    }
+
+    internal static double ComputeLongestSharedSegmentLength(ElkRoutedEdge left, ElkRoutedEdge right)
+    {
+        var leftSegments = FlattenSegments(left);
+        var rightSegments = FlattenSegments(right);
+        var longest = 0d;
+
+        foreach (var leftSegment in leftSegments)
+        {
+            foreach (var rightSegment in rightSegments)
+            {
+                longest = Math.Max(longest, ComputeSharedSegmentLength(
+                    leftSegment.Start,
+                    leftSegment.End,
+                    rightSegment.Start,
+                    rightSegment.End));
+            }
+        }
+
+        return longest;
+    }
+
+    internal static double ComputeLongestSharedApproachSegmentLength(
+        IReadOnlyList<ElkPoint> leftPath,
+        IReadOnlyList<ElkPoint> rightPath,
+        int maxSegmentsFromEnd = 3)
+    {
+        var leftSegments = FlattenSegmentsNearEnd(leftPath, maxSegmentsFromEnd);
+        var rightSegments = FlattenSegmentsNearEnd(rightPath, maxSegmentsFromEnd);
+        var longest = 0d;
+
+        foreach (var leftSegment in leftSegments)
+        {
+            foreach (var rightSegment in rightSegments)
+            {
+                longest = Math.Max(longest, ComputeSharedSegmentLength(
+                    leftSegment.Start,
+                    leftSegment.End,
+                    rightSegment.Start,
+                    rightSegment.End));
+            }
+        }
+
+        return longest;
+    }
+
+    internal static string ResolveBoundarySide(ElkPoint point, ElkPositionedNode node)
+    {
+        var distLeft = Math.Abs(point.X - node.X);
+        var distRight = Math.Abs(point.X - (node.X + node.Width));
+        var distTop = Math.Abs(point.Y - node.Y);
+        var distBottom = Math.Abs(point.Y - (node.Y + node.Height));
+        var min = Math.Min(Math.Min(distLeft, distRight), Math.Min(distTop, distBottom));
+
+        if (Math.Abs(min - distLeft) <= CoordinateTolerance)
+        {
+            return "left";
+        }
+
+        if (Math.Abs(min - distRight) <= CoordinateTolerance)
+        {
+            return "right";
+        }
+
+        if (Math.Abs(min - distTop) <= CoordinateTolerance)
+        {
+            return "top";
+        }
+
+        return "bottom";
+    }
+
     internal static bool AreCollinearAndOverlapping(ElkPoint a1, ElkPoint a2, ElkPoint b1, ElkPoint b2)
     {
         if (IsHorizontal(a1, a2) && IsHorizontal(b1, b2) && Math.Abs(a1.Y - b1.Y) <= CoordinateTolerance)
@@ -128,6 +226,25 @@ internal static class ElkEdgeRoutingGeometry
 
     private static bool IsVertical(ElkPoint start, ElkPoint end) => Math.Abs(start.X - end.X) <= CoordinateTolerance;
 
+    private static IReadOnlyList<RoutedEdgeSegment> FlattenSegmentsNearEnd(
+        IReadOnlyList<ElkPoint> path,
+        int maxSegmentsFromEnd)
+    {
+        if (path.Count < 2 || maxSegmentsFromEnd <= 0)
+        {
+            return [];
+        }
+
+        var startIndex = Math.Max(0, path.Count - (maxSegmentsFromEnd + 1));
+        var segments = new List<RoutedEdgeSegment>();
+        for (var i = startIndex; i < path.Count - 1; i++)
+        {
+            segments.Add(new RoutedEdgeSegment(string.Empty, path[i], path[i + 1]));
+        }
+
+        return segments;
+    }
+
     private static bool IntersectsOrthogonal(ElkPoint horizontalStart, ElkPoint horizontalEnd, ElkPoint verticalStart, ElkPoint verticalEnd)
     {
         var minHorizontalX = Math.Min(horizontalStart.X, horizontalEnd.X);