OpenCV_颜色直方图的计算、显示、处理、对比及反向投影

首先介绍一下直方图

一.用带权重的样本统计直方图

直方图Histogram，是一种常见的概率分布的非参数（区别于高斯分布，泊松分布等用参数表达概率密度的方法）表达方法。直方图可以看成概率密度分布的离散化表达方法。它的计算很简单，是一种投票的方法，就是每个样本往对应的小盒子(bin)里投一票。假设N个样本数据x量化为1～M之间的整数，那么Hist是M维数组，对应的直方图计算方法如下：

//initializing
for i=1:M
    Hist[i] = 0;
end
//voting
for  i = 1:N
    Hist[x[i]] += 1 ;
end

为了表示成概率分布，需要Hist数组和为1：

//normalize
for  j = 1:M
    Hist[j] = Hist[j]/sum(Hist) ; //sum(Hist) = Hist[1] + Hist[2] + ... + Hist[M];
end

在这里sum(Hist)等于样本个数N。以上“投票+归一化”两个步骤，其实可以和成一步，即每个样本x[i]有一个对应的权重w[i]=1/N，投票的时候往小盒子里放的是权重：

 

//initializing
for i=1:M
    Hist[i] = 0;
end
//voting
for  i = 1:N
    Hist[x[i]] += w[i] ;
end

 

这样得到数组Hist里的每个值都是一个0-1之间的小数，表示当x取这个值(数组对应的下标)时候的概率。

 

二.样本权重的变化影响直方图形状

如果想改变一个概率分布取曲线的形状，比如，在训练的时候要强调x[i]=3的样本，一种办法是增加这种样本的个数，使Hist[3]变大，另一种方法是增加和它对应的样本的权重w[i]，让某些样本产生“一个顶俩”的效果，这两种方式都能起到改变概率分布的作用。

 

对人脸检测这类基于图像的目标检测方法，需要搜集大量样本进行离线的训练，样本要尽可能覆盖所有可能的情况，从而使所提取特征的概率分布具有代表性，当样本数趋向于无穷大的时候，概率分布就趋向于真实的分布情况。但通常在实际中，样本数总是有限的，这时就可以通过增加某些比较重要的样本的权重，来达到看起来是增加了某些样本数量的效果。

 

另外，直方图数组Hist的某个bin中的样本权重的改变，不应该仅仅影响当前的bin，也应该对周围相邻的bin造成影响。比如，在统计一个地区人群的身高分布的时候，如果只有一个样本x=1.65m，我们可以在Hist数组中对应1.6<=x<1.7这一个bin里投上一票，但是1.5<=x<1.6和1.7<=x<1.8两个bin的得票为0。其实不应该这样，根据身高应该是连续分布的这一假设，从样本x=1.65m可以安全地推断出世上也应该有身高1.59和1.71的人，这样左右两个相邻的bin的值就不应为0，应该也受到x=1.65m这个样本的影响，这种影响可以假设是服从高斯分布，即越远的bin受影响越小。这其实是另一种常见的概率密度估计的非参数方法，kernel density estimation(KDE)。我们的人脸检测应用由于样本足够多，所以没有考虑这一方法。也就是说，每个特征值在投票的时候，只对一个bin起作用，不影响相邻的那两个。

颜色直方图直观的显示了图像在色彩空间的分布状况，本文将讨论在OpenCv中跟直方图相关的一些基本操作，包括：计算、显示、处理、对比及反向投影.

直方图的计算、显示、处理
  OpenCv中，可以用方法cvCalcHist方法计算图像的直方图。不过值得注意的是，该方法的第一个参数image是一个指向数组的IplImage* 类型指针。这允许利用多个图像通道。对于多通道图像（如ＨＳＶ或者ＲＧＢ），在调用函数ｃｖＣａｌｃＨｉｓｔ（）之前，先要调用函数cvSplit()将图像分为单通道，此方法与宏cvCvtPixtoPlane等同，然后再选择需要参与直方图计算的通道。下面有几段计算直方图的代码，分别计算单通道（红色）直方图、色调和饱和度直方图。

如何在OpenCV中绘制一个直方图？下面是有关于绘制直方图实验的学习总结：

1.cvCreateHist(dim,&size,flag,**range,uniform):

   dim为hist的维度；size为总分区间数；flag为标记图像是什么类型，是CV_HIST_ARRAY,还是CV_HIST_TREE,然后就可以选择如何保存数据，如果CV_HIST_ARRAY,就用CvMatND（多维密集数组）；如果CV_HIST_TREE,就使用CvSparseMat（多维稀疏数组）；range为每个维度的范围；uniform为归一化标识，这个还不是很好理解。

2.IplImage中有一个属性可以设置图像的原点坐标，0代表左上角，1代表左下角。(image->origin)

3.cvCalcHist(**imge,*hist):

   image为统计图像，hist为直方图结构体

4.获取了直方图信息后，可以通过直方图结构体直接访问内部信息：

  hist->type；hist->thresh[i][0]和hist->thresh[i][1]分别存储上阀值和下阀值。如果CV_HIST_ARRAY的话，可以通过(（CvMatND*）hist->bins)->data.fl[i]获取统计值。不过OpenCV已经提供了一个很好的方法去查询，cvQueryHistValue_*D(hist,d...);

5.可以通过CV_RGB(R,G,B)的宏设置RGB颜色。

6.直方图的绘制，使用cvQueryHistValue_*D去获取统计值，然后绘制在一个创建好的图像中。可以通过cvLine或者cvRectangle方法。

7.还可以通过设置range的范围来获取有需要的区域，如果这样的话，最好在画直方图的时候，计算好每个区间的width值。

8.cvGetMinMaxValue(hist,*min,*max,*minindex,*maxindex):

  min和max必须为float类型，minindex和maxindex为最小最大值的位置

9.cvRound方法：四舍五入

10.从HSV颜色转换为RGB颜色：

  IplImage* hsv_color = cvCreateImage(cvSize(1,1),8,3);
  IplImage* rgb_color = cvCreateImage(cvSize(1,1),8,3); 

  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);

具体代码如下：

#include "stdafx.h"
#include <iostream>
using namespace std;


#ifdef _CH_
#pragma package <opencv>
#endif

#include "cv.h"
#include "highgui.h"


//色相饱和度直方图
  void CalcHistHs() 
 {
    IplImage* img_source;

    if (img_source = cvLoadImage("flower.jpg",1))
    {
      IplImage* hsv = cvCreateImage(cvGetSize(img_source),8,3);

      //rgb色彩空间转换到hsv色彩空间
      cvCvtColor(img_source,hsv,CV_BGR2HSV);
      cvNamedWindow( "hsv", 1 );
      cvShowImage( "hsv", hsv );

      IplImage* h_plane = cvCreateImage(cvGetSize(img_source),8,1);
      IplImage* s_plane = cvCreateImage(cvGetSize(img_source),8,1);
      IplImage* v_plane = cvCreateImage(cvGetSize(img_source),8,1);

      IplImage* planes[] ={h_plane,s_plane};
      //分割为单通道图像
      cvCvtPixToPlane(hsv,h_plane,s_plane,v_plane,0);
      cvNamedWindow( "h_plane", 1 );
      cvShowImage( "h_plane", h_plane );
      cvNamedWindow( "s_plane", 1 );
      cvShowImage( "s_plane", s_plane );
      cvNamedWindow( "v_plane", 1 );
      cvShowImage( "v_plane", v_plane );


      //build the histogram and compute its contents

      /** H 分量划分为30个等级，S分量划分为32个等级 */
      int h_bins =30, s_bins = 32;

      CvHistogram* hist;

      {
          int hist_size[] = {h_bins,s_bins};
          float h_ranges[] = {0,180}; /* hue varies from 0 (~0°red) to 180 (~360°red again) */

          float s_ranges[] = {0,255};  /* saturation varies from 0 (black-gray-white) to 255 (pure spectrum color) */

          float* ranges[] = {h_ranges,s_ranges};

          /** 创建直方图，二维, 每个维度上均分 */
          hist = cvCreateHist(
              2, // int dims 
              hist_size, // int* sizes 
              CV_HIST_ARRAY, // int type
              ranges, // float** ranges
              1       //uniform 
              );
      }

      //  根据H,S两个平面数据统计直方图 
      cvCalcHist( planes, hist, 0, 0 );
      //归一化处理
      cvNormalizeHist(hist,1.0);
      /** 获取直方图统计的最大值，用于动态显示直方图 */
      float max_value;
      cvGetMinMaxHistValue( hist, 0, &max_value, 0, 0 );

      int scale=10;
      //创建直方图图像
      /** 设置直方图显示图像 */
      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", img_source );

      cvNamedWindow( "H-S Histogram", 1 );
      cvShowImage( "H-S Histogram", hist_img );

     


    }

}

void CalcHistRgb()
{
    IplImage* img_source;

    if (img_source = cvLoadImage("flower.jpg",1))
    {
        IplImage* RedChannel = cvCreateImage( cvGetSize(img_source), 8, 1);
        IplImage* GreenChannel = cvCreateImage( cvGetSize(img_source), 8, 1);
        IplImage* BlueChannel = cvCreateImage( cvGetSize(img_source), 8, 1);
        IplImage* alphaChannel = cvCreateImage( cvGetSize(img_source), 8, 1);
        IplImage* gray_plane = cvCreateImage(cvGetSize(img_source),8,1);

        
        //分割为单通道图像
        cvCvtPixToPlane(img_source,BlueChannel,GreenChannel,RedChannel,0);
        // 显示图像
        cvNamedWindow( "RedChannel", 1 );
        cvNamedWindow( "GreenChannel", 1 );
        cvNamedWindow( "BlueChannel", 1 );
        cvNamedWindow( "lphaChannel", 1 );
        
        cvShowImage( "RedChannel", RedChannel );
        cvShowImage( "GreenChannel", GreenChannel );
        cvShowImage( "BlueChannel", BlueChannel );
        cvShowImage( "lphaChannel", alphaChannel );
       

        cvCvtColor(img_source,gray_plane,CV_BGR2GRAY);
        cvNamedWindow("GrayPlane",1);
        cvShowImage("GrayPlane",gray_plane);
        //OpenCV中不管是Windows中Load的还是摄像头取得的都是BGR顺序排列的

        //然后为这四幅图创建对应的直方图结构。
        int hist_size = 100;

        int hist_height = 100;

        float range[] = {0,255};

        float* ranges[]={range};

        CvHistogram* r_hist = cvCreateHist(1,&hist_size,CV_HIST_ARRAY,ranges,1);

        CvHistogram* g_hist = cvCreateHist(1,&hist_size,CV_HIST_ARRAY,ranges,1);

        CvHistogram* b_hist = cvCreateHist(1,&hist_size,CV_HIST_ARRAY,ranges,1);

        CvHistogram* gray_hist = cvCreateHist(1,&hist_size,CV_HIST_ARRAY,ranges,1);

        //接下来计算直方图，创建用于显示直方图的图像，略去了一部分重复代码，以下也是
        
        cvCalcHist(&RedChannel,r_hist,0,0);
        cvCalcHist(&GreenChannel,g_hist,0,0);
        cvCalcHist(&BlueChannel,b_hist,0,0);
        cvCalcHist(&gray_plane,gray_hist,0,0);
        cvNormalizeHist(gray_hist,1.0);
        cvNormalizeHist(r_hist,1.0);
        cvNormalizeHist(g_hist,1.0);
        cvNormalizeHist(b_hist,1.0);

        int scale = 2;

        IplImage* hist_image = cvCreateImage(cvSize(hist_size*scale,hist_height*4),8,3);

        cvZero(hist_image);

        //然后开始显示，这里对直方图进行了标准化处理，不然的话无法观察到明显的变化。

        float r_max_value = 0;
        float g_max_value = 0;
        float b_max_value = 0;
        float gray_max_value = 0;
        cvGetMinMaxHistValue(r_hist, 0,&r_max_value,0,0);
        cvGetMinMaxHistValue(g_hist, 0,&g_max_value,0,0);
        cvGetMinMaxHistValue(b_hist, 0,&b_max_value,0,0);
        cvGetMinMaxHistValue(b_hist, 0,&gray_max_value,0,0);
        for(int i=0;i<hist_size;i++)
        {

            float r_bin_val = cvQueryHistValue_1D(r_hist,i);

            int r_intensity = cvRound(r_bin_val*hist_height/r_max_value);
            cvRectangle(
                hist_image,
                cvPoint(i*scale,hist_height-1),
                cvPoint((i+1)*scale - 1, hist_height - r_intensity),
                CV_RGB(255,0,0));

            float g_bin_val=cvQueryHistValue_1D(g_hist,i);
            int g_intensity = cvRound(g_bin_val*hist_height/g_max_value);
            cvRectangle(
                hist_image,
                cvPoint(i*scale,2*hist_height-1),
                cvPoint((i+1)*scale - 1, 2*hist_height - g_intensity),
                CV_RGB(0,255,0));

            float b_bin_val = cvQueryHistValue_1D(b_hist,i);
            int b_intensity = cvRound(b_bin_val*hist_height/b_max_value);
            cvRectangle(
                hist_image,
                cvPoint(i*scale,3*hist_height-1),
                cvPoint((i+1)*scale - 1, 3*hist_height - b_intensity),
                CV_RGB(0,0,255));

            float gray_bin_val = cvQueryHistValue_1D(gray_hist,i);
            int gray_intensity = cvRound(gray_bin_val*hist_height/gray_max_value);
            cvRectangle(
                hist_image,
                cvPoint(i*scale,4*hist_height-1),
                cvPoint((i+1)*scale - 1, 4*hist_height - gray_intensity),
                CV_RGB(100,100,100));

        }
         cvNamedWindow( "Source", 1 );
         cvShowImage( "Source", img_source );

         cvNamedWindow( "RGB_Histogram", 1 );
         cvShowImage( "RGB_Histogram", hist_image );

         
    }

}

int main()
{
   CalcHistRgb();
   CalcHistHs();
   cvWaitKey(0);
}

直方图对比

OpenCv提供了5种对比直方图的方式：CORREL（相关）、CHISQR（卡方）、INTERSECT（相交）、BHATTACHARYYA、EMD（最小工作距离），其中CHISQR速度最快，EMD速度最慢且有诸多限制，但是EMD的效果最好。世界总是充满了矛盾，而我们的工作就是化解矛盾，把每种方式都测试一下，找到正好能解决问题并且速度最优的方法。
 需要注意的是：EMD方式要求先将直方图转换成矩阵：
EMD方法会占用很很很大量的内存，在使用前请注意直方图的维数及区间数目，不然会出现内存不足的异常。关于这点，请参看我的另一篇文章《关于使用cvCalcEMD2计算两个直方图间最小工作距离的限制(Why cvCalcEMD2 Throw Insufficient Memory Exception)》。还有一点值得注意的是，不同的对比方式对待结果的方式很不一样，结果越大不一定说明匹配度更高，具体请参看《学习OpenCv》这本书的相关章节。

对于直方图的相关和相交对比，结果值越大（即亮度较高）的地方表示匹配程度越高；
对于直方图的卡方、Bhattacharyya、EMD对比，结果值越小（即越黑暗）的地方表示匹配程度越高。

陆地移动距离EMD

光线能引起图像颜色值的漂移，尽管这些漂移没有改变颜色直方图的形状，但是这些漂移引起了颜色值位置的变化，从而导致前述匹配策略失效。如果利用颜色直方图的距离测量来代替直方图的匹配策略，那么我们仍然可以像直方图对比一样对比两个直方图的距离，即使第二个直方图发生漂移，也能找到最小的距离度量。

陆地移动距离时一种度量准则，它实际上度量的是怎样将一个直方图的形状转变为另一个直方图的形状，包括移动直方图的部分或者全部到一个新的位置，可以在任何维的直方图上进行这种度量。

0表示最精确匹配，半匹配是成功将直方图的一半转换，将左边直方图的一半转换到下一个直方图。最终移动整个直方图到右边需要整个单位的距离（即将模板直方图转换为完全不匹配直方图）。1表示完全不匹配。

具体代码如下：

int main()
{
    /*CalcHistHs("flower.jpg");
   CvHistogram* hist1 = CalcHistRgb("flower.jpg");
   CvHistogram* hist2 = CalcHistRgb("flower3.jpg");

   double result = cvCompareHist(hist1,hist2,CV_COMP_CORREL);
   cout<< result;
  
   cvWaitKey(0);*/

    IplImage *src = cvLoadImage("flower.jpg");
    IplImage *hsv = cvCreateImage(cvGetSize(src),8,3);
    cvCvtColor(src,hsv,CV_BGR2HSV);// change RGB of src to HSV of hsv
    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};
    cvSplit(hsv,h_plane,s_plane,v_plane,0);//split HSV to 3 channal

    //求得直方图
    int h_bins=30,s_bins=32;
    CvHistogram *hist1,*hist2;
    int size[]={h_bins,s_bins};
    float h_ranges[]={0,180};
    float s_ranges[]={0,255};
    float *ranges[]={h_ranges,s_ranges};

    hist1=cvCreateHist(2,size,CV_HIST_ARRAY,ranges,1);
    cvCalcHist(planes,hist1,0,0);//只能一个通道一个通道的写入直方图，所以上面分成H、S、V
    cvNormalizeHist(hist1,1.0);//归一化直方图，使所有块的值加起来为1
    hist2=cvCreateHist(2,size,CV_HIST_ARRAY,ranges,1);
    cvCalcHist(planes,hist2,0,0);
    cvNormalizeHist(hist2,1.0);

    //求得signature用于比较直方图
    CvMat *sig1,*sig2;
    int numrows=h_bins*s_bins;
    sig1=cvCreateMat(numrows,3,CV_32FC1);//由于是2维图像直方图，所以只需保存每个点的(值，横坐标，纵坐标)三个数，一共numrows个点
    sig2=cvCreateMat(numrows,3,CV_32FC1);
    for(int h=0;h<h_bins;h++)
    {
        for(int s=0;s<s_bins;s++)
        {
            float bin_val=cvQueryHistValue_2D(hist1,h,s);
            cvSet2D(sig1,h*s_bins+s,0,cvScalar(bin_val));
            cvSet2D(sig1,h*s_bins+s,1,cvScalar(h));
            cvSet2D(sig1,h*s_bins+s,2,cvScalar(s));
            bin_val=cvQueryHistValue_2D(hist2,h,s);
            cvSet2D(sig2,h*s_bins+s,0,cvScalar(bin_val));
            cvSet2D(sig2,h*s_bins+s,1,cvScalar(h));
            cvSet2D(sig2,h*s_bins+s,2,cvScalar(s));
        }
    }
    float emd=cvCalcEMD2(sig1,sig2,CV_DIST_L2);
    cout<<emd;//可以清楚的看出因为我对比同一个图像直方图，所以得数0是对的，完全一样
    cvWaitKey(0);
    return 0;


}

直方图的反向投影

我对于反向投影的理解是通过颜色直方图，检测图片中的某个像素点的颜色是否位于直方图中，若位于则将其加亮（阀值化？），通过对图像的检测，得出结果图像。如果照着我这个理解的话，那么对同一物体的颜色的取样点越多，那么越能更好的找出目标图形（当然，这很可能也会带来一些不需要的点，那么这个方法应该对于对比度较大的图像比较有效……）

换个说法就是在反向投影中，直方图的作用在于提供一个比较标准，即对于要检测的图像来说，需要给它提供一个用于识别出它需要被识别出的部分的直方图。

1.反向投影的作用是什么？
    反向投影用于在输入图像（通常较大）中查找特定图像（通常较小或者仅1个像素，以下将其称为模板图像）最匹配的点或者区域，也就是定位模板图像出现在输入图像的位置。
2.反向投影如何查找（工作）？
    查找的方式就是不断的在输入图像中切割跟模板图像大小一致的图像块，并用直方图对比的方式与模板图像进行比较。

假设我们有一张100x100的输入图像，有一张10x10的模板图像，查找的过程是这样的：
（1）从输入图像的左上角(0,0)开始，切割一块(0,0)至(10,10)的临时图像；
（2）生成临时图像的直方图；
（3）用临时图像的直方图和模板图像的直方图对比，对比结果记为c；
（4）直方图对比结果c，就是结果图像(0,0)处的像素值；
（5）切割输入图像从(0,1)至(10,11)的临时图像，对比直方图，并记录到结果图像；
（6）重复（1）～（5）步直到输入图像的右下角。

3.反向投影的结果是什么？
    反向投影的结果包含了：以每个输入图像像素点为起点的直方图对比结果。可以把它看成是一个二维的浮点型数组，二维矩阵，或者单通道的浮点型图像。
4.特殊情况怎么样？
    如果输入图像和模板图像一样大，那么反向投影相当于直方图对比。如果输入图像比模板图像还小，直接罢工～～。
5.使用时有什么要注意的地方？
    需要注意的地方比较多，我们对照反向投影函数来说：
    void cvCalcBackProjectPatch(
        IplImage** image,   /*输入图像：是一个单通道图像数组，而非实际图像*/
        CvArr* dst,         /*输出结果：是一个单通道32位浮点图像，它的宽度为W-w+1，高度为H-h+1，这里的W和H是输入图像的宽度和高度，w和h是模板图像的宽度和高度*/
        CvSize patch_size,  /*模板图像的大小：宽度和高度*/
        CvHistogram* hist,  /*模板图像的直方图：直方图的维数和输入图像的个数相同，并且次序要一致；例如：输入图像包含色调和饱和度，那么直方图的第0维是色调，第1维是饱和度*/
        int method,         /*对比方式：跟直方图对比中的方式类似，可以是：CORREL（相关）、CHISQR（卡方）、INTERSECT（相交）、BHATTACHARYYA*/
        float factor        /*归一化因子，一般都设置成1，否则很可能会出错；中文、英文以及各路转载的文档都错了，这个参数的实际类型是double，而非float，我看了源代码才搞定这个地方*/
    );
    还有最需要注意的地方：这个函数的执行效率非常的低，在使用之前尤其需要注意图像的大小，直方图的维数，对比方式。如果说对比单个直方图对现在的电脑来说是清风拂面，那么反向投影是狂风海啸。对于1010x1010的RGB输入图像，10x10的模板图像，需要生成1百万次3维直方图，对比1百万次3维直方图。

 下面为具体代码：

#include <cv.h>
#include <highgui.h>


int main()
{
    IplImage* src = cvLoadImage("./sample1.jpg");
    if (src != NULL)
    {
        IplImage* hsv = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 3);
        //将bgr图像转化为hsv图像
        cvCvtColor(src, hsv, CV_BGR2HSV);


        //创建3个单通道的图像，用于将hsv图像分离为3个通道
        IplImage* h = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
        IplImage* s = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
        IplImage* v = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
        IplImage* planes[] = {h, s};
        //将hsv图像分离
        cvCvtPixToPlane(hsv, h, s, v, 0);


        //在h通道上设定30个划分度，在s通道上设定32个划分度
        int h_bins(30), s_bins(32);
        CvHistogram* hist;
        {
            int hist_size[] = {h_bins, s_bins};
            float h_ranges[] = {0, 180};
            float s_ranges[] = {0, 255};
            //将h通道上的范围，即[0,180]，以及s通道上的范围，即[0,255]组织成函数cvCreateHist所需
            //的形式
            float* ranges[] = {h_ranges, s_ranges};
            //创建一个2维的、h维上划分度为30、s维上划分度为32的均分直方图
            hist = cvCreateHist(2, hist_size, CV_HIST_ARRAY, ranges, 1);
        }
        //通过源图像上的h与s通道上图像数据统计出直方图
        cvCalcHist(planes, hist, 0, 0);
        //获取得到的直方图的所有数据的和
        CvScalar sc = cvSum(hist->bins);
        float sum = sc.val[0] + sc.val[1] + sc.val[2] + sc.val[3];
        //归一化直方图
        cvNormalizeHist(hist, 1.0);
        //scale:每一个划分在用于显示的图像上所占的像素点数
        int scale = 10;
        IplImage* img = cvCreateImage(cvSize(h_bins * scale, s_bins * scale), IPL_DEPTH_8U, 3);
        cvZero(img);


        //为什么要求最大值呢？由于归一化之后的图像中的像素点的值都不会大于1，那么在人眼看来都是黑
        //色的一片，没法通过图像来直观的感受直方图了，所以在下边会通过将直方图的值和直方图中的最大
        //值做除法，再乘以255，使人眼能看出直方图中数值的变化……如下代码对应直方图2
        float max_value = 0;
        cvGetMinMaxHistValue(hist, NULL, &max_value, 0, 0);
        for (int h = 0; h < h_bins; ++h)
        {
            for (int s = 0; s < s_bins; ++s)
            {
                //访问直方图在关于h与s所确定的颜色的数值
                float bin_val = cvQueryHistValue_2D(hist, h, s);
                int intensity = cvRound(bin_val * 255 / max_value);
                cvRectangle(img,
                            cvPoint(h * scale, s * scale),
                            cvPoint((h + 1) * scale - 1, (s + 1) * scale - 1),
                            CV_RGB(intensity, intensity, intensity),
                            CV_FILLED);
            }
        }


        //如下代码对应直方图1
        int height = 240;
        int width = (h_bins*s_bins*6);
        IplImage* hist_img = cvCreateImage( cvSize(width,height), 8, 3 );
        cvZero( hist_img );
       
        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);
               
                cvSet2D(hsv_color,0,0,cvScalar(h*180.f / h_bins,s*255.f/s_bins,255,0));
                //hsv颜色转化为bgr颜色
                cvCvtColor(hsv_color,rgb_color,CV_HSV2BGR);
                CvScalar color = cvGet2D(rgb_color,0,0);
                //IplImage类型指定的图像原点在左上角，所以要实现图中的效果，矩形的两个顶角应像下边
                //代码中设置
                cvRectangle( hist_img, cvPoint(i*bin_w,height),
                             cvPoint((i+1)*bin_w,height - intensity),
                             color, -1, 8, 0 );
            }
        }
        cvNamedWindow( "H-S Histogram", 1 );
        cvShowImage( "H-S Histogram", hist_img );
        cvNamedWindow("src");
        cvShowImage("src", src);
        cvNamedWindow("img");
        cvShowImage("img", img);


        IplImage* img2 = cvLoadImage("./sample2.jpg");
        IplImage* hsv2 = cvCreateImage(cvGetSize(img2), IPL_DEPTH_8U, 3);
        cvCvtColor(img2, hsv2, CV_BGR2HSV);
        IplImage* h2 = cvCreateImage(cvGetSize(img2), IPL_DEPTH_8U, 1);
        IplImage* s2 = cvCreateImage(cvGetSize(img2), IPL_DEPTH_8U, 1);
        IplImage* v2 = cvCreateImage(cvGetSize(img2), IPL_DEPTH_8U, 1);
        IplImage* planes2[] = {h2, s2};
        cvCvtPixToPlane(hsv2, h2, s2, v2, 0);
        //cvCvtPixToPlane(img2, h2, s2, v2, 0);
        IplImage* backProject = cvCreateImage(cvGetSize(img2), IPL_DEPTH_8U, 1);
        cvSetZero(backProject);
        cvNormalizeHist(hist, sum);
        cvCalcBackProject(planes2, backProject, hist);


        cvNamedWindow("img2");
        cvShowImage("img2", img2);
        cvNamedWindow("back project");
        cvShowImage("back project", backProject);


        //释放资源
        cvWaitKey(0);
        cvDestroyAllWindows();
        cvReleaseImage(&src);
        cvReleaseImage(&img);
        cvReleaseImage(&backProject);
        cvReleaseImage(&img2);
        cvReleaseHist(&hist);
    }


    return 0;
}

模板匹配(Match Template) 修改版

模板匹配的工作方式
    模板匹配的工作方式跟直方图的反向投影基本一样，大致过程是这样的：通过在输入图像上滑动图像块对实际的图像块和输入图像进行匹配。
    假设我们有一张100x100的输入图像，有一张10x10的模板图像，查找的过程是这样的：
  （1）从输入图像的左上角(0,0)开始，切割一块(0,0)至(10,10)的临时图像；（改者注：其实每次匹配都是在模板的中心点对应的位置来给像素赋值，即第一次比较应该是将模板的(temp.width/2,temp.height/2)中心点开始的1/4面积同输入图像进行比较，匹配得到的结果c保存到模板中心点所在像素值中，具体参照《Learning OpenCV》，所以最终用来保留匹配结果的图像大小应该是size =  （images->width - patch_size.x + 1,images->height - patch_size.y + 1））

  （2）用临时图像和模板图像进行对比，对比结果记为c；
  （3）对比结果c，就是结果图像(0,0)处的像素值；
  （4）切割输入图像从(0,1)至(10,11)的临时图像，对比，并记录到结果图像；
  （5）重复（1）～（4）步直到输入图像的右下角。
    大家可以看到，直方图反向投影对比的是直方图，而模板匹配对比的是图像的像素值；模板匹配比直方图反向投影速度要快一些，但是我个人认为直方图反向投影的鲁棒性会更好。

模板匹配的匹配方式
    在OpenCv和EmguCv中支持以下6种对比方式：
    CV_TM_SQDIFF 平方差匹配法：该方法采用平方差来进行匹配；最好的匹配值为0；匹配越差，匹配值越大。
    CV_TM_CCORR 相关匹配法：该方法采用乘法操作；数值越大表明匹配程度越好。
    CV_TM_CCOEFF 相关系数匹配法：1表示完美的匹配；-1表示最差的匹配。
    CV_TM_SQDIFF_NORMED 归一化平方差匹配法
    CV_TM_CCORR_NORMED 归一化相关匹配法
    CV_TM_CCOEFF_NORMED 归一化相关系数匹配法
    根据我的测试结果来看，上述几种匹配方式需要的计算时间比较接近（跟《学习OpenCv》书上说的不同），我们可以选择一个能适应场景的匹配方式。

具体代码：

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

    IplImage *src, *templ,*ftmp[6]; //ftmp is what to display on
    int i;
    
        //Read in the template to be used for matching:
        if((templ=cvLoadImage("flower1.jpg", 1))== 0) {
            printf("Error on reading template /n"); 
            return(-1);
        }

        //Read in the source image to be searched:
        if((src=cvLoadImage("flower.jpg", 1))== 0) {
            printf("Error on reading src image /n");
            return(-1);
        }

        int patchx = templ->width;
        int patchy = templ->height;
        int iwidth = src->width - patchx + 1;
        int iheight = src->height - patchy + 1;
        for(i=0; i<6; ++i){
            ftmp[i] = cvCreateImage( cvSize(iwidth,iheight),32,1);
        }

        //DO THE MATCHING OF THE TEMPLATE WITH THE IMAGE
        for(i=0; i<6; ++i){
            cvMatchTemplate( src, templ, ftmp[i], i); 
            //  double min,max;
            //  cvMinMaxLoc(ftmp,&min,&max);
            cvNormalize(ftmp[i],ftmp[i],1,0,CV_MINMAX);
        }
        //DISPLAY
        cvNamedWindow( "Template", 0 );
        cvShowImage(   "Template", templ );
        cvNamedWindow( "Image", 0 );
        cvShowImage(   "Image", src );

        cvNamedWindow( "SQDIFF", 0 );
        cvShowImage(   "SQDIFF", ftmp[0] );

        cvNamedWindow( "SQDIFF_NORMED", 0 );
        cvShowImage(   "SQDIFF_NORMED", ftmp[1] );

        cvNamedWindow( "CCORR", 0 );
        cvShowImage(   "CCORR", ftmp[2] );

        cvNamedWindow( "CCORR_NORMED", 0 );
        cvShowImage(   "CCORR_NORMED", ftmp[3] );

        cvNamedWindow( "CCOEFF", 0 );
        cvShowImage(   "CCOEFF", ftmp[4] );

        cvNamedWindow( "CCOEFF_NORMED", 0 );
        cvShowImage(   "CCOEFF_NORMED", ftmp[5] );


        //LET USER VIEW RESULTS:
        cvWaitKey(0);
    
    return 0;
}

感谢您耐心看完本文，希望对您有所帮助。