OpenCV环境下CUDA编程示例

企业开发 2018-05-06 18:54:17 阅读次数: 8

在CUDA平台上对图像算法进行并行加速是目前并行计算方面比较简单易行的一种方式，而同时利用OpenCV提供的一些库函数的话，那么事情将会变得更加easy。以下是我个人采用的一种模板，这个模板是从OpenCV里的算法CUDA源码挖掘出来的，我感觉这个用起来比较傲方便，所以经常采用。首先大牛们写的源码都很鲁棒，考虑的比较全面（如大部分算法将1,3,4通道的图像同时搞定），感觉还有一个比较神奇的地方在于CPU端GpuMat和GPU端PtrStepSzb的转换，让我欲罢不能，一个不太理想的地方在于第一帧的初始化时间比较长，应该是CPU到GPU的数据传输。代码中有考虑流，但貌似没有使用。

我使用的是赵开勇的CUDA_VS_Wizard，主函数还是用的cu文件。以下代码是对Vibe背景建模算法的并行，背景建模算法是目前接触到易于并行的一类，如GMM等，而且加速效果不错，因为一个线程执行的数据就是对应一个像素点。

代码如下：

sample.cu

/********************************************************************
*  sample.cu
*  This is a example of the CUDA program.
*********************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <cutil_inline.h>
#include <iostream>
#include <string>
#include "opencv2/core/core.hpp"
#include "opencv2/gpu/gpu.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "Vibe_M_kernel.cu"
#include "Vibe_M.h"
using namespace std;
using namespace cv;
using namespace cv::gpu;

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

int main(int argc, const char** argv)
{
	cv::CommandLineParser cmd(argc, argv,
		"{ c | camera | flase       | use camera }"
		"{ f | file   | 768x576.avi | input video file }"
		"{ m | method | vibe         | method (fgd, mog, mog2, vibe, gmg) }"
		"{ h | help   | false       | print help message }");

	if (cmd.get<bool>("help"))
	{
		cout << "Usage : bgfg_segm [options]" << endl;
		cout << "Avaible options:" << endl;
		cmd.printParams();
		return 0;
	}
	bool useCamera = cmd.get<bool>("camera");
	string file = cmd.get<string>("file");
	string method = cmd.get<string>("method");
	if (method != "fgd" && method != "mog" && method != "mog2" && method != "vibe" && method != "gmg")
	{
		cerr << "Incorrect method" << endl;
		return -1;
	}
	Method m = method == "fgd" ? FGD_STAT : method == "mog" ? MOG : method == "mog2" ? MOG2 : method == "vibe" ? VIBE : GMG;

	VideoCapture cap;
	if (useCamera)
		cap.open(0);
	else
		cap.open(file);
	if (!cap.isOpened())
	{
		cerr << "can not open camera or video file" << endl;
		return -1;
	}
	Mat origin, frame;
	cap >> origin;
	cvtColor(origin,frame,CV_BGR2GRAY);
	GpuMat d_frame(frame);
	Vibe_M vibe;
	GpuMat d_fgmask;

	Mat fgmask;
	Mat fgimg;
	Mat bgimg;

	switch (m)
	{
	case VIBE:
		vibe.initialize(d_frame);
		break;

	}

	namedWindow("image", WINDOW_NORMAL);
	namedWindow("foreground mask", WINDOW_NORMAL);

	for(;;)
	{
		cap >> origin;
		if (origin.empty())
			break;

		cvtColor(origin,frame,CV_BGR2GRAY);

		d_frame.upload(frame);

		//update the model
		switch (m)
		{
		case VIBE:
			vibe(d_frame, d_fgmask);
			break;
		}
		d_fgmask.download(fgmask);

		imshow("image", frame);
		imshow("foreground mask", fgmask);
		int key = waitKey(30);
		if (key == 27)
			break;
		else if(key == ' ')
		{
			cvWaitKey(0);
		}
	}
	exit(0);
}
Vibe_M.cpp 

#include "Vibe_M.h"

namespace cv { namespace gpu { namespace device
{
	namespace vibe_m
	{
		void loadConstants(int nbSamples, int reqMatches, int radius, int subsamplingFactor);

		void init_gpu(PtrStepSzb frame, int cn, PtrStepSzb samples, PtrStepSz<unsigned int> randStates, cudaStream_t stream);

		void update_gpu(PtrStepSzb frame, int cn, PtrStepSzb fgmask, PtrStepSzb samples, PtrStepSz<unsigned int> randStates, cudaStream_t stream);
	}
}}}

namespace
{
	const int defaultNbSamples = 20;
	const int defaultReqMatches = 2;
	const int defaultRadius = 20;
	const int defaultSubsamplingFactor = 16;
}

Vibe_M::Vibe_M(unsigned long rngSeed) :
frameSize_(0, 0), rngSeed_(rngSeed)
{
	nbSamples = defaultNbSamples;
	reqMatches = defaultReqMatches;
	radius = defaultRadius;
	subsamplingFactor = defaultSubsamplingFactor;
}

void Vibe_M::initialize(const GpuMat& firstFrame, Stream& s)
{
	using namespace cv::gpu::device::vibe_m;

	CV_Assert(firstFrame.type() == CV_8UC1 || firstFrame.type() == CV_8UC3 || firstFrame.type() == CV_8UC4);

	//cudaStream_t stream = StreamAccessor::getStream(s);

	loadConstants(nbSamples, reqMatches, radius, subsamplingFactor);

	frameSize_ = firstFrame.size();

	if (randStates_.size() != frameSize_)
	{
		cv::RNG rng(rngSeed_);
		cv::Mat h_randStates(frameSize_, CV_8UC4);
		rng.fill(h_randStates, cv::RNG::UNIFORM, 0, 255);
		randStates_.upload(h_randStates);
	}

	int ch = firstFrame.channels();
	int sample_ch = ch == 1 ? 1 : 4;

	samples_.create(nbSamples * frameSize_.height, frameSize_.width, CV_8UC(sample_ch));

	init_gpu(firstFrame, ch, samples_, randStates_, 0);
}

void Vibe_M::operator()(const GpuMat& frame, GpuMat& fgmask, Stream& s)
{
	using namespace cv::gpu::device::vibe_m;

	CV_Assert(frame.depth() == CV_8U);

	int ch = frame.channels();
	int sample_ch = ch == 1 ? 1 : 4;

	if (frame.size() != frameSize_ || sample_ch != samples_.channels())
		initialize(frame);

	fgmask.create(frameSize_, CV_8UC1);

	update_gpu(frame, ch, fgmask, samples_, randStates_, StreamAccessor::getStream(s));
}

void Vibe_M::release()
{
	frameSize_ = Size(0, 0);

	randStates_.release();

	samples_.release();
}
Vibe_M.h 

#ifndef _VIBE_M_H_
#define _VIBE_M_H_
#ifndef SKIP_INCLUDES
#include <vector>
#include <memory>
#include <iosfwd>
#endif
#include "opencv2/core/core.hpp"
#include "opencv2/core/gpumat.hpp"
#include "opencv2/gpu/gpu.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/features2d/features2d.hpp"
using namespace std;
using namespace cv;
using namespace cv::gpu;

class  Vibe_M
{
public:
	//! the default constructor
	explicit Vibe_M(unsigned long rngSeed = 1234567);
	//! re-initiaization method
	void initialize(const GpuMat& firstFrame, Stream& stream = Stream::Null());
	//! the update operator
	void operator()(const GpuMat& frame, GpuMat& fgmask, Stream& stream = Stream::Null());
	//! releases all inner buffers
	void release();
	int nbSamples;         // number of samples per pixel
	int reqMatches;        // #_min
	int radius;            // R
	int subsamplingFactor; // amount of random subsampling

private:
	Size frameSize_;
	unsigned long rngSeed_;
	GpuMat randStates_;
	GpuMat samples_;
};

#endif
Vibe_M.cu 

#include "Vibe_M.h"
#include "opencv2/gpu/stream_accessor.hpp"

namespace cv { namespace gpu { namespace device
{
	namespace vibe_m
	{
		void loadConstants(int nbSamples, int reqMatches, int radius, int subsamplingFactor);

		void init_gpu(PtrStepSzb frame, int cn, PtrStepSzb samples, PtrStepSz<unsigned int> randStates, cudaStream_t stream);

		void update_gpu(PtrStepSzb frame, int cn, PtrStepSzb fgmask, PtrStepSzb samples, PtrStepSz<unsigned int> randStates, cudaStream_t stream);
	}
}}}

namespace
{
	const int defaultNbSamples = 20;
	const int defaultReqMatches = 2;
	const int defaultRadius = 20;
	const int defaultSubsamplingFactor = 16;
}

Vibe_M::Vibe_M(unsigned long rngSeed) :
frameSize_(0, 0), rngSeed_(rngSeed)
{
	nbSamples = defaultNbSamples;
	reqMatches = defaultReqMatches;
	radius = defaultRadius;
	subsamplingFactor = defaultSubsamplingFactor;
}

void Vibe_M::initialize(const GpuMat& firstFrame, Stream& s)
{
	using namespace cv::gpu::device::vibe_m;

	CV_Assert(firstFrame.type() == CV_8UC1 || firstFrame.type() == CV_8UC3 || firstFrame.type() == CV_8UC4);

	cudaStream_t stream = cv::gpu::StreamAccessor::getStream(s);

	loadConstants(nbSamples, reqMatches, radius, subsamplingFactor);

	frameSize_ = firstFrame.size();

	if (randStates_.size() != frameSize_)
	{
		cv::RNG rng(rngSeed_);
		cv::Mat h_randStates(frameSize_, CV_8UC4);
		rng.fill(h_randStates, cv::RNG::UNIFORM, 0, 255);
		randStates_.upload(h_randStates);
	}

	int ch = firstFrame.channels();
	int sample_ch = ch == 1 ? 1 : 4;

	samples_.create(nbSamples * frameSize_.height, frameSize_.width, CV_8UC(sample_ch));

	init_gpu(firstFrame, ch, samples_, randStates_, stream);
}

void Vibe_M::operator()(const GpuMat& frame, GpuMat& fgmask, Stream& s)
{
	using namespace cv::gpu::device::vibe_m;

	CV_Assert(frame.depth() == CV_8U);

	int ch = frame.channels();
	int sample_ch = ch == 1 ? 1 : 4;

	if (frame.size() != frameSize_ || sample_ch != samples_.channels())
		initialize(frame);

	fgmask.create(frameSize_, CV_8UC1);

	update_gpu(frame, ch, fgmask, samples_, randStates_, cv::gpu::StreamAccessor::getStream(s));
}

void Vibe_M::release()
{
	frameSize_ = Size(0, 0);

	randStates_.release();

	samples_.release();
}
Vibe_M_kernel.cu 

#include "opencv2/gpu/device/common.hpp"
#include "opencv2/gpu/device/vec_math.hpp"

namespace cv { namespace gpu { namespace device
{
	namespace vibe_m
	{
		__constant__ int c_nbSamples;
		__constant__ int c_reqMatches;
		__constant__ int c_radius;
		__constant__ int c_subsamplingFactor;

		void loadConstants(int nbSamples, int reqMatches, int radius, int subsamplingFactor)
		{
			cudaSafeCall( cudaMemcpyToSymbol(c_nbSamples, &nbSamples, sizeof(int)) );
			cudaSafeCall( cudaMemcpyToSymbol(c_reqMatches, &reqMatches, sizeof(int)) );
			cudaSafeCall( cudaMemcpyToSymbol(c_radius, &radius, sizeof(int)) );                        
			cudaSafeCall( cudaMemcpyToSymbol(c_subsamplingFactor, &subsamplingFactor, sizeof(int)) );
		}

		__device__ __forceinline__ uint nextRand(uint& state)
		{
			//const unsigned int CV_RNG_COEFF = 4164903690U;//已经定义
			state = state * CV_RNG_COEFF + (state >> 16);
			return state;
		}

		__constant__ int c_xoff[9] = {-1,  0,  1, -1, 1, -1, 0, 1, 0};
		__constant__ int c_yoff[9] = {-1, -1, -1,  0, 0,  1, 1, 1, 0};

		__device__ __forceinline__ int2 chooseRandomNeighbor(int x, int y, uint& randState, int count = 8)
		{
			int idx = nextRand(randState) % count;

			return make_int2(x + c_xoff[idx], y + c_yoff[idx]);
		}

		__device__ __forceinline__ uchar cvt(uchar val)
		{
			return val;
		}
		__device__ __forceinline__ uchar4 cvt(const uchar3& val)
		{
			return make_uchar4(val.x, val.y, val.z, 0);
		}
		__device__ __forceinline__ uchar4 cvt(const uchar4& val)
		{
			return val;
		}

		template <typename SrcT, typename SampleT>
		__global__ void init(const PtrStepSz<SrcT> frame, PtrStep<SampleT> samples, PtrStep<uint> randStates)
		{
			const int x = blockIdx.x * blockDim.x + threadIdx.x;
			const int y = blockIdx.y * blockDim.y + threadIdx.y;

			if (x >= frame.cols || y >= frame.rows)
				return;

			uint localState = randStates(y, x);

			for (int k = 0; k < c_nbSamples; ++k)
			{
				int2 np = chooseRandomNeighbor(x, y, localState, 9);

				np.x = ::max(0, ::min(np.x, frame.cols - 1));
				np.y = ::max(0, ::min(np.y, frame.rows - 1));

				SrcT pix = frame(np.y, np.x);

				samples(k * frame.rows + y, x) = cvt(pix);
			}

			randStates(y, x) = localState;
		}

		template <typename SrcT, typename SampleT>
		void init_caller(PtrStepSzb frame, PtrStepSzb samples, PtrStepSz<uint> randStates, cudaStream_t stream)
		{
			dim3 block(32, 8);
			dim3 grid(divUp(frame.cols, block.x), divUp(frame.rows, block.y));

			cudaSafeCall( cudaFuncSetCacheConfig(init<SrcT, SampleT>, cudaFuncCachePreferL1) );

			init<SrcT, SampleT><<<grid, block, 0, stream>>>((PtrStepSz<SrcT>) frame, (PtrStepSz<SampleT>) samples, randStates);
			cudaSafeCall( cudaGetLastError() );

			if (stream == 0)
				cudaSafeCall( cudaDeviceSynchronize() );
		}

		void init_gpu(PtrStepSzb frame, int cn, PtrStepSzb samples, PtrStepSz<uint> randStates, cudaStream_t stream)
		{
			typedef void (*func_t)(PtrStepSzb frame, PtrStepSzb samples, PtrStepSz<uint> randStates, cudaStream_t stream);
			static const func_t funcs[] =
			{
				0, init_caller<uchar, uchar>, 0, init_caller<uchar3, uchar4>, init_caller<uchar4, uchar4>
			};

			funcs[cn](frame, samples, randStates, stream);
		}

		__device__ __forceinline__ int calcDist(uchar a, uchar b)
		{
			return ::abs(a - b);
		}
		__device__ __forceinline__ int calcDist(const uchar3& a, const uchar4& b)
		{
			return (::abs(a.x - b.x) + ::abs(a.y - b.y) + ::abs(a.z - b.z)) / 3;
		}
		__device__ __forceinline__ int calcDist(const uchar4& a, const uchar4& b)
		{
			return (::abs(a.x - b.x) + ::abs(a.y - b.y) + ::abs(a.z - b.z)) / 3;
		}

		template <typename SrcT, typename SampleT>
		__global__ void update(const PtrStepSz<SrcT> frame, PtrStepb fgmask, PtrStep<SampleT> samples, PtrStep<uint> randStates)
		{
			const int x = blockIdx.x * blockDim.x + threadIdx.x;
			const int y = blockIdx.y * blockDim.y + threadIdx.y;

			if (x >= frame.cols || y >= frame.rows)
				return;

			uint localState = randStates(y, x);

			SrcT imgPix = frame(y, x);

			// comparison with the model

			int count = 0;
			for (int k = 0; (count < c_reqMatches) && (k < c_nbSamples); ++k)
			{
				SampleT samplePix = samples(k * frame.rows + y, x);

				int distance = calcDist(imgPix, samplePix);

				if (distance < c_radius)
					++count;
			}

			// pixel classification according to reqMatches

			fgmask(y, x) = (uchar) (-(count < c_reqMatches));//当count<2时，为前景 当计数器count>=2时，为背景

			if (count >= c_reqMatches)
			{
				// the pixel belongs to the background

				// gets a random number between 0 and subsamplingFactor-1
				int randomNumber = nextRand(localState) % c_subsamplingFactor;

				// update of the current pixel model
				if (randomNumber == 0)
				{
					// random subsampling

					int k = nextRand(localState) % c_nbSamples;

					samples(k * frame.rows + y, x) = cvt(imgPix);
				}

				// update of a neighboring pixel model
				randomNumber = nextRand(localState) % c_subsamplingFactor;

				if (randomNumber == 0)
				{
					// random subsampling

					// chooses a neighboring pixel randomly
					int2 np = chooseRandomNeighbor(x, y, localState);

					np.x = ::max(0, ::min(np.x, frame.cols - 1));
					np.y = ::max(0, ::min(np.y, frame.rows - 1));

					// chooses the value to be replaced randomly
					int k = nextRand(localState) % c_nbSamples;
					samples(k * frame.rows + np.y, np.x) = cvt(imgPix);
				}
			}

			randStates(y, x) = localState;
		}

		template <typename SrcT, typename SampleT>
		void update_caller(PtrStepSzb frame, PtrStepSzb fgmask, PtrStepSzb samples, PtrStepSz<uint> randStates, cudaStream_t stream)
		{
			dim3 block(32, 8);
			dim3 grid(divUp(frame.cols, block.x), divUp(frame.rows, block.y));

			cudaSafeCall( cudaFuncSetCacheConfig(update<SrcT, SampleT>, cudaFuncCachePreferL1) );

			update<SrcT, SampleT><<<grid, block, 0, stream>>>((PtrStepSz<SrcT>) frame, fgmask, (PtrStepSz<SampleT>) samples, randStates);
			cudaSafeCall( cudaGetLastError() );

			if (stream == 0)
				cudaSafeCall( cudaDeviceSynchronize() );
		}

		void update_gpu(PtrStepSzb frame, int cn, PtrStepSzb fgmask, PtrStepSzb samples, PtrStepSz<uint> randStates, cudaStream_t stream)
		{
			typedef void (*func_t)(PtrStepSzb frame, PtrStepSzb fgmask, PtrStepSzb samples, PtrStepSz<uint> randStates, cudaStream_t stream);
			static const func_t funcs[] =
			{
				0, update_caller<uchar, uchar>, 0, update_caller<uchar3, uchar4>, update_caller<uchar4, uchar4>
			};

			funcs[cn](frame, fgmask, samples, randStates, stream);
		}
	}
}}}



猜你喜欢

转载自blog.csdn.net/lucky_greenegg/article/details/9142219
今日推荐
Linus “吃狗粮”最积极！
开源日报 | Winamp播放器即将开源；生成式AI之战升级第二轮；Linus“吃狗粮”最积极；AI进入泡沫前期；吴泳铭为阿里云带来了什么？
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
周排行
SVN服务端安装在阿里云
实战 | 相机标定
webpack核心概念
note20——》只要肯低头吃苦，人生就会有救
PAT甲级 1062 Talent and Virtue （25 分）排序
NG Toolset开发笔记--5GNR Resource Grid（26）
如何对待上司
oracle命令
第9章 STL迭代器
logstash使用es映射模板
每日归档
更多
2024-05-20(36)
2024-05-19(0)
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022