Discussion :

[codesource1]

Bonsoir TOUT le monde

j'aimerais bien savoir comment peux-je déterminer le code source de la texture lbp sur 16 bit opencv et avec le langage c++
le code ci- dessous détermine le calcul du LBP sur 8 bits. quels sont les modifications nécessaire ???
aidez-moi et merci d'avance

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
Mat LBP(Mat img_src)
{
	bool affiche=true;
	Mat img_gray;
	Mat img_dst(img_src.rows-2, img_src.cols-2, CV_8UC1);
	cvtColor(img_src, img_gray, CV_BGR2GRAY);
	for(int i=1;i<img_gray.rows-1;i++) 
	{
        for(int j=1;j<img_gray.cols-1;j++) 
		{
            unsigned char center = img_gray.at<uchar>(i,j);
            unsigned char code = 0;
            code |= (img_gray.at<uchar>(i-1,j-1) > center) << 7;
            code |= (img_gray.at<uchar>(i-1,j) > center) << 6;
            code |= (img_gray.at<uchar>(i-1,j+1) > center) << 5;
            code |= (img_gray.at<uchar>(i,j+1) > center) << 4;
            code |= (img_gray.at<uchar>(i+1,j+1) > center) << 3;
            code |= (img_gray.at<uchar>(i+1,j) > center) << 2;
            code |= (img_gray.at<uchar>(i+1,j-1) > center) << 1;
            code |= (img_gray.at<uchar>(i,j-1) > center) << 0;
            img_dst.at<unsigned char>(i-1,j-1) = code;
		}
	}
			if(affiche == true)
            {
			  cv::imshow("image LBP", img_dst);
			  waitKey(10);
	          cv::imshow("grayscale",img_gray);
			  waitKey(10);
	        }
 
	        else 
            {
			  cv::destroyWindow("image LBP");
	          cv::destroyWindow("grayscale");
	        }
 
			return img_dst;
}

[ToTo13]

Je ne connais pas OpenCV, mais je connais les LBP. La seule chose que tu dois modifier c'est la récupération de la valeur du pixel "img_gray.at<uchar>(i-1,j-1)", afin de récupérer la valeur pour une image 16bits. Il doit falloir utiliser quelque chose du type <ushort> au lieu de <uchar>.
Mais ce code n'a pas l'air d'être très optimisé. Dans l'article d'origine, les auteurs proposent un code C++ hautement optimisé.

[codesource1]

bonsoir
tout d'abord merci
emm :/ j'ai pas bien te comprendre mais j'aimerais effectuer les calculs de LBP 16x16 pixels au lieu de 3x3 pixels. comment je peux faire ça ?
le code ci-dessus effectue le calcul dans un bloc d'une image 3 x 3 pixels
help me please

[ToTo13]

Ok, c'est pas ce que j'avais compris !

Le 3x3 te donne 8 bits. Le 16x16 va te donner un nombre de bits impressionnant et inutile.
Les auteurs disent que l'on peut travailler en 16bits, il suffit de répartir de manière équidistante 16 points sur un cercle. Les points ne vont bien entendu pas tomber précisément sur le centre des pixels, il est donc conseillé de faire une interpolation en fonction de la position dans le pixel et de la valeur des voisins. Lis donc les articles des auteurs, tout est très bien expliqué et il y a même le code en C/C++ pour le calcul des LBP avec interpolation.

[codesource1]

bsr
ahh d'accord je vous comprend maintenant
si je ne vous dérange pas, pouvez-vous m'envoyer les liens de ces articles + code c/c++? SVP et merci encore.

[codesource1]

j'ai trouvée le code mais j'ai pas bien compris certain instructions (relative indices/fractional part/ set interpolation weights ), a quoi ca sert???
emm autre chose c'est quoi la différence entre le calcul du LBP 3x3 et 16x16 pas en terme principe mais en terme utilité/précision...??

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
#ifndef M_PI
   #define M_PI 3.14159265358979323846
#endif
void ELBP_(const Mat& src, Mat& dst, int radius, int neighbors) {
    neighbors = max(min(neighbors,31),1); // set bounds...
    dst = Mat::zeros(src.rows-2*radius, src.cols-2*radius, CV_32SC1);
    for(int n=0; n<neighbors; n++) {
        // sample points
        float x = static_cast<float>(radius) * cos(2.0*M_PI*n/static_cast<float>(neighbors));
        float y = static_cast<float>(radius) * -sin(2.0*M_PI*n/static_cast<float>(neighbors));
        // relative indices
        int fx = static_cast<int>(floor(x));
        int fy = static_cast<int>(floor(y));
        int cx = static_cast<int>(ceil(x));
        int cy = static_cast<int>(ceil(y));
        // fractional part
        float ty = y - fy;
        float tx = x - fx;
        // set interpolation weights
        float w1 = (1 - tx) * (1 - ty);
        float w2 =      tx  * (1 - ty);
        float w3 = (1 - tx) *      ty;
        float w4 =      tx  *      ty;
        // iterate through your data
        for(int i=radius; i < src.rows-radius;i++) {
            for(int j=radius;j < src.cols-radius;j++) {
                float t = w1*src.at<uchar>(i+fy,j+fx) + w2*src.at<uchar>(i+fy,j+cx) + w3*src.at<uchar>(i+cy,j+fx) + w4*src.at<uchar>(i+cy,j+cx);
                // we are dealing with floating point precision, so add some little tolerance
                dst.at<unsigned int>(i-radius,j-radius) += ((t > src.at<uchar>(i,j)) && (abs(t-src.at<uchar>(i,j)) > std::numeric_limits<float>::epsilon())) << n;
            }
        }
    }
}

[ToTo13]

Ce code n'est pas du tout optimisé...
L'interpolation sert pour les cas ou tu utilises un rayon plus grand que 1 ou lorsque tu souhaites utiliser 16bits (ton cas).
La plupart des points à comparer (avec le centre) ne tombent pas au milieu des pixels. Il est donc "mieux" de faire une interpolation de la valeur plutôt que de faire un arrondi.



- lien
- lien (code C ici)

@article{OPM02,
Author = {Timo Ojala and Matti Pietikainen and Topi Maenpaa},
Journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence},
Month = {July},
Number = {7},
Pages = {971--987},
Rating = {5},
Read = {1},
Title = {Multiresolution Gray-Scale and Rotation Invariant Texture Classification with Local Binary Patterns},
Volume = {24},
Year = {2002}}