Fix quantization and dithering.

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -82,6 +83,7 @@ private static void Seed<TPixel>()
             // This is we actually call all the individual methods you need to seed.
             AotCompileOctreeQuantizer<TPixel>();
             AotCompileWuQuantizer<TPixel>();
+            AotCompilePaletteQuantizer<TPixel>();
             AotCompileDithering<TPixel>();
             AotCompilePixelOperations<TPixel>();
 
@@ -109,7 +111,7 @@ private static void Seed<TPixel>()
         private static void AotCompileOctreeQuantizer<TPixel>()
             where TPixel : struct, IPixel<TPixel>
         {
-            using (var test = new OctreeFrameQuantizer<TPixel>(Configuration.Default, new OctreeQuantizer(false)))
+            using (var test = new OctreeFrameQuantizer<TPixel>(Configuration.Default, new OctreeQuantizer().Options))
             {
                 test.AotGetPalette();
             }
@@ -122,9 +124,25 @@ private static void AotCompileOctreeQuantizer<TPixel>()
         private static void AotCompileWuQuantizer<TPixel>()
             where TPixel : struct, IPixel<TPixel>
         {
-            using (var test = new WuFrameQuantizer<TPixel>(Configuration.Default, new WuQuantizer(false)))
+            using (var test = new WuFrameQuantizer<TPixel>(Configuration.Default, new WuQuantizer().Options))
             {
-                test.QuantizeFrame(new ImageFrame<TPixel>(Configuration.Default, 1, 1));
+                var frame = new ImageFrame<TPixel>(Configuration.Default, 1, 1);
+                test.QuantizeFrame(frame, frame.Bounds());
+                test.AotGetPalette();
+            }
+        }
+
+        /// <summary>
+        /// This method pre-seeds the PaletteQuantizer in the AoT compiler for iOS.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        private static void AotCompilePaletteQuantizer<TPixel>()
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (var test = (PaletteFrameQuantizer<TPixel>)new PaletteQuantizer(Array.Empty<Color>()).CreateFrameQuantizer<TPixel>(Configuration.Default))
+            {
+                var frame = new ImageFrame<TPixel>(Configuration.Default, 1, 1);
+                test.QuantizeFrame(frame, frame.Bounds());
                 test.AotGetPalette();
             }
         }
@@ -136,11 +154,11 @@ private static void AotCompileWuQuantizer<TPixel>()
         private static void AotCompileDithering<TPixel>()
             where TPixel : struct, IPixel<TPixel>
         {
-            var test = new FloydSteinbergDiffuser();
+            var test = new FloydSteinbergDither();
             TPixel pixel = default;
             using (var image = new ImageFrame<TPixel>(Configuration.Default, 1, 1))
             {
-                test.Dither(image, pixel, pixel, 0, 0, 0, 0, 0);
+                test.Dither(image, default, pixel, pixel, 0, 0, 0, 0);
             }
         }
 

src/ImageSharp/Color/Color.NamedColors.cs

@@ -8,6 +8,7 @@ namespace SixLabors.ImageSharp
 {
     /// <content>
     /// Contains static named color values.
+    /// <see href="https://www.w3.org/TR/css-color-3/"/>
     /// </content>
     public readonly partial struct Color
     {
@@ -719,9 +720,9 @@ public readonly partial struct Color
         public static readonly Color Tomato = FromRgba(255, 99, 71, 255);
 
         /// <summary>
-        /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFFFF.
+        /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00000000.
         /// </summary>
-        public static readonly Color Transparent = FromRgba(255, 255, 255, 0);
+        public static readonly Color Transparent = FromRgba(0, 0, 0, 0);
 
         /// <summary>
         /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #40E0D0.

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -11,6 +11,7 @@
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
 namespace SixLabors.ImageSharp.Formats.Bmp
@@ -87,7 +88,7 @@ public BmpEncoderCore(IBmpEncoderOptions options, MemoryAllocator memoryAllocato
             this.memoryAllocator = memoryAllocator;
             this.bitsPerPixel = options.BitsPerPixel;
             this.writeV4Header = options.SupportTransparency;
-            this.quantizer = options.Quantizer ?? new OctreeQuantizer(dither: true, maxColors: 256);
+            this.quantizer = options.Quantizer ?? KnownQuantizers.Octree;
         }
 
         /// <summary>
@@ -335,36 +336,36 @@ private void Write8Bit<TPixel>(Stream stream, ImageFrame<TPixel> image)
         private void Write8BitColor<TPixel>(Stream stream, ImageFrame<TPixel> image, Span<byte> colorPalette)
             where TPixel : struct, IPixel<TPixel>
         {
-            using (IQuantizedFrame<TPixel> quantized = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration, 256).QuantizeFrame(image))
+            using IFrameQuantizer<TPixel> quantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration);
+            using IQuantizedFrame<TPixel> quantized = quantizer.QuantizeFrame(image, image.Bounds());
+
+            ReadOnlySpan<TPixel> quantizedColors = quantized.Palette.Span;
+            var color = default(Rgba32);
+
+            // TODO: Use bulk conversion here for better perf
+            int idx = 0;
+            foreach (TPixel quantizedColor in quantizedColors)
             {
-                ReadOnlySpan<TPixel> quantizedColors = quantized.Palette.Span;
-                var color = default(Rgba32);
+                quantizedColor.ToRgba32(ref color);
+                colorPalette[idx] = color.B;
+                colorPalette[idx + 1] = color.G;
+                colorPalette[idx + 2] = color.R;
 
-                // TODO: Use bulk conversion here for better perf
-                int idx = 0;
-                foreach (TPixel quantizedColor in quantizedColors)
-                {
-                    quantizedColor.ToRgba32(ref color);
-                    colorPalette[idx] = color.B;
-                    colorPalette[idx + 1] = color.G;
-                    colorPalette[idx + 2] = color.R;
-
-                    // Padding byte, always 0.
-                    colorPalette[idx + 3] = 0;
-                    idx += 4;
-                }
+                // Padding byte, always 0.
+                colorPalette[idx + 3] = 0;
+                idx += 4;
+            }
+
+            stream.Write(colorPalette);
 
-                stream.Write(colorPalette);
+            for (int y = image.Height - 1; y >= 0; y--)
+            {
+                ReadOnlySpan<byte> pixelSpan = quantized.GetRowSpan(y);
+                stream.Write(pixelSpan);
 
-                for (int y = image.Height - 1; y >= 0; y--)
+                for (int i = 0; i < this.padding; i++)
                 {
-                    ReadOnlySpan<byte> pixelSpan = quantized.GetRowSpan(y);
-                    stream.Write(pixelSpan);
-
-                    for (int i = 0; i < this.padding; i++)
-                    {
-                        stream.WriteByte(0);
-                    }
+                    stream.WriteByte(0);
                 }
             }
         }

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -28,7 +28,7 @@ internal sealed class GifEncoderCore
         /// <summary>
         /// Configuration bound to the encoding operation.
         /// </summary>
-        private Configuration configuration;
+        private readonly Configuration configuration;
 
         /// <summary>
         /// A reusable buffer used to reduce allocations.
@@ -84,7 +84,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             IQuantizedFrame<TPixel> quantized;
             using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration))
             {
-                quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame);
+                quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame, image.Bounds());
             }
 
             // Get the number of bits.
@@ -144,13 +144,10 @@ private void EncodeGlobal<TPixel>(Image<TPixel> image, IQuantizedFrame<TPixel> q
                 }
                 else
                 {
-                    using (IFrameQuantizer<TPixel> paletteFrameQuantizer =
-                        new PaletteFrameQuantizer<TPixel>(this.configuration, this.quantizer.Diffuser, quantized.Palette))
+                    using (IFrameQuantizer<TPixel> paletteFrameQuantizer = new PaletteFrameQuantizer<TPixel>(this.configuration, this.quantizer.Options, quantized.Palette))
+                    using (IQuantizedFrame<TPixel> paletteQuantized = paletteFrameQuantizer.QuantizeFrame(frame, frame.Bounds()))
                     {
-                        using (IQuantizedFrame<TPixel> paletteQuantized = paletteFrameQuantizer.QuantizeFrame(frame))
-                        {
-                            this.WriteImageData(paletteQuantized, stream);
-                        }
+                        this.WriteImageData(paletteQuantized, stream);
                     }
                 }
             }
@@ -171,16 +168,23 @@ private void EncodeLocal<TPixel>(Image<TPixel> image, IQuantizedFrame<TPixel> qu
                     if (previousFrame != null && previousMeta.ColorTableLength != frameMetadata.ColorTableLength
                                               && frameMetadata.ColorTableLength > 0)
                     {
-                        using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration, frameMetadata.ColorTableLength))
+                        var options = new QuantizerOptions
+                        {
+                            Dither = this.quantizer.Options.Dither,
+                            DitherScale = this.quantizer.Options.DitherScale,
+                            MaxColors = frameMetadata.ColorTableLength
+                        };
+
+                        using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration, options))
                         {
-                            quantized = frameQuantizer.QuantizeFrame(frame);
+                            quantized = frameQuantizer.QuantizeFrame(frame, frame.Bounds());
                         }
                     }
                     else
                     {
                         using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration))
                         {
-                            quantized = frameQuantizer.QuantizeFrame(frame);
+                            quantized = frameQuantizer.QuantizeFrame(frame, frame.Bounds());
                         }
                     }
                 }

src/ImageSharp/Formats/Png/PngEncoderOptionsHelpers.cs

@@ -72,13 +72,15 @@ public static IQuantizedFrame<TPixel> CreateQuantizedFrame<TPixel>(
             // Use the metadata to determine what quantization depth to use if no quantizer has been set.
             if (options.Quantizer is null)
             {
-                options.Quantizer = new WuQuantizer(ImageMaths.GetColorCountForBitDepth(bits));
+                var maxColors = ImageMaths.GetColorCountForBitDepth(bits);
+                options.Quantizer = new WuQuantizer(new QuantizerOptions { MaxColors = maxColors });
             }
 
             // Create quantized frame returning the palette and set the bit depth.
             using (IFrameQuantizer<TPixel> frameQuantizer = options.Quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()))
             {
-                return frameQuantizer.QuantizeFrame(image.Frames.RootFrame);
+                ImageFrame<TPixel> frame = image.Frames.RootFrame;
+                return frameQuantizer.QuantizeFrame(frame, frame.Bounds());
             }
         }
 

src/ImageSharp/Processing/Extensions/Binarization/BinaryDitherExtensions.cs

@@ -1,7 +1,6 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
-using SixLabors.ImageSharp.Processing.Processors.Binarization;
 using SixLabors.ImageSharp.Processing.Processors.Dithering;
 
 namespace SixLabors.ImageSharp.Processing
@@ -19,8 +18,8 @@ public static class BinaryDitherExtensions
         /// <param name="dither">The ordered ditherer.</param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext
-            BinaryDither(this IImageProcessingContext source, IOrderedDither dither) =>
-            source.ApplyProcessor(new BinaryOrderedDitherProcessor(dither));
+            BinaryDither(this IImageProcessingContext source, IDither dither) =>
+            BinaryDither(source, dither, Color.White, Color.Black);
 
         /// <summary>
         /// Dithers the image reducing it to two colors using ordered dithering.
@@ -32,10 +31,10 @@ public static IImageProcessingContext
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext BinaryDither(
             this IImageProcessingContext source,
-            IOrderedDither dither,
+            IDither dither,
             Color upperColor,
             Color lowerColor) =>
-            source.ApplyProcessor(new BinaryOrderedDitherProcessor(dither, upperColor, lowerColor));
+            source.ApplyProcessor(new PaletteDitherProcessor(dither, new[] { upperColor, lowerColor }));
 
         /// <summary>
         /// Dithers the image reducing it to two colors using ordered dithering.
@@ -48,9 +47,9 @@ public static IImageProcessingContext BinaryDither(
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext BinaryDither(
             this IImageProcessingContext source,
-            IOrderedDither dither,
+            IDither dither,
             Rectangle rectangle) =>
-            source.ApplyProcessor(new BinaryOrderedDitherProcessor(dither), rectangle);
+            BinaryDither(source, dither, Color.White, Color.Black, rectangle);
 
         /// <summary>
         /// Dithers the image reducing it to two colors using ordered dithering.
@@ -65,10 +64,10 @@ public static IImageProcessingContext BinaryDither(
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext BinaryDither(
             this IImageProcessingContext source,
-            IOrderedDither dither,
+            IDither dither,
             Color upperColor,
             Color lowerColor,
             Rectangle rectangle) =>
-            source.ApplyProcessor(new BinaryOrderedDitherProcessor(dither, upperColor, lowerColor), rectangle);
+            source.ApplyProcessor(new PaletteDitherProcessor(dither, new[] { upperColor, lowerColor }), rectangle);
     }
-}
+}