Copy rust implementation

Author: JimBobSquarePants

src/PolygonClipper/PolygonClipper.cs

@@ -137,11 +137,11 @@ public Polygon Run()
         // Process all segments in the clipping polygon
         min = new Vertex(double.PositiveInfinity);
         max = new Vertex(double.NegativeInfinity);
+
         for (int i = 0; i < clipping.ContourCount; i++)
         {
             Contour contour = clipping[i];
-            bool exterior = operation != BooleanOperation.Difference;
-            if (exterior)
+            if (operation != BooleanOperation.Difference)
             {
                 contourId++;
             }
@@ -153,8 +153,7 @@ public Polygon Run()
         }
 
         Box2 clippingBB = new(min, max);
-        if (TryTrivialOperationForNonOverlappingBoundingBoxes(subject, clipping, subjectBB, clippingBB, operation,
-                out result))
+        if (TryTrivialOperationForNonOverlappingBoundingBoxes(subject, clipping, subjectBB, clippingBB, operation, out result))
         {
             return result;
         }
@@ -393,6 +392,10 @@ private static void ComputeFields(SweepEvent le, SweepEvent? prev, BooleanOperat
         {
             le.InOut = false;
             le.OtherInOut = true;
+
+            // Clearing the previous result is necessary for recomputing the result.
+            // if the first computation has set the result it is not valid anymore.
+            le.PrevInResult = null;
         }
         else if (le.PolygonType == prev.PolygonType)
         {
@@ -404,15 +407,28 @@ private static void ComputeFields(SweepEvent le, SweepEvent? prev, BooleanOperat
         {
             // Previous line segment in sl belongs to a different polygon that "se" belongs to.
             le.InOut = !prev.OtherInOut;
-            le.OtherInOut = prev.Vertical() ? !prev.InOut : prev.InOut;
+            le.OtherInOut = prev.Vertical ? !prev.InOut : prev.InOut;
         }
 
-        // Compute PrevInResult field
+        // Connect to previous in result: Only use the given `prev` if it is
+        // part of the result and not a vertical segment. Otherwise connect
+        // to its previous in result if any.
         if (prev != null)
         {
-            le.PrevInResult = (!InResult(prev, operation) || prev.Vertical())
-                ? prev.PrevInResult
-                : prev;
+            if (prev.InResult && !prev.Vertical)
+            {
+                le.PrevInResult = prev;
+            }
+            else if (prev.PrevInResult != null)
+            {
+                le.PrevInResult = prev.PrevInResult;
+            }
+            else
+            {
+                // Clearing the previous result is necessary for recomputing the result.
+                // if the first computation has set the result it is not valid anymore.
+                le.PrevInResult = null;
+            }
         }
 
         // Check if the line segment belongs to the Boolean operation
@@ -742,11 +758,9 @@ 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))
-            {
-                resultEvents.Add(se);
-            }
-            else if (!se.Left && se.OtherEvent.InResult)
+            bool include = (se.Left && se.InResult) || (!se.Left && se.OtherEvent.InResult);
+
+            if (include)
             {
                 resultEvents.Add(se);
             }
@@ -831,7 +845,6 @@ private static Polygon ConnectEdges(List<SweepEvent> sortedEvents, SweepEventCom
 
         Polygon polygon = new();
 
-
         for (int i = 0; i < result.ContourCount; i++)
         {
             Contour contour = result[i];

src/PolygonClipper/ResultTransition.cs

@@ -9,17 +9,17 @@ namespace PolygonClipper;
 public enum ResultTransition
 {
     /// <summary>
-    /// The event does not contribute to the result.
+    /// The event transitions within the result.
     /// </summary>
-    NonContributing = -1,
+    Neutral = 0,
 
     /// <summary>
-    /// The event transitions within the result.
+    /// The event does not contribute to the result.
     /// </summary>
-    Neutral = 0,
+    NonContributing = 1,
 
     /// <summary>
     /// The event contributes to the result.
     /// </summary>
-    Contributing = 1
+    Contributing = 2
 }

src/PolygonClipper/SweepEvent.cs

@@ -129,6 +129,14 @@ public SweepEvent(Vertex point, bool left, int contourId)
     /// </summary>
     public bool InResult => this.ResultTransition != ResultTransition.Neutral;
 
+    /// <summary>
+    /// Gets a value indicating whether the line segment (point, otherEvent->point) is a vertical line segment.
+    /// </summary>
+    /// <returns>
+    /// <see langword="true"/> if the line segment is vertical; otherwise <see langword="false"/>.
+    /// </returns>
+    public bool Vertical => this.Point.X == this.OtherEvent.Point.X;
+
     /// <summary>
     /// Gets or sets the position of the event in the sorted events.
     /// </summary>
@@ -167,15 +175,6 @@ public bool Below(Vertex p)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool Above(Vertex p) => !this.Below(p);
 
-    /// <summary>
-    /// Is the line segment (point, otherEvent->point) a vertical line segment.
-    /// </summary>
-    /// <returns>
-    /// <see langword="true"/> if the line segment is vertical; otherwise <see langword="false"/>.
-    /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool Vertical() => this.Point.X == this.OtherEvent.Point.X;
-
     /// <summary>
     /// Returns the segment associated with the sweep event.
     /// </summary>

tests/PolygonClipper.Tests/SweepEventTests.cs

@@ -49,7 +49,7 @@ public void IsAbove()
     public void IsVertical()
     {
         // Act & Assert
-        Assert.True(new SweepEvent(new Vertex(0, 0), true, new SweepEvent(new Vertex(0, 1), false)).Vertical());
-        Assert.False(new SweepEvent(new Vertex(0, 0), true, new SweepEvent(new Vertex(0.0001F, 1), false)).Vertical());
+        Assert.True(new SweepEvent(new Vertex(0, 0), true, new SweepEvent(new Vertex(0, 1), false)).Vertical);
+        Assert.False(new SweepEvent(new Vertex(0, 0), true, new SweepEvent(new Vertex(0.0001F, 1), false)).Vertical);
     }
 }