Наложение шума на изображение методами ООП

Быстрое преобразование Bitmap

Работать с Bitmap через GetPixel/SetPixel - это просто супермедленно. Вот например фильтр - как сделать картинку черно-белой (просто у меня был готовый пример):

public static Bitmap ToGrayScale(Bitmap bmp)
{
    Rectangle rect = new Rectangle(Point.Empty, bmp.Size);
    BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
    int stride = Math.Abs(bmpData.Stride);
    int length = stride * bmp.Height;
    byte[] buffer = new byte[length]; // содержимое буфера будет [B G R B G R B G R...]
    Marshal.Copy(bmpData.Scan0, buffer, 0, bmpData.Stride * bmp.Height); // stride может быть отрицательным (строчки снизу вверх), именно здесь это важно
    bmp.UnlockBits(bmpData);
    for (int row = 0; row < bmp.Height; row++)
    {
        int rowOffset = stride * row;
        for (int col = 0; col < bmp.Width; col++)
        {
            int offset = rowOffset + col * 3; // 24bpp = 3 bytes per pixel
            byte brightness = (byte)(buffer[offset] * 0.114f + buffer[offset + 1] * 0.587f + buffer[offset + 2] * 0.299f); // формула получения яркости 0.114 * B + 0.587f * G + 0.299f * R
            buffer[offset] = brightness;
            buffer[offset + 1] = brightness;
            buffer[offset + 2] = brightness;
        }
    }
    Bitmap result = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
    BitmapData resultData = result.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
    Marshal.Copy(buffer, 0, resultData.Scan0, length);
    result.UnlockBits(resultData);
    return result;
}

Работа через GetPixel/SetPixel для картинки 2560x1440 заняла бы 2,5 секунды, данный код отработает за ~60мс.

Как прочитать, обработать и записать картинку

Bitmap bmp = new Bitmap("image.jpg");
Bitmap result = ToGrayscale(bmp);
result.Save("out.jpg", ImageFormat.Jpeg);

Генератор шума

Давайте теперь пошумим. Чтобы не прикручивать ваши структуры, напишу очень простой фильтр, добавляющий шум по яркости со смещением [-20..+20]

public static Bitmap SetNoise(Bitmap bmp)
{
    Random rnd = new Random();
    Rectangle rect = new Rectangle(Point.Empty, bmp.Size);
    BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
    int stride = Math.Abs(bmpData.Stride);
    int length = stride * bmp.Height;
    byte[] buffer = new byte[length]; // содержимое буфера будет [B G R B G R B G R...]
    Marshal.Copy(bmpData.Scan0, buffer, 0, bmpData.Stride * bmp.Height); // stride может быть отрицательным (строчки снизу вверх), именно здесь это важно
    bmp.UnlockBits(bmpData);
    for (int row = 0; row < bmp.Height; row++)
    {
        int rowOffset = stride * row;
        for (int col = 0; col < bmp.Width; col++)
        {
            int offset = rowOffset + col * 3;

            int b = buffer[offset] + rnd.Next(-20, 21); // правая граница не включена в рандом
            int g = buffer[offset + 1] + rnd.Next(-20, 21);
            int r = buffer[offset + 2] + rnd.Next(-20, 21);

            buffer[offset] = ToByteSaturate(b);
            buffer[offset + 1] = ToByteSaturate(g);
            buffer[offset + 2] = ToByteSaturate(r);
        }
    }
    Bitmap result = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
    BitmapData resultData = result.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);
    Marshal.Copy(buffer, 0, resultData.Scan0, length);
    result.UnlockBits(resultData);
    return result;
}

private static byte ToByteSaturate(int number)
{
    if (number > byte.MaxValue)
        return byte.MaxValue;
    if (number < byte.MinValue)
        return byte.MinValue;
    return (byte)number;
}

Было

Стало

В общем, этот метод работы с картинками в 50-100 раз быстрее, чем через GetPixel/SetPixel, пользуйтесь.

ООП

Теперь давайте переложу это все на ООП, чтобы было прикольнее всем этим пользоваться. Сразу оговорюсь, что здесь нет обработки исключений и нет оптимизаций по производительности, но работает весьма быстро.

Класс картинки, отвечает за хранение данных о картинке, а так же чтение ее из Bitmap и преобразование ее обратно.

public class Photo
{
    public byte[] Buffer { get; }
    public int Stride { get; }
    public int Width { get; }
    public int Height { get; }

    public Photo(Bitmap bmp)
    {
        Width = bmp.Width;
        Height = bmp.Height;
        BitmapData bmpData = bmp.LockBits(new Rectangle(Point.Empty, bmp.Size), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
        Stride = Math.Abs(bmpData.Stride);
        Buffer = new byte[Stride * bmp.Height];
        Marshal.Copy(bmpData.Scan0, Buffer, 0, bmpData.Stride * bmp.Height);
        bmp.UnlockBits(bmpData);
    }

    public Bitmap ToBitmap()
    {
        Bitmap bmp = new Bitmap(Width, Height, PixelFormat.Format24bppRgb);
        BitmapData bmpData = bmp.LockBits(new Rectangle(Point.Empty, bmp.Size), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);
        Marshal.Copy(Buffer, 0, bmpData.Scan0, Buffer.Length);
        bmp.UnlockBits(bmpData);
        return bmp;
    }
}

Далее, реализация фильтра

public struct Pixel
{
    public Pixel(byte b, byte g, byte r)
    {
        B = b;
        G = g;
        R = r;
    }

    public byte B { get; }
    public byte G { get; }
    public byte R { get; }
}

public interface IFilter
{
    public void Apply(Photo photo);
}

public abstract class Filter : IFilter
{
    public virtual void Apply(Photo photo)
    {
        for (int row = 0; row < photo.Height; row++)
        {
            int rowOffset = photo.Stride * row;
            for (int col = 0; col < photo.Width; col++)
            {
                int offset = rowOffset + col * 3; // 24bpp = 3 bytes per pixel
                Pixel pixel = ConvertPixel(new Pixel(photo.Buffer[offset], photo.Buffer[offset + 1], photo.Buffer[offset + 2]));
                photo.Buffer[offset] = pixel.B;
                photo.Buffer[offset + 1] = pixel.G;
                photo.Buffer[offset + 2] = pixel.R;
            }
        }
    }

    protected abstract Pixel ConvertPixel(Pixel pixel);
}

Здесь все просто, фильтр просто применяет цветокоррекцию к каждому пикселю, причем сама цветокоррекция задается в классе, наследующем эту абстракцию.

Давайте обесцветим картинку

public class GrayScaleFilter : Filter
{
    protected override Pixel ConvertPixel(Pixel pixel)
    {
        byte brightness = (byte)(pixel.B * 0.114f + pixel.G * 0.587f + pixel.R * 0.299f);
        return new Pixel(brightness, brightness, brightness);
    }
}

Теперь воспользуюсь этим фильтром

Bitmap bmp = new Bitmap("image.jpg");
Photo photo = new Photo(bmp);
GrayScaleFilter grayFilter = new GrayScaleFilter();
grayFilter.Apply(photo);
Bitmap res = photo.ToBitmap();
res.Save("_gray.jpg", ImageFormat.Jpeg);

Или вот самый простой фильтр-негатив

public class NegativeFilter : Filter
{
    protected override Pixel ConvertPixel(Pixel pixel)
    {
        return new Pixel((byte)(255 - pixel.B), (byte)(255 - pixel.G), (byte)(255 - pixel.R));
    }
}

NegativeFilter negativeFilter = new NegativeFilter();
negativeFilter.Apply(photo);

Теперь параметризованный фильтр, здесь я создам дженерик абстракцию, которая будет отвечать за прием и хранение параметров. То что я увидел у вас в вопросе - это излишества. Старайтесь понимать, за что у вас отвечат тот или иной класс, и старайтесь сделать так, чтобы он отвечал только за что-то одно (принцип SRP из SOLID).

public abstract class ParametrizedFilter<T> : Filter 
    where T : struct
{
    public T Parameters { get; }

    public ParametrizedFilter(T parameters)
    {
        Parameters = parameters;
    }
}

А вы ждали что-то покруче? :)

Теперь создам параметры для фильтра шума, и собственно сам фильтр.

public struct NoiseParameters
{
    public NoiseParameters(int intensity, byte minValue = byte.MinValue, byte maxValue = byte.MaxValue)
    {
        Intensity = intensity;
        MinValue = minValue;
        MaxValue = maxValue;
    }

    public int Intensity { get; }
    public byte MinValue { get; }
    public byte MaxValue { get; }
}


public class NoiseFilter : ParametrizedFilter<NoiseParameters>
{
    private readonly Random _rnd;

    public NoiseFilter(NoiseParameters parameters) : base(parameters)
    {
        _rnd = new Random();
    }

    protected override Pixel ConvertPixel(Pixel pixel)
    {
        int b = pixel.B + _rnd.Next(-Parameters.Intensity, Parameters.Intensity); 
        int g = pixel.G + _rnd.Next(-Parameters.Intensity, Parameters.Intensity);
        int r = pixel.R + _rnd.Next(-Parameters.Intensity, Parameters.Intensity);

        return new Pixel(ToByteSaturate(b), ToByteSaturate(g), ToByteSaturate(r));
    }

    private byte ToByteSaturate(int number)
    {
        if (number > Parameters.MaxValue)
            return Parameters.MaxValue;
        if (number < Parameters.MinValue)
            return Parameters.MinValue;
        return (byte)number;
    }
}

Вот и всего делов.

NoiseFilter noiseFilter = new NoiseFilter(new NoiseParameters(50));
noiseFilter.Apply(photo);

Ну и напоследок, почему же все-таки метод Apply имеет модификатор virtual. А чтобы можно было переопределить его для реализации более сложного фильтра, чем попиксельный.

Вот пример сложного фильтра - оператор Собеля.

public class SobelOperator : GrayScaleFilter
{
    public override void Apply(Photo photo)
    {
        base.Apply(photo); // обесцвечивание

        const int bpp = 3;
        byte[] tempBuffer = new byte[photo.Buffer.Length];
        for (int row = 1; row < photo.Height - 1; row++)
        {
            int rowOffset = photo.Stride * row;
            for (int col = 1; col < photo.Width - 1; col++)
            {
                int offset = rowOffset + col * bpp; // 24bpp = 3 bytes per pixel
                int gx = -photo.Buffer[offset - bpp - photo.Stride] + photo.Buffer[offset + bpp - photo.Stride] - 2 * photo.Buffer[offset - bpp] +
                        2 * photo.Buffer[offset + bpp] - photo.Buffer[offset - bpp + photo.Stride] + photo.Buffer[offset + bpp + photo.Stride];

                int gy = photo.Buffer[offset - bpp - photo.Stride] + 2 * photo.Buffer[offset - photo.Stride] + photo.Buffer[offset + bpp - photo.Stride] -
                    photo.Buffer[offset - bpp + photo.Stride] - 2 * photo.Buffer[offset + photo.Stride] - photo.Buffer[offset + bpp + photo.Stride];

                int g = (int)MathF.Sqrt(gx * gx + gy * gy);
                if (g > byte.MaxValue)
                    g = byte.MaxValue;
                byte gb = (byte)g;

                tempBuffer[offset] = gb;
                tempBuffer[offset + 1] = gb;
                tempBuffer[offset + 2] = gb;
            }
        }
        Array.Copy(tempBuffer, photo.Buffer, tempBuffer.Length);
    }
}

SobelOperator sobelFilter = new SobelOperator();
sobelFilter.Apply(photo);