opencv 颜色直方图（灰度图，均衡化，对比，描绘颜色直方图）

参考：

《OpenCV3编程入门》

《学习OpenCV(中文版)》

#################################################################33

最近上课需要将颜色直方图的内容，所以就把直方图一些常用的知识点复习了一遍，包括灰度图，均衡化，对比等。

#include "hist.h"

/**
 * @function : 显示灰度图和均衡化后的灰度图
 * @param : img_address - const string 图片地址
*/
void show_gray(const string img_address)
{
Mat img, dst;
//加载源图像
img = imread(img_address, 1);
if (img.empty()) 
{
cout<<"读取图片错误\n";
return ;
}

//转为灰度图
cvtColor(img, img, COLOR_BGR2GRAY);

//直方图均衡化
equalizeHist(img, dst);

imshow("show", img);
//显示结果
imshow("show_equalize", dst);

waitKey(0);
}

/**
 * @function : 提取灰度颜色直方图并展示
 * @param : color_address - string 图像地址 
*/
void show_gray_color_histogram(const string color_address)
{
//载入原图并显示
Mat srcImage = imread(color_address, 0);
//imshow("原图", srcImage);
if (!srcImage.data) 
{
cout<<"fail to load image"<<endl;
return ;
}
Mat dst;
equalizeHist(srcImage, dst);
imshow("均衡化", dst);

//定义变量
MatND dstHist;
int dims = 1;
float hranges[] = {0,255};
const float *ranges[] = {hranges};
int size = 256;
int channels = 0;

//计算直方图
calcHist(&dst, 1, &channels, Mat(), dstHist, dims, &size, ranges);
int scale = 1;

Mat dstImage(size*scale, size, CV_8U, Scalar(0));
//获取最大值和最小值
double maxValue = 0;
double minValue = 0;
minMaxLoc(dstHist, &minValue, &maxValue, 0, 0);

//绘制直方图
int hpt = saturate_cast<int>(0.9 * size);
for (int i=0; i<256; i++) 
{
float binValue = dstHist.at<float>(i);
int realValue = saturate_cast<int>(binValue * hpt / maxValue);
rectangle(dstImage, Point(i*scale, size-1), Point((i+1)*scale-1, size-realValue), Scalar(255));
}
imshow("灰度直方图", dstImage);
waitKey(0);
}

/**
 * @function : 绘制RGB颜色直方图
 * @param : img_address - const string 图片地址
*/
void show_RGB_histogram(const string img_address)
{
//载入图片
Mat srcImage;
srcImage = imread(img_address);
imshow("原图", srcImage);

//参数准备
int bins = 256;
int hist_size[] = {bins};
float range[] = {0, 256};
const float *ranges[] = {range};
MatND redHist, greenHist, blueHist;
int channels_r[] = {0};

//进行直方图的计算(红色部分)
calcHist(&srcImage, 1, channels_r, Mat(), redHist, 1, hist_size, ranges, true, false);

//绿色分量计算
int channels_g[] = {1};
calcHist(&srcImage, 1, channels_g, Mat(), greenHist, 1, hist_size, ranges, true, false);

//蓝色分量计算
int channels_b[] = {1};
calcHist(&srcImage, 1, channels_b, Mat(), blueHist, 1, hist_size, ranges, true, false);

//绘制rgb颜色直方图
//参数准备
double maxValue_red, maxValue_green, maxValue_blue;
minMaxLoc(redHist, 0, &maxValue_red, 0, 0);
minMaxLoc(greenHist, 0, &maxValue_green, 0, 0);
minMaxLoc(blueHist, 0, &maxValue_blue, 0, 0);
int scale = 1;
int histHeight = 256;
Mat histImage = Mat::zeros(histHeight, bins*3, CV_8UC3);

//开始绘制
for (int i=0; i<bins; i++)
{
//参数准备
float binValue_red = redHist.at<float>(i);
float binValue_green = greenHist.at<float>(i);
float binValue_blue = blueHist.at<float>(i);

int intensity_red = cvRound(binValue_red * histHeight / maxValue_red); //计算绘制高度
int intensity_green = cvRound(binValue_green * histHeight / maxValue_green); //计算绘制高度
int intensity_blue = cvRound(binValue_blue * histHeight / maxValue_blue); //计算绘制高度

//绘制红色部分直方图
rectangle(histImage, Point(i*scale, histHeight-1), Point((i+1)*scale-1, histHeight-intensity_red), Scalar(0, 0, 255));

//绘制绿色部分直方图
rectangle(histImage, Point((i+bins)*scale, histHeight-1), Point((i+bins+1)*scale-1, histHeight-intensity_green), Scalar(0, 255, 0));

//绘制蓝色部分直方图
rectangle(histImage, Point((i+bins*2)*scale, histHeight-1), Point((i+bins*2+1)*scale-1, histHeight-intensity_blue), Scalar(255, 0, 0));
}

//在窗口中显示
imshow("RGB", histImage);
waitKey(0);
}

/**
 * @function : 直方图对比
 * @param : srcImg_address - const string 原图地址
 * @param : comp1_address - const string 对比图1地址
 * @param : comp2_address - const string 对比图2地址
*/
void compare_hist(const string srcImg_address, const string comp1_address, const string comp2_address)
{
//声明存储基准图像和另外两张对比图像的矩阵(RGB 和 HSV)
Mat srcImage_base, hsvImage_base;
Mat srcImage_test1, hsvImage_test1;
Mat srcImage_test2, hsvImage_test2;
Mat hsvImage_halfDown;

//载入基准图像(srcImage_base)和两张测试图像srcImage_test1,srcImage_test2，并显示
srcImage_base = imread(srcImg_address, 1);
srcImage_test1 = imread(comp1_address, 1);
srcImage_test2 = imread(comp2_address, 1);
//显示
imshow("基准图像", srcImage_base);
imshow("测试图像1", srcImage_test1);
imshow("测试图像2", srcImage_test2);

//将图像由RGB色彩空间转换到HSV色彩空间
cvtColor(srcImage_base, hsvImage_base, COLOR_BGR2HSV);
cvtColor(srcImage_test1, hsvImage_test1, COLOR_BGR2HSV);
cvtColor(srcImage_test2, hsvImage_test2, COLOR_BGR2HSV);

//创建包含基准图像下半身的半身图像(HSV格式)
hsvImage_halfDown = hsvImage_base(Range(hsvImage_base.rows/2, hsvImage_base.rows-1), Range(0, hsvImage_base.cols-1));

//初始化计算直方图需要的实参
//对hue通道使用30个bin，对saturation通道使用32个bin
int h_bins = 50; int s_bins = 60;
int histSize[] = {h_bins, s_bins};
//hue的取值范围从0到256，saturation取值范围从0到180
float h_ranges[] = {0, 256};
float s_ranges[] = {0, 180};
const float* ranges[] = {h_ranges, s_ranges};
//使用第0和第1通道
int channels[] = {0, 1};

//创建存储直方图的MatND
MatND baseHist;
MatND halfDownHist;
MatND testHist1;
MatND testHist2;

//计算基准图像，两张测试图像，半身基准图像的HSV直方图
calcHist(&hsvImage_base, 1, channels, Mat(), baseHist, 2, histSize, ranges, true, false);
normalize(baseHist, baseHist, 0, 1, NORM_MINMAX, -1, Mat());

calcHist(&hsvImage_halfDown, 1, channels, Mat(), halfDownHist, 2, histSize, ranges, true, false);
normalize(halfDownHist, halfDownHist, 0, 1, NORM_MINMAX, -1, Mat());

calcHist(&hsvImage_test1, 1, channels, Mat(), testHist1, 2, histSize, ranges, true, false);
normalize(testHist1, testHist1, 0, 1, NORM_MINMAX, -1, Mat());

calcHist(&hsvImage_test2, 1, channels, Mat(), testHist2, 2, histSize, ranges, true, false);
normalize(testHist2, testHist2, 0, 1, NORM_MINMAX, -1, Mat());

//按顺序使用4种对比标准将基准图像的直方图与其余各直方图进行对比
for (int i=0; i<4; i++)
{
//进行图像直方图的对比
int compare_method = i;
double base_base = compareHist(baseHist, baseHist, compare_method);
double base_half = compareHist(baseHist, halfDownHist, compare_method);
double base_test1 = compareHist(baseHist, testHist1, compare_method);
double base_test2 = compareHist(baseHist, testHist2, compare_method);

//输出结果
cout<<"方法["<<i<<"]的匹配结果如下:"<<endl;
cout<<"【基准图 - 基准图】："<<base_base<<"  【基准图 - 半身图】："<<base_half<<"  【基准图 - 测试图1】："<<base_test1<<" 【基准图 - 测试图2】："<<base_test2<<endl;
}

cout<<"endl..."<<endl;
waitKey(0);
}

上面代码都是使用全局颜色直方图进行操作。在实际应用中，如果想要进行直方图对比，仅使用全局颜色直方图并不能得到很好的结果，因为全局颜色直方图忽略了图像的空间信息。改进方法如下：

将图像分成若干局域，比如上下左右四等分为４个区域，然后分别提取颜色直方图，计算相似度；

在上一步的基础上还可以增加权重值，对于比较重要的区域赋以高权重值；

还可以使用颜色直方图和其他特征向量进行联合对比，比如纹理特征，形状特征等。