Rename quantizer and update tests

Author: JimBobSquarePants

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -54,7 +54,7 @@ internal static class AotCompilerTools
     /// <remarks>
     /// This method doesn't actually do anything but serves an important purpose...
     /// If you are running ImageSharp on iOS and try to call SaveAsGif, it will throw an exception:
-    /// "Attempting to JIT compile method... OctreeFrameQuantizer.ConstructPalette... while running in aot-only mode."
+    /// "Attempting to JIT compile method... HexadecatreeQuantizer.ConstructPalette... while running in aot-only mode."
     /// The reason this happens is the SaveAsGif method makes heavy use of generics, which are too confusing for the AoT
     /// compiler used on Xamarin.iOS. It spins up the JIT compiler to try and figure it out, but that is an illegal op on
     /// iOS so it bombs out.
@@ -479,7 +479,7 @@ private static void AotCompileResampler<TPixel, TResampler>()
     private static void AotCompileQuantizers<TPixel>()
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        AotCompileQuantizer<TPixel, OctreeQuantizer>();
+        AotCompileQuantizer<TPixel, HexadecatreeQuantizer>();
         AotCompileQuantizer<TPixel, PaletteQuantizer>();
         AotCompileQuantizer<TPixel, WebSafePaletteQuantizer>();
         AotCompileQuantizer<TPixel, WernerPaletteQuantizer>();
@@ -549,8 +549,8 @@ private static void AotCompileDither<TPixel, TDither>()
         where TPixel : unmanaged, IPixel<TPixel>
         where TDither : struct, IDither
     {
-        OctreeQuantizer<TPixel> octree = default;
-        default(TDither).ApplyQuantizationDither<OctreeQuantizer<TPixel>, TPixel>(ref octree, default, default, default);
+        HexadecatreeQuantizer<TPixel> hexadecatree = default;
+        default(TDither).ApplyQuantizationDither<HexadecatreeQuantizer<TPixel>, TPixel>(ref hexadecatree, default, default, default);
 
         PaletteQuantizer<TPixel> palette = default;
         default(TDither).ApplyQuantizationDither<PaletteQuantizer<TPixel>, TPixel>(ref palette, default, default, default);

src/ImageSharp/Formats/Bmp/BmpEncoder.cs

@@ -13,7 +13,7 @@ public sealed class BmpEncoder : QuantizingImageEncoder
     /// <summary>
     /// Initializes a new instance of the <see cref="BmpEncoder"/> class.
     /// </summary>
-    public BmpEncoder() => this.Quantizer = KnownQuantizers.Octree;
+    public BmpEncoder() => this.Quantizer = KnownQuantizers.Hexadecatree;
 
     /// <summary>
     /// Gets the number of bits per pixel.

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -116,7 +116,7 @@ public BmpEncoderCore(BmpEncoder encoder, MemoryAllocator memoryAllocator)
         this.bitsPerPixel = encoder.BitsPerPixel;
 
         // TODO: Use a palette quantizer if supplied.
-        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Octree;
+        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Hexadecatree;
         this.pixelSamplingStrategy = encoder.PixelSamplingStrategy;
         this.transparentColorMode = encoder.TransparentColorMode;
         this.infoHeaderType = encoder.SupportTransparency ? BmpInfoHeaderType.WinVersion4 : BmpInfoHeaderType.WinVersion3;

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -117,7 +117,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
 
         if (globalQuantizer is null)
         {
-            // Is this a gif with color information. If so use that, otherwise use octree.
+            // Is this a gif with color information. If so use that, otherwise use the adaptive hexadecatree quantizer.
             if (gifMetadata.ColorTableMode == FrameColorTableMode.Global && gifMetadata.GlobalColorTable?.Length > 0)
             {
                 int ti = GetTransparentIndex(quantized, frameMetadata);
@@ -132,12 +132,12 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
                 }
                 else
                 {
-                    globalQuantizer = new OctreeQuantizer(options);
+                    globalQuantizer = new HexadecatreeQuantizer(options);
                 }
             }
             else
             {
-                globalQuantizer = new OctreeQuantizer(options);
+                globalQuantizer = new HexadecatreeQuantizer(options);
             }
         }
 

src/ImageSharp/Formats/Tiff/TiffEncoder.cs

@@ -15,7 +15,7 @@ public class TiffEncoder : QuantizingImageEncoder
     /// <summary>
     /// Initializes a new instance of the <see cref="TiffEncoder"/> class.
     /// </summary>
-    public TiffEncoder() => this.Quantizer = KnownQuantizers.Octree;
+    public TiffEncoder() => this.Quantizer = KnownQuantizers.Hexadecatree;
 
     /// <summary>
     /// Gets the number of bits per pixel.

src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs

@@ -71,7 +71,7 @@ public TiffEncoderCore(TiffEncoder encoder, Configuration configuration)
         this.configuration = configuration;
         this.memoryAllocator = configuration.MemoryAllocator;
         this.PhotometricInterpretation = encoder.PhotometricInterpretation;
-        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Octree;
+        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Hexadecatree;
         this.pixelSamplingStrategy = encoder.PixelSamplingStrategy;
         this.BitsPerPixel = encoder.BitsPerPixel;
         this.HorizontalPredictor = encoder.HorizontalPredictor;

src/ImageSharp/Processing/Extensions/Quantization/QuantizeExtensions.cs

@@ -12,12 +12,12 @@ namespace SixLabors.ImageSharp.Processing;
 public static class QuantizeExtensions
 {
     /// <summary>
-    /// Applies quantization to the image using the <see cref="OctreeQuantizer"/>.
+    /// Applies quantization to the image using the <see cref="HexadecatreeQuantizer"/>.
     /// </summary>
     /// <param name="source">The current image processing context.</param>
     /// <returns>The <see cref="IImageProcessingContext"/>.</returns>
     public static IImageProcessingContext Quantize(this IImageProcessingContext source) =>
-        Quantize(source, KnownQuantizers.Octree);
+        Quantize(source, KnownQuantizers.Hexadecatree);
 
     /// <summary>
     /// Applies quantization to the image.
@@ -29,15 +29,15 @@ public static IImageProcessingContext Quantize(this IImageProcessingContext sour
         source.ApplyProcessor(new QuantizeProcessor(quantizer));
 
     /// <summary>
-    /// Applies quantization to the image using the <see cref="OctreeQuantizer"/>.
+    /// Applies quantization to the image using the <see cref="HexadecatreeQuantizer"/>.
     /// </summary>
     /// <param name="source">The current image processing context.</param>
     /// <param name="rectangle">
     /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
     /// </param>
     /// <returns>The <see cref="IImageProcessingContext"/>.</returns>
     public static IImageProcessingContext Quantize(this IImageProcessingContext source, Rectangle rectangle) =>
-        Quantize(source, KnownQuantizers.Octree, rectangle);
+        Quantize(source, KnownQuantizers.Hexadecatree, rectangle);
 
     /// <summary>
     /// Applies quantization to the image.

src/ImageSharp/Processing/KnownQuantizers.cs

@@ -1,19 +1,19 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
 namespace SixLabors.ImageSharp.Processing;
 
 /// <summary>
-/// Contains reusable static instances of known quantizing algorithms
+/// Contains reusable static instances of known quantizing algorithms.
 /// </summary>
 public static class KnownQuantizers
 {
     /// <summary>
-    /// Gets the adaptive Octree quantizer. Fast with good quality.
+    /// Gets the adaptive hexadecatree quantizer. Fast with good quality.
     /// </summary>
-    public static IQuantizer Octree { get; } = new OctreeQuantizer();
+    public static IQuantizer Hexadecatree { get; } = new HexadecatreeQuantizer();
 
     /// <summary>
     /// Gets the Xiaolin Wu's Color Quantizer which generates high quality output.

…ocessors/Quantization/OctreeQuantizer.cs …rs/Quantization/HexadecatreeQuantizer.cssrc/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs renamed to src/ImageSharp/Processing/Processors/Quantization/HexadecatreeQuantizer.cs src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs renamed to src/ImageSharp/Processing/Processors/Quantization/HexadecatreeQuantizer.cs

@@ -6,25 +6,29 @@
 namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
 
 /// <summary>
-/// Allows the quantization of images pixels using Octrees.
-/// <see href="http://msdn.microsoft.com/en-us/library/aa479306.aspx"/>
+/// Quantizes images by grouping colors in an adaptive 16-way tree and reducing those groups into a palette.
 /// </summary>
-public class OctreeQuantizer : IQuantizer
+/// <remarks>
+/// Each level routes colors using one bit of RGB and, when useful, one bit of alpha. Fully opaque mid-tone colors
+/// use RGB-only routing so more branch resolution is spent on visible color detail, while transparent, dark, and
+/// light colors use alpha-aware routing so opacity changes can form their own palette buckets.
+/// </remarks>
+public class HexadecatreeQuantizer : IQuantizer
 {
     /// <summary>
-    /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class
+    /// Initializes a new instance of the <see cref="HexadecatreeQuantizer"/> class
     /// using the default <see cref="QuantizerOptions"/>.
     /// </summary>
-    public OctreeQuantizer()
+    public HexadecatreeQuantizer()
         : this(new QuantizerOptions())
     {
     }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class.
+    /// Initializes a new instance of the <see cref="HexadecatreeQuantizer"/> class.
     /// </summary>
-    /// <param name="options">The quantizer options defining quantization rules.</param>
-    public OctreeQuantizer(QuantizerOptions options)
+    /// <param name="options">The quantizer options that control palette size, dithering, and transparency behavior.</param>
+    public HexadecatreeQuantizer(QuantizerOptions options)
     {
         Guard.NotNull(options, nameof(options));
         this.Options = options;
@@ -41,5 +45,5 @@ public IQuantizer<TPixel> CreatePixelSpecificQuantizer<TPixel>(Configuration con
     /// <inheritdoc />
     public IQuantizer<TPixel> CreatePixelSpecificQuantizer<TPixel>(Configuration configuration, QuantizerOptions options)
         where TPixel : unmanaged, IPixel<TPixel>
-        => new OctreeQuantizer<TPixel>(configuration, options);
+        => new HexadecatreeQuantizer<TPixel>(configuration, options);
 }