一些小概念
1.反投影直方图的结果是一个概率映射，体现了已知图像内容出现在图像中特定位置的概率。 2.概率映射可以找到最初的位置，从最初的位置开始并且迭代移动，便可以找到精确的位置，这就是均值漂移算法做的事情。 3.均值漂移算法是以迭代的方式锁定函数的局部最大值的。
关于均值漂移算法的过程(OpenCV)
其实均值漂移算法就是寻找预定义寻找区域中数据点的重心，或者说加权平均值。将寻找区域中心移动到数据点的重心处，并重复这个过程直到寻找区域重心收敛到一个稳定点。 OpenCV中定义了两种终止条件：迭代最大次数以及窗口重心的位移值（低于该值即认为算法收敛）。 在OpenCV中实现这个过程的是meanshift函数，其源代码如下：

#include "_cv.h"  
  
CV_IMPL int  
cvMeanShift( const void* imgProb, CvRect windowIn,  
             CvTermCriteria criteria, CvConnectedComp* comp )  
{  
    //CvMoments用来计算矩形的重心，面积等形状特征  
    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;  
  
    //把0阶矩和1阶矩先初始化置零  
    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" );  
  
    //迭代的标准，精度=1.0，迭代次数=100  
    CV_CALL( criteria = cvCheckTermCriteria( criteria, 1., 100 ));  
  
    //精度eps=1  
    eps = cvRound( criteria.epsilon * criteria.epsilon );  
  
    //最大循环次数=最大迭代次数criteria.max_iter=100  
    for( i = 0; i < criteria.max_iter; i++ )  
    {  
        int dx, dy, nx, ny;  
        double inv_m00;  
  
        //选取搜索区域，对该矩形区域计算它的0,1阶矩  
        CV_CALL( cvGetSubRect( mat, &cur_win, cur_rect ));   
        CV_CALL( cvMoments( &cur_win, &moments ));  
  
        /* Calculating center of mass */  
        if( fabs(moments.m00) < DBL_EPSILON )  
            break;  
  
        //搜索区域的质量m00  
        inv_m00 = moments.inv_sqrt_m00*moments.inv_sqrt_m00;  
        //搜索区域的水平重心偏移dx  
        dx = cvRound( moments.m10 * inv_m00 - windowIn.width*0.5 );  
        //搜索区域的垂直重心偏移dy  
        dy = cvRound( moments.m01 * inv_m00 - windowIn.height*0.5 );  
  
        //搜索区域的重心坐标(nx,ny)  
        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__;  
  
    //对meanshift函数的返回值赋值  
    if( comp )  
    {  
        comp->rect = cur_rect;  
        comp->area = (float)moments.m00;  
    }  
  
    return i;  
}  

 
在里面我们可以很容易的看出迭代过程 对这个算法想仔细研究的同学可以参考一下Dorin Comaniciu 等人2002年写的： 《Mean Shift：A Robust Approach Toward Feature Space Analysis》
实际例子
例子代码

#include <opencv2\core\core.hpp>  
#include <opencv2\highgui\highgui.hpp>  
#include <opencv2\imgproc\imgproc.hpp>  
#include <opencv2\video\tracking.hpp>  
  
#include <iostream>  
#include <vector>  
using namespace std;  
  
#include "objectFinder.h"  
#include "colorhistogram.h"  
  
int main()  
{  
    //读取参考图像  
    cv::Mat image= cv::imread("../3.jpg");  
    if (!image.data)  
        return 0;   
  
    //定义查找物体  
    cv::Mat imageROI= image(cv::Rect(85,200,64,64));  
    cv::rectangle(image, cv::Rect(85,200,64,64),cv::Scalar(0,0,255));  
  
    //显示参考图像  
    cv::namedWindow("第一张图片，标记篮球位置");  
    cv::imshow("第一张图片，标记篮球位置",image);  
  
    //获得色度直方图  
    ColorHistogram hc;  
    cv::MatND colorhist= hc.getHueHistogram(imageROI);  
  
    //读入目标图像  
    image= cv::imread("../4.jpg");  
  
    //显示目标图像  
    cv::namedWindow("第二张图片");  
    cv::imshow("第二张图片",image);  
  
    //将RGB图像图像转换为HSV图像  
    cv::Mat hsv;  
    cv::cvtColor(image, hsv, CV_BGR2HSV);  
  
    //分离图像通道  
    vector<cv::Mat> v;  
    cv::split(hsv,v);  
  
    //消除饱和度较低的像素点  
    int minSat=65;  
    cv::threshold(v[1],v[1],minSat,255,cv::THRESH_BINARY);  
    cv::namedWindow("第二张图片消除饱和度较低的像素点");  
    cv::imshow("第二张图片消除饱和度较低的像素点",v[1]);  
  
    //进行直方图反投影  
    ObjectFinder finder;  
    finder.setHistogram(colorhist);  
    finder.setThreshold(0.3f);  
    int ch[1]={0};  
    cv::Mat result= finder.find(hsv,0.0f,180.0f,ch,1);  
  
    cv::namedWindow("第二张图片进行直方图反投影");  
    cv::imshow("第二张图片进行直方图反投影",result);  
  
    //利用位运算消除低饱和度像素  
    cv::bitwise_and(result,v[1],result);  
    cv::namedWindow("第二张图片利用位运算进一步消除低饱和度像素点");  
    cv::imshow("第二张图片利用位运算进一步消除低饱和度像素点",result);  
  
    // 得到反投影直方图概率图像  
    finder.setThreshold(-1.0f);  
    result= finder.find(hsv,0.0f,180.0f,ch,1);  
    cv::bitwise_and(result,v[1],result);  
    cv::namedWindow("第二张图片处理后的二值图像");  
    cv::imshow("第二张图片处理后的二值图像",result);  
  
    cv::Rect rect(85,200,64,64);  
    cv::rectangle(image, rect, cv::Scalar(0,0,255));  
  
    cv::TermCriteria criteria(cv::TermCriteria::MAX_ITER,10,0.01);  
    cout << "均值漂移迭代次数 = " << cv::meanShift(result,rect,criteria) << endl;  
  
    cv::rectangle(image, rect, cv::Scalar(0,255,0));  
  
    //展示结果图  
    cv::namedWindow("查找结果，红框为第一幅图中篮球位置，绿框为现位置");  
    cv::imshow("查找结果，红框为第一幅图中篮球位置，绿框为现位置",image);  
  
    cv::waitKey();  
    return 0;  
}  

 
输出结果

本文链接:https://www.it72.com/11158.htm