Изображение в оттенки серого

public static UInt32[,] matrix_filtration(int W, int H, UInt32[,] pixel, int N, double[,] matryx)
            {
                int i, j, k, m, gap = (int)(N / 2);
                int tmpH = H + 2 * gap, tmpW = W + 2 * gap;
                UInt32[,] tmppixel = new UInt32[tmpH, tmpW];
                UInt32[,] newpixel = new UInt32[H, W];
                //заполнение временного расширенного изображения
                //углы
                for (i = 0; i < gap; i++)
                    for (j = 0; j < gap; j++)
                    {
                        tmppixel[i, j] = pixel[0, 0];
                        tmppixel[i, tmpW - 1 - j] = pixel[0, W - 1];
                        tmppixel[tmpH - 1 - i, j] = pixel[H - 1, 0];
                        tmppixel[tmpH - 1 - i, tmpW - 1 - j] = pixel[H - 1, W - 1];
                    }
                //крайние левая и правая стороны
                for (i = gap; i < tmpH - gap; i++)
                    for (j = 0; j < gap; j++)
                    {
                        tmppixel[i, j] = pixel[i - gap, j];
                        tmppixel[i, tmpW - 1 - j] = pixel[i - gap, W - 1 - j];
                    }
                //крайние верхняя и нижняя стороны
                for (i = 0; i < gap; i++)
                    for (j = gap; j < tmpW - gap; j++)
                    {
                        tmppixel[i, j] = pixel[i, j - gap];
                        tmppixel[tmpH - 1 - i, j] = pixel[H - 1 - i, j - gap];
                    }
                //центр
                for (i = 0; i < H; i++)
                    for (j = 0; j < W; j++)
                        tmppixel[i + gap, j + gap] = pixel[i, j];
                //применение ядра свертки
                RGB ColorOfPixel = new RGB();
                RGB ColorOfCell = new RGB();
                for (i = gap; i < tmpH - gap; i++)
                    for (j = gap; j < tmpW - gap; j++)
                    {
                        ColorOfPixel.R = 0;
                        ColorOfPixel.G = 0;
                        ColorOfPixel.B = 0;
                        for (k = 0; k < N; k++)
                            for (m = 0; m < N; m++)
                            {
                                ColorOfCell = calculationOfColor(tmppixel[i - gap + k, j - gap + m], matryx[k, m]);
                                ColorOfPixel.R += ColorOfCell.R;
                                ColorOfPixel.G += ColorOfCell.G;
                                ColorOfPixel.B += ColorOfCell.B;
                            }
                        //контролируем переполнение переменных
                        if (ColorOfPixel.R < 0) ColorOfPixel.R = 0;
                        if (ColorOfPixel.R > 255) ColorOfPixel.R = 255;
                        if (ColorOfPixel.G < 0) ColorOfPixel.G = 0;
                        if (ColorOfPixel.G > 255) ColorOfPixel.G = 255;
                        if (ColorOfPixel.B < 0) ColorOfPixel.B = 0;
                        if (ColorOfPixel.B > 255) ColorOfPixel.B = 255;
 
                        newpixel[i - gap, j - gap] = build(ColorOfPixel);
                    }
 
                return newpixel;
            }
 
            //вычисление нового цвета
            public static RGB calculationOfColor(UInt32 pixel, double coefficient)
            {
                RGB Color = new RGB();
                Color.R = (float)(coefficient * ((pixel & 0x00FF0000)>>16)); //>>16
                Color.G = (float)(coefficient * ((pixel & 0x0000FF00) >>8));//>>8
            Color.B = (float)(coefficient * ((pixel & 0x000000FF)));
                return Color;
            }
 
            //сборка каналов
            public static UInt32 build(RGB ColorOfPixel)
            {
                UInt32 Color;
                Color = ((UInt32)ColorOfPixel.R << 16) | ((UInt32)ColorOfPixel.G << 8) | ((UInt32)ColorOfPixel.B);
                return Color;
            }
 
            public const int N = 3;
            public static double[,] blur = new double[N, N] {{0.111,0.111,0.111},
                                                          { 0.111,0.111,0.111},
                                                          { 0.111,0.111,0.111}};
        public void Gray(PictureBox pb)
        {
            int brg;
            Bitmap bmp = new Bitmap(pb.Image);
            for (int i = 1; i < bmp.Width; i++)
            {
                for (int j = 1; j < bmp.Height; j++)
                {
                    brg = (int)(0.3 * bmp.GetPixel(i, j).R + 0.59 * bmp.GetPixel(i, j).G + 0.11 * bmp.GetPixel(i, j).B);
                    bmp.SetPixel(i, j, Color.FromArgb(brg, brg, brg));
                }
            }
            pb.Image = bmp;
            
        }
        private void размытиеToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (nameofimage!="/0")
            {
                pixel = Filter.matrix_filtration(image.Width, image.Height, pixel, Filter.N, Filter.blur);
                FromPixelToBitmap();
                FromBitmapToScreen();
            }
        }
 
        private void матричныйФильтрToolStripMenuItem_Click(object sender, EventArgs e)
        {
            W W = new W();
            W.Show();
        }
 
        private void menuStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
 
        }
 
        private void оттенкиСерогоToolStripMenuItem_Click(object sender, EventArgs e)
        {
           obj.Gray(pictureBox1);
            FromPixelToBitmap();
        }
        public static void FromPixelToBitmap()
        {
            for (int y = 0; y < image.Height; y++)
                for (int x = 0; x < image.Width; x++)
                    image.SetPixel(x, y, Color.FromArgb((int)pixel[y, x]));
        }
 
        //вывод на экран
        public void FromBitmapToScreen()
        {
            pictureBox1.Image = image;
        }