comparer 2 images

**ac/dc** · 20/04/2007, 19h27

Bonjour, je souhaite comparer 2 images BMP ou JPG pour savoir si c'est les meme. Ces 2 images sont toujours des print screen. merci de votre aide si vous avez la r�ponse !

**rtg57** · 20/04/2007, 19h47

Bonjour,

peux-tu �tre plus pr�cis: s'agit-il d'un comparatif entre une image en format BMP et la m�me image mais en format JPG ?
Ou s'agit-il plus simplement d'un comparatif entre 2 images BMP ou 2 images JPG ?

**ac/dc** · 20/04/2007, 20h05

oui oui c'est bien des images de meme type !

**rtg57** · 20/04/2007, 20h21

Bonjour,

� premi�re vue, je dirais que l'utilisation d'une scrutation pixel par pixel des bitmaps pourrait �tre la solution.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
  for( y = hauteur_bitmap; y >= 0; y-- )
  {
    for( x = largeur_bitmap; x >= 0; x-- )
    {
      Couleur_bmp1 = MonBitmap1->Canvas->Pixels[x][y];
      Couleur_bmp2 = MonBitmap2->Canvas->Pixels[x][y];
 
      if( Couleur_bmp1 <> Couleur_bmp2 )
      {
        // Pas pareil...
        break;
      }
    }
  }

Pour �viter du traitement superflu, il faudrait d�j� comparer les hauteurs et largeurs des 2 bitmaps. Si d�j� l� c'est diff�rent, alors c'est pas la peine de continuer.

**ac/dc** · 20/04/2007, 21h04

ouai c cool ce code fonctionne mais il ni aurait pas une methode plus rapide ? c'est extrement lent ....

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Graphics::TBitmap *Bitmap1 = new Graphics::TBitmap;
Graphics::TBitmap *Bitmap2 = new Graphics::TBitmap;
Bitmap1->LoadFromFile("1.BMP");
Bitmap2->LoadFromFile("2.BMP");
 
for(int y = 0; y <= Bitmap1->Height; y++)
  for(int x = 0; x <= Bitmap2->Width; x++)
      if(Bitmap1->Canvas->Pixels[x][y] != Bitmap2->Canvas->Pixels[x][y])
      {
          ShowMessage("Les images ne sont pas identiques !");
          return;
      }
ShowMessage("Les images sont identiques");

**rtg57** · 21/04/2007, 12h15

Pour l'instant, je gal�re comme toi.
Je cherche � 'ombrer' une zone d'un bitmap en fonction d'un second bitmap situ� au-dessus du premier.
Je n'ai pas trouv� de syst�me pour bidouiller les octets m�moire contenant l'image.
Pourtant cela doit exister mais il faut que je trouve le moyen d'acc�der aux pixels d'une fa�on plus globale qu'� travers la m�thode Pixel[x][y].
J'en viens � regretter le temps de mon ATARI 1040 ST avec lequel on acc�dait directement � la m�moire vid�o

**ac/dc** · 21/04/2007, 13h18

j'ai vu qu'il fallait utiliser ScanLine de TBitmap pour accelerer le travail mais j'arrive pas � l'utiliser pour comparer mes pixels ......

**henderson** · 21/04/2007, 13h53

Salut !

Pixels[X][Y] est efficace pour toutes les d�finitions de bitmap.

ScanLine[Y] peut �tre utilis� sur des bitmaps 24 bit, mais pose un s�rieux probl�me pour la comparaison de deux bitmaps 8 bit du fait qu'on compare des index de couleurs et non les couleurs elles-m�mes.

Pour des bitmaps 24 bit, avec ScanLine[Y], il suffit de comparer les composantes pour chaque pixel. Il faudrait voir si on a int�r�t � remplacer 3 tests par un seul test (avec COLORREF obtenu � l'aide de RGB)...

A plus !

**henderson** · 21/04/2007, 13h57

Salut !

J'en viens � regretter le temps de mon ATARI 1040 ST avec lequel on acc�dait directement � la m�moire vid�o

Moi aussi mais on y arrive quand m�me avec un PC !

A plus !

**ac/dc** · 21/04/2007, 15h28

alors comment c'est possible de comparer 2 images tr�s rapidement ?

**henderson** · 21/04/2007, 16h11

Salut !

Par exemple, en faisant ainsi :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void __fastcall TForm1::SpeedButton1Click(TObject *Sender)
{
Graphics::TBitmap *B1 = Image1->Picture->Bitmap;
B1->PixelFormat = pf24bit;
Graphics::TBitmap *B2 = Image2->Picture->Bitmap;
B2->PixelFormat = pf24bit;
Byte *P1;
Byte *P2;
if((B1->Width == B2->Width) && (B1->Height == B2->Height))
    {
    for(int y = 0; y < B1->Height; y++)
        {
 
        P1 = (Byte*)B1->ScanLine[y];
        P2 = (Byte*)B2->ScanLine[y];
 
        for(int x = 0; x < B1->Width; x++)
            {
            if((P1[0] != P2[0]) || (P1[1] != P2[1]) || (P1[2] != P2[2])) return;
            P1 = P1 + 3;
            P2 = P2 + 3;
            }
        }
    ShowMessage("Identiques");
    }
}

A plus !

**henderson** · 21/04/2007, 16h45

Salut !

Sinon, pour aller encore plus vite on peut d�velopper autrement.

On sait qu'ici on perd du temps � tester Byte par Byte, pour ce qui est des composantes.
Cette organisation par triplets n'est d'ailleurs qu'anecdotique vis � vis du traitement que l'on cherche � effectuer ici !

L'id�e est de mettre en place un algo qui va proc�der par granulations successives.
C'est � dire commencer par traiter des int puis des short (s'il en reste) puis un Byte s'il en reste un !

Je ne sais pas si tu me suis ?

"If You Want Blood..."

� plus !

**ac/dc** · 21/04/2007, 17h03

Salut, je vais d'abord voir ce code .... je verrais ensuite pour faire plus rapidement si je peux, car je suis pas sur d'avoir tout compris mais ce code m'aidera peut �tre ! merci ... ("If you want blood, you've got it")

**ac/dc** · 21/04/2007, 17h34

ou� c'est cool �a fonctionne ... des questions tout de meme: Pourquoi on incr�mente P1 et P2 dans la boucle de x ? P1[0], P1[1], P1[2] sont les couleurs RVB ? merci !

**henderson** · 21/04/2007, 18h03

Salut !

Voici ce qui tourne (au moins) deux fois plus vite que ce que j'ai donn� pr�c�demment :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
void __fastcall TForm1::SpeedButton2Click(TObject *Sender)
{
Graphics::TBitmap *Bmp1 = Image1->Picture->Bitmap;
Bmp1->PixelFormat = pf24bit;
Graphics::TBitmap *Bmp2 = Image2->Picture->Bitmap;
Bmp2->PixelFormat = pf24bit;
int *I1; short *S1; Byte *B1;
int *I2; short *S2; Byte *B2;
int nbInt;
int nbByte;
int nbShort;
 
if((Bmp1->Width == Bmp2->Width) && (Bmp1->Height == Bmp2->Height))
    {
    nbInt = Bmp1->Width * 3;
    nbByte = nbInt & 1;
    nbInt = nbInt / 2;
    nbShort = nbInt & 1;
    nbInt = nbInt / 2;
 
    for(int y = 0; y < Bmp1->Height; y++)
        {
        I1 = (int*)Bmp1->ScanLine[y];
        I2 = (int*)Bmp2->ScanLine[y];
 
        for(int x = 0; x < nbInt; x++)
            {
            if(*I1 != *I2) return;
            I1++;
            I2++;
            }
        //Changement de granularité pour la suite
        S1 = (short*)I1;
        S2 = (short*)I2;
        if(nbShort)
            {
            if(*S1 != *S2) return;
            S1++;
            S2++;
            }
        //Changement de granularité pour la suite
        if(nbByte)
            {
            B1 = (Byte*)S1;
            B2 = (Byte*)S2;
            if(*B1 != *B2) return;
            }
        }
    ShowMessage("Identiques");
    }
}

Pour les questions :
On y fait P + 3 � cause des composantes (RGB), x ne compte que les pixels !

A plus !

**ac/dc** · 22/04/2007, 19h32

jte remercie beaucoup pour ce code, m�me si j'ai pas tout compris .... Je voudrais quand meme quelques explications pour comprendre.
Ce que j'ai compris :

Pour toutes les lignes de pixel de l'image
- Fais pointer P1 sur chaque ligne
- Pour tous les pixels de la ligne
- P1[0] contient le rouge; P1[1] le vert et P1[2] le bleu
- Increment de P1 pour passer au pixel suivant

????

**OliverSleep** · 22/04/2007, 20h24

Salut,

moi je viserai plus sur le syst�me de comparaison de Bytes.
J'avais cod� un bout d'appli de comparaison d'images/fichiers rapidement.
En fait je calculais le MD5 du fichier (logiquement unique � chaque fichier...) et il te suffit alors de comparer ce MD5 de chaque fichiers entre eux.

Voil�, si tu cherches des sources de MD5 pour fichier, je pourrai te filer un lien.

+++

**henderson** · 22/04/2007, 23h36

Salut !

Chez moi l'ordre des composantes c'est :

P[0] Blue
P[1] Green
P[2] Red

J'ai corrig� l'erreur dans une autre r�ponse d'une autre discussion (niveau de gris).

Pour le pointeur, on est bien oblig� de faire + 3 puisque la boucle traite des triplets d'octets (1 pixel = 3 octets) et que le pointeur pointeur sur le type Byte.
La boucle x ne fait que d�compter les pixels.

A plus !