Fix #344

Author: JimBobSquarePants

src/ImageSharp.Drawing/InternalPath.cs

@@ -225,16 +225,47 @@ private static PointData[] Simplify(IReadOnlyList<ILineSegment> segments, bool i
     {
         List<PointF> simplified = new(segments.Count);
 
+        // Track indices where collinear direction reversals represent user-intended
+        // geometry: interior points of multi-point linear segments, and junction
+        // points between two linear segments (e.g. PathBuilder LineTo → LineTo).
+        // Reversals at all other indices (flattened curves, curve junctions) are
+        // artifacts and should be removed normally.
+        HashSet<int>? linearReversalIndices = null;
+        ILineSegment? prevSeg = null;
+
         foreach (ILineSegment seg in segments)
         {
+            int start = simplified.Count;
             ReadOnlyMemory<PointF> points = seg.Flatten();
             simplified.AddRange(points.Span);
+
+            if (seg is LinearLineSegment)
+            {
+                // Interior points of a multi-point linear segment (e.g. DrawLine with 3+ points).
+                if (points.Length > 2)
+                {
+                    linearReversalIndices ??= [];
+                    for (int i = start + 1; i < start + points.Length - 1; i++)
+                    {
+                        _ = linearReversalIndices.Add(i);
+                    }
+                }
+
+                // Junction between two linear segments (e.g. PathBuilder LineTo → LineTo).
+                if (prevSeg is LinearLineSegment && start > 0)
+                {
+                    linearReversalIndices ??= [];
+                    _ = linearReversalIndices.Add(start);
+                }
+            }
+
+            prevSeg = seg;
         }
 
-        return Simplify(CollectionsMarshal.AsSpan(simplified), isClosed, removeCloseAndCollinear);
+        return Simplify(CollectionsMarshal.AsSpan(simplified), isClosed, removeCloseAndCollinear, linearReversalIndices);
     }
 
-    private static PointData[] Simplify(ReadOnlySpan<PointF> points, bool isClosed, bool removeCloseAndCollinear)
+    private static PointData[] Simplify(ReadOnlySpan<PointF> points, bool isClosed, bool removeCloseAndCollinear, HashSet<int>? linearReversalIndices = null)
     {
         int polyCorners = points.Length;
         if (polyCorners == 0)
@@ -294,9 +325,27 @@ private static PointData[] Simplify(ReadOnlySpan<PointF> points, bool isClosed,
         {
             int next = WrapArrayIndex(i + 1, polyCorners);
             PointOrientation or = CalculateOrientation(lastPoint, points[i], points[next]);
-            if (or == PointOrientation.Collinear && next != 0)
+            if (removeCloseAndCollinear && or == PointOrientation.Collinear && next != 0)
             {
-                continue;
+                // Preserve collinear points that represent a direction reversal (U-turn)
+                // within a single segment. E.g. (10,10)→(90,10)→(20,10): the middle point
+                // is collinear but the stroker needs to see the reversal.
+                // Don't preserve reversals at segment boundaries — these arise from joining
+                // different path segments (e.g. arc-to-arc) and are not user-intended.
+                bool preserve = false;
+                if (linearReversalIndices == null || linearReversalIndices.Contains(i))
+                {
+                    Vector2 incoming = (Vector2)points[i] - lastPoint;
+                    Vector2 outgoing = (Vector2)points[next] - (Vector2)points[i];
+                    float inLen = incoming.Length();
+                    float outLen = outgoing.Length();
+                    preserve = inLen > Epsilon && outLen > Epsilon && Vector2.Dot(incoming, outgoing) < 0;
+                }
+
+                if (!preserve)
+                {
+                    continue;
+                }
             }
 
             results.Add(

src/ImageSharp.Drawing/PathBuilder.cs

@@ -110,6 +110,15 @@ public PathBuilder MoveTo(PointF point)
         return this;
     }
 
+    /// <summary>
+    /// Moves to current point to the supplied vector.
+    /// </summary>
+    /// <param name="x">The x-coordinate.</param>
+    /// <param name="y">The y-coordinate.</param>
+    /// <returns>The <see cref="PathBuilder"/></returns>
+    public PathBuilder MoveTo(float x, float y)
+        => this.MoveTo(new PointF(x, y));
+
     /// <summary>
     /// Draws the line connecting the current the current point to the new point.
     /// </summary>

tests/ImageSharp.Drawing.Tests/Issues/Issue_344.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Drawing.Processing;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Issues;
+
+public class Issue_344
+{
+    [Theory]
+    [WithSolidFilledImages(100, 100, nameof(Color.Black), PixelTypes.Rgba32)]
+    public void CanDrawWhereSegmentsOverlap<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => provider.RunValidatingProcessorTest(
+            c => c.ProcessWithCanvas(canvas =>
+                {
+                    Pen pen = Pens.Solid(Color.Aqua.WithAlpha(.3F), 1);
+                    canvas.DrawLine(pen, new PointF(10, 10), new PointF(90, 10), new PointF(20, 10));
+                }));
+
+    [Theory]
+    [WithSolidFilledImages(100, 100, nameof(Color.Black), PixelTypes.Rgba32)]
+    public void CanDrawWhereSegmentsOverlap_PathBuilder<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+        => provider.RunValidatingProcessorTest(
+            c => c.ProcessWithCanvas(canvas =>
+            {
+                PathBuilder pathBuilder = new();
+                pathBuilder.MoveTo(10, 10);
+                pathBuilder.LineTo(90, 10);
+                pathBuilder.LineTo(20, 10);
+
+                Pen pen = Pens.Solid(Color.Aqua.WithAlpha(.3F), 1);
+                canvas.Draw(pen, pathBuilder);
+            }));
+}

tests/ImageSharp.Drawing.Tests/Processing/ProcessWithDrawingCanvasTests.Primitives.cs

@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using SixLabors.ImageSharp.Drawing.Processing;
-using SixLabors.ImageSharp.Drawing.Tests.TestUtilities;
 using SixLabors.ImageSharp.Drawing.Tests.TestUtilities.ImageComparison;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;