Add methods on PolygonStroker for manually composing (line) paths

Author: TechPizzaDev

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

@@ -53,26 +53,42 @@ public double Width
         }
     }
 
-    public PathF ProcessPath(ReadOnlySpan<PointF> pathPoints, bool isClosed)
+    public PathF ProcessPath(ReadOnlySpan<PointF> linePoints, bool isClosed)
     {
         this.Reset();
-        for (int i = 0; i < pathPoints.Length; i++)
+        this.AddLinePath(linePoints);
+
+        if (isClosed)
         {
-            PointF point = pathPoints[i];
-            this.AddVertex(point.X, point.Y, PathCommand.LineTo);
+            this.ClosePath();
         }
 
-        if (isClosed)
+        PathF results = new(linePoints.Length * 3);
+        this.FinishPath(results);
+        return results;
+    }
+
+    public void AddLinePath(ReadOnlySpan<PointF> linePoints)
+    {
+        for (int i = 0; i < linePoints.Length; i++)
         {
-            this.AddVertex(0, 0, PathCommand.EndPoly | (PathCommand)PathFlags.Close);
+            PointF point = linePoints[i];
+            this.AddVertex(point.X, point.Y, PathCommand.LineTo);
         }
+    }
+
+    public void ClosePath()
+    {
+        this.AddVertex(0, 0, PathCommand.EndPoly | (PathCommand)PathFlags.Close);
+    }
 
+    public void FinishPath(List<PointF> results)
+    {
         PointF currentPoint = new(0, 0);
         int startIndex = 0;
         PointF? lastPoint = null;
         PathCommand command;
 
-        PathF results = new(pathPoints.Length * 3);
         while (!(command = this.Accumulate(ref currentPoint)).Stop())
         {
             if (command.EndPoly() && results.Count > 0)
@@ -90,12 +106,9 @@ public PathF ProcessPath(ReadOnlySpan<PointF> pathPoints, bool isClosed)
                 }
             }
         }
-
-        return results;
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void Reset()
+    public void Reset()
     {
         this.srcVertices.Clear();
         this.outVertices.Clear();

tests/ImageSharp.Drawing.Benchmarks/Drawing/DrawPolygon.cs

@@ -211,30 +211,52 @@ public void Blaze()
 
     private static List<List<PointF>> GenerateOutlineList(IPath path, float width, JointStyle jointStyle, EndCapStyle endCapStyle)
     {
+        List<List<PointF>> strokedLines = [];
+
         if (width <= 0)
         {
-            return [];
+            return strokedLines;
         }
 
-        List<List<PointF>> stroked = [];
-
-        PolygonStroker stroker = new() { Width = width, LineJoin = GetLineJoin(jointStyle), LineCap = GetLineCap(endCapStyle) };
+        PolygonStroker stroker = new()
+        {
+            Width = width,
+            LineJoin = GetLineJoin(jointStyle),
+            LineCap = GetLineCap(endCapStyle)
+        };
         foreach (ISimplePath simplePath in path.Flatten())
         {
-            bool isClosed = simplePath.IsClosed || endCapStyle is EndCapStyle.Polygon or EndCapStyle.Joined;
+            stroker.Reset();
+
+            int pointCount = 0;
             if (simplePath is Path concretePath)
             {
-                if (concretePath.LineSegments.Count == 1 && concretePath.LineSegments[0] is LinearLineSegment lineSegment)
+                foreach (ILineSegment line in concretePath.LineSegments)
                 {
-                    stroked.Add(stroker.ProcessPath(lineSegment.Flatten().Span, isClosed));
-                    continue;
+                    ReadOnlySpan<PointF> points = line.Flatten().Span;
+                    stroker.AddLinePath(points);
+                    pointCount += points.Length;
                 }
             }
+            else
+            {
+                ReadOnlySpan<PointF> points = simplePath.Points.Span;
+                stroker.AddLinePath(points);
+                pointCount = points.Length;
+            }
+
+            bool isClosed = simplePath.IsClosed || endCapStyle is EndCapStyle.Polygon or EndCapStyle.Joined;
+            if (isClosed)
+            {
+                stroker.ClosePath();
+            }
 
-            stroked.Add(stroker.ProcessPath(simplePath.Points.Span, isClosed));
+            List<PointF> lineBuilder = new(pointCount * 4);
+            stroker.FinishPath(lineBuilder);
+            strokedLines.Add(lineBuilder);
         }
 
-        return stroked;
+        return strokedLines;
 
         static LineJoin GetLineJoin(JointStyle value) => value switch
         {