灰度共生矩阵（GLCM，Gray-Level Co-occurrence Matrix）

最新推荐文章于 2019-05-29 18:42:26 发布
最新推荐文章于 2019-05-29 18:42:26 发布
阅读量9.4k 收藏 36
点赞数 3
分类专栏： 学习笔记

概念

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

灰度共生矩阵是涉及像素距离和角度的矩阵函数，它通过计算图像中一定距离和一定方向的两点灰度之间的相关性，来反映图像在方向、间隔、变化幅度及快慢上的综合信息。

灰度直方图是对图像上单个像素具有某个灰度进行统计的结果，而灰度共生矩阵是对图像上保持某距离的两像素分别具有某灰度的状况进行统计得到的。


GLCM 所代表的含义

灰度共生矩阵元素所表示的含义，以（1，1）点为例，GLCM（1，1）值为1说明左侧原图只有一对灰度为1的像素水平相邻。GLCM（1，2）值为2，是因为原图有两对灰度为1和2的像素水平相邻。




共生矩阵计算纹理特征

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

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

最大概率(Maximum probability)：表示图像中出现次数最多的纹理特征。 
这里写图片描述

对比度(Contrast)：度量矩阵的值是如何分布和图像中局部变化的多少，反应了图像的清晰度和纹理的沟纹深浅。纹理的沟纹越深，反差越大，效果清晰；反之，对比值小，则沟纹浅，效果模糊。对公式(6)，典型的有κ=2，λ=1。 
这里写图片描述

倒数差分矩(Inverse difference moment)：反映图像纹理的同质性，度量图像纹理局部变化的多少。其值大则说明图像纹理的不同区域间缺少变化，局部非常均匀。 
这里写图片描述

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

其中μx, μy为均值，σx, σy为标准差，计算公式如下 


4. 算法实现 
#pragma once
#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;      // 能量 
    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 calGLCM(cv::Mat &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 个等级

};
  • 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
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
#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 /= m_grayLevel;
//              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);
// }

void GLCM::calGLCM(cv::Mat & inputImg, VecGLCM & vecGLCM, int angle)
{
    assert(inputImg.channels() == 1);
    int height = inputImg.rows;
    int width = inputImg.cols;
    int maxGrayLevel = 0;

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

    ++maxGrayLevel;
    VecGLCM tempVec;
    tempVec.resize(height);
    for (int i = 0 ; i < height ; ++i)
    {
        tempVec[i].resize(width);
    }

    if (maxGrayLevel > 16)
    {
        for (int i = 0 ; i < height ; ++i)
        {
            for (int j = 0 ; j < width ; ++j)
            {
                int tmpVal = inputImg.at<uchar>(i, j);
                tmpVal /= m_grayLevel;
                tempVec[i][j] = tmpVal;
            }
        }

        if (angle == GLCM_HORIZATION)
        {
            getHorisonGLCM(tempVec, vecGLCM, width, height);
        }
        else if (angle == GLCM_VERTICAL)
        {
            getVertialGLCM(tempVec, vecGLCM, width, height);
        }
        else if (angle == GLCM_ANGLE45)
        {
            getGLCM45(tempVec, vecGLCM, width, height);
        }
        else if (angle == GLCM_ANGLE135)
        {
            getGLCM135(tempVec, vecGLCM, width, height);
        }
    }
    else
    {
        for (int i = 0; i < height; ++i)
        {
            for (int j = 0; j < width; ++j)
            {
                int tmpVal = inputImg.at<uchar>(i, j);
                tempVec[i][j] = tmpVal;
            }
        }
        if (angle == GLCM_HORIZATION)
        {
            getHorisonGLCM(tempVec, vecGLCM, width, height);
        }
        else if (angle == GLCM_VERTICAL)
        {
            getVertialGLCM(tempVec, vecGLCM, width, height);
        }
        else if (angle == GLCM_ANGLE45)
        {
            getGLCM45(tempVec, vecGLCM, width, height);
        }
        else if (angle == GLCM_ANGLE135)
        {
            getGLCM135(tempVec, vecGLCM, width, height);
        }
    }
}

//==============================================================================
// 函数名称: 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];

            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));//逆差矩
        }
    }
}
  • 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
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358

#include "GLCM.h"

int main()
{

    IplImage* img = cvLoadImage("1.jpg", 0);
//  cv::Mat src = cv::imread("1.jpg", 0);
    GLCM glcm;
    VecGLCM vec;
    GLCMFeatures features;
    glcm.initGLCM(vec);
    // 水平
    glcm.calGLCM(img, vec, GLCM::GLCM_HORIZATION);
    glcm.getGLCMFeatures(vec, features);
    // 垂直
    glcm.calGLCM(img, vec, GLCM::GLCM_VERTICAL);
    glcm.getGLCMFeatures(vec, features);
    // 45 度
    glcm.calGLCM(img, vec, GLCM::GLCM_ANGLE45);
    glcm.getGLCMFeatures(vec, features);
    // 135 度
    glcm.calGLCM(img, vec, GLCM::GLCM_ANGLE135);
    glcm.getGLCMFeatures(vec, features);

    cout << "asm = " << features.energy << endl;
    cout << "eng = " << features.entropy << endl;
    cout << "Con = " << features.contrast << endl;
    cout << "Idm = " << features.idMoment << endl;
    system("pause");
    return 0;
}

juliosun
关注
  • 3
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算灰度共生矩阵GLCM
cxf7394373的专栏
11-18 4万+
灰度共生矩阵         灰度共生矩阵定义为像素对的联合分布概率，是一个对称矩阵，它不仅反映图像灰度在相邻的方向、相邻间隔、变化幅度的综合信息，但也反映了相同的灰度级像素之间的位置分布特征，是计算纹理特征的基础。        设f(x,y)为一幅数字图像，其大小为M×N，灰度级别为Ng，则满足一定空间关系的灰度共生矩阵为：         其中#(x)表示集合x中的元素
灰度共生矩阵
12-12
用于遥感图像处理的灰度共生矩阵的算法，大二的作业，可能效率不太高，求指正
纹理特征分析的灰度共生矩阵（GLCM）
热门推荐
lskyne的专栏
03-11 7万+
纹理分析是对图像灰度（浓淡）空间分布模式的提取和分析。纹理分析在遥感图像、X射线照片、细胞图像判读和处理方面有广泛的应用。关于纹理，还没有一个统一的数学模型。它起源于表征纺织品表面性质的纹理概念，可以用来描述任何物质组成成分的排列情况，例如医学上X 射线照片中的肺纹理、血管纹理、航天(或航空)地形照片中的岩性纹理等。图像处理中的视觉纹理通常理解为某种基本模式（色调基元）的重复排列。因此描述一种纹理
图像特征提取——灰度共生矩阵（GLCM）
远方的橄榄树
05-18 6万+
灰度共生矩阵（Gray-level Co-occurrence Matrix，GLCM）
灰度共生矩阵代码实现
积沙成塔
06-24 6650
2概念 2灰度共生矩阵生成编辑 灰度直方图是对图像上单个象素具有某个灰度进行统计的结果，而灰度共生矩阵是对图像上保持某距离的两象素分别具有某灰度的状况进行统计得到的。 取图像(N×N)中任意一点 （x，y）及偏离它的另一点 （x+a，y+b），设该点对的灰度值为 （g1，g2）。令点（x，y） 在整个画面上移动，则会得到各种 （g1，g2）值，设灰度值的级
灰度共生矩阵GLCM_matlab_灰度共生矩阵GLCM_
09-29
灰度共生矩阵（Gray Level Co-occurrence Matrix, GLCM）是一种在图像处理领域中用于分析图像纹理特征的统计方法。它通过计算像素对在特定方向和距离上的共生出现频率来提取图像的纹理信息。在MATLAB中实现GLCM，...
GLCM_灰度共生矩阵_python_
10-03
灰度共生矩阵（Gray Level Co-occurrence Matrix，简称GLCM）是图像处理中的一个关键概念，用于描述图像中像素之间的关系。它提供了一种量化分析图像纹理特征的方法，广泛应用于图像分类、图像识别和医学图像分析等...
Gray-level_Co-occurrence_Matrix(灰度共生矩阵).doc
04-28
灰度共生矩阵（Gray-level Co-occurrence Matrix, GLCM）是图像处理中用于分析纹理特征的一种统计方法。它通过计算图像中像素对在特定距离和方向上的出现频率，来揭示图像的局部模式和结构。这种方法特别适用于描述...
灰度共生矩阵GLCM.rar_GLCM 图像分割_glcm纹理分割_图像分割 GLCM_灰度共生分割_灰度共生矩阵
07-14
灰度共生矩阵（Gray Level Co-occurrence Matrix, GLCM）是一种在图像处理领域中用于分析纹理特征的重要工具。它通过统计图像中像素对在特定方向和距离上的出现频率，来提取反映图像纹理结构的统计特性。这个压缩包...
灰度共生矩阵glcm
11-15
图像的纹理分析应用实例 包含了熵、相关性、能量、惯性矩、平稳性
灰度共生矩阵（Gray-level Co-occurrence Matrix，GLCM）
weixin_43415436的博客
05-29 8917
1、概念： (下面这些概念我也不懂，看着就头疼，自行了解，不过应该支持原创！) 1、灰度共生矩阵(GLDM)的统计方法是20世纪70年代初由R.Haralick等人提出的，它是在假定图像中各像素间的空间分布关系包含了图像纹理信息的前提下，提出的具有广泛性的纹理分析方法。 2、灰度共生矩阵（Gray-level Co-occurrence Matrix，GLCM）,又叫做灰度共现矩阵； 3、个人理解...
编程计算图像灰度共生矩阵
最新发布
05-17
灰度共生矩阵（Gray-Level Co-occurrence Matrix，GLCM）是用于描述图像纹理特征的一种方法。GLCM可以反映出图像中灰度级别之间的空间关系，从而描述出图像的纹理特征。下面是一个简单的Python程序，用于计算灰度共生矩阵： ```python import cv2 import numpy as np # 读入图像并转换为灰度图像 img = cv2.imread("test.jpg") gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 定义灰度共生矩阵的参数 d = 1 theta = [0, np.pi/4, np.pi/2, 3*np.pi/4] # 计算灰度共生矩阵 glcm = np.zeros((256, 256, len(theta))) for i in range(gray.shape[0]-d): for j in range(gray.shape[1]-d): for k in range(len(theta)): x = gray[i,j] y = gray[i+d*np.sin(theta[k]), j+d*np.cos(theta[k])] glcm[x,y,k] += 1 # 将灰度共生矩阵归一化 glcm /= np.sum(glcm) # 打印灰度共生矩阵 print(glcm) ``` 在上面的程序中，首先读入了一张测试图像，并将其转换为灰度图像。然后定义了灰度共生矩阵的参数，包括距离和方向。接着使用三重循环遍历图像中的每个像素，并计算出该像素与其相邻像素之间的灰度共生矩阵。最后将灰度共生矩阵归一化，并打印出来。 需要注意的是，上面的程序中计算灰度共生矩阵时只考虑了4个方向，如果需要考虑更多的方向，可以增加theta的取值。此外，在实际应用中，还需要根据具体的任务选择合适的灰度共生矩阵特征，如能量、对比度、相关性等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值