一些小概念

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;

}

在里面我们能够非常easy的看出迭代过程

对这个算法想细致研究的同学能够參考一下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;

}

输出结果

-END-