zoukankan      html  css  js  c++  java
  • 【图像算法】图像特征:GLCM灰度共生矩阵,纹理特征

    【图像算法】图像特征:GLCM

          SkySeraph Aug 27th 2011  HQU

    Email:zgzhaobo@gmail.com    QQ:452728574

    Latest Modified Date:Aug 27th 2011 HQU

    -------------------------------------------------------------------------------------------------------------------------------

    一 原理

    1 概念:GLCM,即灰度共生矩阵,GLCM是一个L*L方阵,L为源图像的灰度级

    2 含义:描述的是具有某种空间位置关系的两个像素的联合分布,可看成两个像素灰度对的联合直方图,是一种二阶统计

    3 常用的空间位置关系:有四种,垂直、水平、正负45°

    4 常用的GLCM特征特征:

    (1)能量:  是灰度共生矩阵元素值的平方和,所以也称能量,反映了图像灰度分布均匀程度和纹理粗细度。
          如果共生矩阵的所有值均相等,则ASM值小;相反,如果其中一些值大而其它值小,则ASM值大。
          当共生矩阵中元素集中分布时,此时ASM值大。ASM值大表明一种较均一和规则变化的纹理模式。
    (2)对比度:反映了图像的清晰度和纹理沟纹深浅的程度。纹理沟纹越深,其对比度越大,视觉效果越清晰;
          反之,对比度小,则沟纹浅,效果模糊。灰度差即对比度大的象素对越多,这个值越大。
          灰度公生矩阵中远离对角线的元素值越大,CON越大。
    (3)相关:  它度量空间灰度共生矩阵元素在行或列方向上的相似程度,因此,相关值大小反映了图像中局部灰度相关性。
          当矩阵元素值均匀相等时,相关值就大;相反,如果矩阵像元值相差很大则相关值小。如果图像中有水平方向纹理,
          则水平方向矩阵的COR大于其余矩阵的COR值。
    (4)熵:  是图像所具有的信息量的度量,纹理信息也属于图像的信息,是一个随机性的度量,当共生矩阵中所有元素有最大的随机性、
          空间共生矩阵中所有值几乎相等时,共生矩阵中元素分散分布时,熵较大。它表示了图像中纹理的非均匀程度或复杂程度。
    (5)逆差距:反映图像纹理的同质性,度量图像纹理局部变化的多少。其值大则说明图像纹理的不同区域间缺少变化,局部非常均匀。

    5 原理理解:

    假设衣服图像的纹理矩阵P如下:

    P = [ 0 1 2 0 1 2 
       1 2 0 1 2 0
       2 0 1 2 0 1
       0 1 2 0 1 2
       1 2 0 1 2 0
       2 0 1 2 0 1
     ]

    ①相距为1(第一个参数),位置方向为0°第二个参数)的GLCM矩阵如下:

    [ 0 10 10  

      10 0 10 

      10 10 0  

    ]

    //解析:因为P中灰度级为3,故GLCM为3*3方阵

    ②相距为1(第一个参数),位置方向为正负45°第二个参数)的GLCM矩阵如下:

     [ 16  0  0
        0  16  0 
        0   0  18
    ]

    -------------------------------------------------------------------------------------------------------------------------------

    二 结果

     图像(lenna):

    另附:关于lenna,风靡图像界这张图像,源原轶事:http://www.cs.cmu.edu/~chuck/lennapg/ ^_^

    单个 GLCM以及4个方向的均值、方差GLCM特征:

     

     

    -------------------------------------------------------------------------------------------------------------------------------

    三 源码

    类头文件:

     

    // FeatureDetect.h: interface for the FeatureDetect class. 
    //
    ///////////////////////////////////////////////////////////////////////////////////////
    /* Author: skyseraph/zhaobo   2011/4    zgzhaobo@gmal.com
    */
    ///////////////////////////////////////////////////////////////////////////////////////
    
    #include <math.h>    
    #include "windows.h"
    #include "iostream"
    usingnamespace std;
    
    typedef struct glcmFeature 
    {
    double    dCorrelation;        
    double    dEnergy;            
    double    dEntropy;            
    double    dInertiaQuadrature;    
    double    dLocalCalm;                
    }glcmFeature;
    
    typedef struct glcmFeatureVar 
    {
    double    dAveCorrelation;    
    double    dAveEnergy;    
    double    dAveEntropy;    
    double    dAveInertiaQuadrature;
    double    dAveLocalCalm;    
    double    dVarCorrelation;    
    double    dVarEnergy;        
    double    dVarEntropy;        
    double    dVarInertiaQuadrature;
    double    dVarLocalCalm;        
    }glcmFeatureVar;
    
    class ZBGLCM
    {
    public:    
        ZBGLCM();    
    ~ZBGLCM();
        
    void ComputeMatrix(BYTE **LocalImage, int LocalImageWidth);      
    void ComputeFeature(double&FeatureEnergy, double&FeatureEntropy, 
    double&FeatureInertiaQuadrature, double&FeatureCorrelation, 
    double&FeatureLocalCalm, int** pMatrix, int dim);
        glcmFeature pGLCMF;
        glcmFeatureVar pGLCMFVar;
        glcmFeature GLCMFeature(BYTE* ImageArray,long ImageWidth,long ImageHeight,int FilterWindowWidth,int dir);    
        glcmFeatureVar GLCMFeatureVar(BYTE* ImageArray,long ImageWidth,long ImageHeight,int FilterWindowWidth);
        
    
    public:    
    double FeatureLocalCalmRD;    
    double FeatureLocalCalmLD;    
    double FeatureLocalCalmV;    
    double FeatureLocalCalmH;
    double FeatureCorrelationRD;
    double FeatureCorrelationLD;
    double FeatureCorrelationV;    
    double FeatureCorrelationH;    
    double FeatureInertiaQuadratureRD;
    double FeatureInertiaQuadratureLD;
    double FeatureInertiaQuadratureV;
    double FeatureInertiaQuadratureH;
    double FeatureEntropyRD;
    double FeatureEntropyLD;
    double FeatureEntropyV;    
    double FeatureEntropyH;    
    double FeatureEnergyRD;    
    double FeatureEnergyLD;    
    double FeatureEnergyV;    
    double FeatureEnergyH;    
    
    int FilterWindowWidth;    
    int distance;    
    int GrayLayerNum;
    int L;                
    int** PMatrixRD;
    int** PMatrixLD;    
    int** PMatrixV;    
    int** PMatrixH;    
    };

    类源文件-1:初始化和资源释放

    //////////////////////////////////////////////////////////////////////
    // Construction/Destruction
    //////////////////////////////////////////////////////////////////////
    ZBGLCM::ZBGLCM()
    {    
        PMatrixRD = NULL;    
        PMatrixLD = NULL;
        PMatrixV = NULL;
        PMatrixH = NULL;    
        
        distance =5;
        FilterWindowWidth =16;
        GrayLayerNum =8; 
        L=8;
    
    int i;
        PMatrixH =newint*[GrayLayerNum];
        PMatrixLD=newint*[GrayLayerNum];
        PMatrixRD=newint*[GrayLayerNum];
        PMatrixV =newint*[GrayLayerNum];
        
    for(i=0; i<GrayLayerNum; i++)
        {
            PMatrixH[i] =newint[GrayLayerNum];
            PMatrixLD[i]=newint[GrayLayerNum];
            PMatrixRD[i]=newint[GrayLayerNum];
            PMatrixV[i] =newint[GrayLayerNum];        
        }
    }
    
    ZBGLCM::~ZBGLCM()
    {
    if(PMatrixH !=NULL)
        {        
    for(int i=0; i<GrayLayerNum; i++)
            {
                delete [] PMatrixH[i];
                PMatrixH[i] = NULL; //已析构了,后不再加
            }
            delete [] PMatrixH;
            PMatrixH = NULL;
        }
    if(PMatrixLD !=NULL)
        {
    for(int i=0; i<GrayLayerNum; i++)
            {
                delete[] PMatrixLD[i];
            }
            delete [] PMatrixLD;
        }
    if(PMatrixRD !=NULL)
        {
    for(int i=0; i<GrayLayerNum; i++)
                delete [] PMatrixRD[i];
            delete [] PMatrixRD;
        }
    if(PMatrixV !=NULL)
        {
    for(int i=0; i<GrayLayerNum; i++)
                delete [] PMatrixV[i];
            delete [] PMatrixV;
        }    
    }

    类源文件-2:计算纹理特征

    void ZBGLCM::ComputeFeature(double&FeatureEnergy, double&FeatureEntropy, 
    double&FeatureInertiaQuadrature, double&FeatureCorrelation, 
    double&FeatureLocalCalm, int** pMatrix, int dim)
    {
    int i,j;
    double**pdMatrix;
        pdMatrix =newdouble*[dim];
    for(i=0; i<dim; i++)
            pdMatrix[i] =newdouble[dim];
        
    int total =0;
    for(i=0; i<dim; i++)
        {
    for(j=0; j<dim; j++)
            {
                total += pMatrix[i][j];
            }
        }
    for(i=0; i<dim; i++)
        {
    for(j=0; j<dim; j++)
            {
                pdMatrix[i][j] = (double)pMatrix[i][j]/(double)total;
            }
        }
        
        FeatureEnergy =0.0;
        FeatureEntropy =0.0;
        FeatureInertiaQuadrature =0.0;
        FeatureLocalCalm =0.0;
    
    for(i=0; i<dim; i++)
        {
    for(j=0; j<dim; j++)
            {
                FeatureEnergy += pdMatrix[i][j]*pdMatrix[i][j];            
    if(pdMatrix[i][j]>1e-12)
                {
                    FeatureEntropy -= pdMatrix[i][j]*log(pdMatrix[i][j]);
                }            
                FeatureInertiaQuadrature += (double)(i-j)*(double)(i-j)*pdMatrix[i][j];
                FeatureLocalCalm += pdMatrix[i][j]/(1+(double)(i-j)*(double)(i-j));
            }
        }
        
    double ux =0.0;
    double localtotal =0.0;
    for(i=0; i<dim; i++)
        {
            localtotal =0.0;
    for(j=0; j<dim; j++)
            {
                localtotal += pdMatrix[i][j];
            }
            ux += (double)i * localtotal;
        }
        
    double uy =0.0;
    for(j=0; j<dim; j++)
        {
            localtotal =0.0;
    for(i=0; i<dim; i++)
            {
                localtotal += pdMatrix[i][j];
            }
            uy += (double)j * localtotal;
        }
        
    double sigmax =0.0;
    for(i=0; i<dim; i++)
        {
            localtotal =0.0;
    for(j=0; j<dim; j++)
            {
                localtotal += pdMatrix[i][j];
            }
            sigmax += (double)(i-ux) * (double)(i-ux) * localtotal;
        }
        
    double sigmay =0.0;
    for(j=0; j<dim; j++)
        {
            localtotal =0.0;
    for(i=0; i<dim; i++)
            {
                localtotal += pdMatrix[i][j];
            }
            sigmay += (double)(j-uy) * (double)(j-uy) * localtotal;
        }
        
        FeatureCorrelation =0.0;
    for(i=0; i<dim; i++)
        {
    for(j=0; j<dim; j++)
            {
                FeatureCorrelation += (double)(i-ux) * (double)(j-uy) * pdMatrix[i][j];
            }
        }
    if(sigmax !=0&& sigmay !=0)
        {
            FeatureCorrelation /= sigmax;
            FeatureCorrelation /= sigmay;
        }
    else
            FeatureCorrelation =8;
    
    if(pdMatrix !=NULL)
        {
    for(i=0; i<dim; i++)
            {
                delete [] pdMatrix[i];
                pdMatrix[i] = NULL;
            }
            delete [] pdMatrix;
            pdMatrix = NULL;
        }
    }

    类源文件-3:计算共生矩阵

    void ZBGLCM::ComputeMatrix(BYTE **LocalImage, int LocalImageWidth)
    {
    int i,j;
        
        BYTE **NewImage;
        NewImage =new BYTE*[LocalImageWidth];
    if(NewImage==NULL)
    return;
    for(i=0; i<LocalImageWidth; i++)
        {
            NewImage[i] =new BYTE[LocalImageWidth];
    if(NewImage[i]==NULL)
    return;
        }
        
        
    for(i=0; i<LocalImageWidth; i++)
        {
    for(j=0; j<LocalImageWidth; j++)
            {            
                NewImage[i][j] = LocalImage[i][j] / (256/GrayLayerNum);
            }
        }
    
    for(i=0; i<GrayLayerNum; i++)
        {        
    for(j=0; j<GrayLayerNum; j++)
            {
                PMatrixH[i][j]  =0;
                PMatrixLD[i][j] =0;
                PMatrixRD[i][j] =0;
                PMatrixV[i][j]  =0;
            }
        }
        
    for(i=0; i<LocalImageWidth; i++)
        {
    for(j=0; j<LocalImageWidth-distance; j++)
            {
                PMatrixH[(unsigned int)NewImage[i][j]][(unsigned int)NewImage[i][j+distance]] +=1;
                PMatrixH[(unsigned int)NewImage[i][j+distance]][(unsigned int)NewImage[i][j]] +=1;
            }
        }
    
    for(i=0; i<LocalImageWidth-distance; i++)
        {
    for(j=0; j<LocalImageWidth; j++)
            {
                PMatrixV[(unsigned int)NewImage[i][j]][(unsigned int)NewImage[i+distance][j]] +=1;
                PMatrixV[(unsigned int)NewImage[i+distance][j]][(unsigned int)NewImage[i][j]] +=1;
            }
        }
    
    for(i=0; i<LocalImageWidth-distance; i++)
        {
    for(j=0; j<LocalImageWidth-distance; j++)
            {
    int newi, newj;
                newi = i+distance;
                newj = j+distance;
                PMatrixLD[(unsigned int)NewImage[i][j]][(unsigned int)NewImage[newi][newj]] +=1;
                PMatrixLD[(unsigned int)NewImage[newi][newj]][(unsigned int)NewImage[i][j]] +=1;
            }
        }
    
    for(i=distance; i<LocalImageWidth; i++)
        {
    for(j=0; j<LocalImageWidth-distance; j++)
            {
    int newi, newj;
                newi = i-distance;
                newj = j+distance;
                PMatrixRD[(unsigned int)NewImage[i][j]][(unsigned int)NewImage[newi][newj]] +=1;
                PMatrixRD[(unsigned int)NewImage[newi][newj]][(unsigned int)NewImage[i][j]] +=1;
            }
        }
    
    if(NewImage !=NULL)
        {
    for(i=0; i<LocalImageWidth; i++)
            {
                delete [] NewImage[i];
                NewImage[i] = NULL;
            }
            delete [] NewImage;
            NewImage = NULL;
        }
    }

     类源文件-4:计算GLCM特征 

    glcmFeature ZBGLCM::GLCMFeature(BYTE* ImageArray,long ImageWidth,long ImageHeight,int FilterWindowWidth,int dir)
    {
        assert(ImageHeight>FilterWindowWidth && ImageWidth > FilterWindowWidth);
    
    double dEnergy              =0.0;
    double dEntropy              =0.0;
    double dInertiaQuadrature =0.0;
    double dLocalCalm          =0.0;
    double dCorrelation          =0.0;
    double dEnergy1              =0.0;
    double dEntropy1          =0.0;
    double dInertiaQuadrature1=0.0;
    double dLocalCalm1          =0.0;
    double dCorrelation1      =0.0;    
        
    int rolltimeH = ImageHeight/FilterWindowWidth;
    int rolltimeW = ImageWidth /FilterWindowWidth;
    int i,j;
    int p,q;
        
        unsigned char** arLocalImage;    
        arLocalImage=(unsigned char**)calloc((unsigned)FilterWindowWidth,sizeof(unsigned char*));
    for( i=0;i<FilterWindowWidth;i++) 
        {
            arLocalImage[i]=(unsigned char*)calloc((unsigned)FilterWindowWidth,sizeof(unsigned char));
        }
            
    for(i=0; i< rolltimeH; i++)
        {
    for(j=0; j<rolltimeW; j++)
            {
    for(p=0; p<FilterWindowWidth; p++)
                {
    for(q=0; q<FilterWindowWidth; q++)
                    {
                        arLocalImage[p][q] =*((char*)ImageArray+(ImageHeight-1-(i*FilterWindowWidth+p))*ImageWidth+j*FilterWindowWidth+q);
                    }
                }
                ComputeMatrix(arLocalImage, FilterWindowWidth);
    switch (dir)
                {
    case0:
                    ComputeFeature(dEnergy1, dEntropy1, dInertiaQuadrature1, dCorrelation1, dLocalCalm1, PMatrixH, GrayLayerNum);
    break;
    case1:
                    ComputeFeature(dEnergy1, dEntropy1, dInertiaQuadrature1, dCorrelation1, dLocalCalm1, PMatrixRD, GrayLayerNum);
    break;
    case2:
                    ComputeFeature(dEnergy1, dEntropy1, dInertiaQuadrature1, dCorrelation1, dLocalCalm1, PMatrixV, GrayLayerNum);
    break;
    case3:
                    ComputeFeature(dEnergy1, dEntropy1, dInertiaQuadrature1, dCorrelation1, dLocalCalm1, PMatrixLD, GrayLayerNum);
    break;
    default:
                    ComputeFeature(dEnergy1, dEntropy1, dInertiaQuadrature1, dCorrelation1, dLocalCalm1, PMatrixH, GrayLayerNum);
    break;
                }            
                dEnergy              += dEnergy1;
                dEntropy             += dEntropy1;
                dInertiaQuadrature   += dInertiaQuadrature1;
                dCorrelation         += dCorrelation1;
                dLocalCalm           += dLocalCalm1;        
            }
        }
        dEnergy              /= (rolltimeH*rolltimeW);
        dEntropy             /= (rolltimeH*rolltimeW);
        dInertiaQuadrature   /= (rolltimeH*rolltimeW);
        dCorrelation         /= (rolltimeH*rolltimeW);
        dLocalCalm           /= (rolltimeH*rolltimeW);
        
        pGLCMF.dEnergy = dEnergy ;
        pGLCMF.dEntropy = dEntropy;
        pGLCMF.dInertiaQuadrature = dInertiaQuadrature;
        pGLCMF.dCorrelation = dCorrelation;
        pGLCMF.dLocalCalm = dLocalCalm;
    
    for(i=0; i<FilterWindowWidth; i++)
        {
            free(arLocalImage[i]) ;
            arLocalImage[i] = NULL;
        }
        free(arLocalImage);
        arLocalImage = NULL;
    
    
    return pGLCMF;
    }

     

    类源文件-5:计算GLCM特征均值和方差 

     

    glcmFeatureVar ZBGLCM::GLCMFeatureVar(BYTE* ImageArray,long ImageWidth,long ImageHeight,int FilterWindowWidth)
    {
        assert(ImageHeight>FilterWindowWidth && ImageWidth > FilterWindowWidth);
    
    double dEnergy              =0.0;
    double dEntropy              =0.0;
    double dInertiaQuadrature =0.0;
    double dLocalCalm          =0.0;
    double dCorrelation          =0.0;
    
    double dEnergy1              =0.0;
    double dEntropy1          =0.0;
    double dInertiaQuadrature1=0.0;
    double dLocalCalm1          =0.0;
    double dCorrelation1      =0.0;
    
    double dEnergy2              =0.0;
    double dEntropy2          =0.0;
    double dInertiaQuadrature2=0.0;
    double dLocalCalm2          =0.0;
    double dCorrelation2      =0.0;
    
    double dEnergy3              =0.0;
    double dEntropy3          =0.0;
    double dInertiaQuadrature3=0.0;
    double dLocalCalm3          =0.0;
    double dCorrelation3      =0.0;    
    
    double dEnergy4              =0.0;
    double dEntropy4          =0.0;
    double dInertiaQuadrature4=0.0;
    double dLocalCalm4          =0.0;
    double dCorrelation4      =0.0;
    
    double dEnergy11              =0.0;
    double dEntropy11          =0.0;
    double dInertiaQuadrature11=0.0;
    double dLocalCalm11          =0.0;
    double dCorrelation11      =0.0;
    
    double dEnergy22              =0.0;
    double dEntropy22          =0.0;
    double dInertiaQuadrature22=0.0;
    double dLocalCalm22          =0.0;
    double dCorrelation22      =0.0;
    
    double dEnergy33              =0.0;
    double dEntropy33          =0.0;
    double dInertiaQuadrature33=0.0;
    double dLocalCalm33          =0.0;
    double dCorrelation33      =0.0;
    
    double dEnergy44              =0.0;
    double dEntropy44          =0.0;
    double dInertiaQuadrature44=0.0;
    double dLocalCalm44          =0.0;
    double dCorrelation44      =0.0;
    
    int rolltimeH = ImageHeight/FilterWindowWidth;
    int rolltimeW = ImageWidth /FilterWindowWidth;
    int i,j;
    int p,q;
    
        unsigned char** arLocalImage;    
        arLocalImage=(unsigned char**)calloc((unsigned)FilterWindowWidth,sizeof(unsigned char*));
    for( i=0;i<FilterWindowWidth;i++) 
        {
            arLocalImage[i]=(unsigned char*)calloc((unsigned)FilterWindowWidth,sizeof(unsigned char));
        }
    
    for(i=0; i< rolltimeH; i++)
        {
    for(j=0; j<rolltimeW; j++)
            {
    for(p=0; p<FilterWindowWidth; p++)
                {
    for(q=0; q<FilterWindowWidth; q++)
                    {
                        arLocalImage[p][q] =*((char*)ImageArray+(ImageHeight-1-(i*FilterWindowWidth+p))*ImageWidth+j*FilterWindowWidth+q);
                    }
                }            
                ComputeMatrix(arLocalImage, FilterWindowWidth);
                ComputeFeature(dEnergy1, dEntropy1, dInertiaQuadrature1, dCorrelation1, dLocalCalm1, PMatrixH, GrayLayerNum);
                dEnergy              += dEnergy1;
                dEntropy             += dEntropy1;
                dInertiaQuadrature   += dInertiaQuadrature1;
                dCorrelation         += dCorrelation1;
                dLocalCalm           += dLocalCalm1;
                dEnergy11              += dEnergy1;
                dEntropy11             += dEntropy1;
                dInertiaQuadrature11   += dInertiaQuadrature1;
                dCorrelation11         += dCorrelation1;
                dLocalCalm11           += dLocalCalm1;
                ComputeMatrix(arLocalImage, FilterWindowWidth);
                ComputeFeature(dEnergy2, dEntropy2, dInertiaQuadrature2, dCorrelation2, dLocalCalm2, PMatrixRD, GrayLayerNum);
                dEnergy              += dEnergy2;
                dEntropy             += dEntropy2;
                dInertiaQuadrature   += dInertiaQuadrature2;
                dCorrelation         += dCorrelation2;
                dLocalCalm           += dLocalCalm2;
                dEnergy22              += dEnergy2;
                dEntropy22             += dEntropy2;
                dInertiaQuadrature22   += dInertiaQuadrature2;
                dCorrelation22         += dCorrelation2;
                dLocalCalm22           += dLocalCalm2;
                ComputeMatrix(arLocalImage, FilterWindowWidth);
                ComputeFeature(dEnergy3, dEntropy3, dInertiaQuadrature3, dCorrelation3, dLocalCalm3, PMatrixV, GrayLayerNum);
                dEnergy              += dEnergy3;
                dEntropy             += dEntropy3;
                dInertiaQuadrature   += dInertiaQuadrature3;
                dCorrelation         += dCorrelation3;
                dLocalCalm           += dLocalCalm3;
                dEnergy33              += dEnergy3;
                dEntropy33             += dEntropy3;
                dInertiaQuadrature33   += dInertiaQuadrature3;
                dCorrelation33         += dCorrelation3;
                dLocalCalm33           += dLocalCalm3;
                ComputeMatrix(arLocalImage, FilterWindowWidth);
                ComputeFeature(dEnergy4, dEntropy4, dInertiaQuadrature4, dCorrelation4, dLocalCalm4, PMatrixLD, GrayLayerNum);
                dEnergy              += dEnergy4;
                dEntropy             += dEntropy4;
                dInertiaQuadrature   += dInertiaQuadrature4;
                dCorrelation         += dCorrelation4;
                dLocalCalm           += dLocalCalm4;
                dEnergy44              += dEnergy4;
                dEntropy44             += dEntropy4;
                dInertiaQuadrature44   += dInertiaQuadrature4;
                dCorrelation44         += dCorrelation4;
                dLocalCalm44           += dLocalCalm4;        
                        
            }
        }
        dEnergy              /= (rolltimeH*rolltimeW);
        dEntropy             /= (rolltimeH*rolltimeW);
        dInertiaQuadrature   /= (rolltimeH*rolltimeW);
        dCorrelation         /= (rolltimeH*rolltimeW);
        dLocalCalm           /= (rolltimeH*rolltimeW);
    
        dEnergy11              /= (rolltimeH*rolltimeW);
        dEntropy11             /= (rolltimeH*rolltimeW);
        dInertiaQuadrature11   /= (rolltimeH*rolltimeW);
        dCorrelation11         /= (rolltimeH*rolltimeW);
        dLocalCalm11           /= (rolltimeH*rolltimeW);
    
        dEnergy22              /= (rolltimeH*rolltimeW);
        dEntropy22             /= (rolltimeH*rolltimeW);
        dInertiaQuadrature22   /= (rolltimeH*rolltimeW);
        dCorrelation22         /= (rolltimeH*rolltimeW);
        dLocalCalm22           /= (rolltimeH*rolltimeW);
    
        dEnergy33              /= (rolltimeH*rolltimeW);
        dEntropy33             /= (rolltimeH*rolltimeW);
        dInertiaQuadrature33   /= (rolltimeH*rolltimeW);
        dCorrelation33         /= (rolltimeH*rolltimeW);
        dLocalCalm33           /= (rolltimeH*rolltimeW);
    
        dEnergy44              /= (rolltimeH*rolltimeW);
        dEntropy44             /= (rolltimeH*rolltimeW);
        dInertiaQuadrature44   /= (rolltimeH*rolltimeW);
        dCorrelation44         /= (rolltimeH*rolltimeW);
        dLocalCalm44           /= (rolltimeH*rolltimeW);
    
        pGLCMFVar.dAveEnergy = dEnergy/4 ;
        pGLCMFVar.dAveEntropy = dEntropy/4;
        pGLCMFVar.dAveInertiaQuadrature = dInertiaQuadrature/4;
        pGLCMFVar.dAveCorrelation = dCorrelation/4;
        pGLCMFVar.dAveLocalCalm = dLocalCalm/4;
    
        pGLCMFVar.dVarEnergy=((dEnergy11-pGLCMFVar.dAveEnergy)*(dEnergy11-pGLCMFVar.dAveEnergy)
    +(dEnergy22-pGLCMFVar.dAveEnergy)*(dEnergy22-pGLCMFVar.dAveEnergy)
    +(dEnergy33-pGLCMFVar.dAveEnergy)*(dEnergy33-pGLCMFVar.dAveEnergy)
    +(dEnergy44-pGLCMFVar.dAveEnergy)*(dEnergy44-pGLCMFVar.dAveEnergy))/4;
        pGLCMFVar.dVarEntropy=((dEntropy11-pGLCMFVar.dAveEntropy)*(dEntropy11-pGLCMFVar.dAveEntropy)
    +(dEntropy22-pGLCMFVar.dAveEntropy)*(dEntropy22-pGLCMFVar.dAveEntropy)
    +(dEntropy33-pGLCMFVar.dAveEntropy)*(dEntropy33-pGLCMFVar.dAveEntropy)
    +(dEntropy44-pGLCMFVar.dAveEntropy)*(dEntropy44-pGLCMFVar.dAveEntropy))/4;
        pGLCMFVar.dVarInertiaQuadrature=((dInertiaQuadrature11-pGLCMFVar.dAveInertiaQuadrature)*(dInertiaQuadrature11-pGLCMFVar.dAveInertiaQuadrature)
    +(dInertiaQuadrature22-pGLCMFVar.dAveInertiaQuadrature)*(dInertiaQuadrature22-pGLCMFVar.dAveInertiaQuadrature)
    +(dInertiaQuadrature33-pGLCMFVar.dAveInertiaQuadrature)*(dInertiaQuadrature33-pGLCMFVar.dAveInertiaQuadrature)
    +(dInertiaQuadrature44-pGLCMFVar.dAveInertiaQuadrature)*(dInertiaQuadrature44-pGLCMFVar.dAveInertiaQuadrature))/4;
        pGLCMFVar.dVarCorrelation=((dCorrelation11-pGLCMFVar.dAveCorrelation)*(dCorrelation11-pGLCMFVar.dAveCorrelation)
    +(dCorrelation22-pGLCMFVar.dAveCorrelation)*(dCorrelation22-pGLCMFVar.dAveCorrelation)
    +(dCorrelation33-pGLCMFVar.dAveCorrelation)*(dCorrelation33-pGLCMFVar.dAveCorrelation)
    +(dCorrelation44-pGLCMFVar.dAveCorrelation)*(dCorrelation44-pGLCMFVar.dAveCorrelation))/4;
        pGLCMFVar.dVarLocalCalm=((dLocalCalm11-pGLCMFVar.dAveLocalCalm)*(dLocalCalm11-pGLCMFVar.dAveLocalCalm)
    +(dLocalCalm22-pGLCMFVar.dAveLocalCalm)*(dLocalCalm22-pGLCMFVar.dAveLocalCalm)
    +(dLocalCalm33-pGLCMFVar.dAveLocalCalm)*(dLocalCalm33-pGLCMFVar.dAveLocalCalm)
    +(dLocalCalm44-pGLCMFVar.dAveLocalCalm)*(dLocalCalm44-pGLCMFVar.dAveLocalCalm))/4;
    
    
    for(i=0; i<FilterWindowWidth; i++)
        {
            free(arLocalImage[i]) ;
            arLocalImage[i] = NULL;
        }
        free(arLocalImage);
        arLocalImage = NULL;
    
    
    return pGLCMFVar;
    }

     

    说明:

    参考了 《VisualC++数字图像模式识别技术详解》、《数字图像处理与机器视觉-VisualC++与Matlab实现》等书,此类为本文作者原创,可直接调用,转载/引用请注明出处。

    -------------------------------------------------------------------------------------------------------------------------------

    四 参考资料

    GLCM Texture Tutorial
    Gray-level Co-occurrence Matrix(灰度共生矩阵) _ 丕子

    灰度共生矩阵 - tyut - 博客园

    使用OpenCv的cvGLCM报错

    灰度共发矩阵专题_百度文库

    灰度共生矩阵VC++实现_百度文库

    图像的灰度共生矩阵_百度文库

    灰度共生矩阵_百度文库

    提取共生矩阵特征 - wqvbjhc的专栏 - CSDN博客

    基于灰度共生矩阵的纹理特征提取 - docin.com豆丁网

    基于灰度共生矩阵的图像分割方法研究_百度文库

    一个使用GLCM的例子.(修改了CvTexture的bug)

    《VisualC++数字图像模式识别技术详解》

    《数字图像处理与机器视觉-VisualC++与Matlab实现》

    ------------------------------------------------------------------------------------------------------------------------------

    Author:         SKySeraph

    Email/GTalk: zgzhaobo@gmail.com    QQ:452728574

    From:         http://www.cnblogs.com/skyseraph/

    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利.

     -----------------------------------------------------------------------------------------------------------------------------

     
  • 相关阅读:
    Tips:数据的单位
    PHP面向对象三大特性③
    PHP面向对象三大特性②
    PHP面向对象三大特性①
    PHP-初识面向对象
    C# 基础·算法篇
    C# 基础·常见面试
    C# 特殊处理使用方法
    C# 第三方组件使用
    JS 插件使用
  • 原文地址:https://www.cnblogs.com/GarfieldEr007/p/5459523.html
Copyright © 2011-2022 走看看