有问题请留言或发邮箱：johnnycons@163.com
因为实验室项目工程的需要，最近在研究目标跟踪算法。这里提的Fast Compressive Tracking （快速压缩跟踪）算法是张开华教授在其之前的Compressive Tracking 算法（网站看这里）上做了一些简单的优化，本人测试的结果是FCT算法的处理速度在59帧/s左右（windows下），而之前的CT算法大概是29帧/s，修改后的速度还是不错的（这里的工程都是读图片帧序列，后面给出的工程资源有自带资源）。因为FCT的网站上没有给出代码的C++实现（只有MATLAB的代码，网站看这里），这里就贴出我按照其论文的意思给出C++的代码实现，这里的C++代码也是从其CT算法的c++代码上修改而来的，修改的地方我会在代码中说明。另外为了将代码能够移植到linux上，我对代码的初始运行的地方也做了修改，所以这里贴出的代码是可以运行在linux上的。代码中的注释参考了zouxy09大神的博客，最后为了方便大家运行，我会将FCT C++工程以及linux下运行的代码分别打包供大家下载。因为我也是初学者，能力有限，所以若文中有纰漏请读者指正，有问题请留言或者发我邮箱，thanks。
---------------------------------------------------------------------------------------------------
2015/1/24 补充：该版本C++代码没有实现多尺度的情况。我在看论文的时候没有仔细阅读论文（细看了CT，而没细看FCT），以为FCT论文中没有给出尺度变换的设计。后来有网友指出论文中有尺度变换，罪过罪过，很久之前的东西了，所以暂时没办法更新代码。
2015/1/24 补充：该版本C++代码没有实现多尺度的情况。我在看论文的时候没有仔细阅读论文（细看了CT，而没细看FCT），以为FCT论文中没有给出尺度变换的设计。后来有网友指出论文中有尺度变换，罪过罪过，很久之前的东西了，所以暂时没办法更新代码。
/************************************************************************
* File: CompressiveTracker.h
* Brief: C++ demo for paper: Kaihua Zhang, Lei Zhang, Ming-Hsuan Yang,"Real-Time Compressive Tracking," ECCV 2012.
* Version: 1.0
* Author: Yang Xian
* Email: yang_xian521@163.com
* Date: 2012/08/03
* History:
* Revised by Kaihua Zhang on 14/8/2012, 23/8/2012
* Email: zhkhua@gmail.com
* Homepage: http://www4.comp.polyu.edu.hk/~cskhzhang/
* Project Website: http://www4.comp.polyu.edu.hk/~cslzhang/CT/CT.htm
************************************************************************/
#pragma once
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <vector>
using std::vector;
using namespace cv;
//---------------------------------------------------
class CompressiveTracker
{
public:
CompressiveTracker(void);
~CompressiveTracker(void);
private:
int featureMinNumRect;
int featureMaxNumRect;
int featureNum;//每个box的harr特征个数（也就是弱分类器个数）
vector<vector<Rect>> features;
vector<vector<float>> featuresWeight;
int rOuterPositive;//在离上一帧跟踪到的目标位置的距离小于rOuterPositive的范围内采集 正样本
vector<Rect> samplePositiveBox;//采集的正样本box集
vector<Rect> sampleNegativeBox;//采集的负样本box集
int rSearchWindow;//扫描窗口的大小，或者说检测box的大小
Mat imageIntegral; //图像的积分图
Mat samplePositiveFeatureValue;//采集的正样本的harr特征值 ？？？特征值是矩阵？？
Mat sampleNegativeFeatureValue;//采集的负样本的harr特征值
//对每个样本z（m维向量），它的低维表示是v（n维向量，n远小于m）。假定v中的各元素是独立分布的。
//假定在分类器H(v)中的条件概率p(vi|y=1)和p(vi|y=0)属于高斯分布，并且可以用以下四个参数来描述：
//分别是描述正负样本的高斯分布的均值u和方差sigma
vector<float> muPositive;
vector<float> sigmaPositive;
vector<float> muNegative;
vector<float> sigmaNegative;
float learnRate;//学习速率，控制分类器参数更新的步长
vector<Rect> detectBox; //需要检测的box
Mat detectFeatureValue;
RNG rng; //随机数
private:
void HaarFeature(Rect& _objectBox, int _numFeature);
void sampleRect(Mat& _image, Rect& _objectBox, float _rInner, float _rOuter, int _maxSampleNum, vector<Rect>& _sampleBox);/************************************************************************
* File: RunTracker.cpp
* Brief: C++ demo for paper: Kaihua Zhang, Lei Zhang, Ming-Hsuan Yang,"Real-Time Compressive Tracking," ECCV 2012.
* Version: 1.0
* Author: Yang Xian
* Email: yang_xian521@163.com
* Date: 2012/08/03
* History:
* Revised by Kaihua Zhang on 14/8/2012, 23/8/2012
* Email: zhkhua@gmail.com
* Homepage: http://www4.comp.polyu.edu.hk/~cskhzhang/
* Project Website: http://www4.comp.polyu.edu.hk/~cslzhang/CT/CT.htm
************************************************************************/
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdio.h>
#include <string.h>
//#include <Windows.h>
#include <time.h>
#include "FastCompressiveTracker.h"
using namespace cv;
using namespace std;
void readConfig(char* configFileName, char* imgFilePath, Rect &box,int &num);
/* Description: read the tracking information from file "config.txt"
Arguments:
-configFileName: config file name
-ImgFilePath: Path of the storing image sequences
-box: [x y width height] intial tracking position
History: Created by Kaihua Zhang on 15/8/2012
*/
void readImageSequenceFiles(char* ImgFilePath,vector <string> &imgNames,int &num);
/* Description: search the image names in the image sequences
Arguments:
-ImgFilePath: path of the image sequence
-imgNames: vector that stores image name
History: Created by Kaihua Zhang on 15/8/2012
*/
int main(int argc, char * argv[])
{
time_t start,stop;
start = time(NULL);//获取程序开始运行的时间
char imgFilePath[100];
char conf[100];
strcpy(conf,"./config.txt");
//char tmpDirPath[MAX_PATH+1];//MAX_PATH在windows下是260
char tmpDirPath[261];//this is a test for chengxin
Rect box; // [x y width height] tracking position
int num;
vector <string> imgNames;
readConfig(conf,imgFilePath,box,num);//读取视频帧的配置信息
readImageSequenceFiles(imgFilePath,imgNames,num);//将每一帧的名称放入数组imgNames
// CT framework
CompressiveTracker ct;
Mat frame;
Mat grayImg;
sprintf(tmpDirPath, "%s/", imgFilePath);
imgNames[0].insert(0,tmpDirPath);
cout<<imgNames[0]<<endl;
frame = imread(imgNames[0]);//读取第一帧图片
cvtColor(frame, grayImg, CV_RGB2GRAY); //转换成灰度图
ct.init(grayImg, box); //通过第一帧初始化分类器等参数
//imshow("CT", frame);//just for test 2014/12/14
//waitKey(330);
char strFrame[20];
FILE* resultStream;
resultStream = fopen("TrackingResults.txt", "w");
fprintf (resultStream,"%i %i %i %i\n",(int)box.x,(int)box.y,(int)box.width,(int)box.height);
for(int i = 1; i < imgNames.size()-1; i ++)//处理之后的每一帧图片
{
sprintf(tmpDirPath, "%s/", imgFilePath);
imgNames[i].insert(0,tmpDirPath);
frame = imread(imgNames[i]);// get frame
cvtColor(frame, grayImg, CV_RGB2GRAY);
ct.processFrame(grayImg, box);// Process frame//处理图片帧
rectangle(frame, box, Scalar(200,0,0),2);// Draw rectangle//矩形绘制
fprintf (resultStream,"%i %i %i %i\n",(int)box.x,(int)box.y,(int)box.width,(int)box.height);
sprintf(strFrame, "#%d ",i) ;
putText(frame,strFrame,cvPoint(0,20),2,1,CV_RGB(25,200,25));
imshow("CT", frame);// Display
waitKey(1);
}
stop =time(NULL);//获取程序结束运行的时间
int FPS = imgNames.size()/(stop-start);
cout<< "The FPS of CT is : "<<FPS<<endl;
cout<<endl;
fclose(resultStream);
return 0;
}
void readConfig(char* configFileName, char* imgFilePath, Rect &box,int &num)
{
int x;
int y;
int w;
int h;
int nums;
fstream f;
char cstring[1000];
int readS=0;
f.open(configFileName, fstream::in);
char param1[200]; strcpy(param1,"");
char param2[200]; strcpy(param2,"");
char param3[200]; strcpy(param3,"");//初始化为空串
f.getline(cstring, sizeof(cstring));
readS=sscanf (cstring, "%s %s %s", param1,param2, param3);
strcpy(imgFilePath,param3);
f.getline(cstring, sizeof(cstring));
f.getline(cstring, sizeof(cstring));
f.getline(cstring, sizeof(cstring));
readS=sscanf (cstring, "%s %s %i %i %i %i %i", param1,param2, &x, &y, &w, &h,&nums);
box = Rect(x, y, w, h);
num = nums;
}
void readImageSequenceFiles(char* imgFilePath,vector <string> &imgNames,int &num)
{
imgNames.clear();
/*
char tmpDirSpec[MAX_PATH+1];
sprintf (tmpDirSpec, "%s/*", imgFilePath);
WIN32_FIND_DATA f;
HANDLE h = FindFirstFile(tmpDirSpec , &f);
if(h != INVALID_HANDLE_VALUE)
{
FindNextFile(h, &f); //read ..
FindNextFile(h, &f); //read .
do
{
imgNames.push_back(f.cFileName);
} while(FindNextFile(h, &f));
}
FindClose(h);
*/
String sequencesName = "%05d.jpg";
for(int i=1;i<=num;i++)
{ char imgName[256];
sprintf(imgName,sequencesName.c_str(),i);
String name = imgName;
imgNames.push_back(name);
//cout<<"the name of this frame is "<<name<<endl;
}
}#include "FastCompressiveTracker.h"
#include <math.h>
#include <iostream>
using namespace cv;
using namespace std;
//------------------------------------------------
CompressiveTracker::CompressiveTracker(void)
{
featureMinNumRect = 2;
featureMaxNumRect = 4; // number of rectangle from 2 to 4
featureNum = 50; // number of all weaker classifiers, i.e,feature pool
rOuterPositive = 4; // radical scope of positive samples//scope是范围的意思
rSearchWindow = 25; // size of search window
muPositive = vector<float>(featureNum, 0.0f);//50个
muNegative = vector<float>(featureNum, 0.0f);//50个
sigmaPositive = vector<float>(featureNum, 1.0f);//50个
sigmaNegative = vector<float>(featureNum, 1.0f);//50个
learnRate = 0.85f; // Learning rate parameter
}
CompressiveTracker::~CompressiveTracker(void)
{
}
/*通过积分图来计算采集到的每一个样本的harr特征，这个特征通过与featuresWeight来相乘
就相当于投影到随机测量矩阵中了，也就是进行稀疏表达了。这里不明白的话，可以看下
论文中的图二，就比较直观了。
还有一点：实际上这里采用的不属于真正的harr特征，我博客中翻译有误。这里计算的是
在box中采样得到的不同矩形框的灰度加权求和（当权重是负数的时候就是灰度差）
当为了表述方便，我下面都用harr特征来描述。
每一个样本有50个harr特征，每一个harr特征是由2到3个随机选择的矩形框来构成的，
对这些矩形框的灰度加权求和作为这一个harr特征的特征值。 */
void CompressiveTracker::HaarFeature(Rect& _objectBox, int _numFeature)
/*Description: compute Haar features
Arguments:
-_objectBox: [x y width height] object rectangle
-_numFeature: total number of features.The default is 50.每一个样本有50个harr特征,每一个harr特征是由2到3个随机选择的矩形框来构成的，
*/
{ //_numFeature是一个样本box的harr特征个数，共50个。而上面说到，
//每一个harr特征是由2到3个随机选择的矩形框（vector<Rect>()类型）来构成的。
features = vector<vector<Rect>>(_numFeature, vector<Rect>());
//每一个反应特征的矩形框对应于一个权重，实际上就是随机测量矩阵中相应的元素，用它来与对应的特征
//相乘，表示以权重的程度来感知这个特征。换句话说，featuresWeight就是随机测量矩阵。
featuresWeight = vector<vector<float>>(_numFeature, vector<float>());
int numRect;
Rect rectTemp;
float weightTemp;
for (int i=0; i<_numFeature; i++)//_numFeature是50
{ //numRect是 2或者 3
//那么下面的功能就是得到[2，4）范围的随机数，然后用cvFloor返回不大于参数的最大整数值，那要么是2，要么是3。
numRect = cvFloor(rng.uniform((double)featureMinNumRect, (double)featureMaxNumRect));//这两个值是2和4
for (int j=0; j<numRect; j++)
{
//我在一个box中随机生成一个矩形框，那和你这个box的x和y坐标就无关了，但我必须保证我选择
//的这个矩形框不会超出你这个box的范围啊，是吧
//但这里的3和下面的2是啥意思呢？我就不懂了，个人理解是为了避免这个矩形框太靠近box的边缘了
//要离边缘最小2个像素，不知道这样理解对不对，恳请指导
rectTemp.x = cvFloor(rng.uniform(0.0, (double)(_objectBox.width - 3)));
rectTemp.y = cvFloor(rng.uniform(0.0, (double)(_objectBox.height - 3)));
//cvCeil 返回不小于参数的最小整数值
rectTemp.width = cvCeil(rng.uniform(0.0, (double)(_objectBox.width - rectTemp.x - 2)));
rectTemp.height = cvCeil(rng.uniform(0.0, (double)(_objectBox.height - rectTemp.y - 2)));
features[i].push_back(rectTemp);
//保存得到的特征模板。注意哦，这里的矩形框是相对于box的相对位置哦，不是针对整幅图像的哦
weightTemp = (float)pow(-1.0, cvFloor(rng.uniform(0.0, 2.0))) / sqrt(float(numRect));
//weightTemp = (float)pow(-1.0, c);
//pow(-1.0, c)也就是-1的c次方，而c随机地取0或者1，也就是说weightTemp是随机的正或者负。
//随机测量矩阵中，矩阵元素有三种，sqrt(s)、-sqrt(s)和零。为正和为负的概率是相等的，
//这就是为什么是[2，4）均匀采样的原因，就是取0或者1概率一样。
//但是这里为什么是sqrt(s)分之一呢？还有什么时候是0呢？论文中是0的概率不是挺大的吗？
//没有0元素，哪来的稀疏表达和压缩呢？不懂，恳请指导！（当然稀疏表达的另一个好处
//就是只需保存非零元素。但这里和这个有关系吗？）
featuresWeight[i].push_back(weightTemp);
}
}
}
在上一帧跟踪的目标box的周围采集若干正样本和负样本，来初始化或者更新分类器的
void CompressiveTracker::sampleRect(Mat& _image, Rect& _objectBox, float _rInner, float _rOuter, int _maxSampleNum, vector<Rect>& _sampleBox)
/* Description: compute the coordinate of positive and negative sample image templates
Arguments:
-_image: processing frame
-_objectBox: recent object position
-_rInner: inner sampling radius
-_rOuter: Outer sampling radius
-_maxSampleNum: maximal number of sampled images
-_sampleBox: Storing the rectangle coordinates of the sampled images.
*/
{
int rowsz = _image.rows - _objectBox.height - 1;
int colsz = _image.cols - _objectBox.width - 1;
float inradsq = _rInner*_rInner;
float outradsq = _rOuter*_rOuter;
//我们是在上一帧跟踪的目标box的周围采集正样本和负样本的，而这个周围是通过以
//这个目标为中心的两个圆来表示，这两个圆的半径是_rInner和_rOuter。
//我们在离上一帧跟踪的目标box的小于_rInner距离的范围内采集正样本，
//在大于_rOuter距离的范围内采集负样本（论文中还有一个上界，但好像
//这里没有，其实好像也没什么必要噢）
int dist;
//这四个是为了防止采集的框超出图像范围的，对采集的box的x和y坐标做限制
int minrow = max(0,(int)_objectBox.y-(int)_rInner);
int maxrow = min((int)rowsz-1,(int)_objectBox.y+(int)_rInner);
int mincol = max(0,(int)_objectBox.x-(int)_rInner);
int maxcol = min((int)colsz-1,(int)_objectBox.x+(int)_rInner);
int i = 0;
float prob = ((float)(_maxSampleNum))/(maxrow-minrow+1)/(maxcol-mincol+1);
int r;
int c;
_sampleBox.clear();//important
Rect rec(0,0,0,0);
for( r=minrow; r<=(int)maxrow; r++ )
for( c=mincol; c<=(int)maxcol; c++ ){
dist = (_objectBox.y-r)*(_objectBox.y-r) + (_objectBox.x-c)*(_objectBox.x-c);
//后两个条件是保证距离需要在_rInner和_rOuter的范围内
//那么rng.uniform(0.,1.) < prob 这个是干嘛的呢？
//连着上面看，如果_maxSampleNum大于那个最大个数，prob就大于1，这样，
//rng.uniform(0.,1.) < prob这个条件就总能满足，表示在这个范围产生的
//所以box我都要了（因为我本身想要更多的，但是你给不了我那么多，那么你能给的，我肯定全要了）。
//那如果你给的太多了，我不要那么多，也就是prob<1，那我就随机地跳几个走好了
if( rng.uniform(0.,1.)<prob && dist < inradsq && dist >= outradsq ){
rec.x = c;
rec.y = r;
rec.width = _objectBox.width;
rec.height= _objectBox.height;
_sampleBox.push_back(rec);
i++;
}
}
_sampleBox.resize(i);
}
//这个sampleRect的重载函数是用来在上一帧跟踪的目标box的周围（距离小于_srw）采集若干box来待检测。
//与上面的那个不一样，上面那个是在这一帧已经检测出目标的基础上，采集正负样本来更新分类器的。
//上面那个属于论文中提到的算法的第四个步骤，这个是第一个步骤。然后过程差不多，没什么好说的了
//
void CompressiveTracker::sampleRect(Mat& _image, Rect& _objectBox, float _srw, vector<Rect>& _sampleBox,int step)
/* Description: Compute the coordinate of samples when detecting the object.*/
{
int rowsz = _image.rows - _objectBox.height - 1;
int colsz = _image.cols - _objectBox.width - 1;
float inradsq = _srw*_srw;
int dist;
int minrow = max(0,(int)_objectBox.y-(int)_srw);
int maxrow = min((int)rowsz-1,(int)_objectBox.y+(int)_srw);
int mincol = max(0,(int)_objectBox.x-(int)_srw);
int maxcol = min((int)colsz-1,(int)_objectBox.x+(int)_srw);
int i = 0;
int r;
int c;
Rect rec(0,0,0,0);
_sampleBox.clear();//important
//step表示步长
for( r=minrow; r<=(int)maxrow; r=r+step )
for( c=mincol; c<=(int)maxcol; c=c+step ){
dist = (_objectBox.y-r)*(_objectBox.y-r) + (_objectBox.x-c)*(_objectBox.x-c);
if( dist < inradsq ){
rec.x = c;
rec.y = r;
rec.width = _objectBox.width;
rec.height= _objectBox.height;
_sampleBox.push_back(rec);
i++;
}
}
_sampleBox.resize(i);
}
// Compute the features of samples
//通过积分图来计算采集到的每一个样本的harr特征，这个特征通过与featuresWeight来相乘
//就相当于投影到随机测量矩阵中了，也就是进行稀疏表达了。这里不明白的话，可以看下
//论文中的图二，就比较直观了。所以这里得到的是：每个样本的稀疏表达后的harr特征。
//还有一点：实际上这里采用的不属于真正的harr特征，我博客中翻译有误。这里计算的是
//在box中采样得到的不同矩形框的灰度加权求和
void CompressiveTracker::getFeatureValue(Mat& _imageIntegral, vector<Rect>& _sampleBox, Mat& _sampleFeatureValue)
{
int sampleBoxSize = _sampleBox.size();
_sampleFeatureValue.create(featureNum, sampleBoxSize, CV_32F);//featureNum是50,参数分别是行、列、类型
float tempValue;
int xMin;
int xMax;
int yMin;
int yMax;
for (int i=0; i<featureNum; i++)
{
for (int j=0; j<sampleBoxSize; j++)
{
tempValue = 0.0f;
for (size_t k=0; k<features[i].size(); k++)
{//features中保存的特征模板（矩形框）是相对于box的相对位置的，
//所以需要加上box的坐标才是其在整幅图像中的坐标
xMin = _sampleBox[j].x + features[i][k].x;
xMax = _sampleBox[j].x + features[i][k].x + features[i][k].width;
yMin = _sampleBox[j].y + features[i][k].y;
yMax = _sampleBox[j].y + features[i][k].y + features[i][k].height;
tempValue += featuresWeight[i][k] *
(_imageIntegral.at<float>(yMin, xMin) +
_imageIntegral.at<float>(yMax, xMax) -
_imageIntegral.at<float>(yMin, xMax) -
_imageIntegral.at<float>(yMax, xMin));
}
_sampleFeatureValue.at<float>(i,j) = tempValue;
}
}
}
// Update the mean and variance of the gaussian classifier
//论文中是通过用高斯分布去描述样本的每一个harr特征的概率分布的。高斯分布就可以通过期望和方差
//两个参数来表征。然后通过正负样本的每一个harr特征高斯概率分布的对数比值，来构建分类器决策
//该box属于目标还是背景。这里计算新采集到的正负样本的特征的期望和标准差，并用其来更新分类器
void CompressiveTracker::classifierUpdate(Mat& _sampleFeatureValue, vector<float>& _mu, vector<float>& _sigma, float _learnRate)
{//后面默认的参数个数是50个50个和0.85
Scalar muTemp;
Scalar sigmaTemp;
for (int i=0; i<featureNum; i++)
{
meanStdDev(_sampleFeatureValue.row(i), muTemp, sigmaTemp);
_sigma[i] = (float)sqrt( _learnRate*_sigma[i]*_sigma[i] + (1.0f-_learnRate)*sigmaTemp.val[0]*sigmaTemp.val[0]
+ _learnRate*(1.0f-_learnRate)*(_mu[i]-muTemp.val[0])*(_mu[i]-muTemp.val[0])); // equation 6 in paper
_mu[i] = _mu[i]*_learnRate + (1.0f-_learnRate)*muTemp.val[0]; // equation 6 in paper
}
}
// Compute the ratio classifier
void CompressiveTracker::radioClassifier(vector<float>& _muPos, vector<float>& _sigmaPos, vector<float>& _muNeg, vector<float>& _sigmaNeg,
Mat& _sampleFeatureValue, float& _radioMax, int& _radioMaxIndex)
{
float sumRadio;
_radioMax = -FLT_MAX;
_radioMaxIndex = 0;
float pPos;
float pNeg;
int sampleBoxNum = _sampleFeatureValue.cols;
for (int j=0; j<sampleBoxNum; j++)
{
sumRadio = 0.0f;
for (int i=0; i<featureNum; i++)
{
pPos = exp( (_sampleFeatureValue.at<float>(i,j)-_muPos[i])*(_sampleFeatureValue.at<float>(i,j)-_muPos[i]) / -(2.0f*_sigmaPos[i]*_sigmaPos[i]+1e-30) ) / (_sigmaPos[i]+1e-30);
pNeg = exp( (_sampleFeatureValue.at<float>(i,j)-_muNeg[i])*(_sampleFeatureValue.at<float>(i,j)-_muNeg[i]) / -(2.0f*_sigmaNeg[i]*_sigmaNeg[i]+1e-30) ) / (_sigmaNeg[i]+1e-30);
sumRadio += log(pPos+1e-30) - log(pNeg+1e-30); // equation 4
}
if (_radioMax < sumRadio)
{
_radioMax = sumRadio;
_radioMaxIndex = j;
}
}
}
//传入第一帧和要跟踪的目标box(由文件读入或用户鼠标框选)，初始化处理
void CompressiveTracker::init(Mat& _frame, Rect& _objectBox)
{
// compute feature template
//计算box的harr特征模板，先存着
HaarFeature(_objectBox, featureNum);
//因为这是第一帧，目标box是由由文件读入或者用户鼠标框选的，是已知的，
//所以我们通过在这个目标box周围，采集正样本和负样本来初始化我们的分类器
// compute sample templates
sampleRect(_frame, _objectBox, rOuterPositive, 0, 1000000, samplePositiveBox);//rOuterPositive 默认是4
sampleRect(_frame, _objectBox, rSearchWindow*1.5, rOuterPositive+4.0, 100, sampleNegativeBox);//rSearchWindow是25
//计算积分图，用以快速的计算harr特征
integral(_frame, imageIntegral, CV_32F);
//通过上面的积分图，计算我们采样到的正负样本的box的harr特征
getFeatureValue(imageIntegral, samplePositiveBox, samplePositiveFeatureValue);
getFeatureValue(imageIntegral, sampleNegativeBox, sampleNegativeFeatureValue);
//通过上面的正负样本的特征来初始化分类器
classifierUpdate(samplePositiveFeatureValue, muPositive, sigmaPositive, learnRate);
classifierUpdate(sampleNegativeFeatureValue, muNegative, sigmaNegative, learnRate);
}
void CompressiveTracker::processFrame(Mat& _frame, Rect& _objectBox)
{
// predict
//第一次采样，半径为25，步长为4(跟CT算法不同地方，这里分了两次采样，将采样的数量减少)
sampleRect(_frame, _objectBox, rSearchWindow,detectBox,4);
integral(_frame, imageIntegral, CV_32F);
getFeatureValue(imageIntegral, detectBox, detectFeatureValue);
int radioMaxIndex;
float radioMax;
radioClassifier(muPositive, sigmaPositive, muNegative, sigmaNegative, detectFeatureValue, radioMax, radioMaxIndex);
_objectBox = detectBox[radioMaxIndex];
//第二次采样，半径为10，步长为1
sampleRect(_frame, _objectBox, 10,detectBox,1);
integral(_frame, imageIntegral, CV_32F);
getFeatureValue(imageIntegral, detectBox, detectFeatureValue);
radioClassifier(muPositive, sigmaPositive, muNegative, sigmaNegative, detectFeatureValue, radioMax, radioMaxIndex);
_objectBox = detectBox[radioMaxIndex];
// update
sampleRect(_frame, _objectBox, rOuterPositive, 0.0, 1000000, samplePositiveBox);
sampleRect(_frame, _objectBox, rSearchWindow*1.5, rOuterPositive+4.0, 100, sampleNegativeBox);
getFeatureValue(imageIntegral, samplePositiveBox, samplePositiveFeatureValue);
getFeatureValue(imageIntegral, sampleNegativeBox, sampleNegativeFeatureValue);
classifierUpdate(samplePositiveFeatureValue, muPositive, sigmaPositive, learnRate);
classifierUpdate(sampleNegativeFeatureValue, muNegative, sigmaNegative, learnRate);
}项目下载链接：
linux下：点击打开链接 linux下通过make编译
windows下：点击打开链接 openCV2.4.9 vs2012的工程
扫一扫
121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
