基于opencv的gpu与cpu对比程序，代码来自opencv的文档中

原文链接：

http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/gpu/gpu-basics-similarity/gpu-basics-similarity.html

代码中有错误，关于GpuMat OpenCV代码中没有对其进行操作符运算的重载，所有编译的时候有错误。对于GpuMat的运算只能调用相关函数才行，后面我嫌麻烦就没有重写

<span style="font-size:18px;">// PSNR.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include <iostream>                   // Console I/O

#include <sstream>                    // String to number conversion

#include <opencv2/core/core.hpp>      // Basic OpenCV structures

#include <opencv2/imgproc/imgproc.hpp>// Image processing methods for the CPU

#include <opencv2/highgui/highgui.hpp>// Read images

#include <opencv2/gpu/gpu.hpp>        // GPU structures and methods

using namespace std;

using namespace cv;

double getPSNR(const Mat& I1, const Mat& I2);      // CPU versions

Scalar getMSSIM( const Mat& I1, const Mat& I2);

double getPSNR_GPU(const Mat& I1, const Mat& I2);  // Basic GPU versions

Scalar getMSSIM_GPU( const Mat& I1, const Mat& I2);

struct BufferPSNR                                     // Optimized GPU versions

{   // Data allocations are very expensive on GPU. Use a buffer to solve: allocate once reuse later.

	gpu::GpuMat gI1, gI2, gs, t1,t2;

	gpu::GpuMat buf;

};

double getPSNR_GPU_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b);

struct BufferMSSIM                                     // Optimized GPU versions

{   // Data allocations are very expensive on GPU. Use a buffer to solve: allocate once reuse later.

	gpu::GpuMat gI1, gI2, gs, t1,t2;

	gpu::GpuMat I1_2, I2_2, I1_I2;

	vector<gpu::GpuMat> vI1, vI2;

	gpu::GpuMat mu1, mu2;

	gpu::GpuMat mu1_2, mu2_2, mu1_mu2; 

	gpu::GpuMat sigma1_2, sigma2_2, sigma12;

	gpu::GpuMat t3; 

	gpu::GpuMat ssim_map;

	gpu::GpuMat buf;

};

Scalar getMSSIM_GPU_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b);

void help()

{

	cout

		<< "\n--------------------------------------------------------------------------" << endl

		<< "This program shows how to port your CPU code to GPU or write that from scratch." << endl

		<< "You can see the performance improvement for the similarity check methods (PSNR and SSIM)."  << endl

		<< "Usage:"                                                               << endl

		<< "./gpu-basics-similarity referenceImage comparedImage numberOfTimesToRunTest(like 10)." << endl

		<< "--------------------------------------------------------------------------"   << endl

		<< endl;

}

int main(int argc, char *argv[])

{

	help();

	Mat I1 = imread("swan1.jpg",1);           // Read the two images

	Mat I2 = imread("swan2.jpg",1);

	if (!I1.data || !I2.data)           // Check for success

	{

		cout << "Couldn't read the image";

		return 0;

	}

	BufferPSNR bufferPSNR;

	BufferMSSIM bufferMSSIM;

	int TIMES;

	stringstream sstr("500");

	sstr >> TIMES;

	double time, result;

	//------------------------------- PSNR CPU ----------------------------------------------------

	time = (double)getTickCount();    

	for (int i = 0; i < TIMES; ++i)

		result = getPSNR(I1,I2);

	time = 1000*((double)getTickCount() - time)/getTickFrequency();

	time /= TIMES;

	cout << "Time of PSNR CPU (averaged for " << TIMES << " runs): " << time << " milliseconds."

		<< " With result of: " <<  result << endl; 

	//------------------------------- PSNR GPU ----------------------------------------------------

	time = (double)getTickCount();    

	for (int i = 0; i < TIMES; ++i)

		result = getPSNR_GPU(I1,I2);

	time = 1000*((double)getTickCount() - time)/getTickFrequency();

	time /= TIMES;

	cout << "Time of PSNR GPU (averaged for " << TIMES << " runs): " << time << " milliseconds."

		<< " With result of: " <<  result << endl;

/*

	//------------------------------- PSNR GPU Optimized--------------------------------------------

	time = (double)getTickCount();                                  // Initial call

	result = getPSNR_GPU_optimized(I1, I2, bufferPSNR);

	time = 1000*((double)getTickCount() - time)/getTickFrequency();

	cout << "Initial call GPU optimized:              " << time  <<" milliseconds."

		<< " With result of: " << result << endl;

	time = (double)getTickCount();

	for (int i = 0; i < TIMES; ++i)

		result = getPSNR_GPU_optimized(I1, I2, bufferPSNR);

	time = 1000*((double)getTickCount() - time)/getTickFrequency();

	time /= TIMES;

	cout << "Time of PSNR GPU OPTIMIZED ( / " << TIMES << " runs): " << time

		<< " milliseconds." << " With result of: " <<  result << endl << endl; 

	//------------------------------- SSIM CPU -----------------------------------------------------

	Scalar x;

	time = (double)getTickCount();    

	for (int i = 0; i < TIMES; ++i)

		x = getMSSIM(I1,I2);

	time = 1000*((double)getTickCount() - time)/getTickFrequency();

	time /= TIMES;

	cout << "Time of MSSIM CPU (averaged for " << TIMES << " runs): " << time << " milliseconds."

		<< " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; 

	//------------------------------- SSIM GPU -----------------------------------------------------

	time = (double)getTickCount();    

	for (int i = 0; i < TIMES; ++i)

		x = getMSSIM_GPU(I1,I2);

	time = 1000*((double)getTickCount() - time)/getTickFrequency();

	time /= TIMES;

	cout << "Time of MSSIM GPU (averaged for " << TIMES << " runs): " << time << " milliseconds."

		<< " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; 

	//------------------------------- SSIM GPU Optimized--------------------------------------------

	time = (double)getTickCount();

	x = getMSSIM_GPU_optimized(I1,I2, bufferMSSIM);

	time = 1000*((double)getTickCount() - time)/getTickFrequency();

	cout << "Time of MSSIM GPU Initial Call            " << time << " milliseconds."

		<< " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; 

	time = (double)getTickCount();    

	for (int i = 0; i < TIMES; ++i)

		x = getMSSIM_GPU_optimized(I1,I2, bufferMSSIM);

	time = 1000*((double)getTickCount() - time)/getTickFrequency();

	time /= TIMES;

	cout << "Time of MSSIM GPU OPTIMIZED ( / " << TIMES << " runs): " << time << " milliseconds."

		<< " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl << endl;

	return 0;

	*/

	getchar();

}

double getPSNR(const Mat& I1, const Mat& I2)

{

	Mat s1;

	absdiff(I1, I2, s1);       // |I1 - I2|

	s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits

	s1 = s1.mul(s1);           // |I1 - I2|^2

	Scalar s = sum(s1);         // sum elements per channel

	double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels

	if( sse <= 1e-10) // for small values return zero

		return 0;

	else

	{

		double  mse =sse /(double)(I1.channels() * I1.total());

		double psnr = 10.0*log10((255*255)/mse);

		return psnr;

	}

}

double getPSNR_GPU_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b)

{

	b.gI1.upload(I1);

	b.gI2.upload(I2);

	b.gI1.convertTo(b.t1, CV_32F);

	b.gI2.convertTo(b.t2, CV_32F);

	gpu::absdiff(b.t1.reshape(1), b.t2.reshape(1), b.gs);

	gpu::multiply(b.gs, b.gs, b.gs);

	double sse = gpu::sum(b.gs, b.buf)[0];

	if( sse <= 1e-10) // for small values return zero

		return 0;

	else

	{

		double mse = sse /(double)(I1.channels() * I1.total());

		double psnr = 10.0*log10((255*255)/mse);

		return psnr;

	}

}

double getPSNR_GPU(const Mat& I1, const Mat& I2)

{

	gpu::GpuMat gI1, gI2, gs, t1,t2; 

	gI1.upload(I1);

	gI2.upload(I2);

	gI1.convertTo(t1, CV_32F);

	gI2.convertTo(t2, CV_32F);

	gpu::absdiff(t1.reshape(1), t2.reshape(1), gs);

	gpu::multiply(gs, gs, gs);

	Scalar s = gpu::sum(gs);

	double sse = s.val[0] + s.val[1] + s.val[2];

	if( sse <= 1e-10) // for small values return zero

		return 0;

	else

	{

		double  mse =sse /(double)(gI1.channels() * I1.total());

		double psnr = 10.0*log10((255*255)/mse);

		return psnr;

	}

}

Scalar getMSSIM( const Mat& i1, const Mat& i2)

{

	const double C1 = 6.5025, C2 = 58.5225;

	/***************************** INITS **********************************/

	int d     = CV_32F;

	Mat I1, I2;

	i1.convertTo(I1, d);           // cannot calculate on one byte large values

	i2.convertTo(I2, d); 

	Mat I2_2   = I2.mul(I2);        // I2^2

	Mat I1_2   = I1.mul(I1);        // I1^2

	Mat I1_I2  = I1.mul(I2);        // I1 * I2

	/*************************** END INITS **********************************/

	Mat mu1, mu2;   // PRELIMINARY COMPUTING

	GaussianBlur(I1, mu1, Size(11, 11), 1.5);

	GaussianBlur(I2, mu2, Size(11, 11), 1.5);

	Mat mu1_2   =   mu1.mul(mu1);

	Mat mu2_2   =   mu2.mul(mu2);

	Mat mu1_mu2 =   mu1.mul(mu2);

	Mat sigma1_2, sigma2_2, sigma12; 

	GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);

	sigma1_2 -= mu1_2;

	GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);

	sigma2_2 -= mu2_2;

	GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);

	sigma12 -= mu1_mu2;

	///////////////////////////////// FORMULA ////////////////////////////////

	Mat t1, t2, t3; 

	t1 = 2 * mu1_mu2 + C1;

	t2 = 2 * sigma12 + C2;

	t3 = t1.mul(t2);              // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))

	t1 = mu1_2 + mu2_2 + C1;

	t2 = sigma1_2 + sigma2_2 + C2;

	t1 = t1.mul(t2);               // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))

	Mat ssim_map;

	divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;

	Scalar mssim = mean( ssim_map ); // mssim = average of ssim map

	return mssim;

}

Scalar getMSSIM_GPU( const Mat& i1, const Mat& i2)

{

	const float C1 = 6.5025f, C2 = 58.5225f;

	/***************************** INITS **********************************/

	gpu::GpuMat gI1, gI2, gs1, t1,t2; 

	gI1.upload(i1);

	gI2.upload(i2);

	gI1.convertTo(t1, CV_MAKE_TYPE(CV_32F, gI1.channels()));

	gI2.convertTo(t2, CV_MAKE_TYPE(CV_32F, gI2.channels()));

	vector<gpu::GpuMat> vI1, vI2;

	gpu::split(t1, vI1);

	gpu::split(t2, vI2);

	Scalar mssim;

	for( int i = 0; i < gI1.channels(); ++i )

	{

		gpu::GpuMat I2_2, I1_2, I1_I2; 

		gpu::multiply(vI2[i], vI2[i], I2_2);        // I2^2

		gpu::multiply(vI1[i], vI1[i], I1_2);        // I1^2

		gpu::multiply(vI1[i], vI2[i], I1_I2);       // I1 * I2

		/*************************** END INITS **********************************/

		gpu::GpuMat mu1, mu2;   // PRELIMINARY COMPUTING

		gpu::GaussianBlur(vI1[i], mu1, Size(11, 11), 1.5);

		gpu::GaussianBlur(vI2[i], mu2, Size(11, 11), 1.5);

		gpu::GpuMat mu1_2, mu2_2, mu1_mu2;

		gpu::multiply(mu1, mu1, mu1_2);

		gpu::multiply(mu2, mu2, mu2_2);

		gpu::multiply(mu1, mu2, mu1_mu2);   

		gpu::GpuMat sigma1_2, sigma2_2, sigma12; 

		gpu::GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);

		//sigma1_2 = sigma1_2 - mu1_2;

		gpu::subtract(sigma1_2,mu1_2,sigma1_2);

		gpu::GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);

		//sigma2_2 = sigma2_2 - mu2_2;

		gpu::GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);

		(Mat)sigma12 =(Mat)sigma12 - (Mat)mu1_mu2;

		//sigma12 = sigma12 - mu1_mu2

		///////////////////////////////// FORMULA ////////////////////////////////

		gpu::GpuMat t1, t2, t3; 

// 		t1 = 2 * mu1_mu2 + C1;

// 		t2 = 2 * sigma12 + C2;

// 		gpu::multiply(t1, t2, t3);     // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))

//

// 		t1 = mu1_2 + mu2_2 + C1;

// 		t2 = sigma1_2 + sigma2_2 + C2;

// 		gpu::multiply(t1, t2, t1);     // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))

		gpu::GpuMat ssim_map;

		gpu::divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;

		Scalar s = gpu::sum(ssim_map);

		mssim.val[i] = s.val[0] / (ssim_map.rows * ssim_map.cols);

	}

	return mssim;

}

Scalar getMSSIM_GPU_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b)

{

	int cn = i1.channels();

	const float C1 = 6.5025f, C2 = 58.5225f;

	/***************************** INITS **********************************/

	b.gI1.upload(i1);

	b.gI2.upload(i2);

	gpu::Stream stream;

	stream.enqueueConvert(b.gI1, b.t1, CV_32F);

	stream.enqueueConvert(b.gI2, b.t2, CV_32F);      

	gpu::split(b.t1, b.vI1, stream);

	gpu::split(b.t2, b.vI2, stream);

	Scalar mssim;

	for( int i = 0; i < b.gI1.channels(); ++i )

	{

		gpu::multiply(b.vI2[i], b.vI2[i], b.I2_2, stream);        // I2^2

		gpu::multiply(b.vI1[i], b.vI1[i], b.I1_2, stream);        // I1^2

		gpu::multiply(b.vI1[i], b.vI2[i], b.I1_I2, stream);       // I1 * I2

		//gpu::GaussianBlur(b.vI1[i], b.mu1, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);

		//gpu::GaussianBlur(b.vI2[i], b.mu2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);

		gpu::multiply(b.mu1, b.mu1, b.mu1_2, stream);

		gpu::multiply(b.mu2, b.mu2, b.mu2_2, stream);

		gpu::multiply(b.mu1, b.mu2, b.mu1_mu2, stream);   

		//gpu::GaussianBlur(b.I1_2, b.sigma1_2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);

		//gpu::subtract(b.sigma1_2, b.mu1_2, b.sigma1_2, stream);

		//b.sigma1_2 -= b.mu1_2;  - This would result in an extra data transfer operation

		//gpu::GaussianBlur(b.I2_2, b.sigma2_2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);

		//gpu::subtract(b.sigma2_2, b.mu2_2, b.sigma2_2, stream);

		//b.sigma2_2 -= b.mu2_2;

		//gpu::GaussianBlur(b.I1_I2, b.sigma12, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);

		//gpu::subtract(b.sigma12, b.mu1_mu2, b.sigma12, stream);

		//b.sigma12 -= b.mu1_mu2;

		//here too it would be an extra data transfer due to call of operator*(Scalar, Mat)

		gpu::multiply(b.mu1_mu2, 2, b.t1, stream); //b.t1 = 2 * b.mu1_mu2 + C1;

		//gpu::add(b.t1, C1, b.t1, stream);

		gpu::multiply(b.sigma12, 2, b.t2, stream); //b.t2 = 2 * b.sigma12 + C2;

		//gpu::add(b.t2, C2, b.t2, stream);     

		gpu::multiply(b.t1, b.t2, b.t3, stream);     // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))

		//gpu::add(b.mu1_2, b.mu2_2, b.t1, stream);

		//gpu::add(b.t1, C1, b.t1, stream);

		//gpu::add(b.sigma1_2, b.sigma2_2, b.t2, stream);

		//gpu::add(b.t2, C2, b.t2, stream);

		gpu::multiply(b.t1, b.t2, b.t1, stream);     // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))

		gpu::divide(b.t3, b.t1, b.ssim_map, stream);      // ssim_map =  t3./t1;

		stream.waitForCompletion();

		Scalar s = gpu::sum(b.ssim_map, b.buf);

		mssim.val[i] = s.val[0] / (b.ssim_map.rows * b.ssim_map.cols);

	}

	return mssim;

}</span>

实现效果：

基于opencv的gpu与cpu对比程序，代码来自opencv的文档中的更多相关文章

C# 基于NPOI+Office COM组件实现20行代码在线预览文档（word，excel，pdf，txt，png）
由于项目需要,需要一个在线预览office的功能,小编一开始使用的是微软提供的方法,简单快捷,但是不符合小编开发需求, 就另外用了:将文件转换成html文件然后预览html文件的方法.对微软提供的方法 ...
关于运行“基于极限学习机ELM的人脸识别程序”代码犯下的一些错误
代码来源基于极限学习机ELM的人脸识别程序感谢文章主的分享我的环境是 win10 anaconda Command line client (version 1.6.5)(conda 4.3.3 ...
创建MFC应用程序的类型：单文档+多文档+基于对话框
单文档支持文档视图架构.数据的保存--(读取--改动)文档类功能--显示(视图类功能),比較方便. 基于对话框,主窗体是对话框类型.能够方便的使用控件,所见即所得的编程,比較方便. 单文档类似&quo ...
MFC多文档中opencv处理图像打开、保存
需要在C**Doc和C**View中进行相应修改图像打开: Doc.cpp中: BOOL CCVMFCDoc::Load(IplImage** pp, LPCTSTR csFilename) { I ...
基于数据库的自动化生成工具，自动生成JavaBean、数据库文档、框架代码等(v5.8.8版)
TableGo v5.8.8版震撼发布,此次版本更新如下: 1.新增两个扩展字段,用于生成自定义模板时使用. 2.自定义模板新增模板目录,可以选择不同分类目录下的模 ...
c语言小程序以及java生成注释文档方法
c语言小程序:sizeof和strlen() sizeof运算符以字节为单位给出数据的大小,strlen()函数以字符为单位给出字符串的长度,字符和字节不是一回事. char类型用于存储字母和标点符号 ...
JDBC Java 程序从 MySQL 数据库中读取数据，并备份到 xml 文档中
MySQL 版本:Server version: 5.7.17-log MySQL Community Server (GPL) 相关内容:JDBC Java 程序从 MySQL 数据库中读取数据,并 ...
Caffe常用算子GPU和CPU对比
通过整理LeNet.AlexNet.VGG16.googLeNet.ResNet.MLP统计出的常用算子(不包括ReLU),表格是对比. Prelu Cpu版 Gpu版 for (int i = 0; ...
【opencv入门篇】 10个程序快速上手opencv【下】
导言:本系列博客目的在于能够在vs快速上手opencv,理论知识涉及较少,大家有兴趣可以查阅其他博客深入了解相关的理论知识,本博客后续也会对图像方向的理论进一步分析,敬请期待:) 上篇传送:http: ...

随机推荐

1QPushButton的使用，QLineEdit的使用，设置组件位置，布局（QHBoxLayout，QGridLayout）
1.新建一个空Qt项目 2 新建一个新的文件(右击项目à添加新文件) 3 配置pro文件属性 SOURCES += \ main.cpp QT += widgets gui 4 编写main.c ...
通过一个color创建一个image
使用的地方: [_addButton setBackgroundImage:[UIImage imageWithColor:[[UIColor whiteColor] colorWithAlphaCo ...
最详细的制作正式版10.11 OS X El Capitan 安装U盘的方法
原帖地址:http://bbs.feng.com/read-htm-tid-10036487.html 一.准备工作: 1.准备一个 8GB 或以上容量的 U 盘,确保里面的数据已经妥善备份好(该过程 ...
Centos中git的安装
CentOS的yum源中没有git,只能自己编译安装,现在记录下编译安装的内容,留给自己备忘. 确保已安装了依赖的包 yum install curl yum install curl-deve ...
UNIX网络编程——客户/服务器程序设计示范（总结）
(1)当系统负载较轻是,每来一个客户请求现场派生一个子进程为之服务的传统并发服务器程序模型就足够了.这个模型甚至可以与inetd结合使用,也就是inetd处理每个连接的接收.我们的其他意见是就重负荷运 ...
UNIX网络编程——设置套接字超时
在涉及套接字的I/O操作上设置超时的方法有以下3种: 调用alarm,它在指定超时期时产生SIGALRM信号.这个方法涉及信号处理,而信号处理在不同的实现上存在差异,而且可能干扰进程中现有的alarm ...
Android开发学习之路--UI之初体验
之前都是学习Activity,对于布局都没有做过学习,这里就简单学习下吧.下面看下Android Studio下有哪些控件: 这里分为Widgets,Text Fields,Containers,Da ...
【一天一道LeetCode】#344. Reverse String
一天一道LeetCode 本系列文章已全部上传至我的github,地址:ZeeCoder's Github 欢迎大家关注我的新浪微博,我的新浪微博欢迎转载,转载请注明出处 (一)题目 Write a ...
svn 回退/更新/取消至某个版本命令详解
1. 取消Add/Delete 取消文件 svn revert 文件名取消目录 svn revert --depth=infinity 目录名 2. 回退版本方法1: 用svn merge 1) ...
欢迎进入我的个人博客 anzhan.me
CSDN的博客依旧会更新,但是还是专注于技术. 个人的博客 http://anzhan.me 不单单会同步csdn的技术文章,还会有个人的更多私人的分享,包括旅行日记.欢迎各位朋友经常去看看,大家有私 ...

基于opencv的gpu与cpu对比程序，代码来自opencv的文档中

基于opencv的gpu与cpu对比程序，代码来自opencv的文档中的更多相关文章

随机推荐

热门专题