Wie kann man Bildobjekte mit C# .NET vergleichen?

Question

Können wir zwei Image Objekte mit C#? Prüfen Sie zum Beispiel, ob sie gleich sind, oder noch besser, wie ähnlich ihre Pixel sind?

wenn möglich, wie?

Answer 1

Sie können eine Reihe von Werkzeugen verwenden, die TestApi die eine Open-Source-Bibliothek zur Unterstützung von Unit-Tests ist. Eine dieser APIs heißt Visuelle Verifizierung API und es tut genau das, was Sie brauchen - es kann zwei Bilder vergleichen und Ihnen sagen, ob sie gleich sind:

// 1. Capture the actual pixels from a given window
Snapshot actual = Snapshot.FromRectangle(new Rectangle(0, 0, 100, 100));

// 2. Load the reference/master data from a previously saved file
Snapshot expected = Snapshot.FromFile("Expected.png"));

// 3. Compare the actual image with the master image
//    This operation creates a difference image. Any regions which are identical in 
//    the actual and master images appear as black. Areas with significant 
//    differences are shown in other colors.
Snapshot difference = actual.CompareTo(expected);

// 4. Configure the snapshot verifier - It expects a black image with zero tolerances
SnapshotVerifier v = new SnapshotColorVerifier(Color.Black, new ColorDifference());

// 5. Evaluate the difference image
if (v.Verify(difference) == VerificationResult.Fail)
{
    // Log failure, and save the diff file for investigation
    actual.ToFile("Actual.png", ImageFormat.Png);
    difference.ToFile("Difference.png", ImageFormat.Png);
}

Answer 2

Am einfachsten wäre es, mit den Abmessungen zu beginnen. Wenn die Abmessungen nicht gleich sind, können Sie sie möglicherweise für falsch erklären.

Wenn Sie sie Pixel für Pixel durchgehen müssen, benötigen Sie zwei for-Schleifen. Etwas entlang dieser Linien:

Bitmap ImageA...
Bitmap ImageB...

for ( Int64 x = 0; x < ImageA.Width; x++ )
{
     for ( Int64 y = 0; y < ImageA.Height; y++ )
     {
         if ( ImageA.GetPixel(x, y) != ImageB.GetPixel(x, y) )
         {
            return false;
         }
     }
}

Es ist Pseudocode (die Funktionen existieren in C#, obwohl ich mich im Moment nicht daran erinnern kann) und sehr vereinfacht, aber es ist, wie Sie eine grundlegende Pixel-zu-Pixel-Prüfung durchführen möchten.

Damit diese Schleife funktioniert, müssen die Bilder jedoch die gleichen Abmessungen haben. Wenn dies nicht der Fall ist, kommt es wahrscheinlich zu Ausnahmen, wenn Sie versuchen, ein Pixel außerhalb des Bereichs des kleineren Bildes abzutasten. Außerdem ist der Vergleich der Pixel nicht sehr schnell, so dass Sie vielleicht zuerst einen anderen Weg finden sollten, um mögliche Duplikate auszusortieren.

Edit: Ich bin mir nicht sicher, wie man das auf einem Image aber es ist ganz einfach für Bitmap s. Es gibt keine sichtbare Möglichkeit, Bildpixeldaten aus der Klasse herauszuholen. Es scheint die Bitmaps erben von Images, obwohl, so kann dies noch funktionieren. Da Images eine abstrakte Klasse sowohl für Bitmaps als auch für Metafiles ist, haben sie möglicherweise keine einfache interne Pixelliste.

Answer 3

Ich hatte die gleiche Frage an diesem Tag, mein Workaround war es, image1 und image2 konvertiert zu 256x256 oder 128x128 beide übersetzt UND dann erzeugen ein image3 mit der Differenz zwischen ihnen, dann scannen image3 Überprüfung der Unterschiede und die Rückgabe der Differenz Betrag, fand ich heraus, dass die LOWER Differenz Betrag in % mehr gleich die Bilder sind und mehr wahrscheinlich für sie gleich zu sein. Auf diese Weise können Sie identifizieren, wenn Bilder gleich sind, auch wenn sie unterschiedlich groß sind. hier ist der Code.

double CompareImages(Bitmap InputImage1, Bitmap InputImage2, int Tollerance)
    {
        Bitmap Image1 = new Bitmap(InputImage1, new Size(128, 128));
        Bitmap Image2 = new Bitmap(InputImage2, new Size(128, 128));
        int Image1Size = Image1.Width * Image1.Height;
        int Image2Size = Image2.Width * Image2.Height;
        Bitmap Image3;
        if (Image1Size > Image2Size)
        {
            Image1 = new Bitmap(Image1, Image2.Size);
            Image3 = new Bitmap(Image2.Width, Image2.Height);
        }
        else
        {
            Image1 = new Bitmap(Image1, Image2.Size);
            Image3 = new Bitmap(Image2.Width, Image2.Height);
        }
        for (int x = 0; x < Image1.Width; x++)
        {
            for (int y = 0; y < Image1.Height; y++)
            {
                Color Color1 = Image1.GetPixel(x, y);
                Color Color2 = Image2.GetPixel(x, y);
                int r = Color1.R > Color2.R ? Color1.R - Color2.R : Color2.R - Color1.R;
                int g = Color1.G > Color2.G ? Color1.G - Color2.G : Color2.G - Color1.G;
                int b = Color1.B > Color2.B ? Color1.B - Color2.B : Color2.B - Color1.B;
                Image3.SetPixel(x, y, Color.FromArgb(r,g,b));
            }
        }
        int Difference = 0;
        for (int x = 0; x < Image1.Width; x++)
        {
            for (int y = 0; y < Image1.Height; y++)
            {
                Color Color1 = Image3.GetPixel(x, y);
                int Media = (Color1.R + Color1.G + Color1.B) / 3;
                if (Media > Tollerance)
                    Difference++;
            }
        }
        double UsedSize = Image1Size > Image2Size ? Image2Size : Image1Size;
        double result = Difference*100/UsedSize;
        return Difference*100/UsedSize;
    }

Hier getestet mit über 900 Bildern und es funktioniert wie ein Zauber x)