Refactor path flattening and remove tessellation

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.CoverageRasterizer.cs

@@ -617,20 +617,23 @@ private static bool TryBuildFixedPointEdges(
         int interestY = interest.Y;
         int bandCount = (int)DivideRoundUp(height, TileHeight);
 
-        // Pass 1: Flatten path and count edges per band.
+        // Flatten once and reuse the list for both passes.
+        IEnumerable<ISimplePath> flattened = path.Flatten();
+        IReadOnlyList<ISimplePath> contours = flattened is IReadOnlyList<ISimplePath> list
+            ? list
+            : [.. flattened];
+
+        // Pass 1: Count edges per band.
         int totalSubEdges = 0;
         using IMemoryOwner<int> bandCountsOwner = allocator.Allocate<int>(bandCount, AllocationOptions.Clean);
         Span<int> bandCounts = bandCountsOwner.Memory.Span;
 
-        foreach (ISimplePath simplePath in path.Flatten())
+        for (int c = 0; c < contours.Count; c++)
         {
+            ISimplePath simplePath = contours[c];
             ReadOnlySpan<PointF> points = simplePath.Points.Span;
-            if (points.Length < 2)
-            {
-                continue;
-            }
-
             int segmentCount = simplePath.IsClosed ? points.Length : points.Length - 1;
+
             for (int j = 0; j < segmentCount; j++)
             {
                 PointF p0 = points[j];
@@ -681,20 +684,16 @@ private static bool TryBuildFixedPointEdges(
 
         offsets[bandCount] = running;
 
-        // Pass 2: Flatten again and scatter edges directly into the final buffer.
+        // Pass 2: Scatter edges directly into the final buffer.
         IMemoryOwner<GpuEdge> finalOwner = allocator.Allocate<GpuEdge>(totalSubEdges);
         Span<GpuEdge> finalSpan = finalOwner.Memory.Span;
         using IMemoryOwner<uint> writeCursorsOwner = allocator.Allocate<uint>(bandCount, AllocationOptions.Clean);
         Span<uint> writeCursors = writeCursorsOwner.Memory.Span;
 
-        foreach (ISimplePath simplePath in path.Flatten())
+        for (int c = 0; c < contours.Count; c++)
         {
+            ISimplePath simplePath = contours[c];
             ReadOnlySpan<PointF> points = simplePath.Points.Span;
-            if (points.Length < 2)
-            {
-                continue;
-            }
-
             int segmentCount = simplePath.IsClosed ? points.Length : points.Length - 1;
             for (int j = 0; j < segmentCount; j++)
             {
@@ -775,17 +774,20 @@ private static bool TryBuildStrokeEdges(
         float halfWidth = strokeWidth * 0.5f;
         int yExpansionFixed = (int)MathF.Ceiling(Math.Max(miterLimit, 1f) * halfWidth * FixedOne);
 
+        // Flatten once and reuse the list.
+        IEnumerable<ISimplePath> flattened = path.Flatten();
+        IReadOnlyList<ISimplePath> contours = flattened is IReadOnlyList<ISimplePath> list
+            ? list
+            : [.. flattened];
+
         // Pass 1: Collect all stroke edges and count per band.
         List<GpuEdge> strokeEdges = [];
         List<(int YMinFixed, int YMaxFixed)> edgeYRanges = [];
 
-        foreach (ISimplePath simplePath in path.Flatten())
+        for (int c = 0; c < contours.Count; c++)
         {
+            ISimplePath simplePath = contours[c];
             ReadOnlySpan<PointF> points = simplePath.Points.Span;
-            if (points.Length < 2)
-            {
-                continue;
-            }
 
             bool isClosed = simplePath.IsClosed;
             int segmentCount = isClosed ? points.Length : points.Length - 1;

src/ImageSharp.Drawing/ImageSharp.Drawing.csproj

@@ -45,7 +45,7 @@
     <None Include="..\..\shared-infrastructure\branding\icons\imagesharp.drawing\sixlabors.imagesharp.drawing.128.png" Pack="true" PackagePath="" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="SixLabors.Fonts" Version="3.0.0-alpha.0.27" />
+    <PackageReference Include="SixLabors.Fonts" Version="3.0.0-alpha.0.28" />
     <PackageReference Include="SixLabors.ImageSharp" Version="4.0.0-alpha.0.84" />
     <PackageReference Include="SixLabors.PolygonClipper" Version="1.0.0-alpha.0.52" />
   </ItemGroup>

src/ImageSharp.Drawing/InternalPath.cs

@@ -178,19 +178,6 @@ internal SegmentInfo PointAlongPath(float distanceAlongPath)
         };
     }
 
-    internal IMemoryOwner<PointF> ExtractVertices(MemoryAllocator allocator)
-    {
-        IMemoryOwner<PointF> buffer = allocator.Allocate<PointF>(this.points.Length + 1);
-        Span<PointF> span = buffer.Memory.Span;
-
-        for (int i = 0; i < this.points.Length; i++)
-        {
-            span[i] = this.points[i].Point;
-        }
-
-        return buffer;
-    }
-
     // Modulo is a very slow operation.
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int WrapArrayIndex(int i, int arrayLength) => i < arrayLength ? i : i - arrayLength;

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

@@ -53,7 +53,8 @@ private CompositionCommand(
     public int DefinitionKey { get; }
 
     /// <summary>
-    /// Gets the path to rasterize in target-local coordinates.
+    /// Gets the flattened path to rasterize in target-local coordinates.
+    /// All sub-paths are pre-flattened and oriented for correct fill rasterization.
     /// </summary>
     public IPath Path { get; }
 

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

@@ -58,7 +58,8 @@ public CompositionCoverageDefinition(
     public int DefinitionKey { get; }
 
     /// <summary>
-    /// Gets the path used to generate coverage.
+    /// Gets the closed, flattened path used to generate coverage.
+    /// All sub-paths are pre-flattened and oriented for correct fill rasterization.
     /// </summary>
     public IPath Path { get; }
 

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

@@ -202,10 +202,26 @@ private static void RasterizeCoreRows(
         float samplingOffsetX = samplePixelCenter ? 0.5F : 0F;
         float samplingOffsetY = samplePixelCenter ? 0.5F : 0F;
 
-        using TessellatedMultipolygon multipolygon = TessellatedMultipolygon.Create(path, allocator);
-        using IMemoryOwner<EdgeData> edgeDataOwner = allocator.Allocate<EdgeData>(multipolygon.TotalVertexCount);
+        IEnumerable<ISimplePath> flattened = path.Flatten();
+        IReadOnlyList<ISimplePath> contours = flattened is IReadOnlyList<ISimplePath> list
+            ? list
+            : [.. flattened];
+
+        int totalSegments = 0;
+        for (int i = 0; i < contours.Count; i++)
+        {
+            ISimplePath sp = contours[i];
+            totalSegments += sp.IsClosed ? sp.Points.Length : sp.Points.Length - 1;
+        }
+
+        if (totalSegments == 0)
+        {
+            return;
+        }
+
+        using IMemoryOwner<EdgeData> edgeDataOwner = allocator.Allocate<EdgeData>(totalSegments);
         int edgeCount = BuildEdgeTable(
-            multipolygon,
+            contours,
             interest.Left,
             interest.Top,
             height,
@@ -1164,7 +1180,7 @@ private static int BuildStrokeEdgeTable(
     /// <summary>
     /// Builds an edge table in scanner-local coordinates.
     /// </summary>
-    /// <param name="multipolygon">Input tessellated rings.</param>
+    /// <param name="contours">Flattened path contours.</param>
     /// <param name="minX">Interest left in absolute coordinates.</param>
     /// <param name="minY">Interest top in absolute coordinates.</param>
     /// <param name="height">Interest height in pixels.</param>
@@ -1173,7 +1189,7 @@ private static int BuildStrokeEdgeTable(
     /// <param name="destination">Destination span for edge records.</param>
     /// <returns>Number of valid edge records written.</returns>
     private static int BuildEdgeTable(
-        TessellatedMultipolygon multipolygon,
+        IReadOnlyList<ISimplePath> contours,
         int minX,
         int minY,
         int height,
@@ -1182,13 +1198,15 @@ private static int BuildEdgeTable(
         Span<EdgeData> destination)
     {
         int count = 0;
-        foreach (TessellatedMultipolygon.Ring ring in multipolygon)
+        for (int r = 0; r < contours.Count; r++)
         {
-            ReadOnlySpan<PointF> vertices = ring.Vertices;
-            for (int i = 0; i < ring.VertexCount; i++)
+            ISimplePath contour = contours[r];
+            ReadOnlySpan<PointF> points = contour.Points.Span;
+            int segmentCount = contour.IsClosed ? points.Length : points.Length - 1;
+            for (int i = 0; i < segmentCount; i++)
             {
-                PointF p0 = vertices[i];
-                PointF p1 = vertices[i + 1];
+                PointF p0 = points[i];
+                PointF p1 = points[i + 1 == points.Length ? 0 : i + 1];
 
                 float x0 = (p0.X - minX) + samplingOffsetX;
                 float y0 = (p0.Y - minY) + samplingOffsetY;
@@ -1530,58 +1548,6 @@ public Context(
             this.touchedRowCount = 0;
         }
 
-        /// <summary>
-        /// Rasterizes all edges in a tessellated multipolygon directly into this context.
-        /// </summary>
-        /// <param name="multipolygon">Input tessellated rings.</param>
-        /// <param name="minX">Absolute left coordinate of the current scanner window.</param>
-        /// <param name="minY">Absolute top coordinate of the current scanner window.</param>
-        /// <param name="samplingOffsetX">Horizontal sample origin offset.</param>
-        /// <param name="samplingOffsetY">Vertical sample origin offset.</param>
-        public void RasterizeMultipolygon(
-            TessellatedMultipolygon multipolygon,
-            int minX,
-            int minY,
-            float samplingOffsetX,
-            float samplingOffsetY)
-        {
-            foreach (TessellatedMultipolygon.Ring ring in multipolygon)
-            {
-                ReadOnlySpan<PointF> vertices = ring.Vertices;
-                for (int i = 0; i < ring.VertexCount; i++)
-                {
-                    PointF p0 = vertices[i];
-                    PointF p1 = vertices[i + 1];
-
-                    float x0 = (p0.X - minX) + samplingOffsetX;
-                    float y0 = (p0.Y - minY) + samplingOffsetY;
-                    float x1 = (p1.X - minX) + samplingOffsetX;
-                    float y1 = (p1.Y - minY) + samplingOffsetY;
-
-                    if (!float.IsFinite(x0) || !float.IsFinite(y0) || !float.IsFinite(x1) || !float.IsFinite(y1))
-                    {
-                        continue;
-                    }
-
-                    if (!ClipToVerticalBounds(ref x0, ref y0, ref x1, ref y1, 0F, this.height))
-                    {
-                        continue;
-                    }
-
-                    int fx0 = FloatToFixed24Dot8(x0);
-                    int fy0 = FloatToFixed24Dot8(y0);
-                    int fx1 = FloatToFixed24Dot8(x1);
-                    int fy1 = FloatToFixed24Dot8(y1);
-                    if (fy0 == fy1)
-                    {
-                        continue;
-                    }
-
-                    this.RasterizeLine(fx0, fy0, fx1, fy1);
-                }
-            }
-        }
-
         /// <summary>
         /// Rasterizes all prebuilt edges that overlap this context.
         /// </summary>

src/ImageSharp.Drawing/Processing/DrawingCanvas.PreFlattenedPath.cs

@@ -15,13 +15,13 @@ public sealed partial class DrawingCanvas<TPixel>
     /// <see cref="Flatten"/> returns <c>this</c> directly, avoiding redundant curve subdivision.
     /// Points are mutated in place on <see cref="Transform"/>; no buffers are copied.
     /// </summary>
-    private sealed class PreFlattenedPath : IPath, ISimplePath
+    private sealed class FlattenedPath : IPath, ISimplePath
     {
         private readonly PointF[] points;
         private readonly bool isClosed;
         private RectangleF bounds;
 
-        public PreFlattenedPath(PointF[] points, bool isClosed, RectangleF bounds)
+        public FlattenedPath(PointF[] points, bool isClosed, RectangleF bounds)
         {
             this.points = points;
             this.isClosed = isClosed;
@@ -94,20 +94,35 @@ public IPath Transform(Matrix4x4 matrix)
 
         /// <inheritdoc />
         public IPath AsClosedPath()
-            => this.isClosed ? this : new PreFlattenedPath(this.points, true, this.bounds);
+        {
+            if (this.isClosed)
+            {
+                return this;
+            }
+
+            PointF[] closedPoints = new PointF[this.points.Length + 1];
+            for (int i = 0; i < this.points.Length; i++)
+            {
+                closedPoints[i] = this.points[i];
+            }
+
+            closedPoints[^1] = this.points[0];
+            return new FlattenedPath(closedPoints, true, this.bounds);
+        }
     }
 
     /// <summary>
     /// A lightweight <see cref="IPath"/> wrapper around multiple pre-flattened sub-paths.
     /// <see cref="Flatten"/> yields each sub-path directly, avoiding redundant curve subdivision.
     /// Sub-path points are mutated in place on <see cref="Transform"/>; no buffers are copied.
     /// </summary>
-    private sealed class PreFlattenedCompositePath : IPath
+    private sealed class FlattenedCompositePath : IPath
     {
-        private readonly PreFlattenedPath[] subPaths;
+        private readonly FlattenedPath[] subPaths;
         private RectangleF bounds;
+        private PathTypes? pathType;
 
-        public PreFlattenedCompositePath(PreFlattenedPath[] subPaths, RectangleF bounds)
+        public FlattenedCompositePath(FlattenedPath[] subPaths, RectangleF bounds)
         {
             this.subPaths = subPaths;
             this.bounds = bounds;
@@ -121,9 +136,14 @@ public PathTypes PathType
         {
             get
             {
+                if (this.pathType.HasValue)
+                {
+                    return this.pathType.Value;
+                }
+
                 bool hasOpen = false;
                 bool hasClosed = false;
-                foreach (PreFlattenedPath sp in this.subPaths)
+                foreach (FlattenedPath sp in this.subPaths)
                 {
                     if (sp.PathType == PathTypes.Open)
                     {
@@ -140,7 +160,8 @@ public PathTypes PathType
                     }
                 }
 
-                return hasClosed ? PathTypes.Closed : PathTypes.Open;
+                this.pathType = hasClosed ? PathTypes.Closed : PathTypes.Open;
+                return this.pathType.Value;
             }
         }
 
@@ -165,7 +186,7 @@ public IPath Transform(Matrix4x4 matrix)
 
             for (int i = 0; i < this.subPaths.Length; i++)
             {
-                this.subPaths[i].Transform(matrix);
+                _ = this.subPaths[i].Transform(matrix);
                 RectangleF spBounds = this.subPaths[i].Bounds;
 
                 if (spBounds.Left < minX)
@@ -201,13 +222,13 @@ public IPath AsClosedPath()
                 return this;
             }
 
-            PreFlattenedPath[] closed = new PreFlattenedPath[this.subPaths.Length];
+            FlattenedPath[] closed = new FlattenedPath[this.subPaths.Length];
             for (int i = 0; i < this.subPaths.Length; i++)
             {
-                closed[i] = (PreFlattenedPath)this.subPaths[i].AsClosedPath();
+                closed[i] = (FlattenedPath)this.subPaths[i].AsClosedPath();
             }
 
-            return new PreFlattenedCompositePath(closed, this.bounds);
+            return new FlattenedCompositePath(closed, this.bounds);
         }
     }
 }

src/ImageSharp.Drawing/Processing/DrawingCanvasBatcher{TPixel}.cs

@@ -19,7 +19,6 @@ internal sealed class DrawingCanvasBatcher<TPixel>
 {
     private readonly Configuration configuration;
     private readonly IDrawingBackend backend;
-    private readonly ICanvasFrame<TPixel> targetFrame;
     private readonly List<CompositionCommand> commands = [];
 
     internal DrawingCanvasBatcher(
@@ -29,13 +28,13 @@ internal DrawingCanvasBatcher(
     {
         this.configuration = configuration;
         this.backend = backend;
-        this.targetFrame = targetFrame;
+        this.TargetFrame = targetFrame;
     }
 
     /// <summary>
     /// Gets the target frame that this batcher flushes to.
     /// </summary>
-    public ICanvasFrame<TPixel> TargetFrame => this.targetFrame;
+    public ICanvasFrame<TPixel> TargetFrame { get; }
 
     /// <summary>
     /// Appends one normalized composition command to the pending queue.
@@ -61,7 +60,7 @@ public void FlushCompositions()
         try
         {
             CompositionScene scene = new(this.commands);
-            this.backend.FlushCompositions(this.configuration, this.targetFrame, scene);
+            this.backend.FlushCompositions(this.configuration, this.TargetFrame, scene);
         }
         finally
         {