Оптимизация алгоритма размытия

static Bitmap Blur(Bitmap image, int radius)
{
    Bitmap res = new Bitmap(image.Width, image.Height);
    Console.WriteLine(res.Width);
    Console.WriteLine(res.Height);
 
    for (int cy = 0; cy < image.Height; cy++)
    {
        for (int cx = 0; cx < image.Width; cx++)
        {
            int count = 0;
            int alpha = 0;
            int red = 0;
            int green = 0;
            int blue = 0;
            for (int y = 0; y < image.Height; y++)
            {
                for (int x = 0; x < image.Width; x++)
                {
                    if ((x-cx) * (x-cx) + (y-cy) * (y-cy) <= radius * radius)
                    {
                        count++;
                        alpha += image.GetPixel(x, y).A;
                        red += image.GetPixel(x, y).R;
                        green += image.GetPixel(x, y).G;
                        blue += image.GetPixel(x, y).B;
                    }
                }
            }
            for (int y = 0; y < image.Height; y++)
            {
                for (int x = 0; x < image.Width; x++)
                {
                    res.SetPixel(cx, cy, Color.FromArgb(alpha / count, red / count, green / count, blue / count));
                }
            }
        }
    }
    return res;
}

static Bitmap Blur(Bitmap image, int radius)
{
    Bitmap res = new Bitmap(image.Width, image.Height);
    Color[,] pixels = new Color[image.Width, image.Height];
 
    BitmapData imageData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height),
                                         ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    int bytesPerPixel = 4; // RGBA
    int stride = imageData.Stride;
    IntPtr scan0 = imageData.Scan0;
 
    unsafe
    {
        byte* ptr = (byte*)scan0;
 
        for (int y = 0; y < image.Height; y++)
        {
            for (int x = 0; x < image.Width; x++)
            {
                int index = y * stride + x * bytesPerPixel;
                byte alpha = ptr[index + 3];
                byte red = ptr[index + 2];
                byte green = ptr[index + 1];
                byte blue = ptr[index];
 
                pixels[x, y] = Color.FromArgb(alpha, red, green, blue);
            }
        }
    }
 
    image.UnlockBits(imageData);
 
    for (int cy = 0; cy < image.Height; cy++)
    {
        for (int cx = 0; cx < image.Width; cx++)
        {
            int count = 0;
            int alpha = 0;
            int red = 0;
            int green = 0;
            int blue = 0;
 
            for (int y = Math.Max(0, cy - radius); y < Math.Min(image.Height, cy + radius); y++)
            {
                for (int x = Math.Max(0, cx - radius); x < Math.Min(image.Width, cx + radius); x++)
                {
                    if ((x - cx) * (x - cx) + (y - cy) * (y - cy) <= radius * radius)
                    {
                        count++;
                        alpha += pixels[x, y].A;
                        red += pixels[x, y].R;
                        green += pixels[x, y].G;
                        blue += pixels[x, y].B;
                    }
                }
            }
 
            res.SetPixel(cx, cy, Color.FromArgb(alpha / count, red / count, green / count, blue / count));
        }
    }
 
    return res;
}

using Image img = Image.Load("input.png");
img.Mutate(c => c.GaussianBlur(2.5f));
img.Save("blurred.png");