opencv运动物体检测

2021-04-05 00:08:57

#encoding=utf-8
import cv2
import time
import winsound

camera = cv2.VideoCapture(0)    # 定义摄像头对象，其参数0表示第一个摄像头（自带摄像头）
if camera is None:
    #如果摄像头打开失败，则输出提示信息
    print('please connect the camera')
    exit()
 
fps = 30    #帧率 
pre_frame = None    #总是取前一帧做为背景（不用考虑环境影响）
  
while True:
    start = time.time()
    # 读取视频流
    res, cur_frame = camera.read()
    if res != True:
        break
    end = time.time()
    
    seconds = end - start
    if seconds < 1.0/fps:
        time.sleep(1.0/fps - seconds)
    
    cv2.namedWindow('img',0);
    #cv2.imshow('img', cur_frame)
    
    #检测如何按下Q键，则退出程序
    key = cv2.waitKey(30) & 0xff
    if key == 27:
        break
    #转灰度图
    gray_img = cv2.cvtColor(cur_frame, cv2.COLOR_BGR2GRAY)
    #将图片缩放
    gray_img = cv2.resize(gray_img, (500, 500))
    # 用高斯滤波进行模糊处理
    gray_img = cv2.GaussianBlur(gray_img, (21, 21), 0)
 
    #如果没有背景图像就将当前帧当作背景图片
    if pre_frame is None:
        pre_frame = gray_img
    else:
        # absdiff把两幅图的差的绝对值输出到另一幅图上面来
        img_delta = cv2.absdiff(pre_frame, gray_img)
        
        #threshold阈值函数(原图像应该是灰度图,对像素值进行分类的阈值,当像素值高于（有时是小于）
        #阈值时应该被赋予的新的像素值,阈值方法)
        thresh = cv2.threshold(img_delta, 25, 255, cv2.THRESH_BINARY)[1]
        
        #膨胀图像
        thresh = cv2.dilate(thresh, None, iterations=2)
        
        # findContours检测物体轮廓(寻找轮廓的图像,轮廓的检索模式,轮廓的近似办法)
        contours, hierarchy =   cv2.findContours(thresh.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
        
        for c in contours:
            #灵敏度
            if cv2.contourArea(c) < 1000:	# 1000为阈值
                continue
            else:
                #框选移动部分
                (x,y,w,h) = cv2.boundingRect(c)
                cv2.rectangle(cur_frame,(x,y),(x+w,y+h),(0,255,0),2)
 
                print("something is moving!!!")
                flag = True
                if flag == True:
                    winsound.Beep(600, 1000)
                break

        #显示
        cv2.imshow('img', cur_frame)	
        pre_frame = gray_img
        
# release()释放摄像头 
camera.release()
#destroyAllWindows()关闭所有图像窗口
cv2.destroyAllWindows()

更多相关内容

基于OpenCv的运动物体检测算法
2020-08-28 04:45:28

主要为大家详细介绍了基于OpenCv的运动物体检测算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

收起
opencv运动物体检测
2012-03-28 13:32:58

opencv运动物体检测,检测视频中的运动物体,并分离出前景背景

收起
opencv 运动物体跟踪检测
2017-08-18 09:43:42

内含代码可以检测运动物体，采用高斯混合模型算法提取前景

收起
基于opencv运动物体背景分割方法的目标检测及目标跟踪实现
2022-04-27 09:32:14

2.使用opencv中createBackgroundSubtractorMOG2()运动物体背景分割，及后续目标检测 3.代码中实现了对车辆的检测和跟踪 4.代码计算量小，可实现实时跟踪 5.可对感兴趣区域（ROI）进行单独检测和跟踪 6.代码关键步骤...

收起
OpenCV:使用OpenCV进行物体检测的实验
2021-05-22 08:11:57

使用OpenCV进行物体检测的实验 BlobTrack1.py进行简单的运动跟踪（blob速度和距离移动）。示例视频非常简单，它实际上并不匹配一帧到下一帧的斑点，但是当帧中只有一个运动对象时，它仍然可以工作。比较位置，大小...

收起

Python

【opencv学习】【运动物体检测】

千次阅读 2022-02-14 22:28:32

今天学习运动物体检测 一：帧差法捕获摄像头的运动的手 import cv2 import numpy as np # 如果我们想捕获一些运动的物体，每一帧图像中，不动的部分称之为背景，运动的物体称之为前景 # 假如我们的视频捕捉窗口是...

今天学习运动物体检测
一：帧差法
捕获摄像头的运动的手

import cv2
import numpy as np

# 如果我们想捕获一些运动的物体，每一帧图像中，不动的部分称之为背景，运动的物体称之为前景
# 假如我们的视频捕捉窗口是不动的，比如摄像头放着不动，保证了背景是基本不发生变化的，但是我们怎么捕获前景和背景啊？
# 第一部分: 帧差法
# 通过前后两帧的差值来捕捉运动的物体（一般用时间t的帧减去时间t-1的帧），超过某个阈值，则判断是前景，否则是背景
# 这个方法很简单，但是会带来巨大的噪声（微微震动，零星点）和空洞（运动物体非边缘部分也被判断成了背景）

cap = cv2.VideoCapture(0)  # 其参数0表示第一个摄像头，一般就是笔记本的内建摄像头。
# cap = cv2.VideoCapture('images/kk 2022-01-23 18-21-21.mp4')  # 来自vedio视频的

# 获取第一帧
ret, frame = cap.read()
frame_prev = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将彩色图像转成灰度图

kernel1 = np.ones((5, 5), np.uint8)  # 为了开运算使用
while (1):
    # 获取每一帧
    ret, frame = cap.read()
    if frame is None:
        print("camera is over...")
        break

    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将彩色图像转成灰度图
    diff = frame - frame_prev  # 肯定有一些是负数，全是灰度值的相减

    diff_abs = cv2.convertScaleAbs(diff)  # 取绝对值，保留我们的差异值

    _, thresh1 = cv2.threshold(diff_abs, 100, 255, cv2.THRESH_BINARY)  # 二值化处理

    MORPH_OPEN_1 = cv2.morphologyEx(thresh1, cv2.MORPH_OPEN, kernel1)  # 开运算，去除噪声和毛刺
    # erosion_it2r_1 = cv2.dilate(MORPH_OPEN_1, kernel1, iterations=2)  # 膨胀操作

    # cv2.imshow("capture", thresh1)  # 展示该图像
    cv2.imshow("capture", MORPH_OPEN_1)  # 展示该图像

    frame_prev = frame  # 更新前一帧

    # 进行等待或者退出判断
    if cv2.waitKey(1) & 0xFF == 27:
        break
cap.release()
cv2.destroyAllWindows()

请添加图片描述

捕捉视频的帧，捕获坤坤的打篮球和跳舞

import cv2
import numpy as np

# 如果我们想捕获一些运动的物体，每一帧图像中，不动的部分称之为背景，运动的物体称之为前景
# 假如我们的视频捕捉窗口是不动的，比如摄像头放着不动，保证了背景是基本不发生变化的，但是我们怎么捕获前景和背景啊？
# 第一部分: 帧差法
# 通过前后两帧的差值来捕捉运动的物体（一般用时间t的帧减去时间t-1的帧），超过某个阈值，则判断是前景，否则是背景
# 这个方法很简单，但是会带来巨大的噪声（微微震动，零星点）和空洞（运动物体非边缘部分也被判断成了背景）

cap = cv2.VideoCapture('images/kk 2022-01-23 18-21-21.mp4')  # 来自vedio视频的

# 获取第一帧
ret, frame = cap.read()
frame_prev = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将彩色图像转成灰度图

# kernel1 = np.ones((5, 5), np.uint8)  # 为了开运算使用
while (1):
    # 获取每一帧
    ret, frame = cap.read()
    if frame is None:
        print("camera is over...")
        break

    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将彩色图像转成灰度图
    diff = frame - frame_prev  # 肯定有一些是负数，全是灰度值的相减

    diff_abs = cv2.convertScaleAbs(diff)  # 取绝对值，保留我们的差异值

    _, thresh1 = cv2.threshold(diff_abs, 100, 255, cv2.THRESH_BINARY)  # 二值化处理

    # MORPH_OPEN_1 = cv2.morphologyEx(thresh1, cv2.MORPH_OPEN, kernel1)  # 开运算，去除噪声和毛刺
    # erosion_it2r_1 = cv2.dilate(MORPH_OPEN_1, kernel1, iterations=2)  # 膨胀操作

    cv2.imshow("capture", diff_abs)  # 展示该图像
    # cv2.imshow("capture", thresh1)  # 展示该图像
    # cv2.imshow("capture", MORPH_OPEN_1)  # 展示该图像

    frame_prev = frame  # 更新前一帧

    # 进行等待或者退出判断
    if cv2.waitKey(24) & 0xFF == 27:
        break
cap.release()
cv2.destroyAllWindows()

效果如下：
请添加图片描述

总体而言，帧差法的效果真的是不忍直视。

二：高斯混合模型（GMM）
在进行前景检测前，先进行背景的学习和训练，对图像的每一个背景采用一个GMM进行模拟，每个背景的混合高斯模型是可以训练的，是自适应的。在测试阶段，对新来的像素进行GMM检测，如果像素值匹配某个高斯模型（进行概率值计算，看看和哪个高斯模型接近，或者看看和均值的偏离程度），则认为是背景，否则认为是前景（剧烈变化的像素，属于异常而原理GMM模型）。由于整个过程中GMM模型在不断的更新学习，多以对动态背景有一定的鲁棒性。

我们的视频中的每一帧的像素点不可能是一成不变的（理想很丰满），总会有空气密度导致的变化，吹一吹风，或者摄像头的微微抖动。但是正常情况下，我们都认为背景中的像素点都是满足一个高斯分布，在一定的概率下抖动是正常的。

我们的背景实际上也应当是多个高斯分布的混合分布，且每个高斯模型也是可以带权重的。因为背景有蓝天，建筑，树木花草，马路等。这些都是一些分布。

至于GMM和EM算法的内容和关系，我们在之前学习过，这里就不再讲述了。EM算法是求解GMM的一个方法。

运用在图像中的话，是怎么做的呢？步骤如下：
1：首先初始化每个高斯模型矩阵参数，初始的方差都是假设的（比如设置为5）。
2：先给T帧图像进行训练GMM，来了第一个像素后把他当成第一个高斯分布，比如作为均值。
3：后面再来一个像素，和当前的高斯分布作对比，如果该像素值和与当前的高斯模型的均值的差值在3倍的方差以内，就认为是属于该高斯分布，并对高斯分布参数进行更新。
4：如果该像素不满足该高斯分布。则用这个新的像素建立一个新的高斯分布（用它做均值，假设一个方差（比如设置为5））。但是一个像素位置不要太多个高斯分布，太多了会造成计算量巨大。3~5个基本够了。

GMM测试步骤：
对于新来的像素值，和GMM的的多个高斯分布的均值分别作比较，其差值在2倍的方差之内，则认为是背景，否则是前景。前景像素点设置为255，背景像素点设置为0，行成了一个二值图像。

import cv2
import numpy as np

cap = cv2.VideoCapture('images/kk 2022-01-23 18-21-21.mp4')  # 来自vedio视频的

kernel1 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
mog = cv2.createBackgroundSubtractorMOG2()  # 创建混合高斯模型来用于北京建模

while (1):
    # 获取每一帧
    ret, frame = cap.read()
    if frame is None:
        print("camera is over...")
        break

    fmask = mog.apply(frame)  # 判断哪些是前景和背景

    MORPH_OPEN_1 = cv2.morphologyEx(fmask, cv2.MORPH_OPEN, kernel1)  # 开运算，去除噪声和毛刺

    contours, _ = cv2.findContours(fmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)  # 只检测外边框

    for cont in contours:
        # 计算各个轮廓的面积
        len = cv2.arcLength(cont, True)
        if len > 300:  # 去除一些小的噪声点
            # 找到一个轮廓
            x,y,w,h = cv2.boundingRect(cont)
            # 画出这个矩形
            cv2.rectangle(frame, (x,y), (x+w, y+h), color=(0,255,0), thickness=3)

    # 画出所有的轮廓
    cv2.imshow('frame', frame)
    cv2.imshow('fmask', fmask)

    # 进行等待或者退出判断
    if cv2.waitKey(24) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

效果如下：
请添加图片描述

三：KNN
也是根据每个像素点的历史信息进行统计额比较，来判断新来的像素值是不是背景。具体的原理后面补充。

import cv2
import numpy as np

cap = cv2.VideoCapture('images/kk 2022-01-23 18-21-21.mp4')  # 来自vedio视频的

kernel1 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
knn = cv2.createBackgroundSubtractorKNN()  # 创建KNN模型

while (1):
    # 获取每一帧
    ret, frame = cap.read()
    if frame is None:
        print("camera is over...")
        break

    fmask = knn.apply(frame)  # 判断哪些是前景和背景

    MORPH_OPEN_1 = cv2.morphologyEx(fmask, cv2.MORPH_OPEN, kernel1)  # 开运算，去除噪声和毛刺

    contours, _ = cv2.findContours(fmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)  # 只检测外边框

    for cont in contours:
        # 计算各个轮廓的面积
        len = cv2.arcLength(cont, True)
        if len > 200:  # 去除一些小的噪声点
            # 找到一个轮廓
            x,y,w,h = cv2.boundingRect(cont)
            # 画出这个矩形
            cv2.rectangle(frame, (x,y), (x+w, y+h), color=(0,255,0), thickness=3)

    # 画出所有的轮廓
    cv2.imshow('frame', frame)
    cv2.imshow('fmask', fmask)

    # 进行等待或者退出判断
    if cv2.waitKey(24) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

效果如下：
请添加图片描述

收起

展开全文

计算机视觉人工智能

Python-OpenCV运动物体检测
万次阅读 2018-10-05 18:00:01
运动物体检查，在移动目标定位和智能安防系统中有广泛的应用，它的实现原理：捕获连续帧之间的变化情况，将每次捕获的图像进行对比，然后检查差值图像中的所有斑块（颜色相近的地方）。
运动物体检查，在移动目标定位和智能安防系统中有广泛的应用，它的实现原理：捕获连续帧之间的变化情况，将每次捕获的图像进行对比，然后检查差值图像中的所有斑块（颜色相近的地方）。

Demo在实现的过程中，首先需要设置“背景帧”，通过捕获连续帧，比较“背景帧”与其它帧之间的差异，这种方法检测结果还是挺不错的，但是若在室外，光线的变化就会引起误检测，具有局限性和干扰性。

Demo运行效果如下：

Demo实现如下：
```
import cv2
import numpy as np

camera = cv2.VideoCapture(0) # 参数0表示第一个摄像头
# 判断视频是否打开
if (camera.isOpened()):
    print('Open')
else:
    print('摄像头未打开')

# 测试用,查看视频size
size = (int(camera.get(cv2.CAP_PROP_FRAME_WIDTH)),
        int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT)))
print('size:'+repr(size))

es &#
```
收起
展开全文
Python

基于opencv的运动物体检测方法总结

千次阅读 2020-04-14 19:15:14

今天朋友问我要一个车上充满点点的图片，然后我第一时间想到了光流法，然后想到了之前总结的运动物体检测的几个方法，还在有道云笔记里面，所以打算搬迁过来。帧间差分法定义：利用相邻的两帧或者三帧图像，利用...

今天朋友问我要一个车上充满点点的图片，然后我第一时间想到了光流法，然后想到了之前总结的运动物体检测的几个方法，还在有道云笔记里面，所以打算搬迁过来。

帧间差分法

定义：利用相邻的两帧或者三帧图像，利用像素之间的差异性，判断是否有运动目标

基本步骤：相邻帧相减－－－阈值处理－－－去除噪声－－－膨胀联通－－－查找轮廓－－－绘制外接矩形

参考方法：https://www.cnblogs.com/little-monkey/p/7637130.html
#include "opencv2/opencv.hpp"
#include<iostream>
using namespace std;
using namespace cv;

int CarNum = 0;
string intToString(int number)  //int类型转为string类型
{
    stringstream ss;
    ss << number;
    return ss.str();
}

Mat MoveDetect(Mat frame1, Mat frame2) {
    Mat result = frame2.clone();
    Mat gray1, gray2;
    cvtColor(frame1, gray1, COLOR_BGR2GRAY);
    cvtColor(frame2, gray2, COLOR_BGR2GRAY);

    Mat diff;
    absdiff(gray1, gray2, diff);
    //imshow("absdiss", diff);
    threshold(diff, diff, 50, 255, THRESH_BINARY);
    imshow("threshold", diff);

    medianBlur(diff, diff, 5);
    imshow("medianBlur", diff);

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

    vector<vector<Point>> contours;
    vector<Vec4i> hierarcy;
    findContours(diff, contours, hierarcy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point(0, 0));//查找轮廓
    vector<vector<Point>>contours_poly(contours.size());
    vector<Rect> boundRect(contours.size()); //定义外接矩形集合
    //drawContours(img2, contours, -1, Scalar(0, 0, 255), 1, 8);  //绘制轮廓
    int x0 = 0, y0 = 0, w0 = 0, h0 = 0;
    for (int i = 0; i<contours.size(); i++)
    {
    //对图像轮廓点进行多边形拟合：轮廓点组成的点集，输出的多边形点集，精度（即两个轮廓点之间的距离），输出多边形是否封闭
        approxPolyDP(Mat(contours[i]), contours_poly[i], 3, true);
        boundRect[i] = boundingRect(Mat(contours_poly[i]));
        if (boundRect[i].width>55 && boundRect[i].width<180 && boundRect[i].height>55 && boundRect[i].height<180) {//轮廓筛选
            x0 = boundRect[i].x;
            y0 = boundRect[i].y;
            w0 = boundRect[i].width;
            h0 = boundRect[i].height;

            rectangle(result, Point(x0, y0), Point(x0 + w0, y0 + h0), Scalar(0, 255, 0), 2, 8, 0);
            //经过这条线（区间），车辆数量+1
            if ((y0 + h0 / 2 + 1) >= 138 && (y0 + h0 / 2 - 1) <= 142) {
                CarNum++;
            }
        }
        line(result, Point(0, 140), Point(568, 140), Scalar(0, 0, 255), 1, 8);//画红线
        Point org(0, 35);
        putText(result, "CarNum=" + intToString(CarNum), org, FONT_HERSHEY_SIMPLEX, 0.8f, Scalar(0, 255, 0), 2);
    }
    return result;
}

int main() {
    VideoCapture cap("out3.avi");
    if (!cap.isOpened()) //检查打开是否成功
        return -1;
    Mat frame;
    Mat tmp;
    Mat result;
    int count = 0;
    while (1) {
        cap >> frame;
        if (frame.empty())//检查视频是否结束
            break;
        else {
            resize(frame,frame,Size(640,480));
            count++;
            if (count == 1)
                result = MoveDetect(frame, frame);
            else result = MoveDetect(tmp, frame);
            imshow("video", frame);
            imshow("result", result);
            tmp = frame.clone();
            if (waitKey(20) == 27)
                break;
        }
    }
    cap.release();
    return 0;
}

背景减弱法原理

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

基本步骤：原图－－背景－－阈值处理－－－去除噪声（腐蚀滤波）－－－膨胀连通－－－查找轮廓－－－外接矩形

代码实现：BackgroundSubtractor一共给我们提供了三种具体方法，分别是BackgroundSubtractorMOG, BackgroundSubtractorMOG2和BackgroundSubtractorGMG (这是基于基于3.1.0)

这三种方法的具体区别及使用方法可以参考这篇官方文档,但是我在官网中看到4.1.0中，只有BackgroundSubtractorKNN和BackgroundSubtractorMOG2这两种方法。

//参考链接：https://blog.csdn.net/qq_32925781/article/details/52878465
// 方法：BackgroundSubtractorMOG2
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/videoio.hpp"
#include <opencv2/highgui.hpp>
#include <opencv2/video.hpp>
#include <stdio.h>
#include <iostream>
#include <sstream>

using namespace cv;
using namespace std;

Mat frame; //当前帧
Mat fgMaskMOG2; //通过MOG2方法得到的掩码图像fgmask
Mat segm;      //frame的副本

vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
Ptr<BackgroundSubtractor> pMOG2; //MOG2 Background subtractor

//处理输入视频函数定义
void processVideo();

int main()
{
    //namedWindow("Original Frame");
    //namedWindow("After MOG2");
    //create Background Subtractor objects
    pMOG2 = createBackgroundSubtractorMOG2();

    processVideo();

    destroyAllWindows();
    return 0;
}


void processVideo() {

    VideoCapture capture(1); //参数为0，默认从摄像头读取视频

    if(!capture.isOpened()){
        cout << "Unable to open the camera! " << endl;
       //EXIT_FAILURE 可以作为exit()的参数来使用，表示没有成功地执行一个程序,其值为1        
        exit(EXIT_FAILURE); 
    }

    while( true ){

        if(!capture.read(frame)) {
            cout << "Unable to read next frame." << endl;
            exit(0);
        }

        //对画面进行一定的缩放，方便处理
        double scale = 1.3;         //缩放比例
        Mat smallImg(frame.rows / scale,frame.cols / scale,CV_8SC1);
        resize(frame, frame, smallImg.size(),0,0,INTER_LINEAR);


        pMOG2->apply(frame, fgMaskMOG2);    //更新背景模型
        frame.copyTo(segm);             //建立一个当前frame的副本
        findContours(fgMaskMOG2, contours, hierarchy,
                     RETR_TREE, CHAIN_APPROX_SIMPLE,Point(0,0)); //检测轮廓

        vector <vector<Point> > contours_poly( contours.size());
        vector <Point2f> center( contours.size());
        vector <float> radius( contours.size());
        for( int i = 0; i < contours.size(); i++){
         //findContours后的轮廓信息contours可能过于复杂不平滑，
         //可以用approxPolyDP函数对该多边形曲线做适当近似
            approxPolyDP( Mat(contours[i]), contours_poly[i], 3, true);
            //得到轮廓的外包络圆
            minEnclosingCircle( contours_poly[i], center[i], radius[i]);
        }
        //对所得到的轮廓进行一定的筛选
        for(int i = 0; i < contours.size(); i++ ){
            if (contourArea(contours[i]) > 500){
                circle(segm, center[i], (int)radius[i], Scalar(100, 100, 0), 2, 8, 0);
                break;
            }
        }

        //得到当前是第几帧
        stringstream ss;
//        rectangle(frame, cv::Point(10, 2), cv::Point(100,20),
//                  cv::Scalar(255,255,255), -1);
        ss << capture.get(CAP_PROP_POS_FRAMES);
        string frameNumberString = ss.str();
        putText(frame, frameNumberString.c_str(), cv::Point(15, 15),
                FONT_HERSHEY_SIMPLEX, 0.5 , cv::Scalar(0,0,0));

        //显示
        imshow("frame", frame);
        imshow("Segm", segm);
        imshow("FG Mask MOG 2", fgMaskMOG2);

        int key;
        key = waitKey(5);
        if (key == 'q' || key == 'Q' || key == 27)
            break;
    }

    capture.release();
}

光流场法

定义:一般而言，光流是由于场景中前景目标本身的移动、相机的运动，或者两者的共同运动所产生的。

原理：

undefined

/*稀疏光流阀*/
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/video.hpp>
using namespace cv;
using namespace std;
int main(int argc, char **argv)
{

    VideoCapture capture("/home/demon/CLionProjects/Radar/cmake-build-debug/110_90.avi");
    if (!capture.isOpened()){
        //error in opening the video input
        cerr << "Unable to open file!" << endl;
        return 0;
    }
    // Create some random colors
    vector<Scalar> colors;
    RNG rng;
    for(int i = 0; i < 100; i++)
    {
        int r = rng.uniform(0, 256);
        int g = rng.uniform(0, 256);
        int b = rng.uniform(0, 256);
        colors.push_back(Scalar(r,g,b));
    }
    Mat old_frame, old_gray;
    vector<Point2f> p0, p1;
    // Take first frame and find corners in it
    capture >> old_frame;
    cvtColor(old_frame, old_gray, COLOR_BGR2GRAY);
    goodFeaturesToTrack(old_gray, p0, 100, 0.3, 7, Mat(), 7, false, 0.04);
    // Create a mask image for drawing purposes
    Mat mask = Mat::zeros(old_frame.size(), old_frame.type());
    while(true){
        Mat frame, frame_gray;
        capture >> frame;
        if (frame.empty())
            break;
        cvtColor(frame, frame_gray, COLOR_BGR2GRAY);
        // 计算光流点
        vector<uchar> status;
        vector<float> err;
        //设置迭代终止条件
        TermCriteria criteria = TermCriteria((TermCriteria::COUNT) + (TermCriteria::EPS), 10, 0.03);

        calcOpticalFlowPyrLK(old_gray, frame_gray, p0, p1, status, err, Size(15,15), 2, criteria);

        vector<Point2f> good_new;
        for(uint i = 0; i < p0.size(); i++)
        {
            // Select good points
            if(status[i] == 1) {
                good_new.push_back(p1[i]);
                // draw the tracks
//                line(mask,p1[i], p0[i], Scalar(0,0,255), 2);
//                circle(frame, p1[i], 5, Scalar(0,0,255), -1);
                circle(mask, p1[i], 10, Scalar(0,0,255), -1);
            }
        }

        Mat img;
        add(frame, mask, img);
        imshow("Frame", img);
        int keyboard = waitKey(30);
        if (keyboard == 'q' || keyboard == 27)
            break;
        // Now update the previous frame and previous points
        old_gray = frame_gray.clone();
        p0 = good_new;
    }
}

写视频

写视频
//实现写视频功能
#include<opencv2/opencv.hpp>
#include<iostream>
using namespace cv;
using namespace std;

int main()
{
//    'M', 'J', 'P', 'G'　　　　'X','V','I','D'
//Size要和图片尺寸保持一致
    VideoWriter writer("blue_red.avi",cv::VideoWriter::fourcc('X','V','I','D'),8,Size(1280,1024),true);
    char filename[50];
    Mat frame;
    for (int i = 1; i < 243; i++)
    {
        sprintf(filename,"//home/demon/MVViewer/6mm-two/%d.bmp",i);
        frame=imread(filename);
        if(frame.empty())   break;
        writer<<frame;

    }
    cout<<"write end!"<<endl;
    destroyAllWindows();
    return 0;
}

参考链接：https://www.cnblogs.com/little-monkey/p/7637130.html

　　　　　https://blog.csdn.net/zhang1308299607/article/details/80081553

　　　　　http://www.dataguru.cn/thread-926371-1-1.html

　　　　 https://blog.csdn.net/oliverkingli/article/details/78067557

收起

展开全文

计算机视觉

基于OPENCV运动物体检测
2010-10-25 15:22:45

用OPENCV实现对运动物体检测，有详细的代码以及注释

收起
OpenCV利用背景建模检测运动物体
2020-08-28 07:41:19

主要为大家详细介绍了OpenCV利用背景建模检测运动物体，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

收起
python+opencv运动目标检测
2021-02-23 08:29:01

给出了三种运动目标检测的程序实现

收起
基于Opencv的运动目标的检测和跟踪
2021-04-16 17:53:50

检测运动物体需要无运动物体的背景图像，所以，首先应用多帧像素平均值法提取了运动视频序列的背景图，从背景图像中分离目标像素，获取目标的质心坐标，并应用质心跟踪法以灰色图像序列为基础，对运动的目标进行实时...

收起
用python和OpenCV进行动态物体检测
千次阅读 2020-04-23 10:11:59

用python和OpenCV进行动态物体检测 此程序

收起

计算机视觉 python
python opencv实现运动检测
2021-01-20 04:54:26

本文实例为大家分享了python opencv运动检测的具体代码，供大家参考，具体内容如下 # -*- coding:utf-8 -*- __author__ = 'kingking' __version__ = '1.0' __date__ = '14/07/2017' import cv2 import numpy as np ...

收起
[opencv]学习之帧差法实现运动物体检测
千次阅读 2022-04-19 16:16:25

//帧差处理找到帧与帧之间运动物体差异 absdiff(frontGray,afterGray,diff); //imshow("diff",diff); //二值化 threshold(diff,diff,25,255,CV_THRESH_BINARY); //imshow("threashold",diff); //腐蚀处理： Mat ...

收起

c++
opencv手动实现运动目标检测
千次阅读 2020-11-26 20:27:00

本文的运动目标检测主要基于背景消去(Background Subtraction)算法，本文将手动实现背景消去算法并检测到运动物体的实时位置。编程的基本环境是VS2019+opencv4.4。一、基本原理我们的基本思想是使用背景消去算法...

收起

计算机视觉
【OpenCV学习笔记】三十九、运动物体检测(一)
万次阅读 多人点赞 2017-04-14 11:09:03

运动物体检测(一) 1.背景减法 2.运动物体检测——帧差法

收起
python+OpenCV笔记（三十七）：检测运动物体——使用MOG/KNN背景差分器
千次阅读 2022-02-05 16:41:33

python+OpenCV笔记（三十七）：检测运动物体——使用MOG/KNN背景差分器

收起

python 计算机视觉图像处理
C#图像处理-OpenCVSharp教程(三十五) OpenCVSharp运动物体检测(一)
千次阅读 2021-06-15 19:16:03

本文作者Color Space，文章未经作者允许禁止转载！本文将介绍OpenCVSharp特征检测与匹配(一)---SIFT特征点提取与绘制！

收起

C# 图像处理
python opencv3 运动检测
2018-08-09 16:19:00

思路：开启摄像头后设置一个当前帧为背景，在之后检测到的帧都与背景对比不同，对不同的地方进行检测 1 # coding:utf-8 2 3 """ 4 计算帧之间的差异考虑背景帧与其他帧之间的差异 5 """ 6 7...

收起
openCV+python 边缘检测直线检测角点检测 运动物体检测
2019-05-12 19:13:27

基于openCV+python 的一系列检测操作，较为基础

收起
视频前景提取（基于opencv的运动物体检测）
千次下载 热门讨论 2011-11-19 16:26:35

基于opencv+vs2008的视频前景检测，对于视频监控领域是很好的小demo

收起
【OpenCV】“帧差法”实现移动物体的检测（车辆识别）
千次阅读 多人点赞 2022-04-19 02:19:04

本文介绍如何通过使用Qt结合OpenCV运用帧差法来进行车辆识别。帧差法是一种通过对视频图像序列中相邻两帧作差分运算来获得运动目标轮廓的方法，它可以很好地适用于存在多个运动目标和摄像机移动的情况。...

收起

车辆识别 qt
opencv 视频运动物体检测
热门讨论 2012-11-15 09:47:36

opencv运动物体检测的代码，通过读取视频的每几帧，通过对比这几帧实现进行运动物体检测

收起

基于OpenCv的运动物体检测算法