So Ändern Sie die Pixelfarbe des Bildes in C#.NET

Bevor wir darüber reden, perfromance lassen Sie uns überprüfen Sie Ihren code:

var originalColor = scrBitmap.GetPixel(i, j);
if (originalColor = Color.Black)
    newBitmap.SetPixel(i, j, Color.Red);

Hier gibt es zwei Fehler:

1. Sie nicht vergleichen Color.Black aber Sie zuweisen Color.Black zu originalColor.
2. Sie nicht behandeln Transparenz.

Prüfen für Transparenz Sie sollten sich nicht vergleichen die Color - Objekt, aber der R -, G -, B-Werte, ändern wir zu:

var originalColor = scrBitmap.GetPixel(i, j);
if (originalColor.R == 0 && originalColor.G == 0 && originalColor.B == 0)
    newBitmap.SetPixel(i, j, Color.FromArgb(originalColor.A, Color.Red));

Nun wirst du sehen, dass es funktioniert, aber es dauert eine sehr lange Zeit zum verarbeiten jedes Bild: GetPixel und SetPixel sind ziemlich langsam (primär, weil Sie prüfen und berechnen alles für jeden Anruf). Es ist viel besser zu handhaben bitmap-Daten direkt. Wenn Sie wissen, dass das Bild-format im Voraus (und es ist behoben, die für jedes Bild) dann kann man es viel viel schneller mit etwas mehr code:

static unsafe Bitmap ReplaceColor(Bitmap source,
                                  Color toReplace,
                                  Color replacement)
{
  const int pixelSize = 4; //32 bits per pixel

  Bitmap target = new Bitmap(
    source.Width,
    source.Height,
    PixelFormat.Format32bppArgb);

  BitmapData sourceData = null, targetData = null;

  try
  {
    sourceData = source.LockBits(
      new Rectangle(0, 0, source.Width, source.Height),
      ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

    targetData = target.LockBits(
      new Rectangle(0, 0, target.Width, target.Height),
      ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

    for (int y = 0; y < source.Height; ++y)
    {
      byte* sourceRow = (byte*)sourceData.Scan0 + (y * sourceData.Stride);
      byte* targetRow = (byte*)targetData.Scan0 + (y * targetData.Stride);

      for (int x = 0; x < source.Width; ++x)
      {
        byte b = sourceRow[x * pixelSize + 0];
        byte g = sourceRow[x * pixelSize + 1];
        byte r = sourceRow[x * pixelSize + 2];
        byte a = sourceRow[x * pixelSize + 3];

        if (toReplace.R == r && toReplace.G == g && toReplace.B == b)
        {
          r = replacement.R;
          g = replacement.G;
          b = replacement.B;
        }

        targetRow[x * pixelSize + 0] = b;
        targetRow[x * pixelSize + 1] = g;
        targetRow[x * pixelSize + 2] = r;
        targetRow[x * pixelSize + 3] = a;
      }
    }
  }
  finally
  {
    if (sourceData != null)
      source.UnlockBits(sourceData);

    if (targetData != null)
      target.UnlockBits(targetData);
  }

  return target;
}

Natürlich kann man das weiter optimiert und Sie müssen, um die Handhabung der verschiedenen Formate ( siehe diese Liste von pixel-Formate und dieser Artikel über das layout), aber betrachten Sie es als Ausgangspunkt für die Arbeit mit bitmaps.

Vollständigkeit dies entspricht Farbe ohne direkten Zugriff auf die bitmap-Daten. Bitte beachten Sie, dass dies nur selten verwendet, da es furchtbar langsam.

static Bitmap ReplaceColor(Bitmap source,
                           Color toReplace,
                           Color replacement)
{
    var target = new Bitmap(source.Width, source.Height);

    for (int x = 0; x < source.Width; ++x)
    {
        for (int y = 0; y < source.Height; ++y)
        {
            var color = source.GetPixel(x, y);
            target.SetPixel(x, y, color == toReplace ? replacement : color);
        }
    }

    return target;
}

Bitte beachten Sie auch, dass diese überlegen, alpha-Kanal im Vergleich (also 50% grün-transparent, zum Beispiel, ist nicht die gleiche Farbe wie 30% grün-transparent). Ignorieren alpha-Sie können Sie etwas wie dies:

if (color.R == toReplace.R && color.G == toReplace.G && color.B == toReplace.B)

Schließlich, wenn Sie wissen, dass die Pixel zu ersetzen, sind wenig Sie können eine raw-Kopie der original-Bild (mit Graphics.FromImage einen Kontext schaffen, und zeichnen es in source bitmap), so werden Sie rufen SetPixel() nur, wenn es ist ein Ersatz. IMO der Optimierung ist hier ziemlich nutzlos: wenn Sie Leistung verwenden erste Lösung...

InformationsquelleAutor der Antwort Adriano Repetti

Werde ich Ihnen eine andere Lösung, da diese nicht berechnen für jedes pixel.

Seine kurze und einfache. Konvertieren Zeit 62 ms:

public Bitmap Color(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 color you want ColorMatrix
            //now is set to red, but with different values 
            //you can get anything you want.
            ColorMatrix colorMatrix = new ColorMatrix(
                new float[][]
                {

                    new float[] {1f, .0f, .0f, 0, 0},
                    new float[] {1f, .0f, .0f, 0, 0},
                    new float[] {1f, .0f, .0f, 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 original image on the new image using the color matrix
            g.DrawImage(original, new Rectangle(0, 0, original.Width, original.Height),
                0, 0, original.Width, original.Height, GraphicsUnit.Pixel, attributes);

            //release sources used
            g.Dispose();
            return newBitmap;
        }

InformationsquelleAutor der Antwort Nicholas