Merge branch 'master' into PorterDuffImprovement

Author: JimBobSquarePants

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -136,7 +136,7 @@ private static void AotCompileDithering<TPixel>()
             TPixel pixel = default;
             using (var image = new ImageFrame<TPixel>(Configuration.Default, 1, 1))
             {
-                test.Dither(image, pixel, pixel, 0, 0, 0, 0, 0, 0);
+                test.Dither(image, pixel, pixel, 0, 0, 0, 0, 0);
             }
         }
 

src/ImageSharp/Processing/Extensions/DiffuseExtensions.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;
@@ -95,4 +95,4 @@ public static IImageProcessingContext Diffuse(
             Rectangle rectangle) =>
             source.ApplyProcessor(new ErrorDiffusionPaletteProcessor(diffuser, threshold, palette), rectangle);
     }
-}
+}

src/ImageSharp/Processing/Processors/Binarization/BinaryErrorDiffusionProcessor{TPixel}.cs

@@ -14,7 +14,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization
     /// Performs binary threshold filtering against an image using error diffusion.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class BinaryErrorDiffusionProcessor<TPixel> : ImageProcessor<TPixel>
+    internal sealed class BinaryErrorDiffusionProcessor<TPixel> : ImageProcessor<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
         private readonly BinaryErrorDiffusionProcessor definition;
@@ -76,7 +76,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
                     }
 
                     TPixel transformedPixel = luminance >= threshold ? upperColor : lowerColor;
-                    diffuser.Dither(source, sourcePixel, transformedPixel, x, y, startX, startY, endX, endY);
+                    diffuser.Dither(source, sourcePixel, transformedPixel, x, y, startX, endX, endY);
                 }
             }
         }

src/ImageSharp/Processing/Processors/Dithering/AtkinsonDiffuser.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 SixLabors.ImageSharp.Primitives;
@@ -11,22 +11,24 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
     /// </summary>
     public sealed class AtkinsonDiffuser : ErrorDiffuser
     {
+        private const float Divisor = 8F;
+
         /// <summary>
         /// The diffusion matrix
         /// </summary>
         private static readonly DenseMatrix<float> AtkinsonMatrix =
             new float[,]
             {
-               { 0, 0, 1, 1 },
-               { 1, 1, 1, 0 },
-               { 0, 1, 0, 0 }
+               { 0, 0, 1 / Divisor, 1 / Divisor },
+               { 1 / Divisor, 1 / Divisor, 1 / Divisor, 0 },
+               { 0, 1 / Divisor, 0, 0 }
             };
 
         /// <summary>
         /// Initializes a new instance of the <see cref="AtkinsonDiffuser"/> class.
         /// </summary>
         public AtkinsonDiffuser()
-            : base(AtkinsonMatrix, 8)
+            : base(AtkinsonMatrix)
         {
         }
     }

src/ImageSharp/Processing/Processors/Dithering/BurksDiffuser.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 SixLabors.ImageSharp.Primitives;
@@ -11,22 +11,24 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
     /// </summary>
     public sealed class BurksDiffuser : ErrorDiffuser
     {
+        private const float Divisor = 32F;
+
         /// <summary>
         /// The diffusion matrix
         /// </summary>
         private static readonly DenseMatrix<float> BurksMatrix =
             new float[,]
             {
-                { 0, 0, 0, 8, 4 },
-                { 2, 4, 8, 4, 2 }
+                { 0, 0, 0, 8 / Divisor, 4 / Divisor },
+                { 2 / Divisor, 4 / Divisor, 8 / Divisor, 4 / Divisor, 2 / Divisor }
             };
 
         /// <summary>
         /// Initializes a new instance of the <see cref="BurksDiffuser"/> class.
         /// </summary>
         public BurksDiffuser()
-            : base(BurksMatrix, 32)
+            : base(BurksMatrix)
         {
         }
     }
-}
+}

src/ImageSharp/Processing/Processors/Dithering/ErrorDiffuser.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;
@@ -15,112 +15,80 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
     /// </summary>
     public abstract class ErrorDiffuser : IErrorDiffuser
     {
-        /// <summary>
-        /// The vector to perform division.
-        /// </summary>
-        private readonly Vector4 divisorVector;
-
-        /// <summary>
-        /// The matrix width.
-        /// </summary>
-        private readonly int matrixHeight;
-
-        /// <summary>
-        /// The matrix height.
-        /// </summary>
-        private readonly int matrixWidth;
-
-        /// <summary>
-        /// The offset at which to start the dithering operation.
-        /// </summary>
-        private readonly int startingOffset;
-
-        /// <summary>
-        /// The diffusion matrix.
-        /// </summary>
+        private readonly int offset;
         private readonly DenseMatrix<float> matrix;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ErrorDiffuser"/> class.
         /// </summary>
         /// <param name="matrix">The dithering matrix.</param>
-        /// <param name="divisor">The divisor.</param>
-        internal ErrorDiffuser(in DenseMatrix<float> matrix, byte divisor)
+        internal ErrorDiffuser(in DenseMatrix<float> matrix)
         {
-            Guard.MustBeGreaterThan(divisor, 0, nameof(divisor));
-
-            this.matrix = matrix;
-            this.matrixWidth = this.matrix.Columns;
-            this.matrixHeight = this.matrix.Rows;
-            this.divisorVector = new Vector4(divisor);
+            // Calculate the offset position of the pixel relative to
+            // the diffusion matrix.
+            this.offset = 0;
 
-            this.startingOffset = 0;
-            for (int i = 0; i < this.matrixWidth; i++)
+            for (int col = 0; col < matrix.Columns; col++)
             {
-                // Good to disable here as we are not comparing mathematical output.
-                // ReSharper disable once CompareOfFloatsByEqualityOperator
-                if (matrix[0, i] != 0)
+                if (matrix[0, col] != 0)
                 {
-                    this.startingOffset = (byte)(i - 1);
+                    this.offset = col - 1;
                     break;
                 }
             }
+
+            this.matrix = matrix;
         }
 
         /// <inheritdoc />
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel transformed, int x, int y, int minX, int minY, int maxX, int maxY)
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel transformed, int x, int y, int minX, int maxX, int maxY)
             where TPixel : struct, IPixel<TPixel>
         {
             image[x, y] = transformed;
 
-            // Equal? Break out as there's nothing to pass.
+            // Equal? Break out as there's no error to pass.
             if (source.Equals(transformed))
             {
                 return;
             }
 
             // Calculate the error
             Vector4 error = source.ToVector4() - transformed.ToVector4();
-            this.DoDither(image, x, y, minX, minY, maxX, maxY, error);
+            this.DoDither(image, x, y, minX, maxX, maxY, error);
         }
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private void DoDither<TPixel>(ImageFrame<TPixel> image, int x, int y, int minX, int minY, int maxX, int maxY, Vector4 error)
+        [MethodImpl(InliningOptions.ShortMethod)]
+        private void DoDither<TPixel>(ImageFrame<TPixel> image, int x, int y, int minX, int maxX, int maxY, Vector4 error)
             where TPixel : struct, IPixel<TPixel>
         {
+            int offset = this.offset;
+            DenseMatrix<float> matrix = this.matrix;
+
             // Loop through and distribute the error amongst neighboring pixels.
-            for (int row = 0; row < this.matrixHeight; row++)
+            for (int row = 0, targetY = y; row < matrix.Rows && targetY < maxY; row++, targetY++)
             {
-                int matrixY = y + row;
-                if (matrixY > minY && matrixY < maxY)
-                {
-                    Span<TPixel> rowSpan = image.GetPixelRowSpan(matrixY);
+                Span<TPixel> rowSpan = image.GetPixelRowSpan(targetY);
 
-                    for (int col = 0; col < this.matrixWidth; col++)
+                for (int col = 0; col < matrix.Columns; col++)
+                {
+                    int targetX = x + (col - offset);
+                    if (targetX >= minX && targetX < maxX)
                     {
-                        int matrixX = x + (col - this.startingOffset);
-
-                        if (matrixX > minX && matrixX < maxX)
+                        float coefficient = matrix[row, col];
+                        if (coefficient == 0)
                         {
-                            float coefficient = this.matrix[row, col];
-
-                            // Good to disable here as we are not comparing mathematical output.
-                            // ReSharper disable once CompareOfFloatsByEqualityOperator
-                            if (coefficient == 0)
-                            {
-                                continue;
-                            }
+                            continue;
+                        }
 
-                            ref TPixel pixel = ref rowSpan[matrixX];
-                            var offsetColor = pixel.ToVector4();
+                        ref TPixel pixel = ref rowSpan[targetX];
+                        var result = pixel.ToVector4();
 
-                            Vector4 result = ((error * coefficient) / this.divisorVector) + offsetColor;
-                            pixel.FromVector4(result);
-                        }
+                        result += error * coefficient;
+                        pixel.FromVector4(result);
                     }
                 }
             }
         }
     }
-}
+}

src/ImageSharp/Processing/Processors/Dithering/ErrorDiffusionPaletteProcessor{TPixel}.cs

@@ -13,7 +13,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
     /// An <see cref="IImageProcessor{TPixel}"/> that dithers an image using error diffusion.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class ErrorDiffusionPaletteProcessor<TPixel> : PaletteDitherProcessor<TPixel>
+    internal sealed class ErrorDiffusionPaletteProcessor<TPixel> : PaletteDitherProcessor<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>
@@ -33,8 +33,6 @@ public ErrorDiffusionPaletteProcessor(ErrorDiffusionPaletteProcessor definition,
         protected override void OnFrameApply(ImageFrame<TPixel> source)
         {
             byte threshold = (byte)MathF.Round(this.Definition.Threshold * 255F);
-            bool isAlphaOnly = typeof(TPixel) == typeof(Alpha8);
-
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
             int startY = interest.Y;
             int endY = interest.Bottom;
@@ -49,7 +47,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
             sourcePixel.ToRgba32(ref rgba);
 
             // Convert to grayscale using ITU-R Recommendation BT.709 if required
-            byte luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
+            byte luminance = ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
 
             for (int y = startY; y < endY; y++)
             {
@@ -72,14 +70,14 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
                         }
 
                         sourcePixel.ToRgba32(ref rgba);
-                        luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
+                        luminance = ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
 
                         // Setup the previous pointer
                         previousPixel = sourcePixel;
                     }
 
                     TPixel transformedPixel = luminance >= threshold ? pair.Second : pair.First;
-                    this.Definition.Diffuser.Dither(source, sourcePixel, transformedPixel, x, y, startX, startY, endX, endY);
+                    this.Definition.Diffuser.Dither(source, sourcePixel, transformedPixel, x, y, startX, endX, endY);
                 }
             }
         }

src/ImageSharp/Processing/Processors/Dithering/FloydSteinbergDiffuser.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 SixLabors.ImageSharp.Primitives;
@@ -11,22 +11,24 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
     /// </summary>
     public sealed class FloydSteinbergDiffuser : ErrorDiffuser
     {
+        private const float Divisor = 16F;
+
         /// <summary>
         /// The diffusion matrix
         /// </summary>
         private static readonly DenseMatrix<float> FloydSteinbergMatrix =
             new float[,]
             {
-                { 0, 0, 7 },
-                { 3, 5, 1 }
+                { 0, 0, 7 / Divisor },
+                { 3 / Divisor, 5 / Divisor, 1 / Divisor }
             };
 
         /// <summary>
         /// Initializes a new instance of the <see cref="FloydSteinbergDiffuser"/> class.
         /// </summary>
         public FloydSteinbergDiffuser()
-            : base(FloydSteinbergMatrix, 16)
+            : base(FloydSteinbergMatrix)
         {
         }
     }
-}
+}

src/ImageSharp/Processing/Processors/Dithering/IErrorDiffuser.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 SixLabors.ImageSharp.PixelFormats;
@@ -19,11 +19,10 @@ public interface IErrorDiffuser
         /// <param name="x">The column index.</param>
         /// <param name="y">The row index.</param>
         /// <param name="minX">The minimum column value.</param>
-        /// <param name="minY">The minimum row value.</param>
         /// <param name="maxX">The maximum column value.</param>
         /// <param name="maxY">The maximum row value.</param>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel transformed, int x, int y, int minX, int minY, int maxX, int maxY)
+        void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel transformed, int x, int y, int minX, int maxX, int maxY)
             where TPixel : struct, IPixel<TPixel>;
     }
-}
+}