CT跟踪

最新推荐文章于 2024-03-18 20:12:46 发布
最新推荐文章于 2024-03-18 20:12:46 发布
阅读量4.5k 收藏 5
点赞数 1
分类专栏： 计算机视觉 图像处理 文章标签： 计算机视觉 目标跟踪

 

感谢香港理工大学的Kaihua Zhang，这是他即将在ECCV 2012上出现的paper：Real-time Compressive Tracking。 这里是他的介绍：

一种简单高效地基于压缩感知的跟踪算法。首先利用符合压缩感知RIP条件的随机感知矩对多尺度图像特征进行降维，然后在降维后的特征上采用简单的朴素贝叶斯分类器进行分类。该跟踪算法非常简单，但是实验结果很鲁棒，速度大概能到达40帧/秒。具体原理分析可参照相关文章。

链接

免积分下载代码：http://download.csdn.net/detail/sangni007/5297374

1.Description: compute Haar features    (templates)

void CompressiveTracker::HaarFeature(Rect& _objectBox, int _numFeature)

在rect内取_numFeature维特征，（rect的宽高与_objectBox一样，与_objectBox.x _objectBox.y无关）
每一维Feature都用若干Rect表示，存在vector<vector<Rect>> feature (_numFeature, vector<Rect>())中,

相应权重 vector<vector<float>>featuresWeight(_numFeature, vector<float>())

 

2.Description: compute the coordinate of positive and negative sample image templates

void CompressiveTracker::sampleRect(Mat& _image, Rect& _objectBox, float _rInner, 
	float _rOuter, int _maxSampleNum, vector<Rect>& _sampleBox)

随机洒出若干Rect，记录坐标Rect(x,y)

保证sampleRect的(x,y)到_objectBox的(x,y)的dist满足:_rOuter*_rOuter<dist<_rInner*_rInner

取样本：1：正：dist小；2：负：dist大：

存入_sampleBox

void CompressiveTracker::sampleRect(Mat& _image, Rect& _objectBox, float _srw, vector<Rect>& _sampleBox)

这个sampleRect的重载函数是用来，预测位置的

只要满足：dist<_rInner*_rInner

初始化第一帧不运行这个sampleRect的重载函数，只在跟踪时，首先运行它再更新正负样本函数；

 

3.Compute the features of samples

void CompressiveTracker::getFeatureValue(Mat& _imageIntegral, vector<Rect>& _sampleBox, Mat& _sampleFeatureValue)

计算相应Rect的积分图像的Sum值，存入Mat& _sampleFeatureValue（即特征值）

 

4.// Update the mean and variance of the gaussian classifier

void CompressiveTracker::classifierUpdate(Mat& _sampleFeatureValue, vector<float>& _mu, vector<float>& _sigma, float _learnRate)

计算每个上一步积分矩阵Mat& _sampleFeatureValue中每一SampleBox的期望和标准差
并Update（具体计算采用文章的公式[6]）

 

5.// 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)

利用朴素贝叶斯分类(gaussian model)文章公式[4]

计算所有sample的贝叶斯值，用radioMax存储最大值，即为预测位置

 

Discussion

这篇文章最成功的地方在于简单高效，绝对可以达到实时跟踪的效果，之前实验的粒子滤波就显得太慢了；但是有很多问题需要改进。（个人观点和网友总结，欢迎拍砖~）

1.尺度问题，只能对单尺度操作，当对象远离时跟踪框依然大小不变；

2.关于压缩感知，可以改进，比如选择features pool 像随机森林一样选择最优特征；

3.偏向当前新样本，所以很容易就遗忘以前学习过的样本，一旦偏离，会越偏越远；

4.我也是刚研究tracking by detection不久，拜读了compressive tracking，感觉很有新意，用这么简洁的方法就能实现较好的效果，这篇论文的实验部分很像mil tracking，mil的弱分类器也是假设使用高斯分布，但是我实验的结果是 haar like 特征并不是很好的服从高斯分布，尤其是negative sample，所以在物体的表征变化很大的时候，这种representation不能很好的捕捉到，另外里面有个学习参数 lambda，这个参数的设置也是一个经验值，据我的经验，一般是偏向当前新样本，所以很容易就遗忘以前学习过的样本，TLD的随机森林fern是记录正负样本个数来计算posterior，这种方式在long time tracking比这个要好，另外TLD在每个细节上做得很好，它的更新模型也是有动态系统的理论支持。以上是个人拙见，希望能多交流。——老熊

5.如果在一些跟踪算法上面加些trick，也是可以做 long time tracking的。TLD 的trick就是用了第一帧的信息，其实这个信息很多时候是不太好的。并且这种trick多年前就有人用过了，不是TLD新创的。另外 TLD 的PAMI文章没有说这个trick，CVPR10文章说了。CT这个方法简单，它的侧重点不是说拼什么跟踪效果，主要是在理论方面说明一下问题——zhkhua

//---------------------------------------------------
class CompressiveTracker
{
public:
	CompressiveTracker(void);
	~CompressiveTracker(void);

private:
	int featureMinNumRect;
	int featureMaxNumRect;
	int featureNum;
	vector<vector<Rect>> features;
	vector<vector<float>> featuresWeight;
	int rOuterPositive;
	vector<Rect> samplePositiveBox;
	vector<Rect> sampleNegativeBox;
	int rSearchWindow;
	Mat imageIntegral;
	Mat samplePositiveFeatureValue;
	Mat sampleNegativeFeatureValue;
	vector<float> muPositive;
	vector<float> sigmaPositive;
	vector<float> muNegative;
	vector<float> sigmaNegative;
	float learnRate;
	vector<Rect> detectBox;
	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);
	void sampleRect(Mat& _image, Rect& _objectBox, float _srw, vector<Rect>& _sampleBox);
	void getFeatureValue(Mat& _imageIntegral, vector<Rect>& _sampleBox, Mat& _sampleFeatureValue);
	void classifierUpdate(Mat& _sampleFeatureValue, vector<float>& _mu, vector<float>& _sigma, float _learnRate);
	void radioClassifier(vector<float>& _muPos, vector<float>& _sigmaPos, vector<float>& _muNeg, vector<float>& _sigmaNeg,
						Mat& _sampleFeatureValue, float& _radioMax, int& _radioMaxIndex);
public:
	void processFrame(Mat& _frame, Rect& _objectBox);
	void init(Mat& _frame, Rect& _objectBox);
};

 

 

#include "CompressiveTracker.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
	rSearchWindow = 25; // size of search window
	muPositive = vector<float>(featureNum, 0.0f);
	muNegative = vector<float>(featureNum, 0.0f);
	sigmaPositive = vector<float>(featureNum, 1.0f);
	sigmaNegative = vector<float>(featureNum, 1.0f);
	learnRate = 0.85f;	// Learning rate parameter
}

CompressiveTracker::~CompressiveTracker(void)
{
}


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.
*/
{
	features = vector<vector<Rect>>(_numFeature, vector<Rect>());
	featuresWeight = vector<vector<float>>(_numFeature, vector<float>());
	
	int numRect;
	Rect rectTemp;
	float weightTemp;
      
	for (int i=0; i<_numFeature; i++)
	{
		//每一个特征生成一个平均分布的随机数, 这个特征用几个Rect表示;
		numRect = cvFloor(rng.uniform((double)featureMinNumRect, (double)featureMaxNumRect));
		
		for (int j=0; j<numRect; j++)
		{
			//在Rcet(x,y,w,h)内画随机rectTemp,事实上，只用到了_objectBox的w和h,原则上在rect(0,0,w,h)内均匀分布;
			rectTemp.x = cvFloor(rng.uniform(0.0, (double)(_objectBox.width - 3)));
			rectTemp.y = cvFloor(rng.uniform(0.0, (double)(_objectBox.height - 3)));
			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);

			weightTemp = (float)pow(-1.0, cvFloor(rng.uniform(0.0, 2.0))) / sqrt(float(numRect));
			featuresWeight[i].push_back(weightTemp);
           
		}
	}
}


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;//4*4
	float outradsq = _rOuter*_rOuter;//0*0

  	
	int dist;

	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++ ){
			//保证sampleRect的(x,y)到_objectBox的(x,y)的dist满足:_rOuter*_rOuter<dist<_rInner*_rInner
			dist = (_objectBox.y-r)*(_objectBox.y-r) + (_objectBox.x-c)*(_objectBox.x-c);
			
			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);
		
}

void CompressiveTracker::sampleRect(Mat& _image, Rect& _objectBox, float _srw, vector<Rect>& _sampleBox)
/* 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

	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);

			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
void CompressiveTracker::getFeatureValue(Mat& _imageIntegral, vector<Rect>& _sampleBox, Mat& _sampleFeatureValue)
{
	int sampleBoxSize = _sampleBox.size();
	_sampleFeatureValue.create(featureNum, sampleBoxSize, CV_32F);
	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++)
			{
				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) +      //计算指定区域的积分图像的sum值;
					_imageIntegral.at<float>(yMax, xMax) -
					_imageIntegral.at<float>(yMin, xMax) -
					_imageIntegral.at<float>(yMax, xMin));
			}
			_sampleFeatureValue.at<float>(i,j) = tempValue; //计算指定区域的积分图像的sum值，作为特征;
		}
	}
}

// Update the mean and variance of the gaussian classifier
void CompressiveTracker::classifierUpdate(Mat& _sampleFeatureValue, vector<float>& _mu, vector<float>& _sigma, float _learnRate)
{
	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;
		}
	}
}
void CompressiveTracker::init(Mat& _frame, Rect& _objectBox)
{
	// compute feature template
	HaarFeature(_objectBox, featureNum);

	// compute sample templates
	sampleRect(_frame, _objectBox, rOuterPositive, 0, 1000000, samplePositiveBox);
	sampleRect(_frame, _objectBox, rSearchWindow*1.5, rOuterPositive+4.0, 100, sampleNegativeBox);

	integral(_frame, imageIntegral, CV_32F);//计算积分图像;

	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
	sampleRect(_frame, _objectBox, rSearchWindow,detectBox);
	integral(_frame, imageIntegral, CV_32F);
	getFeatureValue(imageIntegral, detectBox, detectFeatureValue);
	int radioMaxIndex;
	float radioMax;
	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);
}
西电之梦
关注
专栏目录
Compressive Tracking——CT跟踪
小熊不去实验室
10-26 1万+
感谢香港理工大学的Kaihua Zhang，这是他即将在ECCV 2012上出现的paper：Real-time Compressive Tracking。 这里是他的介绍： 一种简单高效地基于压缩感知的跟踪算法。首先利用符合压缩感知RIP条件的随机感知矩对多尺度图像特征进行降维，然后在降维后的特征上采用简单的朴素贝叶斯分类器进行分类。该跟踪算法非常简单，但是实验结果很鲁棒，速度大概能到达4
基于压缩的实时目标追踪（CT）
manniMagic的博客
06-26 1488
ＣＴ算法的学习－－－－这是本人第一篇博客，是基于各种大神的基础上写的，若有雷同或相似之处，还望见谅，因为有时候看大神们的博客还是有些疑问，所以这里面包含了一些我自己的或综合大神们的想法，大家一起进步~参考的博客论文会附在后面~有疑问的可以留言讨论！
CT模型机动目标圆周运动跟踪
06-28
针对机动目标跟踪的CT（联动式转弯运动）模型研究。实现了MATLAB仿真，（出图）。已给系统方差噪声方差Q、R，本人论文中已应用。
快速压缩跟踪（fast compressive tracking）（CT）算法实践
dx0014的博客
07-22 474
CT算法详细解析可以参考：快速压缩跟踪（fast compressive tracking）（CT）算法剖析 论文源码在作者主页上下载，我测试了一下，主要是比较一下各个算法，看如何往嵌入式上移植。在这里插入代码片 int main(int argc, char * argv[]) { CompressiveTracker ct; Mat grayImg; VideoCapture cap; char c; cap.open("E:\\dataSet\\xinpingtai_video\\xidian.mp.
CT跟踪代码下载
03-04
CT跟踪代码下载
ct程序备份.rar_CT跟踪_ct_压缩感知_压缩感知算法 用于运动目标的跟踪_目标跟踪
07-15
键词： 压缩感知算法 用于运动目标的跟踪
摄像头CT跟踪算法
03-03
**摄像头CT跟踪算法详解** 摄像头物体跟踪是计算机视觉领域中的一个重要课题，广泛应用于视频监控、自动驾驶、人机交互等多个场景。CT（Continued Targeting）算法是一种常用的物体跟踪方法，它通过连续的目标定位...
trackers.rar_csk ct 跟踪_eikonal equation_trackers_视觉跟踪_跟踪
07-15
各种视觉跟踪算法总结，包括matlab和c,c++代码
win7 64位 VS2012+OpenCV2.4.9 CT跟踪C++程序项目
10-16
根据香港理工大学的Kaihua Zhang的paper：Real-timeCompressive Tracking，压缩跟踪Compressive TrackingC++程序，在win7 64位 VS2012+OpenCV2.4.9 环境下完美运行，摄像头跟踪。
容积卡尔曼滤波CKF——机动目标跟踪 匀速转弯模型CT
05-17
容积卡尔曼滤波CKF 匀速圆周运动，匀速转弯运动CT 代码肯定能运行且有结果，可开发性强， 如果有问题可联系WX:ZB823618313 算法：标准的容积卡尔曼滤波 仿真场景：二维目标，CT模型 传感器类型：主动雷达 MATLAB仿真仿真实现; 仿真结果：二维跟踪轨迹，各维度跟踪轨迹，跟踪误差误差，各个维度跟踪误差，位置跟踪误差，速度跟踪误差）。 仿真参数设置：见下面链接的里面又给 仿真结果可以先看下面链接博客， 对应的仿真模型及参数设置见扩展卡尔曼滤波 对应的理论分析和参数设置，见博文《容积卡尔曼滤波UKF—目标跟踪中的应用(仿真部分)》https://zhangdonglin.blog.csdn.net/article/details/115741172 《匀速圆周运动-目标运动模型/机动目标跟踪》 https://zhangdonglin.blog.csdn.net/article/details/124461832?spm=1001.2014.3001.5502
匹配追踪算法C语言实现(omp,cosamp,subspace-pursuit)
11-17
三种匹配追踪算法的C语言实现。 omp算法、cosamp算法、subspcae-pursuit算法。
Matlab仿真CV、CA、CT三种运动模型的轨迹
12-27
通过Matlab产生匀速直线运动、匀加速直线运动、匀速转弯运动三种运动轨迹的点迹，并加入了杂波。相关参数可自行调整。
压缩感知跟踪（二）
记录计算机应用的点点滴滴！！！！！
04-10 2016
这次准备在这里贴上
Real-Time Compressive Tracking(CT) 札记
独立圜中
10-28 3248
Real-Time compressive Tracking, Kaihua Zhang, ECCV2012 这篇论文由香港理工大学张开华发表在2012年的ECCV之上，论文附有数据对比及代码。 cvchina:    http://www.cvchina.info/2012/07/31/real-time-compressive-tracking/comment-page-1/#commen
基于CV模型卡尔曼滤波、CT模型卡尔曼滤波、IMM模型滤波的目标跟踪
最新发布
rUdvJYP的博客
03-18 693
本文介绍了基于CV模型卡尔曼滤波、CT模型卡尔曼滤波和IMM模型滤波的目标跟踪方法，并对其原理和实现进行了详细讲解。与CV模型不同，CT模型卡尔曼滤波考虑了目标运动模型的不确定性，通过引入额外的状态变量和状态转移方程来描述目标的运动特性。在目标跟踪过程中，CV模型卡尔曼滤波能够准确地预测目标的运动轨迹，并以此为基础进行目标的跟踪与定位。在实际应用中，基于CV模型卡尔曼滤波、CT模型卡尔曼滤波和IMM模型滤波的目标跟踪方法已经被广泛应用于物体检测、目标识别、行人跟踪等领域。程序已调通，可直接运行。
快速压缩跟踪（fast compressive tracking）（CT）算法剖析
autocyz
03-20 8168
Fast Compressive Tracking （快速压缩跟踪） 虽然目前有很多种的跟踪算法，但是由于姿态的变化、光照的变化、障碍物等原因的存在，导致很多算法的鲁棒性不好。 目前比较主流的跟踪算法有两种，generative  tracking algorithms（生成跟踪算法）和discriminative algorithms（判别跟踪算法）。 生成跟踪算法，顾名思义边生成边跟踪
卡尔曼滤波（3）-------目标跟踪之协同转弯或者坐标转弯模型（CT model）
梦 醉了谁的博客
04-09 7991
卡尔曼滤波（4）-------协同转弯或者坐标转弯模型（CT model）基本原理状态方程测量方程![在这里插入图片描述](https://img-blog.csdnimg.cn/20210409200146275.png)源代码产生目标的运动轨迹kalman 滤波函数仿真结果 基本原理 状态方程       式中，状态矢量Xn为5*1的矢量。分别为X方向的位置，X方向的速度，Y方向的位置，Y方向的速度，转弯率。状态转移矩阵F为   
目标跟踪系列一：压缩跟踪（compressive tracking）
眼观
11-17 4055
入坑满两年，决定开始写关于目标跟踪的博客了，欢迎批评指正。 主要关注的是single-object, short-term, model-free visual tracking problem. 即单目标，短时，无模型目标跟踪问题。 一开始是因为要做本科毕设，那时候毫无头绪，也不知道该用什么方法，对这个领域一无所知。就在网上随便看，看到了当时很有名的一篇文章，叫压缩跟踪（CT）：
压缩感知在目标跟踪中的应用——实时压缩跟踪(CT)算法解析
本文将深入解析张开华老师在2012年ECCV（欧洲计算机视觉会议）上提出的压缩跟踪（Compressive Tracking, CT）算法，这是一种高效且具有实时性的目标跟踪技术。 CT算法的核心思想是融合压缩感知（Compressive ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值