public unsafe void Issue1640 <TPixel>(TestImageProvider <TPixel> provider)
            where TPixel : unmanaged, IPixel <TPixel>
        {
            if (!TestEnvironment.Is64BitProcess)
            {
                return;
            }

            // https://github.com/SixLabors/ImageSharp/discussions/1640
            // Test using isolated memory to ensure clean buffers for reference
            provider.Configuration = Configuration.CreateDefaultInstance();
            var options = new HistogramEqualizationOptions
            {
                Method          = HistogramEqualizationMethod.AdaptiveTileInterpolation,
                LuminanceLevels = 4096,
                ClipHistogram   = false,
                ClipLimit       = 350,
                NumberOfTiles   = 8
            };

            using Image <TPixel> image           = provider.GetImage();
            using Image <TPixel> referenceResult = image.Clone(ctx =>
            {
                ctx.HistogramEqualization(options);
                ctx.Resize(image.Width / 4, image.Height / 4, KnownResamplers.Bicubic);
            });

            using Image <TPixel> processed = image.Clone(ctx =>
            {
                ctx.HistogramEqualization(options);
                ctx.Resize(image.Width / 4, image.Height / 4, KnownResamplers.Bicubic);
            });

            ValidatorComparer.VerifySimilarity(referenceResult, processed);
        }
Esempio n. 2
0
        private static HistogramEqualizationProcessor <TPixel> GetProcessor <TPixel>(HistogramEqualizationOptions options)
            where TPixel : struct, IPixel <TPixel>
        {
            HistogramEqualizationProcessor <TPixel> processor;

            switch (options.Method)
            {
            case HistogramEqualizationMethod.Global:
                processor = new GlobalHistogramEqualizationProcessor <TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimitPercentage);
                break;

            case HistogramEqualizationMethod.AdaptiveTileInterpolation:
                processor = new AdaptiveHistEqualizationProcessor <TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimitPercentage, options.Tiles);
                break;

            case HistogramEqualizationMethod.AdaptiveSlidingWindow:
                processor = new AdaptiveHistEqualizationSWProcessor <TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimitPercentage, options.Tiles);
                break;

            default:
                processor = new GlobalHistogramEqualizationProcessor <TPixel>(options.LuminanceLevels, options.ClipHistogram, options.ClipLimitPercentage);
                break;
            }

            return(processor);
        }
Esempio n. 3
0
 public void GlobalHistogramEqualization_CompareToReferenceOutput <TPixel>(TestImageProvider <TPixel> provider)
     where TPixel : unmanaged, IPixel <TPixel>
 {
     using (Image <TPixel> image = provider.GetImage())
     {
         var options = new HistogramEqualizationOptions
         {
             Method          = HistogramEqualizationMethod.Global,
             LuminanceLevels = 256,
         };
         image.Mutate(x => x.HistogramEqualization(options));
         image.DebugSave(provider);
         image.CompareToReferenceOutput(ValidatorComparer, provider, extension: "png");
     }
 }
Esempio n. 4
0
 public void Issue984 <TPixel>(TestImageProvider <TPixel> provider)
     where TPixel : struct, IPixel <TPixel>
 {
     using (Image <TPixel> image = provider.GetImage())
     {
         var options = new HistogramEqualizationOptions()
         {
             Method          = HistogramEqualizationMethod.AdaptiveTileInterpolation,
             LuminanceLevels = 256,
             ClipHistogram   = true,
             NumberOfTiles   = 10
         };
         image.Mutate(x => x.HistogramEqualization(options));
         image.DebugSave(provider);
     }
 }
Esempio n. 5
0
 public void Adaptive_TileInterpolation_10Tiles_WithClipping <TPixel>(TestImageProvider <TPixel> provider)
     where TPixel : struct, IPixel <TPixel>
 {
     using (Image <TPixel> image = provider.GetImage())
     {
         var options = new HistogramEqualizationOptions
         {
             Method          = HistogramEqualizationMethod.AdaptiveTileInterpolation,
             LuminanceLevels = 256,
             ClipHistogram   = true,
             NumberOfTiles   = 10
         };
         image.Mutate(x => x.HistogramEqualization(options));
         image.DebugSave(provider);
         image.CompareToReferenceOutput(ValidatorComparer, provider);
     }
 }
Esempio n. 6
0
 /// <summary>
 /// Equalizes the histogram of an image to increases the contrast.
 /// </summary>
 /// <param name="source">The image this method extends.</param>
 /// <param name="options">The histogram equalization options to use.</param>
 /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
 public static IImageProcessingContext HistogramEqualization(
     this IImageProcessingContext source,
     HistogramEqualizationOptions options) =>
 source.ApplyProcessor(HistogramEqualizationProcessor.FromOptions(options));
Esempio n. 7
0
 /// <summary>
 /// Equalizes the histogram of an image to increases the contrast.
 /// </summary>
 /// <typeparam name="TPixel">The pixel format.</typeparam>
 /// <param name="source">The image this method extends.</param>
 /// <param name="options">The histogram equalization options to use.</param>
 /// <returns>The <see cref="Image{TPixel}"/>.</returns>
 public static IImageProcessingContext <TPixel> HistogramEqualization <TPixel>(this IImageProcessingContext <TPixel> source, HistogramEqualizationOptions options)
     where TPixel : struct, IPixel <TPixel>
 => source.ApplyProcessor(GetProcessor <TPixel>(options));