save bitmap image as grayscale image in C#

Question

This is my bitmap code

Bitmap b = new Bitmap(columns, rows, PixelFormat.Format24bppRgb);
BitmapData bmd = b.LockBits(new Rectangle(0, 0, columns, rows), ImageLockMode.ReadWrite, b.PixelFormat); 

How can i save this as a grayscale image ?

Well iam specifically interested in the saving part. How do i save it as a file ?

Answer 1

I've used a similar method to this before

http://www.codeproject.com/KB/graphics/quickgrayscale.aspx

e.g:

            for (int Y = 0; Y < Size.Y; Y++)
            {
                PixelData_s* PPixel =
                    PixelAt(0, Y, ImageWidth, PBase);

                for (int X = 0; X < Size.X; X++)
                {
                    byte Value = (byte)((PPixel->Red + PPixel->Green + PPixel->Blue) / 3);
                    PPixel->Red = Value;
                    PPixel->Green = Value;
                    PPixel->Blue = Value;
                    PPixel++;
                } // End for
            } // End for

Basically sum the RGB component values for the given pixel and divide by 3. This requires unsafe keyword which is required for operations using pointers. You could avoid using pointers and simply do something like this:

        for (int X = 0; X < Size.X; X++)
        {
            for (int Y = 0; Y < Size.Y; Y++)
            {
                Color C = WinBitmap.GetPixel(X, Y);
                int Value = (C.R + C.G + C.B) / 3;
                WinBitmap.SetPixel(X, Y, Color.FromArgb(Value, Value, Value));
            } // End for
        } // End for

but this is rather slow compared.

Answer 2

I found a function how do this in this address

How to convert a colour image to grayscale

public Bitmap ConvertToGrayscale(Bitmap source)
{
  Bitmap bm = new Bitmap(source.Width,source.Height);
  for(int y=0;y<bm.Height;y++)
  {
    for(int x=0;x<bm.Width;x++)
    {
      Color c=source.GetPixel(x,y);
      int luma = (int)(c.R*0.3 + c.G*0.59+ c.B*0.11);
      bm.SetPixel(x,y,Color.FromArgb(luma,luma,luma));
    }
  }
  return bm;
}

Answer 3

We have an imaging component which facilitates application of numerous "effects", including simple color manipulations - it is considerably quicker to simply apply a color transformation matrix than manually walking pixel-by-pixel, like so, for example...

private static ColorMatrix GrayscaleMatrix = new ColorMatrix(
    new float[][]
    {
        new float[] {0.30f, 0.30f, 0.30f, 0, 0},
        new float[] {0.59f, 0.59f, 0.59f, 0, 0},
        new float[] {0.11f, 0.11f, 0.11f, 0, 0},
        new float[] {0, 0, 0, 1, 0},
        new float[] {0, 0, 0, 0, 1}
    }
);

public static void ApplyGrayscaleTransformation(string inputPath, string outputPath)
{
    using (var image = Bitmap.FromFile(inputPath))
    {
        using (var graphics = Graphics.FromImage(image))
        {
            using (var attributes = new ImageAttributes())
            {
                attributes.SetColorMatrix(GrayscaleMatrix);
                graphics.DrawImage(image, 
                    new Rectangle(0,0,image.Width, image.Height), 
                    0, 0, image.Width, image.Height, GraphicsUnit.Pixel, 
                    attributes);
            }
        }
        image.Save(outputPath);
    }
}

The speed between this and unsafe methods are mostly negligible but can vary; it's worth testing cases when it gets to that point - one benefit is not having to compile with /unsafe.

Answer 4

There are many links in google

like

https://web.archive.org/web/20110219113117/http://www.switchonthecode.com/tutorials/csharp-tutorial-convert-a-color-image-to-grayscale (WebArchive for broken link)

or

https://web.archive.org/web/20120707003826/http://www.dreamincode.net/code/snippet2570.htm (WebArchive for broken link)