精华内容
下载资源
问答
  • 灰度共生矩阵的定义以及算法

    千次阅读 2016-07-16 17:06:38
    灰度共生矩阵就是两个灰度在特定的位置上出现的概率Pd(i,j),其中d指一定的方向的距离,i,j分别指灰度率。 算法:通过遍历hd_current,在灰度率矩阵中找到对应的hd_shift,每次把共生矩阵对应(*hd_current,*hd_shift...

    灰度共生矩阵就是两个灰度在特定的位置上出现的概率Pd(i,j),其中d指一定的方向的距离,i,j分别指灰度率。

    算法:通过遍历hd_current,在灰度率矩阵中找到对应的hd_shift,每次把共生矩阵对应(*hd_current,*hd_shift)自增。

    展开全文
  • 上层共生

    2020-04-20 17:45:47
    在CFT中,“超层态”被定义为超重力气体的成分,该气体是通过将CFT分解为“ | 00〉-股”并通过“小的”无异常的超共形发生器作用于各股而获得的。 我们表明,最近构造的带电超层代表了通用超层态超重力对偶的构造的...
  • 共生矩阵

    2020-05-15 14:00:57
    cooc_feature_image(Regions, Image : : LdGray, Direction...每个矩阵元素的平方和,是灰度共生矩阵元素值的平方和,所以也称之为能量,反映了图像灰度分布均匀程度和纹理粗细度。ASM值大表明一种较均一和规则变化的纹

    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越大图像越清晰。

    展开全文
  • 灰度共生矩阵&灰度梯度共生矩阵

    千次阅读 2019-03-11 22:43:26
    文章目录0,感谢1,灰度共生矩阵(Gray Level Cooccurrence Matrix)1.1初识1.2Opencv实现 0,感谢 学习记录,不当之处多多指教,在此感谢以下博主 灰度共生矩阵的原理及实现(特征提取)-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实现

    展开全文
  • 灰度共生矩阵

    2016-08-24 15:10:47
    灰度共生矩阵就是一种通过研究灰度的空间相关特性来描述纹理的常用方法。 灰度共生矩阵生成 编辑 灰度直方图是对图像上单个象素具有某个灰度进行统计的结果,而灰度共生矩阵是对图像上保持某距离的两象素分别...

    概念

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

    灰度共生矩阵生成

    编辑
    灰度直方图是对图像上单个象素具有某个灰度进行统计的结果,而灰度共生矩阵是对图像上保持某距离的两象素分别具有某灰度的状况进行统计得到的。
    取图像(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) ,这样的方阵称为灰度共生矩阵。距离差分值(a,b) 取不同的数值组合,可以得到不同情况下的联合概率矩阵。(a,b) 取值要根据纹理周期分布的特性来选择,对于较细的纹理,选取(1,0)、(1,1)、(2,0)等小的差分值。
    当 a=1,b=0时,像素对是水平的,即0度扫描;当a=0,b=1 时,像素对是垂直的,即90度扫描;当 a=1,b=1时,像素对是右对角线的,即45度扫描;当 a=-1,b=1时,像素对是左对角线,即135度扫描。
    这样,两个象素灰度级同时发生的概率,就将 (x,y)的空间坐标转化为“灰度对” (g1,g2)的描述,形成了灰度共生矩阵。
    实验中对灰度共生矩阵进行了如下的归一化:
    (1)

    灰度共生矩阵的特征

    编辑
    直觉上来说,如果图像的是由具有相似灰度值的像素块构成,则灰度共生矩阵的对角元素会有比较大的值;如果图像像素灰度值在局部有变化,那么偏离对角线的元素会有比较大的值。
    通常可以用一些标量来表征灰度共生矩阵的特征,令G表示灰度共生矩阵常用的特征有:

    ASM 能量(angular second moment)

    也即每个矩阵元素的平方和。
    如果灰度共生矩阵中的值集中在某一块(比如对连续灰度值图像,值集中在对角线;对结构化的图像,值集中在偏离对角线的位置),则ASM有较大值,若G中的值分布较均匀(如噪声严重的图像),则ASM有较小的值。
    能量是灰度共生矩阵元素值的平方和,所以也称能量,反映了图像灰度分布均匀程度和纹理粗细度。如果共生矩阵的所有值均相等,则ASM值小;相反,如果其中一些值大而其它值小,则ASM值大。当共生矩阵中元素集中分布时,此时ASM值大。ASM值大表明一种较均一和规则变化的纹理模式。

    对比度(contrast)

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

    逆差矩(inverse different moment)

    如果灰度共生矩阵对角元素有较大值,IDM就会取较大的值。因此连续灰度的图像会有较大IDM值。
    逆差矩: 反映图像纹理的同质性,度量图像纹理局部变化的多少。其值大则说明图像纹理的不同区域间缺少变化,局部非常均匀。

    熵(entropy)

    若灰度共生矩阵值分布均匀,也即图像近于随机或噪声很大,熵会有较大值。
    熵是图像所具有的信息量的度量,纹理信息也属于图像的信息,是一个随机性的度量,当共生矩阵中所有元素有最大的随机性、空间共生矩阵中所有值几乎相等时,共生矩阵中元素分散分布时,熵较大。它表示了图像中纹理的非均匀程度或复杂程度。

    自相关(correlation)

    其中
    自相关反应了图像纹理的一致性。如果图像中有水平方向纹理,则水平方向矩阵的COR大于其余矩阵的COR值。它度量空间灰度共生矩阵元素在行或列方向上的相似程度,因此,相关值大小反映了图像中局部灰度相关性。当矩阵元素值均匀相等时,相关值就大;相反,如果矩阵像元值相差很大则相关值小。
    最后,可以用一个向量将以上特征综合在一起。例如,当距离差分值(a,b)取四种值的时候,可以综合得到向量:
    h=[ASM1, CON1, IDM1, ENT1, COR1, ..., ASM4, CON4, IDM4, ENT4, COR4]
    展开全文
  • 计算灰度共生矩阵

    千次阅读 2015-05-24 22:01:38
     灰度共生矩阵定义为像素对的联合分布概率,是一个对称矩阵,它不仅反映图像灰度在相邻的方向、相邻间隔、变化幅度的综合信息,但也反映了相同的灰度级像素之间的位置分布特征,是计算纹理特征的基础。  设f(x,y)...
  • 灰度共生矩阵-python

    千次阅读 热门讨论 2018-06-06 18:26:09
    本篇博客参考灰度共生矩阵(GLCM)附Python代码 ,对其进行了完善...灰度共生矩阵中每个元素的值可以定义为(x, y)点与(x + dx, y + dy)点的值对为(i, j)的概率。统计整幅图像中每一种灰度值组合出现的概率矩阵 P 即...
  • 计算灰度共生矩阵GLCM

    2017-07-26 10:58:53
     灰度共生矩阵定义为像素对的联合分布概率,是一个对称矩阵,它不仅反映图像灰度在相邻的方向、相邻间隔、变化幅度的综合信息,但也反映了相同的灰度级像素之间的位置分布特征,是计算纹理特征的基础。  设f(x,y)...
  • 灰度共生矩阵原理

    2019-10-13 22:02:00
    共生矩阵用两个位置的像素的联合概率密度来定义,它不仅反映亮度的分布特性,也反映具有同样亮度或接近亮度的像素之间的位置分布特性,是有关图像亮度变化的二阶统计特征。它是定义一组纹理特征的基础。 由于纹理是...
  • 图像纹理——灰度共生矩阵

    万次阅读 多人点赞 2016-11-11 14:34:18
    在图像中任意一点(x,y)及偏离它的一点(x+a,y+b)(其中a,b为整数,认为定义)构成点对。设该点对的灰度值为(f1,f2),假设图像的最大灰度级为L,则f1与f2的组合共有L*L种。对于整福图像,统计每一种(f1,f2)
  • 我们将共生关系定义在w*w的窗口内,窗口内的不同两个像素p、q为共生关系,其灰度、即为共生灰度。论文算法在计算灰度共生矩阵前会先将灰度值量化为K个等级。当共生关系的考察窗口半径为r时,对于每个像素,我们只...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,256
精华内容 1,702
关键字:

共生定义