Replace PolygonScanner with DefaultRasterizer and optimize

Author: JimBobSquarePants

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

@@ -116,64 +116,23 @@ public static CompositionCommand Create(
     }
 
     /// <summary>
-    /// Computes a coverage definition key from path geometry and rasterization state.
+    /// Computes a coverage definition key from path identity and rasterization state.
     /// </summary>
     /// <param name="path">Path to rasterize.</param>
     /// <param name="rasterizerOptions">Rasterizer options used for coverage generation.</param>
-    /// <param name="definitionKeyCache">Optional scoped cache keyed by path identity to avoid repeated path flattening.</param>
+    /// <param name="definitionKeyCache">Unused. Retained for API compatibility.</param>
     /// <returns>A stable key for coverage-equivalent commands.</returns>
     public static int ComputeCoverageDefinitionKey(
         IPath path,
         in RasterizerOptions rasterizerOptions,
         Dictionary<int, (IPath Path, int RasterState, int DefinitionKey)>? definitionKeyCache = null)
     {
-        // Fast path: when the caller provides a cache and the same IPath object is
-        // reused (e.g. cached glyph sub-pixel variants), skip the expensive
-        // Flatten + point-hash and return the cached key.
-        if (definitionKeyCache is not null)
-        {
-            int pathIdentity = RuntimeHelpers.GetHashCode(path);
-            int rasterState = HashCode.Combine(
-                rasterizerOptions.Interest.Size,
-                (int)rasterizerOptions.IntersectionRule,
-                (int)rasterizerOptions.RasterizationMode,
-                (int)rasterizerOptions.SamplingOrigin);
-            int cacheProbe = HashCode.Combine(pathIdentity, rasterState);
-
-            if (definitionKeyCache.TryGetValue(cacheProbe, out (IPath Path, int RasterState, int DefinitionKey) cached) &&
-                ReferenceEquals(cached.Path, path) &&
-                cached.RasterState == rasterState)
-            {
-                return cached.DefinitionKey;
-            }
-
-            int definitionKey = ComputeCoverageDefinitionKeySlow(path, in rasterizerOptions);
-            definitionKeyCache[cacheProbe] = (path, rasterState, definitionKey);
-            return definitionKey;
-        }
-
-        return ComputeCoverageDefinitionKeySlow(path, in rasterizerOptions);
-    }
-
-    private static int ComputeCoverageDefinitionKeySlow(IPath path, in RasterizerOptions rasterizerOptions)
-    {
-        HashCode hash = default;
-        foreach (ISimplePath simplePath in path.Flatten())
-        {
-            ReadOnlySpan<PointF> points = simplePath.Points.Span;
-            hash.Add(simplePath.IsClosed);
-            hash.Add(points.Length);
-            for (int i = 0; i < points.Length; i++)
-            {
-                hash.Add(points[i].X);
-                hash.Add(points[i].Y);
-            }
-        }
-
-        hash.Add(rasterizerOptions.Interest.Size);
-        hash.Add((int)rasterizerOptions.IntersectionRule);
-        hash.Add((int)rasterizerOptions.RasterizationMode);
-        hash.Add((int)rasterizerOptions.SamplingOrigin);
-        return hash.ToHashCode();
+        int pathIdentity = RuntimeHelpers.GetHashCode(path);
+        int rasterState = HashCode.Combine(
+            rasterizerOptions.Interest.Size,
+            (int)rasterizerOptions.IntersectionRule,
+            (int)rasterizerOptions.RasterizationMode,
+            (int)rasterizerOptions.SamplingOrigin);
+        return HashCode.Combine(pathIdentity, rasterState);
     }
 }

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

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Runtime.CompilerServices;
+
 namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 
 /// <summary>
@@ -18,14 +20,16 @@ public static List<CompositionBatch> CreatePreparedBatches(
         IReadOnlyList<CompositionCommand> commands,
         in Rectangle targetBounds)
     {
-        List<CompositionBatch> batches = [];
+        int commandCount = commands.Count;
+        List<CompositionBatch> batches = new(EstimateBatchCapacity(commandCount));
         int index = 0;
-        while (index < commands.Count)
+        while (index < commandCount)
         {
             CompositionCommand definitionCommand = commands[index];
             int definitionKey = definitionCommand.DefinitionKey;
-            List<PreparedCompositionCommand> preparedCommands = [];
-            for (; index < commands.Count; index++)
+            int remainingCount = commandCount - index;
+            List<PreparedCompositionCommand> preparedCommands = new(EstimatePreparedCommandCapacity(remainingCount));
+            for (; index < commandCount; index++)
             {
                 CompositionCommand command = commands[index];
                 if (command.DefinitionKey != definitionKey)
@@ -56,6 +60,55 @@ public static List<CompositionBatch> CreatePreparedBatches(
         return batches;
     }
 
+    /// <summary>
+    /// Estimates initial capacity for the outer batch list from total scene command count.
+    /// </summary>
+    /// <param name="commandCount">Total number of scene commands.</param>
+    /// <returns>Suggested initial capacity for the batch list.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int EstimateBatchCapacity(int commandCount)
+    {
+        // Typical scenes reuse coverage definitions, so batch count is usually
+        // meaningfully lower than command count.
+        if (commandCount <= 8)
+        {
+            return commandCount;
+        }
+
+        if (commandCount <= 128)
+        {
+            return commandCount / 2;
+        }
+
+        return commandCount / 4;
+    }
+
+    /// <summary>
+    /// Estimates initial capacity for one contiguous prepared-command run.
+    /// </summary>
+    /// <param name="remainingCount">Commands remaining from the current scan index.</param>
+    /// <returns>Suggested initial capacity for the current prepared-command list.</returns>
+    /// <remarks>
+    /// This estimate is intentionally capped for large tails because the list is
+    /// allocated per run during scanning rather than once per scene.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int EstimatePreparedCommandCapacity(int remainingCount)
+    {
+        // Most adjacent commands share a definition in small-medium scenes.
+        if (remainingCount <= 16)
+        {
+            return remainingCount;
+        }
+
+        if (remainingCount <= 128)
+        {
+            return remainingCount / 2;
+        }
+
+        return 64;
+    }
+
     /// <summary>
     /// Clips one scene command to target bounds and computes coverage source offset mapping.
     /// </summary>

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

@@ -2,8 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Diagnostics.CodeAnalysis;
-using System.Numerics;
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Drawing.Shapes.Rasterization;
 using SixLabors.ImageSharp.Memory;
 
@@ -175,13 +173,12 @@ internal void FlushPreparedBatch<TPixel>(
                 applicators,
                 destinationBounds,
                 definition.RasterizerOptions.Interest.Top);
-            DefaultRasterizer.Instance.Rasterize(
+
+            DefaultRasterizer.RasterizeRows(
                 definition.Path,
                 definition.RasterizerOptions,
                 configuration.MemoryAllocator,
-                ref operation,
-                static (int y, Span<float> scanline, ref RowOperation<TPixel> callbackState) =>
-                    callbackState.InvokeScanline(y, scanline));
+                operation.InvokeCoverageRow);
         }
         finally
         {
@@ -212,153 +209,40 @@ public RowOperation(
             this.coverageTop = coverageTop;
         }
 
-        public void InvokeScanline(int y, Span<float> scanline)
+        public void InvokeCoverageRow(int y, int startX, Span<float> coverage)
         {
             int sourceY = y - this.coverageTop;
+            int rowStart = startX;
+            int rowEnd = startX + coverage.Length;
+
+            Rectangle destinationBounds = this.destinationBounds;
+            BrushApplicator<TPixel>[] applicators = this.applicators;
             for (int i = 0; i < this.commands.Count; i++)
             {
                 PreparedCompositionCommand command = this.commands[i];
+                Rectangle commandDestination = command.DestinationRegion;
+
                 int commandY = sourceY - command.SourceOffset.Y;
-                if ((uint)commandY >= (uint)command.DestinationRegion.Height)
+                if ((uint)commandY >= (uint)commandDestination.Height)
                 {
                     continue;
                 }
 
-                int destinationX = this.destinationBounds.X + command.DestinationRegion.X;
-                int destinationY = this.destinationBounds.Y + command.DestinationRegion.Y + commandY;
                 int sourceStartX = command.SourceOffset.X;
-                Span<float> rowSlice = scanline.Slice(sourceStartX, command.DestinationRegion.Width);
-                ApplyCoverageSpans(this.applicators[i], rowSlice, destinationX, destinationY);
-            }
-        }
-
-        /// <summary>
-        /// Applies only contiguous non-zero coverage spans for a scanline.
-        /// </summary>
-        /// <param name="applicator">Brush applicator used to composite pixels.</param>
-        /// <param name="coverage">Scanline coverage values for the current command row.</param>
-        /// <param name="destinationX">Destination x coordinate for the start of <paramref name="coverage"/>.</param>
-        /// <param name="destinationY">Destination y coordinate for the scanline.</param>
-        private static void ApplyCoverageSpans(
-            BrushApplicator<TPixel> applicator,
-            Span<float> coverage,
-            int destinationX,
-            int destinationY)
-        {
-            // Use SIMD path when available and the span is large enough to amortize setup.
-            if (Vector.IsHardwareAccelerated && coverage.Length >= (Vector<float>.Count * 2))
-            {
-                ApplyCoverageSpansSimd(applicator, coverage, destinationX, destinationY);
-                return;
-            }
-
-            ApplyCoverageSpansScalar(applicator, coverage, destinationX, destinationY);
-        }
-
-        /// <summary>
-        /// Applies contiguous non-zero coverage spans using SIMD-accelerated zero/non-zero chunk checks.
-        /// </summary>
-        /// <param name="applicator">Brush applicator used to composite pixels.</param>
-        /// <param name="coverage">Scanline coverage values for the current command row.</param>
-        /// <param name="destinationX">Destination x coordinate for the start of <paramref name="coverage"/>.</param>
-        /// <param name="destinationY">Destination y coordinate for the scanline.</param>
-        private static void ApplyCoverageSpansSimd(
-            BrushApplicator<TPixel> applicator,
-            Span<float> coverage,
-            int destinationX,
-            int destinationY)
-        {
-            int i = 0;
-            int n = coverage.Length;
-            int width = Vector<float>.Count;
-            Vector<float> zero = Vector<float>.Zero;
-
-            while (i < n)
-            {
-                // Phase 1: skip fully-zero SIMD blocks.
-                while (i <= n - width)
-                {
-                    Vector<float> v = new(coverage.Slice(i, width));
-                    if (!Vector.EqualsAll(v, zero))
-                    {
-                        break;
-                    }
-
-                    i += width;
-                }
-
-                while (i < n && coverage[i] == 0F)
-                {
-                    i++;
-                }
-
-                if (i >= n)
-                {
-                    return;
-                }
-
-                int runStart = i;
-
-                // Phase 2: advance across fully non-zero SIMD blocks.
-                while (i <= n - width)
+                int sourceEndX = sourceStartX + commandDestination.Width;
+                int overlapStart = Math.Max(rowStart, sourceStartX);
+                int overlapEnd = Math.Min(rowEnd, sourceEndX);
+                if (overlapEnd <= overlapStart)
                 {
-                    Vector<float> v = new(coverage.Slice(i, width));
-                    Vector<int> eqZero = Vector.Equals(v, zero);
-                    if (!Vector.EqualsAll(eqZero, Vector<int>.Zero))
-                    {
-                        break;
-                    }
-
-                    i += width;
+                    continue;
                 }
 
-                while (i < n && coverage[i] != 0F)
-                {
-                    i++;
-                }
+                int localStart = overlapStart - rowStart;
+                int localLength = overlapEnd - overlapStart;
+                int destinationX = destinationBounds.X + commandDestination.X + (overlapStart - sourceStartX);
+                int destinationY = destinationBounds.Y + commandDestination.Y + commandY;
 
-                // Apply exactly one contiguous non-zero run.
-                applicator.Apply(coverage[runStart..i], destinationX + runStart, destinationY);
-            }
-        }
-
-        /// <summary>
-        /// Applies contiguous non-zero coverage spans using a scalar scan.
-        /// </summary>
-        /// <param name="applicator">Brush applicator used to composite pixels.</param>
-        /// <param name="coverage">Scanline coverage values for the current command row.</param>
-        /// <param name="destinationX">Destination x coordinate for the start of <paramref name="coverage"/>.</param>
-        /// <param name="destinationY">Destination y coordinate for the scanline.</param>
-        private static void ApplyCoverageSpansScalar(
-            BrushApplicator<TPixel> applicator,
-            Span<float> coverage,
-            int destinationX,
-            int destinationY)
-        {
-            // Track the start of a contiguous non-zero coverage run.
-            int runStart = -1;
-            for (int i = 0; i < coverage.Length; i++)
-            {
-                if (coverage[i] > 0F)
-                {
-                    // Enter a new run when transitioning from zero to non-zero coverage.
-                    if (runStart < 0)
-                    {
-                        runStart = i;
-                    }
-                }
-                else if (runStart >= 0)
-                {
-                    // Coverage returned to zero: apply the finished run only.
-                    applicator.Apply(coverage[runStart..i], destinationX + runStart, destinationY);
-                    runStart = -1;
-                }
-            }
-
-            if (runStart >= 0)
-            {
-                // Flush trailing run that reaches end-of-scanline.
-                applicator.Apply(coverage[runStart..], destinationX + runStart, destinationY);
+                applicators[i].Apply(coverage.Slice(localStart, localLength), destinationX, destinationY);
             }
         }
     }