Incorporated the rust port

* Did not add the new SignedArea method. More tests are failing with it
* Did not touch the SegmentComparer. Adding it makes more tests fail

* We now only have 9 Tests failing

Author: stefannikolei

src/PolygonClipper/FloatExtensions.cs

@@ -0,0 +1,75 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace PolygonClipper;
+
+/// <summary>
+/// Provides extension methods for floating-point numbers.
+/// </summary>
+internal static class FloatExtensions
+{
+    /// <summary>
+    /// Returns the next representable double value in the direction of y.
+    /// </summary>
+    /// <remarks><see href="https://docs.rs/float_next_after/latest/src/float_next_after/lib.rs.html"/></remarks>
+    /// <param name="x">The starting floating-point number.</param>
+    /// <param name="y">The target floating-point number.</param>
+    /// <returns>The next representable value of x towards y.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static double NextAfter(this double x, double y)
+    {
+        // Special cases
+        if (double.IsNaN(x) || double.IsNaN(y))
+        {
+            return double.NaN;
+        }
+
+        if (x == y)
+        {
+            return y;
+        }
+
+        if (double.IsPositiveInfinity(x))
+        {
+            return double.PositiveInfinity;
+        }
+
+        if (double.IsNegativeInfinity(x))
+        {
+            return double.NegativeInfinity;
+        }
+
+        // Handle stepping from zero
+        if (x == 0D)
+        {
+            return Math.CopySign(double.Epsilon, y); // Smallest positive subnormal double
+        }
+
+        // Convert double to raw bits
+        long bits = BitConverter.DoubleToInt64Bits(x);
+
+        // Adjust bits to get the next representable value
+        if ((y > x) == (x > 0D)) // Moving in the same sign direction
+        {
+            bits++;
+        }
+        else
+        {
+            bits--;
+        }
+
+        // Convert bits back to double
+        double next = BitConverter.Int64BitsToDouble(bits);
+
+        // Ensure correct handling of signed zeros
+        if (next == 0D)
+        {
+            return Math.CopySign(next, x);
+        }
+
+        return next;
+    }
+}

src/PolygonClipper/PolygonClipper.cs

@@ -153,7 +153,8 @@ 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;
         }
@@ -221,17 +222,15 @@ public Polygon Run()
                 sweepEvent = sweepEvent.OtherEvent;
                 int it = sweepEvent.PosSL;
                 prevEvent = statusLine.Prev(it);
-
-                statusLine.RemoveAt(it);
-
-                // Shift `next` to account for the removal
-                nextEvent = statusLine.Next(it - 1);
+                nextEvent = statusLine.Next(it);
 
                 // Check intersection between neighbors
                 if (prevEvent != null && nextEvent != null)
                 {
                     _ = PossibleIntersection(prevEvent, nextEvent, eventQueue);
                 }
+
+                statusLine.RemoveAt(it);
             }
         }
 
@@ -364,25 +363,13 @@ private static void ProcessSegment(
         e1.ContourId = e2.ContourId = contourId;
 
         // Determine which endpoint is the left endpoint
-        //if (s.Min == s.Source)
-        //{
-        //    e2.Left = false;
-        //}
-        //else if (s.Min == s.Target)
-        //{
-        //    e1.Left = false;
-        //}
-        //else
-        {
-            // As a fallback, use the comparator for floating-point precision issues
-            if (eventQueue.Comparer.Compare(e1, e2) < 0)
-            {
-                e2.Left = false;
-            }
-            else
-            {
-                e1.Left = false;
-            }
+        if (eventQueue.Comparer.Compare(e1, e2) < 0)
+        {
+            e2.Left = false;
+        }
+        else
+        {
+            e1.Left = false;
         }
 
         min = Vertex.Min(min, s.Min);
@@ -503,8 +490,9 @@ private static bool InResult(SweepEvent sweepEvent, BooleanOperation operation)
             {
                 BooleanOperation.Intersection => !sweepEvent.OtherInOut,
                 BooleanOperation.Union => sweepEvent.OtherInOut,
-                BooleanOperation.Difference => (sweepEvent.OtherInOut && sweepEvent.PolygonType == PolygonType.Subject) ||
-                                            (!sweepEvent.OtherInOut && sweepEvent.PolygonType == PolygonType.Clipping),
+                BooleanOperation.Difference =>
+                    (sweepEvent.OtherInOut && sweepEvent.PolygonType == PolygonType.Subject) ||
+                    (!sweepEvent.OtherInOut && sweepEvent.PolygonType == PolygonType.Clipping),
                 BooleanOperation.Xor => true,
                 _ => false,
             },
@@ -711,7 +699,7 @@ private static void DivideSegment(
         {
             // TODO: enabling this line makes a single test issue76.geojson fail.
             // The files are different in the two reference repositories but both fail.
-            // p = new Vertex(NextAfter(p.X, true), p.Y);
+            p = new Vertex(p.X.NextAfter(double.PositiveInfinity), p.Y);
         }
 
         // Create the right event for the left segment (new right endpoint)
@@ -740,34 +728,6 @@ private static void DivideSegment(
         eventQueue.Enqueue(r);
     }
 
-    /// <summary>
-    /// Returns the next representable double-precision floating-point value in the given direction.
-    /// <see href="https://docs.rs/float_next_after/latest/float_next_after/trait.NextAfter.html"/>
-    /// </summary>
-    /// <param name="x">The starting double value.</param>
-    /// <param name="up">If true, moves towards positive infinity; otherwise, towards negative infinity.</param>
-    /// <returns>The next representable double in the given direction.</returns>
-    private static double NextAfter(double x, bool up)
-    {
-        if (double.IsNaN(x) || x == double.PositiveInfinity || x == double.NegativeInfinity)
-        {
-            return x; // NaN and infinity stay the same
-        }
-
-        // Convert double to its IEEE 754 bit representation
-        long bits = BitConverter.DoubleToInt64Bits(x);
-        if (up)
-        {
-            bits += (bits >= 0) ? 1 : -1; // Increase magnitude
-        }
-        else
-        {
-            bits += (bits > 0) ? -1 : 1; // Decrease magnitude
-        }
-
-        return BitConverter.Int64BitsToDouble(bits);
-    }
-
     /// <summary>
     /// Connects edges in the result polygon by processing the sweep events
     /// and constructing contours for the final result.
@@ -860,8 +820,7 @@ private static Polygon ConnectEdges(List<SweepEvent> sortedEvents, SweepEventCom
                 resultEvents[pos].OutputContourId = contourId;
                 contour.AddVertex(resultEvents[pos].Point);
                 pos = NextPos(pos, resultEvents, processed, originalPos);
-            }
-            while (pos != originalPos && pos < resultEvents.Count);
+            } while (pos != originalPos && pos < resultEvents.Count);
 
             result.Push(contour);
         }
@@ -878,7 +837,8 @@ private static Polygon ConnectEdges(List<SweepEvent> sortedEvents, SweepEventCom
                 polygon.Push(contour);
 
                 // Followed by holes if any
-                for (int j = 0; j < contour.HoleCount; j++) {
+                for (int j = 0; j < contour.HoleCount; j++)
+                {
                     int holeId = contour.GetHoleIndex(j);
                     polygon.Push(result[holeId]);
                 }

tests/PolygonClipper.Tests/FloatExtensionTests.cs

@@ -0,0 +1,35 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using Xunit;
+
+namespace PolygonClipper.Tests;
+
+public class FloatExtensionsTests
+{
+    public static TheoryData<double, double, double> NextAfterTestData => new()
+    {
+        { 0.0, double.PositiveInfinity, double.Epsilon },
+        { -0.0, double.PositiveInfinity, double.Epsilon },
+        { 0.0, double.NegativeInfinity, -double.Epsilon },
+        { -0.0, double.NegativeInfinity, -double.Epsilon },
+        { 1.0, double.PositiveInfinity, 1.0000000000000002 },
+        { 1.0, double.NegativeInfinity, 0.9999999999999999 },
+        { -1.0, double.PositiveInfinity, -0.9999999999999999 },
+        { -1.0, double.NegativeInfinity, -1.0000000000000002 },
+        { double.MaxValue, double.PositiveInfinity, double.PositiveInfinity },
+        { double.MinValue, double.NegativeInfinity, double.NegativeInfinity },
+        { double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity },
+        { double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity },
+        { double.NaN, double.PositiveInfinity, double.NaN },
+        { double.NaN, double.NegativeInfinity, double.NaN },
+    };
+
+    [Theory]
+    [MemberData(nameof(NextAfterTestData))]
+    public void NextAfter_ShouldReturnCorrectResult(double input, double target, double expected)
+    {
+        double result = input.NextAfter(target);
+        Assert.Equal(expected, result);
+    }
+}