opencv3.10光流法和前景提取法

最新推荐文章于 2024-08-16 20:20:08 发布
最新推荐文章于 2024-08-16 20:20:08 发布
阅读量6.2k 收藏 7
点赞数 3
分类专栏： opencv3常用代码示例 c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Gone_HuiLin/article/details/53433908
版权 
//bgfg_segm.h

#ifndef BGFG_SEGM_H
#define BGFG_SEGM_H

#include "opencv2/core.hpp"
#include "opencv2/core/utility.hpp"

using namespace cv;

enum Method
{
	MOG,
	MOG2,
	GMG,
	FGD_STAT
};

extern void foregroundExtraction(const Mat &frmae, Method m);

#endif


//bgfg_segm.cpp

#include <iostream>
#include <string>

#include "bgfg_segm.h"
#include "opencv2/cudabgsegm.hpp"
#include "opencv2/cudalegacy.hpp"
#include "opencv2/video.hpp"
#include "opencv2/highgui.hpp"

using namespace std;
using namespace cv::cuda;

static void fgd_Stat(const Mat &frame)
{
	const char *imageWindow = "image";
	const char *foregroundMaskWindow = "foreground mask";
	const char *foregroundImageWindow = "foreground image";
	const char *meanBackgroundImage = "mean background image";

	static bool isFirstFrame = true;
	static GpuMat d_frame;
	static Ptr<BackgroundSubtractor> fgd = cuda::createBackgroundSubtractorFGD();

	static GpuMat d_fgmask;
	static GpuMat d_bgimg;

	static Mat fgmask;
	static Mat fgimg;
	static Mat bgimg;

	d_frame.upload(frame);
	static GpuMat d_fgimg(d_frame.size(), d_frame.type());

	if (isFirstFrame)
	{
		fgd->apply(d_frame, d_fgmask);
		isFirstFrame = false;
	}
	else
	{
		int64 start = cv::getTickCount();

		fgd->apply(d_frame, d_fgmask);
		fgd->getBackgroundImage(d_bgimg);

		double fps = cv::getTickFrequency() / (cv::getTickCount() - start);
		std::cout << "FPS : " << fps << std::endl;

		d_fgimg.setTo(Scalar::all(0));
		d_frame.copyTo(d_fgimg, d_fgmask);

		d_fgmask.download(fgmask);
		d_fgimg.download(fgimg);
		d_bgimg.download(bgimg);

		imshow(imageWindow, frame);
		imshow(foregroundMaskWindow, fgmask);
		imshow(foregroundImageWindow, fgimg);
		imshow(meanBackgroundImage, bgimg);
	}
}

static void mog(const Mat &frame)
{
	const char *imageWindow = "image";
	const char *foregroundMaskWindow = "foreground mask";
	const char *foregroundImageWindow = "foreground image";
	const char *meanBackgroundImage = "mean background image";

	static bool isFirstFrame = true;
	static GpuMat d_frame;
	static Ptr<BackgroundSubtractor> mog = cuda::createBackgroundSubtractorMOG();

	static GpuMat d_fgmask;
	static GpuMat d_bgimg;

	static Mat fgmask;
	static Mat fgimg;
	static Mat bgimg;

	d_frame.upload(frame);
	static GpuMat d_fgimg(d_frame.size(), d_frame.type());

	if (isFirstFrame)
	{
		mog->apply(d_frame, d_fgmask, 0.01);
		isFirstFrame = false;
	}
	else
	{
		int64 start = cv::getTickCount();

		mog->apply(d_frame, d_fgmask, 0.01);
		mog->getBackgroundImage(d_bgimg);

		double fps = cv::getTickFrequency() / (cv::getTickCount() - start);
		std::cout << "FPS : " << fps << std::endl;

		d_fgimg.setTo(Scalar::all(0));
		d_frame.copyTo(d_fgimg, d_fgmask);

		d_fgmask.download(fgmask);
		d_fgimg.download(fgimg);
		d_bgimg.download(bgimg);

		imshow(imageWindow, frame);
		imshow(foregroundMaskWindow, fgmask);
		imshow(foregroundImageWindow, fgimg);
		imshow(meanBackgroundImage, bgimg);
	}
}

static void mog2(const Mat &frame)
{
	const char *imageWindow = "image";
	const char *foregroundMaskWindow = "foreground mask";
	const char *foregroundImageWindow = "foreground image";
	const char *meanBackgroundImage = "mean background image";

	static bool isFirstFrame = true;
	static GpuMat d_frame;
	static Ptr<BackgroundSubtractor> mog2 = cuda::createBackgroundSubtractorMOG2();

	static GpuMat d_fgmask;
	static GpuMat d_bgimg;

	static Mat fgmask;
	static Mat fgimg;
	static Mat bgimg;

	d_frame.upload(frame);
	static GpuMat d_fgimg(d_frame.size(), d_frame.type());

	if (isFirstFrame)
	{
		mog2->apply(d_frame, d_fgmask);
		isFirstFrame = false;
	}
	else
	{
		int64 start = cv::getTickCount();

		mog2->apply(d_frame, d_fgmask);
		mog2->getBackgroundImage(d_bgimg);

		double fps = cv::getTickFrequency() / (cv::getTickCount() - start);
		std::cout << "FPS : " << fps << std::endl;

		d_fgimg.setTo(Scalar::all(0));
		d_frame.copyTo(d_fgimg, d_fgmask);

		d_fgmask.download(fgmask);
		d_fgimg.download(fgimg);
		d_bgimg.download(bgimg);

		imshow(imageWindow, frame);
		imshow(foregroundMaskWindow, fgmask);
		imshow(foregroundImageWindow, fgimg);
		imshow(meanBackgroundImage, bgimg);
	}
}

static void gmg(const Mat &frame)
{
	const char *imageWindow = "image";
	const char *foregroundMaskWindow = "foreground mask";
	const char *foregroundImageWindow = "foreground image";

	static bool isFirstFrame = true;
	static GpuMat d_frame;
	static Ptr<BackgroundSubtractor> gmg = cuda::createBackgroundSubtractorGMG(40);

	static GpuMat d_fgmask;

	static Mat fgmask;
	static Mat fgimg;

	d_frame.upload(frame);
	static GpuMat d_fgimg(d_frame.size(), d_frame.type());

	if (isFirstFrame)
	{
		gmg->apply(d_frame, d_fgmask);
		isFirstFrame = false;
	}
	else
	{
		int64 start = cv::getTickCount();
		gmg->apply(d_frame, d_fgmask);
		double fps = cv::getTickFrequency() / (cv::getTickCount() - start);
		std::cout << "FPS : " << fps << std::endl;

		d_fgimg.setTo(Scalar::all(0));
		d_frame.copyTo(d_fgimg, d_fgmask);

		d_fgmask.download(fgmask);
		d_fgimg.download(fgimg);

		d_fgmask.download(fgmask);
		d_fgimg.download(fgimg);

		imshow(imageWindow, frame);
		imshow(foregroundMaskWindow, fgmask);
		imshow(foregroundImageWindow, fgimg);
	}
}

void foregroundExtraction(const Mat &frmae, Method m)
{
	assert(m >= MOG && m <= FGD_STAT);

	switch (m)
	{
	case FGD_STAT:
		fgd_Stat(frmae);
		break;

	case MOG:
		mog(frmae);
		break;

	case MOG2:
		mog2(frmae);
		break;

	case GMG:
		gmg(frmae);
		break;

	default:
		cout << "没有该方法，程序将退出." << endl;
		exit(1);
		break;
	}
}

//optical_flow.h

#ifndef OPTICAL_FLOW_H
#define OPTICAL_FLOW_H

#include "opencv2/core.hpp"
#include <opencv2/core/utility.hpp>

using namespace cv;

extern const char *optical_Flow_Name[];
extern Mat opticalFlowOut;

extern void optical_flow(const Mat &frame0, const Mat &frame1, const char *optical_Flow_Name);

#endif

//optical_flow.cpp

#include <iostream>
#include <fstream>

#include "optical_flow.h"
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include "opencv2/highgui.hpp"
#include "opencv2/cudaoptflow.hpp"
#include "opencv2/cudaarithm.hpp"

using namespace std;
using namespace cv::cuda;

Mat opticalFlowOut;					//原始光流输出图片，三通道		CV_8UC3

inline bool isFlowCorrect(Point2f u)
{
	return !cvIsNaN(u.x) && !cvIsNaN(u.y) && fabs(u.x) < 1e9 && fabs(u.y) < 1e9;
}

static Vec3b computeColor(float fx, float fy)
{
	static bool first = true;

	// relative lengths of color transitions:
	// these are chosen based on perceptual similarity
	// (e.g. one can distinguish more shades between red and yellow
	//  than between yellow and green)
	const int RY = 15;
	const int YG = 6;
	const int GC = 4;
	const int CB = 11;
	const int BM = 13;
	const int MR = 6;
	const int NCOLS = RY + YG + GC + CB + BM + MR;
	static Vec3i colorWheel[NCOLS];

	if (first)
	{
		int k = 0;

		for (int i = 0; i < RY; ++i, ++k)
			colorWheel[k] = Vec3i(255, 255 * i / RY, 0);

		for (int i = 0; i < YG; ++i, ++k)
			colorWheel[k] = Vec3i(255 - 255 * i / YG, 255, 0);

		for (int i = 0; i < GC; ++i, ++k)
			colorWheel[k] = Vec3i(0, 255, 255 * i / GC);

		for (int i = 0; i < CB; ++i, ++k)
			colorWheel[k] = Vec3i(0, 255 - 255 * i / CB, 255);

		for (int i = 0; i < BM; ++i, ++k)
			colorWheel[k] = Vec3i(255 * i / BM, 0, 255);

		for (int i = 0; i < MR; ++i, ++k)
			colorWheel[k] = Vec3i(255, 0, 255 - 255 * i / MR);

		first = false;
	}

	const float rad = sqrt(fx * fx + fy * fy);
	const float a = atan2(-fy, -fx) / (float)CV_PI;

	const float fk = (a + 1.0f) / 2.0f * (NCOLS - 1);
	const int k0 = static_cast<int>(fk);
	const int k1 = (k0 + 1) % NCOLS;
	const float f = fk - k0;

	Vec3b pix;

	for (int b = 0; b < 3; b++)
	{
		const float col0 = colorWheel[k0][b] / 255.0f;
		const float col1 = colorWheel[k1][b] / 255.0f;

		float col = (1 - f) * col0 + f * col1;

		if (rad <= 1)
			col = 1 - rad * (1 - col); // increase saturation with radius
		else
			col *= .75; // out of range

		pix[2 - b] = static_cast<uchar>(255.0 * col);
	}

	return pix;
}

static void drawOpticalFlow(const Mat_<float>& flowx, const Mat_<float>& flowy, Mat& dst, float maxmotion = -1)
{
	static bool isFirstTime = true;
	if (isFirstTime)
	{
		dst.create(flowx.size(), CV_8UC3);
		isFirstTime = false;
	}

	dst.setTo(Scalar::all(0));

	// determine motion range:
	float maxrad = maxmotion;

	if (maxmotion <= 0)
	{
		maxrad = 1;
		for (int y = 0; y < flowx.rows; ++y)
		{
			for (int x = 0; x < flowx.cols; ++x)
			{
				Point2f u(flowx(y, x), flowy(y, x));

				if (!isFlowCorrect(u))
					continue;

				maxrad = max(maxrad, sqrt(u.x * u.x + u.y * u.y));
			}
		}
	}

	for (int y = 0; y < flowx.rows; ++y)
	{
		for (int x = 0; x < flowx.cols; ++x)
		{
			Point2f u(flowx(y, x), flowy(y, x));

			if (isFlowCorrect(u))
				dst.at<Vec3b>(y, x) = computeColor(u.x / maxrad, u.y / maxrad);
		}
	}
}

static void showFlow(const char* name, const GpuMat& d_flow)
{
	static GpuMat planes[2];
	cuda::split(d_flow, planes);

	Mat flowx(planes[0]);
	Mat flowy(planes[1]);

	//drawOpticalFlow(flowx, flowy, opticalFlowOut, 10);
	drawOpticalFlow(flowx, flowy, opticalFlowOut);	//-1

	imshow(name, opticalFlowOut);
}

//Brox光流法
static void optical_flow_Brox(const Mat &frame0, const Mat &frame1)
{
	static GpuMat d_frame0;
	static GpuMat d_frame1;

	d_frame0.upload(frame0);
	d_frame1.upload(frame1);

	static GpuMat d_flow(frame0.size(), CV_32FC2);

	static Ptr<cuda::BroxOpticalFlow> brox = cuda::BroxOpticalFlow::create(0.197f, 50.0f, 0.8f, 10, 77, 10);

	static GpuMat d_frame0f;
	static GpuMat d_frame1f;

	d_frame0.convertTo(d_frame0f, CV_32F, 1.0 / 255.0);
	d_frame1.convertTo(d_frame1f, CV_32F, 1.0 / 255.0);

	//int64 start = getTickCount();

	brox->calc(d_frame0f, d_frame1f, d_flow);

	//double timeSec = (getTickCount() - start) / getTickFrequency();
	//cout << "Brox : " << timeSec << " sec" << endl;

	showFlow("Brox", d_flow);
}

//LK光流法
static void optical_flow_LK(const Mat &frame0, const Mat &frame1)
{
	static GpuMat d_frame0;
	static GpuMat d_frame1;

	d_frame0.upload(frame0);
	d_frame1.upload(frame1);

	static GpuMat d_flow(frame0.size(), CV_32FC2);

	static Ptr<cuda::DensePyrLKOpticalFlow> lk = cuda::DensePyrLKOpticalFlow::create(Size(7, 7));

	//int64 start = getTickCount();

	lk->calc(d_frame0, d_frame1, d_flow);

	//double timeSec = (getTickCount() - start) / getTickFrequency();
	//cout << "LK : " << timeSec << " sec" << endl;

	showFlow("LK", d_flow);
}

//Farn光流法
static void optical_flow_Farn(const Mat &frame0, const Mat &frame1)
{
	static GpuMat d_frame0;
	static GpuMat d_frame1;

	d_frame0.upload(frame0);
	d_frame1.upload(frame1);

	static GpuMat d_flow(frame0.size(), CV_32FC2);

	static Ptr<cuda::FarnebackOpticalFlow> farn = cuda::FarnebackOpticalFlow::create();
	//int64 start = getTickCount();

	farn->calc(d_frame0, d_frame1, d_flow);

	//double timeSec = (getTickCount() - start) / getTickFrequency();
	//cout << "Farn : " << timeSec << " sec" << endl;

	showFlow("Farn", d_flow);
}

//TVL1光流法
static void optical_flow_TVL1(const Mat &frame0, const Mat &frame1)
{
	static GpuMat d_frame0;
	static GpuMat d_frame1;

	d_frame0.upload(frame0);
	d_frame1.upload(frame1);

	static GpuMat d_flow(frame0.size(), CV_32FC2);

	static Ptr<cuda::OpticalFlowDual_TVL1> tvl1 = cuda::OpticalFlowDual_TVL1::create();
	//int64 start = getTickCount();

	tvl1->calc(d_frame0, d_frame1, d_flow);

	//double timeSec = (getTickCount() - start) / getTickFrequency();
	//cout << "TVL1 : " << timeSec << " sec" << endl;

	showFlow("TVL1", d_flow);
}

typedef void(*optical_Flow)(const Mat &, const Mat &);
static optical_Flow optical_Flow_Method[] = { optical_flow_Brox, \
optical_flow_LK, \
optical_flow_Farn, \
optical_flow_TVL1, \
NULL };

const char *optical_Flow_Name[] = { "Brox", "LK", "Farn", "TVL1", NULL };

static int getIndexOfOpticalFlowMethod(const char *methodName)
{
	assert(methodName != NULL);
	for (int i = 0; i < sizeof(optical_Flow_Name) / sizeof(*optical_Flow_Name) - 1; i++)
	{
		if (strcmp(methodName, optical_Flow_Name[i]) == 0)
		{
			return i;
		}
	}

	return -1;
}

//fram0前一帧图像，frame1frame1当前帧图像，均为灰度图
void optical_flow(const Mat &frame0, const Mat &frame1, const char *optical_Flow_Name)
{
	static bool isFirstTime = true;
	if (isFirstTime)
	{
		assert(optical_Flow_Name != NULL && !frame0.empty() && !frame1.empty() && frame0.size() == frame1.size());
		isFirstTime = false;
	}
	
	/*if (optical_Flow_Name == NULL)
	{
	cout << "请指定正确的光流方法" << endl;
	return;
	}*/

	//static int methodIndex = getIndexOfOpticalFlowMethod(optical_Flow_Name);
	static int methodIndex = getIndexOfOpticalFlowMethod(optical_Flow_Name);

	assert(methodIndex > -1);
	/*if (methodIndex == -1)
	{
	cout << "请指定正确的光流方法" << endl;
	return;
	}*/

	optical_Flow_Method[methodIndex](frame0, frame1);
}


//main.cpp

#include "bgfg_segm.h"
#include "optical_flow.h"
#include <cuda.h>
#include <cuda_runtime.h>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include "opencv2/highgui.hpp"
#include <iostream>

int main(int argc, char *argv[])
{
	const char *orignalFrameWin = "原始视频帧流";

	//char *fileName = "E:/opencv2.48/sources/samples/gpu/768x576.avi";
	//char *fileName = "D:/FarnebackInGPU/myProject/myProject/data/car/MAH00152.MP4";
	//char *fileName = "D:/FarnebackInGPU/myProject/myProject/data/car/MAH00153.MP4"; 
	//char *fileName = "D:/FarnebackInGPU/myProject/myProject/data/car/20161101050502.MTS";
	//char *fileName = "D:/FarnebackInGPU/myProject/myProject/data/car/MAH00151.MP4";
	char *fileName = "D:/FarnebackInGPU/myProject/myProject/data/car/MAH00158.MP4";
	//const char *fileName = "D:/FarnebackInGPU/myProject/myProject/data/car/MAH00152.MP4";
	//const char *fileName = "D:/FarnebackInGPU/myProject/myProject/data/car/MAH00154.MP4";
	
	Method foregroudExtMethod = MOG;	//FGD_STAT, MOG, MOG2, GMG
	int frames = 0;
	Mat currentFrame, previousFrame;
	Mat currentGrayFrame, previousGrayFrame;
	bool isFirstFrame = true;

	VideoCapture cap;
	cap.open(fileName);
	if (!cap.isOpened())
	{
		fprintf(stderr, "Video can't be opened!\n");
		return 1;
	}

	cudaError_t cudaStatus;
	cudaStatus = cudaSetDevice(0);
	if (cudaStatus != cudaSuccess) {
		fprintf(stderr, "cudaSetDevice failed!  Do you have a CUDA-capable GPU installed?");
		return 1;
	}

	while (cap.isOpened())
	{
		cap >> currentFrame;
		if (!currentFrame.data)
		{
			fprintf(stderr, "Frame is empty!\n");
			break;
		}

		while (currentFrame.cols > 800)
		{
			resize(currentFrame, currentFrame, Size(currentFrame.cols / 2, currentFrame.rows / 2));
		}

		frames++;
		cv::cvtColor(currentFrame, currentGrayFrame, CV_RGB2GRAY);
		std::cout << "第" << frames << "帧" << std::endl;
		imshow(orignalFrameWin, currentFrame);

		if (isFirstFrame)
		{
			swap(currentGrayFrame, previousGrayFrame);
			isFirstFrame = false;
		}
		else
		{
			//计算光流
			//const char *optical_Flow_Method_Name[] = { "Brox", "LK", "Farn", "TVL1", NULL };
			optical_flow(previousGrayFrame, currentGrayFrame, optical_Flow_Name[0]);
			swap(currentGrayFrame, previousGrayFrame);
		}

		//前景提取
		foregroundExtraction(currentFrame, foregroudExtMethod);

		int key = cv::waitKey(1);
		if (key == 27) break;
		else if (key == 'p' || key == 'P') cv::waitKey();
	}
	
	cudaStatus = cudaDeviceReset();
	if (cudaStatus != cudaSuccess)
	{
		fprintf(stderr, "cudaDeviceReset failed!");
		return 1;
	}

	return 0;
}


龚慧林
关注
专栏目录
基于opencv的光流法
04-17
根据提供的文件信息，我们可以归纳出该段代码是关于利用OpenCV库实现光流法（Optical Flow）的一个示例程序。接下来将详细解释这段代码所涉及的重要知识点。 ### 光流法简介 光流法是一种在连续两帧图像之间估计...
OpenCV光流法
04-08
本篇文章将深入探讨OpenCV中的光流法，以及如何利用它来进行图像处理和分析。 光流的基本概念源于视觉运动感知，它描述了图像中像素在时间上的连续运动轨迹。光流法通过估计相邻帧之间的像素变化来捕获物体的动态...
前景提取算法调研
ckqsars的博客
09-26 2622
前景提取算法调研 总结： 前景提取算法，主要是用于在摄像监控中，从视频流数据中剔除不需要分析的背景部分，从而提升算法对视频分析的效果。在前景提取中主要分为两大类，一个是静态的前景提取：即摄像头是固定不动的相对的背景基本是不变化的，另一个时动态前景提取：即摄像头是追踪某个运动的物体背景是随着追踪的物体进行变化的。在本文中，主要是分析静态前景提取的方法。 前景提取的主要有三大难点：1）视频流因光线等因...
opencv--光流跟踪
StruggleToLife的博客
08-13 446
对象跟踪三要素：图像表示，外观模型，移动模型 KLT（Lucas Kanade Tracker）条件：亮度恒定，近距离移动，空间一致性 稀疏光流：Sparse Optical Flow 找到特征点：角点检测法 代码： #include <opencv2/opencv.hpp> #include <iostream> using namespa...
OpenCV与AI深度学习 | 使用OpenCV轮廓检测提取图像前景
最新发布
csdn_xmj的博客
08-16 1046
前景提取是计算机视觉领域中非常流行的任务。使用前景提取方法，我们尝试提取任何我们感兴趣的图像或对象，并丢弃其余的背景。最近基于深度学习的图像分割技术使这变得非常容易。但我们也可以使用纯计算机视觉技术来实现这一点。
opencv计算brox光流_计算机视觉基础——数字图像与颜色空间
weixin_39969232的博客
12-03 353
欢迎大家关注微信公众号：baihuaML，白话机器学习。码字不易，如转载请私信我！！在这里，我们一起分享AI的故事。您可以在后台留言，关于机器学习、深度学习的问题，我们会选择其中的优质问题进行回答！Hello，大家好。白话机器学习新的一个专题又开始了。在本次专题中，我们呼应“白话”这个概念，为大家科普一些简单的计算机视觉的概念，帮助大家扫盲~~~今天我们首先聊一聊——数字图像与颜色空间。我们经常会...
探索OpenCV的光流算法视频超分与源码实现
徐福记456
06-18 2051
​在OpenCV4.0以后，视频图像超分模块已经迁移到opencv_contrib独立仓库。在视频超分有两种形式：结合光流算法实现超分、使用CNN卷积神经网络实现超分。在这里主要探索光流算法实现视频超分，然后进一步分析源码实现。
基于opencv的光流法、帧间差分法、高斯背景模型差分法下实现运动目标检测
05-27
【作品名称】：基于opencv的光流法、帧间差分法、高斯背景模型差分法下实现运动目标检测 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项...
Opencv光流运动物体追踪详解
08-28
Opencv提供了金字塔LK光流算法的实现，通过include "highgui/highgui.hpp"、"opencv2/nonfree/nonfree.hpp"、"opencv2/video/tracking.hpp"头文件，并使用 namespace cv 和 namespace std。该算法可以实现图像跟踪、...
基于Opencv的光流法文献
06-27
OpenCV（开源计算机视觉库）提供了强大的光流法实现，使得开发者和研究人员能够轻松地在C++、Python等语言中应用这一技术。这篇基于OpenCV的光流法文献可能包含了关于理论基础、算法实现、优化技巧以及实际应用等多...
Python实现跟踪、光流、前景检测
02-28
【内附详细说明文档】 本项目是使用python，利用opencv库实现的共8个视频处理算法，包括：目标跟踪算法Meanshift, Camshift；稀疏光流以及稠密光流的计算OpticalFlow, OpticalFlow_full，前景检测算法MOG, CNT, GMG, GSOC,LSBP 。 代码简洁易读，可做为python课设参考资料，或者供图像处理爱好者学习。
前景检测算法_2(帧差法1)（转）
zhang43211234的博客
07-11 1269
原文地址：https://www.cnblogs.com/tornadomeet/archive/2012/05/01/2477629.html　帧差法是背景减图法中的一种，只不过是帧差法不需要建模，因为它的背景模型就是上一帧的图，所以速度非常快，另外帧差法对缓慢变换的光照不是很敏感，所以其用途还是有的，有不少学者对其做出了出色的改进。　　其基本原理可以用下面公式看出：　　|i(t)-i(t-1)...
OpenCV 光流算法加速---使用GPU来计算光流
Marvek的博客
09-02 6351
一、依赖项 OpenCV 2.4.13.x + CUDA 8.0 OpenCV 3.2.0及以上 + CUDA 8.0 OpenCV 3.4.x + CUDA 9.1 OpenCV编译时，需要添加CUDA 支持。安装CUDA 以及OpenCV，可参考我的另外两篇博客 Ubuntu 安装CUDA与OpenCV Ubuntu 编译OpenCV 二、代码 计算稠密光流时，一般使用”cal...
opencv3.10中4种视频前景提取
Gone_HuiLin的博客
11-19 4103
#include #include #include "opencv2/core.hpp" #include "opencv2/core/utility.hpp" #include "opencv2/cudabgsegm.hpp" #include "opencv2/cudalegacy.hpp" #include "opencv2/video.hpp" #include "opencv2/
【opencv】示例-bgfg_segm 背景分割：利用背景减去算法（KNN、MOG2）分离图像中运动物体（前景）和静止背景图像...
cxyhjl的博客
04-05 530
// OpenCV项目的一部分。 // 它遵从分布及 http://opencv.org/license.html 顶级目录下的LICENSE文件中的许可条款 // 包含OpenCV相关头文件 #include "opencv2/core.hpp" #include "opencv2/imgproc.hpp" #include "opencv2/video.hpp" #include "ope...
OpenCV3.0中有哪些视频背景/前景分割(背景建模/前景提取)算法的类,它们各自的算法原理、特点是什么,并附示例代码
昊虹AI笔记
05-26 1847
关于OpenCV3中有哪些视频背景/前景分割(背景建模/前景提取)算法的类，汇总如下： cv::Algorithm   cv::BackgroundSubtractor     cv::BackgroundSubtractorKNN     cv::BackgroundSubtractorMOG2       cv::cuda::BackgroundSubtractorMOG2     cv::bgsegm::BackgroundSubtractorGMG     cv::bgsegm::Backgroun
Farneback光流法检测前景的一个例子
AP1005834的博客
12-15 5517
一、前言 本文使用opencv的calcOpticalFlowFarneback光流法计算图像的运动光流，并显示计算得的光流强度，视频大小为640*480，但速度很慢，计算速度为300ms左右一帧。不知使用GPU版的光流法能快多少。 二、简单的代码 #include #include #include #include using namespace cv; #include #
Opencv 自带提取前景（背景建模）
热门推荐
小松鼠的专栏
03-17 1万+
官方教程源码稍加修改： 读入视频（图片序列）->bei //opencv #include "opencv2/imgcodecs.hpp" #include "opencv2/imgproc.hpp" #include "opencv2/videoio.hpp" #include #include //C #include //C++ #include #include using
使用OpenCV实现光流法视频处理
9. 光流法的实现通常包括特征检测、匹配和优化等步骤，OpenCV库提供了`cvCalcOpticalFlowPyrLK`等函数来简化这一过程。 10. 计算得到的光流信息可以用来分析和显示物体的运动，例如绘制出像素的运动轨迹或者用于...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值