Replace DashPathSplitter with GenerateDashes extension

Author: JimBobSquarePants

samples/WebGPUWindowDemo/Program.cs

@@ -28,7 +28,7 @@ public static unsafe class Program
 {
     private const int WindowWidth = 800;
     private const int WindowHeight = 600;
-    private const int BallCount = 10;
+    private const int BallCount = 50;
 
     // Silk.NET WebGPU API and windowing handles.
     private static WebGPU wgpu;
@@ -38,7 +38,6 @@ public static unsafe class Program
     private static Instance* instance;
     private static Surface* surface;
     private static SurfaceConfiguration surfaceConfiguration;
-    private static SurfaceCapabilities surfaceCapabilities;
     private static Adapter* adapter;
     private static Device* device;
     private static Queue* queue;

src/ImageSharp.Drawing.WebGPU/WEBGPU_BACKEND_PROCESS.md

@@ -72,7 +72,7 @@ DrawingCanvasBatcher.Flush()
 For stroke definitions (`CompositionCoverageDefinition.IsStroke`), the backend
 performs stroke expansion on the GPU using `StrokeExpandComputeShader`:
 
-1. **Dash splitting** (CPU): If the definition has a dash pattern, `DashPathSplitter.SplitDashes()`
+1. **Dash splitting** (CPU): If the definition has a dash pattern, `SplitPathExtensions.GenerateDashes()`
    (shared with `DefaultDrawingBackend` in the core project) segments the centerline into
    open dash sub-paths before edge building.
 
@@ -194,7 +194,7 @@ Edge preparation (path flattening, fixed-point conversion, CSR construction) run
 Both the CPU and GPU backends use per-band parallel stroke expansion - the CPU
 via `DefaultRasterizer.RasterizeStrokeRows` and the GPU via
 `StrokeExpandComputeShader`. Both share the same `StrokeEdgeFlags` enum and
-`DashPathSplitter` (in the core project). The CPU backend fuses stroke expansion
+`SplitPathExtensions.GenerateDashes` (in the core project). The CPU backend fuses stroke expansion
 directly into the rasterizer's band loop, while the GPU backend uses a separate
 compute dispatch that writes outline edges into pre-allocated per-band output
 slots sized by `ComputeOutlineEdgesPerCenterline()`.

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.cs

@@ -506,7 +506,7 @@ private bool TryRenderPreparedFlush<TPixel>(
             {
                 // For dashed strokes, split the path into dash segments on the CPU
                 // so the GPU evaluates solid strokes on each dash segment.
-                strokePath = DashPathSplitter.SplitDashes(strokePath, definition.StrokeWidth, definition.StrokePattern.Span);
+                strokePath = strokePath.GenerateDashes(definition.StrokeWidth, definition.StrokePattern.Span);
             }
 
             float halfWidth = definition.StrokeWidth * 0.5f;

src/ImageSharp.Drawing/OutlinePathExtensions.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Numerics;
 using SixLabors.ImageSharp.Drawing.PolygonGeometry;
 using SixLabors.ImageSharp.Drawing.Processing;
 
@@ -98,144 +97,22 @@ public static IPath GenerateOutline(
             return path.GenerateOutline(width, strokeOptions);
         }
 
-        const float eps = 1e-6f;
-        const int maxPatternSegments = 10000;
+        IPath dashed = path.GenerateDashes(width, pattern, startOff);
 
-        // Compute the absolute pattern length in path units to detect degenerate patterns.
-        float patternLength = 0f;
-        for (int i = 0; i < pattern.Length; i++)
-        {
-            patternLength += MathF.Abs(pattern[i]) * width;
-        }
-
-        // Fallback to a solid outline when the dash pattern is too small to be meaningful.
-        if (patternLength <= eps)
+        // GenerateDashes returns the original path when the pattern is degenerate
+        // or when segmentation would exceed safety limits; stroke it as solid.
+        if (ReferenceEquals(dashed, path))
         {
             return path.GenerateOutline(width, strokeOptions);
         }
 
-        IEnumerable<ISimplePath> paths = path.Flatten();
-
-        List<PointF[]> outlines = [];
-        List<PointF> buffer = new(64); // arbitrary initial capacity hint.
-
-        foreach (ISimplePath p in paths)
+        if (dashed == Path.Empty)
         {
-            bool online = !startOff;
-            int patternPos = 0;
-            float targetLength = pattern[patternPos] * width;
-
-            ReadOnlySpan<PointF> pts = p.Points.Span;
-            if (pts.Length < 2)
-            {
-                continue;
-            }
-
-            // number of edges to traverse (no wrap for open paths)
-            int edgeCount = p.IsClosed ? pts.Length : pts.Length - 1;
-            float totalLength = 0f;
-
-            // Compute total path length to estimate the number of dash segments to produce.
-            for (int j = 0; j < edgeCount; j++)
-            {
-                int nextIndex = p.IsClosed ? (j + 1) % pts.Length : j + 1;
-                totalLength += Vector2.Distance(pts[j], pts[nextIndex]);
-            }
-
-            if (totalLength > eps)
-            {
-                // Avoid runaway segmentation by falling back when the dash count explodes.
-                float estimatedSegments = (totalLength / patternLength) * pattern.Length;
-                if (estimatedSegments > maxPatternSegments)
-                {
-                    return path.GenerateOutline(width, strokeOptions);
-                }
-            }
-
-            int i = 0;
-            Vector2 current = pts[0];
-
-            while (i < edgeCount)
-            {
-                int nextIndex = p.IsClosed ? (i + 1) % pts.Length : i + 1;
-                Vector2 next = pts[nextIndex];
-                float segLen = Vector2.Distance(current, next);
-
-                // Skip degenerate segments.
-                if (segLen <= eps)
-                {
-                    current = next;
-                    i++;
-                    continue;
-                }
-
-                // Accumulate into the current dash span when the segment is shorter than the target.
-                if (segLen + eps < targetLength)
-                {
-                    buffer.Add(current);
-                    current = next;
-                    i++;
-                    targetLength -= segLen;
-                    continue;
-                }
-
-                // Close out a dash span when the segment length matches the target length.
-                if (MathF.Abs(segLen - targetLength) <= eps)
-                {
-                    buffer.Add(current);
-                    buffer.Add(next);
-
-                    if (online && buffer.Count >= 2 && buffer[0] != buffer[^1])
-                    {
-                        outlines.Add([.. buffer]);
-                    }
-
-                    buffer.Clear();
-                    online = !online;
-
-                    current = next;
-                    i++;
-                    patternPos = (patternPos + 1) % pattern.Length;
-                    targetLength = pattern[patternPos] * width;
-                    continue;
-                }
-
-                // Split inside this segment to end the current dash span.
-                float t = targetLength / segLen; // 0 < t < 1 here
-                Vector2 split = current + (t * (next - current));
-
-                buffer.Add(current);
-                buffer.Add(split);
-
-                if (online && buffer.Count >= 2 && buffer[0] != buffer[^1])
-                {
-                    outlines.Add([.. buffer]);
-                }
-
-                buffer.Clear();
-                online = !online;
-
-                current = split; // continue along the same geometric segment
-
-                patternPos = (patternPos + 1) % pattern.Length;
-                targetLength = pattern[patternPos] * width;
-            }
-
-            // flush tail of the last dash span, if any
-            if (buffer.Count > 0)
-            {
-                buffer.Add(current); // terminate at the true end position
-
-                if (online && buffer.Count >= 2 && buffer[0] != buffer[^1])
-                {
-                    outlines.Add([.. buffer]);
-                }
-
-                buffer.Clear();
-            }
+            return Path.Empty;
         }
 
-        // Each outline span is stroked as an open polyline; the union cleans overlaps.
-        return StrokedShapeGenerator.GenerateStrokedShapes(outlines, width, strokeOptions);
+        // Each dash segment is an open sub-path; stroke expansion and boolean merge
+        // are handled by the generator.
+        return StrokedShapeGenerator.GenerateStrokedShapes(dashed, width, strokeOptions);
     }
 }

src/ImageSharp.Drawing/PolygonGeometry/StrokedShapeGenerator.cs

@@ -13,67 +13,6 @@ namespace SixLabors.ImageSharp.Drawing.PolygonGeometry;
 /// </summary>
 internal static class StrokedShapeGenerator
 {
-    /// <summary>
-    /// Strokes a collection of dashed polyline spans and returns a merged outline.
-    /// </summary>
-    /// <param name="spans">
-    /// The input spans. Each <see cref="PointF"/> array is treated as an open polyline
-    /// and is stroked using the current stroker settings.
-    /// Spans that are null or contain fewer than 2 points are ignored.
-    /// </param>
-    /// <param name="width">The stroke width in the caller's coordinate space.</param>
-    /// <param name="options">The stroke geometry options.</param>
-    /// <returns>
-    /// A <see cref="ComplexPolygon"/> representing the stroked outline after boolean merge.
-    /// </returns>
-    public static ComplexPolygon GenerateStrokedShapes(List<PointF[]> spans, float width, StrokeOptions options)
-    {
-        // 1) Stroke each dashed span as open.
-        PCPolygon rings = new(spans.Count);
-        foreach (PointF[] span in spans)
-        {
-            if (span == null || span.Length < 2)
-            {
-                continue;
-            }
-
-            Contour ring = new(span.Length);
-            for (int i = 0; i < span.Length; i++)
-            {
-                PointF p = span[i];
-                ring.Add(new Vertex(p.X, p.Y));
-            }
-
-            rings.Add(ring);
-        }
-
-        int count = rings.Count;
-        if (count == 0)
-        {
-            return new([]);
-        }
-
-        PCPolygon result = PolygonStroker.Stroke(rings, width, CreateStrokeOptions(options));
-
-        IPath[] shapes = new IPath[result.Count];
-        int index = 0;
-        for (int i = 0; i < result.Count; i++)
-        {
-            Contour contour = result[i];
-            PointF[] points = new PointF[contour.Count];
-
-            for (int j = 0; j < contour.Count; j++)
-            {
-                Vertex vertex = contour[j];
-                points[j] = new PointF((float)vertex.X, (float)vertex.Y);
-            }
-
-            shapes[index++] = new Polygon(points);
-        }
-
-        return new(shapes);
-    }
-
     /// <summary>
     /// Strokes a path and returns a merged outline from its flattened segments.
     /// </summary>
@@ -168,7 +107,8 @@ private static PolygonClipper.StrokeOptions CreateStrokeOptions(StrokeOptions op
                 LineCap.Round => PolygonClipper.LineCap.Round,
                 LineCap.Square => PolygonClipper.LineCap.Square,
                 _ => PolygonClipper.LineCap.Butt,
-            }
+            },
+            NormalizeOutput = options.NormalizeOutput
         };
 
         return o;

src/ImageSharp.Drawing/Processing/Backends/DefaultDrawingBackend.cs

@@ -162,7 +162,7 @@ private void FlushPreparedBatch<TPixel>(
         {
             // Dashed strokes: split into dash segments on the CPU, then stroke-expand
             // each segment via the per-band parallel path (same as solid strokes).
-            rasterPath = DashPathSplitter.SplitDashes(rasterPath, definition.StrokeWidth, definition.StrokePattern.Span);
+            rasterPath = rasterPath.GenerateDashes(definition.StrokeWidth, definition.StrokePattern.Span);
 
             // Recompute interest from the split path bounds with stroke expansion.
             float halfWidth = definition.StrokeWidth * 0.5f;

src/ImageSharp.Drawing/Processing/Backends/PolygonScanning.MD

@@ -52,14 +52,14 @@ each parallel band only expands the centerline edges that overlap it. This avoid
 the cost of a serial full-path `GenerateOutline()` call and eliminates the
 intermediate `IPath` allocation for the expanded outline.
 
-For dashed strokes, `DashPathSplitter` splits the centerline into dash segments
+For dashed strokes, `SplitPathExtensions` splits the centerline into dash segments
 on the CPU before passing the result through the same per-band stroke expansion
 pipeline.
 
 ```
 IPath (centerline)
   |
-  +--> [if dashed] DashPathSplitter.SplitDashes(path, strokeWidth, pattern)
+  +--> [if dashed] SplitPathExtensions.GenerateDashes(path, strokeWidth, pattern)
   |
   v
 path.Flatten() -> List<ISimplePath> (preserving open/closed state)

src/ImageSharp.Drawing/Processing/StrokeOptions.cs

@@ -40,6 +40,16 @@ public sealed class StrokeOptions : IEquatable<StrokeOptions?>
     /// </summary>
     public InnerJoin InnerJoin { get; set; } = InnerJoin.Miter;
 
+    /// <summary>
+    /// Gets or sets a value indicating whether stroked contours should be normalized
+    /// by resolving self-intersections and overlaps before returning.
+    /// </summary>
+    /// <remarks>
+    /// Defaults to false for maximum throughput. When disabled, callers should rasterize
+    /// with a non-zero winding fill rule.
+    /// </remarks>
+    public bool NormalizeOutput { get; set; }
+
     /// <inheritdoc/>
     public override bool Equals(object? obj) => this.Equals(obj as StrokeOptions);
 
@@ -51,7 +61,8 @@ public bool Equals(StrokeOptions? other)
            this.ArcDetailScale == other.ArcDetailScale &&
            this.LineJoin == other.LineJoin &&
            this.LineCap == other.LineCap &&
-           this.InnerJoin == other.InnerJoin;
+           this.InnerJoin == other.InnerJoin &&
+           this.NormalizeOutput == other.NormalizeOutput;
 
     /// <inheritdoc/>
     public override int GetHashCode()
@@ -61,5 +72,6 @@ public override int GetHashCode()
             this.ArcDetailScale,
             this.LineJoin,
             this.LineCap,
-            this.InnerJoin);
+            this.InnerJoin,
+            this.NormalizeOutput);
 }