Use more accuracy when calculating variance. Fix #866

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -95,8 +95,11 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             bool useGlobalTable = this.colorTableMode == GifColorTableMode.Global;
 
             // Quantize the image returning a palette.
-            QuantizedFrame<TPixel> quantized =
-                this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()).QuantizeFrame(image.Frames.RootFrame);
+            QuantizedFrame<TPixel> quantized = null;
+            using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()))
+            {
+                quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame);
+            }
 
             // Get the number of bits.
             this.bitDepth = ImageMaths.GetBitsNeededForColorDepth(quantized.Palette.Length).Clamp(1, 8);
@@ -133,7 +136,6 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
 
             // Clean up.
             quantized?.Dispose();
-            quantized = null;
 
             // TODO: Write extension etc
             stream.WriteByte(GifConstants.EndIntroducer);
@@ -158,7 +160,8 @@ private void EncodeGlobal<TPixel>(Image<TPixel> image, QuantizedFrame<TPixel> qu
                 }
                 else
                 {
-                    using (QuantizedFrame<TPixel> paletteQuantized = palleteQuantizer.CreateFrameQuantizer(image.GetConfiguration()).QuantizeFrame(frame))
+                    using (IFrameQuantizer<TPixel> palleteFrameQuantizer = palleteQuantizer.CreateFrameQuantizer(image.GetConfiguration()))
+                    using (QuantizedFrame<TPixel> paletteQuantized = palleteFrameQuantizer.QuantizeFrame(frame))
                     {
                         this.WriteImageData(paletteQuantized, stream);
                     }
@@ -181,14 +184,17 @@ private void EncodeLocal<TPixel>(Image<TPixel> image, QuantizedFrame<TPixel> qua
                     if (previousFrame != null && previousMeta.ColorTableLength != frameMetadata.ColorTableLength
                                               && frameMetadata.ColorTableLength > 0)
                     {
-                        quantized = this.quantizer.CreateFrameQuantizer<TPixel>(
-                            image.GetConfiguration(),
-                            frameMetadata.ColorTableLength).QuantizeFrame(frame);
+                        using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration(), frameMetadata.ColorTableLength))
+                        {
+                            quantized = frameQuantizer.QuantizeFrame(frame);
+                        }
                     }
                     else
                     {
-                        quantized = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration())
-                            .QuantizeFrame(frame);
+                        using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()))
+                        {
+                            quantized = frameQuantizer.QuantizeFrame(frame);
+                        }
                     }
                 }
 

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -243,8 +243,11 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
                 }
 
                 // Create quantized frame returning the palette and set the bit depth.
-                quantized = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration())
-                    .QuantizeFrame(image.Frames.RootFrame);
+                using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()))
+                {
+                    quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame);
+                }
+
                 byte quantizedBits = (byte)ImageMaths.GetBitsNeededForColorDepth(quantized.Palette.Length).Clamp(1, 8);
                 bits = Math.Max(bits, quantizedBits);
 

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

@@ -98,6 +98,11 @@ public virtual QuantizedFrame<TPixel> QuantizeFrame(ImageFrame<TPixel> image)
             return quantizedFrame;
         }
 
+        /// <inheritdoc/>
+        public virtual void Dispose()
+        {
+        }
+
         /// <summary>
         /// Execute the first pass through the pixels in the image to create the palette.
         /// </summary>

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

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors.Dithering;
 
@@ -10,7 +11,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     /// Provides methods to allow the execution of the quantization process on an image frame.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    public interface IFrameQuantizer<TPixel>
+    public interface IFrameQuantizer<TPixel> : IDisposable
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>

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

@@ -33,7 +33,7 @@ public QuantizeProcessor(IQuantizer quantizer)
         /// <inheritdoc />
         protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle sourceRectangle, Configuration configuration)
         {
-            IFrameQuantizer<TPixel> executor = this.Quantizer.CreateFrameQuantizer<TPixel>(configuration);
+            using (IFrameQuantizer<TPixel> executor = this.Quantizer.CreateFrameQuantizer<TPixel>(configuration))
             using (QuantizedFrame<TPixel> quantized = executor.QuantizeFrame(source))
             {
                 int paletteCount = quantized.Palette.Length - 1;