基于C++/opencv 提取图像的直方图

 一个图像是由不同颜色值的像素组成的，像索值在图像中的分布情况是这幅图像的一个重要特征。图像是由像素组成的，在一个单通道的灰度图像中，每个像素的值介于0(黑色)-

255（白色）之间。根据图像的内容，你会发现每个灰度值的像素数目是不同的。

直方图是一个简单的表，它给出了一幅图像或一组图像中拥有给定数值的像素数量。因此，灰度图像的直方图有256个条目(或称为容器)。0号容器给出值为0的像素个数，1号容器给出值为1的像素个数，依此类推。显然，如果你对方图的所有项求和，会得到像素的总数。直方图也可以被归一化，归一化后的所有项之和等于1。在这种情况下，每一项给出的都是拥有特定数值的像素在图像中占的比例。

谢谢原博：http://blog.csdn.net/andrewseu/article/details/49616279

　　　　　http://blog.csdn.net/garfielder007/article/details/49931049

以下是两种提取图像直方图的方法：

法一：

// test1_320平滑处理.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include"iostream"
#include<cv.h>
#include <opencv2/core/core.hpp>
#include<opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
using namespace std;
using namespace cv;


int _tmain(int argc, _TCHAR* argv[])
{
IplImage* src = cvLoadImage("Blind.jpg");
IplImage* hsv = cvCreateImage(cvGetSize(src), 8, 3);
IplImage* h_plane = cvCreateImage(cvGetSize(src), 8, 1);
IplImage* s_plane = cvCreateImage(cvGetSize(src), 8, 1);
IplImage* v_plane = cvCreateImage(cvGetSize(src), 8, 1);
IplImage* planes[] = {h_plane,s_plane};

//H分量划分为16个等级，S分量划分为8个等级
int h_bins = 16, s_bins = 8;
int hist_size[] = { h_bins, s_bins };

//H分量的变化范围
float h_ranges[] = { 0, 180 };
//S分量的变化范围
float s_ranges[] = { 0, 255 };
float* ranges[] = { h_ranges, s_ranges };
//输入图像转到HSV颜色空间
cvCvtColor(src, hsv, CV_BGR2HSV);
cvCvtPixToPlane(hsv, h_plane, s_plane, v_plane,0);
//创建直方图，二维，每个维度上均分
CvHistogram * hist = cvCreateHist(2, hist_size, CV_HIST_ARRAY, ranges, 1);
//根据H,S两个平面数据统计直方图
cvCalcHist(planes, hist, 0, 0);
//获取直方图统计的最大值，用于动态显示直方图
float max_value;
cvGetMinMaxHistValue(hist, 0, &max_value, 0, 0);
//设置直方图显示图像
int height = 240;
int width = (h_bins*s_bins * 6);
IplImage* hist_Img = cvCreateImage(cvSize(width, height), 8, 3);
cvZero(hist_Img);
//用来进行HSV到RGB颜色转换的临时单位图像
IplImage * hsv_color = cvCreateImage(cvSize(1, 1), 8, 3);
IplImage * rgb_color = cvCreateImage(cvSize(1, 1), 8, 3);
int bin_w = width / (h_bins*s_bins);
for (int h = 0; h < h_bins;h++)
{
for (int s = 0; s < s_bins;s++)
{
int i = h*s_bins + s;
//获取直方图中的统计次数，计算显示在图像中的高度
float bin_val = cvQueryHistValue_2D(hist, h, s);
int intensity = cvRound(bin_val*height / max_value);
//获取当前直方图代表的颜色，转换成RGB用于绘制
cvSet2D(hsv_color, 0, 0, cvScalar(h*180.f / h_bins, s*255.f / s_bins, 255,0));
cvCvtColor(hsv_color, rgb_color, CV_HSV2BGR);
CvScalar color = cvGet2D(rgb_color, 0, 0);
cvRectangle(hist_Img, cvPoint(i*bin_w, height),
cvPoint((i+1)*bin_w,height-intensity),color,-1,8,0);
}
}
cvNamedWindow("Source", 1);
cvShowImage("Source", src);
cvNamedWindow("H-S Histogram", 1);
cvShowImage("H-S Histogram", hist_Img);
cvWaitKey(0);
return 0;
}

 

 法二：

// test2_321.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include<opencv2/opencv.hpp>  
#include <opencv2/core/core.hpp>
#include<opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
using namespace std;
using namespace cv;

class HistogramND
{
private:
    Mat image;//源图像  
    int hisSize[1], hisWidth, hisHeight;//直方图的大小,宽度和高度  
    float range[2];//直方图取值范围  
    const float *ranges;
    Mat channelsRGB[3];//分离的BGR通道  
    MatND outputRGB[3];//输出直方图分量  
public:
    HistogramND(){
        hisSize[0] = 256;
        hisWidth = 400;
        hisHeight = 400;
        range[0] = 0.0;
        range[1] = 256.0;
        ranges = &range[0];
    }

    //导入图片  
    bool importImage(String path){
        image = imread(path);
        if (!image.data)
            return false;
        return true;
    }

    //分离通道  
    void splitChannels(){
        split(image, channelsRGB);
    }

    //计算直方图  
    void getHistogram(){
        calcHist(&channelsRGB[0], 1, 0, Mat(), outputRGB[0], 1, hisSize, &ranges);
        calcHist(&channelsRGB[1], 1, 0, Mat(), outputRGB[1], 1, hisSize, &ranges);
        calcHist(&channelsRGB[2], 1, 0, Mat(), outputRGB[2], 1, hisSize, &ranges);

        //输出各个bin的值  
        for (int i = 0; i < hisSize[0]; ++i){
            cout << i << "   B:" << outputRGB[0].at<float>(i);
            cout << "   G:" << outputRGB[1].at<float>(i);
            cout << "   R:" << outputRGB[2].at<float>(i) << endl;
        }
    }

    //显示直方图  
    void displayHisttogram(){
        Mat rgbHist[3];
        for (int i = 0; i < 3; i++)
        {
            rgbHist[i] = Mat(hisWidth, hisHeight, CV_8UC3, Scalar::all(0));
        }
        normalize(outputRGB[0], outputRGB[0], 0, hisWidth - 20, NORM_MINMAX);
        normalize(outputRGB[1], outputRGB[1], 0, hisWidth - 20, NORM_MINMAX);
        normalize(outputRGB[2], outputRGB[2], 0, hisWidth - 20, NORM_MINMAX);
        for (int i = 0; i < hisSize[0]; i++)
        {
            int val = saturate_cast<int>(outputRGB[0].at<float>(i));
            rectangle(rgbHist[0], Point(i * 2 + 10, rgbHist[0].rows), 
                Point((i + 1) * 2 + 10, rgbHist[0].rows - val), Scalar(0, 0, 255), 1, 8);
            val = saturate_cast<int>(outputRGB[1].at<float>(i));
            rectangle(rgbHist[1], Point(i * 2 + 10, rgbHist[1].rows), Point((i + 1) * 2 + 10, 
                rgbHist[1].rows - val), Scalar(0, 255, 0), 1, 8);
            val = saturate_cast<int>(outputRGB[2].at<float>(i));
            rectangle(rgbHist[2], Point(i * 2 + 10, rgbHist[2].rows), Point((i + 1) * 2 + 10, 
                rgbHist[2].rows - val), Scalar(255, 0, 0), 1, 8);
        }

        cv::imshow("R", rgbHist[0]);
        imshow("G", rgbHist[1]);
        imshow("B", rgbHist[2]);
        imshow("image", image);
    }
};




int _tmain(int argc, _TCHAR* argv[])
{
    String path = "D:\\LiHong\\Blind Way Recognition\\MyProject\\test2_321\\test2_321\\Blind.jpg";
    /*cv::Mat img = cv::imread("Blind.jpg");*/
    HistogramND hist;
    /*if (!img.data)
    {
        return -1;
    }*/
    if (!hist.importImage(path)){
        cout << "Import Error!" << endl;
        return -1;
    }
    hist.splitChannels();
    hist.getHistogram();
    hist.displayHisttogram();
    cv::waitKey();


    return 0;
}