GLCM texture analysis using OpenCV C++

edit

if you have compiled OpenCV with contrib modules you can use cv::plot::Plot2d

i made some modification on your code and get the following graph for lena.jpg

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/plot.hpp>
#include <iostream>

using namespace cv;
using namespace std;


void glcm(const Mat img, vector<double> &vec_energy)
{
    float energy = 0, contrast = 0, homogenity = 0, IDM = 0, entropy = 0, mean1 = 0;
    int row = img.rows, col = img.cols;
    cv::Mat gl = cv::Mat::zeros(256, 256, CV_32FC1);

    //creating glcm matrix with 256 levels,radius=1 and in the horizontal direction
    for (int i = 0; i<row; i++)
        for (int j = 0; j<col - 1; j++)
            gl.at<float>(img.at<uchar>(i, j), img.at<uchar>(i, j + 1)) = gl.at<float>(img.at<uchar>(i, j), img.at<uchar>(i, j + 1)) + 1;

    // normalizing glcm matrix for parameter determination
    gl = gl + gl.t();
    gl = gl / sum(gl)[0];


    for (int i = 0; i<256; i++)
        for (int j = 0; j<256; j++)
        {
            energy = gl.at<float>(i, j)*gl.at<float>(i, j);
            vec_energy.push_back(energy);

            //finding parameters
            contrast = contrast + (i - j)*(i - j)*gl.at<float>(i, j);
            homogenity = homogenity + gl.at<float>(i, j) / (1 + abs(i - j));
            if (i != j)
                IDM = IDM + gl.at<float>(i, j) / ((i - j)*(i - j));                      //Taking k=2;
            if (gl.at<float>(i, j) != 0)
                entropy = entropy - gl.at<float>(i, j)*log10(gl.at<float>(i, j));
            mean1 = mean1 + 0.5*(i*gl.at<float>(i, j) + j*gl.at<float>(i, j));
        }

/*  for (int i = 0; i<256; i++)
    {
        for (int j = 0; j<256; j++)
            cout << a[i][j] << "\t";
        cout << endl;
    }*/


    cout << "energy=" << energy << endl;
    cout << "contrast=" << contrast << endl;
    cout << "homogenity=" << homogenity << endl;
    cout << "IDM=" << IDM << endl;
    cout << "entropy=" << entropy << endl;
    cout << "mean=" << mean1 << endl;
}


int main(int argc, char** argv)
{


    Mat img = cv::imread(argv[1], CV_LOAD_IMAGE_UNCHANGED);

    if (img.empty())
    {
        cout << "can not load " << argv[1];
        return 1;
    }
    imshow("Image", img);

    vector<double> vec_energy;
    glcm(img, vec_energy);   //call to glcm function

    Mat mat_energy = Mat(vec_energy);

    Mat plot_result;

    Ptr<plot::Plot2d> plot = plot::Plot2d::create(mat_energy);
    plot->setShowGrid(false);
    plot->setShowText(false);
    plot->render(plot_result);

    imshow("plot", plot_result);
    cv::waitKey(0);
    return 0;
}

if you don't have plot module installed you can use

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

#include <iostream>

using namespace cv;
using namespace std;

namespace cv
{
    namespace plot
    {
        //! @addtogroup plot
        //! @{

        class CV_EXPORTS_W Plot2d : public Algorithm
        {
        public:

            CV_WRAP virtual void setMinX(double _plotMinX) = 0;
            CV_WRAP virtual void setMinY(double _plotMinY) = 0;
            CV_WRAP virtual void setMaxX(double _plotMaxX) = 0;
            CV_WRAP virtual void setMaxY(double _plotMaxY) = 0;
            CV_WRAP virtual void setPlotLineWidth(int _plotLineWidth) = 0;
            /**
            * @brief Switches data visualization mode
            *
            * @Param _needPlotLine if true then neighbour plot points will be connected by lines.
            * In other case data will be plotted as a set of standalone points.
            */
            CV_WRAP virtual void setNeedPlotLine(bool _needPlotLine) = 0;
            CV_WRAP virtual void setPlotLineColor(Scalar _plotLineColor) = 0;
            CV_WRAP virtual ...