problème conversion C/c+

Version imprimable

Bonjour,

j'essaie d'utiliser le code de calcul des LBP disponible dans le fichier facerec.cpp d'Opencv

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
template <typename _Tp> static
void olbp_(InputArray _src, OutputArray _dst) {
    // get matrices
    Mat src = _src.getMat();
    // allocate memory for result
    _dst.create(src.rows-2, src.cols-2, CV_8UC1);
    Mat dst = _dst.getMat();
    // zero the result matrix
    dst.setTo(0);
    // calculate patterns
    for(int i=1;i<src.rows-1;i++) {
        for(int j=1;j<src.cols-1;j++) {
            _Tp center = src.at<_Tp>(i,j);
            unsigned char code = 0;
            code |= (src.at<_Tp>(i-1,j-1) >= center) << 7;
            code |= (src.at<_Tp>(i-1,j) >= center) << 6;
            code |= (src.at<_Tp>(i-1,j+1) >= center) << 5;
            code |= (src.at<_Tp>(i,j+1) >= center) << 4;
            code |= (src.at<_Tp>(i+1,j+1) >= center) << 3;
            code |= (src.at<_Tp>(i+1,j) >= center) << 2;
            code |= (src.at<_Tp>(i+1,j-1) >= center) << 1;
            code |= (src.at<_Tp>(i,j-1) >= center) << 0;
            dst.at<unsigned char>(i-1,j-1) = code;
        }
    }
}

Précision : j'utilise un code en C

Or lors de la compilation il y a une erreur avec le template (non reconnaissance du modèle)

J'ai donc enlevé la première ligne et j'ai remplacé tout les _Tp par "char"

Ensuite lors de la compilation j'obtenais "impossible de convertir IplImage en InputArray

J'essaie donc de convertir mes IplImage en mat de la manière suivante :

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
void olbp_(IplImage* _src,IplImage* filtre) {
    // get matrices
    Mat src(_src);
    // allocate memory for result
    Mat _dst;
	_dst.create(src.rows-2, src.cols-2, CV_8UC1);
 
    // zero the result matrix
    _dst.setTo(0);
    // calculate patterns
    for(int i=1;i<src.rows-1;i++) {
        for(int j=1;j<src.cols-1;j++) {
            char center = src.at<char>(i,j);
            unsigned char code = 0;
            code |= (src.at<char>(i-1,j-1) >= center) << 7;
            code |= (src.at<char>(i-1,j) >= center) << 6;
            code |= (src.at<char>(i-1,j+1) >= center) << 5;
            code |= (src.at<char>(i,j+1) >= center) << 4;
            code |= (src.at<char>(i+1,j+1) >= center) << 3;
            code |= (src.at<char>(i+1,j) >= center) << 2;
            code |= (src.at<char>(i+1,j-1) >= center) << 1;
            code |= (src.at<char>(i,j-1) >= center) << 0;
            _dst.at<unsigned char>(i-1,j-1) = code;
        }
    }
 
	filtre = cvCreateImage(cvSize(_dst.cols,_dst.rows),8,1);
	IplImage ipltemp=_dst;
	cvCopy(&ipltemp,filtre);
 
}

Ce qui ne fonctionne pas : le code compile mais lorsque j'essai d'afficher la sortie "filtre" il ne se passe rien ...

Quelqu'un peut il m'expliquer ces différentes erreurs ?

Cordialement,

A.

03/03/2015, 11h37
phi1981
C'est normal.
Code:

1 2 filtre = cvCreateImage(cvSize(_dst.cols,_dst.rows),8,1);
Ici, la fonction cvCreateImage() alloue l'image et retourne un pointeur sur elle. filtre est une variable de type pointeur sur IplImage qui a été passée en paramètre à ta fonction.
Mais tu écrases la valeur initiale de ce pointeur par la valeur de retour de cvCreateImage(), et puis tu ne la retourne jamais à l'appelant, donc c'est perdu. En passant, cela entraine aussi peut-être une fuite mémoire, puisque "filtre" pointait peut-être sur une image déjà allouée.
Parmi les solutions, il y a l'idée de prendre un pointeur de pointeur en paramètre, ou bien de demander à l'appelant de passer une image déjà allouée avec la bonne taille, ou bien que la fonction olbp_() retourne "filtre".
03/03/2015, 11h50
Arthur_

Pourquoi est ce que je ne la retourne jamais à l’appelant ?

ma fonction retourne effectivement filtre :

Code:

void olbp_(IplImage* _src,IplImage* filtre)

Dans mon main filtre est simplement défini tel quel : IplImage* filtre;

Parce qu'en C++ (et en C), les paramètres sont passés par copie (par défaut).
Ta fonction olbp_ (en passant, c'est un drôle de nom), reçoit deux pointeurs. Elle en modifie un (filtre), mais ce qu'il faut comprendre, c'est qu'elle NE modifie PAS ce qui est pointé par le pointeur, elle modifie VRAIMENT le pointeur lui même.

Un exemple plus simple, imagine si ta fonction prenait deux ints en paramètre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void olbp_ (int a, int b) { b = a +1; // ici, b a été modifié, mais sa valeur n'est utilisée nulle part ... } int main (int argc, char **argv) { int a=10; int b=20; olbp_ (a, b); // a vaut toujours 10, b vaut toujours 20, parce que c'est une COPIE de ces valeurs qui a été passée à olbp }
Ta fonction, même si elle reçoit des pointeurs, souffre du même probleme: tu modifie le paramètre d'entrée filtre, pas ce qui est pointé par filtre.