Enregistrer l'image bitmap en niveaux de gris d'image en C#

Question

Ceci est mon code bitmap

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

Comment puis-je enregistrer comme une image en niveaux de gris?

Eh bien je suis particulièrement intéressé par la partie épargne. Comment puis-je l'enregistrer en tant que fichier?

Answer 1

Il y a beaucoup de liens dans google

comme

https://web.archive.org/web/20110219113117/http://www.switchonthecode.com/tutorials/csharp-tutorial-convert-a-color-image-to-grayscale (WebArchive pour le lien cassé)

ou

https://web.archive.org/web/20120707003826/http://www.dreamincode.net/code/snippet2570.htm (WebArchive pour le lien cassé)

Answer 2

J'ai utilisé une méthode similaire à celle avant

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

par exemple:

  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 

résumé Fondamentalement, les valeurs composantes RVB pour le pixel donné et diviser par 3. Cela exige dangereux mot-clé qui est requis pour les opérations utilisant des pointeurs. Vous pouvez éviter d'utiliser des pointeurs et simplement faire quelque chose comme ceci:

 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 

mais cela est lent par rapport plutôt.

Answer 3

Je trouve une fonction comment le faire dans cette adresse

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 4

Nous avons une composante d'imagerie qui facilite l'application de nombreux « effets », y compris des manipulations simples de couleur - il est beaucoup plus rapide d'appliquer simplement une matrice de transformation de couleur que la marche manuellement pixel par pixel, comme ainsi, par exemple ...

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); 
    } 
} 

La vitesse entre ceci et unsafe méthodes sont souvent négligeables, mais peut varier; il vaut la peine de tester des cas quand cela arrive à ce point - un avantage n'est pas d'avoir à compiler avec /unsafe.