Port PrecomputeIterationOrder

Author: stefannikolei

src/PolygonClipper/PolygonClipper.cs

@@ -742,7 +742,11 @@ private static Polygon ConnectEdges(List<SweepEvent> sortedEvents, SweepEventCom
         for (int i = 0; i < sortedEvents.Count; i++)
         {
             SweepEvent se = sortedEvents[i];
-            if ((se.Left && se.InResult) || (!se.Left && se.OtherEvent.InResult))
+            if ((se.Left && se.InResult))
+            {
+                resultEvents.Add(se);
+            }
+            else if (!se.Left && se.OtherEvent.InResult)
             {
                 resultEvents.Add(se);
             }
@@ -777,12 +781,14 @@ private static Polygon ConnectEdges(List<SweepEvent> sortedEvents, SweepEventCom
         for (int i = 0; i < resultEvents.Count; i++)
         {
             SweepEvent sweepEvent = resultEvents[i];
-            if (!sweepEvent.Left)
+            if (sweepEvent.Left)
             {
                 (sweepEvent.OtherEvent.Pos, sweepEvent.Pos) = (sweepEvent.Pos, sweepEvent.OtherEvent.Pos);
             }
         }
 
+        ReadOnlySpan<int> iterationMap = PrecomputeIterationOrder(resultEvents);
+
         Polygon result = new();
         Span<bool> processed = new bool[resultEvents.Count];
         for (int i = 0; i < resultEvents.Count; i++)
@@ -796,31 +802,29 @@ private static Polygon ConnectEdges(List<SweepEvent> sortedEvents, SweepEventCom
             Contour contour = InitializeContourFromContext(resultEvents[i], result, contourId);
 
             int pos = i;
-            int originalPos = i;
             Vertex initial = resultEvents[i].Point;
             contour.AddVertex(initial);
 
             // Main loop to process the contour
-            do
+            while (true)
             {
-                processed[pos] = true;
-                resultEvents[pos].OutputContourId = contourId;
+                MarkProcessed(resultEvents[pos], processed, pos, contourId);
+                pos = resultEvents[pos].Pos;
+
+                MarkProcessed(resultEvents[pos], processed, pos, contourId);
 
-                if (resultEvents[pos].Left)
+                contour.AddVertex(resultEvents[pos].Point);
+                pos = NextPos(pos, processed, iterationMap, out bool found);
+                if (!found)
                 {
-                    resultEvents[pos].ResultInOut = false;
+                    break;
                 }
-                else
+
+                if (resultEvents[pos].Point == initial)
                 {
-                    resultEvents[pos].OtherEvent.ResultInOut = true;
+                    break;
                 }
-
-                pos = resultEvents[pos].Pos;
-                processed[pos] = true;
-                resultEvents[pos].OutputContourId = contourId;
-                contour.AddVertex(resultEvents[pos].Point);
-                pos = NextPos(pos, resultEvents, processed, originalPos);
-            } while (pos != originalPos && pos < resultEvents.Count);
+            }
 
             result.Push(contour);
         }
@@ -848,6 +852,95 @@ private static Polygon ConnectEdges(List<SweepEvent> sortedEvents, SweepEventCom
         return polygon;
     }
 
+    private static ReadOnlySpan<int> PrecomputeIterationOrder(List<SweepEvent> data)
+    {
+        Span<int> map = new Span<int>(new int[data.Count]);
+
+        int i = 0;
+        while (i < data.Count)
+        {
+            SweepEvent xRef = data[i];
+
+            // Find index range of R events
+            int rFrom = i;
+            while (i < data.Count && xRef.Point == data[i].Point && !data[i].Left)
+            {
+                i++;
+            }
+
+            int rUptoExclusive = i;
+
+            // Find index range of L events
+            int lFrom = i;
+            while (i < data.Count && xRef.Point == data[i].Point)
+            {
+                if (!data[i].Left)
+                {
+                    throw new InvalidOperationException("Expected left event");
+                }
+
+                i++;
+            }
+
+            int lUptoExclusive = i;
+
+            bool hasREvents = rUptoExclusive > rFrom;
+            bool hasLEvents = lUptoExclusive > lFrom;
+
+            if (hasREvents)
+            {
+                int rUpto = rUptoExclusive - 1;
+
+                // Connect elements in [rFrom, rUpto) to larger index
+                for (int j = rFrom; j < rUpto; j++)
+                {
+                    map[j] = j + 1;
+                }
+
+                // Special handling of *last* element: Connect either the last L event
+                // or loop back to start of R events (if no L events).
+                if (hasLEvents)
+                {
+                    map[rUpto] = lUptoExclusive - 1;
+                }
+                else
+                {
+                    map[rUpto] = rFrom;
+                }
+            }
+
+            if (hasLEvents)
+            {
+                int lUpto = lUptoExclusive - 1;
+
+                // Connect elements in (lFrom, lUpto] to lower index
+                for (int j = lFrom + 1; j <= lUpto; j++)
+                {
+                    map[j] = j - 1;
+                }
+
+                // Special handling of *first* element: Connect either to the first R event
+                // or loop back to end of L events (if no R events).
+                if (hasREvents)
+                {
+                    map[lFrom] = rFrom;
+                }
+                else
+                {
+                    map[lFrom] = lUpto;
+                }
+            }
+        }
+
+        return map;
+    }
+
+    private static void MarkProcessed(SweepEvent sweepEvent, Span<bool> processed, int pos, int contourId)
+    {
+        processed[pos] = true;
+        sweepEvent.OutputContourId = contourId;
+    }
+
     /// <summary>
     /// Initializes a contour based on its context in relation to previous events and contours.
     /// Implements the 4 cases of parent contours from the Martinez paper (Fig. 4).
@@ -915,6 +1008,8 @@ private static Contour InitializeContourFromContext(SweepEvent sweepEvent, Polyg
     /// <param name="resultEvents">The list of sweep events representing result segments.</param>
     /// <param name="processed">A list indicating whether each event at the corresponding index has been processed.</param>
     /// <param name="originalPos">The original position to return if no unprocessed event is found.</param>
+    /// <param name="iterationMap"></param>
+    /// <param name="found"></param>
     /// <returns>The index of the next unprocessed position.</returns>
     /// <remarks>
     /// This method searches forward from the current position until it finds an unprocessed event with
@@ -923,41 +1018,27 @@ private static Contour InitializeContourFromContext(SweepEvent sweepEvent, Polyg
     /// </remarks>
     private static int NextPos(
         int pos,
-        List<SweepEvent> resultEvents,
         ReadOnlySpan<bool> processed,
-        int originalPos)
+        ReadOnlySpan<int> iterationMap,
+        out bool found)
     {
-        int newPos = pos + 1;
-        Vertex initial = resultEvents[pos].Point;
-        Vertex next = default;
-
-        if (newPos < resultEvents.Count)
-        {
-            next = resultEvents[newPos].Point;
-        }
+        int startPos = pos;
 
-        // Search forward for the next unprocessed event with a different point
-        while (newPos < resultEvents.Count && initial == next)
+        while (true)
         {
-            if (!processed[newPos])
+            pos = iterationMap[pos];
+            if (pos == startPos)
             {
-                return newPos;
+                // Entire group is already processed?
+                found = false;
+                return Int32.MinValue;
             }
 
-            newPos++;
-            if (newPos < resultEvents.Count)
+            if (!processed[pos])
             {
-                next = resultEvents[newPos].Point;
+                found = true;
+                return pos;
             }
         }
-
-        // If not found, search backward for an unprocessed event
-        newPos = pos - 1;
-        while (newPos > originalPos && processed[newPos])
-        {
-            newPos--;
-        }
-
-        return newPos;
     }
 }