verbose naming for Histogram Equalization stuff + make it public

src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistEqualizationProcessor.cs → src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor.cs

@@ -7,17 +7,21 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
     /// Applies an adaptive histogram equalization to the image. The image is split up in tiles. For each tile a cumulative distribution function (cdf) is calculated.
     /// To calculate the final equalized pixel value, the cdf value of four adjacent tiles will be interpolated.
     /// </summary>
-    internal class AdaptiveHistEqualizationProcessor : HistogramEqualizationProcessor
+    public class AdaptiveHistogramEqualizationProcessor : HistogramEqualizationProcessor
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="AdaptiveHistEqualizationProcessor"/> class.
+        /// Initializes a new instance of the <see cref="AdaptiveHistogramEqualizationProcessor"/> class.
         /// </summary>
         /// <param name="luminanceLevels">The number of different luminance levels. Typical values are 256 for 8-bit grayscale images
         /// or 65536 for 16-bit grayscale images.</param>
         /// <param name="clipHistogram">Indicating whether to clip the histogram bins at a specific value.</param>
         /// <param name="clipLimitPercentage">Histogram clip limit in percent of the total pixels in the tile. Histogram bins which exceed this limit, will be capped at this value.</param>
         /// <param name="numberOfTiles">The number of tiles the image is split into (horizontal and vertically). Minimum value is 2. Maximum value is 100.</param>
-        public AdaptiveHistEqualizationProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage, int numberOfTiles)
+        public AdaptiveHistogramEqualizationProcessor(
+            int luminanceLevels,
+            bool clipHistogram,
+            float clipLimitPercentage,
+            int numberOfTiles)
             : base(luminanceLevels, clipHistogram, clipLimitPercentage)
         {
             this.NumberOfTiles = numberOfTiles;
@@ -31,7 +35,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         /// <inheritdoc />
         public override IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>()
         {
-            return new AdaptiveHistEqualizationProcessor<TPixel>(this.LuminanceLevels, this.ClipHistogram, this.ClipLimitPercentage, this.NumberOfTiles);
+            return new AdaptiveHistogramEqualizationProcessor<TPixel>(
+                this.LuminanceLevels,
+                this.ClipHistogram,
+                this.ClipLimitPercentage,
+                this.NumberOfTiles);
         }
     }
-}
+}

src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistEqualizationProcessor{TPixel}.cs → src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs

@@ -21,18 +21,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
     /// To calculate the final equalized pixel value, the cdf value of four adjacent tiles will be interpolated.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class AdaptiveHistEqualizationProcessor<TPixel> : HistogramEqualizationProcessor<TPixel>
+    internal class AdaptiveHistogramEqualizationProcessor<TPixel> : HistogramEqualizationProcessor<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="AdaptiveHistEqualizationProcessor{TPixel}"/> class.
+        /// Initializes a new instance of the <see cref="AdaptiveHistogramEqualizationProcessor{TPixel}"/> class.
         /// </summary>
         /// <param name="luminanceLevels">The number of different luminance levels. Typical values are 256 for 8-bit grayscale images
         /// or 65536 for 16-bit grayscale images.</param>
         /// <param name="clipHistogram">Indicating whether to clip the histogram bins at a specific value.</param>
         /// <param name="clipLimitPercentage">Histogram clip limit in percent of the total pixels in the tile. Histogram bins which exceed this limit, will be capped at this value.</param>
         /// <param name="tiles">The number of tiles the image is split into (horizontal and vertically). Minimum value is 2. Maximum value is 100.</param>
-        public AdaptiveHistEqualizationProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage, int tiles)
+        public AdaptiveHistogramEqualizationProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage, int tiles)
             : base(luminanceLevels, clipHistogram, clipLimitPercentage)
         {
             Guard.MustBeGreaterThanOrEqualTo(tiles, 2, nameof(tiles));

src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistEqualizationSWProcessor.cs → src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor.cs

@@ -6,17 +6,21 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
     /// <summary>
     /// Applies an adaptive histogram equalization to the image using an sliding window approach.
     /// </summary>
-    internal class AdaptiveHistEqualizationSWProcessor : HistogramEqualizationProcessor
+    public class AdaptiveHistogramEqualizationSlidingWindowProcessor : HistogramEqualizationProcessor
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="AdaptiveHistEqualizationSWProcessor"/> class.
+        /// Initializes a new instance of the <see cref="AdaptiveHistogramEqualizationSlidingWindowProcessor"/> class.
         /// </summary>
         /// <param name="luminanceLevels">The number of different luminance levels. Typical values are 256 for 8-bit grayscale images
         /// or 65536 for 16-bit grayscale images.</param>
         /// <param name="clipHistogram">Indicating whether to clip the histogram bins at a specific value.</param>
         /// <param name="clipLimitPercentage">Histogram clip limit in percent of the total pixels in the tile. Histogram bins which exceed this limit, will be capped at this value.</param>
         /// <param name="numberOfTiles">The number of tiles the image is split into (horizontal and vertically). Minimum value is 2. Maximum value is 100.</param>
-        public AdaptiveHistEqualizationSWProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage, int numberOfTiles)
+        public AdaptiveHistogramEqualizationSlidingWindowProcessor(
+            int luminanceLevels,
+            bool clipHistogram,
+            float clipLimitPercentage,
+            int numberOfTiles)
             : base(luminanceLevels, clipHistogram, clipLimitPercentage)
         {
             this.NumberOfTiles = numberOfTiles;
@@ -30,7 +34,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         /// <inheritdoc />
         public override IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>()
         {
-            return new AdaptiveHistEqualizationSWProcessor<TPixel>(this.LuminanceLevels, this.ClipHistogram, this.ClipLimitPercentage, this.NumberOfTiles);
+            return new AdaptiveHistogramEqualizationSlidingWindowProcessor<TPixel>(
+                this.LuminanceLevels,
+                this.ClipHistogram,
+                this.ClipLimitPercentage,
+                this.NumberOfTiles);
         }
     }
 }

src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistEqualizationSWProcessor{TPixel}.cs → src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}.cs

@@ -20,18 +20,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
     /// Applies an adaptive histogram equalization to the image using an sliding window approach.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class AdaptiveHistEqualizationSWProcessor<TPixel> : HistogramEqualizationProcessor<TPixel>
+    internal class AdaptiveHistogramEqualizationSlidingWindowProcessor<TPixel> : HistogramEqualizationProcessor<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="AdaptiveHistEqualizationSWProcessor{TPixel}"/> class.
+        /// Initializes a new instance of the <see cref="AdaptiveHistogramEqualizationSlidingWindowProcessor{TPixel}"/> class.
         /// </summary>
         /// <param name="luminanceLevels">The number of different luminance levels. Typical values are 256 for 8-bit grayscale images
         /// or 65536 for 16-bit grayscale images.</param>
         /// <param name="clipHistogram">Indicating whether to clip the histogram bins at a specific value.</param>
         /// <param name="clipLimitPercentage">Histogram clip limit in percent of the total pixels in the tile. Histogram bins which exceed this limit, will be capped at this value.</param>
         /// <param name="tiles">The number of tiles the image is split into (horizontal and vertically). Minimum value is 2. Maximum value is 100.</param>
-        public AdaptiveHistEqualizationSWProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage, int tiles)
+        public AdaptiveHistogramEqualizationSlidingWindowProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage, int tiles)
             : base(luminanceLevels, clipHistogram, clipLimitPercentage)
         {
             Guard.MustBeGreaterThanOrEqualTo(tiles, 2, nameof(tiles));

src/ImageSharp/Processing/Processors/Normalization/GlobalHistogramEqualizationProcessor.cs

@@ -6,8 +6,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
     /// <summary>
     /// Defines a global histogram equalization applicable to an <see cref="Image"/>.
     /// </summary>
-    internal class GlobalHistogramEqualizationProcessor : HistogramEqualizationProcessor
+    public class GlobalHistogramEqualizationProcessor : HistogramEqualizationProcessor
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GlobalHistogramEqualizationProcessor"/> class.
+        /// </summary>
+        /// <param name="luminanceLevels">The number of luminance levels.</param>
+        /// <param name="clipHistogram">A value indicating whether to clip the histogram bins at a specific value.</param>
+        /// <param name="clipLimitPercentage">The histogram clip limit in percent of the total pixels in the tile. Histogram bins which exceed this limit, will be capped at this value.</param>
         public GlobalHistogramEqualizationProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage)
             : base(luminanceLevels, clipHistogram, clipLimitPercentage)
         {

src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor.cs

@@ -8,7 +8,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
     /// <summary>
     /// Defines a processor that normalizes the histogram of an image.
     /// </summary>
-    internal abstract class HistogramEqualizationProcessor : IImageProcessor
+    public abstract class HistogramEqualizationProcessor : IImageProcessor
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="HistogramEqualizationProcessor"/> class.
@@ -63,7 +63,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                     break;
 
                 case HistogramEqualizationMethod.AdaptiveTileInterpolation:
-                    processor = new AdaptiveHistEqualizationProcessor(
+                    processor = new AdaptiveHistogramEqualizationProcessor(
                         options.LuminanceLevels,
                         options.ClipHistogram,
                         options.ClipLimitPercentage,
@@ -71,7 +71,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                     break;
 
                 case HistogramEqualizationMethod.AdaptiveSlidingWindow:
-                    processor = new AdaptiveHistEqualizationSWProcessor(
+                    processor = new AdaptiveHistogramEqualizationSlidingWindowProcessor(
                         options.LuminanceLevels,
                         options.ClipHistogram,
                         options.ClipLimitPercentage,