Refactor and fix gif encoder

Author: JimBobSquarePants

src/ImageSharp/Color/Color.Conversions.cs

@@ -139,7 +139,7 @@ public Color(Vector4 vector)
     /// </summary>
     /// <param name="color">The <see cref="Color"/>.</param>
     /// <returns>The <see cref="Vector4"/>.</returns>
-    public static explicit operator Vector4(Color color) => color.ToVector4();
+    public static explicit operator Vector4(Color color) => color.ToScaledVector4();
 
     /// <summary>
     /// Converts an <see cref="Vector4"/> to <see cref="Color"/>.
@@ -228,7 +228,7 @@ internal Bgr24 ToBgr24()
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    internal Vector4 ToVector4()
+    internal Vector4 ToScaledVector4()
     {
         if (this.boxedHighPrecisionPixel is null)
         {

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -21,6 +21,16 @@ public sealed class ImageFrame<TPixel> : ImageFrame, IPixelSource<TPixel>
 {
     private bool isDisposed;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ImageFrame{TPixel}" /> class.
+    /// </summary>
+    /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
+    /// <param name="size">The <see cref="Size"/> of the frame.</param>
+    internal ImageFrame(Configuration configuration, Size size)
+        : this(configuration, size.Width, size.Height, new ImageFrameMetadata())
+    {
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ImageFrame{TPixel}" /> class.
     /// </summary>

src/ImageSharp/ImageFrame{TPixel}.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Memory;
@@ -14,13 +15,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 /// </summary>
 /// <typeparam name="TPixel">The pixel format.</typeparam>
 /// <para>
-/// This class is not threadsafe and should not be accessed in parallel.
+/// This class is not thread safe and should not be accessed in parallel.
 /// Doing so will result in non-idempotent results.
 /// </para>
 internal sealed class EuclideanPixelMap<TPixel> : IDisposable
     where TPixel : unmanaged, IPixel<TPixel>
 {
     private Rgba32[] rgbaPalette;
+    private int transparentIndex;
 
     /// <summary>
     /// Do not make this readonly! Struct value would be always copied on non-readonly method calls.
@@ -34,12 +36,24 @@ internal sealed class EuclideanPixelMap<TPixel> : IDisposable
     /// <param name="configuration">The configuration.</param>
     /// <param name="palette">The color palette to map from.</param>
     public EuclideanPixelMap(Configuration configuration, ReadOnlyMemory<TPixel> palette)
+        : this(configuration, palette, -1)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="EuclideanPixelMap{TPixel}"/> class.
+    /// </summary>
+    /// <param name="configuration">The configuration.</param>
+    /// <param name="palette">The color palette to map from.</param>
+    /// <param name="transparentIndex">An explicit index at which to match transparent pixels.</param>
+    public EuclideanPixelMap(Configuration configuration, ReadOnlyMemory<TPixel> palette, int transparentIndex = -1)
     {
         this.configuration = configuration;
         this.Palette = palette;
         this.rgbaPalette = new Rgba32[palette.Length];
         this.cache = new ColorDistanceCache(configuration.MemoryAllocator);
         PixelOperations<TPixel>.Instance.ToRgba32(configuration, this.Palette.Span, this.rgbaPalette);
+        this.transparentIndex = transparentIndex;
     }
 
     /// <summary>
@@ -91,16 +105,43 @@ public void Clear(ReadOnlyMemory<TPixel> palette)
         this.cache.Clear();
     }
 
+    /// <summary>
+    /// Allows setting the transparent index after construction.
+    /// </summary>
+    /// <param name="index">An explicit index at which to match transparent pixels.</param>
+    public void SetTransparentIndex(int index) => this.transparentIndex = index;
+
     [MethodImpl(InliningOptions.ShortMethod)]
     private int GetClosestColorSlow(Rgba32 rgba, ref TPixel paletteRef, out TPixel match)
     {
         // Loop through the palette and find the nearest match.
         int index = 0;
         float leastDistance = float.MaxValue;
+
+        if (this.transparentIndex >= 0 && rgba == default)
+        {
+            // We have explicit instructions. No need to search.
+            index = this.transparentIndex;
+            this.cache.Add(rgba, (byte)index);
+
+            if (index >= 0 && index < this.Palette.Length)
+            {
+                match = Unsafe.Add(ref paletteRef, (uint)index);
+            }
+            else
+            {
+                Unsafe.SkipInit(out TPixel pixel);
+                pixel.FromScaledVector4(Vector4.Zero);
+                match = pixel;
+            }
+
+            return index;
+        }
+
         for (int i = 0; i < this.rgbaPalette.Length; i++)
         {
             Rgba32 candidate = this.rgbaPalette[i];
-            int distance = DistanceSquared(rgba, candidate);
+            float distance = DistanceSquared(rgba, candidate);
 
             // If it's an exact match, exit the loop
             if (distance == 0)
@@ -130,12 +171,12 @@ private int GetClosestColorSlow(Rgba32 rgba, ref TPixel paletteRef, out TPixel m
     /// <param name="b">The second point.</param>
     /// <returns>The distance squared.</returns>
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static int DistanceSquared(Rgba32 a, Rgba32 b)
+    private static float DistanceSquared(Rgba32 a, Rgba32 b)
     {
-        int deltaR = a.R - b.R;
-        int deltaG = a.G - b.G;
-        int deltaB = a.B - b.B;
-        int deltaA = a.A - b.A;
+        float deltaR = a.R - b.R;
+        float deltaG = a.G - b.G;
+        float deltaB = a.B - b.B;
+        float deltaA = a.A - b.A;
         return (deltaR * deltaR) + (deltaG * deltaG) + (deltaB * deltaB) + (deltaA * deltaA);
     }
 

src/ImageSharp/Processing/Processors/Quantization/EuclideanPixelMap{TPixel}.cs

@@ -11,6 +11,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 public class PaletteQuantizer : IQuantizer
 {
     private readonly ReadOnlyMemory<Color> colorPalette;
+    private readonly int transparentIndex;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PaletteQuantizer"/> class.
@@ -27,12 +28,24 @@ public PaletteQuantizer(ReadOnlyMemory<Color> palette)
     /// <param name="palette">The color palette.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     public PaletteQuantizer(ReadOnlyMemory<Color> palette, QuantizerOptions options)
+        : this(palette, options, -1)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PaletteQuantizer"/> class.
+    /// </summary>
+    /// <param name="palette">The color palette.</param>
+    /// <param name="options">The quantizer options defining quantization rules.</param>
+    /// <param name="transparentIndex">An explicit index at which to match transparent pixels.</param>
+    internal PaletteQuantizer(ReadOnlyMemory<Color> palette, QuantizerOptions options, int transparentIndex)
     {
         Guard.MustBeGreaterThan(palette.Length, 0, nameof(palette));
         Guard.NotNull(options, nameof(options));
 
         this.colorPalette = palette;
         this.Options = options;
+        this.transparentIndex = transparentIndex;
     }
 
     /// <inheritdoc />
@@ -52,6 +65,6 @@ public IQuantizer<TPixel> CreatePixelSpecificQuantizer<TPixel>(Configuration con
         // Always use the palette length over options since the palette cannot be reduced.
         TPixel[] palette = new TPixel[this.colorPalette.Length];
         Color.ToPixel(this.colorPalette.Span, palette.AsSpan());
-        return new PaletteQuantizer<TPixel>(configuration, options, palette);
+        return new PaletteQuantizer<TPixel>(configuration, options, palette, this.transparentIndex);
     }
 }

src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs

@@ -25,18 +25,23 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
     /// <summary>
     /// Initializes a new instance of the <see cref="PaletteQuantizer{TPixel}"/> struct.
     /// </summary>
-    /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
+    /// <param name="configuration">The configuration which allows altering default behavior or extending the library.</param>
     /// <param name="options">The quantizer options defining quantization rules.</param>
     /// <param name="palette">The palette to use.</param>
+    /// <param name="transparentIndex">An explicit index at which to match transparent pixels.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public PaletteQuantizer(Configuration configuration, QuantizerOptions options, ReadOnlyMemory<TPixel> palette)
+    public PaletteQuantizer(
+        Configuration configuration,
+        QuantizerOptions options,
+        ReadOnlyMemory<TPixel> palette,
+        int transparentIndex)
     {
         Guard.NotNull(configuration, nameof(configuration));
         Guard.NotNull(options, nameof(options));
 
         this.Configuration = configuration;
         this.Options = options;
-        this.pixelMap = new EuclideanPixelMap<TPixel>(configuration, palette);
+        this.pixelMap = new EuclideanPixelMap<TPixel>(configuration, palette, transparentIndex);
     }
 
     /// <inheritdoc/>
@@ -59,6 +64,12 @@ public void AddPaletteColors(Buffer2DRegion<TPixel> pixelRegion)
     {
     }
 
+    /// <summary>
+    /// Allows setting the transparent index after construction.
+    /// </summary>
+    /// <param name="index">An explicit index at which to match transparent pixels.</param>
+    public void SetTransparentIndex(int index) => this.pixelMap.SetTransparentIndex(index);
+
     /// <inheritdoc/>
     [MethodImpl(InliningOptions.ShortMethod)]
     public readonly byte GetQuantizedColor(TPixel color, out TPixel match)

src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs

@@ -38,7 +38,7 @@ public GifEncoderTests()
 
     [Theory]
     [WithTestPatternImages(100, 100, TestPixelTypes, false)]
-    [WithTestPatternImages(100, 100, TestPixelTypes, false)]
+    [WithTestPatternImages(100, 100, TestPixelTypes, true)]
     public void EncodeGeneratedPatterns<TPixel>(TestImageProvider<TPixel> provider, bool limitAllocationBuffer)
         where TPixel : unmanaged, IPixel<TPixel>
     {