Discussion :

[Leon Ira]

Salut tout le monde !

J'essaie d'implémenter l'opérateur gradient avec openCV, pour ça j'ai cru comprendre que la méthode la plus simple est de passer par cvSobel.

Voici mon code :

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
 
void gradient(IplImage* src, IplImage* magnitude, IplImage* orientation, int deg = 1) {
 
    int x = 0, y = 0;//utilisées pour boucler
    double a = 0;//debug
    uchar *px, *py, *pm, *po;
//dx et dy doivent contenir le différentiel selon x et y
    IplImage* dx = cvCreateImage(cvGetSize(src), IPL_DEPTH_16S, 1);
    IplImage* dy = cvCreateImage(cvGetSize(src), IPL_DEPTH_16S, 1);
 
    cvSobel(src, dx, deg, 0, 3);
    cvSobel(src, dy, 0, deg, 3);
 
 
    for (y = 0; y < src->height; ++y) {
        for (x = 0; x < src->width; ++x) {
            px = cvPtr2D(dx, y, x, NULL);
            py = cvPtr2D(dy, y, x, NULL);
            pm = cvPtr2D(magnitude, y, x, NULL);
            po = cvPtr2D(orientation, y, x, NULL);
 
            a = atan2(*px, *py) * 180 / M_PI;
            *po = a;
            *pm = sqrt(pow(*px, 2) + pow(*py, 2));
        }
    }
}

Bref, j'arrive bien a afficher quelque chose qui ressemble plus ou moins à un gradient (après reconversion de dxet dy en IPL_DEPTH_8U), mais quand je debug, je me rend compte que mes matrix dy et dx ne contiennent que des valeurs positives (alors que la dérivée selon une coordonnée devrait donner un certain nombre de valeurs négatives…).
Si j'ai bien compris IPL_DEPTH_16S contient du 16 bits signés, càd un short int et une plage -32 768 à 32 767. (enfin à confirmer, je suis en linux x86_64)
Quand je printf("%i",*px); ce n'est pas ce que j'ai.

Quelqu'un a une explication, ou mieux, une implémentation du gradient qui marche ?
Ou j'aurais mal compris à quoi sert cvSobel ?
Pour info, je m'inspire de http://opencv-users.1802565.n2.nabbl...td2191671.html

Voilou, merci d'avance

[vravier]

Salut,

Je n'ai jamais utilisé la fonction cvPtr2D, mais vu qu'elle retourne un uchar*, je pense que le problème se situe ici:
Tes matrices dx et dy contiennent des valeurs signées sur 16 bits, mais tu récupères un pointeur sur une valeur non signée sur 8 bits. *px (et les autres) sera donc toujours compris entre 0 et 255.
Essaie de voir s'il n'y a pas une fonction sur une IplImage qui te renvoie vraiment la valeur à une coordonnée précise, un peu comme la fonction Mat::at.

Ce n'est qu'une supposition hein, je n'ai fait que lire le code

Sinon, l'approche Sobel semble effectivement une des méthodes possibles pour calculer un gradient si on en croit (entre autre) l'article Wikipédia

Edit: Si j'en crois le code dans array.cpp:

Code :

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

1
2
3
ptr = (uchar*)img->imageData;
// blablabla...
ptr += y*img->widthStep + x*pix_size;

et ce qui est fait ailleurs genre

Code :

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

const short *cd = (const short*)cvPtr2D(cxy, y, 0);

il te faudrait déclarer tes pointeurs comme ceci:

Code :

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

short int *px, *py;

et caster en appelant cvPtr2D:

Code :

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

1
2
*px = (short int*)cvPtr2D(dx, y, x, NULL);
*py = (short int*)cvPtr2D(dy, y, x, NULL);

Et je viens de m'apercevoir que tes pointeurs *pm et *po doivent certainement plus être de type float ou double. A toi de voir en fonction de la création de tes IplImage magnitude et orientation.