Обработка изображения с использованием медианного фильтра

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication18
{
    class Program
    {
        static void Main(string[] args)
        {
            const int size = 11;
            for (int i = 3; i < size; i+=2)
            {
                using (var bmp = new Bitmap("source.bmp"))
                using (var result = MedianFiltering(bmp, i))
                {
                    result.Save($"output_new{i}.bmp", ImageFormat.Bmp);
                }
            }
        }
 
        private static Bitmap MedianFiltering(Bitmap source, int size)
        {
            if (size < 3)
                throw new ArgumentOutOfRangeException("size", "should be > 3");
            size |= 1;
            int padding = size/2;
            var colours = source.GetPixels();
            var resPixels = new Color[colours.GetLength(0), colours.GetLength(1)];
            for (int i = padding; i < colours.GetLength(0) - padding; i++)
            {
                for (int j = padding; j < colours.GetLength(1) - padding; j++)
                {
                    resPixels[i, j] = GetPixel(colours, i, j, size);
                }
            }
 
 
            var result = new Bitmap(source.Width, source.Height);
            for (int i = 0; i < resPixels.GetLength(0); i++)
            {
                for (int j = 0; j < resPixels.GetLength(1); j++)
                {
                    result.SetPixel(j, i, resPixels[i, j]);
                }
            }
            return result;
        }
 
        private static Color GetPixel(Color[,] colours, int i, int j, int size)
        {
            int medR = GetMedian(colours, c => c.R, i, j, size);
            int medG = GetMedian(colours, c => c.G, i, j, size);
            int medB = GetMedian(colours, c => c.B, i, j, size);
            return Color.FromArgb(medR, medG, medB);
        }
 
        private static int GetMedian(Color[,] colours, Func<Color, int> func, int i, int j, int size)
        {
            int[] result = new int[size*size];
            int index = 0;
            int diff = size/2;
            for (int x = i - diff; x <= i + diff; x++)
            {
                for (int y = j - diff; y <= j + diff; y++)
                {
                    result[index++] = func(colours[x, y]);
                }
            }
            Array.Sort(result);
            return result[result.Length/2];
        }
    }
}

using System;
using System.Drawing;
using System.Drawing.Imaging;
 
namespace Helpers
{
    public static class BitmapHelper
    {
        struct Pixel : IEquatable<Pixel>
        {
            
// ReSharper disable UnassignedField.Compiler
            public byte Blue;
            public byte Green;
            public byte Red;
 
            public bool Equals(Pixel other)
            {
                return Red == other.Red && Green == other.Green && Blue == other.Blue;
            }
        }
 
        public static Color[,] GetPixels(this Bitmap bmp)
        {
            return ProcessBitmap(bmp, pixel => Color.FromArgb(pixel.Red, pixel.Green, pixel.Blue));
        }
 
        public static float[,] GetBrightness(this Bitmap bmp)
        {
            return ProcessBitmap(bmp, pixel => Color.FromArgb(pixel.Red, pixel.Green, pixel.Blue).GetBrightness());
        }
 
        private static unsafe T[,] ProcessBitmap<T>(this Bitmap bitmap, Func<Pixel, T> func)
        {
            var lockBits = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly,
                                       bitmap.PixelFormat);
            int padding = lockBits.Stride - (bitmap.Width*sizeof (Pixel));
 
            int width = bitmap.Width;
            int height = bitmap.Height;
 
            var result = new T[height, width];
 
            var ptr = (byte*) lockBits.Scan0;
 
            for (int i = 0; i < height; i++)
            {
                for (int j = 0; j < width; j++)
                {
                    var pixel = (Pixel*) ptr;
                    result[i, j] = func(*pixel);
                    ptr += sizeof (Pixel);
                }
                ptr += padding;
            }
 
            bitmap.UnlockBits(lockBits);
 
            return result;
        }
    }
}