Expose final internals to allow decoupling Drawing.

src/ImageSharp.Drawing/Common/Extensions/GraphicsOptionsExtensions.cs

@@ -0,0 +1,53 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp
+{
+    /// <summary>
+    /// Extensions methods fpor the <see cref="GraphicsOptions"/> class.
+    /// </summary>
+    internal static class GraphicsOptionsExtensions
+    {
+        /// <summary>
+        /// Evaluates if a given SOURCE color can completely replace a BACKDROP color given the current blending and composition settings.
+        /// </summary>
+        /// <param name="options">The graphics options.</param>
+        /// <param name="color">The source color.</param>
+        /// <returns>true if the color can be considered opaque</returns>
+        /// <remarks>
+        /// Blending and composition is an expensive operation, in some cases, like
+        /// filling with a solid color, the blending can be avoided by a plain color replacement.
+        /// This method can be useful for such processors to select the fast path.
+        /// </remarks>
+        public static bool IsOpaqueColorWithoutBlending(this GraphicsOptions options, Color color)
+        {
+            if (options.ColorBlendingMode != PixelColorBlendingMode.Normal)
+            {
+                return false;
+            }
+
+            if (options.AlphaCompositionMode != PixelAlphaCompositionMode.SrcOver
+                && options.AlphaCompositionMode != PixelAlphaCompositionMode.Src)
+            {
+                return false;
+            }
+
+            const float Opaque = 1F;
+
+            if (options.BlendPercentage != Opaque)
+            {
+                return false;
+            }
+
+            if (((Vector4)color).W != Opaque)
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

src/ImageSharp.Drawing/Primitives/ShapeRegion.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -49,7 +49,7 @@ public override int Scan(float y, Span<float> buffer, Configuration configuratio
 
             using (IMemoryOwner<PointF> tempBuffer = configuration.MemoryAllocator.Allocate<PointF>(buffer.Length))
             {
-                Span<PointF> innerBuffer = tempBuffer.GetSpan();
+                Span<PointF> innerBuffer = tempBuffer.Memory.Span;
                 int count = this.Shape.FindIntersections(start, end, innerBuffer);
 
                 for (int i = 0; i < count; i++)
@@ -61,4 +61,4 @@ public override int Scan(float y, Span<float> buffer, Configuration configuratio
             }
         }
     }
-}
+}

src/ImageSharp.Drawing/Processing/BrushApplicator.cs

@@ -1,68 +1,85 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
 using System.Buffers;
-
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.Memory;
 
 namespace SixLabors.ImageSharp.Processing
 {
     /// <summary>
-    /// primitive that converts a point in to a color for discovering the fill color based on an implementation
+    /// A primitive that converts a point into a color for discovering the fill color based on an implementation.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    /// <seealso cref="System.IDisposable" />
-    public abstract class BrushApplicator<TPixel> : IDisposable // disposable will be required if/when there is an ImageBrush
+    /// <seealso cref="IDisposable" />
+    public abstract class BrushApplicator<TPixel> : IDisposable
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="BrushApplicator{TPixel}"/> class.
         /// </summary>
+        /// <param name="configuration">The configuration instance to use when performing operations.</param>
         /// <param name="target">The target.</param>
         /// <param name="options">The options.</param>
-        internal BrushApplicator(ImageFrame<TPixel> target, GraphicsOptions options)
+        internal BrushApplicator(Configuration configuration, ImageFrame<TPixel> target, GraphicsOptions options)
         {
+            this.Configuration = configuration;
             this.Target = target;
             this.Options = options;
             this.Blender = PixelOperations<TPixel>.Instance.GetPixelBlender(options);
         }
 
         /// <summary>
-        /// Gets the blender
+        /// Gets the configuration instance to use when performing operations.
+        /// </summary>
+        protected Configuration Configuration { get; }
+
+        /// <summary>
+        /// Gets the pixel blender.
         /// </summary>
         internal PixelBlender<TPixel> Blender { get; }
 
         /// <summary>
-        /// Gets the destination
+        /// Gets the target image.
         /// </summary>
         protected ImageFrame<TPixel> Target { get; }
 
         /// <summary>
-        /// Gets the blend percentage
+        /// Gets thegraphics options
         /// </summary>
         protected GraphicsOptions Options { get; }
 
         /// <summary>
-        /// Gets the color for a single pixel.
+        /// Gets the overlay pixel at the specified position.
         /// </summary>
-        /// <param name="x">The x coordinate.</param>
-        /// <param name="y">The y coordinate.</param>
-        /// <returns>The a <typeparamref name="TPixel"/> that should be applied to the pixel.</returns>
+        /// <param name="x">The x-coordinate.</param>
+        /// <param name="y">The y-coordinate.</param>
+        /// <returns>The <see typeparam="TPixel"/> at the specified position.</returns>
         internal abstract TPixel this[int x, int y] { get; }
 
         /// <inheritdoc/>
-        public abstract void Dispose();
+        public void Dispose()
+        {
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Disposes the object and frees resources for the Garbage Collector.
+        /// </summary>
+        /// <param name="disposing">Whether to dispose managed and unmanaged objects.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+        }
 
         /// <summary>
         /// Applies the opacity weighting for each pixel in a scanline to the target based on the pattern contained in the brush.
         /// </summary>
-        /// <param name="scanline">The a collection of opacity values between 0 and 1 to be merged with the brushed color value before being applied to the target.</param>
-        /// <param name="x">The x position in the target pixel space that the start of the scanline data corresponds to.</param>
-        /// <param name="y">The y position in  the target pixel space that whole scanline corresponds to.</param>
+        /// <param name="scanline">A collection of opacity values between 0 and 1 to be merged with the brushed color value before being applied to the target.</param>
+        /// <param name="x">The x-position in the target pixel space that the start of the scanline data corresponds to.</param>
+        /// <param name="y">The y-position in  the target pixel space that whole scanline corresponds to.</param>
         /// <remarks>scanlineBuffer will be > scanlineWidth but provide and offset in case we want to share a larger buffer across runs.</remarks>
         internal virtual void Apply(Span<float> scanline, int x, int y)
         {
@@ -71,8 +88,8 @@ internal virtual void Apply(Span<float> scanline, int x, int y)
             using (IMemoryOwner<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))
             using (IMemoryOwner<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length))
             {
-                Span<float> amountSpan = amountBuffer.GetSpan();
-                Span<TPixel> overlaySpan = overlay.GetSpan();
+                Span<float> amountSpan = amountBuffer.Memory.Span;
+                Span<TPixel> overlaySpan = overlay.Memory.Span;
 
                 for (int i = 0; i < scanline.Length; i++)
                 {
@@ -89,7 +106,7 @@ internal virtual void Apply(Span<float> scanline, int x, int y)
                 }
 
                 Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                this.Blender.Blend(this.Target.Configuration, destinationRow, destinationRow, overlaySpan, amountSpan);
+                this.Blender.Blend(this.Configuration, destinationRow, destinationRow, overlaySpan, amountSpan);
             }
         }
     }

src/ImageSharp.Drawing/Processing/EllipticGradientBrush.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -47,17 +47,19 @@ public EllipticGradientBrush(
 
         /// <inheritdoc />
         public override BrushApplicator<TPixel> CreateApplicator<TPixel>(
+            Configuration configuration,
             ImageFrame<TPixel> source,
             RectangleF region,
             GraphicsOptions options) =>
             new RadialGradientBrushApplicator<TPixel>(
+                configuration,
                 source,
-                options,
                 this.center,
                 this.referenceAxisEnd,
                 this.axisRatio,
                 this.ColorStops,
-                this.RepetitionMode);
+                this.RepetitionMode,
+                options);
 
         /// <inheritdoc />
         private sealed class RadialGradientBrushApplicator<TPixel> : GradientBrushApplicator<TPixel>
@@ -86,24 +88,26 @@ private sealed class RadialGradientBrushApplicator<TPixel> : GradientBrushApplic
             /// <summary>
             /// Initializes a new instance of the <see cref="RadialGradientBrushApplicator{TPixel}" /> class.
             /// </summary>
-            /// <param name="target">The target image</param>
-            /// <param name="options">The options</param>
-            /// <param name="center">Center of the ellipse</param>
+            /// <param name="configuration">The configuration instance to use when performing operations.</param>
+            /// <param name="target">The target image.</param>
+            /// <param name="center">Center of the ellipse.</param>
             /// <param name="referenceAxisEnd">Point on one angular points of the ellipse.</param>
             /// <param name="axisRatio">
             /// Ratio of the axis length's. Used to determine the length of the second axis,
             /// the first is defined by <see cref="center"/> and <see cref="referenceAxisEnd"/>.</param>
-            /// <param name="colorStops">Definition of colors</param>
+            /// <param name="colorStops">Definition of colors.</param>
             /// <param name="repetitionMode">Defines how the gradient colors are repeated.</param>
+            /// <param name="options">The graphics options.</param>
             public RadialGradientBrushApplicator(
+                Configuration configuration,
                 ImageFrame<TPixel> target,
-                GraphicsOptions options,
                 PointF center,
                 PointF referenceAxisEnd,
                 float axisRatio,
                 ColorStop[] colorStops,
-                GradientRepetitionMode repetitionMode)
-                : base(target, options, colorStops, repetitionMode)
+                GradientRepetitionMode repetitionMode,
+                GraphicsOptions options)
+                : base(configuration, target, colorStops, repetitionMode, options)
             {
                 this.center = center;
                 this.referenceAxisEnd = referenceAxisEnd;
@@ -122,11 +126,6 @@ public RadialGradientBrushApplicator(
                 this.cosRotation = (float)Math.Cos(this.rotation);
             }
 
-            /// <inheritdoc />
-            public override void Dispose()
-            {
-            }
-
             /// <inheritdoc />
             protected override float PositionOnGradient(float xt, float yt)
             {
@@ -139,23 +138,21 @@ protected override float PositionOnGradient(float xt, float yt)
                 float xSquared = x * x;
                 float ySquared = y * y;
 
-                var inBoundaryChecker = (xSquared / this.referenceRadiusSquared)
-                                        + (ySquared / this.secondRadiusSquared);
-
-                return inBoundaryChecker;
+                return (xSquared / this.referenceRadiusSquared) + (ySquared / this.secondRadiusSquared);
             }
 
             private float AngleBetween(PointF junction, PointF a, PointF b)
             {
-                var vA = a - junction;
-                var vB = b - junction;
+                PointF vA = a - junction;
+                PointF vB = b - junction;
                 return MathF.Atan2(vB.Y, vB.X) - MathF.Atan2(vA.Y, vA.X);
             }
 
             private float DistanceBetween(
                 PointF p1,
                 PointF p2)
             {
+                // TODO: Can we not just use Vector2 distance here?
                 float dX = p1.X - p2.X;
                 float dXsquared = dX * dX;
 
@@ -165,4 +162,4 @@ private float DistanceBetween(
             }
         }
     }
-}
+}