clipLimit now in percent of the total number of pixels in the grid

src/ImageSharp/Processing/HistogramEqualizationExtension.cs

@@ -40,15 +40,15 @@ namespace SixLabors.ImageSharp.Processing
             switch (options.Method)
             {
                 case HistogramEqualizationMethod.Global:
-                    processor = new GlobalHistogramEqualizationProcessor<TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimit);
+                    processor = new GlobalHistogramEqualizationProcessor<TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimitPercentage);
                     break;
 
                 case HistogramEqualizationMethod.Adaptive:
-                    processor = new AdaptiveHistEqualizationProcessor<TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimit, options.GridSize);
+                    processor = new AdaptiveHistEqualizationProcessor<TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimitPercentage, options.GridSize);
                     break;
 
                 default:
-                    processor = new GlobalHistogramEqualizationProcessor<TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimit);
+                    processor = new GlobalHistogramEqualizationProcessor<TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimitPercentage);
                     break;
             }
 

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

@@ -25,10 +25,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         /// <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="clipLimit">The histogram clip limit. Histogram bins which exceed this limit, will be capped at this value.</param>
+        /// <param name="clipLimitPercentage">Histogram clip limit in percent of the total pixels in the grid. Histogram bins which exceed this limit, will be capped at this value.</param>
         /// <param name="gridSize">The grid size of the adaptive histogram equalization. Minimum value is 4.</param>
-        public AdaptiveHistEqualizationProcessor(int luminanceLevels, bool clipHistogram, int clipLimit, int gridSize)
-            : base(luminanceLevels, clipHistogram, clipLimit)
+        public AdaptiveHistEqualizationProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage, int gridSize)
+            : base(luminanceLevels, clipHistogram, clipLimitPercentage)
         {
             Guard.MustBeGreaterThanOrEqualTo(gridSize, 4, nameof(gridSize));
 
@@ -80,7 +80,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                                 {
                                     // Clipping the histogram, but doing it on a copy to keep the original un-clipped values for the next iteration.
                                     histogram.CopyTo(histogramCopy);
-                                    this.ClipHistogram(histogramCopy, this.ClipLimit);
+                                    this.ClipHistogram(histogramCopy, this.ClipLimitPercentage, pixelsInGrid);
                                 }
 
                                 // Calculate the cumulative distribution function, which will map each input pixel in the current grid to a new value.

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

@@ -23,9 +23,9 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         /// <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="clipLimit">The histogram clip limit. Histogram bins which exceed this limit, will be capped at this value.</param>
-        public GlobalHistogramEqualizationProcessor(int luminanceLevels, bool clipHistogram, int clipLimit)
-            : base(luminanceLevels, clipHistogram, clipLimit)
+        /// <param name="clipLimitPercentage">Histogram clip limit in percent of the total pixels. 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)
         {
         }
 
@@ -50,7 +50,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
 
                 if (this.ClipHistogramEnabled)
                 {
-                    this.ClipHistogram(histogram, this.ClipLimit);
+                    this.ClipHistogram(histogram, this.ClipLimitPercentage, numberOfPixels);
                 }
 
                 // Calculate the cumulative distribution function, which will map each input pixel to a new value.

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

@@ -25,10 +25,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         public bool ClipHistogram { get; set; } = true;
 
         /// <summary>
-        /// Gets or sets the histogram clip limit. Histogram bins which exceed this limit, will be capped at this value.
-        /// Defaults to 60.
+        /// Gets or sets the histogram clip limit in percent of the total pixels in the grid. Histogram bins which exceed this limit, will be capped at this value.
+        /// Defaults to 0.35.
         /// </summary>
-        public int ClipLimit { get; set; } = 60;
+        public float ClipLimitPercentage { get; set; } = 0.035f;
 
         /// <summary>
         /// Gets or sets the size of the grid for the adaptive histogram equalization. Defaults to 32.

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

@@ -19,15 +19,15 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         /// <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">Indicates, if histogram bins should be clipped.</param>
-        /// <param name="clipLimit">The histogram clip limit. Histogram bins which exceed this limit, will be capped at this value.</param>
-        protected HistogramEqualizationProcessor(int luminanceLevels, bool clipHistogram, int clipLimit)
+        /// <param name="clipLimitPercentage">Histogram clip limit in percent of the total pixels in the grid. Histogram bins which exceed this limit, will be capped at this value.</param>
+        protected HistogramEqualizationProcessor(int luminanceLevels, bool clipHistogram, float clipLimitPercentage)
         {
             Guard.MustBeGreaterThan(luminanceLevels, 0, nameof(luminanceLevels));
-            Guard.MustBeGreaterThan(clipLimit, 1, nameof(clipLimit));
+            Guard.MustBeGreaterThan(clipLimitPercentage, 0.0f, nameof(clipLimitPercentage));
 
             this.LuminanceLevels = luminanceLevels;
             this.ClipHistogramEnabled = clipHistogram;
-            this.ClipLimit = clipLimit;
+            this.ClipLimitPercentage = clipLimitPercentage;
         }
 
         /// <summary>
@@ -41,9 +41,9 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         public bool ClipHistogramEnabled { get; }
 
         /// <summary>
-        /// Gets the histogram clip limit. Histogram bins which exceed this limit, will be capped at this value.
+        /// Gets the histogram clip limit in percent of the total pixels in the grid. Histogram bins which exceed this limit, will be capped at this value.
         /// </summary>
-        public int ClipLimit { get; }
+        public float ClipLimitPercentage { get; }
 
         /// <summary>
         /// Calculates the cumulative distribution function.
@@ -87,9 +87,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
         /// the values over the clip limit to all other bins equally.
         /// </summary>
         /// <param name="histogram">The histogram to apply the clipping.</param>
-        /// <param name="clipLimit">The histogram clip limit. Histogram bins which exceed this limit, will be capped at this value.</param>
-        protected void ClipHistogram(Span<int> histogram, int clipLimit)
+        /// <param name="clipLimitPercentage">Histogram clip limit in percent of the total pixels in the grid. Histogram bins which exceed this limit, will be capped at this value.</param>
+        /// <param name="pixelCount">The numbers of pixels inside the grid.</param>
+        protected void ClipHistogram(Span<int> histogram, float clipLimitPercentage, int pixelCount)
         {
+            int clipLimit = Convert.ToInt32(pixelCount * clipLimitPercentage);
             int sumOverClip = 0;
             for (int i = 0; i < histogram.Length; i++)
             {