cooc_feature_image(Regions, Image : : LdGray, Direction : Energy, Correlation, Homogeneity, Contrast)

Regions：要计算的区域

image：要计算的灰度图像

LDGray：待区分灰度值的个数

**Direction ：矩阵的方向
Energy：灰度能量值


每个矩阵元素的平方和，是灰度共生矩阵元素值的平方和，所以也称之为能量，反映了图像灰度分布均匀程度和纹理粗细度。ASM值大表明一种较均一和规则变化的纹理模式。

Correlation：灰度值相关性



自相关反应了图像纹理的一致性。如果图像中有水平方向纹理，则水平方向矩阵的COR大于其余矩阵的COR值。它度量空间灰度共生矩阵元素在行或列方向上的相似程度，因此，相关值大小反映了图像中局部灰度相关性。当矩阵元素值均匀相等时，相关值就大;相反，如果矩阵像元值相差很大则相关值小。反应了图像纹理的一致性。如果图像中有水平方向纹理，则水平方向矩阵的COR大于其余矩阵的COR值。

Homogeneity：灰度值的局部同质性**

Contrast：灰度值的对比度

*直接反映了某个像素值及其领域像素值的亮度的对比情况。如果偏离对角线的元素有较大值，即图像亮度值变化很快，则CON会有较大取值，这也符合对比度的定义。其中 。反映了图像的清晰度和纹理沟纹深浅的程度。纹理沟纹越深，其对比度越大，视觉效果越清晰；反之，对比度小，则沟纹浅，效果模糊。灰度差即对比度大的象素对越多，这个值越大。灰度公生矩阵中远离对角线的元素值越大，CON越大。

纹理沟纹越深，其对比度越大，视觉效果越清晰；反之，对比度小，则沟纹浅，效果模糊。灰度差即对比度大的象素对越多，这个值越大。灰度公生矩阵中远离对角线的元素值越大，con越大。所以con越大图像越清晰。

文章目录
1，灰度共生矩阵(Gray Level Cooccurrence Matrix)
1.0感谢
1.1初识
1.2Opencv实现
2，灰度梯度共生矩阵(Gray-Gradient Cooccurence Matrix,GGCM)
2.0，感谢
2.1，初识
2.2，Opencv实现



学习记录，不当之处多多指教，在此感谢以下博主


1，灰度共生矩阵(Gray Level Cooccurrence Matrix)
1.0感谢
灰度共生矩阵的原理及实现(特征提取)-OpenCV

灰度共生矩阵的生成和理解

灰度共生矩阵原理
1.1初识


以水平相邻为例：

GLCM(1,1)=1表示I图中左右相邻都为1的只有一对

GLCM(1,2)=2表示I图中左右分别为1，2的有两对，如上图的红线所示
通常我们假设有两个点f(x,y)与f(x+a,y+b)相邻：x方向相隔a，y方向相隔b

a=1，b=0:水平相邻，0度

a=1，b=1:对角相邻，45度

a=-1，b=1:对角相邻，135度

1，灰度共生矩阵定义为：从灰度为i的像素点出发，统计保持一定距离的两具有某灰度分布的像素。统计"灰度对"同时发生的概率，形成了灰度共生矩阵。

2，共生矩阵用两个位置的像素的联合概率密度来定义，它不仅反应亮度的分布特征，也反映具有相同亮度或者接近亮度像素之间的位置分布特性，是有关图像亮度变换的二阶统计特征。

3，一般不直接作为区分纹理特征(数据量大)，一般采用如下统计量：能量，熵，对比度，均匀性，相关性，方差，和平均，和方差，和熵，差方差，差平均，差熵，相关信息测度，最大相关系数。

能量：角二阶矩阵(Angular Second Moment,ASM)，Energy，uniformity，uniformity of energy

公式： ASM=sum(p(i,j).^2)

 p(i,j)是归一化的灰度共生矩阵。反应了图像灰度分布均匀程度和纹理粗细度，图像均匀，纹理较细，反应在共生矩阵就是大量集中在某一部分，因此ASM值大。
熵：(Entropy,ENT)

公式： ENT = sum(p(i,j)*(-log(p(i,j))))

 p(i,j)是归一化的灰度共生矩阵。描述图像具有的信息量的度量，表明图像的复杂度，和复杂度成正比。
反差分矩阵：(Inverse Differential  Moment,IDM)

公式： IDM = sum(p(i,j)/(1+(i-j)^2))

 反应了纹理的清晰程度和规则程度，纹理清晰，规律性强，易于描述，值较大，反之较小。
对比度：(Contrast)

公式： contrast= sum(p(i,j)*(i-j)^2)

 返回图像中某个像素与它的邻居之间的对比度。反映了图像的清晰度和纹理沟纹深浅的程度
1.2Opencv实现

代码源自： 传送门
GLCM.h
#include<iostream>
#include <cassert>
#include <vector>
#include <iterator>
#include <functional>
#include <algorithm>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

typedef vector<vector<int> > VecGLCM;

typedef struct _GLCMFeatures
{
    _GLCMFeatures()
        : energy(0.0)
        , entropy(0.0)
        , contrast(0.0)
        , idMoment(0.0)
    {

    }

    double energy;      // 能量ASM:angular second moment  
    double entropy;     // 熵
    double contrast;    // 对比度
    double idMoment;    // 逆差分矩， inverse difference moment

} GLCMFeatures;

class GLCM
{
public:
    GLCM();
    ~GLCM();

public:
    // 枚举灰度共生矩阵的方向
    enum 
    {
        GLCM_HORIZATION = 0,        // 水平
        GLCM_VERTICAL = 1,          // 垂直
        GLCM_ANGLE45 = 2,           // 45度角
        GLCM_ANGLE135 = 3           // 135度角
    };

public:
    // 计算灰度共生矩阵
    void calGLCM(IplImage* inputImg, VecGLCM& vecGLCM, int angle);
    // 计算特征值
    void getGLCMFeatures(VecGLCM& vecGLCM, GLCMFeatures& features);
public:
    // 初始化灰度共生矩阵
    void initGLCM(VecGLCM& vecGLCM, int size = 16);
    // 设置灰度划分等级，默认值为 16
    void setGrayLevel(int grayLevel) { m_grayLevel = grayLevel; }
    // 获取灰度等级
    int getGrayLevel() const { return m_grayLevel; }
private:
    
	// 计算水平灰度共生矩阵
    void getHorisonGLCM(VecGLCM &src, VecGLCM &dst, int imgWidth, int imgHeight);
    // 计算垂直灰度共生矩阵
    void getVertialGLCM(VecGLCM &src, VecGLCM &dst, int imgWidth, int imgHeight);
    // 计算 45 度灰度共生矩阵
    void getGLCM45(VecGLCM &src, VecGLCM &dst, int imgWidth, int imgHeight);
    // 计算 135 度灰度共生矩阵
    void getGLCM135(VecGLCM &src, VecGLCM &dst, int imgWidth, int imgHeight);

private:
    int m_grayLevel;        // 将灰度共生矩阵划分为 grayLevel 个等级

};

GLCM.cpp
#include "stdafx.h"
#include "GLCM.h"

GLCM::GLCM() : m_grayLevel(16)
{

}

GLCM::~GLCM()
{

}

//==============================================================================
// 函数名称: initGLCM
// 参数说明: vecGLCM,要进行初始化的共生矩阵,为二维方阵
//          size, 二维矩阵的大小,必须与图像划分的灰度等级相等
// 函数功能: 初始化二维矩阵
//==============================================================================

void GLCM::initGLCM(VecGLCM& vecGLCM, int size)
{
    assert(size == m_grayLevel);
    vecGLCM.resize(size);
    for (int i = 0; i < size; ++i)
    {
        vecGLCM[i].resize(size);
    }

    for (int i = 0; i < size; ++i)
    {
        for (int j = 0; j < size; ++j)
        {
            vecGLCM[i][j] = 0;
        }
    }
}

//==============================================================================
// 函数名称: getHorisonGLCM
// 参数说明: src,要进行处理的矩阵,源数据
//          dst,输出矩阵,计算后的矩阵，即要求的灰度共生矩阵
//          imgWidth, 图像宽度
//          imgHeight, 图像高度
// 函数功能: 计算水平方向的灰度共生矩阵
//==============================================================================

void GLCM::getHorisonGLCM(VecGLCM &src, VecGLCM &dst, int imgWidth, int imgHeight)
{
    int height = imgHeight;
    int width = imgWidth;

    for (int i = 0; i < height; ++i)
    {
        for (int j = 0; j < width - 1; ++j)
        {
            int rows = src[i][j];
            int cols = src[i][j + 1];
            dst[rows][cols]++;
        }
    }


}

//==============================================================================
// 函数名称: getVertialGLCM
// 参数说明: src,要进行处理的矩阵,源数据
//          dst,输出矩阵,计算后的矩阵，即要求的灰度共生矩阵
//          imgWidth, 图像宽度
//          imgHeight, 图像高度
// 函数功能: 计算垂直方向的灰度共生矩阵
//==============================================================================

void GLCM::getVertialGLCM(VecGLCM &src, VecGLCM &dst, int imgWidth, int imgHeight)
{
    int height = imgHeight;
    int width = imgWidth;
    for (int i = 0; i < height - 1; ++i)
    {
        for (int j = 0; j < width; ++j)
        {
            int rows = src[i][j];
            int cols = src[i + 1][j];
            dst[rows][cols]++;
        }
    }
}

//==============================================================================
// 函数名称: getGLCM45
// 参数说明: src,要进行处理的矩阵,源数据
//          dst,输出矩阵,计算后的矩阵，即要求的灰度共生矩阵
//          imgWidth, 图像宽度
//          imgHeight, 图像高度
// 函数功能: 计算45度的灰度共生矩阵
//==============================================================================

void GLCM::getGLCM45(VecGLCM &src, VecGLCM &dst, int imgWidth, int imgHeight)
{
    int height = imgHeight;
    int width = imgWidth;
    for (int i = 0; i < height - 1; ++i)
    {
        for (int j = 0; j < width - 1; ++j)
        {
            int rows = src[i][j];
            int cols = src[i + 1][j + 1];
            dst[rows][cols]++;
        }
    }
}


//==============================================================================
// 函数名称: getGLCM135
// 参数说明: src,要进行处理的矩阵,源数据
//          dst,输出矩阵,计算后的矩阵，即要求的灰度共生矩阵
//          imgWidth, 图像宽度
//          imgHeight, 图像高度
// 函数功能: 计算 135 度的灰度共生矩阵
//==============================================================================

void GLCM::getGLCM135(VecGLCM& src, VecGLCM& dst, int imgWidth, int imgHeight)
{
    int height = imgHeight;
    int width = imgWidth;
    for (int i = 0; i < height - 1; ++i)
    {
        for (int j = 1; j < width; ++j)
        {
            int rows = src[i][j];
            int cols = src[i + 1][j - 1];
            dst[rows][cols]++;
        }
    }
}

//==============================================================================
// 函数名称: calGLCM
// 参数说明: inputImg,要进行纹理特征计算的图像,为灰度图像
//          vecGLCM, 输出矩阵,根据灰度图像计算出的灰度共生阵
//          angle,灰度共生矩阵的方向,有水平、垂直、45度、135度四个方向
// 函数功能: 计算灰度共生矩阵
//==============================================================================

void GLCM::calGLCM(IplImage* inputImg, VecGLCM& vecGLCM, int angle)
{
    assert(inputImg->nChannels == 1);
    IplImage* src = NULL;
    src = cvCreateImage(cvGetSize(inputImg), IPL_DEPTH_32S, inputImg->nChannels);
    cvConvert(inputImg, src);

    int height = src->height;
    int width = src->width;
    int maxGrayLevel = 0;
    // 寻找最大像素灰度最大值
    for (int i = 0; i < height; ++i)
    {
        for (int j = 0; j < width; ++j)
        {
            int grayVal = cvGetReal2D(src, i, j);
            if (grayVal > maxGrayLevel)
            {
                maxGrayLevel = grayVal;
            }

        }
    }// end for i

    ++maxGrayLevel;
    VecGLCM tempVec;
    // 初始化动态数组
    tempVec.resize(height);
    for (int i = 0; i < height; ++i)
    {
        tempVec[i].resize(width);
    }

    if (maxGrayLevel > 16)//若灰度级数大于16，则将图像的灰度级缩小至16级，减小灰度共生矩阵的大小。
    {
        for (int i = 0; i < height; ++i)
        {
            for (int j = 0; j < width; ++j)
            {
                int tmpVal = cvGetReal2D(src, i, j);
                tmpVal = (tmpVal*m_grayLevel)/maxGrayLevel;
                tempVec[i][j] = tmpVal;
            }
        }

        if (angle == GLCM_HORIZATION)  // 水平方向
            getHorisonGLCM(tempVec, vecGLCM, width, height);
        if (angle == GLCM_VERTICAL)    // 垂直方向
            getVertialGLCM(tempVec, vecGLCM, width, height);
        if (angle == GLCM_ANGLE45)     // 45 度灰度共生阵
            getGLCM45(tempVec, vecGLCM, width, height);
        if (angle == GLCM_ANGLE135)    // 135 度灰度共生阵
            getGLCM135(tempVec, vecGLCM, width, height);
    }
    else//若灰度级数小于16，则生成相应的灰度共生矩阵
    {
        for (int i = 0; i < height; ++i)
        {
            for (int j = 1; j < width; ++j)
            {
                int tmpVal = cvGetReal2D(src, i, j);
                tempVec[i][j] = tmpVal;
            }
        }

        if (angle == GLCM_HORIZATION)  // 水平方向
            getHorisonGLCM(tempVec, vecGLCM, width, height);
        if (angle == GLCM_VERTICAL)    // 垂直方向
            getVertialGLCM(tempVec, vecGLCM, width, height);
        if (angle == GLCM_ANGLE45)     // 45 度灰度共生阵
            getGLCM45(tempVec, vecGLCM, width, height);
        if (angle == GLCM_ANGLE135)    // 135 度灰度共生阵
            getGLCM135(tempVec, vecGLCM, width, height);
    }

    cvReleaseImage(&src);
}

//==============================================================================
// 函数名称: getGLCMFeatures
// 参数说明: vecGLCM, 输入矩阵,灰度共生阵
//          features,灰度共生矩阵计算的特征值,主要包含了能量、熵、对比度、逆差分矩
// 函数功能: 根据灰度共生矩阵计算的特征值
//==============================================================================

void GLCM::getGLCMFeatures(VecGLCM& vecGLCM, GLCMFeatures& features)
{
    int total = 0;

    for (int i = 0; i < m_grayLevel; ++i)
    {
        for (int j = 0; j < m_grayLevel; ++j)
        {
            total += vecGLCM[i][j];     // 求所有图像的灰度值的和
        }
    }

    vector<vector<double> > temp;
    temp.resize(m_grayLevel);
    for (int i = 0; i < m_grayLevel; ++i)
    {
        temp[i].resize(m_grayLevel);
    }

    // 归一化
    for (int i = 0; i < m_grayLevel; ++i)
    {
        for (int j = 0; j < m_grayLevel; ++j)
        {
            temp[i][j] = (double)vecGLCM[i][j] / (double)total;
        }
    }

    for (int i = 0; i < m_grayLevel; ++i)
    {
        for (int j = 0; j < m_grayLevel; ++j)
        {
            features.energy += temp[i][j] * temp[i][j]; //ASM

            if (temp[i][j]>0)
                features.entropy -= temp[i][j] * log(temp[i][j]);               //熵     

            features.contrast += (double)(i - j)*(double)(i - j)*temp[i][j];        //对比度
            features.idMoment += temp[i][j] / (1 + (double)(i - j)*(double)(i - j));//逆差矩
        }
    }
}

调用：
		//src为输入图像IplImage,自己load一张图像即可
		IplImage* img = cvCreateImage(cvGetSize(src),src->depth,src->nChannels);
		cvCopy(src,img);

        GLCM glcm;
        VecGLCM vec;
        GLCMFeatures features;
        glcm.initGLCM(vec);
        // 水平
        glcm.calGLCM(img, vec, GLCM::GLCM_HORIZATION);
        glcm.getGLCMFeatures(vec, features);
        double energy_hor = features.energy;
        double entropy_hor = features.entropy;
        double contrast_hor = features.contrast;
        double idMoment_hor = features.idMoment;

        // 垂直
        glcm.calGLCM(img, vec, GLCM::GLCM_VERTICAL);
        glcm.getGLCMFeatures(vec, features);
        double energy_vetical = features.energy;
        double entropy_vetical = features.entropy;
        double contrast_vetical = features.contrast;
        double idMoment_vetical = features.idMoment;


        // 45 度
        glcm.calGLCM(img, vec, GLCM::GLCM_ANGLE45);
        glcm.getGLCMFeatures(vec, features);
        double energy_45 = features.energy;
        double entropy_45 = features.entropy;
        double contrast_45 = features.contrast;
        double idMoment_45 = features.idMoment;


        // 135 度
        glcm.calGLCM(img, vec, GLCM::GLCM_ANGLE135);
        glcm.getGLCMFeatures(vec, features);
        double energy_135 = features.energy;
        double entropy_135 = features.entropy;
        double contrast_135 = features.contrast;
        double idMoment_135 = features.idMoment;

        double energy_average = (energy_135 + energy_45 + energy_hor + energy_vetical) / 4;
        double entropy_average = (entropy_135 + entropy_45 + entropy_hor + entropy_vetical) / 4;
        double contrast_average = (contrast_135 + contrast_45 + contrast_hor + contrast_vetical) / 4;
        double idMoment_average = (idMoment_135 + idMoment_45 + idMoment_hor + idMoment_vetical) / 4;


 原作者灰度分级
//GLCM.cpp Line187
tmpVal /= m_grayLevel);

改为
tmpVal = (tmpVal*m_grayLevel)/maxGrayLevel;


2，灰度梯度共生矩阵(Gray-Gradient Cooccurence Matrix,GGCM)
2.0，感谢
灰度梯度共生矩阵纹理特征

灰度梯度共生矩阵Python
2.1，初识
 1，灰度梯度共生矩阵不仅反应了灰度之间的关系，还反映了梯度之间的关系。灰度是构建图像的基础，梯度是构建图像边缘的要素。

 2，描绘了图像内各像素点灰度与梯度的分布规律，给出了像点与其领域内像点的空间关系，能很好的描绘纹理。对于方向性的纹理也可以从梯度方向上反应出来。

 3，由之前相邻的像素点组成的共生矩阵变成灰度度和梯度图对应点组成的共生矩阵。

 4, 与GLCM的区别，GLCM是灰度级nGray*nGray组成的矩阵，GGCM是灰度级nGray与梯度级nGrad组成的矩阵。GLCM统计的是灰度对(相邻或其他方式)的个数，GGCM统计的是灰度-梯度对(灰度图像，梯度图像相同位置对应)的个数。
2.2，Opencv实现

1.概念
       Co-occurrence Histograms of Oriented Gradients(Co-HOG)，即共生矩阵梯度方向直方图特征，是一种高维特征，其主要的特点就是引入了共生矩阵。Co-HOG将每个像素点的梯度方向进行成对的组合，同时将原来的梯度方向划分为8个，范围从0度到360度，即每45度为一个bin。由于每两个像素点组成一个组合，所以共生矩阵的大小为8x8=64.梯度方向图及梯度对图如下所示：

2.点对中的偏移关系
       所找点对之间的相对位置，比如上下关系，左右关系等等叫做偏移方式。点对中的偏移关系有31种形式，如图所示，任意一个白点与黑点的组合都是一种偏移方式，同时白点本身也是一种偏移方式。
                                                             偏移关系总图
所以给定一种偏移方式，我们可视化共生矩阵的过程如下图所示：
3.Co-HOG特征实现过程
（1）对整幅图像进行和HOG特征一样的梯度计算。然后将图像按照宽高比均分为m*n个小块，例如原图是18x36，那么生成的每个小块为3x6,所以就生成了6*6个小块（小块是无重叠区域的）；
（2）选定一种偏移方式对每个小块进行扫描，生成一个共生矩阵，这样就会生成一个m*n*64的列向量；
（3）然后变换一种偏移关系在整幅图像上扫描，直到31种所有偏移方式都扫描一次。这样将会生成31*64*m*n的列向量，也就是最终的Co-HOG特征。
那么整个Co-HOG特征的计算过程如下图所以：
4.Co-HOG特征的优势
        Co-HOG特征与HOG特征一样，在光照变化和形变下具有鲁棒性，除此之外，由于CO-HOG特征是高维特征，因此它更加细化地表达了图像形状的信息。我们知道HOG特征在计算上包括更多的复杂步骤，例如方向权值投票，梯度方向直方图归一化，还有小区域是重叠的，而Co-HOG却不需要这些步骤，所以计算速度更快。
5.Co-HOG特征计算实现的伪代码

灰度共生矩阵特征分析法
相邻某一间隔长度的两个像素，它们之间要么具有相同的灰度级，要么具有不同的灰度级，若能找出这样两个像素的联合分布的统计形式，对于图像的纹理分析很有意义。
灰度共生矩阵(GLDM)的统计方法是20世纪70年代初由R.Haralick等人提出的，它是在假定图像中各像素间的空间分布关系包含了图像纹理信息的前提下，提出的具有广泛性的纹理分析方法。
灰度共生矩阵被定义为从图像中每一个灰度为i的像素点出发，离开某个固定位置(相隔距离为d，方位为0度、45度、90度等)，正好灰度值为j的概率，即所有估计的值可以表示成一个矩阵的形式，以此被称为灰度共生矩阵。
这里：
1.从哪个灰度级i出发，人为指定。
2.相隔距离与方向也人为指定,方向可以通过[0 d]来指定。
0度：              [0 d]
45度：             [-d d]
90度：             [-d 0]
135度：            [-d -d]
3.另一个灰度级j也人为指定。
对于纹理变化缓慢的图像，其灰度共生矩阵对角线上的数值较大；而对于纹理变化较快的图像，其灰度共生矩阵对角线上的数值较小，对角线两侧的值较大。
由于灰度共生矩阵的数据量较大，一般不直接作为区分纹理的特征，而是基于它构建的一些统计量作为纹理分类特征。
Haralick曾提出了14种基于灰度共生矩阵计算出来的统计量：即：能量、熵、对比度、均匀性、相关性、方差、和平均、和方差、和熵、差方差、差平均、差熵、相关信息测度以及最大相关系数。
下图显示了如何求解灰度共生矩阵：
下面这幅图总有8个灰度级
以出发点灰度级1，目标点灰度级也为1为例，设查找方向水平间隔为1(方向为水平方向，包括左右)，GLCM(1，1)值为1说明只有1对的像素水平相邻。
以出发点灰度级1，目标点灰度级也为2为例，设查找方向水平间隔为1(方向为水平方向，包括左右)，GLCM(1，2)值为1说明只有2对的像素水平相邻。
举例几种常用的统计值
1.角二阶矩(Angular Second Moment, ASM)
角二阶矩又称能量，是图像灰度分布均匀程度和纹理粗细的一个度量，反映了图像灰度分布均匀程度和纹理粗细度。当图像纹理均一规则时，能量值较大；反之灰度共生矩阵的元素值相近，能量值较小。
2.熵(Entropy, ENT)
熵度量了图像包含信息量的随机性，表现了图像的复杂程度。当共生矩阵中所有值均相等或者像素值表现出最大的随机性时，熵最大。
3.对比度
对比度反应了图像的清晰度和纹理的沟纹深浅。纹理越清晰反差越大对比度也就越大。
4.反差分矩阵(Inverse Differential Moment, IDM)
反差分矩阵又称逆方差，反映了纹理的清晰程度和规则程度，纹理清晰、规律性较强、易于描述的，值较大。
​
5.能量
能量变换反映了图像灰度分布均匀程度和纹理粗细度。若灰度共生矩阵的元素值相近，则能量较小，表示纹理细致；若其中一些值大，而其它值小，则能量值较大。能量值大表明一种较均一和规则变化的纹理模式。
6.逆方差
逆方差反映了图像纹理局部变化的大小，若图像纹理的不同区域间较均匀，变化缓慢，逆方差会较大，反之较小。
7.相关性
用来度量图像的灰度级在行或列方向上的相似程度，因此值得大小反应了局部灰度相关性，值越大，相关性也越大。