Reconnaissance d'image (forme simple])

**dewey01** · 02/09/2008, 10h51

Bonjour, suite au conseil d'un modo du site, je viens poster ici mes quelques questions.

Pour notre stage, mon partenaire et moi devons devons coder un programme permettant de savoir ou non si il y a une petite forme (double cercle) dans le coin haut de droite d'une page scannée.

L'identification de cette forme permettra de savoir si il faut ou non créer un nouveau document pdf (en effet, le scanner numérise toutes les pages et crée un gros pdf avec le tout, mais l'utilisateur souhaite parfois créer plusieurs pdf).

Étant novice dans ce domaine, on nous a conseiller d'utiliser OpenCV (nous souhaiterions l'utiliser en C), mais voila la doc est vaste et nous ne savons pas trop comment procéder.

Je suis donc à la recherche d'information sur les possibles fonctions utilisable, le bon liens à lire et autre éventuels conseils.

Merci d'avance.

**Vinsss84** · 02/09/2008, 16h41

Pour la detection de cercles va voir du côté de la transformée de Hough et plus particulièrement de la fonction cvHoughCircle.
Par ailleurs vu que tu connais déja en partie la position de tes cercles sur l'image il te faut te restreindre à cette partie (fonction cvSetImageROI) afin d'éviter un maximum de fausses détection.

Si ta marque est vraiment caractéristique (tampon encreur par exemple) tu peux très bien envisager un matching de cette zone avec un template du tampon afin de detecter ou non sa présence. (j'ai personnelement réaliser ça pour une detection de tampons de bibliothèque sur des manuscrits. la fonction a utiliser ici est, dans mes souvenirs la fonction cvMatchWithTemplate.

Attention à l'utilisation d'un bon seuil...
voila

**dewey01** · 02/09/2008, 17h04

Envoyé par Vinsss84

Pour la detection de cercles va voir du côté de la transformée de Hough et plus particulièrement de la fonction cvHoughCircle.

On a tester aujourd'hui, sa bug un petit peu mais on ne connait pas encore bien la lib c'est normale.

Envoyé par Vinsss84

Par ailleurs vu que tu connais déja en partie la position de tes cercles sur l'image il te faut te restreindre à cette partie (fonction cvSetImageROI) afin d'éviter un maximum de fausses détection.

On y avait penser mais on était pas sur que ce soit possible.

Envoyé par Vinsss84

Si ta marque est vraiment caractéristique (tampon encreur par exemple) tu peux très bien envisager un matching de cette zone avec un template du tampon afin de detecter ou non sa présence. (j'ai personnelement réaliser ça pour une detection de tampons de bibliothèque sur des manuscrits. la fonction a utiliser ici est, dans mes souvenirs la fonction cvMatchWithTemplate.

Attention à l'utilisation d'un bon seuil...
voila

La je ne comprend pas tout si tu pouvais me donner quelques explication sur le matching ce serait vraiment cool.

En tout cas merci beaucoup pour la réponse !

**Vinsss84** · 02/09/2008, 17h33

Bien alors, le matching c'est simplement mettre en correspondance deux formes semblables.
En gros tu as d'un côté un fichier image qui contient ton symbole et tu vas aller chercher dans ton image toutes les formes qui sont semblable a celle contenues dans ton template (le petit fichier image contenant ton symbole).
C'est possible uniquement si ton symbole est toujours a peu de chose près semblable.

Pour la ROI c'est très simple à mettre en place.
Bon pour commencer ROI signifie Region of Interest. Ca peut paraître évident mais c'est un terme a connaître.
En pratique il te suffit de définir un rectangle (cvRect) qui aura pour caractéristiques la poistion dans l'image de la zone qui t'interesse.
Typiquement si tu veux le coint haut/gauche, avec un rectangle d'une taille 200x200 pixel tu vas faire :

CvRect roi = cvRect(0,0,200,200);
cvSetImageROI(image,roi);

voilou

**dewey01** · 02/09/2008, 18h03

Merci bien, on va se focaliser dès demain sur la recherche et le fonctionnement des fonctions de matching !

Merci encore

**dewey01** · 03/09/2008, 11h36

Envoyé par Vinsss84

Bien alors, le matching c'est simplement mettre en correspondance deux formes semblables.
En gros tu as d'un côté un fichier image qui contient ton symbole et tu vas aller chercher dans ton image toutes les formes qui sont semblable a celle contenues dans ton template (le petit fichier image contenant ton symbole).
C'est possible uniquement si ton symbole est toujours a peu de chose près semblable.

Question: as-tu des exemple de fonctions qui font du matching, j'ai chercher toute la matinée mais sans succès, l'utilisation de cette fonction n'a pas l'air très courante.

En ce qui concerne la délimitation d'un zone pour la recherche de notre forme, ce ne sera pas possible car il pourra etre n'importe ou sur la page scannée. Du coup, le temps de recherche ne sera pas trop long avec le matching sur une page A4 ?

Merci bien

**Vinsss84** · 03/09/2008, 12h12

le temps de recherche risque en effet d'être long, de l'ordre d'une a deux secondes. mais surtout selon le signe, il risque d'apparaitre un certain nombre de fausses detections. Realiser la recherche sur de version binarisées de la page et du template pourront aider également.

Mon code pour faire ça, non commenté, non expliqué, pas trop le temps la...

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
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
int Tools::Retrait_Tampon(IplImage *src,  CvRect ROI,char *filename)
{
    IplImage * templ_bis = cvLoadImage("bibl.jpg",0);
    //IplImage * templ_bis = cvLoadImage("croix.jpg",0);
    IplImage * templ;
    int n_stamps = 0;
    float rapporthl = 0;
    float rapporthl_fix = 0;
    float coeff_resize;
    rapporthl_fix = 2714./1968.;
    float src_x = cvGetSize(src).width ;
    float src_y = cvGetSize(src).height;
    float templ_x = cvGetSize(templ_bis).width ;
    float templ_y = cvGetSize(templ_bis).height;
    rapporthl = src_y/src_x;
    coeff_resize = rapporthl_fix/rapporthl;
    float seuil;
    seuil = STAMP;
    if (coeff_resize > 1.01 && coeff_resize < 1.5)
    {
        templ = cvCreateImage(cvSize((int)(templ_x/coeff_resize),(int)(templ_y/coeff_resize)),8,src->nChannels);
        cvResize(templ_bis,templ);
        seuil = seuil / (coeff_resize*coeff_resize*coeff_resize);
 
        cvSaveImage("bibl3.jpg",templ);
    }
    else
    {
        templ = cvLoadImage("bibl.jpg",0);
    }
    Tools::Binarization(src,src,3,1);
    Tools::Binarization(templ,templ,3,1);
    //cvSmooth(src,src,2);
    //cvSmooth(templ,templ,2);
    int x = (int)src_x- cvGetSize(templ).width +1;
    int y = (int)src_y - cvGetSize(templ).height +1;
    IplImage * result = cvCreateImage(cvSize(x,y),IPL_DEPTH_32F,1);
    CvRect correct;
    //FILE * stamp;
    //strcat(filename,".dat");
    //stamp = fopen(filename,"w+");
    cvMatchTemplate(src,templ, result, 4 );
 
    double min_val = 0;
    double max_val = 0;
 
    CvPoint max_loc = cvPoint(0,0) ;
    CvPoint min_loc = cvPoint(0,0);
 
    if (ROI.height != 0)
    {
        cvSetImageROI(result,ROI);
    }
 
    cvMinMaxLoc(result,&min_val,&max_val,&min_loc,&max_loc,0);
 
    if ( max_val > seuil)
    {
 
       cvRect(max_loc.x,max_loc.y,cvGetSize(templ).width,cvGetSize(templ).height);
        cvSetImageROI(src,correct);
 
        cvSet(src,cvScalarAll(255),0);
        cvSetImageROI(src,cvRect(0,0,(int)src_x,(int)src_y));
        //cvSmooth(src,src,2);
        //fprintf(stamp,"Tampon : %i\n x : %i \n y : %i \n",n_stamps,max_loc.x,max_loc.y);
 
 
 
    }
    //printf("valeur trouvée : %d \n",n_stamps);
    //fclose(stamp);
    cvReleaseImage(&templ);
    cvReleaseImage(&result);
    cvReleaseImage(&templ_bis);
    return n_stamps;
 
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int Tools::Binarization(IplImage *src, IplImage *bin_img, int window, int smooth)
{
    int err_ind = 0;
    //Smoothing the image in order to reduce noice influence
    if (smooth ==1)
    {
        cvSmooth(src,src,2);
    }
 
     cvAdaptiveThreshold(src,bin_img,255,CV_ADAPTIVE_THRESH_GAUSSIAN_C,CV_THRESH_BINARY,window);
 
 
    return err_ind;
}

**dewey01** · 03/09/2008, 15h48

Il y a pas mal de truc que j'ai du mal a comprendre mais bon c'est normale. Ce que j'ai vraiment du mal a saisir c'est comment tu sais si il a trouver l'objet ou pas, car cvMatchTemplate est une fonction void, elle ne renvois pas 0 ou 1 pour dire si elle a matcher ou pas.
Remplis t-elle une structure ?

Autre question, dans la documentation : http://opencv.jp/opencv_org/docs/ref...gproc_matching, il y a différente méthode, laquelle as tu utilisée et pourquoi ?

Merci pour tout.

**Vinsss84** · 03/09/2008, 15h56

La fonction cvMatchTemplate remplit une matrice/image en 32F qui contient la valeur du critère d'appariement pour chaque point de l'image. Tu utilises ensuite la fonction cvMinmaxLoc pour localiser dans cette image les coordonnées de tes bon résultats

After the function finishes comparison, the best matches can be found as global minimums (CV_TM_SQDIFF*) or maximums (CV_TM_CCORR* and CV_TM_CCOEFF*) using cvMinMaxLoc function. In case of color image and template summation in both numerator and each sum in denominator is done over all the channels (and separate mean values are used for each channel).

Quand a la méthode utilisée je crois que j'ai pris la première que j'ai testé car les resultats etaient bons xD
Cross Correlation Normée il m semble

**dewey01** · 04/09/2008, 10h22

Merci pour les réponses, mais je dois avouer que j'ai beaucoup de mal à comprendre la méthode.

Si jamais tu as le temps de de rentrer plus en détail ou même juste commenter ton code, je t'en serais extrêmement reconnaissant. Mais si tu as pas le temps ce n'est pas grave, tu m'as déjà appris beaucoup de choses.

Un grand merci.

**Vinsss84** · 04/09/2008, 11h32

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
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
int Tools::Retrait_Tampon(IplImage *src,  CvRect ROI,char *filename)
{
//On charge le template : "bibl.jpg", correspondant pour moi a une image de //tampon de bibliothèque
    IplImage * templ_bis = cvLoadImage("bibl.jpg",0);
    IplImage * templ;
 
    int n_stamps = 0;
    float rapporthl = 0;
    float rapporthl_fix = 0;
/*
    float coeff_resize;
    rapporthl_fix = 2714./1968.;
    float src_x = cvGetSize(src).width ;
    float src_y = cvGetSize(src).height;
    float templ_x = cvGetSize(templ_bis).width ;
    float templ_y = cvGetSize(templ_bis).height;
    rapporthl = src_y/src_x;
    coeff_resize = rapporthl_fix/rapporthl;
Partie de code utiliser pour adapter la taille du tampon en fonction de la taille en pixels de l'image (quelques problèmes dans la numérisation de mes 4000 pages :D
*/
 
//Definition du seuil de correlation : ici STAMP = 9000000 (depend de la taille du template a matcher et de la methode utilisée)
    float seuil;
    seuil = STAMP;
 
/* IDem morceau de code pour adapter la taille du template a la taille en pixels de l'image
    if (coeff_resize > 1.01 && coeff_resize < 1.5)
    {
        templ = cvCreateImage(cvSize((int)(templ_x/coeff_resize),(int)(templ_y/coeff_resize)),8,src->nChannels);
        cvResize(templ_bis,templ);
        seuil = seuil / (coeff_resize*coeff_resize*coeff_resize);
 
        cvSaveImage("bibl3.jpg",templ);
    }
    else
    {
        templ = cvLoadImage("bibl.jpg",0);
    }
*/
 
//Binarisation de l'image et du template
    Tools::Binarization(src,src,3,1);
    Tools::Binarization(templ,templ,3,1);
 
//creation de l'image resultat de la bonne taille
 
    int x = (int)src_x- cvGetSize(templ).width +1;
    int y = (int)src_y - cvGetSize(templ).height +1;
 
    IplImage * result = cvCreateImage(cvSize(x,y),IPL_DEPTH_32F,1);
    CvRect correct;
//utilisation de la fonction de match, methode cross cor
    cvMatchTemplate(src,templ, result, 4 );
 
    double min_val = 0;
    double max_val = 0;
 
    CvPoint max_loc = cvPoint(0,0) ;
    CvPoint min_loc = cvPoint(0,0);
 
    if (ROI.height != 0)
    {
        cvSetImageROI(result,ROI);
    }
 
//Recherche avec cvMinMaxLoc de la valeur la plus probable d'être un match positif, test par rapport a la valeur de seuil 
 
    cvMinMaxLoc(result,&min_val,&max_val,&min_loc,&max_loc,0);
 
 
    if ( max_val > seuil)
    {
//si le match est positif je remplace l'endroit du match detecté par un carré blanc, puisque je cherchai a supprimer mes tampons. De ton coté tu peux juste te contenter d'encadrer la zone et d'annoncer que tu as trouvé ce qu'il faut        
         cvRect(max_loc.x,max_loc.y,cvGetSize(templ).width,cvGetSize(templ).height);
        cvSetImageROI(src,correct);
 
        cvSet(src,cvScalarAll(255),0);
        cvSetImageROI(src,cvRect(0,0,(int)src_x,(int)src_y));
 
 
 
 
    }
 
    cvReleaseImage(&templ);
    cvReleaseImage(&result);
    cvReleaseImage(&templ_bis);
    return n_stamps;
 
 
}

Code commenté et epuré

**dewey01** · 04/09/2008, 18h03

Merci beaucoup pour ton code, j'ai pas mal avancé du coup. Voici mon code, bon sa ne marche pas (c'est normale je pense) mais sa compile, c'est déjà sa.

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
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
#include <stdio.h>
#include <stdlib.h>
#include "cv.h"
#include "highgui.h"
 
int         main()
{
   IplImage *templ;
   IplImage *src;
   IplImage *result;
   double   seuil;
   int      x;
   int      y;
   double   min_val = 0;
   double   max_val = 0;
   float    src_x;
   float    src_y;
   CvPoint  max_loc;
   CvPoint  min_loc;
   CvRect   correct;
 
   /* Récupération de l'image et du template, format jpeg */
 
   templ= cvLoadImage("template.jpg", 0);
   src = cvLoadImage("image.jpg", 0);
 
   /* Initialisation du seuil, 0.900000 car pour max_val j'obtiens des valeurs entre
       0.900000 et 1.000000 lorsque le template se trouve sur l'image */
 
   seuil = 0.900000;
 
   /* Récupération des valeurs nécessaires pour la création de l'image résult   */
 
   src_x = cvGetSize(src).width;
   src_y = cvGetSize(src).height;
   x = (int)src_x- cvGetSize(templ).width +1;
   y = (int)src_y - cvGetSize(templ).height +1;
   result = cvCreateImage(cvSize(x,y),IPL_DEPTH_32F,1);
 
   /* Utilisation de cvMatchTemplate avec la dernière méthode (un peu a taton comme toi) */
 
   cvMatchTemplate(src, templ, result, CV_TM_CCOEFF_NORMED);
 
   /* Recherche des résultats */
 
   max_loc = cvPoint(0,0);
   min_loc = cvPoint(0,0);
   cvMinMaxLoc(result, &min_val, &max_val, &min_loc, &max_loc, 0);
 
   /* Debugs */
 
   printf("valeur de max_val : %f\n", max_val);
   printf("valeur de seuil : %f\n", seuil);
 
   /* J'entoure le template par un cercle */
 
   if (max_val > seuil)
   {
       printf("Template trouvé, eureka !\n");
       cvCircle(result, cvPoint(max_loc.x, max_loc.y), 10,
        CV_RGB(255, 50, 50), 1, 8, 0);
   }
   else
   {
       printf("Template non trouvé !\n");
   }
   /* Affichage de l'image résult */
 
   cvNamedWindow("test", 1);
   cvShowImage( "test", result);
   cvWaitKey(0);
 
   /* Libération de la mémoire */
 
   cvReleaseImage(&templ);
   cvReleaseImage(&result);
   return(0);
}

Voici mon image de test et mon template:

Qu'en penses tu

?

Edit: j'ai essayer de changer le seuil (enlever un 0) mais lorsque je fais sa il me trouve toujours le template même si il n'y en a pas dans l'image source.

Edit: Après vérification, c'est la valeur de max_val qui ne change jamais, même en changeant les template.

**dewey01** · 08/09/2008, 17h24

Du nouveau, j'ai avancer un peu en bidouillant mais je semble être parvenu a obtenir des résultats cohérent pour max_value.
Mais maintenant nouveau problème, je souhaiterais entourer la zone trouver (j'ai les coordonnée, j'arrive a afficher l'image result) mais je ne trouve pas la fonction adéquate.
Merci

**Vinsss84** · 08/09/2008, 23h19

Réponse rapide, j'ai pas trop eu le temps de passer ces derniers jours (je regarderai ton code demain si j'ai le temps)

- Pour entourer une zone tu as la fonction cvDrawRect qui va très bien
- Sinon pour ton image et ton template ça devrait marcher sans trop de soucis.
- Enfin je te soumet une idée : met des commentaires

comme ça la prochaine fois que quelqu'un pose la question il est tout bien le code :')
Et les commentaires c'est beau !

**dewey01** · 09/09/2008, 09h25

Code commenté et épuré

Edit: Bizarre mais je ne trouve pas la fonction cvDrawRect dans la doc officielle.

**Vinsss84** · 09/09/2008, 10h08

Ah que c'est beau

Pour cvDrawRect elle est documentée quelque part :

mais en gros tu l'utilises de la façon suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cvDrawRect(tonimage,cvPoint(x,y),cvPoint(x',y'),CV_RGB(255,50,50)/*ta couleur*/,30)

**dewey01** · 09/09/2008, 12h02

En fait dans la doc, la fonction est documenté sour le nom cvRectangle, et du coup j'ai vu cvCircle en dessous j'ai choisit celle la =).
Voila le résult&at que j'obtient :

Mais bon si je met le "A" juste en dessous du cercle par exemple, il ne me le trouvera pas car mon template fais du 50*50 alors il faut que tout ce qu'il y a autour du "A" soit blanc.

Donc j'ai essayer avec un template en PNG pour avoir la transparence autour, mon debug me dit qu'il trouve bien le template mais lors de l'affichage il n'y a qu'une page blanche, pas un cercle blanc sur fond noir avec le "A" entourer comme ci-dessus.

**Vinsss84** · 09/09/2008, 13h05

essaye de baisser ton seuil pour palier à ce problème de non detection si le contour n'est pas tout blanc

**dewey01** · 09/09/2008, 14h14

Envoyé par Vinsss84

essaye de baisser ton seuil pour palier à ce problème de non detection si le contour n'est pas tout blanc

Sa ne fonctionne pas, j'ai déjà essayer, il me détecte un autre endroit. Ce qui m'embête c'est qu'avec le template en PNG il a l'air de détecté un template mais je peut pas vérifié à cause de l'image blanche de résultat.

Edit: En fait sa chie dans la colle a chaque fois j'essaie d'intégrer un template (le "A" de test) avec un fond transparent, c'est vraiment bizarre.