Camshift算法原理(opencv源码剖析) (下)

最新推荐文章于 2019-11-08 12:26:41 发布
最新推荐文章于 2019-11-08 12:26:41 发布
阅读量1.3k 收藏
点赞数
分类专栏： 图像处理 OpenCV

转载于：http://hi.baidu.com/wcp12_4/item/c0d042d61addfb846dce3f45

opencv源码

// cvMeanShift
cvMeanShift( const void* imgProb, CvRect windowIn,
             CvTermCriteria criteria, CvConnectedComp* comp )
{
    CvMoments moments;
    int    i = 0, eps;
    CvMat  stub, *mat = (CvMat*)imgProb;
    CvMat  cur_win;
    CvRect cur_rect = windowIn;

    CV_FUNCNAME( "cvMeanShift" );

    if( comp )
        comp->rect = windowIn;

    moments.m00 = moments.m10 = moments.m01 = 0;

    __BEGIN__;

    CV_CALL( mat = cvGetMat( mat, &stub ));

    if( CV_MAT_CN( mat->type ) > 1 )
        CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );

    if( windowIn.height <= 0 || windowIn.width <= 0 )
        CV_ERROR( CV_StsBadArg, "Input window has non-positive sizes" );

    if( windowIn.x < 0 || windowIn.x + windowIn.width > mat->cols ||
        windowIn.y < 0 || windowIn.y + windowIn.height > mat->rows )
        CV_ERROR( CV_StsBadArg, "Initial window is not inside the image ROI" );

    CV_CALL( criteria = cvCheckTermCriteria( criteria, 1., 100 ));

    eps = cvRound( criteria.epsilon * criteria.epsilon );

    for( i = 0; i < criteria.max_iter; i++ )//迭代max_iter次，调用meanshift时传入
    {
        int dx, dy, nx, ny;
        double inv_m00;
  //得到子矩阵（搜索框）
        CV_CALL( cvGetSubRect( mat, &cur_win, cur_rect ));//返回输入的矩阵的矩形数组子集的矩阵头到cur_win
        CV_CALL( cvMoments( &cur_win, &moments ));//计算矩

        /* Calculating center of mass */
        if( fabs(moments.m00) < DBL_EPSILON )
            break;

        inv_m00 = moments.inv_sqrt_m00*moments.inv_sqrt_m00;//m00不为0
        // 计算重心偏移量
        dx = cvRound( moments.m10 * inv_m00 - windowIn.width*0.5 );//m10/m00  
        dy = cvRound( moments.m01 * inv_m00 - windowIn.height*0.5 );//m01/m00

        nx = cur_rect.x + dx;
        ny = cur_rect.y + dy;

        if( nx < 0 )
            nx = 0;
        else if( nx + cur_rect.width > mat->cols )
            nx = mat->cols - cur_rect.width;

        if( ny < 0 )
            ny = 0;
        else if( ny + cur_rect.height > mat->rows )
            ny = mat->rows - cur_rect.height;

        dx = nx - cur_rect.x;
        dy = ny - cur_rect.y;
        cur_rect.x = nx;//更新搜索框位置
        cur_rect.y = ny;

        /* Check for coverage centers mass & window */
        if( dx*dx + dy*dy < eps )
            break;
    }

    __END__;

    if( comp )
    {
        comp->rect = cur_rect;
        comp->area = (float)moments.m00;
    }

    return i;
}


// cvCamShift
 

cvCamShift( const void* imgProb, CvRect windowIn,
            CvTermCriteria criteria,
            CvConnectedComp* _comp,
            CvBox2D* box )
{
    const int TOLERANCE = 10;
    CvMoments moments;
    double m00 = 0, m10, m01, mu20, mu11, mu02, inv_m00;
    double a, b, c, xc, yc;
    double rotate_a, rotate_c;
    double theta = 0, square;
    double cs, sn;
    double length = 0, width = 0;
    int itersUsed = 0;
    CvConnectedComp comp;
    CvMat  cur_win, stub, *mat = (CvMat*)imgProb;

    CV_FUNCNAME( "cvCamShift" );

    comp.rect = windowIn;//初始搜索窗口

    __BEGIN__;

    CV_CALL( mat = cvGetMat( mat, &stub ));//目标图

    CV_CALL( itersUsed = cvMeanShift( mat, windowIn, criteria, &comp ));//调用meanshift
    windowIn = comp.rect;

 //搜索窗口扩大TOLERANCE，
    windowIn.x -= TOLERANCE;
    if( windowIn.x < 0 )
        windowIn.x = 0;

    windowIn.y -= TOLERANCE;
    if( windowIn.y < 0 )
        windowIn.y = 0;

    windowIn.width += 2 * TOLERANCE;
    if( windowIn.x + windowIn.width > mat->width )
        windowIn.width = mat->width - windowIn.x;

    windowIn.height += 2 * TOLERANCE;
    if( windowIn.y + windowIn.height > mat->height )
        windowIn.height = mat->height - windowIn.y;

//返回输入的矩阵的矩形数组子集的矩阵头到cur_win
    CV_CALL( cvGetSubRect( mat, &cur_win, windowIn ));

    /* Calculating moments in new center mass *///计算矩
    CV_CALL( cvMoments( &cur_win, &moments ));

    m00 = moments.m00;//0阶矩
    m10 = moments.m10;
    m01 = moments.m01;
    mu11 = moments.mu11;
    mu20 = moments.mu20;
    mu02 = moments.mu02;

    if( fabs(m00) < DBL_EPSILON )
        EXIT;

    inv_m00 = 1. / m00;
    xc = cvRound( m10 * inv_m00 + windowIn.x );//搜索窗口位置
    yc = cvRound( m01 * inv_m00 + windowIn.y );
    a = mu20 * inv_m00;
    b = mu11 * inv_m00;
    c = mu02 * inv_m00;

    /* Calculating width & height */
    square = sqrt( 4 * b * b + (a - c) * (a - c) );

    /* Calculating orientation */
    theta = atan2( 2 * b, a - c + square );

    /* Calculating width & length of figure */
    cs = cos( theta );
    sn = sin( theta );

    rotate_a = cs * cs * mu20 + 2 * cs * sn * mu11 + sn * sn * mu02;
    rotate_c = sn * sn * mu20 - 2 * cs * sn * mu11 + cs * cs * mu02;
    length = sqrt( rotate_a * inv_m00 ) * 4;//长
    width = sqrt( rotate_c * inv_m00 ) * 4;//宽

    /* In case, when tetta is 0 or 1.57... the Length & Width may be exchanged */
    if( length < width )
    {
        double t;
        
        CV_SWAP( length, width, t );
        CV_SWAP( cs, sn, t );
        theta = CV_PI*0.5 - theta;
    }

    /* Saving results */
    if( _comp || box )
    {
        int t0, t1;
        int _xc = cvRound( xc );
        int _yc = cvRound( yc );

        t0 = cvRound( fabs( length * cs ));
        t1 = cvRound( fabs( width * sn ));

        t0 = MAX( t0, t1 ) + 2;
        comp.rect.width = MIN( t0, (mat->width - _xc) * 2 );

        t0 = cvRound( fabs( length * sn ));
        t1 = cvRound( fabs( width * cs ));

        t0 = MAX( t0, t1 ) + 2;
        comp.rect.height = MIN( t0, (mat->height - _yc) * 2 );

        comp.rect.x = MAX( 0, _xc - comp.rect.width / 2 );
        comp.rect.y = MAX( 0, _yc - comp.rect.height / 2 );

        comp.rect.width = MIN( mat->width - comp.rect.x, comp.rect.width );
        comp.rect.height = MIN( mat->height - comp.rect.y, comp.rect.height );
        comp.area = (float) m00;
    }

    __END__;

    if( _comp )
        *_comp = comp;
    
    if( box )
    {
        box->size.height = (float)length;
        box->size.width = (float)width;
        box->angle = (float)(theta*180./CV_PI);
        box->center = cvPoint2D32f( comp.rect.x + comp.rect.width*0.5f,
                                    comp.rect.y + comp.rect.height*0.5f);
    }

    return itersUsed;
}

 

 

参考文献：

《学习opencv》中文版   

Computer Vision Face Tracking For Use in a Perceptual User Interface    。Gary R. Bradski  1998

cvhistogram.cpp   cvcamshift.cpp

**************************************************************** 给力的分割线  ***********************************************************************

 我的论文程序里用的meanshift函数，从opencv的meanshift函数改动而来（自己写的代码来计算0阶矩、1阶矩，其他小改动了哈，使之适应小数据集的均值飘逸计算）

CV_IMPL int myMeanShift( const IplImage* imgProb, CvRect windowIn, CvTermCriteria criteria, CvConnectedComp* comp )
{
       int  i = 0, eps;
    CvRect cur_rect = windowIn;

    CV_FUNCNAME( "myMeanShift" );

    if( comp )
        comp->rect = windowIn;

    double m00 = 0; 
 double m10 = 0; 
 double m01 = 0;//0阶矩 1阶矩

    __BEGIN__;

 

    if( windowIn.height <= 0 || windowIn.width <= 0 )
        CV_ERROR( CV_StsBadArg, "Input window has non-positive sizes" );

    if( windowIn.x < 0 || windowIn.x + windowIn.width > imgProb->width ||
        windowIn.y < 0 || windowIn.y + windowIn.height > imgProb->height )
        CV_ERROR( CV_StsBadArg, "Initial window is not inside the image ROI" );

    CV_CALL( criteria = cvCheckTermCriteria( criteria, 1., 100 ));

    eps = cvRound( criteria.epsilon * criteria.epsilon );

    for( i = 0; i < 1/*criteria.max_iter*/; i++ )//迭代100次
    {
        int dx, dy, nx, ny;
        double inv_m00;
  
  //计算矩 m00 m10 m01

  //得到图像的值 , cvGet2D(img,行,列)
  cout<<"val  ";
  for(int i = 0; i < windowIn.height ; i++)
  {
   for(int j =0 ; j < windowIn.width ; j++)
   {
    if(  ((cur_rect.y + i) < imgProb->height)  &&  ((cur_rect.x + j) < imgProb->width)  )
    {
     CvScalar tmp;
     tmp = cvGet2D(imgProb , windowIn.y + i, windowIn.x + j);//行、列

     cout<<" "<<tmp.val[0];

     m00 = m00 + tmp.val[0];

     m10 = m10 + (j+1) * tmp.val[0];
     m01 = m01 + (i+1) * tmp.val[0];

    }

   }

   cout<<endl;
  }
  cout<<endl<<"m00 "<<m00<<" "<<m10<<" "<<m01<<endl;


  //
  


        /* Calculating center of mass */
        if( fabs(m00) < DBL_EPSILON )
            break;

  if(m00!=0)
  {
   inv_m00 = (1/sqrt(m00))*(1/sqrt(m00));//m00不为0
  }
        // 计算重心偏移量
        dx = cvRound( m10 * inv_m00 - (windowIn.width*0.5 +0.5));//m10/m00  
        dy = cvRound( m01 * inv_m00 - (windowIn.height*0.5 +0.5));//m01/m00

        nx = cur_rect.x + dx;//重心位移
        ny = cur_rect.y + dy;

  cout<<"center:"<<m10 * inv_m00<<" "<<m01 * inv_m00<<endl ;
  cout<<"rect.x y "<<cur_rect.x<<" "<<cur_rect.y<<"  nx ny :"<<nx<<" "<<ny<<endl;
  cout<<"dx dy11:"<<m10 * inv_m00 - (windowIn.width*0.5+0.5)<<" "<<m01 * inv_m00 - (windowIn.height*0.5+0.5)<<"   ";
  cout<<"win  width height :"<<windowIn.x<<" "<<windowIn.y<<" "<<windowIn.width*0.5<<"  "<<windowIn.height*0.5<<endl;
  cout<<"dx dy:"<<dx<<" "<<dy<<endl;

        if( nx < 0 )
            nx = 0;
        else if( nx + cur_rect.width > imgProb->width )
            nx = imgProb->width - cur_rect.width;

        if( ny < 0 )
            ny = 0;
        else if( ny + cur_rect.height > imgProb->height )
            ny = imgProb->height - cur_rect.height;

        dx = nx - cur_rect.x;
        dy = ny - cur_rect.y;
        cur_rect.x = nx;//更新搜索框位置
        cur_rect.y = ny;

        /* Check for coverage centers mass & window */
        if( dx*dx + dy*dy < eps )
            break;
    }

    __END__;

    if( comp )
    {
        comp->rect = cur_rect;
        comp->area = (float)m00;
    }

    return i;
}

**************************************************************** 给力的分割线  ***********************************************************************

相对于camshift的颜色概率分布，其他基于meanshift的跟踪方法大多用小模板在原图像中进行匹配(匹配值计算有各种方法)，计算模板中心位置的像素(原图像)的匹配值，来得到原图像的匹配度概率分布。再在这个分布上meanshift。这些方法和camshift相比就是计算量大了很多，应该是这样子的，了解还不是很多。

feixiaku
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opencv动态目标跟踪学习总结
bcbobo21cn的专栏
03-15 8万+
用opencv实现对视频中动态目标的追踪 第一步，是要建立一个编程环境，然后加载opencv的库路径等等。具体步骤在 http://www.opencv.org.cn/ 的“安装”中 有详细介绍。 第二步，建立一个MFC的对话框程序，做两个按钮，一个“打开视频文件”，一个“运动跟踪处理”。 具体操作： 1 建立MFC对话框程序的框架：File  ->New  -> MFC A
Python+OpenCV：Meanshift and Camshift
《好好先生》专栏
11-26 391
Python+OpenCV：Meanshift and Camshift Meanshift Consider you have a set of points. (It can be a pixel distribution like histogram backprojection). You are given a small window (may be a circle) and you have to move that window to the area of maximum pixe
meanshift算法学习（二）：opencv中的meanshift
On my way
11-03 6256
0.前言       接着上一篇文章点击打开链接说，opencv中提供的meanshift可以用来实现跟踪，其基本原理是迭代求解概率分布的“局部极值”。这一篇内容，我只讲opencv中的meanshift的用法和源代码分析。因为：（1）具体的数学原理推导，涉及到一些其他方面的知识譬如无参数估计、核函数等方面内容较多（2）opencv中的meanshift严格意义上来说是最简化版本的算法，结合着数
计算机视觉
柯影的博客
11-08 528
计算机视觉部分，主要侧重在底层特征提取，视频分析，跟踪，目标检测和识别方面等方面。对于自己不太熟悉的领域比如摄像机标定和立体视觉，仅仅列出上google上引用次数比较多的文献。有一些刚刚出版的文章，个人非常喜欢，也列出来了。 1. Active Appearance Models 活动表观模型和活动轮廓模型基本思想来源Snake，现在在人脸三维建模方面得到了很成功的应用，这里列出了三篇最早...
在OpenCV里使用Camshift算法的实现
09-18
总的来说，OpenCV中的Camshift算法提供了一种强大而灵活的工具，适用于各种目标跟踪问题，尤其在目标大小和形状变化较大的情况下表现优越。通过理解其原理和正确使用，开发者可以构建出更精确、鲁棒的目标跟踪系统。
Opencv基于CamShift算法实现目标跟踪
08-28
Opencv基于CamShift算法实现目标跟踪 Opencv基于CamShift算法实现目标跟踪是计算机视觉领域中的一种目标跟踪算法，主要用于视频序列中的目标跟踪。CamShift算法全称是“Continuously Adaptive Mean-Shift”（连续的...
camshift(opencv).rar_camshift_camshift opencv_opencv camshift
07-13
opencv的camshift程序+注释 camshift算法 里面程序有详细的注释 是初学者的好资料 有利于自学
基于camshift算法的OpenCV目标跟踪的实现
04-01
基于camshift算法的OpenCV目标跟踪的实现 用于OpenCV1.0+VC++6.0
Camshift算法（2）
weixin_30329623的博客
09-15 63
这里主要介绍下MeanShift算法的迭代过程，毕竟Camshift算法是以它为核心的。MeanShift算法是一种寻找局部极值的方法。做为一种直观上的理解是它一步一步爬向最高点即爬山算法.而怎么个爬法，用计算出的重心做为下一步窗口的中心，直到窗口的位置不再变化。在理解MeanShift算法的时候，可以先不加入核函数（是计算距离对统计分布的影响）和权重函数（如人为主观的影响）。 在...
opencv2对读书笔记——使用均值漂移算法查找物体
figou22221的专栏
06-19 630
一些小概念 1.反投影直方图的结果是一个概率映射，体现了已知图像内容出现在图像中特定位置的概率。 2.概率映射可以找到最初的位置，从最初的位置开始并且迭代移动，便可以找到精确的位置，这就是均值漂移算法做的事情。 3.均值漂移算法是以迭代的方式锁定函数的局部最大值的。 关于均值漂移算法的过程(opencv) 其实均值漂移算法就是寻找预定义寻找区域中数据点的重心，或者
Camshift算法（1）
weixin_30566063的博客
09-28 211
Camshift算法是Continuously Adaptive Mean Shift algorithm的简称。它是一个基于MeanSift的改进算法。它首次由Gary R.Bradski等人提出和应用在人脸的跟踪上，并取得了不错的效果。由于它是利用颜色的概率信息进行的跟踪，使得它的运行效率比较高。Camshift算法的过程由下面步骤组成： （1）确定初始目标及其区域； （2）计...
模板匹配中差值的平方和（SSD）与互相关准则的关系
热门推荐
zouxy09的专栏
01-28 2万+
模板匹配中差值的平方和（SSD）与互相关准则的关系 zouxy09@qq.com http://blog.csdn.net/zouxy09          模板匹配TemplateMatching是在图像中寻找目标的方法之一。原理很简单，就是在一幅图像中寻找和模板图像（patch）最相似的区域。在OpenCV中有对应的函数可以调用：        void matchTemplate(
图像处理与计算机视觉：基础，经典以及最近发展
木瓜子的博客
07-20 1276
本文转载自：https://blog.csdn.net/dcraw/article/details/7617891 图像处理与计算机视觉：基础，经典以及最近发展（1） 序&nbsp; 1.&nbsp;为什么要写这篇文章 从2002年到现在，接触图像快十年了。虽然没...
目标跟踪：Meanshift, Camshift
EastCarFxx Blog
04-25 3584
Meanshift/Camshift
图像处理与计算机视觉 基础，经典以及最近发展
飞信天下专栏
05-22 1万+
************************************************************************************************************************************************************************************            在这里，我特别
OpenCV自带的CamShift算法解读
海尔兄弟的博客
04-28 5899
今天要给大家分享的是
CamShift 算法原理
最新发布
05-13
CamShift（Continuously Adaptive Mean Shift）算法是一种基于Mean Shift算法的目标跟踪算法。其原理可以概括为以下几...通过这种动态调整的方式，CamShift算法可以在目标尺寸变化较大的情况下，仍能够有效地追踪目标。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值