Remove old scanner/rasterizer

Author: JimBobSquarePants

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

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using SixLabors.ImageSharp.Drawing.Shapes.Rasterization;
 using SixLabors.ImageSharp.Memory;
 
@@ -10,22 +9,14 @@ namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 /// <summary>
 /// Default CPU drawing backend.
 /// </summary>
-/// <remarks>
-/// This backend currently dispatches to the existing scanline rasterizer pipeline.
-/// A tiled rasterizer path is wired behind an AppContext switch for incremental rollout.
-/// </remarks>
 internal sealed class CpuDrawingBackend : IDrawingBackend
 {
-    private const string ExperimentalTiledRasterizerSwitch = "SixLabors.ImageSharp.Drawing.ExperimentalTiledRasterizer";
+    private readonly IRasterizer primaryRasterizer;
 
-    private readonly IRasterizer defaultRasterizer;
-    private readonly TiledRasterizer tiledRasterizer;
-
-    private CpuDrawingBackend(IRasterizer defaultRasterizer)
+    private CpuDrawingBackend(IRasterizer primaryRasterizer)
     {
-        Guard.NotNull(defaultRasterizer, nameof(defaultRasterizer));
-        this.defaultRasterizer = defaultRasterizer;
-        this.tiledRasterizer = TiledRasterizer.Instance;
+        Guard.NotNull(primaryRasterizer, nameof(primaryRasterizer));
+        this.primaryRasterizer = primaryRasterizer;
     }
 
     /// <summary>
@@ -36,7 +27,7 @@ private CpuDrawingBackend(IRasterizer defaultRasterizer)
     /// <summary>
     /// Gets the primary rasterizer used by this backend.
     /// </summary>
-    public IRasterizer PrimaryRasterizer => this.defaultRasterizer;
+    public IRasterizer PrimaryRasterizer => this.primaryRasterizer;
 
     /// <summary>
     /// Creates a backend that uses the given rasterizer as the primary implementation.
@@ -57,16 +48,5 @@ public void RasterizePath<TState>(
         ref TState state,
         RasterizerScanlineHandler<TState> scanlineHandler)
         where TState : struct
-    {
-        if (UseExperimentalTiledRasterizer())
-        {
-            this.tiledRasterizer.Rasterize(path, options, allocator, ref state, scanlineHandler);
-            return;
-        }
-
-        this.defaultRasterizer.Rasterize(path, options, allocator, ref state, scanlineHandler);
-    }
-
-    private static bool UseExperimentalTiledRasterizer()
-        => AppContext.TryGetSwitch(ExperimentalTiledRasterizerSwitch, out bool enabled) && enabled;
+        => this.primaryRasterizer.Rasterize(path, options, allocator, ref state, scanlineHandler);
 }

src/ImageSharp.Drawing/Processing/Processors/Drawing/FillPathProcessor.cs

@@ -11,12 +11,6 @@ namespace SixLabors.ImageSharp.Drawing.Processing.Processors.Drawing;
 /// </summary>
 public class FillPathProcessor : IImageProcessor
 {
-    /// <summary>
-    /// Fixed subpixel sampling density used by the CPU rasterizer for both antialiased and
-    /// quantized-aliased rendering.
-    /// </summary>
-    internal const int FixedRasterizerSubpixelCount = 16;
-
     /// <summary>
     /// Initializes a new instance of the <see cref="FillPathProcessor" /> class.
     /// </summary>

src/ImageSharp.Drawing/Processing/Processors/Drawing/FillPathProcessor{TPixel}.cs

@@ -64,23 +64,20 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
 
         int minX = interest.Left;
 
-        // The rasterizer always computes continuous coverage, then aliased mode quantizes coverage
-        // in ProcessRasterizedScanline().
-        int subpixelCount = FillPathProcessor.FixedRasterizerSubpixelCount;
         using BrushApplicator<TPixel> applicator = brush.CreateApplicator(configuration, graphicsOptions, source, this.bounds);
         MemoryAllocator allocator = this.Configuration.MemoryAllocator;
         IDrawingBackend drawingBackend = configuration.GetDrawingBackend();
+        RasterizationMode rasterizationMode = graphicsOptions.Antialias ? RasterizationMode.Antialiased : RasterizationMode.Aliased;
         RasterizerOptions rasterizerOptions = new(
             interest,
-            subpixelCount,
             shapeOptions.IntersectionRule,
+            rasterizationMode,
             RasterizerSamplingOrigin.PixelBoundary);
 
         RasterizationState state = new(
             source,
             applicator,
             minX,
-            graphicsOptions.Antialias,
             isSolidBrushWithoutBlending,
             solidBrushColor);
 
@@ -106,41 +103,6 @@ private static bool IsSolidBrushWithoutBlending(GraphicsOptions options, Brush i
 
     private static void ProcessRasterizedScanline(int y, Span<float> scanline, ref RasterizationState state)
     {
-        if (!state.Antialias)
-        {
-            bool hasOnes = false;
-            bool hasZeros = false;
-            for (int x = 0; x < scanline.Length; x++)
-            {
-                if (scanline[x] >= 0.5F)
-                {
-                    scanline[x] = 1F;
-                    hasOnes = true;
-                }
-                else
-                {
-                    scanline[x] = 0F;
-                    hasZeros = true;
-                }
-            }
-
-            if (state.IsSolidBrushWithoutBlending && hasOnes != hasZeros)
-            {
-                if (hasOnes)
-                {
-                    state.Source.PixelBuffer.DangerousGetRowSpan(y).Slice(state.MinX, scanline.Length).Fill(state.SolidBrushColor);
-                }
-
-                return;
-            }
-
-            if (state.IsSolidBrushWithoutBlending && hasOnes)
-            {
-                FillOpaqueRuns(state.Source, y, state.MinX, scanline, state.SolidBrushColor);
-                return;
-            }
-        }
-
         if (state.IsSolidBrushWithoutBlending)
         {
             ApplyCoverageRunsForOpaqueSolidBrush(state.Source, state.Applicator, scanline, state.MinX, y, state.SolidBrushColor);
@@ -236,46 +198,18 @@ private static void ApplyCoverageRunsForOpaqueSolidBrush(
         }
     }
 
-    private static void FillOpaqueRuns(ImageFrame<TPixel> source, int y, int minX, Span<float> scanline, TPixel solidBrushColor)
-    {
-        Span<TPixel> destinationRow = source.PixelBuffer.DangerousGetRowSpan(y).Slice(minX, scanline.Length);
-        int i = 0;
-
-        while (i < scanline.Length)
-        {
-            while (i < scanline.Length && scanline[i] <= 0F)
-            {
-                i++;
-            }
-
-            int runStart = i;
-            while (i < scanline.Length && scanline[i] > 0F)
-            {
-                i++;
-            }
-
-            int runLength = i - runStart;
-            if (runLength > 0)
-            {
-                destinationRow.Slice(runStart, runLength).Fill(solidBrushColor);
-            }
-        }
-    }
-
     private readonly struct RasterizationState
     {
         public RasterizationState(
             ImageFrame<TPixel> source,
             BrushApplicator<TPixel> applicator,
             int minX,
-            bool antialias,
             bool isSolidBrushWithoutBlending,
             TPixel solidBrushColor)
         {
             this.Source = source;
             this.Applicator = applicator;
             this.MinX = minX;
-            this.Antialias = antialias;
             this.IsSolidBrushWithoutBlending = isSolidBrushWithoutBlending;
             this.SolidBrushColor = solidBrushColor;
         }
@@ -286,8 +220,6 @@ public RasterizationState(
 
         public int MinX { get; }
 
-        public bool Antialias { get; }
-
         public bool IsSolidBrushWithoutBlending { get; }
 
         public TPixel SolidBrushColor { get; }

src/ImageSharp.Drawing/Processing/Processors/Text/RichTextGlyphRenderer.cs

@@ -541,19 +541,17 @@ private Buffer2D<float> Render(IPath path)
         // Pad to prevent edge clipping.
         size += new Size(2, 2);
 
-        // Use one coverage rasterization path for both AA and aliased text.
-        // Aliased mode quantizes coverage in ProcessTextScanline().
-        int subpixelCount = FillPathProcessor.FixedRasterizerSubpixelCount;
         RasterizerSamplingOrigin samplingOrigin = RasterizerSamplingOrigin.PixelBoundary;
         GraphicsOptions graphicsOptions = this.drawingOptions.GraphicsOptions;
+        RasterizationMode rasterizationMode = graphicsOptions.Antialias ? RasterizationMode.Antialiased : RasterizationMode.Aliased;
 
         // Take the path inside the path builder, scan thing and generate a Buffer2D representing the glyph.
         Buffer2D<float> buffer = this.memoryAllocator.Allocate2D<float>(size.Width, size.Height, AllocationOptions.Clean);
-        TextRasterizationState state = new(buffer, graphicsOptions.Antialias);
+        TextRasterizationState state = new(buffer);
         RasterizerOptions rasterizerOptions = new(
             new Rectangle(0, 0, size.Width, size.Height),
-            subpixelCount,
             TextUtilities.MapFillRule(this.currentFillRule),
+            rasterizationMode,
             samplingOrigin);
 
         this.drawingBackend.RasterizePath(
@@ -570,14 +568,6 @@ private static void ProcessTextScanline(int y, Span<float> scanline, ref TextRas
     {
         Span<float> destination = state.Buffer.DangerousGetRowSpan(y);
         scanline.CopyTo(destination);
-
-        if (!state.Antialias)
-        {
-            for (int x = 0; x < destination.Length; x++)
-            {
-                destination[x] = destination[x] >= 0.5F ? 1F : 0F;
-            }
-        }
     }
 
     private void Dispose(bool disposing)
@@ -625,15 +615,9 @@ public readonly void Dispose()
 
     private readonly struct TextRasterizationState
     {
-        public TextRasterizationState(Buffer2D<float> buffer, bool antialias)
-        {
-            this.Buffer = buffer;
-            this.Antialias = antialias;
-        }
+        public TextRasterizationState(Buffer2D<float> buffer) => this.Buffer = buffer;
 
         public Buffer2D<float> Buffer { get; }
-
-        public bool Antialias { get; }
     }
 
     private readonly struct CacheKey : IEquatable<CacheKey>

src/ImageSharp.Drawing/Shapes/ComplexPolygon.cs

@@ -117,10 +117,7 @@ public IPath AsClosedPath()
     /// <inheritdoc/>
     SegmentInfo IPathInternals.PointAlongPath(float distance)
     {
-        if (this.internalPaths == null)
-        {
-            this.InitInternalPaths();
-        }
+        this.EnsureInternalPaths();
 
         distance %= this.length;
         foreach (InternalPath p in this.internalPaths)
@@ -141,17 +138,29 @@ SegmentInfo IPathInternals.PointAlongPath(float distance)
     /// <inheritdoc/>
     IReadOnlyList<InternalPath> IInternalPathOwner.GetRingsAsInternalPath()
     {
-        this.InitInternalPaths();
+        this.EnsureInternalPaths();
         return this.internalPaths;
     }
 
+    [MemberNotNull(nameof(internalPaths))]
+    private void EnsureInternalPaths()
+    {
+        if (this.internalPaths is not null)
+        {
+            return;
+        }
+
+        this.InitInternalPaths();
+    }
+
     /// <summary>
     /// Initializes <see cref="internalPaths"/> and <see cref="length"/>.
     /// </summary>
     [MemberNotNull(nameof(internalPaths))]
     private void InitInternalPaths()
     {
         this.internalPaths = new List<InternalPath>(this.paths.Length);
+        this.length = 0;
 
         foreach (IPath p in this.paths)
         {

src/ImageSharp.Drawing/Shapes/IInternalPathOwner.cs

@@ -13,5 +13,5 @@ internal interface IInternalPathOwner
     /// Returns the rings as a readonly collection of <see cref="InternalPath"/> elements.
     /// </summary>
     /// <returns>The <see cref="IReadOnlyList{T}"/>.</returns>
-    IReadOnlyList<InternalPath> GetRingsAsInternalPath();
+    public IReadOnlyList<InternalPath> GetRingsAsInternalPath();
 }

src/ImageSharp.Drawing/Shapes/Path.cs

@@ -15,6 +15,7 @@ public class Path : IPath, ISimplePath, IPathInternals, IInternalPathOwner
 {
     private readonly ILineSegment[] lineSegments;
     private InternalPath? innerPath;
+    private IReadOnlyList<InternalPath>? internalPathRings;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Path"/> class.
@@ -131,7 +132,8 @@ SegmentInfo IPathInternals.PointAlongPath(float distance)
        => this.InnerPath.PointAlongPath(distance);
 
     /// <inheritdoc/>
-    IReadOnlyList<InternalPath> IInternalPathOwner.GetRingsAsInternalPath() => [this.InnerPath];
+    IReadOnlyList<InternalPath> IInternalPathOwner.GetRingsAsInternalPath()
+        => this.internalPathRings ??= [this.InnerPath];
 
     /// <summary>
     /// Converts an SVG path string into an <see cref="IPath"/>.