灰度共生矩阵的实现

版权声明：原文地址http://blog.csdn.net/computerme/article/details/39805257

     灰度共生矩阵，Gray Level Co-occurrence Matrix,简写为GLCM

     由于纹理是由灰度分布在空间位置上反复出现而形成的，因而在图像空间中相隔某距离的两象素之间会存在一定的灰度关系，即图像中灰度的空间相关特性。灰度共生矩阵就是一种通过研究灰度的空间相关特性来描述纹理的常用方法。

     取图像(N×N)中任意一点 （x，y）及偏离它的另一点 （x+a，y+b），设该点对的灰度值为 （g1，g2）。令点（x，y） 在整个画面上移动，则会得到各种 （g1，g2）值，设灰度值的级数为 k，则（g1，g2） 的组合共有 k 的平方种。对于整个画面，统计出每一种 （g1，g2）值出现的次数，然后排列成一个方阵，再用（g1，g2） 出现的总次数将它们归一化为出现的概率P（g1，g2） ，这样的方阵称为灰度共生矩阵。

     下图显示了如何求解灰度共生矩阵，以（1，1）点为例，GLCM（1，1）值为1说明只有一对灰度为1的像素水平相邻。GLCM（1，2）值为2，是因为有两对灰度为1和2的像素水平相邻。

 

         设f(x,y)为一幅数字图像，其大小为M×N，灰度级别为Ng，则满足一定空间关系的灰度共生矩阵为：

        其中#(x)表示集合x中的元素个数，显然P为Ng×Ng的矩阵，若(x1,y1)与(x2,y2)间距离为d,两者与坐标横轴的夹角为θ，则可以得到各种间距及角度的灰度共生矩阵(i,j,d,θ)。其中元素(i,j)的值表示一个灰度为i，另一个灰度为j的两个相距为d的像素对在角的方向上出现的次数。结合上面的图会更容易理解。

       在计算得到共生矩阵之后，往往不是直接应用计算的灰度共生矩阵，而是在此基础上计算纹理特征量，我们经常用对比度、能量、熵、相关性等特征量来表示纹理特征。

        (1) 对比度：又称为反差，度量矩阵的值是如何分布和图像中局部变化的多少，反应了图像的清晰度和纹理的沟纹深浅。纹理的沟纹越深，反差越大，效果清晰；反之，对比值小，则沟纹浅，效果模糊。 

        (2) 能量：是灰度共生矩阵各元素值的平方和，是对图像纹理的灰度变化稳定程度的度量，反应了图像灰度分布均匀程度和纹理粗细度。能量值大表明当前纹理是一种规则变化较为稳定的纹理。          

        (3) 熵：是图像包含信息量的随机性度量。当共生矩阵中所有值均相等或者像素值表现出最大的随机性时，熵最大；因此熵值表明了图像灰度分布的复杂程度，熵值越大，图像越复杂。             

        (4) 相关性：也称为同质性，用来度量图像的灰度级在行或列方向上的相似程度，因此值的大小反应了局部灰度相关性，值越大，相关性也越大。

下面是代码的实现

[cpp]  view plain  copy

 

1. #define GLCM_DIS 2  //灰度共生矩阵的统计距离  
2. #define GLCM_CLASS 8 //计算灰度共生矩阵的图像灰度值等级化  
3. #define GLCM_ANGLE_HORIZATION    0   //水平  
4. #define GLCM_ANGLE_VERTICAL      1   //垂直  
5. #define GLCM_ANGLE_DIGONAL_45    2   //45度对角  
6. #define GLCM_ANGLE_DIGONAL_135   3   //135度对角  
7. int calGLCM(CvMat* bWavelet,int angleDirection,double* featureVector)  
8. {  
9.     int i,j;  
10.     int width,height;  
11.     int min,max;  
12.     if(NULL == bWavelet)  
13.         return 1;  
14.     width = bWavelet->width;  
15.     height = bWavelet->height;  
16.   
17.     int * glcm = new int[GLCM_CLASS * GLCM_CLASS];  
18.     int * histImage = new int[width * height];  
19.   
20.     if(NULL == glcm || NULL == histImage)  
21.         return 2;  
22.   
23.     //灰度等级化---分GLCM_CLASS个等级  
24.     int relative_value = 0;  
25.     for(i = 0;i < height;i++){  
26.         for(j = 0;j < width;j++){  
27.             histImage[i * width + j] = (int)(CV_MAT_ELEM(*bWavelet,float,i,j) * GLCM_CLASS / 256);  
28.             //printf("%d ",histImage[i * width + j]);  
29.         }  
30.     }  
31.   
32.     //初始化共生矩阵  
33.     for (i = 0;i < GLCM_CLASS;i++)  
34.         for (j = 0;j < GLCM_CLASS;j++)  
35.             glcm[i * GLCM_CLASS + j] = 0;  
36.   
37.     //计算灰度共生矩阵  
38.     int w,k,l;  
39.     //水平方向  
40.     if(angleDirection == GLCM_ANGLE_HORIZATION)  
41.     {  
42.         for (i = 0;i < height;i++)  
43.         {  
44.             for (j = 0;j < width;j++)  
45.             {  
46.                 l = histImage[i * width + j];  
47.                 if(j + GLCM_DIS >= 0 && j + GLCM_DIS < width)  
48.                 {  
49.                     k = histImage[i * width + j + GLCM_DIS];  
50.                     glcm[l * GLCM_CLASS + k]++;  
51.                 }  
52.                 if(j - GLCM_DIS >= 0 && j - GLCM_DIS < width)  
53.                 {  
54.                     k = histImage[i * width + j - GLCM_DIS];  
55.                     glcm[l * GLCM_CLASS + k]++;  
56.                 }  
57.             }  
58.         }  
59.     }  
60.     //垂直方向  
61.     else if(angleDirection == GLCM_ANGLE_VERTICAL)  
62.     {  
63.         for (i = 0;i < height;i++)  
64.         {  
65.             for (j = 0;j < width;j++)  
66.             {  
67.                 l = histImage[i * width + j];  
68.                 if(i + GLCM_DIS >= 0 && i + GLCM_DIS < height)   
69.                 {  
70.                     k = histImage[(i + GLCM_DIS) * width + j];  
71.                     glcm[l * GLCM_CLASS + k]++;  
72.                 }  
73.                 if(i - GLCM_DIS >= 0 && i - GLCM_DIS < height)   
74.                 {  
75.                     k = histImage[(i - GLCM_DIS) * width + j];  
76.                     glcm[l * GLCM_CLASS + k]++;  
77.                 }  
78.             }  
79.         }  
80.     }  
81.     //135度对角方向  
82.     else if(angleDirection == GLCM_ANGLE_DIGONAL_135)  
83.     {  
84.         for (i = 0;i < height;i++)  
85.         {  
86.             for (j = 0;j < width;j++)  
87.             {  
88.                 l = histImage[i * width + j];  
89.   
90.                 if(j + GLCM_DIS >= 0 && j + GLCM_DIS < width && i + GLCM_DIS >= 0 && i + GLCM_DIS < height)  
91.                 {  
92.                     k = histImage[(i + GLCM_DIS) * width + j + GLCM_DIS];  
93.                     glcm[l * GLCM_CLASS + k]++;  
94.                 }  
95.                 if(j - GLCM_DIS >= 0 && j - GLCM_DIS < width && i - GLCM_DIS >= 0 && i - GLCM_DIS < height)  
96.                 {  
97.                     k = histImage[(i - GLCM_DIS) * width + j - GLCM_DIS];  
98.                     glcm[l * GLCM_CLASS + k]++;  
99.                 }  
100.             }  
101.         }  
102.     }  
103.     //45度对角方向  
104.     else if(angleDirection == GLCM_ANGLE_DIGONAL_45)  
105.     {  
106.         for (i = 0;i < height;i++)  
107.         {  
108.             for (j = 0;j < width;j++)  
109.             {  
110.                 l = histImage[i * width + j];  
111.   
112.                 if(j + GLCM_DIS >= 0 && j + GLCM_DIS < width && i - GLCM_DIS >= 0 && i - GLCM_DIS < height)  
113.                 {  
114.                     k = histImage[(i - GLCM_DIS) * width + j + GLCM_DIS];  
115.                     glcm[l * GLCM_CLASS + k]++;  
116.                 }  
117.                 if(j - GLCM_DIS >= 0 && j - GLCM_DIS < width && i + GLCM_DIS >= 0 && i + GLCM_DIS < height)  
118.                 {  
119.                     k = histImage[(i + GLCM_DIS) * width + j - GLCM_DIS];  
120.                     glcm[l * GLCM_CLASS + k]++;  
121.                 }  
122.             }  
123.         }  
124.     }  
125.   
126.     //计算特征值  
127.     double entropy = 0,energy = 0,contrast = 0,homogenity = 0;  
128.     for (i = 0;i < GLCM_CLASS;i++)  
129.     {  
130.         for (j = 0;j < GLCM_CLASS;j++)  
131.         {  
132.             //熵  
133.             if(glcm[i * GLCM_CLASS + j] > 0)  
134.                 entropy -= glcm[i * GLCM_CLASS + j] * log10(double(glcm[i * GLCM_CLASS + j]));  
135.             //能量  
136.             energy += glcm[i * GLCM_CLASS + j] * glcm[i * GLCM_CLASS + j];  
137.             //对比度  
138.             contrast += (i - j) * (i - j) * glcm[i * GLCM_CLASS + j];  
139.             //一致性  
140.             homogenity += 1.0 / (1 + (i - j) * (i - j)) * glcm[i * GLCM_CLASS + j];  
141.         }  
142.     }  
143.     //返回特征值  
144.     i = 0;  
145.     featureVector[i++] = entropy;  
146.     featureVector[i++] = energy;  
147.     featureVector[i++] = contrast;  
148.     featureVector[i++] = homogenity;  
149.   
150.     delete[] glcm;  
151.     delete[] histImage;  
152.     return 0;  
153. }  

Reference:

http://blog.csdn.NET/weiyuweizhi/article/details/5724050

http://blog.csdn.Net/cxf7394373/article/details/6988229