概括：运动物体检测是应用差分法实现，运动物体追踪是利用基于时间序列预测模型实现。

##运动物体检测

常用的检测方法为背景减除法和帧差法，这两种方法原理基本上都是图片相减。两种方法各有优缺点：

帧差法适用于更多场景，如：摄像头移动以及多目标运动场景，缺点就是检测的人物之间容易出现空洞。

背景减除法，适用场景局限，只适用于第一帧是背景图的视频，但检测人物没有空洞。

以上这两种方法均不能很好的处理光照过强以及阴影的运动物体视频。

物体检测方法还有许多，有基于图像相减的三帧差法，还有对于电脑性能要求较高的光流法。
效果
背景减除法：（人物没有出现空洞现象，但对于光照过强区域效果不好）


帧差法：(人物出现空洞，对下一步处理造成影响)

运动物体追踪
之前一直对每一帧检测的运动物体进行标志就以为达到了追踪，但实时检测标志并不是追踪，若在多目标运动物体中没有做到区分不同的目标，就不算是追踪。
追踪思路


1.对每一帧进行运动目标检测

2.对检测到的物体进行判断，判断是否是存在的运动目标，是则添加运动轨迹，不是则当作新的目标。

3.画出运动轨迹等

如何判断当前已检测到的目标是否是已经存在的运动目标？

这里我刚开始选取的是简单的轮廓面积已经轮廓外接矩形等特征，因为轮廓获得的不稳定，显然效果不是很好。这里采用的是预测模型，在上一篇鼠标运动的预测中。简单来说就是用检测到的运动目标与预测的位置进行比较，若在一定误差内就算追踪成功。
运动视频下载
网上有很多的视频库，我下载视频库的链接
代码
头文件
#pragma once
#ifndef TrackObject
#define TrackObject
#include<opencv2\opencv.hpp>
#include<iostream>
using namespace std;
using namespace cv;
class Blob {
public:
	vector<Point>_contour;
	vector<Point>centerPos;
	Point preditNextCenter;
	Point currentCenter;//first
	Rect currentRect;//first
	double currentArea;//first
	double currentRate;//first
	//bool isStillBeTracked;//是否还在被跟踪
	//int FramesWithoutMatched;
	Blob(vector<Point>con);
	void Predit();
	
};
#endif // !TrackObject


Main
//问题：由于光照的影响很不稳定（对于寻找的轮廓），光照补偿（解决阴影）和去除光照



#include "ObjectTrack.h"
double DistanceBetwwenPoint(Point p1,Point p2)
{
	int x =abs(p1.x - p2.x);
	int y = abs(p1.y - p2.y);
	double res = sqrt(pow(x, 2)) + sqrt(pow(y, 2));
	//cout << "距离为：" << res << endl;
	return res;
	//sqrt(里面参数接受为double型)
}
vector<Blob>Blobs;
int main()
{
	VideoCapture  cap("Walk1.mpeg");//这个视频有轻微抖动现象,利用高斯滤波
	//int framenum = cap.get(CAP_PROP_POS_FRAMES);
	
	if (!cap.isOpened()) { cout << "读取视频错误" << endl; return 0; }
	Mat cur, pre;
	cap >> pre;
	GaussianBlur(pre,pre,Size(3,3),0.8);
	cvtColor(pre,pre,CV_BGR2GRAY);

	while (1)
	{
		cap >> cur;

		if (cur.empty()) { break; }//作用相当于判断是否到达视频最后一帧

		GaussianBlur(cur,cur,Size(3,3),0.8);
		cvtColor(cur,cur,CV_BGR2GRAY);

		/*具体实现步骤*/
		//1.背景减除法检测运动物体
		Mat df;//difference frame
		absdiff(cur, pre,df );
		threshold(df,df,70,255,CV_THRESH_BINARY);
		vector<vector<Point>>contours;//找到的轮廓均存在contours
		findContours(df,contours,CV_RETR_EXTERNAL,CV_CHAIN_APPROX_SIMPLE);

		vector<Blob>possibleBlobs;
		
		for (size_t i = 0; i < contours.size(); i++)
		{//筛选出可能的目标对象，根据视频中的背景设置筛选条件
			Blob tem(contours[i]);
			//if (tem.currentArea > 60&&tem.currentRate<1.0) {
			if (tem.currentArea > 100) {
				possibleBlobs.push_back(tem);
				
			}
		}
		cout << "每次检测出来的possible个数" << possibleBlobs.size() << endl;

		/*
		2.跟踪队列为空则直接把possibleBlob全部放入跟踪队列
		其他则进行判断，判断是已有的跟踪对象，则把中心点推入已有的跟踪对象，
		若是新的跟踪对象直接放入跟踪队列里
		*/
		if (Blobs.size()==0) {//跟踪队列为空
			for (auto &c : possibleBlobs)
			{
				Blobs.push_back(c);
			}
			cout << "目标队列为空时第一次加入目标队列追踪的个数"<<Blobs.size() << endl;
		}
		else {
			for (auto &tem : Blobs)
			{
				tem.Predit();
			}
			/*
			3.选作什么作为不同的跟踪目标之间的区分呢
			首先尝试过直接利用已找到的轮廓作为区分，例如轮廓的面积和轮廓外界矩形特征等，但是区分效果很不好
			这里利用的是鼠标运动检测中的预测目标点，若预测的目标点小于规定值则认为是同一个目标。

			*/
			for (auto &tem : possibleBlobs)
			{
				int flag = false;
				for (auto &target : Blobs)
				{
					if (DistanceBetwwenPoint(tem.currentCenter, target.preditNextCenter) <50.0 )
					{
						target.centerPos.push_back(tem.currentCenter);
						flag = true;
						break;
					}
				}

				if (flag == false)Blobs.push_back(tem);//作为新目标被跟踪
			}
		}
		/*for (auto &tem : possibleBlobs)
		{//不正确的写法
		int flag = false;//匹配标志
		for (auto &exist : Blobs)
		{
		if (abs(tem.currentArea - exist.currentArea) <= scale && abs(tem.currentRate - exist.currentRate) <= scale)
		{
		exist.centerPos.push_back(tem.currentCenter);
		flag = true;
		break;
		}
		}
		if (flag == false)Blobs.push_back(tem);
		}*/

		
		
		cout <<"追踪对象有:"<< Blobs.size() << endl;
		for (int i = 0; i < Blobs.size(); i++)
		{
			int size = Blobs[i].centerPos.size();
			cout << "第" << i << "个追踪对象内的centerPos点数:" << size << endl;
			
			for (int k= 0;k < size; k++)
			{
				circle(cur, Blobs[i].centerPos[k],1,Scalar(255,0,0),1,8);
			}
			
			if (size == 1)
			{
				rectangle(cur, Blobs[i].currentRect, Scalar(255, 0, 0), 1, 8);
			}
			else
			{
				Point p1;
				p1.x = Blobs[i].centerPos[size - 1].x - Blobs[i].currentRect.width*0.5;
				p1.y= Blobs[i].centerPos[size - 1].y - Blobs[i].currentRect.height*0.5;
				Rect rect(p1.x,p1.y,Blobs[i].currentRect.width,Blobs[i].currentRect.height);
				rectangle(cur, rect, Scalar(255, 0, 0), 1, 8);
			}
			
		}
		//drawContours(cur,contours,-1,Scalar(255,0,0),1,8);
		imshow("df",df);
		imshow("cur",cur);
		//pre=cur;//加上这一句就是帧差法
		if (waitKey(100) == 27)break;//或者当前的帧数是最后一帧,采用判断当前读取的帧数是否非空即可
	}
	cap.release();
	destroyAllWindows();
	system("pause");
	return 0;
}




其中cpp文件里有初始化和预测函数，预测方法与鼠标移动预测类似，所以就不贴了。
效果

第一部分：C++与OpenCV
第二部分：Python3与OpenCV
C++实现:
/**************************************************
* 背景建模，运动物体检测
*
**************************************************/
/***********************************************************************
* OpenCV example
***********************************************************************/
#include 
#include 
#include 
#include 
#include 
using namespace std;
using namespace cv;
int main( int argc, char** argv )
{
//声明IplImage指针
IplImage* pFrame = NULL;
IplImage* pFrImg = NULL;
IplImage* pBkImg = NULL;
CvMat* pFrameMat = NULL;
CvMat* pFrMat = NULL;
CvMat* pBkMat = NULL;
CvCapture* pCapture = NULL;
int nFrmNum = 0;
//创建窗口
cvNamedWindow("video", 1);
cvNamedWindow("background",1);
cvNamedWindow("foreground",1);
//使窗口有序排列
cvMoveWindow("video", 30, 0);
cvMoveWindow("background", 360, 0);
cvMoveWindow("foreground", 690, 0);
if( argc > 2 )
{
fprintf(stderr, "Usage: bkgrd [video_file_name]\n");
return -1;
}
//打开摄像头
if (argc ==1)
if( !(pCapture = cvCaptureFromCAM(-1)))
{
fprintf(stderr, "Can not open camera.\n");
return -2;
}
//打开视频文件
if(argc == 2)
if( !(pCapture = cvCaptureFromFile(argv[1])))
{
fprintf(stderr, "Can not open video file %s\n", argv[1]);
return -2;
}
//逐帧读取视频
while(pFrame = cvQueryFrame( pCapture ))
{
nFrmNum++;
//如果是第一帧，需要申请内存，并初始化
if(nFrmNum == 1)
{
pBkImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
pBkMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrameMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//转化成单通道图像再处理
cvCvtColor(pFrame, pBkImg, CV_BGR2GRAY);
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
cvConvert(pFrImg, pFrMat);
cvConvert(pFrImg, pBkMat);
}
else
{
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
//高斯滤波先，以平滑图像
//cvSmooth(pFrameMat, pFrameMat, CV_GAUSSIAN, 3, 0, 0);
//当前帧跟背景图相减
cvAbsDiff(pFrameMat, pBkMat, pFrMat);
//二值化前景图
cvThreshold(pFrMat, pFrImg, 60, 255.0, CV_THRESH_BINARY);
//进行形态学滤波，去掉噪音
//cvErode(pFrImg, pFrImg, 0, 1);
//cvDilate(pFrImg, pFrImg, 0, 1);
//更新背景
cvRunningAvg(pFrameMat, pBkMat, 0.003, 0);
//将背景转化为图像格式，用以显示
cvConvert(pBkMat, pBkImg);
//显示图像
cvShowImage("video", pFrame);
cvShowImage("background", pBkImg);
cvShowImage("foreground", pFrImg);
//如果有按键事件，则跳出循环
//此等待也为cvShowImage函数提供时间完成显示
//等待时间可以根据CPU速度调整
if( cvWaitKey(2) >= 0 )
break;
}
}
//销毁窗口
cvDestroyWindow("video");
cvDestroyWindow("background");
cvDestroyWindow("foreground");
//释放图像和矩阵
cvReleaseImage(&pFrImg);
cvReleaseImage(&pBkImg);
cvReleaseMat(&pFrameMat);
cvReleaseMat(&pFrMat);
cvReleaseMat(&pBkMat);
cvReleaseCapture(&pCapture);
return 0;
}
Python3实现：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Software: PyCharm
#
######################
#
# 背景建模，运动物体检测
#
######################
import sys
# import the necessary things for OpenCV
import cv2 as cv
if __name__ == '__main__':
pBkImg = None
pFrImg = None
pBkMat = None
pFrMat = None
pFrameMat = None
nFrmNum = 0
#创建窗口
cvNamedWindow("video", 1)
cvNamedWindow("background",1)
cvNamedWindow("foreground",1)
#使窗口有序排列
cvMoveWindow("video", 30, 0)
cvMoveWindow("background", 360, 0)
cvMoveWindow("foreground", 690, 0)
#打开摄像头
pCapture = cvCreateCameraCapture(0)
if not pCapture:
print("Can not open camera.")
sys.exit(1)
#打开视频文件
#   pCapture = cvCaptureFromFile(sys.argv[1]) if not pCapture:
#   print("Can not open video file.") sys.exit(1)
#逐帧读取视频
while 1:
pFrame = cvQueryFrame( pCapture )
if not pFrame:
print("Can not open frame.")
sys.exit(1)
nFrmNum = nFrmNum+1
print(nFrmNum)
#如果是第一帧，需要申请内存，并初始化
if nFrmNum == 1:
pBkImg = cvCreateImage(cvSize(pFrame.width,pFrame.height), IPL_DEPTH_8U,1)
pFrImg =cvCreateImage(cvSize(pFrame.width, pFrame.height), IPL_DEPTH_8U,1)
pBkMat = cvCreateMat(pFrame.height, pFrame.width, CV_32FC1)
pFrMat = cvCreateMat(pFrame.height, pFrame.width, CV_32FC1)
pFrameMat = cvCreateMat(pFrame.height, pFrame.width, CV_32FC1)
#转化成单通道图像再处理
cvCvtColor(pFrame, pBkImg, CV_BGR2GRAY)
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY)
cvConvert(pFrImg, pFrameMat)
cvConvert(pFrImg, pFrMat)
cvConvert(pFrImg, pBkMat)
else:
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY)
cvConvert(pFrImg, pFrameMat)
#高斯滤波先，以平滑图像
cvSmooth(pFrameMat, pFrameMat, CV_GAUSSIAN, 3, 0, 0)
#当前帧跟背景图相减
cvAbsDiff(pFrameMat, pBkMat, pFrMat)
#二值化前景图
cvThreshold(pFrMat, pFrImg, 60, 255.0, CV_THRESH_BINARY)
#进行形态学滤波，去掉噪音
cvErode(pFrImg, pFrImg, None, 1)
cvDilate(pFrImg, pFrImg, None, 1)
#更新背景
cvRunningAvg(pFrameMat, pBkMat, 0.003, None)
#将背景转化为图像格式，用以显示
cvConvert(pBkMat, pBkImg)
#显示图像
cvFlip(pFrame, None, 0)
cvFlip(pBkImg, None, 0)
cvFlip(pFrImg, None, 0)
cvShowImage("video", pFrame)
cvShowImage("background", pBkImg)
cvShowImage("foreground", pFrImg)
#如果有按键事件，则跳出循环 此等待也为cvShowImage函数提供时间完成显示 等待时间可以根据CPU速度调整
if cvWaitKey(2) >= 0 :
break
#销毁窗口
cvDestroyWindow("video")
cvDestroyWindow("background")
cvDestroyWindow("foreground")
#释放图像和矩阵
cvReleaseImage(pFrImg)
cvReleaseImage(pBkImg)
cvReleaseMat(pFrameMat)
cvReleaseMat(pFrMat)
cvReleaseMat(pBkMat)
cvReleaseCapture(pCapture)
sys.exit(0)

1)运动物体检测简介 

运动物体检测就是在视频(视频文件/摄像头获取)中检测运动物体(目标)。opencv中常用的运动物体检测方法有背景减法，帧差法，光流法，运动物体检测广泛应用于视频安全监控，，车辆检测等方面 

背景减法:就是用原图像减去背景模型，剩下的就是前景图像，即运动目标 

帧差法:就是利用相邻的两帧或三帧图像，利用像素之间的差异性，判断是否有运动目标 

视频就是一帧一帧图像组成的 

求图像差异最基本的就是图像减法(-,suntract,absdiff) 

 - /Subtract        —–a-b <0 —0 

 -Adsdiff   —————|a-b|>0

2)背景减法 

基本步骤: 

原图—背景—-阈值处理—去除噪声(腐蚀 滤波)—膨胀连通—-查找轮廓—-外接矩形(椭圆/圆) 

3)帧差法 

基本步骤 : 

相邻帧相减—阈值处理—-去除噪声(腐蚀滤波)—-膨胀连通—-查找轮廓—-外接矩形(椭圆/圆）



//两张图片的验证
Mat img1=imread("1.bmp");
Mat img2=imread("55.bmp");
imshow("img1",img1);
imshow("img2",img2);
//Mat result=img2.clone();
Mat gray1,gray2;
cvtColor(img1,gray1,CV_BGR2GRAY);
cvtColor(img2,gray2,CV_BGR2GRAY);
Mat diff;
adsdiff(gray1,gray2,diff);
imshow("absdiss",diff);
threshold(diff,diff,45,255,CV_THRESH_BINARY);
imshow("threshold",diff);

Mat element=getStructuringElement(MOORPH_RECT,Size(3,3));
Mat element2=getStructuringElement(MORPH_RECT,Size(11,11));
erode(diff,diff,element);
imshow("erode",diff);

dilate(diff,diff,element2);
imshow("dilate",diff);

vector<vector<Point>contours;
vector<Vec4i>hierarcy;
findContours(diff,contours,hierarcy,CV_RETR_EXTERNAL,CHAIN_APPROX_NONE);//查找轮廓
vector<Rect>boundRect(contours.size());//定义外接矩形集合
drawContours(img2,contours,-1,Scalar(0,0,255),1,8);//绘制轮廓
int xo=0;yo=0;wo=0;ho=0;
for(int i=0;i<contours.size();i++)
{
  boundRect[i]=boundingRect((Mat)contours[i]);//查找每个轮廓的外接矩形
  xo=boundRect[i].x;//获得第i个外接矩形的左上角的x坐标
  yo=boundRect[i].y;//获得第i个外接矩形的左上角的y坐标
  wo=boundRect[i].width;//获得第i个外接矩形的宽度
  ho=boundRect[i].height;//获得第i个外接矩形的高度
  rectangle(img2,Point(xo,yo),Point(xo+wo,yo+ho),Scalar(0,255,0),2,8);//绘制第i个外接矩形
}
imshow("result",img2);
waitKey(0);


视频要可以提取第一帧为背景帧

运动物体检测+预测运动方向
一开始的时候我想了好久，都觉得好玄学啊，我在运动的时候，可以乱溜达，我想怎么动怎么动，又不是什么规则的运动，都不是什么可以拟合的曲线，那预测位置多奇怪啊,我可能这一秒的趋势是往前运动，但是我突然想不开非要退一下呢qaq，就感觉有点奇怪
运动物体检测
一开始想的是采用背景运动估计的方法去做的，但是在我测试的时候，我固定了摄像头位置，但是由于摄像头好像会自动聚焦然后会有点放大缩小，图像在抖动，而我又是以摄像头读取到的第一帧图像为基础背景去比较的，就导致背景自己就觉得自己在动，就很诡异，效果并不好，代码如下：
import cv2
import numpy as np
 
cap = cv2.VideoCapture(0)

es = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 4))
kernel = np.ones((3, 3), np.uint8)
background = None
 
while True:
  ret, frame = cap.read()
  gray_img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
  gray_img = cv2.GaussianBlur(gray_img, (21, 21), 0)
 
  # 将第一帧设为背景
  if background is None:
    background = gray_img
    continue
  img = cv2.absdiff(background, gray_img)
  img = cv2.threshold(img, 25, 255, cv2.THRESH_BINARY)[1] 
  img = cv2.dilate(img, es, iterations=2)
  # 框选
  contours, hierarchy = cv2.findContours(img.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
  for c in contours:
    (x, y, w, h) = cv2.boundingRect(c)
    cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 255, 0), 2)
 
  cv2.imshow('contours', frame)
  cv2.imshow('dis', img)
 
  key = cv.waitKey(30)
    if key == 27:
        break
camera.release()
cv2.destroyAllWindows()

然后就改变了想法，采用了光流法，因为很方便就能反馈相邻两帧的相应特征点的坐标，但是缺陷就在于取得特征点有些是无用的

其中角点检测我参考的博客是：

Harris角点检测数学计算过程与CornerHarris方法参数的一点说明【DataWhale学习记录】

角点检测详细总结及代码示例

光流法参考的是：

SLAM代码（光流法）
运动预测
我一开始采取的是取相邻两帧之间的特征点的位置,轨迹就是两点连接起来，预测出的运动方向用向量表示，因为没办法直接在图上画出向量，所以我选择了自己计算一下然后用三条线画一个向量出来
        x = 10*(x1 - x0) + x0
        y = 10*(y1 - y0) + y0
        x2 = (x - x0)*cmath.sqrt(2)//2 - (y - y0)*cmath.sqrt(2)//2 + x0
        y2 = (x - x0)*cmath.sqrt(2)//2 + (y - y0)*cmath.sqrt(2)//2 + y0
        x3 = (x - x0)*cmath.sqrt(2)//2 + (y - y0)*cmath.sqrt(2)//2 + x0
        y3 = -(x - x0)*cmath.sqrt(2)//2 + (y - y0)*cmath.sqrt(2)//2 + y0
        cv.line(res, (x0, y0), (int(x), int(y)), (0, 0, 139), 2)
        cv.line(res, (int(x), int(y)), (x2, y2), (0, 0, 139), 2)
        cv.line(res, (int(x), int(y)), (x3, y3), (0, 0, 139), 2)
        cv.line(points, (x1, y1), (x0, y0), (0, 0, 255), 3)
        frame = cv.circle(res, (x1, y1), 10, (0, 255, 0))

这样算的话就有一个缺陷，如果物体运动速度快一些的话，向量就会画的很大，运动速度的快慢决定了向量大小

如果非要说圈出预测的物体下一帧所在的位置的话，如下：
x4 = 2*(x1 - x0) + x0
y4 = 2*(y1 - y0) + y0 
cv.circle(res, (int(x4), int(y4)), 10, (139, 0, 139), 2)

最终效果

绿色的圈是当前位置，紫色的圈是预测位置，箭头是预测的运动方向

很悲伤的是我不想开会员，录屏只让两分钟没啥，mp4转gif的画免费的只有5s，转完了还变快了💩💩💩
理想改进
如果以后还会想做的话，还是想通过运动补偿解决摄像头抖动的问题以达到维持静态背景的效果，然后训练一个运动预测模型，其实如果累计的点合适多的话也是可以当作理想曲线去拟合的
源码下载
上传在我的csdn上了

https://download.csdn.net/download/Colleron/15416029