颜色直方图匹配（一）

ゞ浴缸里的玫瑰 2022-08-19 13:08 256阅读 0赞

最近在研究颜色直方图匹配算法，提取一张图的色彩特征有很多种方法，最常用的一种特征是提取它的颜色直方图分布特征。网上搜了很多文章，颜色直方图匹配算法主要有两类，一类基于RGB色彩空间的直方图匹配，另一类是基于HSV色彩空间的直方图匹配。其中基于RGB色彩空间的直方图匹配，网上大多是将图像分成RGB三通道，计算每一个通道的直方图，然后求平均，最后计算相似度；我觉得这种方法会丢失很多颜色特征，很不靠谱，还不如直接转成灰度图像，求灰度直方图并计算相似度。在维基百科上看到一种基于区间统计的颜色直方图方法，感觉比较靠谱，它是将R,G,B各分量的颜色信息划分为N 区间。比如；将图像每个像素的R、G和B的值都分成4个bins(256除以64)，构建RGB（4X4X4 ）颜色模型，然后再统计各个区间内的像素数，如下图：

![Center][]  
  
C/C++代码实现方法如下：

统计颜色直方图方法一：采用三维数组a\[\]\[\]\[\]来遍历Mat每一个像素。

vector<float> getHist1(Mat testImg)//RGB色彩空间的（4，4，4）模型。
    {
    	const int div = 64;
    	const int bin_num = 256 / div;
    	int length = bin_num*bin_num*bin_num;
    	Vec3i pix;
    	vector<float> b;
    	float a[bin_num*bin_num*bin_num] = { 0 };
    	float d[bin_num][bin_num][bin_num] = { 0 };
    
    	for (int r = 0; r < testImg.rows; r++)
    	{
    		for (int c = 0; c < testImg.cols; c++)
    		{
    			pix = testImg.at<Vec3b>(r, c);
    			pix.val[0] = pix.val[0] / div;
    			pix.val[1] = pix.val[1] / div;
    			pix.val[2] = pix.val[2] / div;
    			//	testImg.at<Vec3b>(r, c) = pix;
    			d[pix.val[0]][pix.val[1]][pix.val[2]]++;
    		}
    	}
    	float sum = 0;
    	for (int i = 0; i < bin_num; i++)
    	for (int j = 0; j < bin_num; j++)
    	for (int k = 0; k < bin_num; k++){
    		a[i*bin_num*bin_num + j*bin_num + k] = d[i][j][k];
    		sum += d[i][j][k];
    		cout << d[i][j][k] << " ";
    	}
    	for (int i = 0; i < length; i++)//归一化
    	{
    		a[i] = a[i] / sum;
    		b.push_back(a[i]);
    	}
    	return b;
    }

统计颜色直方图方法二：采用一维数组a\[\]来遍历Mat每一个像素。

vector<float> getHist(Mat testImg)//RGB色彩空间的（8，8，8）模型。
    {
    	//CV_8UC3---Vec3b  
    	//相应的CV_8SC3---Vec3s  
    	//相应的CV_16UC3---Vec3w  
    	const int div = 32;
    	const int bin_num = 256 / div;
    	const int length = bin_num*bin_num*bin_num;
    	Vec3i pix;
    	vector<float> b;
    	int ord = 0;
    	float a[length] = { 0 };
    	//Mat test = Mat::zeros(64, 1, CV_8UC1);
    	//Mat mat = cvCreateMat(64, 1, CV_32FC1);
    
    	for (int r = 0; r < testImg.rows; r++)
    	{
    		for (int c = 0; c < testImg.cols; c++)
    		{
    			pix = testImg.at<Vec3b>(r, c);
    			pix.val[0] = pix.val[0] / div;
    			pix.val[1] = pix.val[1] / div;
    			pix.val[2] = pix.val[2] / div;
    			//	testImg.at<Vec3b>(r, c) = pix;
    			ord = pix.val[0] * bin_num * bin_num + pix.val[1] * bin_num + pix.val[2];
    			a[ord] += 1;
    		}
    	}
    
    	float sum = 0;
    	for (int i = 0; i < length; i++)
    	{
    		sum += a[i];
    		//cout << a[i] << " ";
    	}
    	for (int i = 0; i < length; i++)//归一化
    	{
    		a[i] = a[i] / sum;
    		//cout << a[i] << " ";
    		b.push_back(a[i]);
    	}
    	return b;
    }

由于以上方法通过testImg.at<Vec3b>(r, c)的方法遍历每个像素，效率低下，对实时性要求较高的场合，不建议采用。  
有一种更高效的方法就是采用指针来遍历，方法如下：

vector<float> getHist2(Mat &image)//RGB色彩空间的（4，4，4）模型。
    {
    	const int div = 64;
    	const int bin_num = 256 / div;
    	int nr = image.rows; // number of rows
    	int nc = image.cols; // number of columns
    	if (image.isContinuous())  {
    		// then no padded pixels  
    		nc = nc*nr;
    		nr = 1;  // it is now a 1D array  
    	}
    	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));// mask used to round the pixel value
    	uchar mask = 0xFF << n; // e.g. for div=16, mask= 0xF0
    	int b, g, r;
    	vector<float> bin_hist;
    	int ord = 0;
    	float a[bin_num*bin_num*bin_num] = { 0 };
    	for (int j = 0; j < nr; j++) {
    		const uchar* idata = image.ptr<uchar>(j);
    		for (int i = 0; i < nc; i++) {
    			b = ((*idata++)&mask) / div;
    			g = ((*idata++)&mask) / div;
    			r = ((*idata++)&mask) / div;
    			ord = b * bin_num * bin_num + g * bin_num + r;
    			a[ord] += 1;
    		} // end of row      
    	}
    	float sum = 0;
    //	cout << "a[i]2:" << endl;
    	for (int i = 0; i < div; i++)
    	{
    		sum += a[i];
    //		cout << a[i] << " ";
    	}
    	for (int i = 0; i < div; i++)//归一化
    	{
    		a[i] = a[i] / sum;
    		bin_hist.push_back(a[i]);
    	}
    	return bin_hist;
    
    }

颜色直方图匹配方法实现：

double GetCompareHist(Mat testImg1, Mat testImg2)//基于RGB色彩空间的（4，4，4）模型直方图匹配。
    {
    	double start, end, cost;
    	start = clock();
    	vector<float> b1;
    	vector<float> b2;
    	//b1 = getHist1(testImg1);//采用自带函数(Img.at<Vec3b>(r, c))取像素,时间为：78ms
    	//b2 = getHist1(testImg2);
    	b1 = getHist2(testImg1);//利用指针取像素,时间为：10ms
    	b2 = getHist2(testImg2);
    	double base_test = compareHist(b1, b2, CV_COMP_CORREL);
    	//	double base_test = compareHist(b1, b2, CV_COMP_BHATTACHARYYA);//CV_COMP_BHATTACHARYYA
    	end = clock();
    	cost = end - start;
    	printf("代码执行时间为:%f\n", cost);
    	return base_test;
    }

另一类是基于HSV色彩空间的直方图匹配实现方法：

double GetCompareHist1(Mat src_base, Mat src_test1)//基于HSV色彩空间的直方图匹配。
    {
    	/// 转换到 HSV
    	Mat  hsv_base;
    	Mat  hsv_test1;
    	cvtColor(src_base, hsv_base, CV_BGR2HSV);
    	cvtColor(src_test1, hsv_test1, CV_BGR2HSV);
    
    	/// 对hue通道使用30个bin,对saturatoin通道使用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 hist_base;
    	MatND hist_half_down;
    	MatND hist_test1;
    
    	/// 计算HSV图像的直方图
    	calcHist(&hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false);
    	normalize(hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat());
    
    	calcHist(&hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false);
    	normalize(hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat());
    
    	int compare_method = CV_COMP_CORREL;
    	double base_test = compareHist(hist_base, hist_test1, compare_method);
    	return base_test;
    }

未完待续。。。。。。

[Center]: /images/20220731/858aca1d5ae846b78cd1c0c87784d74e.png