update some of the functions in ocl module to the latest version

modules/ocl/perf/test_blend.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfang Bai, fangfang@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <iomanip>
+
+#ifdef HAVE_OPENCL
+using namespace cv;
+using namespace cv::ocl;
+using namespace cvtest;
+using namespace testing;
+using namespace std;
+
+PARAM_TEST_CASE(Blend, MatType, int)
+{
+	int type;
+	int channels;
+	std::vector<cv::ocl::Info> oclinfo;
+	
+	virtual void SetUp()
+	{
+	
+		type = GET_PARAM(0);
+		channels = GET_PARAM(1);
+		//int devnums = getDevice(oclinfo);
+		//CV_Assert(devnums > 0);
+		//cv::ocl::setBinpath(CLBINPATH);
+	}
+};
+
+TEST_P(Blend, Performance)
+{
+	cv::Size size(MWIDTH, MHEIGHT);
+	cv::Mat img1_host = randomMat(size, CV_MAKETYPE(type, channels), 0, type == CV_8U ? 255.0 : 1.0);
+	cv::Mat img2_host = randomMat(size, CV_MAKETYPE(type, channels), 0, type == CV_8U ? 255.0 : 1.0);
+	cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
+	cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
+	cv::ocl::oclMat gimg1(size, CV_MAKETYPE(type, channels)), gimg2(size, CV_MAKETYPE(type, channels)), gweights1(size, CV_32F), gweights2(size, CV_32F);
+	cv::ocl::oclMat gdst(size, CV_MAKETYPE(type, channels));
+	
+	
+	double totalgputick_all = 0;
+	double totalgputick_kernel = 0;
+	double t1 = 0;
+	double t2 = 0;
+	
+	for (int j = 0; j < LOOP_TIMES + 1; j ++) //LOOP_TIMES=100
+	{
+		t1 = (double)cvGetTickCount();
+		cv::ocl::oclMat gimg1 = cv::ocl::oclMat(img1_host);
+		cv::ocl::oclMat gimg2 = cv::ocl::oclMat(img2_host);
+		cv::ocl::oclMat gweights1 = cv::ocl::oclMat(weights1);
+		cv::ocl::oclMat gweights2 = cv::ocl::oclMat(weights1);
+		
+		t2 = (double)cvGetTickCount();
+		cv::ocl::blendLinear(gimg1, gimg2, gweights1, gweights2, gdst);
+		t2 = (double)cvGetTickCount() - t2;
+		
+		cv::Mat m;
+		gdst.download(m);
+		t1 = (double)cvGetTickCount() - t1;
+		
+		if (j == 0)
+		{
+			continue;
+		}
+		
+		totalgputick_all = t1 + totalgputick_all;
+		totalgputick_kernel = t2 + totalgputick_kernel;
+	};
+	
+	cout << "average gpu total  runtime is  " << totalgputick_all / ((double)cvGetTickFrequency()* LOOP_TIMES * 1000.) << "ms" << endl;
+	
+	cout << "average gpu runtime without data transfering  is  " << totalgputick_kernel / ((double)cvGetTickFrequency()* LOOP_TIMES * 1000.) << "ms" << endl;
+	
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, Combine(
+                            Values(CV_8U, CV_32F), Values(1, 4)));
+#endif
\ No newline at end of file

modules/ocl/perf/test_canny.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfang Bai, fangfang@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <iomanip>
+#ifdef HAVE_OPENCL
+using namespace cv;
+using namespace cv::ocl;
+using namespace cvtest;
+using namespace testing;
+using namespace std;
+
+#define FILTER_IMAGE "../../../samples/gpu/road.png"
+
+#ifndef MWC_TEST_UTILITY
+#define MWC_TEST_UTILITY
+
+// Param class
+#ifndef IMPLEMENT_PARAM_CLASS
+#define IMPLEMENT_PARAM_CLASS(name, type) \
+class name \
+	{ \
+	public: \
+	name ( type arg = type ()) : val_(arg) {} \
+	operator type () const {return val_;} \
+	private: \
+	type val_; \
+	}; \
+	inline void PrintTo( name param, std::ostream* os) \
+	{ \
+	*os << #name <<  "(" << testing::PrintToString(static_cast< type >(param)) << ")"; \
+	}
+
+IMPLEMENT_PARAM_CLASS(Channels, int)
+#endif // IMPLEMENT_PARAM_CLASS
+#endif // MWC_TEST_UTILITY
+
+////////////////////////////////////////////////////////
+// Canny1
+
+IMPLEMENT_PARAM_CLASS(AppertureSize, int);
+IMPLEMENT_PARAM_CLASS(L2gradient, bool);
+
+PARAM_TEST_CASE(Canny1, AppertureSize, L2gradient)
+{
+	int apperture_size;
+	bool useL2gradient;
+	//std::vector<cv::ocl::Info> oclinfo;
+
+	virtual void SetUp()
+	{
+		apperture_size = GET_PARAM(0);
+		useL2gradient = GET_PARAM(1);
+		
+		//int devnums = getDevice(oclinfo);
+		//CV_Assert(devnums > 0);
+	}
+};
+
+TEST_P(Canny1, Performance)
+{
+	cv::Mat img = readImage(FILTER_IMAGE,cv::IMREAD_GRAYSCALE);
+	ASSERT_FALSE(img.empty());
+
+	double low_thresh = 100.0;
+	double high_thresh = 150.0;
+
+	cv::Mat edges_gold;
+	cv::ocl::oclMat edges;
+
+    double totalgputick=0;
+	double totalgputick_kernel=0;
+	
+	double t1=0;
+	double t2=0;
+	for(int j = 0; j < LOOP_TIMES+1; j ++)
+	{
+
+		t1 = (double)cvGetTickCount();//gpu start1		
+			
+		cv::ocl::oclMat ocl_img = cv::ocl::oclMat(img);//upload
+			
+		t2=(double)cvGetTickCount();//kernel
+		cv::ocl::Canny(ocl_img, edges, low_thresh, high_thresh, apperture_size, useL2gradient);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+			
+		cv::Mat cpu_dst;
+		edges.download (cpu_dst);//download
+			
+		t1 = (double)cvGetTickCount() - t1;//gpu end1
+
+		if(j == 0)
+			continue;
+
+		totalgputick=t1+totalgputick;
+
+		totalgputick_kernel=t2+totalgputick_kernel;	
+
+	}
+
+	cout << "average gpu runtime is  " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+	cout << "average gpu runtime without data transfer is  " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+
+
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny1, testing::Combine(
+						testing::Values(AppertureSize(3), AppertureSize(5)),
+						testing::Values(L2gradient(false), L2gradient(true))));
+
+
+
+#endif  //Have opencl
\ No newline at end of file

modules/ocl/perf/test_columnsum.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//	   Fangfang Bai fangfang@multicorewareinc.com
+//    
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <iomanip>
+
+using namespace cv;
+using namespace cv::ocl;
+using namespace cvtest;
+using namespace testing;
+using namespace std;
+
+///////////////////////////////////////////////////////////////////////////////
+/// ColumnSum
+
+#ifdef HAVE_OPENCL
+
+////////////////////////////////////////////////////////////////////////
+// ColumnSum
+
+PARAM_TEST_CASE(ColumnSum)
+{
+	cv::Mat src;
+	//std::vector<cv::ocl::Info> oclinfo;
+
+	virtual void SetUp()
+	{
+		//int devnums = getDevice(oclinfo);
+		//CV_Assert(devnums > 0);
+	}
+};
+
+TEST_F(ColumnSum, Performance)
+{
+	cv::Size size(MWIDTH,MHEIGHT);
+    cv::Mat src = randomMat(size, CV_32FC1);
+    cv::ocl::oclMat d_dst;
+
+	double totalgputick=0;
+	double totalgputick_kernel=0;
+	double t1=0;
+	double t2=0;
+
+	for(int j = 0; j < LOOP_TIMES+1; j ++)
+	{
+
+		t1 = (double)cvGetTickCount();//gpu start1
+
+        cv::ocl::oclMat d_src(src);		
+
+		t2=(double)cvGetTickCount();//kernel
+		cv::ocl::columnSum(d_src,d_dst);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+
+		cv::Mat cpu_dst;
+		d_dst.download (cpu_dst);//download
+
+		t1 = (double)cvGetTickCount() - t1;//gpu end1
+
+		if(j == 0)
+			continue;
+
+		totalgputick=t1+totalgputick;
+		totalgputick_kernel=t2+totalgputick_kernel;	
+
+	}
+
+	cout << "average gpu runtime is  " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+	cout << "average gpu runtime without data transfer is  " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+
+
+
+}
+
+
+
+#endif 
\ No newline at end of file

modules/ocl/perf/test_fft.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfangbai, fangfang@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+using namespace std;
+#ifdef HAVE_CLAMDFFT
+////////////////////////////////////////////////////////////////////////////
+// Dft
+PARAM_TEST_CASE(Dft, cv::Size, bool) 
+{
+	cv::Size dft_size;
+	bool	 dft_rows;
+	vector<cv::ocl::Info> info;
+	virtual void SetUp()
+	{
+		dft_size = GET_PARAM(0);
+		dft_rows = GET_PARAM(1);
+		cv::ocl::getDevice(info);
+	}
+};
+
+TEST_P(Dft, C2C)
+{
+	cv::Mat a = randomMat(dft_size, CV_32FC2, 0.0, 10.0);
+	int flags = 0;
+	flags |= dft_rows ? cv::DFT_ROWS : 0;
+
+	cv::ocl::oclMat d_b;
+
+	double totalgputick=0;
+	double totalgputick_kernel=0;
+	double t1=0;
+	double t2=0;
+
+	for(int j = 0; j < LOOP_TIMES+1; j ++)
+	{
+
+		t1 = (double)cvGetTickCount();//gpu start1
+
+		cv::ocl::oclMat ga=cv::ocl::oclMat(a);//upload
+
+		t2=(double)cvGetTickCount();//kernel
+		cv::ocl::dft(ga, d_b, a.size(), flags);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+
+		cv::Mat cpu_dst;
+		d_b.download (cpu_dst);//download
+
+		t1 = (double)cvGetTickCount() - t1;//gpu end1
+
+		if(j == 0)
+			continue;
+
+		totalgputick=t1+totalgputick;	
+		totalgputick_kernel=t2+totalgputick_kernel;	
+
+	}
+
+	cout << "average gpu runtime is  " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+	cout << "average gpu runtime without data transfer is  " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+}
+
+
+
+TEST_P(Dft, R2CthenC2R)
+{
+	cv::Mat a = randomMat(dft_size, CV_32FC1, 0.0, 10.0);
+
+	int flags = 0;
+	//flags |= dft_rows ? cv::DFT_ROWS : 0; // not supported yet
+
+	cv::ocl::oclMat d_b, d_c;
+
+	cv::ocl::dft(cv::ocl::oclMat(a), d_b, a.size(), flags);
+	cv::ocl::dft(d_b, d_c, a.size(), flags + cv::DFT_INVERSE + cv::DFT_REAL_OUTPUT);
+
+	EXPECT_MAT_NEAR(a, d_c, a.size().area() * 1e-4, "");
+}
+
+//INSTANTIATE_TEST_CASE_P(ocl_DFT, Dft, testing::Combine(
+//						testing::Values(cv::Size(1280, 1024), cv::Size(1920, 1080),cv::Size(1800, 1500)),
+//						testing::Values(false, true)));
+
+#endif // HAVE_CLAMDFFT

modules/ocl/perf/test_gemm.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfang Bai, fangfang@multicorewareinc.com
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include "precomp.hpp"
+using namespace std;
+#ifdef HAVE_CLAMDBLAS
+////////////////////////////////////////////////////////////////////////////
+// GEMM
+PARAM_TEST_CASE(Gemm, int, cv::Size, int) 
+{
+	int      type;
+	cv::Size mat_size;
+	int		 flags;
+	vector<cv::ocl::Info> info;
+	virtual void SetUp()
+	{
+		type     = GET_PARAM(0);
+		mat_size = GET_PARAM(1);
+		flags    = GET_PARAM(2);
+
+		cv::ocl::getDevice(info);
+	}
+};
+
+TEST_P(Gemm, Performance)
+{
+	cv::Mat a = randomMat(mat_size, type, 0.0, 10.0);
+	cv::Mat b = randomMat(mat_size, type, 0.0, 10.0);
+	cv::Mat c = randomMat(mat_size, type, 0.0, 10.0);
+	cv::ocl::oclMat ocl_dst;	
+
+	double totalgputick=0;
+	double totalgputick_kernel=0;
+	double t1=0;
+	double t2=0;
+
+	for(int j = 0; j < LOOP_TIMES+1; j ++)
+	{
+
+		t1 = (double)cvGetTickCount();//gpu start1
+
+		cv::ocl::oclMat ga = cv::ocl::oclMat(a);//upload
+		cv::ocl::oclMat gb = cv::ocl::oclMat(b);//upload
+		cv::ocl::oclMat gc = cv::ocl::oclMat(c);//upload
+
+		t2=(double)cvGetTickCount();//kernel
+		cv::ocl::gemm(ga, gb, 1.0,gc, 1.0, ocl_dst, flags);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+
+		cv::Mat cpu_dst;
+		ocl_dst.download (cpu_dst);//download
+
+		t1 = (double)cvGetTickCount() - t1;//gpu end
+
+		if(j == 0)
+			continue;
+
+		totalgputick=t1+totalgputick;	
+		totalgputick_kernel=t2+totalgputick_kernel;	
+
+	}
+	cout << "average gpu runtime is  " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+    cout << "average gpu runtime without data transfer is  " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+}
+
+
+INSTANTIATE_TEST_CASE_P(ocl_gemm, Gemm, testing::Combine(
+						testing::Values(CV_32FC1, CV_32FC2/* , CV_64FC1, CV_64FC2*/),
+						testing::Values(cv::Size(512, 512), cv::Size(1024, 1024)),
+						testing::Values(0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_1_T + cv::GEMM_2_T)));
+#endif
\ No newline at end of file

modules/ocl/perf/test_hog.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//		Fangfang BAI, fangfang@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/core/core.hpp"
+#include <iomanip>
+using namespace std;
+
+
+
+#ifdef HAVE_OPENCL
+
+
+PARAM_TEST_CASE(HOG,cv::Size,int)
+{
+	cv::Size winSize;
+	int type;
+	std::vector<cv::ocl::Info> oclinfo;
+
+	virtual void SetUp()
+	{
+		winSize = GET_PARAM(0);
+		type = GET_PARAM(1);
+		int devnums = getDevice(oclinfo);
+		CV_Assert(devnums > 0);
+	}
+};
+
+TEST_P(HOG, GetDescriptors)
+{
+	// Load image
+	cv::Mat img_rgb = readImage("D:road.png");
+	ASSERT_FALSE(img_rgb.empty());
+
+	// Convert image
+	cv::Mat img;
+	switch (type)
+	{
+	case CV_8UC1:
+		cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
+		break;
+	case CV_8UC4:
+	default:
+		cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+		break;
+	}
+		// HOGs
+	cv::ocl::HOGDescriptor ocl_hog;
+	ocl_hog.gamma_correction = true;
+
+
+	// Compute descriptor
+	cv::ocl::oclMat d_descriptors;
+	//down_descriptors = down_descriptors.reshape(0, down_descriptors.cols * down_descriptors.rows);
+
+	double totalgputick=0;
+	double totalgputick_kernel=0;
+	double t1=0;
+	double t2=0;
+
+	for(int j = 0; j < LOOP_TIMES+1; j ++)
+	{
+
+		t1 = (double)cvGetTickCount();//gpu start1
+
+		cv::ocl::oclMat d_img=cv::ocl::oclMat(img);//upload
+
+		t2=(double)cvGetTickCount();//kernel
+		ocl_hog.getDescriptors(d_img, ocl_hog.win_size, d_descriptors, ocl_hog.DESCR_FORMAT_COL_BY_COL);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+
+		cv::Mat down_descriptors;
+		d_descriptors.download(down_descriptors);
+
+		t1 = (double)cvGetTickCount() - t1;//gpu end1
+
+		if(j == 0)
+			continue;
+
+		totalgputick=t1+totalgputick;
+		totalgputick_kernel=t2+totalgputick_kernel;	
+
+	}
+
+	cout << "average gpu runtime is  " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+	cout << "average gpu runtime without data transfer is  " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+
+	
+}
+
+
+TEST_P(HOG, Detect)
+{
+	// Load image
+	cv::Mat img_rgb = readImage("D:road.png");
+	ASSERT_FALSE(img_rgb.empty());
+
+	// Convert image
+	cv::Mat img;
+	switch (type)
+	{
+	case CV_8UC1:
+		cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
+		break;
+	case CV_8UC4:
+	default:
+		cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+		break;
+	}
+	
+    // HOGs
+	if ((winSize != cv::Size(48, 96)) && (winSize != cv::Size(64, 128)))
+		winSize = cv::Size(64, 128);
+	cv::ocl::HOGDescriptor ocl_hog(winSize);
+	ocl_hog.gamma_correction = true;
+
+	cv::HOGDescriptor hog;
+	hog.winSize = winSize;
+	hog.gammaCorrection = true;
+
+	if (winSize.width == 48 && winSize.height == 96)
+	{
+		// daimler's base
+		ocl_hog.setSVMDetector(ocl_hog.getPeopleDetector48x96());
+		hog.setSVMDetector(hog.getDaimlerPeopleDetector());
+	}
+	else if (winSize.width == 64 && winSize.height == 128)
+	{
+		ocl_hog.setSVMDetector(ocl_hog.getPeopleDetector64x128());
+		hog.setSVMDetector(hog.getDefaultPeopleDetector());
+	}
+	else
+	{
+		ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
+		hog.setSVMDetector(hog.getDefaultPeopleDetector());
+	}
+
+	// OpenCL detection
+	std::vector<cv::Point> d_v_locations;
+
+	double totalgputick=0;
+	double totalgputick_kernel=0;
+	double t1=0;
+	double t2=0;
+
+	for(int j = 0; j < LOOP_TIMES+1; j ++)
+	{
+
+		t1 = (double)cvGetTickCount();//gpu start1
+
+		cv::ocl::oclMat d_img=cv::ocl::oclMat(img);//upload
+
+		t2=(double)cvGetTickCount();//kernel
+		ocl_hog.detect(d_img, d_v_locations, 0);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+        
+		t1 = (double)cvGetTickCount() - t1;//gpu end1		
+		if(j == 0)
+			continue;
+		totalgputick=t1+totalgputick;
+		totalgputick_kernel=t2+totalgputick_kernel;	
+
+	}
+
+	cout << "average gpu runtime is  " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+	cout << "average gpu runtime without data transfer is  " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+
+}
+
+
+INSTANTIATE_TEST_CASE_P(OCL_ObjDetect, HOG, testing::Combine(
+						testing::Values(cv::Size(64, 128), cv::Size(48, 96)),
+						testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
+
+
+#endif //HAVE_OPENCL

modules/ocl/perf/test_match_template.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfang Bai, fangfang@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <iomanip>
+#ifdef HAVE_OPENCL
+using namespace cv;
+using namespace cv::ocl;
+using namespace cvtest;
+using namespace testing;
+using namespace std;
+
+#ifndef MWC_TEST_UTILITY
+#define MWC_TEST_UTILITY
+//////// Utility
+#ifndef DIFFERENT_SIZES
+#else
+#undef DIFFERENT_SIZES
+#endif
+#define DIFFERENT_SIZES testing::Values(cv::Size(256, 256), cv::Size(3000, 3000))
+
+// Param class
+#ifndef IMPLEMENT_PARAM_CLASS
+#define IMPLEMENT_PARAM_CLASS(name, type) \
+class name \
+{ \
+public: \
+	name ( type arg = type ()) : val_(arg) {} \
+	operator type () const {return val_;} \
+private: \
+	type val_; \
+}; \
+	inline void PrintTo( name param, std::ostream* os) \
+{ \
+	*os << #name <<  "(" << testing::PrintToString(static_cast< type >(param)) << ")"; \
+}
+
+IMPLEMENT_PARAM_CLASS(Channels, int)
+#endif // IMPLEMENT_PARAM_CLASS
+#endif // MWC_TEST_UTILITY
+
+////////////////////////////////////////////////////////////////////////////////
+// MatchTemplate
+#define ALL_TEMPLATE_METHODS testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR), TemplateMethod(cv::TM_CCOEFF), TemplateMethod(cv::TM_SQDIFF_NORMED), TemplateMethod(cv::TM_CCORR_NORMED), TemplateMethod(cv::TM_CCOEFF_NORMED))
+
+IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size);
+
+const char* TEMPLATE_METHOD_NAMES[6] = {"TM_SQDIFF", "TM_SQDIFF_NORMED", "TM_CCORR", "TM_CCORR_NORMED", "TM_CCOEFF", "TM_CCOEFF_NORMED"};
+
+PARAM_TEST_CASE(MatchTemplate, cv::Size, TemplateSize, Channels, TemplateMethod)
+{
+	cv::Size size;
+	cv::Size templ_size;
+	int cn;
+	int method;
+	//vector<cv::ocl::Info> oclinfo;
+
+	virtual void SetUp()
+	{
+		size = GET_PARAM(0);
+		templ_size = GET_PARAM(1);
+		cn = GET_PARAM(2);
+		method = GET_PARAM(3);
+		//int devnums = getDevice(oclinfo);
+		//CV_Assert(devnums > 0);
+	}
+};
+struct MatchTemplate8U : MatchTemplate {};
+
+TEST_P(MatchTemplate8U, Performance)
+{
+	std::cout << "Method: " << TEMPLATE_METHOD_NAMES[method] << std::endl;
+	std::cout << "Image Size: (" << size.width << ", " << size.height << ")"<< std::endl;
+	std::cout << "Template Size: (" << templ_size.width << ", " << templ_size.height << ")"<< std::endl;
+	std::cout << "Channels: " << cn << std::endl;
+
+	cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
+	cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
+	cv::Mat dst_gold;
+	cv::ocl::oclMat dst;
+
+
+
+
+	
+	double totalgputick=0;
+	double totalgputick_kernel=0;
+
+	double t1=0;
+	double t2=0;
+	for(int j = 0; j < LOOP_TIMES+1; j ++)
+	{
+
+		t1 = (double)cvGetTickCount();//gpu start1
+
+        cv::ocl::oclMat ocl_image = cv::ocl::oclMat(image);//upload
+		cv::ocl::oclMat ocl_templ = cv::ocl::oclMat(templ);//upload
+
+		t2=(double)cvGetTickCount();//kernel
+		cv::ocl::matchTemplate(ocl_image, ocl_templ, dst, method);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+
+		cv::Mat cpu_dst;
+		dst.download (cpu_dst);//download
+
+		t1 = (double)cvGetTickCount() - t1;//gpu end1
+
+		if(j == 0)
+			continue;
+
+		totalgputick=t1+totalgputick;	
+		totalgputick_kernel=t2+totalgputick_kernel;	
+
+	}
+
+	cout << "average gpu runtime is  " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+	cout << "average gpu runtime without data transfer is  " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+
+
+}
+
+
+struct MatchTemplate32F : MatchTemplate {};
+TEST_P(MatchTemplate32F, Performance)
+{
+	std::cout << "Method: " << TEMPLATE_METHOD_NAMES[method] << std::endl;
+	std::cout << "Image Size: (" << size.width << ", " << size.height << ")"<< std::endl;
+	std::cout << "Template Size: (" << templ_size.width << ", " << templ_size.height << ")"<< std::endl;
+	std::cout << "Channels: " << cn << std::endl;
+	cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
+	cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
+
+	cv::Mat dst_gold;
+	cv::ocl::oclMat dst;
+
+
+
+
+	double totalgputick=0;
+	double totalgputick_kernel=0;
+
+	double t1=0;
+	double t2=0;
+	for(int j = 0; j < LOOP_TIMES; j ++)
+	{
+
+		t1 = (double)cvGetTickCount();//gpu start1
+
+        cv::ocl::oclMat ocl_image = cv::ocl::oclMat(image);//upload
+		cv::ocl::oclMat ocl_templ = cv::ocl::oclMat(templ);//upload
+
+		t2=(double)cvGetTickCount();//kernel
+		cv::ocl::matchTemplate(ocl_image, ocl_templ, dst, method);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+
+		cv::Mat cpu_dst;
+		dst.download (cpu_dst);//download
+
+		t1 = (double)cvGetTickCount() - t1;//gpu end1		
+
+		totalgputick=t1+totalgputick;
+	
+		totalgputick_kernel=t2+totalgputick_kernel;	
+
+	}
+
+   cout << "average gpu runtime is  " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+   cout << "average gpu runtime without data transfer is  " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
+
+
+
+}
+
+
+INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, 
+	testing::Combine(
+    testing::Values(cv::Size(1280, 1024), cv::Size(MWIDTH, MHEIGHT),cv::Size(1800, 1500)),
+    testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16))/*, TemplateSize(cv::Size(30, 30))*/),
+    testing::Values(Channels(1), Channels(4)/*, Channels(3)*/),
+	ALL_TEMPLATE_METHODS
+	)
+);
+
+INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate32F, testing::Combine(
+    testing::Values(cv::Size(1280, 1024), cv::Size(MWIDTH, MHEIGHT),cv::Size(1800, 1500)),
+    testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16))/*, TemplateSize(cv::Size(30, 30))*/),
+    testing::Values(Channels(1), Channels(4) /*, Channels(3)*/),
+    testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))));
+
+#endif //HAVE_OPENCL
\ No newline at end of file

modules/ocl/perf/test_pyrdown.cpp

+///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    fangfang bai, fangfang@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <iomanip>
+
+#ifdef HAVE_OPENCL
+
+using namespace cv;
+using namespace cv::ocl;
+using namespace cvtest;
+using namespace testing;
+using namespace std;
+
+PARAM_TEST_CASE(PyrDown, MatType, int)
+{
+	int type;
+	int channels;
+	//src mat
+	cv::Mat mat1;
+	cv::Mat dst;
+	
+	//std::vector<cv::ocl::Info> oclinfo;
+	//ocl dst mat for testing
+	
+	cv::ocl::oclMat gmat1;
+	cv::ocl::oclMat gdst;
+	
+	
+	virtual void SetUp()
+	{
+		type = GET_PARAM(0);
+		channels = GET_PARAM(1);
+		//int devnums = getDevice(oclinfo);
+		//CV_Assert(devnums > 0);
+	}
+	
+	
+};
+
+#define VARNAME(A) string(#A);
+
+////////////////////////////////PyrDown/////////////////////////////////////////////////
+TEST_P(PyrDown, Mat)
+{
+	cv::Size size(MWIDTH, MHEIGHT);
+	cv::RNG &rng = TS::ptr()->get_rng();
+	mat1 = randomMat(rng, size, CV_MAKETYPE(type, channels), 5, 16, false);
+	
+	
+	cv::ocl::oclMat gdst;
+	double totalgputick = 0;
+	double totalgputick_kernel = 0;
+	
+	double t1 = 0;
+	double t2 = 0;
+	
+	for (int j = 0; j < LOOP_TIMES + 1; j ++)
+	{
+	
+		t1 = (double)cvGetTickCount();//gpu start1
+		
+		cv::ocl::oclMat gmat1(mat1);
+		
+		t2 = (double)cvGetTickCount(); //kernel
+		cv::ocl::pyrDown(gmat1, gdst);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+		
+		cv::Mat cpu_dst;
+		gdst.download(cpu_dst);
+		
+		t1 = (double)cvGetTickCount() - t1;//gpu end1
+		
+		if (j == 0)
+		{
+			continue;
+		}
+		
+		totalgputick = t1 + totalgputick;
+		
+		totalgputick_kernel = t2 + totalgputick_kernel;
+		
+	}
+	
+	cout << "average gpu runtime is  " << totalgputick / ((double)cvGetTickFrequency()* LOOP_TIMES * 1000.) << "ms" << endl;
+	cout << "average gpu runtime without data transfer is  " << totalgputick_kernel / ((double)cvGetTickFrequency()* LOOP_TIMES * 1000.) << "ms" << endl;
+	
+}
+
+//********test****************
+INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, Combine(
+                            Values(CV_8U, CV_32F), Values(1, 4)));
+
+
+#endif // HAVE_OPENCL

modules/ocl/perf/test_pyrup.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    fangfang bai fangfang@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/core/core.hpp"
+#include "precomp.hpp"
+#include <iomanip>
+#ifdef HAVE_OPENCL
+using namespace cv;
+using namespace cv::ocl;
+using namespace cvtest;
+using namespace testing;
+using namespace std;
+
+
+PARAM_TEST_CASE(PyrUp, MatType, int)
+{
+	int type;
+	int channels;
+	//std::vector<cv::ocl::Info> oclinfo;
+	
+	virtual void SetUp()
+	{
+		type = GET_PARAM(0);
+		channels = GET_PARAM(1);
+		//int devnums = getDevice(oclinfo);
+		//CV_Assert(devnums > 0);
+	}
+};
+
+TEST_P(PyrUp, Performance)
+{
+	cv::Size size(MWIDTH, MHEIGHT);
+	cv::Mat src = randomMat(size, CV_MAKETYPE(type, channels));
+	cv::Mat dst_gold;
+	cv::ocl::oclMat dst;
+	
+	
+	double totalgputick = 0;
+	double totalgputick_kernel = 0;
+	
+	double t1 = 0;
+	double t2 = 0;
+	
+	for (int j = 0; j < LOOP_TIMES + 1; j ++)
+	{
+		t1 = (double)cvGetTickCount();//gpu start1
+		
+		cv::ocl::oclMat srcMat = cv::ocl::oclMat(src);//upload
+		
+		t2 = (double)cvGetTickCount(); //kernel
+		cv::ocl::pyrUp(srcMat, dst);
+		t2 = (double)cvGetTickCount() - t2;//kernel
+		
+		cv::Mat cpu_dst;
+		dst.download(cpu_dst); //download
+		
+		t1 = (double)cvGetTickCount() - t1;//gpu end1
+		
+		if (j == 0)
+		{
+			continue;
+		}
+		
+		totalgputick = t1 + totalgputick;
+		
+		totalgputick_kernel = t2 + totalgputick_kernel;
+		
+	}
+	
+	
+	cout << "average gpu runtime is  " << totalgputick / ((double)cvGetTickFrequency()* LOOP_TIMES * 1000.) << "ms" << endl;
+	cout << "average gpu runtime without data transfer is  " << totalgputick_kernel / ((double)cvGetTickFrequency()* LOOP_TIMES * 1000.) << "ms" << endl;
+	
+	
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, Combine(
+                            Values(CV_8U, CV_32F), Values(1, 4)));
+
+#endif // HAVE_OPENCL
\ No newline at end of file

modules/ocl/src/columnsum.cpp

@@ -67,7 +67,9 @@ namespace cv
 
 void cv::ocl::columnSum(const oclMat& src,oclMat& dst)
 {
-	CV_Assert(src.type() == CV_32FC1 && dst.type() == CV_32FC1 && src.size() == dst.size());
+	CV_Assert(src.type() == CV_32FC1);
+
+	dst.create(src.size(), src.type());
 
 	Context *clCxt = src.clCxt;                                        
 		       

modules/ocl/src/kernels/blend_linear.cl

@@ -67,32 +67,6 @@ __kernel void BlendLinear_C1_D0(
 	}
 }
 
-__kernel void BlendLinear_C3_D0(
-	__global uchar *dst,
-	__global uchar *img1,
-	__global uchar *img2,
-	__global float *weight1,
-	__global float *weight2,
-	int rows,
-	int cols,
-	int istep,
-	int wstep
-	)
-{
-	int idx = get_global_id(0);
-	int idy = get_global_id(1);
-	int x = idx / 3;
-	int y = idy;
-	if (x < cols && y < rows)
-	{
-		int pos = idy * istep + idx;
-		int wpos = idy * (wstep /sizeof(float)) + x;
-		float w1 = weight1[wpos];
-		float w2 = weight2[wpos];
-		dst[pos] = (img1[pos] * w1 + img2[pos] * w2) / (w1 + w2 + 1e-5f);
-	}
-}
-
 __kernel void BlendLinear_C4_D0(
 	__global uchar *dst,
 	__global uchar *img1,
@@ -143,32 +117,6 @@ __kernel void BlendLinear_C1_D5(
 	}
 }
 
-__kernel void BlendLinear_C3_D5(
-	__global float *dst,
-	__global float *img1,
-	__global float *img2,
-	__global float *weight1,
-	__global float *weight2,
-	int rows,
-	int cols,
-	int istep,
-	int wstep
-	)
-{
-	int idx = get_global_id(0);
-	int idy = get_global_id(1);
-	int x = idx / 3;
-	int y = idy;
-	if (x < cols && y < rows)
-	{
-		int pos = idy * (istep / sizeof(float)) + idx;
-		int wpos = idy * (wstep /sizeof(float)) + x;
-		float w1 = weight1[wpos];
-		float w2 = weight2[wpos];
-		dst[pos] = (img1[pos] * w1 + img2[pos] * w2) / (w1 + w2 + 1e-5f);
-	}
-}
-
 __kernel void BlendLinear_C4_D5(
 	__global float *dst,
 	__global float *img1,
@@ -194,3 +142,4 @@ __kernel void BlendLinear_C4_D5(
 		dst[pos] = (img1[pos] * w1 + img2[pos] * w2) / (w1 + w2 + 1e-5f);
 	}
 }
+

modules/ocl/src/kernels/nonfree_surf.cl

@@ -58,17 +58,9 @@
 // Image read mode
 __constant sampler_t sampler    = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
 
+#define FLT_EPSILON (1e-15)
 #define CV_PI_F 3.14159265f
 
-// print greyscale image to show image layout
-__kernel void printImage(image2d_t img)
-{
-    printf("(%d, %d) - %3d \n", 
-        get_global_id(0), 
-        get_global_id(1), 
-        read_imageui(img, (int2)(get_global_id(0), get_global_id(1))).x
-        );
-}
 
 // Use integral image to calculate haar wavelets.
 // N = 2
@@ -444,7 +436,6 @@ __kernel
         float val0 = N9[localLin];
         if (val0 > c_hessianThreshold)
         {
-            //printf(\"(%3d, %3d) N9[%3d]=%7.1f val0=%7.1f\\n\", l_x, l_y, localLin - zoff, N9[localLin], val0);
             // Coordinates for the start of the wavelet in the sum image. There
             // is some integer division involved, so don't try to simplify this
             // (cancel out sampleStep) without checking the result is the same
@@ -726,6 +717,7 @@ __kernel
     __global float* featureSize = keypoints + SIZE_ROW * keypoints_step;
     __global float* featureDir  = keypoints + ANGLE_ROW * keypoints_step;
 
+
     volatile __local  float s_X[128];
     volatile __local  float s_Y[128];
     volatile __local  float s_angle[128];
@@ -737,6 +729,7 @@ __kernel
     and building the keypoint descriptor are defined relative to 's' */
     const float s = featureSize[get_group_id(0)] * 1.2f / 9.0f;
 
+
     /* To find the dominant orientation, the gradients in x and y are
     sampled in a circle of radius 6s using wavelets of size 4s.
     We ensure the gradient wavelet size is even to ensure the
@@ -765,16 +758,18 @@ __kernel
             Y = c_aptW[tid] * icvCalcHaarPatternSum_2(sumTex, c_NY, 4, grad_wav_size, y, x);
 
             angle = atan2(Y, X);
+            
             if (angle < 0)
                 angle += 2.0f * CV_PI_F;
             angle *= 180.0f / CV_PI_F;
+
         }
     }
     s_X[tid] = X;
     s_Y[tid] = Y;
     s_angle[tid] = angle;
     barrier(CLK_LOCAL_MEM_FENCE);
-
+    
     float bestx = 0, besty = 0, best_mod = 0;
 
 #pragma unroll
@@ -807,7 +802,6 @@ __kernel
             sumx += s_X[get_local_id(0) + 96];
             sumy += s_Y[get_local_id(0) + 96];
         }
-
         reduce_32_sum(s_sumx + get_local_id(1) * 32, sumx, get_local_id(0));
         reduce_32_sum(s_sumy + get_local_id(1) * 32, sumy, get_local_id(0));
 
@@ -818,10 +812,8 @@ __kernel
             bestx = sumx;
             besty = sumy;
         }
-
         barrier(CLK_LOCAL_MEM_FENCE);
     }
-
     if (get_local_id(0) == 0)
     {
         s_X[get_local_id(1)] = bestx;
@@ -846,6 +838,10 @@ __kernel
             kp_dir += 2.0f * CV_PI_F;
         kp_dir *= 180.0f / CV_PI_F;
 
+        kp_dir = 360.0f - kp_dir;
+        if (fabs(kp_dir - 360.f) < FLT_EPSILON)
+            kp_dir = 0.f;
+
         featureDir[get_group_id(0)] = kp_dir;
     }
 }
@@ -940,7 +936,10 @@ void calc_dx_dy(
     const float centerX = featureX[get_group_id(0)];
     const float centerY = featureY[get_group_id(0)];
     const float size = featureSize[get_group_id(0)];
-    const float descriptor_dir = featureDir[get_group_id(0)] * (float)(CV_PI_F / 180.0f);
+    float descriptor_dir = 360.0f - featureDir[get_group_id(0)];
+    if (fabs(descriptor_dir - 360.f) < FLT_EPSILON)
+        descriptor_dir = 0.f;
+    descriptor_dir *= (float)(CV_PI_F / 180.0f);
 
     /* The sampling intervals and wavelet sized for selecting an orientation
     and building the keypoint descriptor are defined relative to 's' */

modules/ocl/src/kernels/objdetect_hog.cl

@@ -448,3 +448,42 @@ __kernel void compute_gradients_8UC1_kernel(const int height, const int width, c
         grad[ ((gidY * grad_quadstep + x) << 1) + 1 ]   = mag * ang;
     }
 }
+
+//----------------------------------------------------------------------------
+// Resize
+
+__kernel void resize_8UC4_kernel(__global uchar4 * dst, __global const uchar4 * src,
+                                 int dst_offset, int src_offset, int dst_step, int src_step, 
+                                 int src_cols, int src_rows, int dst_cols, int dst_rows, float ifx, float ify )
+{
+    int dx = get_global_id(0);
+    int dy = get_global_id(1);
+    
+    int sx = (int)floor(dx*ifx+0.5f);
+    int sy = (int)floor(dy*ify+0.5f);
+    sx = min(sx, src_cols-1);
+    sy = min(sy, src_rows-1);
+    int dpos = (dst_offset>>2) + dy * (dst_step>>2) + dx;
+    int spos = (src_offset>>2) + sy * (src_step>>2) + sx;
+    
+    if(dx<dst_cols && dy<dst_rows)
+        dst[dpos] = src[spos];
+}
+
+__kernel void resize_8UC1_kernel(__global uchar * dst, __global const uchar * src,
+                                 int dst_offset, int src_offset, int dst_step, int src_step, 
+                                 int src_cols, int src_rows, int dst_cols, int dst_rows, float ifx, float ify )
+{
+    int dx = get_global_id(0);
+    int dy = get_global_id(1);
+    
+    int sx = (int)floor(dx*ifx+0.5f);
+    int sy = (int)floor(dy*ify+0.5f);
+    sx = min(sx, src_cols-1);
+    sy = min(sy, src_rows-1);
+    int dpos = dst_offset + dy * dst_step + dx;
+    int spos = src_offset + sy * src_step + sx;
+    
+    if(dx<dst_cols && dy<dst_rows)
+        dst[dpos] = src[spos];
+}
\ No newline at end of file

modules/ocl/src/pyrdown.cpp

-
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//		Dachuan Zhao, dachuan@multicorewareinc.com
+//		Yao Wang, yao@multicorewareinc.com
+//    
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other oclMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
 #include "precomp.hpp"
 
 using namespace cv;
@@ -24,7 +69,6 @@ namespace cv
 template<typename T>
 void pyrdown_run(const oclMat &src, const oclMat &dst)
 {
-    CV_Assert(src.cols / 2 == dst.cols && src.rows / 2 == dst.rows);
 
     CV_Assert(src.type() == dst.type());
     CV_Assert(src.depth() != CV_8S);
@@ -108,7 +152,7 @@ void cv::ocl::pyrDown(const oclMat& src, oclMat& dst)
 
     dst.create((src.rows + 1) / 2, (src.cols + 1) / 2, src.type());
 
-	//dst.step = dst.rows;
+	dst.download_channels = src.download_channels;
 
     pyrdown_run(src, dst);
 }

modules/ocl/src/surf.cpp

@@ -149,8 +149,7 @@ namespace
             //loadGlobalConstants(maxCandidates, maxFeatures, img_rows, img_cols, surf_.nOctaveLayers, static_cast<float>(surf_.hessianThreshold));
 
             bindImgTex(img);
-            oclMat integral_sqsum;
-            integral(img, surf_.sum, integral_sqsum); // the two argumented integral version is incorrect
+            integral(img, surf_.sum); // the two argumented integral version is incorrect
 
             bindSumTex(surf_.sum);
             maskSumTex = 0;