Merge pull request #1193 from SixLabors/af/extended-quantization

Efficient global quantization in GifEncoder

Author: JimBobSquarePants

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -112,7 +112,7 @@ private static void Seed<TPixel>()
         private static void AotCompileOctreeQuantizer<TPixel>()
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            using (var test = new OctreeFrameQuantizer<TPixel>(Configuration.Default, new OctreeQuantizer().Options))
+            using (var test = new OctreeQuantizer<TPixel>(Configuration.Default, new OctreeQuantizer().Options))
             {
                 var frame = new ImageFrame<TPixel>(Configuration.Default, 1, 1);
                 test.QuantizeFrame(frame, frame.Bounds());
@@ -126,7 +126,7 @@ private static void AotCompileOctreeQuantizer<TPixel>()
         private static void AotCompileWuQuantizer<TPixel>()
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            using (var test = new WuFrameQuantizer<TPixel>(Configuration.Default, new WuQuantizer().Options))
+            using (var test = new WuQuantizer<TPixel>(Configuration.Default, new WuQuantizer().Options))
             {
                 var frame = new ImageFrame<TPixel>(Configuration.Default, 1, 1);
                 test.QuantizeFrame(frame, frame.Bounds());
@@ -140,7 +140,7 @@ private static void AotCompileWuQuantizer<TPixel>()
         private static void AotCompilePaletteQuantizer<TPixel>()
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            using (var test = (PaletteFrameQuantizer<TPixel>)new PaletteQuantizer(Array.Empty<Color>()).CreateFrameQuantizer<TPixel>(Configuration.Default))
+            using (var test = (PaletteQuantizer<TPixel>)new PaletteQuantizer(Array.Empty<Color>()).CreatePixelSpecificQuantizer<TPixel>(Configuration.Default))
             {
                 var frame = new ImageFrame<TPixel>(Configuration.Default, 1, 1);
                 test.QuantizeFrame(frame, frame.Bounds());

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -336,8 +336,8 @@ private void Write8Bit<TPixel>(Stream stream, ImageFrame<TPixel> image)
         private void Write8BitColor<TPixel>(Stream stream, ImageFrame<TPixel> image, Span<byte> colorPalette)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            using IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration);
-            using IndexedImageFrame<TPixel> quantized = frameQuantizer.QuantizeFrame(image, image.Bounds());
+            using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration);
+            using IndexedImageFrame<TPixel> quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(image, image.Bounds());
 
             ReadOnlySpan<TPixel> quantizedColors = quantized.Palette.Span;
             var color = default(Rgba32);

src/ImageSharp/Formats/Gif/GifDecoderCore.cs

@@ -543,8 +543,8 @@ private void RestoreToBackground<TPixel>(ImageFrame<TPixel> frame)
                 return;
             }
 
-            BufferArea<TPixel> pixelArea = frame.PixelBuffer.GetArea(this.restoreArea.Value);
-            pixelArea.Clear();
+            BufferRegion<TPixel> pixelRegion = frame.PixelBuffer.GetRegion(this.restoreArea.Value);
+            pixelRegion.Clear();
 
             this.restoreArea = null;
         }

src/ImageSharp/Formats/Gif/GifEncoder.cs

@@ -25,6 +25,12 @@ public sealed class GifEncoder : IImageEncoder, IGifEncoderOptions
         /// </summary>
         public GifColorTableMode? ColorTableMode { get; set; }
 
+        /// <summary>
+        /// Gets or sets the <see cref="IPixelSamplingStrategy"/> used for quantization
+        /// when building a global color table in case of <see cref="GifColorTableMode.Global"/>.
+        /// </summary>
+        public IPixelSamplingStrategy GlobalPixelSamplingStrategy { get; set; } = new DefaultPixelSamplingStrategy();
+
         /// <inheritdoc/>
         public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             where TPixel : unmanaged, IPixel<TPixel>

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -49,6 +49,11 @@ internal sealed class GifEncoderCore
         /// </summary>
         private int bitDepth;
 
+        /// <summary>
+        /// The pixel sampling strategy for global quantization.
+        /// </summary>
+        private IPixelSamplingStrategy pixelSamplingStrategy;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="GifEncoderCore"/> class.
         /// </summary>
@@ -60,6 +65,7 @@ public GifEncoderCore(Configuration configuration, IGifEncoderOptions options)
             this.memoryAllocator = configuration.MemoryAllocator;
             this.quantizer = options.Quantizer;
             this.colorTableMode = options.ColorTableMode;
+            this.pixelSamplingStrategy = options.GlobalPixelSamplingStrategy;
         }
 
         /// <summary>
@@ -81,9 +87,18 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
 
             // Quantize the image returning a palette.
             IndexedImageFrame<TPixel> quantized;
-            using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration))
+
+            using (IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration))
             {
-                quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame, image.Bounds());
+                if (useGlobalTable)
+                {
+                    frameQuantizer.BuildPalette(this.pixelSamplingStrategy, image);
+                    quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame, image.Bounds());
+                }
+                else
+                {
+                    quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(image.Frames.RootFrame, image.Bounds());
+                }
             }
 
             // Get the number of bits.
@@ -154,7 +169,7 @@ private void EncodeGlobal<TPixel>(Image<TPixel> image, IndexedImageFrame<TPixel>
                         pixelMap = new EuclideanPixelMap<TPixel>(this.configuration, quantized.Palette);
                     }
 
-                    using var paletteFrameQuantizer = new PaletteFrameQuantizer<TPixel>(this.configuration, this.quantizer.Options, pixelMap);
+                    using var paletteFrameQuantizer = new PaletteQuantizer<TPixel>(this.configuration, this.quantizer.Options, pixelMap);
                     using IndexedImageFrame<TPixel> paletteQuantized = paletteFrameQuantizer.QuantizeFrame(frame, frame.Bounds());
                     this.WriteImageData(paletteQuantized, stream);
                 }
@@ -184,13 +199,13 @@ private void EncodeLocal<TPixel>(Image<TPixel> image, IndexedImageFrame<TPixel>
                             MaxColors = frameMetadata.ColorTableLength
                         };
 
-                        using IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration, options);
-                        quantized = frameQuantizer.QuantizeFrame(frame, frame.Bounds());
+                        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, options);
+                        quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(frame, frame.Bounds());
                     }
                     else
                     {
-                        using IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration);
-                        quantized = frameQuantizer.QuantizeFrame(frame, frame.Bounds());
+                        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration);
+                        quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(frame, frame.Bounds());
                     }
                 }
 

src/ImageSharp/Formats/Gif/IGifEncoderOptions.cs

@@ -1,6 +1,9 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System.Collections.Generic;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
 namespace SixLabors.ImageSharp.Formats.Gif
@@ -19,5 +22,10 @@ internal interface IGifEncoderOptions
         /// Gets the color table mode: Global or local.
         /// </summary>
         GifColorTableMode? ColorTableMode { get; }
+
+        /// <summary>
+        /// Gets the <see cref="IPixelSamplingStrategy"/> used for quantization when building a global color table.
+        /// </summary>
+        IPixelSamplingStrategy GlobalPixelSamplingStrategy { get; }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.ScaledCopyTo.cs

@@ -15,10 +15,10 @@ internal partial struct Block8x8F
         /// Copy block data into the destination color buffer pixel area with the provided horizontal and vertical scale factors.
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void ScaledCopyTo(in BufferArea<float> area, int horizontalScale, int verticalScale)
+        public void ScaledCopyTo(in BufferRegion<float> region, int horizontalScale, int verticalScale)
         {
-            ref float areaOrigin = ref area.GetReferenceToOrigin();
-            this.ScaledCopyTo(ref areaOrigin, area.Stride, horizontalScale, verticalScale);
+            ref float areaOrigin = ref region.GetReferenceToOrigin();
+            this.ScaledCopyTo(ref areaOrigin, region.Stride, horizontalScale, verticalScale);
         }
 
         [MethodImpl(InliningOptions.ShortMethod)]

src/ImageSharp/Formats/Png/PngEncoderOptionsHelpers.cs

@@ -77,10 +77,10 @@ public static IndexedImageFrame<TPixel> CreateQuantizedFrame<TPixel>(
             }
 
             // Create quantized frame returning the palette and set the bit depth.
-            using (IFrameQuantizer<TPixel> frameQuantizer = options.Quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()))
+            using (IQuantizer<TPixel> frameQuantizer = options.Quantizer.CreatePixelSpecificQuantizer<TPixel>(image.GetConfiguration()))
             {
                 ImageFrame<TPixel> frame = image.Frames.RootFrame;
-                return frameQuantizer.QuantizeFrame(frame, frame.Bounds());
+                return frameQuantizer.BuildPaletteAndQuantizeFrame(frame, frame.Bounds());
             }
         }
 

src/ImageSharp/Image{TPixel}.cs

@@ -48,6 +48,18 @@ public Image(Configuration configuration, int width, int height, TPixel backgrou
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Image{TPixel}"/> class
+        /// with the height and the width of the image.
+        /// </summary>
+        /// <param name="width">The width of the image in pixels.</param>
+        /// <param name="height">The height of the image in pixels.</param>
+        /// <param name="backgroundColor">The color to initialize the pixels with.</param>
+        public Image(int width, int height, TPixel backgroundColor)
+            : this(Configuration.Default, width, height, backgroundColor, new ImageMetadata())
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Image{TPixel}"/> class
         /// with the height and the width of the image.

src/ImageSharp/Memory/Buffer2DExtensions.cs

@@ -80,29 +80,29 @@ internal static Rectangle FullRectangle<T>(this Buffer2D<T> buffer)
         }
 
         /// <summary>
-        /// Return a <see cref="BufferArea{T}"/> to the subarea represented by 'rectangle'
+        /// Return a <see cref="BufferRegion{T}"/> to the subarea represented by 'rectangle'
         /// </summary>
         /// <typeparam name="T">The element type</typeparam>
         /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
         /// <param name="rectangle">The rectangle subarea</param>
-        /// <returns>The <see cref="BufferArea{T}"/></returns>
-        internal static BufferArea<T> GetArea<T>(this Buffer2D<T> buffer, in Rectangle rectangle)
-            where T : struct =>
-            new BufferArea<T>(buffer, rectangle);
+        /// <returns>The <see cref="BufferRegion{T}"/></returns>
+        internal static BufferRegion<T> GetRegion<T>(this Buffer2D<T> buffer, in Rectangle rectangle)
+            where T : unmanaged =>
+            new BufferRegion<T>(buffer, rectangle);
 
-        internal static BufferArea<T> GetArea<T>(this Buffer2D<T> buffer, int x, int y, int width, int height)
-            where T : struct =>
-            new BufferArea<T>(buffer, new Rectangle(x, y, width, height));
+        internal static BufferRegion<T> GetRegion<T>(this Buffer2D<T> buffer, int x, int y, int width, int height)
+            where T : unmanaged =>
+            new BufferRegion<T>(buffer, new Rectangle(x, y, width, height));
 
         /// <summary>
-        /// Return a <see cref="BufferArea{T}"/> to the whole area of 'buffer'
+        /// Return a <see cref="BufferRegion{T}"/> to the whole area of 'buffer'
         /// </summary>
         /// <typeparam name="T">The element type</typeparam>
         /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
-        /// <returns>The <see cref="BufferArea{T}"/></returns>
-        internal static BufferArea<T> GetArea<T>(this Buffer2D<T> buffer)
-            where T : struct =>
-            new BufferArea<T>(buffer);
+        /// <returns>The <see cref="BufferRegion{T}"/></returns>
+        internal static BufferRegion<T> GetRegion<T>(this Buffer2D<T> buffer)
+            where T : unmanaged =>
+            new BufferRegion<T>(buffer);
 
         /// <summary>
         /// Returns the size of the buffer.