CamShift算法

拟采用的方法，CamShift算法，即"Continuously Apative Mean-Shift"算法，是一种运动跟踪算法。它主要通过视频图像中运动物体的颜色信息来达到跟踪的目的。该算法的已经在PC上尝试过，效果良好。目前正在往手机上移植。

这个算法是根据颜色信息来跟踪吗？有待验证

（1）Camshift算法

转自： http://blog.sina.com.cn/s/blog_5d1476580101a57j.html

Camshift算法是Continuously Adaptive Mean Shift algorithm的简称。它是一个基于MeanSift的改进算法。它首次由Gary R.Bradski等人提出和应用在人脸的跟踪上，并取得了不错的效果。由于它是利用颜色的概率信息进行的跟踪，使得它的运行效率比较高。Camshift算法的过程由下面步骤组成：

（1）确定初始目标及其区域；

（2）计算出目标的色度（Hue)分量的直方图；

（3）利用直方图计算输入图像的反向投影图（后面做进一步的解释）；

（４）利用MeanShift算法在反向投影图中迭代收索，直到其收敛或达到最大迭代次数。并保存零次矩；

（5）从第（4）步中获得收索窗口的中心位置和计算出新的窗口大小，以此为参数，进入到下一幀的目标跟踪。（即跳转到第（2）步）；

几点说明：

1. 在输入图像进行反向投影图之前在HSV空间内做了一个阀值处理，用以滤掉一些噪声。

2. 反向投影图则是概率分布图，在反向投影图中某一像素点的值指的是这个点符合目标的概率分布的概率是多少，或者直接说其为目标图像像素点的像素点是多少。计算方法为：根据像素点的像素值查目标的直方图，其对应像素值的概率是多少就做为该点在反向投影图中的值。

3. Camshit算法到底是怎样自适应调整窗口的大小的。扩大：Canshift算法在计算窗口大小前，在MeanShift算出的窗口的四个方向上增大了TOLERANCE，即高和宽都增大了2TOLERANCE（此值自己调整设置），这才有可能使得窗口能够变大。缩小：在扩大的窗口内重新计算0阶矩，1阶矩和2阶矩，利用矩的值重新计算高和宽。因此Camshif算法相当于在MeanShift的结果上，再做了一个调整，从而使得跟踪的窗口大小能够随目标的大小变化。

优点：算法的效率比较高，如果能利用多少特征做出来的统计直方图，我估计实验效果会更好。

缺点：（1）只利用颜色统计做的跟踪，在背景有相似颜色时，会出现跟踪错误的情况。（2）不能做多目标跟踪。（3）由于它只在初始位置（而不是从每个像素点）开始迭代，所以有可能在初始位置错了后，收敛的位置还是原位置（即跟丢了后，可能会找不回来）。

问题：论文中有关于窗口大小调整，是根据直方图来迭代求解，不知是怎么回事？在代码中没看到实现。在此向大家请教！

下面是Camshift算法Demo的代码：

代码

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->  1 #ifdef _CH_
 #pragma package
 #endif
 
 #define CV_NO_BACKWARD_COMPATIBILITY
 
 #ifndef _EiC
 #include "cv.h"
 #include "highgui.h"
 #include
 #include
 #endif
 
 IplImage *image = 0, *hsv = 0, *hue = 0, *mask = 0, *backproject = 0, *histimg = 0;
 CvHistogram *hist = 0;
 
 int backproject_mode = 0;
 int select_object = 0;
 int track_object = 0;
 int show_hist = 1;
 CvPoint origin;
 CvRect selection;
 CvRect track_window;
 CvBox2D track_box;
 CvConnectedComp track_comp;
 int hdims = 16;
 float hranges_arr[] = {0,180};
 float* hranges = hranges_arr;
 int vmin = 10, vmax = 256, smin = 30;
 
 void on_mouse( int event, int x, int y, int flags, void* param )
 {
     if( !image )
         return;
 
     if( image->origin )
         y = image->height - y;
 
     if( select_object )//表明还正在框选目标
     {
         selection.x = MIN(x,origin.x);
         selection.y = MIN(y,origin.y);
         selection.width = selection.x + CV_IABS(x - origin.x);
         selection.height = selection.y + CV_IABS(y - origin.y);
 
         //保证数据的有效性
         selection.x = MAX( selection.x, 0 );
         selection.y = MAX( selection.y, 0 );
         selection.width = MIN( selection.width, image->width );
         selection.height = MIN( selection.height, image->height );
         selection.width -= selection.x;
         selection.height -= selection.y;
     }
 
     switch( event )
     {
     case CV_EVENT_LBUTTONDOWN://框选目标
         origin = cvPoint(x,y);
         selection = cvRect(x,y,0,0);
         select_object = 1;
         break;
     case CV_EVENT_LBUTTONUP://框选结束
         select_object = 0;
         if( selection.width > 0 && selection.height > 0 )
             track_object = -1;
         break;
     }
 }
 
 
 CvScalar hsv2rgb( float hue )
 {
     int rgb[3], p, sector;
     static const int sector_data[][3]=
         {{0,2,1}, {1,2,0}, {1,0,2}, {2,0,1}, {2,1,0}, {0,1,2}};
     hue *= 0.033333333333333333333333333333333f;
     sector = cvFloor(hue);
     p = cvRound(255*(hue - sector));
     p ^= sector & 1 ? 255 : 0;
 
     rgb[sector_data[sector][0]] = 255;
     rgb[sector_data[sector][1]] = 0;
     rgb[sector_data[sector][2]] = p;
 
     return cvScalar(rgb[2], rgb[1], rgb[0],0);
 }
 
 int main( int argc, char** argv )
 {
     CvCapture* capture = 0;
 
     if( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0])))
         capture = cvCaptureFromCAM( argc == 2 ? argv[1][0] - '0' : 0 );
     else if( argc == 2 )
         capture = cvCaptureFromAVI( argv[1] );
 
     if( !capture )
     {
         fprintf(stderr,"Could not initialize capturing...\n");
         return -1;
     }
 
     printf( "Hot keys: \n"
         "\tESC - quit the program\n"
         "\tc - stop the tracking\n"
         "\tb - switch to/from backprojection view\n"
         "\th - show/hide object histogram\n"
         "To initialize tracking, select the object with mouse\n" );
 
     cvNamedWindow( "Histogram", 1 );
     cvNamedWindow( "CamShiftDemo", 1 );
     cvSetMouseCallback( "CamShiftDemo", on_mouse, 0 );
     cvCreateTrackbar( "Vmin", "CamShiftDemo", &vmin, 256, 0 );
     cvCreateTrackbar( "Vmax", "CamShiftDemo", &vmax, 256, 0 );
     cvCreateTrackbar( "Smin", "CamShiftDemo", &smin, 256, 0 );
 
     for(;;)
     {
         IplImage* frame = 0;
         int i, bin_w, c;
 
         frame = cvQueryFrame( capture );
         if( !frame )
             break;
 
         if( !image )
         {
            
             image = cvCreateImage( cvGetSize(frame), 8, 3 );
             image->origin = frame->origin;
             hsv = cvCreateImage( cvGetSize(frame), 8, 3 );
             hue = cvCreateImage( cvGetSize(frame), 8, 1 );
             mask = cvCreateImage( cvGetSize(frame), 8, 1 );
             backproject = cvCreateImage( cvGetSize(frame), 8, 1 );
             hist = cvCreateHist(1, &hdims, CV_HIST_ARRAY, &hranges, 1 );
             histimg = cvCreateImage( cvSize(320,200), 8, 3 );
             cvZero( histimg );
         }
 
         cvCopy( frame, image, 0 );
         cvCvtColor( image, hsv, CV_BGR2HSV );
 
         if( track_object )
         {
             int _vmin = vmin, _vmax = vmax;
 
             cvInRangeS( hsv, cvScalar(0,smin,MIN(_vmin,_vmax),0),
                         cvScalar(180,256,MAX(_vmin,_vmax),0), mask ); //去除噪声，在此数据内的值，确定mask为1
             cvSplit( hsv, hue, 0, 0, 0 ); //获得色调分量，并以此来做反向投影图
 
             if( track_object < 0 )
             {
                 float max_val = 0.f;
                 cvSetImageROI( hue, selection );
                 cvSetImageROI( mask, selection );
                 cvCalcHist( &hue, hist, 0, mask );//计算选中部分直方图
                 cvGetMinMaxHistValue( hist, 0, &max_val, 0, 0 );
                 cvConvertScale( hist->bins, hist->bins, max_val ? 255. / max_val : 0., 0 );
                 cvResetImageROI( hue );
                 cvResetImageROI( mask );
                 track_window = selection;
                 track_object = 1;
 
                 cvZero( histimg );
                 bin_w = histimg->width / hdims;
                 for( i = 0; i < hdims; i++ )
                 {
                     int val = cvRound( cvGetReal1D(hist->bins,i)*histimg->height/255 );//获取直方图的中每一项的高
                     CvScalar color = hsv2rgb(i*180.f/hdims);//直方图每一项的颜色是根据项数变化的
                     cvRectangle( histimg, cvPoint(i*bin_w,histimg->height),  //画直方图
                                  cvPoint((i+1)*bin_w,histimg->height - val),
                                  color, -1, 8, 0 );
                 }
             }
 
             cvCalcBackProject( &hue, backproject, hist ); //计算反向投影图backproject
             cvAnd( backproject, mask, backproject, 0 );        //去除上下阀值外的点后的投影图
             cvCamShift( backproject, track_window,        //利用camshift搜索0-255的灰度图像
                         cvTermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1 ),
                         &track_comp, &track_box );
             track_window = track_comp.rect;    //获得新的跟踪窗口
 
             if( backproject_mode )
                 cvCvtColor( backproject, image, CV_GRAY2BGR );
        
             if( !image->origin ) //如果为假，需要改变椭圆的角度
                 track_box.angle = -track_box.angle;
             cvEllipseBox( image, track_box, CV_RGB(255,0,0), 3, CV_AA, 0 );//画跟踪椭圆
         }
 
         if( select_object && selection.width > 0 && selection.height > 0 )//在框住的时候反向显示
         {
             cvSetImageROI( image, selection );
             cvXorS( image, cvScalarAll(255), image, 0 );
             cvResetImageROI( image );
         }
 
         cvShowImage( "CamShiftDemo", image );
         cvShowImage( "Histogram", histimg );
 
         c = cvWaitKey(10);
         if( (char) c == 27 )
             break;
         switch( (char) c )
         {
         case 'b':
             backproject_mode ^= 1;
             break;
         case 'c':
             track_object = 0;
             cvZero( histimg );
             break;
         case 'h':
             show_hist ^= 1;
             if( !show_hist )
                 cvDestroyWindow( "Histogram" );
             else
                 cvNamedWindow( "Histogram", 1 );
             break;
         default:
             ;
         }
     }
 
     cvReleaseCapture( &capture );
     cvDestroyWindow("CamShiftDemo");
 
     return 0;
 }
 
 #ifdef _EiC
 main(1,"camshiftdemo.c");
 #endif

（2）转自： http://baike.baidu.com/link?url=-QnO7qxM8avtB6i791ScOf2K3VU4jxDpfd0No7hcniYv1YYu3ooo-s2XfgJjKYv5bB6ob4Vu70A-hc-2yasU1K

它是MeanShift算法的改进，称为连续自适应的MeanShift算法，CamShift算法的全称是"Continuously Adaptive Mean-SHIFT"，它的基本思想是视频图像的所有帧作MeanShift运算，并将上一帧的结果（即Search Window的中心和大小）作为下一帧MeanShift算法的Search Window的初始值，如此迭代下去。

Camshift 是由Meanshift 推导而来 Meanshift主要是用在单张影像上，但

是独立一张影像分析对追踪而言并无意义，Camshift 就是利用MeanShift的方

法，对影像串列进行分析。

(1) 首先在影像串列中选择ㄧ区域。

(2) 计算此区域的颜色2D机率分布。

(3) 用MeanShift演算法来收敛欲追踪的区域。

(4) 集中收敛的区域，并标示之。

(5) 每个frame重复(3)(4)。

Camshift 关键就在于当目标的大小发生改变的时候，此算法可以自适应调整目标区域继续跟踪。

对于OPENCV中的CAMSHIFT例子，是通过计算目标HSV空间下的HUE分量直方图，通过直方图反向投影得到目标像素的概率分布，然后通过调用CV库中的CAMSHIFT算法，自动跟踪并调整目标窗口的中心位置与大小。

这个算法对于纯色物体在黑白背景下的跟踪效果是很好的，但是如果背景的颜色与目标相近，或者目标附近有与目标的色调相近的算法比较物体，则CAMSHIFT会自动将其包括在内，导致跟踪窗口扩大，甚至有时会将跟踪窗口扩大到整个视频框架。

camshift示意图，gif动图

（3）Camshift算法原理及其Opencv实现

转自： http://hi.baidu.com/gilbertjuly/item/985693cf8dc0430cad092f15

Camshift原理
camshift利用目标的颜色直方图模型将图像转换为颜色概率分布图，初始化一个搜索窗的大小和位置，并根据上一帧得到的结果自适应调整搜索窗口的位置和大小，从而定位出当前图像中目标的中心位置。

分为三个部分：
1--色彩投影图（反向投影）：
(1).RGB颜色空间对光照亮度变化较为敏感，为了减少此变化对跟踪效果的影响，首先将图像从RGB空间转换到HSV空间。(2).然后对其中的H分量作直方图，在直方图中代表了不同H分量值出现的概率或者像素个数，就是说可以查找出H分量大小为h的概率或者像素个数，即得到了颜色概率查找表。(3).将图像中每个像素的值用其颜色出现的概率对替换，就得到了颜色概率分布图。这个过程就叫反向投影，颜色概率分布图是一个灰度图像。

2--meanshift
meanshift算法是一种密度函数梯度估计的非参数方法，通过迭代寻优找到概率分布的极值来定位目标。
算法过程为：
(1).在颜色概率分布图中选取搜索窗W
(2).计算零阶距：

计算一阶距：

计算搜索窗的质心：

(3).调整搜索窗大小
宽度为；长度为1.2s；
(4).移动搜索窗的中心到质心，如果移动距离大于预设的固定阈值，则重复2)3)4)，直到搜索窗的中心与质心间的移动距离小于预设的固定阈值，或者循环运算的次数达到某一最大值，停止计算。关于meanshift的收敛性证明可以google相关文献。

3--camshift
将meanshift算法扩展到连续图像序列，就是camshift算法。它将视频的所有帧做meanshift运算，并将上一帧的结果，即搜索窗的大小和中心，作为下一帧meanshift算法搜索窗的初始值。如此迭代下去，就可以实现对目标的跟踪。
算法过程为：
(1).初始化搜索窗
(2).计算搜索窗的颜色概率分布（反向投影）
(3).运行meanshift算法，获得搜索窗新的大小和位置。
(4).在下一帧视频图像中用(3)中的值重新初始化搜索窗的大小和位置，再跳转到(2)继续进行。

camshift能有效解决目标变形和遮挡的问题，对系统资源要求不高，时间复杂度低，在简单背景下能够取得良好的跟踪效果。但当背景较为复杂，或者有许多与目标颜色相似像素干扰的情况下，会导致跟踪失败。因为它单纯的考虑颜色直方图，忽略了目标的空间分布特性，所以这种情况下需加入对跟踪目标的预测算法。

---

Camshift的opencv实现
原文http://blog.csdn.net/houdy/archive/2004/11/10/175739.aspx

1--Back Projection
计算Back Projection的OpenCV代码。
(1).准备一张只包含被跟踪目标的图片，将色彩空间转化到HSI空间，获得其中的H分量：
IplImage* target=cvLoadImage("target.bmp",-1);  //装载图片
IplImage* target_hsv=cvCreateImage( cvGetSize(target), IPL_DEPTH_8U, 3 );
IplImage* target_hue=cvCreateImage( cvGetSize(target), IPL_DEPTH_8U, 3 );
cvCvtColor(target,target_hsv,CV_BGR2HSV);       //转化到HSV空间
cvSplit( target_hsv, target_hue, NULL, NULL, NULL );    //获得H分量

(2).计算H分量的直方图，即1D直方图：
IplImage* h_plane=cvCreateImage( cvGetSize(target_hsv),IPL_DEPTH_8U,1 );
int hist_size[]={255};          //将H分量的值量化到[0,255]
float* ranges[]={ {0,360} };    //H分量的取值范围是[0,360)
CvHistogram* hist=cvCreateHist(1, hist_size, ranges, 1);
cvCalcHist(&target_hue, hist, 0, NULL);
在这里需要考虑H分量的取值范围的问题，H分量的取值范围是[0,360)，这个取值范围的值不能用一个byte来表示，为了能用一个byte表示，需要将H值做适当的量化处理，在这里我们将H分量的范围量化到[0,255]。

(3).计算Back Projection：
IplImage* rawImage;
//get from video frame,unsigned byte,one channel
IplImage* result=cvCreateImage(cvGetSize(rawImage),IPL_DEPTH_8U,1);
cvCalcBackProject(&rawImage,result,hist);
(4). result即为我们需要的.

2--Mean Shift算法
质心可以通过以下公式来计算：
(1).计算区域内0阶矩
for(int i=0;i< height;i++)
for(int j=0;j< width;j++)
M00+=I(i,j)

(2).区域内1阶矩：
for(int i=0;i< height;i++)
for(int j=0;j< width;j++)
{
M10+=i*I(i,j);
M01+=j*I(i,j);
}

(3).则Mass Center为：
Xc=M10/M00; Yc=M01/M00

在OpenCV中，提供Mean Shift算法的函数，函数的原型是：
int cvMeanShift(IplImage* imgprob,CvRect windowIn,
CvTermCriteria criteria,CvConnectedComp* out);
需要的参数为：
(1).IplImage* imgprob：2D概率分布图像，传入；
(2).CvRect windowIn：初始的窗口，传入；
(3).CvTermCriteria criteria：停止迭代的标准，传入；
(4).CvConnectedComp* out:查询结果，传出。
注：构造CvTermCriteria变量需要三个参数，一个是类型，另一个是迭代的最大次数，最后一个表示特定的阈值。例如可以这样构造 criteria：
criteria=cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,10,0.1)。

3--CamShift算法
整个算法的具体步骤分5步：
Step 1：将整个图像设为搜寻区域。
Step 2：初始话Search Window的大小和位置。
Step 3：计算Search Window内的彩色概率分布，此区域的大小比Search Window要稍微大一点。
Step 4：运行MeanShift。获得Search Window新的位置和大小。
Step 5：在下一帧视频图像中，用Step 3获得的值初始化Search Window的位置和大小。跳转到Step 3继续运行。

OpenCV代码：
在OpenCV中，有实现CamShift算法的函数，此函数的原型是：
cvCamShift(IplImage* imgprob, CvRect windowIn,
CvTermCriteria criteria,
CvConnectedComp* out, CvBox2D* box=0);
其中：
imgprob：色彩概率分布图像。
windowIn：Search Window的初始值。
Criteria：用来判断搜寻是否停止的一个标准。
out：保存运算结果,包括新的Search Window的位置和面积。
box：包含被跟踪物体的最小矩形。

更多参考：

带有注释的camshift算法的opencv实现代码见：
http://download.csdn.net/source/1663015

（4）Camshift算法原理及其Opencv实现

转自：http://blog.csdn.net/leixiaohua1020/article/details/12236091

Camshift原理
camshift利用目标的颜色直方图模型将图像转换为颜色概率分布图，初始化一个搜索窗的大小和位置，并根据上一帧得到的结果自适应调整搜索窗口的位置和大小，从而定位出当前图像中目标的中心位置。

分为三个部分：
1--色彩投影图（反向投影）：
(1).RGB颜色空间对光照亮度变化较为敏感，为了减少此变化对跟踪效果的影响，首先将图像从RGB空间转换到HSV空间。(2).然后对其中的H分量作直方图，在直方图中代表了不同H分量值出现的概率或者像素个数，就是说可以查找出H分量大小为h的概率或者像素个数，即得到了颜色概率查找表。(3).将图像中每个像素的值用其颜色出现的概率对替换，就得到了颜色概率分布图。这个过程就叫反向投影，颜色概率分布图是一个灰度图像。

2--meanshift
meanshift算法是一种密度函数梯度估计的非参数方法，通过迭代寻优找到概率分布的极值来定位目标。
算法过程为：
(1).在颜色概率分布图中选取搜索窗W
(2).计算零阶距：

计算一阶距：

计算搜索窗的质心：

(3).调整搜索窗大小
宽度为；长度为1.2s；
(4).移动搜索窗的中心到质心，如果移动距离大于预设的固定阈值，则重复2)3)4)，直到搜索窗的中心与质心间的移动距离小于预设的固定阈值，或者循环运算的次数达到某一最大值，停止计算。关于meanshift的收敛性证明可以google相关文献。

3--camshift
将meanshift算法扩展到连续图像序列，就是camshift算法。它将视频的所有帧做meanshift运算，并将上一帧的结果，即搜索窗的大小和中心，作为下一帧meanshift算法搜索窗的初始值。如此迭代下去，就可以实现对目标的跟踪。
算法过程为：
(1).初始化搜索窗
(2).计算搜索窗的颜色概率分布（反向投影）
(3).运行meanshift算法，获得搜索窗新的大小和位置。
(4).在下一帧视频图像中用(3)中的值重新初始化搜索窗的大小和位置，再跳转到(2)继续进行。

camshift能有效解决目标变形和遮挡的问题，对系统资源要求不高，时间复杂度低，在简单背景下能够取得良好的跟踪效果。但当背景较为复杂，或者有许多与目标颜色相似像素干扰的情况下，会导致跟踪失败。因为它单纯的考虑颜色直方图，忽略了目标的空间分布特性，所以这种情况下需加入对跟踪目标的预测算法。

OpenCV实现camshift算法的例子：

1. //对运动物体的跟踪：
2. //如果背景固定,可用帧差法 然后在计算下连通域 将面积小的去掉即可
3. //如果背景单一,即你要跟踪的物体颜色和背景色有较大区别 可用基于颜色的跟踪 如CAMSHIFT 鲁棒性都是较好的
4. //如果背景复杂,如背景中有和前景一样的颜色 就需要用到一些具有预测性的算法 如卡尔曼滤波等 可以和CAMSHIFT结合
5. #ifdef _CH_
6. #pragma package <opencv>
7. #endif
8. #ifndef _EiC
9. #include "cv.h"
10. #include "highgui.h"
11. #include <stdio.h>
12. #include <ctype.h>
13. #endif
14. IplImage *image = 0, *hsv = 0, *hue = 0, *mask = 0, *backproject = 0, *histimg = 0;
15. //用HSV中的Hue分量进行跟踪
16. CvHistogram *hist = 0;
17. //直方图类
18. int backproject_mode = 0;
19. int select_object = 0;
20. int track_object = 0;
21. int show_hist = 1;
22. CvPoint origin;
23. CvRect selection;
24. CvRect track_window;
25. CvBox2D track_box;
26. //Meanshift跟踪算法返回的Box类
27. //typedef struct CvBox2D{
28. //CvPoint2D32f center; /* 盒子的中心 */
29. //CvSize2D32f size; /* 盒子的长和宽 */
30. //float angle; /* 水平轴与第一个边的夹角，用弧度表示*/
31. //}CvBox2D;
32. CvConnectedComp track_comp;
33. //连接部件
34. //typedef struct CvConnectedComp{
35. //double area; /* 连通域的面积 */
36. //float value; /* 分割域的灰度缩放值 */
37. //CvRect rect; /* 分割域的 ROI */
38. //} CvConnectedComp;
39. int hdims = 16;
40. //划分直方图bins的个数，越多越精确
41. float hranges_arr[] = {0,180};
42. //像素值的范围
43. float* hranges = hranges_arr;
44. //用于初始化CvHistogram类
45. int vmin = 10, vmax = 256, smin = 30;
46. //用于设置滑动条
47. void on_mouse( int event, int x, int y, int flags, void* param )
48. //鼠标回调函数,该函数用鼠标进行跟踪目标的选择
49. {
50. if( !image )
51. return;
52. if( image->origin )
53. y = image->height - y;
54. //如果图像原点坐标在左下,则将其改为左上
55. if( select_object )
56. //select_object为1,表示在用鼠标进行目标选择
57. //此时对矩形类selection用当前的鼠标位置进行设置
58. {
59. selection.x = MIN(x,origin.x);
60. selection.y = MIN(y,origin.y);
61. selection.width = selection.x + CV_IABS(x - origin.x);
62. selection.height = selection.y + CV_IABS(y - origin.y);
63. selection.x = MAX( selection.x, 0 );
64. selection.y = MAX( selection.y, 0 );
65. selection.width = MIN( selection.width, image->width );
66. selection.height = MIN( selection.height, image->height );
67. selection.width -= selection.x;
68. selection.height -= selection.y;
69. }
70. switch( event )
71. {
72. case CV_EVENT_LBUTTONDOWN:
73. //鼠标按下,开始点击选择跟踪物体
74. origin = cvPoint(x,y);
75. selection = cvRect(x,y,0,0);
76. select_object = 1;
77. break;
78. case CV_EVENT_LBUTTONUP:
79. //鼠标松开,完成选择跟踪物体
80. select_object = 0;
81. if( selection.width > 0 && selection.height > 0 )
82. //如果选择物体有效，则打开跟踪功能
83. track_object = -1;
84. break;
85. }
86. }
87. CvScalar hsv2rgb( float hue )
88. //用于将Hue量转换成RGB量
89. {
90. int rgb[3], p, sector;
91. static const int sector_data[][3]=
92. {{0,2,1}, {1,2,0}, {1,0,2}, {2,0,1}, {2,1,0}, {0,1,2}};
93. hue *= 0.033333333333333333333333333333333f;
94. sector = cvFloor(hue);
95. p = cvRound(255*(hue - sector));
96. p ^= sector & 1 ? 255 : 0;
97. rgb[sector_data[sector][0]] = 255;
98. rgb[sector_data[sector][1]] = 0;
99. rgb[sector_data[sector][2]] = p;
100. return cvScalar(rgb[2], rgb[1], rgb[0],0);
101. }
102. int main( int argc, char** argv )
103. {
104. CvCapture* capture = 0;
105. if( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0])))
106. //打开摄像头
107. capture = cvCaptureFromCAM( argc == 2 ? argv[1][0] - '0' : 0 );
108. else if( argc == 2 )
109. //打开avi
110. capture = cvCaptureFromAVI( argv[1] );
111. if( !capture )
112. //打开视频流失败
113. {
114. fprintf(stderr,"Could not initialize capturing...\n");
115. return -1;
116. }
117. printf( "Hot keys: \n"
118. "\tESC - quit the program\n"
119. "\tc - stop the tracking\n"
120. "\tb - switch to/from backprojection view\n"
121. "\th - show/hide object histogram\n"
122. "To initialize tracking, select the object with mouse\n" );
123. //打印程序功能列表
124. cvNamedWindow( "Histogram", 1 );
125. //用于显示直方图
126. cvNamedWindow( "CamShiftDemo", 1 );
127. //用于显示视频
128. cvSetMouseCallback( "CamShiftDemo", on_mouse, 0 );
129. //设置鼠标回调函数
130. cvCreateTrackbar( "Vmin", "CamShiftDemo", &vmin, 256, 0 );
131. cvCreateTrackbar( "Vmax", "CamShiftDemo", &vmax, 256, 0 );
132. cvCreateTrackbar( "Smin", "CamShiftDemo", &smin, 256, 0 );
133. //设置滑动条
134. for(;;)
135. //进入视频帧处理主循环
136. {
137. IplImage* frame = 0;
138. int i, bin_w, c;
139. frame = cvQueryFrame( capture );
140. if( !frame )
141. break;
142. if( !image )
143. //image为0,表明刚开始还未对image操作过,先建立一些缓冲区
144. {
145. image = cvCreateImage( cvGetSize(frame), 8, 3 );
146. image->origin = frame->origin;
147. hsv = cvCreateImage( cvGetSize(frame), 8, 3 );
148. hue = cvCreateImage( cvGetSize(frame), 8, 1 );
149. mask = cvCreateImage( cvGetSize(frame), 8, 1 );
150. //分配掩膜图像空间
151. backproject = cvCreateImage( cvGetSize(frame), 8, 1 );
152. //分配反向投影图空间,大小一样,单通道
153. hist = cvCreateHist( 1, &hdims, CV_HIST_ARRAY, &hranges, 1 );
154. //分配直方图空间
155. histimg = cvCreateImage( cvSize(320,200), 8, 3 );
156. //分配用于直方图显示的空间
157. cvZero( histimg );
158. //置背景为黑色
159. }
160. cvCopy( frame, image, 0 );
161. cvCvtColor( image, hsv, CV_BGR2HSV );
162. //把图像从RGB表色系转为HSV表色系
163. if( track_object )
164. //track_object非零,表示有需要跟踪的物体
165. {
166. int _vmin = vmin, _vmax = vmax;
167. cvInRangeS( hsv, cvScalar(0,smin,MIN(_vmin,_vmax),0),
168. cvScalar(180,256,MAX(_vmin,_vmax),0), mask );
169. //制作掩膜板，只处理像素值为H：0~180，S：smin~256，V：vmin~vmax之间的部分
170. cvSplit( hsv, hue, 0, 0, 0 );
171. //分离H分量
172. if( track_object < 0 )
173. //如果需要跟踪的物体还没有进行属性提取，则进行选取框类的图像属性提取
174. {
175. float max_val = 0.f;
176. cvSetImageROI( hue, selection );
177. //设置原选择框为ROI
178. cvSetImageROI( mask, selection );
179. //设置掩膜板选择框为ROI
180. cvCalcHist( &hue, hist, 0, mask );
181. //得到选择框内且满足掩膜板内的直方图
182. cvGetMinMaxHistValue( hist, 0, &max_val, 0, 0 );
183. cvConvertScale( hist->bins, hist->bins, max_val ? 255. / max_val : 0., 0 );
184. // 对直方图的数值转为0~255
185. cvResetImageROI( hue );
186. //去除ROI
187. cvResetImageROI( mask );
188. //去除ROI
189. track_window = selection;
190. track_object = 1;
191. //置track_object为1,表明属性提取完成
192. cvZero( histimg );
193. bin_w = histimg->width / hdims;
194. for( i = 0; i < hdims; i++ )
195. //画直方图到图像空间
196. {
197. int val = cvRound( cvGetReal1D(hist->bins,i)*histimg->height/255 );
198. CvScalar color = hsv2rgb(i*180.f/hdims);
199. cvRectangle( histimg, cvPoint(i*bin_w,histimg->height),
200. cvPoint((i+1)*bin_w,histimg->height - val),
201. color, -1, 8, 0 );
202. }
203. }
204. cvCalcBackProject( &hue, backproject, hist );
205. //计算hue的反向投影图
206. cvAnd( backproject, mask, backproject, 0 );
207. //得到掩膜内的反向投影
208. cvCamShift( backproject, track_window,
209. cvTermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1 ),
210. &track_comp, &track_box );
211. //使用MeanShift算法对backproject中的内容进行搜索,返回跟踪结果
212. track_window = track_comp.rect;
213. //得到跟踪结果的矩形框
214. if( backproject_mode )
215. cvCvtColor( backproject, image, CV_GRAY2BGR );
216. if( image->origin )
217. track_box.angle = -track_box.angle;
218. cvEllipseBox( image, track_box, CV_RGB(255,0,0), 3, CV_AA, 0 );
219. //画出跟踪结果的位置
220. }
221. if( select_object && selection.width > 0 && selection.height > 0 )
222. //如果正处于物体选择，画出选择框
223. {
224. cvSetImageROI( image, selection );
225. cvXorS( image, cvScalarAll(255), image, 0 );
226. cvResetImageROI( image );
227. }
228. cvShowImage( "CamShiftDemo", image );
229. cvShowImage( "Histogram", histimg );
230. c = cvWaitKey(10);
231. if( (char) c == 27 )
232. break;
233. switch( (char) c )
234. //按键切换功能
235. {
236. case 'b':
237. backproject_mode ^= 1;
238. break;
239. case 'c':
240. track_object = 0;
241. cvZero( histimg );
242. break;
243. case 'h':
244. show_hist ^= 1;
245. if( !show_hist )
246. cvDestroyWindow( "Histogram" );
247. else
248. cvNamedWindow( "Histogram", 1 );
249. break;
250. default:
251. ;
252. }
253. }
254. cvReleaseCapture( &capture );
255. cvDestroyWindow("CamShiftDemo");
256. return 0;
257. }
258. #ifdef _EiC
259. main(1,"camshiftdemo.c");
260. #endif

Camshift算法Opencv实现

转自http://www.oschina.net/code/snippet_230937_25534

//对运动物体的跟踪：
//如果背景固定,可用帧差法 然后在计算下连通域 将面积小的去掉即可
//如果背景单一,即你要跟踪的物体颜色和背景色有较大区别 可用基于颜色的跟踪 如CAMSHIFT 鲁棒性都是较好的
//如果背景复杂,如背景中有和前景一样的颜色 就需要用到一些具有预测性的算法 如卡尔曼滤波等 可以和CAMSHIFT结合 

#ifdef _CH_
#pragma package <opencv>
#endif

#ifndef _EiC
#include "cv.h"
#include "highgui.h"
#include <stdio.h>
#include <ctype.h>
#endif

IplImage *image = , *hsv = , *hue = , *mask = , *backproject = , *histimg = ;
//用HSV中的Hue分量进行跟踪
CvHistogram *hist = ;
//直方图类
;
;
;
;
CvPoint origin;
CvRect selection;
CvRect track_window;
CvBox2D track_box;
//Meanshift跟踪算法返回的Box类
//typedef struct CvBox2D{
//CvPoint2D32f center; /* 盒子的中心 */
//CvSize2D32f size; /* 盒子的长和宽 */
//float angle; /* 水平轴与第一个边的夹角，用弧度表示*/
//}CvBox2D;
CvConnectedComp track_comp;
//连接部件
//typedef struct CvConnectedComp{
//double area; /* 连通域的面积 */
//float value; /* 分割域的灰度缩放值 */
//CvRect rect; /* 分割域的 ROI */
//} CvConnectedComp;
;
//划分直方图bins的个数，越多越精确
,};
//像素值的范围
float* hranges = hranges_arr;
//用于初始化CvHistogram类
, vmax = , smin = ;
//用于设置滑动条

void on_mouse( int event, int x, int y, int flags, void* param )
//鼠标回调函数,该函数用鼠标进行跟踪目标的选择
{
    if( !image )
        return;

    if( image->origin )
        y = image->height - y;
    //如果图像原点坐标在左下,则将其改为左上

    if( select_object )
    //select_object为1,表示在用鼠标进行目标选择
    //此时对矩形类selection用当前的鼠标位置进行设置
    {
        selection.x = MIN(x,origin.x);
        selection.y = MIN(y,origin.y);
        selection.width = selection.x + CV_IABS(x - origin.x);
        selection.height = selection.y + CV_IABS(y - origin.y);

        selection.x = MAX( selection.x,  );
        selection.y = MAX( selection.y,  );
        selection.width = MIN( selection.width, image->width );
        selection.height = MIN( selection.height, image->height );
        selection.width -= selection.x;
        selection.height -= selection.y;
    }

    switch( event )
    {
    case CV_EVENT_LBUTTONDOWN:
        //鼠标按下,开始点击选择跟踪物体
        origin = cvPoint(x,y);
        selection = cvRect(x,y,,);
        select_object = ;
        break;
    case CV_EVENT_LBUTTONUP:
        //鼠标松开,完成选择跟踪物体
        select_object = ;
         && selection.height >  )
            //如果选择物体有效，则打开跟踪功能
            track_object = -;
        break;
    }
}

CvScalar hsv2rgb( float hue )
//用于将Hue量转换成RGB量
{
    ], p, sector;
    ]=
        {{,,}, {,,}, {,,}, {,,}, {,,}, {,,}};
    hue *= 0.033333333333333333333333333333333f;
    sector = cvFloor(hue);
    p = cvRound(*(hue - sector));
    p ^= sector &  ?  : ;

    rgb[sector_data[sector][]] = ;
    rgb[sector_data[sector][]] = ;
    rgb[sector_data[sector][]] = p;

    ], rgb[], rgb[],);
}

int main( int argc, char** argv )
{
    CvCapture* capture = ;

     || (argc ==  && strlen(argv[]) ==  && isdigit(argv[][])))
        //打开摄像头
        capture = cvCaptureFromCAM( argc ==  ? argv[][] -  );
     )
        //打开avi
        capture = cvCaptureFromAVI( argv[] ); 

    if( !capture )
    //打开视频流失败
    {
        fprintf(stderr,"Could not initialize capturing...\n");
        ;
    }

    printf( "Hot keys: \n"
        "\tESC - quit the program\n"
        "\tc - stop the tracking\n"
        "\tb - switch to/from backprojection view\n"
        "\th - show/hide object histogram\n"
        "To initialize tracking, select the object with mouse\n" );
    //打印程序功能列表

    cvNamedWindow(  );
    //用于显示直方图
    cvNamedWindow(  );
    //用于显示视频
    cvSetMouseCallback(  );
    //设置鼠标回调函数
    cvCreateTrackbar( ,  );
    cvCreateTrackbar( ,  );
    cvCreateTrackbar( ,  );
    //设置滑动条

    for(;;)
    //进入视频帧处理主循环
    {
        IplImage* frame = ;
        int i, bin_w, c;

        frame = cvQueryFrame( capture );
        if( !frame )
            break;

        if( !image )
        //image为0,表明刚开始还未对image操作过,先建立一些缓冲区
        {
            image = cvCreateImage( cvGetSize(frame), ,  );
            image->origin = frame->origin;
            hsv = cvCreateImage( cvGetSize(frame), ,  );
            hue = cvCreateImage( cvGetSize(frame), ,  );
            mask = cvCreateImage( cvGetSize(frame), ,  );
            //分配掩膜图像空间
            backproject = cvCreateImage( cvGetSize(frame), ,  );
            //分配反向投影图空间,大小一样,单通道
            hist = cvCreateHist( , &hdims, CV_HIST_ARRAY, &hranges,  );
            //分配直方图空间
            histimg = cvCreateImage( cvSize(,), ,  );
            //分配用于直方图显示的空间
            cvZero( histimg );
            //置背景为黑色
        }

        cvCopy( frame, image,  );
        cvCvtColor( image, hsv, CV_BGR2HSV );
        //把图像从RGB表色系转为HSV表色系

        if( track_object )
        //track_object非零,表示有需要跟踪的物体
        {
            int _vmin = vmin, _vmax = vmax;

            cvInRangeS( hsv, cvScalar(,smin,MIN(_vmin,_vmax),),
                        cvScalar(,,MAX(_vmin,_vmax),), mask );
            //制作掩膜板，只处理像素值为H：0~180，S：smin~256，V：vmin~vmax之间的部分
            cvSplit( hsv, hue, , ,  );
            //分离H分量

             )
            //如果需要跟踪的物体还没有进行属性提取，则进行选取框类的图像属性提取
            {
                .f;
                cvSetImageROI( hue, selection );
                //设置原选择框为ROI
                cvSetImageROI( mask, selection );
                //设置掩膜板选择框为ROI
                cvCalcHist( &hue, hist, , mask );
                //得到选择框内且满足掩膜板内的直方图
                cvGetMinMaxHistValue( hist, , &max_val, ,  );
                cvConvertScale( hist->bins, hist->bins, max_val ? . / max_val : .,  );
                // 对直方图的数值转为0~255
                cvResetImageROI( hue );
                //去除ROI
                cvResetImageROI( mask );
                //去除ROI
                track_window = selection;
                track_object = ;
                //置track_object为1,表明属性提取完成
                cvZero( histimg );
                bin_w = histimg->width / hdims;
                ; i < hdims; i++ )
                //画直方图到图像空间
                {
                     );
                    CvScalar color = hsv2rgb(i*.f/hdims);
                    cvRectangle( histimg, cvPoint(i*bin_w,histimg->height),
                                 cvPoint((i+)*bin_w,histimg->height - val),
                                 color, -, ,  );
                }
            }

            cvCalcBackProject( &hue, backproject, hist );
            //计算hue的反向投影图
            cvAnd( backproject, mask, backproject,  );
            //得到掩膜内的反向投影
            cvCamShift( backproject, track_window,
                        cvTermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, ,  ),
                        &track_comp, &track_box );
            //使用MeanShift算法对backproject中的内容进行搜索,返回跟踪结果
            track_window = track_comp.rect;
            //得到跟踪结果的矩形框

            if( backproject_mode )
                cvCvtColor( backproject, image, CV_GRAY2BGR );

            if( image->origin )
                track_box.angle = -track_box.angle;
            cvEllipseBox( image, track_box, CV_RGB(,,), , CV_AA,  );
            //画出跟踪结果的位置
        }

         && selection.height >  )
        //如果正处于物体选择，画出选择框
        {
            cvSetImageROI( image, selection );
            cvXorS( image, cvScalarAll(), image,  );
            cvResetImageROI( image );
        }

        cvShowImage( "CamShiftDemo", image );
        cvShowImage( "Histogram", histimg );

        c = cvWaitKey();
         )
            break;
        switch( (char) c )
        //按键切换功能
        {
        case 'b':
            backproject_mode ^= ;
            break;
        case 'c':
            track_object = ;
            cvZero( histimg );
            break;
        case 'h':
            show_hist ^= ;
            if( !show_hist )
                cvDestroyWindow( "Histogram" );
            else
                cvNamedWindow(  );
            break;
        default:
            ;
        }
    }

    cvReleaseCapture( &capture );
    cvDestroyWindow("CamShiftDemo");

    ;
}

#ifdef _EiC
main(,"camshiftdemo.c");
#endif