必威体育Betway必威体育官网
当前位置:首页 > IT技术

光流法+FAST特征点

时间:2019-06-12 12:44:11来源:IT技术作者:seo实验室小编阅读:86次「手机版」
 

光流法

转自http://blog.csdn.net/qianxin_dh/article/details/42810073

一.光流法回顾

光流作为飞行昆虫对外界光学信息感知,处理的方式,其概念在1950年有Gibson首次提出,80年代初期Horn和Schunck以及Lucas和Kanade做了奠基性工作,之后光流法被广泛研究,很多种方法被相继提出。1994年,Barron等对当时的有代表性光流法进行了详细的分类和评价,对光流法的发展起到了关键性作用。Barron按照理论基础和数学方法的区别把光流法分成五类:基于偏微分(梯度)的方法,基于特征匹配法的方法,基于能量的方法,基于相位的方法,其中最常用的方法为基于偏微分的方法和基于特征匹配的方法。2011年,S.Baker等研究发现大多数的光流法都是对数据项和平滑项的和的优化,并参考Barron-Fleet的分类法,根据数据项和平滑项及系数的不同取法分亮度约束法,变分法,一阶法,二阶法,空间约束法等等,并建立了Middlebury Flow数据库,包含图像序列,真实光流和对光流算法的评价。

根据光流计算的约束条件,可分为全局光流法和局部光流法,前者的代表是Horn & Schunck(HS)法及其衍生方法,后者的代表是Lucas & Kanade(LK)法及其衍生方法。使用全局光流法直接利用了整幅图像的稠密光流,免去了提取“good feature”的过程,但是由于计算量过大,影响了算法的实时性。此外,全局光流法的全局约束也会使误差在整幅图像上传播,影响光流估计准确性。相比之下,局部光流法可以在计算光流之前提取特征点,利用这些特征点的稀疏光流代表整幅图像的稠密光流,可以同时提高光流的准确性并减少计算时间。Chaos对使用光流进行视觉导航的8种系统进行了统计,LK法由于其计算的简便性及时间消耗少而最为常用。生物学家也指出果蝇也是靠特征点和光流进行导航。因此,特征点的选取对于稀疏光流的运动估计非常关键。

基于特征点的光流法只在第一帧提取特征点,然后计算特征点的光流,所以用于光流计算的特征点应该不仅可以代表图像信息,而且能够提高光流的准确性。传统的特征点是针对一副图像提取角点或纹理,如图像梯度的极值处以及Laplacian的零点,但它们可能是深度不连续点或是光滑表面上的亮度异常点,会导致光流计算不准确。SIFT或SURF特征点利用了高斯差分金字塔的局部极值点具有尺度不变性的特点,提取的特征点对图像信息具有很强的代表性。基于光流运动方程的Shi & Tomasi法提取的good feature,以包含两幅图像信息的局部邻域的矩阵的特征值为量度,易于利用光流进行跟踪,具有局部性和仿射不变形。

二.Fast特征点

 文章应该是《Machine Learning for high-speed corner detection》,FAST特征顾名思义,就是快,它快于现有其它角点的检测速度,在一些对实时性要求较高的条件下,可以考虑使用该特征。FAST特征是基于特征点周围的图像灰度值,检测候选特征点周围一圈的像素值,若该像素点圆形邻域圆周上有3/4的点和该像素点灰度值差足够大,则认为该像素点为一个特征点。如下入所示:

三.代码

       Fast特征和LK光流法相结合,实现对摄像头里运动物体的特征点跟踪。(配置:vs2008 + opencv2.3.1)

头文件:

[cpp] view plain copy print?

  1. #include <opencv2/highgui/highgui.hpp>  
  2. #include <opencv2/core/core.hpp>  
  3. #include <opencv2/imgproc/imgproc.hpp>  
  4. #include <opencv2/features2d/features2d.hpp>  
  5. #include <opencv2/video/tracking.hpp>  
  6.   
  7. class FeatureTracker  
  8. {  
  9. private:  
  10.     cv::Mat gray;  //当前灰度图像  
  11.     cv::Mat gray_prev; //之前灰度图像  
  12.     //两幅图像间跟踪的特征点 0->1  
  13.     std::vector<cv::Point2f>points[2];  
  14.     //跟踪的点初始位置  
  15.     std::vector<cv::Point2f>initial;  
  16.     std::vector<cv::Point2f>features;       //检测到的特征  
  17.     std::vector<uchar> status;      //检测到的特征的状态  
  18.     std::vector<float> err;           //跟踪过程中的错误  
  19. public:  
  20.     FeatureTracker();  
  21.     ~FeatureTracker();  
  22.   
  23.     void process(cv::Mat& frame ,cv::Mat& output);  
  24.     void detectFeaturePoints(cv::Mat& frame);  
  25.     bool addNewPoints();  
  26.     bool acceptTrackedPoint(int i);  
  27.     void handleTrackedPoints(cv::Mat& frame,cv::Mat& output);  
  28. };  

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/video/tracking.hpp>

class FeatureTracker
{
private:
    cv::Mat gray;  //当前灰度图像
    cv::Mat gray_prev; //之前灰度图像
    //两幅图像间跟踪的特征点 0->1
    std::vector<cv::Point2f>points[2];
    //跟踪的点初始位置
    std::vector<cv::Point2f>initial;
    std::vector<cv::Point2f>features;       //检测到的特征
    std::vector<uchar> status;      //检测到的特征的状态
    std::vector<float> err;           //跟踪过程中的错误
public:
	FeatureTracker();
	~FeatureTracker();

	void process(cv::Mat& frame ,cv::Mat& output);
	void detectFeaturePoints(cv::Mat& frame);
	bool addNewPoints();
	bool acceptTrackedPoint(int i);
	void handleTrackedPoints(cv::Mat& frame,cv::Mat& output);
};

函数实现:

[cpp] view plain copy print?

  1. #include "FeatureTracker.h"  
  2.   
  3. FeatureTracker:: FeatureTracker()  
  4. {  
  5. }  
  6.   
  7. FeatureTracker:: ~FeatureTracker()  
  8. {  
  9.   
  10. }  
  11.   
  12. void FeatureTracker::detectFeaturePoints(cv::Mat& frame)  
  13. {  
  14.     std::vector<cv::KeyPoint> keyPoints;  
  15.   
  16.     cv::FastFeatureDetector fast(10);  //检测阈值  
  17.     fast.detect(frame,keyPoints);  
  18.     features.clear();  
  19.   
  20.     for (int i=0;i<keyPoints.size();i++)  
  21.     {  
  22.         features.push_back(cv::Point2f(keyPoints[i].pt.x,keyPoints[i].pt.y));  
  23.     }  
  24. }  
  25.   
  26. bool FeatureTracker::addNewPoints()  
  27. {  
  28.     return points[0].size()<=10;  
  29. }  
  30.   
  31. bool FeatureTracker::acceptTrackedPoint(int i)  
  32. {  
  33.     return status[i] &&  
  34.         //如果移动  
  35.         (abs(points[0][i].x - points[1][i].x)+  
  36.         (abs(points[0][i].y - points[1][i].y))>2);  
  37. }  
  38.   
  39. void FeatureTracker::handleTrackedPoints(cv::Mat& frame,cv::Mat& output)  
  40. {  
  41.     for(int i=0;i<points[1].size();i++){  
  42.         //绘制直线和圆  
  43.         cv::line(output,  
  44.                     initial[i],                //初始位置  
  45.                     points[1][i],               //新位置  
  46.                     cv::Scalar(255,0,0));  
  47.         cv::circle(output,points[1][i],3,cv::Scalar(0,0,255),-1);  
  48.     }  
  49. }  
  50.   
  51. void FeatureTracker::process(cv::Mat& frame,cv::Mat& output)  
  52. {  
  53.     cv::cvtColor(frame,gray,CV_BGR2GRAY);  
  54.     frame.copyTo(output);  
  55.   
  56.     if (addNewPoints())  
  57.     {  
  58.         detectFeaturePoints(frame);  
  59.         points[0].insert(points[0].end(),features.begin(),features.end());  
  60.         initial.insert(initial.end(),features.begin(),features.end());  
  61.     }  
  62.   
  63.     if (gray_prev.empty())  
  64.         gray.copyTo(gray_prev);  
  65.   
  66.     //lk法跟踪特征点  
  67.     cv::calcOpticalFlowPyrLK(  
  68.         gray_prev,gray,        //两幅连续图像  
  69.         points[0],                //图1中的输入点坐标  
  70.         points[1],                //</span><span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-size:12px;">图2中的输入点坐标</span></span><span style="font-size:14px;">  
  71.         status,                    //跟踪成功  
  72.         err);                     //跟踪错误  
  73.   
  74.     //遍历所有跟踪的点进行筛选  
  75.     int k=0;  
  76.     for(int i=0;i<points[1].size();i++){  
  77.         //是否需要保留该点  
  78.         if (acceptTrackedPoint(i))  
  79.         {  
  80.             //进行保留  
  81.             initial[k] = initial[i];  
  82.             points[1][k++] = points[1][i];  
  83.         }  
  84.     }  
  85.       
  86.     //去除不成功的点  
  87.     points[1].resize(k);  
  88.     initial.resize(k);  
  89.   
  90.     //处理接受的跟踪点  
  91.     handleTrackedPoints(frame,output);  
  92.   
  93.     //当前帧的点和图像变为前一帧的点和图像  
  94.     std::swap(points[1],points[0]);  
  95.     cv::swap(gray_prev,gray);  
  96. }  

#include "FeatureTracker.h"

FeatureTracker:: FeatureTracker()
{
}

FeatureTracker:: ~FeatureTracker()
{

}

void FeatureTracker::detectFeaturePoints(cv::Mat& frame)
{
	std::vector<cv::KeyPoint> keyPoints;

	cv::FastFeatureDetector fast(10);  //检测阈值
	fast.detect(frame,keyPoints);
	features.clear();

	for (int i=0;i<keyPoints.size();i++)
	{
		features.push_back(cv::Point2f(keyPoints[i].pt.x,keyPoints[i].pt.y));
	}
}

bool FeatureTracker::addNewPoints()
{
	return points[0].size()<=10;
}

bool FeatureTracker::acceptTrackedPoint(int i)
{
	return status[i] &&
		//如果移动
		(abs(points[0][i].x - points[1][i].x)+
		(abs(points[0][i].y - points[1][i].y))>2);
}

void FeatureTracker::handleTrackedPoints(cv::Mat& frame,cv::Mat& output)
{
	for(int i=0;i<points[1].size();i++){
		//绘制直线和圆
		cv::line(output,
			        initial[i],                //初始位置
					points[1][i],               //新位置
					cv::Scalar(255,0,0));
		cv::circle(output,points[1][i],3,cv::Scalar(0,0,255),-1);
	}
}

void FeatureTracker::process(cv::Mat& frame,cv::Mat& output)
{
	cv::cvtColor(frame,gray,CV_BGR2GRAY);
	frame.copyTo(output);

	if (addNewPoints())
	{
		detectFeaturePoints(frame);
		points[0].insert(points[0].end(),features.begin(),features.end());
		initial.insert(initial.end(),features.begin(),features.end());
	}

	if (gray_prev.empty())
		gray.copyTo(gray_prev);

	//lk法跟踪特征点
	cv::calcOpticalFlowPyrLK(
		gray_prev,gray,        //两幅连续图像
		points[0],                //图1中的输入点坐标
		points[1],                //</span><span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-size:12px;">图2中的输入点坐标</span></span><span style="font-size:14px;">
		status,                    //跟踪成功
		err);                     //跟踪错误

	//遍历所有跟踪的点进行筛选
	int k=0;
	for(int i=0;i<points[1].size();i++){
		//是否需要保留该点
		if (acceptTrackedPoint(i))
		{
			//进行保留
			initial[k] = initial[i];
			points[1][k++] = points[1][i];
		}
	}
	
	//去除不成功的点
	points[1].resize(k);
	initial.resize(k);

	//处理接受的跟踪点
	handleTrackedPoints(frame,output);

	//当前帧的点和图像变为前一帧的点和图像
	std::swap(points[1],points[0]);
	cv::swap(gray_prev,gray);
}

主函数:

[cpp] view plain copy print?

  1. // OpticlaTracking.cpp   
  2. //created by qianxin_dh   
  3.   
  4. #include "stdafx.h"  
  5. #include "FeatureTracker.h"  
  6.   
  7. using namespace cv ;  
  8. using namespace std;  
  9.   
  10.   
  11. const char* winname="LK  Tracking";  
  12.   
  13. int main()  
  14. {  
  15.     VideoCapture capture;  
  16.     capture.open(1);  
  17.   
  18.     namedWindow(winname,CV_WINDOW_AUTOSIZE);  
  19.   
  20.     Mat frame;  
  21.     Mat output;  
  22.     FeatureTracker lk;  
  23.   
  24.     while (capture>>frame)  
  25.     {  
  26.         lk.process(frame,output);  
  27.         imshow(winname, output);  
  28.         char c=waitKey(33);  
  29.         if (c==27) {  
  30.             break;  
  31.         }  
  32.     }  
  33.     return 0;  
  34. }  

相关阅读

计算机视觉--光流法(optical flow)简介

光流法理论背景 1.什么是光流 光流(optical flow)是空间运动物体在观察成像平面上的像素运动的瞬时速度。 光流法是利用图像序列中

分享到:

栏目导航

推荐阅读

热门阅读