Use 4ry heap with delayed sorting

Author: JimBobSquarePants

src/PolygonClipper/PolygonClipper.cs

@@ -131,7 +131,8 @@ public Polygon Run()
         int clippingVertexCount = clipping.GetVertexCount();
         int eventCount = (subjectVertexCount + clippingVertexCount) * 2;
 
-        StablePriorityQueue<SweepEvent, SweepEventComparer> eventQueue = new(new SweepEventComparer(), eventCount);
+        SweepEventComparer comparer = new();
+        List<SweepEvent> unorderedEventQueue = new(eventCount);
         int contourId = 0;
 
         for (int i = 0; i < subject.ContourCount; i++)
@@ -140,7 +141,14 @@ public Polygon Run()
             contourId++;
             for (int j = 0; j < contour.VertexCount - 1; j++)
             {
-                ProcessSegment(contourId, contour.Segment(j), PolygonType.Subject, eventQueue, ref min, ref max);
+                ProcessSegment(
+                    contourId,
+                    contour.Segment(j),
+                    PolygonType.Subject,
+                    unorderedEventQueue,
+                    comparer,
+                    ref min,
+                    ref max);
             }
         }
 
@@ -155,7 +163,14 @@ public Polygon Run()
 
             for (int j = 0; j < contour.VertexCount - 1; j++)
             {
-                ProcessSegment(contourId, contour.Segment(j), PolygonType.Clipping, eventQueue, ref min, ref max);
+                ProcessSegment(
+                    contourId,
+                    contour.Segment(j),
+                    PolygonType.Clipping,
+                    unorderedEventQueue,
+                    comparer,
+                    ref min,
+                    ref max);
             }
         }
 
@@ -166,14 +181,14 @@ public Polygon Run()
         }
 
         // Sweep line algorithm: process events in the priority queue
+        StablePriorityQueue<SweepEvent, SweepEventComparer> eventQueue = new(comparer, unorderedEventQueue);
         List<SweepEvent> sortedEvents = new(eventCount);
 
         // Heuristic capacity for the sweep line status structure.
         // At any given point during the sweep, only a subset of segments
         // are active, so we preallocate half the subject's vertex count
         // to reduce resizing without overcommitting memory.
         StatusLine statusLine = new(subjectVertexCount >> 1);
-        SweepEventComparer comparer = eventQueue.Comparer;
         double subjectMaxX = subjectBB.Max.X;
         double minMaxX = Vertex.Min(subjectBB.Max, clippingBB.Max).X;
 
@@ -348,14 +363,16 @@ private static bool TryTrivialOperationForNonOverlappingBoundingBoxes(
     /// <param name="contourId">The identifier of the contour to which the segment belongs.</param>
     /// <param name="s">The segment to process.</param>
     /// <param name="pt">The polygon type to which the segment belongs.</param>
-    /// <param name="eventQueue">The event queue to add the generated events to.</param>
+    /// <param name="eventQueue">The unordered event queue to add the generated events to.</param>
+    /// <param name="comparer">The comparer used to determine the order of sweep events in the queue.</param>
     /// <param name="min">The minimum vertex of the bounding box.</param>
     /// <param name="max">The maximum vertex of the bounding box.</param>
     private static void ProcessSegment(
         int contourId,
         Segment s,
         PolygonType pt,
-        StablePriorityQueue<SweepEvent, SweepEventComparer> eventQueue,
+        List<SweepEvent> eventQueue,
+        SweepEventComparer comparer,
         ref Vertex min,
         ref Vertex max)
     {
@@ -372,7 +389,7 @@ private static void ProcessSegment(
         e1.ContourId = e2.ContourId = contourId;
 
         // Determine which endpoint is the left endpoint
-        if (eventQueue.Comparer.Compare(e1, e2) < 0)
+        if (comparer.Compare(e1, e2) < 0)
         {
             e2.Left = false;
         }
@@ -385,8 +402,8 @@ private static void ProcessSegment(
         max = Vertex.Max(max, s.Max);
 
         // Add the events to the event queue
-        eventQueue.Enqueue(e1);
-        eventQueue.Enqueue(e2);
+        eventQueue.Add(e1);
+        eventQueue.Add(e2);
     }
 
     /// <summary>

src/PolygonClipper/StablePriorityQueue{T,TComparer}.cs

@@ -18,6 +18,7 @@ namespace PolygonClipper;
 internal sealed class StablePriorityQueue<T, TComparer>
     where TComparer : IComparer<T>
 {
+    private const int Log2Arity = 2;
     private readonly List<T> heap;
 
     /// <summary>
@@ -31,6 +32,23 @@ public StablePriorityQueue(TComparer comparer, int capacity)
         this.heap = new List<T>(capacity > 0 ? capacity : 16);
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StablePriorityQueue{T, TComparer}"/> class
+    /// with a specified comparer and an initial collection of unordered elements.
+    /// The heap property is established in linear time.
+    /// </summary>
+    /// <param name="comparer">The comparer to determine the priority of the elements.</param>
+    /// <param name="items">
+    /// The initial collection of elements to heapify.
+    /// Note: The collection is modified to establish the heap property.
+    /// </param>
+    public StablePriorityQueue(TComparer comparer, List<T> items)
+    {
+        this.Comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
+        this.heap = items ?? throw new ArgumentNullException(nameof(items));
+        this.Heapify(this.heap);
+    }
+
     /// <summary>
     /// Gets the number of elements in the priority queue.
     /// </summary>
@@ -107,7 +125,7 @@ private void Up(uint index, List<T> heap)
 
         while (index > 0)
         {
-            uint parent = (index - 1u) >> 1;
+            uint parent = (index - 1u) >> Log2Arity;
             T current = Unsafe.Add(ref dRef, parent);
             if (comparer.Compare(item, current) >= 0)
             {
@@ -133,18 +151,21 @@ private void Down(uint index, List<T> heap)
         ref T dRef = ref MemoryMarshal.GetReference(data);
 
         uint length = (uint)data.Length;
-        uint halfLength = length >> 1;
         T item = Unsafe.Add(ref dRef, index);
         TComparer comparer = this.Comparer;
 
-        while (index < halfLength)
+        while ((index << Log2Arity) + 1u < length)
         {
-            uint bestChild = (index << 1) + 1; // Initially left child
-            uint right = bestChild + 1u;
+            uint firstChild = (index << Log2Arity) + 1u;
+            uint bestChild = firstChild;
+            uint maxChild = Math.Min(firstChild + (1u << Log2Arity), length);
 
-            if (right < length && comparer.Compare(Unsafe.Add(ref dRef, right), Unsafe.Add(ref dRef, bestChild)) < 0)
+            for (uint i = firstChild + 1u; i < maxChild; i++)
             {
-                bestChild = right;
+                if (comparer.Compare(Unsafe.Add(ref dRef, i), Unsafe.Add(ref dRef, bestChild)) < 0)
+                {
+                    bestChild = i;
+                }
             }
 
             if (comparer.Compare(Unsafe.Add(ref dRef, bestChild), item) >= 0)
@@ -159,6 +180,25 @@ private void Down(uint index, List<T> heap)
         Unsafe.Add(ref dRef, index) = item;
     }
 
+    /// <summary>
+    /// Heapifies the given list to establish the min-heap property.
+    /// </summary>
+    /// <param name="heap">The list to heapify.</param>
+    private void Heapify(List<T> heap)
+    {
+        int count = heap.Count;
+        if (count <= 1)
+        {
+            return;
+        }
+
+        int lastParent = (count - 2) >> Log2Arity;
+        for (int i = lastParent; i >= 0; i--)
+        {
+            this.Down((uint)i, heap);
+        }
+    }
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     private static void ThrowIfEmpty(int count)
     {