c# - Convierte una imagen a escala de grises

image-processing bitmap

Question

¿Hay alguna forma de convertir una imagen a escala de grises en 16 píxeles por formato de bit, en lugar de configurar cada uno de los componentes r, g y b en la luminancia? Actualmente tengo un bmp del archivo.

Bitmap c = new Bitmap("filename");

Quiero un mapa de bits d, que es una versión en escala de grises de c. Veo un constructor que incluye System.Drawing.Imaging.PixelFormat, pero no entiendo cómo usarlo. Soy nuevo en el procesamiento de imágenes y en las bibliotecas relevantes de C #, pero tengo una experiencia moderada con C #.

Cualquier ayuda, referencia a una fuente en línea, pista o sugerencia será apreciada.

Gracias.

EDITAR: d es la versión en escala de grises de c.

Answer 1

"Quiero un mapa de bits d, que sea en escala de grises. Veo un consructor que incluye System.Drawing.Imaging.PixelFormat, pero no entiendo cómo usarlo".

Aquí está cómo hacer esto

Bitmap grayScaleBP = new 
         System.Drawing.Bitmap(2, 2, System.Drawing.Imaging.PixelFormat.Format16bppGrayScale);

EDITAR: Para convertir a escala de grises

             Bitmap c = new Bitmap("fromFile");
             Bitmap d;
             int x, y;

             // Loop through the images pixels to reset color.
             for (x = 0; x < c.Width; x++)
             {
                 for (y = 0; y < c.Height; y++)
                 {
                     Color pixelColor = c.GetPixel(x, y);
                     Color newColor = Color.FromArgb(pixelColor.R, 0, 0);
                     c.SetPixel(x, y, newColor); // Now greyscale
                 }
             }
            d = c;   // d is grayscale version of c  

Versión más rápida de switchonthecode siga el enlace para un análisis completo:

public static Bitmap MakeGrayscale3(Bitmap original)
{
   //create a blank bitmap the same size as original
   Bitmap newBitmap = new Bitmap(original.Width, original.Height);

   //get a graphics object from the new image
   Graphics g = Graphics.FromImage(newBitmap);

   //create the grayscale ColorMatrix
   ColorMatrix colorMatrix = new ColorMatrix(
      new float[][] 
      {
         new float[] {.3f, .3f, .3f, 0, 0},
         new float[] {.59f, .59f, .59f, 0, 0},
         new float[] {.11f, .11f, .11f, 0, 0},
         new float[] {0, 0, 0, 1, 0},
         new float[] {0, 0, 0, 0, 1}
      });

   //create some image attributes
   ImageAttributes attributes = new ImageAttributes();

   //set the color matrix attribute
   attributes.SetColorMatrix(colorMatrix);

   //draw the original image on the new image
   //using the grayscale color matrix
   g.DrawImage(original, new Rectangle(0, 0, original.Width, original.Height),
      0, 0, original.Width, original.Height, GraphicsUnit.Pixel, attributes);

   //dispose the Graphics object
   g.Dispose();
   return newBitmap;
}

Answer 2

El código a continuación es la solución más simple:

Bitmap bt = new Bitmap("imageFilePath");

for (int y = 0; y < bt.Height; y++)
{
    for (int x = 0; x < bt.Width; x++)
    {
        Color c = bt.GetPixel(x, y);

        int r = c.R;
        int g = c.G;
        int b = c.B;
        int avg = (r + g + b) / 3;
        bt.SetPixel(x, y, Color.FromArgb(avg,avg,avg));
    }   
}

bt.Save("d://out.bmp");

Answer 3

Hay un método estático en la clase ToolStripRenderer , llamado CreateDisabledImage . Su uso es tan simple como:

Bitmap c = new Bitmap("filename");
Image d = ToolStripRenderer.CreateDisabledImage(c);

Utiliza una matriz un poco diferente a la de la respuesta aceptada y, además, la multiplica por una transparencia de valor 0,7, por lo que el efecto es ligeramente diferente de la escala de grises, pero si desea obtener su imagen en gris, es la más simple y mejor solución.

Answer 4

Ninguno de los ejemplos anteriores crea imágenes de mapa de bits de 8 bits (8bpp). Algunos software, como el procesamiento de imágenes, solo son compatibles con 8bpp. Desafortunadamente, las bibliotecas MS .NET no tienen una solución. El formato PixelFormat.Format8bppIndexed parece prometedor, pero después de muchos intentos no pude hacerlo funcionar.

Para crear un verdadero archivo de mapa de bits de 8 bits, debe crear los encabezados adecuados . Finalmente encontré la solución de la biblioteca de escala de grises para crear archivos de mapa de bits de 8 bits (BMP). El código es muy simple:

Image image = Image.FromFile("c:/path/to/image.jpg");
GrayBMP_File.CreateGrayBitmapFile(image, "c:/path/to/8bpp/image.bmp");

El código para este proyecto está lejos de ser bonito, pero funciona, con un pequeño problema fácil de arreglar. El autor codificó la resolución de la imagen a 10x10. A los programas de procesamiento de imágenes no les gusta esto. La solución está abierta GrayBMP_File.cs (sí, nombres de archivos funky, lo sé) y reemplaza las líneas 50 y 51 con el código siguiente. El ejemplo establece la resolución en 200x200 pero debe cambiarla al número correcto.

int resX = 200;
int resY = 200;
// horizontal resolution
Copy_to_Index(DIB_header, BitConverter.GetBytes(resX * 100), 24);
// vertical resolution 
Copy_to_Index(DIB_header, BitConverter.GetBytes(resY * 100), 28);

Answer 5

Para resumir algunos elementos aquí: hay algunas opciones de píxel por píxel que, si bien son simples, no son rápidas.

Comentario de @Luis que enlaza a: (archivado) https://web.archive.org/web/20110827032809/http://www.switchonthecode.com/tutorials/csharp-tutorial-convert-a-color-image-to-grayscale es excelente.

Él analiza tres opciones diferentes e incluye tiempos para cada una.

Answer 6

Bitmap d = new Bitmap(c.Width, c.Height);

for (int i = 0; i < c.Width; i++)
{
    for (int x = 0; x < c.Height; x++)
    {
        Color oc = c.GetPixel(i, x);
        int grayScale = (int)((oc.R * 0.3) + (oc.G * 0.59) + (oc.B * 0.11));
        Color nc = Color.FromArgb(oc.A, grayScale, grayScale, grayScale);
        d.SetPixel(i, x, nc);
    }
}

De esta manera también mantiene el canal alfa.
Disfrutar.