Clip dashed paths

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/Processors/Drawing/FillPathProcessor.cs

@@ -52,8 +52,8 @@ public IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>(Configuratio
 
         if (shape is RectangularPolygon rectPoly)
         {
-            var rectF = new RectangleF(rectPoly.Location, rectPoly.Size);
-            var rect = (Rectangle)rectF;
+            RectangleF rectF = new(rectPoly.Location, rectPoly.Size);
+            Rectangle rect = (Rectangle)rectF;
             if (!this.Options.GraphicsOptions.Antialias || rectF == rect)
             {
                 // Cast as in and back are the same or we are using anti-aliasing
@@ -63,7 +63,7 @@ public IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>(Configuratio
         }
 
         // Clone the definition so we can pass the transformed path.
-        var definition = new FillPathProcessor(this.Options, this.Brush, shape);
+        FillPathProcessor definition = new(this.Options, this.Brush, shape);
         return new FillPathProcessor<TPixel>(configuration, definition, source, sourceRectangle);
     }
 }

src/ImageSharp.Drawing/Processing/Processors/Drawing/FillPathProcessor{TPixel}.cs

@@ -67,7 +67,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
 
         // We need to offset the pixel grid to account for when we outline a path.
         // basically if the line is [1,2] => [3,2] then when outlining at 1 we end up with a region of [0.5,1.5],[1.5, 1.5],[3.5,2.5],[2.5,2.5]
-        // and this can cause missed fills when not using antialiasing.so we offset the pixel grid by 0.5 in the x & y direction thus causing the#
+        // and this can cause missed fills when not using antialiasing.so we offset the pixel grid by 0.5 in the x & y direction thus causing the
         // region to align with the pixel grid.
         if (graphicsOptions.Antialias)
         {

src/ImageSharp.Drawing/Shapes/InternalPath.cs

@@ -200,7 +200,7 @@ internal IMemoryOwner<PointF> ExtractVertices(MemoryAllocator allocator)
     private static int WrapArrayIndex(int i, int arrayLength) => i < arrayLength ? i : i - arrayLength;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static PointOrientation CalulateOrientation(Vector2 p, Vector2 q, Vector2 r)
+    private static PointOrientation CalculateOrientation(Vector2 p, Vector2 q, Vector2 r)
     {
         // See http://www.geeksforgeeks.org/orientation-3-ordered-points/
         // for details of below formula.
@@ -217,7 +217,7 @@ private static PointOrientation CalulateOrientation(Vector2 p, Vector2 q, Vector
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static PointOrientation CalulateOrientation(Vector2 qp, Vector2 rq)
+    private static PointOrientation CalculateOrientation(Vector2 qp, Vector2 rq)
     {
         // See http://www.geeksforgeeks.org/orientation-3-ordered-points/
         // for details of below formula.
@@ -242,7 +242,7 @@ private static PointOrientation CalulateOrientation(Vector2 qp, Vector2 rq)
     /// </returns>
     private static PointData[] Simplify(IReadOnlyList<ILineSegment> segments, bool isClosed, bool removeCloseAndCollinear)
     {
-        var simplified = new List<PointF>();
+        List<PointF> simplified = new(segments.Count);
 
         foreach (ILineSegment seg in segments)
         {
@@ -260,10 +260,10 @@ private static PointData[] Simplify(ReadOnlyMemory<PointF> vectors, bool isClose
         int polyCorners = points.Length;
         if (polyCorners == 0)
         {
-            return Array.Empty<PointData>();
+            return [];
         }
 
-        var results = new List<PointData>();
+        List<PointData> results = new(polyCorners);
         Vector2 lastPoint = points[0];
 
         if (!isClosed)
@@ -292,7 +292,7 @@ private static PointData[] Simplify(ReadOnlyMemory<PointF> vectors, bool isClose
                             Length = 0,
                         });
 
-                    return results.ToArray();
+                    return [.. results];
                 }
             }
             while (removeCloseAndCollinear && points[0].Equivalent(points[prev], Epsilon2)); // skip points too close together
@@ -304,31 +304,28 @@ private static PointData[] Simplify(ReadOnlyMemory<PointF> vectors, bool isClose
                 new PointData
                 {
                     Point = points[0],
-                    Orientation = CalulateOrientation(lastPoint, points[0], points[1]),
+                    Orientation = CalculateOrientation(lastPoint, points[0], points[1]),
                     Length = Vector2.Distance(lastPoint, points[0]),
                 });
 
             lastPoint = points[0];
         }
 
-        float totalDist = 0;
         for (int i = 1; i < polyCorners; i++)
         {
             int next = WrapArrayIndex(i + 1, polyCorners);
-            PointOrientation or = CalulateOrientation(lastPoint, points[i], points[next]);
+            PointOrientation or = CalculateOrientation(lastPoint, points[i], points[next]);
             if (or == PointOrientation.Collinear && next != 0)
             {
                 continue;
             }
 
-            float dist = Vector2.Distance(lastPoint, points[i]);
-            totalDist += dist;
             results.Add(
                 new PointData
                 {
                     Point = points[i],
                     Orientation = or,
-                    Length = dist,
+                    Length = Vector2.Distance(lastPoint, points[i]),
                 });
             lastPoint = points[i];
         }
@@ -342,7 +339,7 @@ private static PointData[] Simplify(ReadOnlyMemory<PointF> vectors, bool isClose
             }
         }
 
-        return results.ToArray();
+        return [.. results];
     }
 
     private struct PointData

src/ImageSharp.Drawing/Shapes/OutlinePathExtensions.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper;
 
 namespace SixLabors.ImageSharp.Drawing;
@@ -11,7 +12,6 @@ namespace SixLabors.ImageSharp.Drawing;
 /// </summary>
 public static class OutlinePathExtensions
 {
-    private const float MiterOffsetDelta = 20;
     private const JointStyle DefaultJointStyle = JointStyle.Square;
     private const EndCapStyle DefaultEndCapStyle = EndCapStyle.Butt;
 
@@ -45,20 +45,16 @@ public static IPath GenerateOutline(this IPath path, float width, JointStyle joi
             return Path.Empty;
         }
 
-        List<Polygon> polygons = [];
+        List<Polygon> stroked = [];
+
+        // TODO: Wire up options
+        PolygonStroker stroker = new() { Width = width, LineJoin = LineJoin.BevelJoin, LineCap = LineCap.Butt };
         foreach (ISimplePath simplePath in path.Flatten())
         {
-            PolygonStroker stroker = new() { Width = width };
-            Polygon polygon = stroker.ProcessPath(simplePath.Points.Span, simplePath.IsClosed);
-            polygons.Add(polygon);
+            stroked.Add(new Polygon(stroker.ProcessPath(simplePath.Points.Span, simplePath.IsClosed).ToArray()));
         }
 
-        return new ComplexPolygon(polygons);
-
-        // ClipperOffset offset = new(MiterOffsetDelta);
-        // offset.AddPath(path, jointStyle, endCapStyle);
-
-        // return offset.Execute(width);
+        return new ComplexPolygon(stroked);
     }
 
     /// <summary>
@@ -78,11 +74,11 @@ public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<f
     /// <param name="path">The path to outline</param>
     /// <param name="width">The outline width.</param>
     /// <param name="pattern">The pattern made of multiples of the width.</param>
-    /// <param name="startOff">Whether the first item in the pattern is on or off.</param>
+    /// <param name="invert">Whether the first item in the pattern is off.</param>
     /// <returns>A new <see cref="IPath"/> representing the outline.</returns>
     /// <exception cref="ClipperException">Thrown when an offset cannot be calculated.</exception>
-    public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<float> pattern, bool startOff)
-        => GenerateOutline(path, width, pattern, startOff, DefaultJointStyle, DefaultEndCapStyle);
+    public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<float> pattern, bool invert)
+        => GenerateOutline(path, width, pattern, invert, DefaultJointStyle, DefaultEndCapStyle);
 
     /// <summary>
     /// Generates an outline of the path with alternating on and off segments based on the pattern.
@@ -103,12 +99,12 @@ public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<f
     /// <param name="path">The path to outline</param>
     /// <param name="width">The outline width.</param>
     /// <param name="pattern">The pattern made of multiples of the width.</param>
-    /// <param name="startOff">Whether the first item in the pattern is on or off.</param>
+    /// <param name="invert">Whether the first item in the pattern is off.</param>
     /// <param name="jointStyle">The style to apply to the joints.</param>
     /// <param name="endCapStyle">The style to apply to the end caps.</param>
     /// <returns>A new <see cref="IPath"/> representing the outline.</returns>
     /// <exception cref="ClipperException">Thrown when an offset cannot be calculated.</exception>
-    public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<float> pattern, bool startOff, JointStyle jointStyle, EndCapStyle endCapStyle)
+    public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<float> pattern, bool invert, JointStyle jointStyle, EndCapStyle endCapStyle)
     {
         if (width <= 0)
         {
@@ -122,18 +118,21 @@ public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<f
 
         IEnumerable<ISimplePath> paths = path.Flatten();
 
-        ClipperOffset offset = new(MiterOffsetDelta);
-        List<PointF> buffer = new();
-        foreach (ISimplePath p in paths)
+        // TODO: Wire up options
+        PolygonStroker stroker = new() { Width = width, LineJoin = LineJoin.BevelJoin, LineCap = LineCap.Butt };
+
+        PathsF stroked = [];
+        List<PointF> buffer = [];
+        foreach (ISimplePath simplePath in paths)
         {
-            bool online = !startOff;
+            bool online = !invert;
             float targetLength = pattern[0] * width;
             int patternPos = 0;
-            ReadOnlySpan<PointF> points = p.Points.Span;
+            ReadOnlySpan<PointF> points = simplePath.Points.Span;
 
             // Create a new list of points representing the new outline
             int pCount = points.Length;
-            if (!p.IsClosed)
+            if (!simplePath.IsClosed)
             {
                 pCount--;
             }
@@ -145,20 +144,20 @@ public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<f
             {
                 int next = (i + 1) % points.Length;
                 Vector2 targetPoint = points[next];
-                float distToNext = Vector2.Distance(currentPoint, targetPoint);
-                if (distToNext > targetLength)
+                float distanceToNext = Vector2.Distance(currentPoint, targetPoint);
+                if (distanceToNext > targetLength)
                 {
-                    // find a point between the 2
-                    float t = targetLength / distToNext;
+                    // Find a point between the 2
+                    float t = targetLength / distanceToNext;
 
                     Vector2 point = (currentPoint * (1 - t)) + (targetPoint * t);
                     buffer.Add(currentPoint);
                     buffer.Add(point);
 
-                    // we now inset a line joining
+                    // We now insert a line
                     if (online)
                     {
-                        offset.AddPath(new ReadOnlySpan<PointF>(buffer.ToArray()), jointStyle, endCapStyle);
+                        stroked.Add(stroker.ProcessPath(CollectionsMarshal.AsSpan(buffer), false));
                     }
 
                     online = !online;
@@ -167,39 +166,64 @@ public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<f
 
                     currentPoint = point;
 
-                    // next length
+                    // Next length
                     patternPos = (patternPos + 1) % pattern.Length;
                     targetLength = pattern[patternPos] * width;
                 }
-                else if (distToNext <= targetLength)
+                else if (distanceToNext <= targetLength)
                 {
                     buffer.Add(currentPoint);
                     currentPoint = targetPoint;
                     i++;
-                    targetLength -= distToNext;
+                    targetLength -= distanceToNext;
                 }
             }
 
             if (buffer.Count > 0)
             {
-                if (p.IsClosed)
+                if (simplePath.IsClosed)
                 {
                     buffer.Add(points[0]);
                 }
                 else
                 {
-                    buffer.Add(points[points.Length - 1]);
+                    buffer.Add(points[^1]);
                 }
 
                 if (online)
                 {
-                    offset.AddPath(new ReadOnlySpan<PointF>(buffer.ToArray()), jointStyle, endCapStyle);
+                    stroked.Add(stroker.ProcessPath(CollectionsMarshal.AsSpan(buffer), false));
                 }
 
                 buffer.Clear();
             }
         }
 
-        return offset.Execute(width);
+        // Clean up self intersections.
+        PolygonClipper clipper = new() { PreserveCollinear = true };
+        clipper.AddSubject(stroked);
+        PathsF clipped = [];
+        clipper.Execute(ClippingOperation.Union, FillRule.Positive, clipped);
+
+        if (clipped.Count == 0)
+        {
+            // Cannot clip. Return the stroked path.
+            Polygon[] polygons = new Polygon[stroked.Count];
+            for (int i = 0; i < stroked.Count; i++)
+            {
+                polygons[i] = new Polygon(stroked[i].ToArray());
+            }
+
+            return new ComplexPolygon(polygons);
+        }
+
+        // Convert the clipped paths back to polygons.
+        Polygon[] result = new Polygon[clipped.Count];
+        for (int i = 0; i < clipped.Count; i++)
+        {
+            result[i] = new Polygon(clipped[i].ToArray());
+        }
+
+        return new ComplexPolygon(result);
     }
 }

src/ImageSharp.Drawing/Shapes/PolygonClipper/ArrayBuilder{T}.cs

@@ -26,10 +26,10 @@ internal struct ArrayBuilder<T>
     public ArrayBuilder(int capacity)
         : this()
     {
-        Guard.MustBeGreaterThanOrEqualTo(capacity, 0, nameof(capacity));
-
-        this.data = new T[capacity];
-        this.size = capacity;
+        if (capacity > 0)
+        {
+            this.data = new T[capacity];
+        }
     }
 
     /// <summary>

src/ImageSharp.Drawing/Shapes/PolygonClipper/Clipper.cs

@@ -14,7 +14,7 @@ internal class Clipper
     /// Initializes a new instance of the <see cref="Clipper"/> class.
     /// </summary>
     public Clipper()
-        => this.polygonClipper = new PolygonClipper();
+        => this.polygonClipper = new PolygonClipper() { PreserveCollinear = true };
 
     /// <summary>
     /// Generates the clipped shapes from the previously provided paths.

src/ImageSharp.Drawing/Shapes/PolygonClipper/ClipperUtils.cs

@@ -46,7 +46,7 @@ public static PathF StripDuplicates(PathF path, bool isClosedPath)
             return result;
         }
 
-        Vector2 lastPt = path[0];
+        PointF lastPt = path[0];
         result.Add(lastPt);
         for (int i = 1; i < cnt; i++)
         {
@@ -152,11 +152,9 @@ public static bool SegsIntersect(Vector2 seg1a, Vector2 seg1b, Vector2 seg2a, Ve
             // ensure NOT collinear
             return res1 != 0 || res2 != 0 || res3 != 0 || res4 != 0;
         }
-        else
-        {
-            return (CrossProduct(seg1a, seg2a, seg2b) * CrossProduct(seg1b, seg2a, seg2b) < 0)
-                && (CrossProduct(seg2a, seg1a, seg1b) * CrossProduct(seg2b, seg1a, seg1b) < 0);
-        }
+
+        return (CrossProduct(seg1a, seg2a, seg2b) * CrossProduct(seg1b, seg2a, seg2b) < 0)
+            && (CrossProduct(seg2a, seg1a, seg1b) * CrossProduct(seg2b, seg1a, seg1b) < 0);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/ImageSharp.Drawing/Shapes/PolygonClipper/PolygonClipper.cs

@@ -398,8 +398,8 @@ private bool BuildPaths(PathsF solutionClosed, PathsF solutionOpen)
     {
         solutionClosed.Clear();
         solutionOpen.Clear();
-        solutionClosed.Capacity = this.outrecList.Count;
-        solutionOpen.Capacity = this.outrecList.Count;
+        solutionClosed.EnsureCapacity(this.outrecList.Count);
+        solutionOpen.EnsureCapacity(this.outrecList.Count);
 
         int i = 0;
 
@@ -1122,7 +1122,7 @@ private void Reset()
             this.isSortedMinimaList = true;
         }
 
-        this.scanlineList.Capacity = this.minimaList.Count;
+        this.scanlineList.EnsureCapacity(this.minimaList.Count);
         for (int i = this.minimaList.Count - 1; i >= 0; i--)
         {
             this.scanlineList.Add(this.minimaList[i].Vertex.Point.Y);
@@ -1924,7 +1924,7 @@ private void AddPathsToVertexList(PathsF paths, ClippingType polytype, bool isOp
             totalVertCnt += path.Count;
         }
 
-        this.vertexList.Capacity = this.vertexList.Count + totalVertCnt;
+        this.vertexList.EnsureCapacity(this.vertexList.Count + totalVertCnt);
 
         foreach (PathF path in paths)
         {