Only clip when we need to

Author: JimBobSquarePants

src/ImageSharp.Drawing/Shapes/PolygonGeometry/StrokedShapeGenerator.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
+using SixLabors.ImageSharp.Drawing.Utilities;
 using SixLabors.PolygonClipper;
 
 namespace SixLabors.ImageSharp.Drawing.Shapes.PolygonGeometry;
@@ -57,6 +59,7 @@ public IPath[] GenerateStrokedShapes(List<PointF[]> spans, float width)
         // 1) Stroke each dashed span as open.
         this.polygonStroker.Width = width;
 
+        List<PointF[]> ringPoints = new(spans.Count);
         List<IPath> rings = new(spans.Count);
         foreach (PointF[] span in spans)
         {
@@ -71,6 +74,7 @@ public IPath[] GenerateStrokedShapes(List<PointF[]> spans, float width)
                 continue;
             }
 
+            ringPoints.Add(stroked);
             rings.Add(new Polygon(new LinearLineSegment(stroked)));
         }
 
@@ -80,10 +84,9 @@ public IPath[] GenerateStrokedShapes(List<PointF[]> spans, float width)
             return [];
         }
 
-        if (count == 1)
+        if (!HasIntersections(ringPoints))
         {
-            // Only one stroked ring. Return as-is; two-operand union requires both sides non-empty.
-            return [rings[0]];
+            return count == 1 ? [rings[0]] : [.. rings];
         }
 
         // 2) Partition so the first and last are on different polygons
@@ -140,6 +143,7 @@ public IPath[] GenerateStrokedShapes(List<PointF[]> spans, float width)
     public IPath[] GenerateStrokedShapes(IPath path, float width)
     {
         // 1) Stroke the input path into closed rings
+        List<PointF[]> ringPoints = [];
         List<IPath> rings = [];
         this.polygonStroker.Width = width;
 
@@ -151,6 +155,7 @@ public IPath[] GenerateStrokedShapes(IPath path, float width)
                 continue; // skip degenerate outputs
             }
 
+            ringPoints.Add(stroked);
             rings.Add(new Polygon(new LinearLineSegment(stroked)));
         }
 
@@ -160,10 +165,9 @@ public IPath[] GenerateStrokedShapes(IPath path, float width)
             return [];
         }
 
-        if (count == 1)
+        if (!HasIntersections(ringPoints))
         {
-            // Only one stroked ring. Return as-is; two-operand union requires both sides non-empty.
-            return [rings[0]];
+            return count == 1 ? [rings[0]] : [.. rings];
         }
 
         // 2) Partition so the first and last are on different polygons
@@ -204,4 +208,92 @@ public IPath[] GenerateStrokedShapes(IPath path, float width)
         // 4) Return the cleaned, merged outline
         return clipper.GenerateClippedShapes(BooleanOperation.Union);
     }
+
+    /// <summary>
+    /// Determines whether any of the provided rings contain self-intersections or intersect with other rings.
+    /// </summary>
+    /// <remarks>
+    /// This method performs a conservative scan to detect intersections among the provided rings. It
+    /// checks for both self-intersections within each ring and intersections between different rings. Rings are treated
+    /// as polylines; if a ring is closed (its first and last points are equal), the closing segment is included in the
+    /// intersection checks. This method is intended for fast intersection detection and may be used to determine
+    /// whether further geometric processing, such as clipping, is necessary.
+    /// </remarks>
+    /// <param name="rings">
+    /// A list of rings, where each ring is represented as an array of points defining its vertices. Each ring is
+    /// expected to be a sequence of points forming a polyline or polygon.
+    /// </param>
+    /// <returns><see langword="true"/> if any ring self-intersects or any two rings intersect; otherwise, <see langword="false"/>.</returns>
+    private static bool HasIntersections(List<PointF[]> rings)
+    {
+        // Detect whether any stroked ring self-intersects or intersects another ring.
+        // This is a fast, conservative scan used to decide whether we can skip clipping.
+        Vector2 intersection = default;
+
+        for (int r = 0; r < rings.Count; r++)
+        {
+            PointF[] ring = rings[r];
+            int segmentCount = ring.Length - 1;
+            if (segmentCount < 2)
+            {
+                continue;
+            }
+
+            // 1) Self-intersection scan for the current ring.
+            // Adjacent segments share a vertex and are skipped to avoid trivial hits.
+            bool isClosed = ring[0] == ring[^1];
+            for (int i = 0; i < segmentCount; i++)
+            {
+                Vector2 a0 = new(ring[i].X, ring[i].Y);
+                Vector2 a1 = new(ring[i + 1].X, ring[i + 1].Y);
+
+                for (int j = i + 1; j < segmentCount; j++)
+                {
+                    // Skip neighbors and the closing edge pair in a closed ring.
+                    if (j == i + 1 || (isClosed && i == 0 && j == segmentCount - 1))
+                    {
+                        continue;
+                    }
+
+                    Vector2 b0 = new(ring[j].X, ring[j].Y);
+                    Vector2 b1 = new(ring[j + 1].X, ring[j + 1].Y);
+                    if (Intersect.LineSegmentToLineSegmentIgnoreCollinear(a0, a1, b0, b1, ref intersection))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            // 2) Cross-ring intersection scan against later rings only.
+            // This avoids double work while checking all ring pairs.
+            for (int s = r + 1; s < rings.Count; s++)
+            {
+                PointF[] other = rings[s];
+                int otherSegmentCount = other.Length - 1;
+                if (otherSegmentCount < 1)
+                {
+                    continue;
+                }
+
+                for (int i = 0; i < segmentCount; i++)
+                {
+                    Vector2 a0 = new(ring[i].X, ring[i].Y);
+                    Vector2 a1 = new(ring[i + 1].X, ring[i + 1].Y);
+
+                    for (int j = 0; j < otherSegmentCount; j++)
+                    {
+                        Vector2 b0 = new(other[j].X, other[j].Y);
+                        Vector2 b1 = new(other[j + 1].X, other[j + 1].Y);
+                        if (Intersect.LineSegmentToLineSegmentIgnoreCollinear(a0, a1, b0, b1, ref intersection))
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
+        // No intersections detected.
+        return false;
+    }
 }

src/ImageSharp.Drawing/Shapes/PolygonGeometry/VertexDistance.cs

@@ -93,5 +93,6 @@ public static bool CalcIntersection(double ax, double ay, double bx, double by,
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static double CrossProduct(double x1, double y1, double x2, double y2, double x, double y) => ((x - x2) * (y2 - y1)) - ((y - y2) * (x2 - x1));
+    public static double CrossProduct(double x1, double y1, double x2, double y2, double x, double y)
+        => ((x - x2) * (y2 - y1)) - ((y - y2) * (x2 - x1));
 }

src/ImageSharp.Drawing/Shapes/Text/BaseGlyphBuilder.cs

@@ -6,6 +6,7 @@
 using SixLabors.Fonts;
 using SixLabors.Fonts.Rendering;
 using SixLabors.ImageSharp.Drawing.Processing;
+using SixLabors.PolygonClipper;
 
 namespace SixLabors.ImageSharp.Drawing.Text;
 
@@ -220,7 +221,7 @@ void IGlyphRenderer.EndLayer()
 
             ShapeOptions options = new()
             {
-                ClippingOperation = ClippingOperation.Intersection,
+                ClippingOperation = BooleanOperation.Intersection,
                 IntersectionRule = TextUtilities.MapFillRule(this.currentLayerFillRule)
             };
 

src/ImageSharp.Drawing/Utilities/Intersect.cs

@@ -1,33 +1,71 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
 
 namespace SixLabors.ImageSharp.Drawing.Utilities;
 
+/// <summary>
+/// Lightweight 2D segment intersection helpers for polygon and path processing.
+/// </summary>
+/// <remarks>
+/// This is intentionally small and allocation-free. It favors speed and numerical tolerance
+/// over exhaustive classification (e.g., collinear overlap detection), which keeps it fast
+/// enough for per-segment scanning in stroking or clipping preparation passes.
+/// </remarks>
 internal static class Intersect
 {
+    // Epsilon used for floating-point tolerance. We treat values within ±Eps as zero.
+    // This helps avoid instability when segments are nearly parallel or endpoints are
+    // very close to the intersection boundary.
     private const float Eps = 1e-3f;
     private const float MinusEps = -Eps;
     private const float OnePlusEps = 1 + Eps;
 
+    /// <summary>
+    /// Tests two line segments for intersection, ignoring collinear overlap.
+    /// </summary>
+    /// <param name="a0">Start of segment A.</param>
+    /// <param name="a1">End of segment A.</param>
+    /// <param name="b0">Start of segment B.</param>
+    /// <param name="b1">End of segment B.</param>
+    /// <param name="intersectionPoint">
+    /// Receives the intersection point when the segments intersect within tolerance.
+    /// When no intersection is detected, the value is left unchanged.
+    /// </param>
+    /// <returns>
+    /// <see langword="true"/> if the segments intersect within their extents (including endpoints),
+    /// <see langword="false"/> if they are disjoint or collinear.
+    /// </returns>
+    /// <remarks>
+    /// The method is based on solving two parametric line equations and uses a small epsilon
+    /// window around [0, 1] to account for floating-point error. Collinear cases are rejected
+    /// early (crossD ≈ 0) to keep the method fast; callers that need collinear overlap detection
+    /// must implement that separately.
+    /// </remarks>
     public static bool LineSegmentToLineSegmentIgnoreCollinear(Vector2 a0, Vector2 a1, Vector2 b0, Vector2 b1, ref Vector2 intersectionPoint)
     {
+        // Direction vectors of the segments.
         float dax = a1.X - a0.X;
         float day = a1.Y - a0.Y;
         float dbx = b1.X - b0.X;
         float dby = b1.Y - b0.Y;
 
+        // Cross product of directions. When near zero, the lines are parallel or collinear.
         float crossD = (-dbx * day) + (dax * dby);
 
-        if (crossD > MinusEps && crossD < Eps)
+        // Reject parallel/collinear lines. Collinear overlap is intentionally ignored.
+        if (crossD is > MinusEps and < Eps)
         {
             return false;
         }
 
+        // Solve for parameters s and t where:
+        //   a0 + t*(a1-a0) = b0 + s*(b1-b0)
         float s = ((-day * (a0.X - b0.X)) + (dax * (a0.Y - b0.Y))) / crossD;
         float t = ((dbx * (a0.Y - b0.Y)) - (dby * (a0.X - b0.X))) / crossD;
 
+        // If both parameters are within [0,1] (with tolerance), the segments intersect.
         if (s > MinusEps && s < OnePlusEps && t > MinusEps && t < OnePlusEps)
         {
             intersectionPoint.X = a0.X + (t * dax);