关闭

灰度共生矩阵及相关特征值的计算——opencv

标签: opencv
6414人阅读 评论(3) 收藏 举报
分类:
#include<iostream>
#include<opencv2/highgui.hpp>
#include<opencv2/core.hpp>
#include<opencv2/imgcodecs.hpp>
#include<opencv2/opencv.hpp>
using namespace std;
using namespace cv;

const int gray_level = 16;

void getglcm_horison(Mat& input, Mat& dst)//0度灰度共生矩阵
{
    Mat src=input;
    CV_Assert(1 == src.channels());
    src.convertTo(src, CV_32S);
    int height = src.rows;
    int width = src.cols;
    int max_gray_level=0;
    for (int j = 0; j < height; j++)//寻找像素灰度最大值
    {
        int* srcdata = src.ptr<int>(j);
        for (int i = 0; i < width; i++)
        {
            if (srcdata[i] > max_gray_level)
            {
                max_gray_level = srcdata[i];
            }
        }
    }
    max_gray_level++;//像素灰度最大值加1即为该矩阵所拥有的灰度级数
    if (max_gray_level > 16)//若灰度级数大于16,则将图像的灰度级缩小至16级,减小灰度共生矩阵的大小。
    {
        for (int i = 0; i < height; i++)
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width; j++)
            {
                srcdata[j] = (int)srcdata[j] / gray_level;
            }
        }

        dst.create(gray_level, gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height; i++)
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width - 1; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata[j + 1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
    else//若灰度级数小于16,则生成相应的灰度共生矩阵
    {
        dst.create(max_gray_level, max_gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height; i++)
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width - 1; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata[j + 1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
}


void getglcm_vertical(Mat& input, Mat& dst)//90度灰度共生矩阵
{
    Mat src = input;
    CV_Assert(1 == src.channels());
    src.convertTo(src, CV_32S);
    int height = src.rows;
    int width = src.cols;
    int max_gray_level = 0;
    for (int j = 0; j < height; j++)
    {
        int* srcdata = src.ptr<int>(j);
        for (int i = 0; i < width; i++)
        {
            if (srcdata[i] > max_gray_level)
            {
                max_gray_level = srcdata[i];
            }
        }
    }
    max_gray_level++;
    if (max_gray_level > 16)
    {
        for (int i = 0; i < height; i++)//将图像的灰度级缩小至16级,减小灰度共生矩阵的大小。
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width; j++)
            {
                srcdata[j] = (int)srcdata[j] / gray_level;
            }
        }

        dst.create(gray_level, gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height-1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i+1);
            for (int j = 0; j < width ; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
    else
    {
        dst.create(max_gray_level, max_gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height-1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 0; j < width; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
}


void getglcm_45(Mat& input, Mat& dst)//45度灰度共生矩阵
{
    Mat src = input;
    CV_Assert(1 == src.channels());
    src.convertTo(src, CV_32S);
    int height = src.rows;
    int width = src.cols;
    int max_gray_level = 0;
    for (int j = 0; j < height; j++)
    {
        int* srcdata = src.ptr<int>(j);
        for (int i = 0; i < width; i++)
        {
            if (srcdata[i] > max_gray_level)
            {
                max_gray_level = srcdata[i];
            }
        }
    }
    max_gray_level++;
    if (max_gray_level > 16)
    {
        for (int i = 0; i < height; i++)//将图像的灰度级缩小至16级,减小灰度共生矩阵的大小。
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width; j++)
            {
                srcdata[j] = (int)srcdata[j] / gray_level;
            }
        }

        dst.create(gray_level, gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 0; j < width-1; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j+1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
    else
    {
        dst.create(max_gray_level, max_gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 0; j < width-1; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j+1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
}


void getglcm_135(Mat& input, Mat& dst)//135度灰度共生矩阵
{
    Mat src = input;
    CV_Assert(1 == src.channels());
    src.convertTo(src, CV_32S);
    int height = src.rows;
    int width = src.cols;
    int max_gray_level = 0;
    for (int j = 0; j < height; j++)
    {
        int* srcdata = src.ptr<int>(j);
        for (int i = 0; i < width; i++)
        {
            if (srcdata[i] > max_gray_level)
            {
                max_gray_level = srcdata[i];
            }
        }
    }
    max_gray_level++;
    if (max_gray_level > 16)
    {
        for (int i = 0; i < height; i++)//将图像的灰度级缩小至16级,减小灰度共生矩阵的大小。
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width; j++)
            {
                srcdata[j] = (int)srcdata[j] / gray_level;
            }
        }

        dst.create(gray_level, gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 1; j < width; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j-1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
    else
    {
        dst.create(max_gray_level, max_gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 1; j < width; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j-1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
}

void feature_computer(Mat&src, double& Asm, double& Eng, double& Con, double& Idm)//计算特征值
{
    int height = src.rows;
    int width = src.cols;
    int total = 0;
    for (int i = 0; i < height; i++)
    {
        int*srcdata = src.ptr<int>(i);
        for (int j = 0; j < width; j++)
        {
            total += srcdata[j];//求图像所有像素的灰度值的和
        }
    }

    Mat copy;
    copy.create(height, width, CV_64FC1);
    for (int i = 0; i < height; i++)
    {
        int*srcdata = src.ptr<int>(i);
        double*copydata = copy.ptr<double>(i);
        for (int j = 0; j < width; j++)
        {
            copydata[j]=(double)srcdata[j]/(double)total;//图像每一个像素的的值除以像素总和
        }
    }


    for (int i = 0; i < height; i++)
    {
        double*srcdata = copy.ptr<double>(i);
        for (int j = 0; j < width; j++)
        {
            Asm += srcdata[j] * srcdata[j];//能量
            if (srcdata[j]>0)
                Eng -= srcdata[j] * log(srcdata[j]);//熵             
            Con += (double)(i - j)*(double)(i - j)*srcdata[j];//对比度
            Idm += srcdata[j] / (1 + (double)(i - j)*(double)(i - j));//逆差矩
        }
    }
}

int main()
{
    Mat dst_horison, dst_vertical, dst_45, dst_135;

    Mat src = imread("C:\\Users\\aoe\\Desktop\\Visual C+\\Visual C+\\chapter08\\pic\\healthy\\201.bmp");
    if (src.empty())
    {
        return -1;
    }
    Mat src_gray;
    //src.create(src.size(), CV_8UC1);
    //src_gray = Scalar::all(0);
    cvtColor(src, src_gray, COLOR_BGR2GRAY);

    //src =( Mat_<int>(6, 6) << 0, 1, 2, 3, 0, 1, 1, 2, 3, 0, 1, 2, 2, 3, 0, 1, 2, 3, 3, 0, 1, 2, 3, 0, 0, 1, 2, 3, 0, 1, 1, 2, 3, 0, 1, 2 );
    //src = (Mat_<int>(4, 4) << 1, 17, 0, 3,3,2,20,5,26,50,1,2,81,9,25,1);
    getglcm_horison(src_gray, dst_horison);
    getglcm_vertical(src_gray, dst_vertical);
    getglcm_45(src_gray, dst_45);
    getglcm_135(src_gray, dst_135);

    double eng_horison=0, con_horison=0, idm_horison=0, asm_horison=0;
    feature_computer(dst_horison, asm_horison, eng_horison, con_horison, idm_horison);

    cout << "asm_horison:" << asm_horison << endl;
    cout << "eng_horison:" << eng_horison << endl;
    cout << "con_horison:" << con_horison << endl;
    cout << "idm_horison:" << idm_horison << endl;


/*  for (int i = 0; i < dst_horison.rows; i++)
    {
        int *data = dst_horison.ptr<int>(i);
        for (int j = 0; j < dst_horison.cols; j++)
        {
            cout << data[j] << " ";
        }
        cout << endl;
    }
    cout << endl;

    for (int i = 0; i < dst_vertical.rows; i++)
    {
        int *data = dst_vertical.ptr<int>(i);
        for (int j = 0; j < dst_vertical.cols; j++)
        {
            cout << data[j] << " ";
        }
        cout << endl;
    }
    cout << endl;

    for (int i = 0; i < dst_45.rows; i++)
    {
        int *data = dst_45.ptr<int>(i);
        for (int j = 0; j < dst_45.cols; j++)
        {
            cout << data[j] << " ";
        }
        cout << endl;
    }

    cout << endl;

    for (int i = 0; i < dst_135.rows; i++)
    {
        int *data = dst_135.ptr<int>(i);
        for (int j = 0; j < dst_135.cols; j++)
        {
            cout << data[j] << " ";
        }
        cout << endl;
    }*/
    system("pause");
    return 0;
}

参考:
灰度共生矩阵的定义与理解:http://www.cnblogs.com/xiangshancuizhu/archive/2011/07/24/2115266.html

opencv实现:
http://blog.csdn.net/cxf7394373/article/details/6988229
http://download.csdn.net/download/sxnzxz/3419181

1
0
查看评论

灰度共生矩阵及特征提取—OpenCV

因为OpenCV中自带的灰度共生矩阵的计算使用过程中,经常出现问题;之前在项目中使用了别人基于OpenCV重新编写cl_texture的灰度共生矩阵,但该代码只能在MFC环境下使用,且不能释放内存;现有的网上流行的基于OpenCV的灰度共生矩阵的计算,都是基于C++接口实现的;因为,本人使用的是Op...
  • lingtianyulong
  • lingtianyulong
  • 2016-11-04 10:06
  • 3674

OpenCV22(灰度共现矩阵/灰度共生矩阵)

理解它的最好办法,就是我们来一起算一次。 一、先介绍一下基本的概念 灰度共现/共生矩阵,其上元素,是灰度图像中某种形状的像素对,在全图中出现的次数(或者是概率)。(不理解?没关系,一会就明白了) 可以用作图像的一种特征,借以区分不同的图像。 灰度共现矩阵是方阵,矩阵的行数是图像灰度的等级。(不...
  • u014488388
  • u014488388
  • 2016-10-21 07:33
  • 1424

灰度共生矩阵及相关特征值的计算——opencv

#include<iostream> #include<opencv2/highgui.hpp> #include<opencv2/core.hpp> #include<opencv2/imgcodecs.hpp> #include<opencv...
  • yanxiaopan
  • yanxiaopan
  • 2016-08-29 21:39
  • 6414

利用灰度共生矩阵提取图像纹理特征

利用灰度共生矩阵提取图像纹理特征 --xuliang
  • vipxuliang
  • vipxuliang
  • 2014-07-21 11:02
  • 4246

灰度共生矩阵(GLCM,Gray-Level Co-occurrence Matrix)

概念 由于纹理是由灰度分布在空间位置上反复出现而形成的,因而在图像空间中相隔某距离的两像素之间会存在一定的灰度关系,即图像中灰度的空间相关特性。灰度共生矩阵就是一种通过研究灰度的空间相关特性来描述纹理的常用方法。 灰度共生矩阵是涉及像素距离和角度的矩阵函数,它通过计算图像中一定距离和一定方向的两点灰...
  • panda1234lee
  • panda1234lee
  • 2017-05-08 13:51
  • 1179

灰度共生矩阵四个方向得到一组特征值

#include #include #include #include #include using namespace std; using namespace cv; const int gray_level = 16; void getglcm_horison(...
  • jiangjiao4726
  • jiangjiao4726
  • 2017-07-18 09:40
  • 388

图像纹理——灰度共生矩阵

1.灰度共生矩阵 本文是借用一篇文章的例子讲解灰度共生矩阵,用文字说明感觉说不清,自己之前用该方法做过实验,还是会忘,所以干脆用例子的方式介绍,下一次再看也容易理解。 在图像中任意一点(x,y)及偏离它的一点(x+a,y+b)(其中a,b为整数,认为定义)构成点对。设该点对的灰度值为(f1,f2),...
  • guanyuqiu
  • guanyuqiu
  • 2016-11-11 14:34
  • 7670

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

在网上看了很多灰度共生矩阵生成的例子感觉都没有说明白,要不就直接上结果要不就给一堆看不懂的代码和公式,后来看了matlab中的介绍就明白了,其实很简单,仔细把下面的看三遍就理解怎么来的了! GLCM表其实就是所有像素可能的组合,比如,GLCM(1,1)就是I中像素值为1和1的组合,GL...
  • jialeheyeshu
  • jialeheyeshu
  • 2016-05-07 12:40
  • 1517

VC++&amp;opencv实现的灰度共生矩阵

  • 2011-07-05 13:54
  • 9.47MB
  • 下载

灰度共生矩阵vs2010+opencv2

  • 2014-04-07 22:26
  • 4KB
  • 下载
    个人资料
    • 访问:118604次
    • 积分:2338
    • 等级:
    • 排名:第18907名
    • 原创:115篇
    • 转载:68篇
    • 译文:0篇
    • 评论:5条
    最新评论