Texture Local Binary Pattern (LBP)

Version imprimable

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 :roll:

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
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;
}

31/03/2015, 00h09
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é.
31/03/2015, 19h37
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 :)
31/03/2015, 20h32
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.
31/03/2015, 23h59
codesource1

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

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:

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;
            }
        }
    }
}

02/04/2015, 00h25
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)

Citation:

@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}}