Comment comparer les objets Image avec C # .NET?

Peut-on comparer les deux Image objets avec C#? Par exemple, vérifiez si elles sont égales, ou même mieux de vérifier la similitude de leurs pixels?

si possible, comment?

source d'informationauteur Louis Rhys

  1. 12

    Vous pouvez utiliser un ensemble d'outils appelé TestApiqui est un open-source de la bibliothèque à l'aide de tests unitaires. L'un de ces API est appelée Vérification visuelle de l'APIet c'est exactement ce dont vous avez besoin - il permet de comparer deux images et vous dire s'ils sont égaux:

    //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);
}
  2. 4

    Le plus simple endroit pour commencer serait dimensions. Si les dimensions ne sont pas les mêmes, vous pouvez être en mesure de les déclarer faux.

    Si vous avez besoin d'aller à travers eux, pixel par pixel, vous aurez besoin de deux boucles for. Quelque chose le long de ces lignes:

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

    Pseudo-code (les fonctions existent dans C#, bien que je ne me souviens pas pour le moment) et très simpliste, mais est la façon dont vous voulez effectuer une base de pixel-à-pixel case.

    Noter, cependant, pour que la boucle pour travailler les images doivent être de mêmes dimensions. Si ils ne le sont pas, vous êtes susceptible d'avoir des exceptions si vous essayez un échantillon d'un pixel à l'extérieur de la plus petite zone. Elle aussi ne sera pas terriblement rapide pour comparer les pixels, de sorte que vous voudrez peut-être trouver un autre moyen que de les jeter possible les doublons en premier.

    Edit: je ne suis pas sûr de la façon de faire cela sur une Imagemais c'est assez simple pour Bitmaps. Il n'y a pas une manière visible de l'obtention de pixel de l'Image des données en dehors de la classe. Il semble que les Bitmaps hériter d'Images, bien que, si cela peut encore travailler. Étant donné que les Images sont une classe abstraite pour les deux images et des Métafichiers, ils ne peuvent pas avoir un simple internes liste des pixels.

  3. 1

    J'ai eu la même question ce jour-là, ma solution est de prendre image1 et image2 converti à 256x256 ou 128x128 traduits ET générer ensuite une image3 avec la différence entre eux, et d'analyser ensuite image3 de vérifier les différences et en retournant le montant de la différence, j'ai découvert que la réduction du montant de la différence en%, plus égalitaire, les images et sont plus susceptibles d'être de l'égalité. De cette façon, vous pouvez identifier si les images sont égaux, même s'ils sont de taille différente. voici le 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;
}

    Testé ici avec plus de 900 images et il fonctionne comme un charme x)