Comparer deux images python

Version imprimable

23/04/2015, 16h18
luclucdu38

Comparer deux images python

Bonjour à tous,

j'ai beau chercher sur internet, rien a faire, je ne trouve pas ou comprend pas comment comparer deux images. En tout cas comme j'en ai besoin.

Je voudrais créer une fonction('Image.png') qui prend une capture d'écran puis compare avec celle de la base de donnée. Pas de problème pour la capture d'écran...

L'image chargé peut être très petite, 10px par 10px comme 500px par 500px. Il faudrait que ma fonction me retourne une réponse positive si cette petite image est présente dans la capture d'écran (donc dans la grande) mais ça peut être n'importe ou dans cette screenshot. Et une réponse négative si celle-ci n'est pas présente bien sûr.

Je recherche de l'aide car cela fait 1 semaine que je nages littéralement dedans... je suis débutant en python donc mollo les explications svp les gens :mrgreen: pas trop technique si vous voyez ce que je vais dire.

je vous remercie d'avance

luc
23/04/2015, 20h18
wiztricks

Salut,

Comparer 2 images est d'abord une question d'algorithme.
Lorsque vous aurez les idées plus claires sur "comment" faire cette comparaison, il sera temps de voir comment coder cela avec Python (ou un autre langage).
Et les personnes qui vous permettront de définir un algorithme qui tienne la route fréquentent plutôt le forum "Algo".
Bon courage,

- W
23/04/2015, 20h25
luclucdu38

Merci, je vais voir la-bas parce que en fait j'avais pensé à comparer pixel par pixel mais j'ai vite abandonné vue comment c'est long et pas efficace. En cherchant sur internet certaines personnes dises qu'il existe des algorithmes de comparaison pixel par pixel rapide mais je trouve pas et je n'ai pas idée de comment ils font...

Je ne connais pas le forum, je suis nouveau.
24/04/2015, 15h58
Flodelarab

Bonjour,

apparemment, tu cherches une égalité stricte. Donc la recherche pixel par pixel n'est pas mauvaise en elle-même. Mais il ne faut pas comparer tous les pixels quand il y en a déjà un qui diffère...

De la même façon, ce qui peut devenir infiniment long, c'est de vouloir récupérer les pixels un a un par une méthode getPixel(), lente. Alors que d'autres méthodes te mettent, en 1 seule fois, ton bout d'image dans un tampon (buffer) dans lequel tu travailles très vite.

[dernierrecours] Ensuite, des images identiques ont probablement des sommes identiques ou valeurs moyennes identiques, écarts-type identiques, etc... Donc pour rejeter une possibilité, il suffit qu'une fonction comme celles citées, déjà implémentée et super rapide te donne un résultat pour trancher. [/dernierrecours]

j'ai réussit avec une moyenne de gris pour chaque pixel.

La grande image est couper en lamelles qui correspondes à 1 pixel de haut. Cet lamelle est comparé avec la première lamelle de la petite image. Si la petite est comprise dans la grande alors on passe à la suivant. Sinon on recommence à la lamelle suivante.

Voici le code :

Code:

1
2
3
 
from PIL import Image, ImageGrab
from os import chdir

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
# Compare deux listes (l'une dans l'autre) -------------------------------------
 
def compare_liste(grande,petite):
 
    presence = 0
 
    difference = len(grande)-len(petite)
 
    for n in range(difference):
 
        if grande[n:n+len(petite)] == petite :
            presence = 1
            break
 
    return presence

Code:

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
52
53
54
55
56
57
 
# Compare ligne par ligne sous forme de liste ----------------------------------
 
def compare_image(w):
 
    # Variables / Listes -------------------------------------------------------
 
    compteur = 0
    variable = 0
    ecart = 0
 
    # Images -------------------------------------------------------------------
 
    chdir('Images')
 
    screen = ImageGrab.grab() # Screen tout l'ecran (ou une partie de l'ecran)
    taille_screen = screen.size
 
    image = Image.open(w)
    taille_image = image.size
 
    # Capture d'ecran ----------------------------------------------------------
 
    for y in range (taille_screen[1]):
 
        # Reset des listes -----------------------------------------------------
 
        L_screen = []
        L_image = []
 
        # Cree la grande liste -------------------------------------------------
 
        for x in range (taille_screen[0]):
 
            ps = screen.getpixel((x,y))
            L_screen.append(int((ps[0]+ps[1]+ps[2])/3))
 
        # Cree la petite liste -------------------------------------------------
 
        for x in range (taille_image[0]):
 
            ps = image.getpixel((x,y-ecart))
            L_image.append(int((ps[0]+ps[1]+ps[2])/3))
 
        # Compare ligne par ligne ----------------------------------------------
 
        if compare_liste(L_screen,L_image) == 1 :
            compteur = compteur + 1
 
            if compteur == taille_image[1]:
                variable = 1
                break
 
        else :
            ecart = ecart + 1
 
    return variable

La fonction compare_image('photo.png') :

Renvoie "1" si la photo est comprise dans l'écran, le screen.
Renvoie "0" si la photo n'est pas comprise dans l'écran, le screen.

Le temps de traitement est maximum 10 secondes pour une petite photo de 100 par 100.

Citation:

De la même façon, ce qui peut devenir infiniment long, c'est de vouloir récupérer les pixels un a un par une méthode getPixel(), lente. Alors que d'autres méthodes te mettent, en 1 seule fois, ton bout d'image dans un tampon (buffer) dans lequel tu travailles très vite.

Il faudrait que mon temps de traitement soit <1 seconde voir <0.5 secondes pour le top du top.
ton histoire de buffer m'intéresse mais je ne vois pas comment je peux l'utiliser.

Apres modifications, j'ai réussit à faire mieux :

La fonction renvoie 'True',x_milieu,y_milieu si l'image est trouvé dans le champs de recherche allant de x1,y1,x2,y2. Par défaut, si les 4 dernières variables ne sont pas entrées, la fonction fait la recherche dans tout l'écran.

La fonction renvoie 'False','None','None' si l'image n'est pas présente dans le champs de recherche.

compare_image('image_a_rechercher.png',x1,y1,x2,y2)

Code:

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
 
def compare_image(image_a_rechercher,*arg):
 
    from PIL import ImageGrab
 
    if len(arg) < 4 :
        x1 = 0
        y1 = 0
        x2 = (ImageGrab.grab().size)[0]
        y2 = (ImageGrab.grab().size)[1]
 
    else :
        x1 = arg[0]
        y1 = arg[1]
        x2 = arg[2]
        y2 = arg[3]
 
    # Variables / Listes -------------------------------------------------------
 
    variable = 'False'
    compteur = 0
    ecart = 0
    dernier = 0
    presence = 0
 
    # Images -------------------------------------------------------------------
    try :
        chdir('Images')
    except:
        int() # Ne fait rien
 
    from PIL import Image
 
    image = Image.open(image_a_rechercher)
    taille_image = image.size
 
    screen = ImageGrab.grab()
    taille_screen = screen.size
 
    # Capture d'ecran ----------------------------------------------------------
 
    for y in range (y1,y2):
        if variable == 'True' : break
 
        # Reset des listes -----------------------------------------------------
 
        L_screen = []
        L_image = []
        presence = 0
 
        # Cree la grande liste -------------------------------------------------
 
        for x in range (x1,x2):
 
            ps = screen.getpixel((x,y))
            L_screen.append(int((ps[0]+ps[1]+ps[2])/3))
 
        # Cree la petite liste -------------------------------------------------
 
        for x in range (taille_image[0]):
 
            ps = image.getpixel((x,y-ecart-y1))
            L_image.append(int((ps[0]+ps[1]+ps[2])/3))
 
        # Compare ligne par ligne ----------------------------------------------
 
        difference = len(L_screen)-len(L_image)
 
        for n in range(difference):
 
            if L_screen[n:n+len(L_image)] == L_image :
                presence = 1
                break
 
        # Compte les lignes ----------------------------------------------------
 
        if presence == 1 :
            compteur = compteur + 1
 
            if compteur == taille_image[1]:
                variable = 'True'
                break
 
        else :
            if compteur != 0 :
                ecart = y-y1
                compteur = 0
 
            else :
                ecart = ecart + 1
 
    # Sortie de recherche ------------------------------------------------------
 
    if variable == 'False' :
 
        x_milieu, y_milieu = 'None','None'
 
    else :
 
        x_milieu = int(n+taille_image[0]/2)+x1
        y_milieu = int(y-taille_image[1]/2)
 
    return variable, x_milieu, y_milieu

Si quelqu'un trouve une technique plus rapide, je suis preneur.