Merge pull request #17 from SixLabors/js/optimize-possible-intersection

Reduce allocations and internal copies

Author: JimBobSquarePants

src/PolygonClipper/Box2.cs

@@ -16,7 +16,7 @@ namespace PolygonClipper;
     /// </summary>
     /// <param name="vector">The xy-coordinate.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Box2(Vertex vector)
+    public Box2(in Vertex vector)
         : this(vector, vector)
     {
     }
@@ -26,7 +26,7 @@ public Box2(Vertex vector)
     /// </summary>
     /// <param name="min">The minimum xy-coordinate.</param>
     /// <param name="max">The maximum xy-coordinate.</param>
-    public Box2(Vertex min, Vertex max)
+    public Box2(in Vertex min, in Vertex max)
     {
         this.Min = min;
         this.Max = max;
@@ -43,11 +43,11 @@ public Box2(Vertex min, Vertex max)
     public Vertex Max { get; }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool operator ==(Box2 left, Box2 right)
+    public static bool operator ==(in Box2 left, in Box2 right)
         => left.Equals(right);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool operator !=(Box2 left, Box2 right)
+    public static bool operator !=(in Box2 left, in Box2 right)
         => !(left == right);
 
     /// <summary>
@@ -56,7 +56,7 @@ public Box2(Vertex min, Vertex max)
     /// <param name="other">The other box.</param>
     /// <returns>The summed <see cref="Box2"/>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Box2 Add(Box2 other)
+    public Box2 Add(in Box2 other)
         => new(Vertex.Min(this.Min, other.Min), Vertex.Max(this.Max, other.Max));
 
     /// <inheritdoc/>

src/PolygonClipper/Contour.cs

@@ -43,8 +43,7 @@ public sealed class Contour
     public int HoleCount => this.holes.Count;
 
     /// <summary>
-    /// Gets a value indicating whether the contour
-    /// is external (not a hole).
+    /// Gets a value indicating whether the contour is external (not a hole).
     /// </summary>
     public bool IsExternal => this.HoleOf == null;
 
@@ -127,12 +126,12 @@ public bool IsCounterClockwise()
         {
             c = points[i];
             c1 = points[i + 1];
-            area += (c.X * c1.Y) - (c1.X * c.Y);
+            area += Vertex.Cross(c, c1);
         }
 
-        c = points[this.points.Count - 1];
+        c = points[^1];
         c1 = points[0];
-        area += (c.X * c1.Y) - (c1.X * c.Y);
+        area += Vertex.Cross(c, c1);
         return this.cc = area >= 0;
     }
 
@@ -176,11 +175,11 @@ public void SetCounterClockwise()
     }
 
     /// <summary>
-    /// Offsets the contour by the specified x and y values.
+    /// Translates the contour by the specified x and y values.
     /// </summary>
     /// <param name="x">The x-coordinate offset.</param>
     /// <param name="y">The y-coordinate offset.</param>
-    public void Offset(double x, double y)
+    public void Translate(double x, double y)
     {
         List<Vertex> points = this.points;
         for (int i = 0; i < points.Count; i++)
@@ -194,7 +193,7 @@ public void Offset(double x, double y)
     /// </summary>
     /// <param name="vertex">The vertex to add.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void AddVertex(Vertex vertex) => this.points.Add(vertex);
+    public void AddVertex(in Vertex vertex) => this.points.Add(vertex);
 
     /// <summary>
     /// Removes the vertex at the specified index from the contour.

src/PolygonClipper/Polygon.cs

@@ -93,15 +93,15 @@ public Box2 GetBoundingBox()
     }
 
     /// <summary>
-    /// Offsets the polygon by the specified x and y values.
+    /// Translates the polygon by the specified x and y values.
     /// </summary>
     /// <param name="x">The x-coordinate offset.</param>
     /// <param name="y">The y-coordinate offset.</param>
-    public void Offset(double x, double y)
+    public void Translate(double x, double y)
     {
         for (int i = 0; i < this.contours.Count; i++)
         {
-            this.contours[i].Offset(x, y);
+            this.contours[i].Translate(x, y);
         }
     }
 

src/PolygonClipper/PolygonClipper.cs

@@ -123,16 +123,32 @@ public Polygon Run()
         Vertex min = new(double.PositiveInfinity);
         Vertex max = new(double.NegativeInfinity);
 
-        int eventCount = (subject.GetVertexCount() + clipping.GetVertexCount()) * 2;
-        StablePriorityQueue<SweepEvent, SweepEventComparer> eventQueue = new(new SweepEventComparer(), eventCount);
+        // Estimate the total number of sweep events.
+        // Each segment contributes two events (left/right endpoints),
+        // and subdivision during intersection may increase the count,
+        // so we conservatively double the total vertex count.
+        int subjectVertexCount = subject.GetVertexCount();
+        int clippingVertexCount = clipping.GetVertexCount();
+        int eventCount = (subjectVertexCount + clippingVertexCount) * 2;
+
+        SweepEventComparer comparer = new();
+        List<SweepEvent> unorderedEventQueue = new(eventCount);
         int contourId = 0;
+
         for (int i = 0; i < subject.ContourCount; i++)
         {
             Contour contour = subject[i];
             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);
             }
         }
 
@@ -147,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);
             }
         }
 
@@ -158,9 +181,14 @@ public Polygon Run()
         }
 
         // Sweep line algorithm: process events in the priority queue
-        List<SweepEvent> sortedEvents = [];
-        StatusLine statusLine = new();
-        SweepEventComparer comparer = eventQueue.Comparer;
+        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);
         double subjectMaxX = subjectBB.Max.X;
         double minMaxX = Vertex.Min(subjectBB.Max, clippingBB.Max).X;
 
@@ -335,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)
     {
@@ -359,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;
         }
@@ -372,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>
@@ -868,7 +898,7 @@ private static Polygon ConnectEdges(List<SweepEvent> sortedEvents, SweepEventCom
 
     private static ReadOnlySpan<int> PrecomputeIterationOrder(List<SweepEvent> data)
     {
-        Span<int> map = new(new int[data.Count]);
+        Span<int> map = new int[data.Count];
 
         int i = 0;
         while (i < data.Count)

src/PolygonClipper/PolygonUtilities.cs

@@ -17,7 +17,7 @@ internal static class PolygonUtilities
     /// <param name="p2">The third point.</param>
     /// <returns>The <see cref="double"/> area.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static double SignedArea(Vertex p0, Vertex p1, Vertex p2)
+    public static double SignedArea(in Vertex p0, in Vertex p1, in Vertex p2)
         => ((p0.X - p2.X) * (p1.Y - p2.Y)) - ((p1.X - p2.X) * (p0.Y - p2.Y));
 
     /// <summary>
@@ -33,7 +33,7 @@ public static double SignedArea(Vertex p0, Vertex p1, Vertex p2)
     /// - Returns 1 if the segments intersect at a single point.
     /// - Returns 2 if the segments overlap.
     /// </returns>
-    public static int FindIntersection(Segment seg0, Segment seg1, out Vertex pi0, out Vertex pi1)
+    public static int FindIntersection(in Segment seg0, in Segment seg1, out Vertex pi0, out Vertex pi1)
     {
         pi0 = default;
         pi1 = default;
@@ -76,7 +76,7 @@ public static int FindIntersection(Segment seg0, Segment seg1, out Vertex pi0, o
     /// - Returns 1 if the segments intersect at a single point.
     /// - Returns 2 if the segments overlap.
     /// </returns>
-    private static int FindIntersectionImpl(Segment seg0, Segment seg1, out Vertex pi0, out Vertex pi1)
+    private static int FindIntersectionImpl(in Segment seg0, in Segment seg1, out Vertex pi0, out Vertex pi1)
     {
         pi0 = default;
         pi1 = default;
@@ -175,7 +175,12 @@ private static int FindIntersectionImpl(Segment seg0, Segment seg1, out Vertex p
     /// <returns>
     /// <see langword="true"/> if the segments intersect; otherwise, <see langword="false"/>.
     /// </returns>
-    private static bool TryGetIntersectionBoundingBox(Vertex a1, Vertex a2, Vertex b1, Vertex b2, [NotNullWhen(true)] out Box2? result)
+    private static bool TryGetIntersectionBoundingBox(
+        in Vertex a1,
+        in Vertex a2,
+        in Vertex b1,
+        in Vertex b2,
+        [NotNullWhen(true)] out Box2? result)
     {
         Vertex minA = Vertex.Min(a1, a2);
         Vertex maxA = Vertex.Max(a1, a2);
@@ -202,7 +207,7 @@ private static bool TryGetIntersectionBoundingBox(Vertex a1, Vertex a2, Vertex b
     /// <param name="bbox">The bounding box.</param>
     /// <returns>The constrained point.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static Vertex ConstrainToBoundingBox(Vertex p, Box2 bbox)
+    private static Vertex ConstrainToBoundingBox(in Vertex p, in Box2 bbox)
         => Vertex.Min(Vertex.Max(p, bbox.Min), bbox.Max);
 
     /// <summary>
@@ -213,5 +218,5 @@ private static Vertex ConstrainToBoundingBox(Vertex p, Box2 bbox)
     /// <param name="d">The direction vector of the segment.</param>
     /// <returns>The interpolated vertex at the given fractional distance.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Vertex MidPoint(Vertex p, double s, Vertex d) => p + (s * d);
+    public static Vertex MidPoint(in Vertex p, double s, in Vertex d) => p + (s * d);
 }

src/PolygonClipper/Segment.cs

@@ -17,7 +17,7 @@ namespace PolygonClipper;
     /// <param name="source">The segment source.</param>
     /// <param name="target">The segment target.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Segment(Vertex source, Vertex target)
+    public Segment(in Vertex source, in Vertex target)
     {
         this.Source = source;
         this.Target = target;
@@ -46,11 +46,11 @@ public Segment(Vertex source, Vertex target)
     public Vertex Max { get; }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool operator ==(Segment left, Segment right)
+    public static bool operator ==(in Segment left, in Segment right)
         => left.Equals(right);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool operator !=(Segment left, Segment right)
+    public static bool operator !=(in Segment left, in Segment right)
         => !(left == right);
 
     /// <summary>

src/PolygonClipper/SegmentComparer.cs

@@ -13,8 +13,6 @@ namespace PolygonClipper;
 /// </summary>
 internal sealed class SegmentComparer : IComparer<SweepEvent>, IComparer
 {
-    private readonly SweepEventComparer eventComparer = new();
-
     /// <inheritdoc/>
     public int Compare(SweepEvent? x, SweepEvent? y)
     {
@@ -35,7 +33,7 @@ public int Compare(SweepEvent? x, SweepEvent? y)
         }
 
         SweepEvent perhapsInversedX, perhapsInversedY;
-        bool inversed = false;
+        bool inversed;
 
         if (x.IsBefore(y))
         {