mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1930 lines
53 KiB
1930 lines
53 KiB
12 years ago
|
/*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, Institute Of Software Chinese Academy Of Science, all rights reserved.
|
||
|
|
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
|
||
|
|
// Third party copyrights are property of their respective owners.
|
||
|
|
//
|
||
|
|
// @Authors
|
||
|
|
// Niko Li, newlife20080214@gmail.com
|
||
|
|
// Jia Haipeng, jiahaipeng95@gmail.com
|
||
|
|
// Shengen Yan, yanshengen@gmail.com
|
||
|
|
// Jiang Liyuan, lyuan001.good@163.com
|
||
|
|
// Rock Li, Rock.Li@amd.com
|
||
|
|
// Zailong Wu, bullet@yeah.net
|
||
|
|
// Xu Pang, pangxu010@163.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"
|
||
|
|
|
||
|
|
#ifdef HAVE_OPENCL
|
||
|
|
|
||
|
|
using namespace cvtest;
|
||
|
|
using namespace testing;
|
||
|
|
using namespace std;
|
||
|
|
|
||
|
|
|
||
|
|
MatType nulltype = -1;
|
||
|
|
|
||
|
|
#define ONE_TYPE(type) testing::ValuesIn(typeVector(type))
|
||
|
|
#define NULL_TYPE testing::ValuesIn(typeVector(nulltype))
|
||
|
|
|
||
|
|
|
||
|
|
vector<MatType> typeVector(MatType type)
|
||
|
|
{
|
||
|
|
vector<MatType> v;
|
||
|
|
v.push_back(type);
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
PARAM_TEST_CASE(ImgprocTestBase, MatType,MatType,MatType,MatType,MatType, bool)
|
||
|
|
{
|
||
|
|
int type1,type2,type3,type4,type5;
|
||
|
|
cv::Scalar val;
|
||
|
|
// set up roi
|
||
|
|
int roicols;
|
||
|
|
int roirows;
|
||
|
|
int src1x;
|
||
|
|
int src1y;
|
||
|
|
int src2x;
|
||
|
|
int src2y;
|
||
|
|
int dstx;
|
||
|
|
int dsty;
|
||
|
|
int dst1x;
|
||
|
|
int dst1y;
|
||
|
|
int maskx;
|
||
|
|
int masky;
|
||
|
|
|
||
|
|
//mat
|
||
|
|
cv::Mat mat1;
|
||
|
|
cv::Mat mat2;
|
||
|
|
cv::Mat mask;
|
||
|
|
cv::Mat dst;
|
||
|
|
cv::Mat dst1; //bak, for two outputs
|
||
|
|
|
||
|
|
//mat with roi
|
||
|
|
cv::Mat mat1_roi;
|
||
|
|
cv::Mat mat2_roi;
|
||
|
|
cv::Mat mask_roi;
|
||
|
|
cv::Mat dst_roi;
|
||
|
|
cv::Mat dst1_roi; //bak
|
||
|
12 years ago
|
//std::vector<cv::ocl::Info> oclinfo;
|
||
|
12 years ago
|
//ocl mat
|
||
|
|
cv::ocl::oclMat clmat1;
|
||
|
|
cv::ocl::oclMat clmat2;
|
||
|
|
cv::ocl::oclMat clmask;
|
||
|
|
cv::ocl::oclMat cldst;
|
||
|
|
cv::ocl::oclMat cldst1; //bak
|
||
|
|
|
||
|
|
//ocl mat with roi
|
||
|
|
cv::ocl::oclMat clmat1_roi;
|
||
|
|
cv::ocl::oclMat clmat2_roi;
|
||
|
|
cv::ocl::oclMat clmask_roi;
|
||
|
|
cv::ocl::oclMat cldst_roi;
|
||
|
|
cv::ocl::oclMat cldst1_roi;
|
||
|
|
|
||
|
|
virtual void SetUp()
|
||
|
|
{
|
||
|
|
type1 = GET_PARAM(0);
|
||
|
|
type2 = GET_PARAM(1);
|
||
|
|
type3 = GET_PARAM(2);
|
||
|
|
type4 = GET_PARAM(3);
|
||
|
|
type5 = GET_PARAM(4);
|
||
|
|
cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
cv::Size size(MWIDTH, MHEIGHT);
|
||
|
|
double min = 1,max = 20;
|
||
|
12 years ago
|
//int devnums = getDevice(oclinfo);
|
||
|
|
//CV_Assert(devnums>0);
|
||
|
|
////if you want to use undefault device, set it here
|
||
|
|
////setDevice(oclinfo[0]);
|
||
|
|
//cv::ocl::setBinpath(CLBINPATH);
|
||
|
12 years ago
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
mat1 = randomMat(rng, size, type1, min, max, false);
|
||
|
|
clmat1 = mat1;
|
||
|
|
}
|
||
|
|
if(type2!=nulltype)
|
||
|
|
{
|
||
|
|
mat2 = randomMat(rng, size, type2, min, max, false);
|
||
|
|
clmat2 = mat2;
|
||
|
|
}
|
||
|
|
if(type3!=nulltype)
|
||
|
|
{
|
||
|
|
dst = randomMat(rng, size, type3, min, max, false);
|
||
|
|
cldst = dst;
|
||
|
|
}
|
||
|
|
if(type4!=nulltype)
|
||
|
|
{
|
||
|
|
dst1 = randomMat(rng, size, type4, min, max, false);
|
||
|
|
cldst1 = dst1;
|
||
|
|
}
|
||
|
|
if(type5!=nulltype)
|
||
|
|
{
|
||
|
|
mask = randomMat(rng, size, CV_8UC1, 0, 2, false);
|
||
|
|
cv::threshold(mask, mask, 0.5, 255., type5);
|
||
|
|
clmask = mask;
|
||
|
|
}
|
||
|
|
val = cv::Scalar(rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0), rng.uniform(-10.0, 10.0));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void Has_roi(int b)
|
||
|
|
{
|
||
|
|
//cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
if(b)
|
||
|
|
{
|
||
|
|
//randomize ROI
|
||
|
|
roicols = mat1.cols-1; //start
|
||
|
|
roirows = mat1.rows-1;
|
||
|
|
src1x = 1;
|
||
|
|
src2x = 1;
|
||
|
|
src1y = 1;
|
||
|
|
src2y = 1;
|
||
|
|
dstx = 1;
|
||
|
|
dsty =1;
|
||
|
|
dst1x = 1;
|
||
|
|
dst1y =1;
|
||
|
|
maskx =1;
|
||
|
|
masky =1;
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
roicols = mat1.cols;
|
||
|
|
roirows = mat1.rows;
|
||
|
|
src1x = 0;
|
||
|
|
src2x = 0;
|
||
|
|
src1y = 0;
|
||
|
|
src2y = 0;
|
||
|
|
dstx = 0;
|
||
|
|
dsty = 0;
|
||
|
|
dst1x =0;
|
||
|
|
dst1y =0;
|
||
|
|
maskx =0;
|
||
|
|
masky =0;
|
||
|
|
};
|
||
|
|
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
mat1_roi = mat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
//clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(type2!=nulltype)
|
||
|
|
{
|
||
|
|
mat2_roi = mat2(Rect(src2x,src2y,roicols,roirows));
|
||
|
|
//clmat2_roi = clmat2(Rect(src2x,src2y,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(type3!=nulltype)
|
||
|
|
{
|
||
|
|
dst_roi = dst(Rect(dstx,dsty,roicols,roirows));
|
||
|
|
//cldst_roi = cldst(Rect(dstx,dsty,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(type4!=nulltype)
|
||
|
|
{
|
||
|
|
dst1_roi = dst1(Rect(dst1x,dst1y,roicols,roirows));
|
||
|
|
//cldst1_roi = cldst1(Rect(dst1x,dst1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(type5!=nulltype)
|
||
|
|
{
|
||
|
|
mask_roi = mask(Rect(maskx,masky,roicols,roirows));
|
||
|
|
//clmask_roi = clmask(Rect(maskx,masky,roicols,roirows));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void random_roi()
|
||
|
|
{
|
||
|
|
cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
|
||
|
|
//randomize ROI
|
||
|
|
roicols = rng.uniform(1, mat1.cols);
|
||
|
|
roirows = rng.uniform(1, mat1.rows);
|
||
|
|
src1x = rng.uniform(0, mat1.cols - roicols);
|
||
|
|
src1y = rng.uniform(0, mat1.rows - roirows);
|
||
|
|
src2x = rng.uniform(0, mat2.cols - roicols);
|
||
|
|
src2y = rng.uniform(0, mat2.rows - roirows);
|
||
|
|
dstx = rng.uniform(0, dst.cols - roicols);
|
||
|
|
dsty = rng.uniform(0, dst.rows - roirows);
|
||
|
|
dst1x = rng.uniform(0, dst1.cols - roicols);
|
||
|
|
dst1y = rng.uniform(0, dst1.rows - roirows);
|
||
|
|
maskx = rng.uniform(0, mask.cols - roicols);
|
||
|
|
masky = rng.uniform(0, mask.rows - roirows);
|
||
|
|
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
mat1_roi = mat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
//clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(type2!=nulltype)
|
||
|
|
{
|
||
|
|
mat2_roi = mat2(Rect(src2x,src2y,roicols,roirows));
|
||
|
|
//clmat2_roi = clmat2(Rect(src2x,src2y,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(type3!=nulltype)
|
||
|
|
{
|
||
|
|
dst_roi = dst(Rect(dstx,dsty,roicols,roirows));
|
||
|
|
//cldst_roi = cldst(Rect(dstx,dsty,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(type4!=nulltype)
|
||
|
|
{
|
||
|
|
dst1_roi = dst1(Rect(dst1x,dst1y,roicols,roirows));
|
||
|
|
//cldst1_roi = cldst1(Rect(dst1x,dst1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(type5!=nulltype)
|
||
|
|
{
|
||
|
|
mask_roi = mask(Rect(maskx,masky,roicols,roirows));
|
||
|
|
//clmask_roi = clmask(Rect(maskx,masky,roicols,roirows));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
////////////////////////////////equalizeHist//////////////////////////////////////////
|
||
|
|
|
||
|
|
struct equalizeHist : ImgprocTestBase {};
|
||
|
|
|
||
|
|
TEST_P(equalizeHist, MatType)
|
||
|
|
{
|
||
|
|
if (mat1.type() != CV_8UC1 || mat1.type() != dst.type())
|
||
|
|
{
|
||
|
|
cout<<"Unsupported type"<<endl;
|
||
|
|
EXPECT_DOUBLE_EQ(0.0, 0.0);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::equalizeHist(mat1_roi, dst_roi);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
cldst_roi = cldst(Rect(dstx,dsty,roicols,roirows));
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::equalizeHist(clmat1_roi, cldst_roi);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_cldst;
|
||
|
|
//cldst.download(cpu_cldst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::equalizeHist(clmat1_roi, cldst_roi);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
////////////////////////////////bilateralFilter////////////////////////////////////////////
|
||
|
|
|
||
|
|
struct bilateralFilter : ImgprocTestBase {};
|
||
|
|
|
||
|
|
TEST_P(bilateralFilter, Mat)
|
||
|
|
{
|
||
|
|
double sigmacolor = 50.0;
|
||
|
|
int radius = 9;
|
||
|
|
int d = 2*radius+1;
|
||
|
|
double sigmaspace = 20.0;
|
||
|
|
int bordertype[] = {cv::BORDER_CONSTANT,cv::BORDER_REPLICATE/*,BORDER_REFLECT,BORDER_WRAP,BORDER_REFLECT_101*/};
|
||
|
|
//const char* borderstr[]={"BORDER_CONSTANT", "BORDER_REPLICATE"/*, "BORDER_REFLECT","BORDER_WRAP","BORDER_REFLECT_101"*/};
|
||
|
|
if (mat1.type() != CV_8UC1 || mat1.type() != dst.type())
|
||
|
|
{
|
||
|
|
cout<<"Unsupported type"<<endl;
|
||
|
|
EXPECT_DOUBLE_EQ(0.0, 0.0);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
for(int i=0;i<sizeof(bordertype)/sizeof(int);i++){
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::bilateralFilter(mat1_roi, dst_roi, d,sigmacolor,sigmaspace, bordertype[i]);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::bilateralFilter(clmat1_roi, cldst_roi, d,sigmacolor,sigmaspace, bordertype[i]);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_cldst;
|
||
|
|
cldst.download(cpu_cldst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
};
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::bilateralFilter(clmat1_roi, cldst_roi, d,sigmacolor,sigmaspace, bordertype[i]);
|
||
|
|
};
|
||
|
|
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
////////////////////////////////copyMakeBorder////////////////////////////////////////////
|
||
|
|
|
||
|
|
struct CopyMakeBorder : ImgprocTestBase {};
|
||
|
|
|
||
|
|
TEST_P(CopyMakeBorder, Mat)
|
||
|
|
{
|
||
|
|
int bordertype[] = {cv::BORDER_CONSTANT,cv::BORDER_REPLICATE/*,BORDER_REFLECT,BORDER_WRAP,BORDER_REFLECT_101*/};
|
||
|
|
//const char* borderstr[]={"BORDER_CONSTANT", "BORDER_REPLICATE"/*, "BORDER_REFLECT","BORDER_WRAP","BORDER_REFLECT_101"*/};
|
||
|
|
|
||
|
|
if ((mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32SC1) || mat1.type() != dst.type())
|
||
|
|
{
|
||
|
|
cout<<"Unsupported type"<<endl;
|
||
|
|
EXPECT_DOUBLE_EQ(0.0, 0.0);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
for(int i=0;i<sizeof(bordertype)/sizeof(int);i++){
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::copyMakeBorder(mat1_roi, dst_roi, 7,5,5,7, bordertype[i],cv::Scalar(1.0));
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::copyMakeBorder(clmat1_roi, cldst_roi,7,5,5,7, bordertype[i],cv::Scalar(1.0));
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_cldst;
|
||
|
|
cldst.download(cpu_cldst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
};
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::copyMakeBorder(clmat1_roi, cldst_roi,7,5,5,7, bordertype[i],cv::Scalar(1.0));
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
////////////////////////////////cornerMinEigenVal//////////////////////////////////////////
|
||
|
|
|
||
|
|
struct cornerMinEigenVal : ImgprocTestBase {};
|
||
|
|
|
||
|
|
TEST_P(cornerMinEigenVal, Mat)
|
||
|
|
{
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
int blockSize = 7, apertureSize= 1 + 2 * (rand() % 4);
|
||
|
|
int borderType = cv::BORDER_REFLECT;
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::cornerMinEigenVal(mat1_roi, dst_roi, blockSize, apertureSize, borderType);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::cornerMinEigenVal(clmat1_roi, cldst_roi, blockSize, apertureSize, borderType);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_cldst;
|
||
|
|
cldst.download(cpu_cldst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
int blockSize = 7, apertureSize= 1 + 2 * (rand() % 4);
|
||
|
|
int borderType = cv::BORDER_REFLECT;
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
};
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::cornerMinEigenVal(clmat1_roi, cldst_roi, blockSize, apertureSize, borderType);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
////////////////////////////////cornerHarris//////////////////////////////////////////
|
||
|
|
|
||
|
|
struct cornerHarris : ImgprocTestBase {};
|
||
|
|
|
||
|
|
TEST_P(cornerHarris, Mat)
|
||
|
|
{
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
int blockSize = 7, apertureSize= 3;
|
||
|
|
int borderType = cv::BORDER_REFLECT;
|
||
|
|
double kk = 2;
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::cornerHarris(mat1_roi, dst_roi, blockSize, apertureSize, kk, borderType);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::cornerHarris(clmat1_roi, cldst_roi, blockSize, apertureSize, kk, borderType);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_cldst;
|
||
|
|
cldst.download(cpu_cldst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
double kk = 2;
|
||
|
|
int blockSize = 7, apertureSize= 3;
|
||
|
|
int borderType = cv::BORDER_REFLECT;
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
};
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::cornerHarris(clmat1_roi, cldst_roi, blockSize, apertureSize, kk, borderType);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
////////////////////////////////integral/////////////////////////////////////////////////
|
||
|
|
|
||
|
|
struct integral : ImgprocTestBase {};
|
||
|
|
|
||
|
|
TEST_P(integral, Mat)
|
||
|
|
{
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::integral(mat1_roi, dst_roi, dst1_roi);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
}
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::integral(clmat1_roi, cldst_roi, cldst1_roi);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_cldst;
|
||
|
|
cv::Mat cpu_cldst1;
|
||
|
|
cldst.download(cpu_cldst);//download
|
||
|
|
cldst1.download(cpu_cldst1);
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
if(type1!=nulltype)
|
||
|
|
{
|
||
|
|
clmat1_roi = clmat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
};
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::integral(clmat1_roi, cldst_roi, cldst1_roi);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
// warpAffine & warpPerspective
|
||
|
|
|
||
|
|
PARAM_TEST_CASE(WarpTestBase, MatType, int)
|
||
|
|
{
|
||
|
|
int type;
|
||
|
|
cv::Size size;
|
||
|
|
int interpolation;
|
||
|
|
|
||
|
|
//src mat
|
||
|
|
cv::Mat mat1;
|
||
|
|
cv::Mat dst;
|
||
|
|
|
||
|
|
// set up roi
|
||
|
|
int src_roicols;
|
||
|
|
int src_roirows;
|
||
|
|
int dst_roicols;
|
||
|
|
int dst_roirows;
|
||
|
|
int src1x;
|
||
|
|
int src1y;
|
||
|
|
int dstx;
|
||
|
|
int dsty;
|
||
|
|
|
||
|
|
|
||
|
|
//src mat with roi
|
||
|
|
cv::Mat mat1_roi;
|
||
|
|
cv::Mat dst_roi;
|
||
|
12 years ago
|
//std::vector<cv::ocl::Info> oclinfo;
|
||
|
12 years ago
|
//ocl dst mat for testing
|
||
|
|
cv::ocl::oclMat gdst_whole;
|
||
|
|
|
||
|
|
//ocl mat with roi
|
||
|
|
cv::ocl::oclMat gmat1;
|
||
|
|
cv::ocl::oclMat gdst;
|
||
|
|
|
||
|
|
virtual void SetUp()
|
||
|
|
{
|
||
|
|
type = GET_PARAM(0);
|
||
|
|
//dsize = GET_PARAM(1);
|
||
|
|
interpolation = GET_PARAM(1);
|
||
|
|
|
||
|
|
cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
size = cv::Size(MWIDTH, MHEIGHT);
|
||
|
|
|
||
|
|
mat1 = randomMat(rng, size, type, 5, 16, false);
|
||
|
|
dst = randomMat(rng, size, type, 5, 16, false);
|
||
|
|
|
||
|
12 years ago
|
//int devnums = getDevice(oclinfo);
|
||
|
|
//CV_Assert(devnums > 0);
|
||
|
|
////if you want to use undefault device, set it here
|
||
|
|
////setDevice(oclinfo[0]);
|
||
|
|
//cv::ocl::setBinpath(CLBINPATH);
|
||
|
12 years ago
|
}
|
||
|
|
void Has_roi(int b)
|
||
|
|
{
|
||
|
|
//cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
if(b)
|
||
|
|
{
|
||
|
|
//randomize ROI
|
||
|
|
src_roicols = mat1.cols-1; //start
|
||
|
|
src_roirows = mat1.rows-1;
|
||
|
|
dst_roicols=dst.cols-1;
|
||
|
|
dst_roirows=dst.rows-1;
|
||
|
|
src1x = 1;
|
||
|
|
src1y = 1;
|
||
|
|
dstx = 1;
|
||
|
|
dsty =1;
|
||
|
|
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
src_roicols = mat1.cols;
|
||
|
|
src_roirows = mat1.rows;
|
||
|
|
dst_roicols=dst.cols;
|
||
|
|
dst_roirows=dst.rows;
|
||
|
|
src1x = 0;
|
||
|
|
src1y = 0;
|
||
|
|
dstx = 0;
|
||
|
|
dsty = 0;
|
||
|
|
|
||
|
|
};
|
||
|
|
mat1_roi = mat1(Rect(src1x,src1y,src_roicols,src_roirows));
|
||
|
|
dst_roi = dst(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
/////warpAffine
|
||
|
|
|
||
|
|
struct WarpAffine : WarpTestBase{};
|
||
|
|
|
||
|
|
TEST_P(WarpAffine, Mat)
|
||
|
|
{
|
||
|
|
static const double coeffs[2][3] =
|
||
|
|
{
|
||
|
|
{cos(3.14 / 6), -sin(3.14 / 6), 100.0},
|
||
|
|
{sin(3.14 / 6), cos(3.14 / 6), -100.0}
|
||
|
|
};
|
||
|
|
Mat M(2, 3, CV_64F, (void*)coeffs);
|
||
|
|
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::warpAffine(mat1_roi, dst_roi, M, size, interpolation);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
gdst_whole = dst;
|
||
|
|
gdst = gdst_whole(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
|
||
|
|
gmat1 = mat1_roi;
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::warpAffine(gmat1, gdst, M, size, interpolation);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_dst;
|
||
|
|
gdst_whole.download (cpu_dst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
gdst_whole = dst;
|
||
|
|
gdst = gdst_whole(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
gmat1 = mat1_roi;
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::warpAffine(gmat1, gdst, M, size, interpolation);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// warpPerspective
|
||
|
|
|
||
|
|
struct WarpPerspective : WarpTestBase{};
|
||
|
|
|
||
|
|
TEST_P(WarpPerspective, Mat)
|
||
|
|
{
|
||
|
|
static const double coeffs[3][3] =
|
||
|
|
{
|
||
|
|
{cos(3.14 / 6), -sin(3.14 / 6), 100.0},
|
||
|
|
{sin(3.14 / 6), cos(3.14 / 6), -100.0},
|
||
|
|
{0.0, 0.0, 1.0}
|
||
|
|
};
|
||
|
|
Mat M(3, 3, CV_64F, (void*)coeffs);
|
||
|
|
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::warpPerspective(mat1_roi, dst_roi, M, size, interpolation);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
gdst_whole = dst;
|
||
|
|
gdst = gdst_whole(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
|
||
|
|
gmat1 = mat1_roi;
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::warpPerspective(gmat1, gdst, M, size, interpolation);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_dst;
|
||
|
|
gdst_whole.download (cpu_dst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
gdst_whole = dst;
|
||
|
|
gdst = gdst_whole(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
gmat1 = mat1_roi;
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::warpPerspective(gmat1, gdst, M, size, interpolation);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
12 years ago
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
// remap
|
||
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
PARAM_TEST_CASE(Remap, MatType, MatType, MatType, int, int)
|
||
|
|
{
|
||
|
|
int srcType;
|
||
|
|
int map1Type;
|
||
|
|
int map2Type;
|
||
|
|
cv::Scalar val;
|
||
|
|
|
||
|
|
int interpolation;
|
||
|
|
int bordertype;
|
||
|
|
|
||
|
|
cv::Mat src;
|
||
|
|
cv::Mat dst;
|
||
|
|
cv::Mat map1;
|
||
|
|
cv::Mat map2;
|
||
|
|
|
||
|
|
|
||
|
|
int src_roicols;
|
||
|
|
int src_roirows;
|
||
|
|
int dst_roicols;
|
||
|
|
int dst_roirows;
|
||
|
|
int map1_roicols;
|
||
|
|
int map1_roirows;
|
||
|
|
int map2_roicols;
|
||
|
|
int map2_roirows;
|
||
|
|
int srcx;
|
||
|
|
int srcy;
|
||
|
|
int dstx;
|
||
|
|
int dsty;
|
||
|
|
int map1x;
|
||
|
|
int map1y;
|
||
|
|
int map2x;
|
||
|
|
int map2y;
|
||
|
|
|
||
|
|
cv::Mat src_roi;
|
||
|
|
cv::Mat dst_roi;
|
||
|
|
cv::Mat map1_roi;
|
||
|
|
cv::Mat map2_roi;
|
||
|
|
|
||
|
|
//ocl mat for testing
|
||
|
|
cv::ocl::oclMat gdst;
|
||
|
|
|
||
|
|
//ocl mat with roi
|
||
|
|
cv::ocl::oclMat gsrc_roi;
|
||
|
|
cv::ocl::oclMat gdst_roi;
|
||
|
|
cv::ocl::oclMat gmap1_roi;
|
||
|
|
cv::ocl::oclMat gmap2_roi;
|
||
|
|
|
||
|
|
virtual void SetUp()
|
||
|
|
{
|
||
|
|
srcType = GET_PARAM(0);
|
||
|
|
map1Type = GET_PARAM(1);
|
||
|
|
map2Type = GET_PARAM(2);
|
||
|
|
interpolation = GET_PARAM(3);
|
||
|
|
bordertype = GET_PARAM(4);
|
||
|
|
|
||
|
|
cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
cv::Size srcSize = cv::Size(MWIDTH, MHEIGHT);
|
||
|
|
cv::Size dstSize = cv::Size(MWIDTH, MHEIGHT);
|
||
|
|
cv::Size map1Size = cv::Size(MWIDTH, MHEIGHT);
|
||
|
|
double min = 5, max = 16;
|
||
|
|
|
||
|
|
if(srcType != nulltype)
|
||
|
|
{
|
||
|
|
src = randomMat(rng, srcSize, srcType, min, max, false);
|
||
|
|
}
|
||
|
|
if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2&& map2Type == nulltype))
|
||
|
|
{
|
||
|
|
map1 = randomMat(rng, map1Size, map1Type, min, max, false);
|
||
|
|
|
||
|
|
}
|
||
|
|
else if (map1Type == CV_32FC1 && map2Type == CV_32FC1)
|
||
|
|
{
|
||
|
|
map1 = randomMat(rng, map1Size, map1Type, min, max, false);
|
||
|
|
map2 = randomMat(rng, map1Size, map1Type, min, max, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
else
|
||
|
|
cout<<"The wrong input type"<<endl;
|
||
|
|
|
||
|
|
dst = randomMat(rng, map1Size, srcType, min, max, false);
|
||
|
|
switch (src.channels())
|
||
|
|
{
|
||
|
|
case 1:
|
||
|
|
val = cv::Scalar(rng.uniform(0.0, 10.0), 0, 0, 0);
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
val = cv::Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), 0, 0);
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
val = cv::Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), 0);
|
||
|
|
break;
|
||
|
|
case 4:
|
||
|
|
val = cv::Scalar(rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0), rng.uniform(0.0, 10.0));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
//int devnums = getDevice(oclinfo);
|
||
|
|
//CV_Assert(devnums > 0);
|
||
|
|
//if you want to use undefault device, set it here
|
||
|
|
//setDevice(oclinfo[0]);
|
||
|
|
//cv::ocl::setBinpath(CLBINPATH);
|
||
|
|
}
|
||
|
|
void Has_roi(int b)
|
||
|
|
{
|
||
|
|
if(b)
|
||
|
|
{
|
||
|
|
//randomize ROI
|
||
|
|
dst_roicols = dst.cols - 1;
|
||
|
|
dst_roirows = dst.rows - 1;
|
||
|
|
|
||
|
|
src_roicols = src.cols - 1;
|
||
|
|
src_roirows = src.rows - 1;
|
||
|
|
|
||
|
|
|
||
|
|
srcx = 1;
|
||
|
|
srcy = 1;
|
||
|
|
dstx = 1;
|
||
|
|
dsty = 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
dst_roicols = dst.cols;
|
||
|
|
dst_roirows = dst.rows;
|
||
|
|
|
||
|
|
src_roicols = src.cols;
|
||
|
|
src_roirows = src.rows;
|
||
|
|
|
||
|
|
|
||
|
|
srcx = 0;
|
||
|
|
srcy = 0;
|
||
|
|
dstx = 0;
|
||
|
|
dsty = 0;
|
||
|
|
}
|
||
|
|
map1_roicols = dst_roicols;
|
||
|
|
map1_roirows = dst_roirows;
|
||
|
|
map2_roicols = dst_roicols;
|
||
|
|
map2_roirows = dst_roirows;
|
||
|
|
map1x = dstx;
|
||
|
|
map1y = dsty;
|
||
|
|
map2x = dstx;
|
||
|
|
map2y = dsty;
|
||
|
|
|
||
|
|
if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2&& map2Type == nulltype))
|
||
|
|
{
|
||
|
|
map1_roi = map1(Rect(map1x,map1y,map1_roicols,map1_roirows));
|
||
|
|
gmap1_roi = map1_roi;
|
||
|
|
}
|
||
|
|
|
||
|
|
else if (map1Type == CV_32FC1 && map2Type == CV_32FC1)
|
||
|
|
{
|
||
|
|
map1_roi = map1(Rect(map1x,map1y,map1_roicols,map1_roirows));
|
||
|
|
map2_roi = map2(Rect(map2x,map2y,map2_roicols,map2_roirows));
|
||
|
|
gmap1_roi = map1_roi;
|
||
|
|
gmap2_roi = map2_roi;
|
||
|
|
}
|
||
|
|
dst_roi = dst(Rect(dstx, dsty, dst_roicols, dst_roirows));
|
||
|
|
src_roi = dst(Rect(srcx, srcy, src_roicols, src_roirows));
|
||
|
|
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
TEST_P(Remap, Mat)
|
||
|
|
{
|
||
|
|
if((interpolation == 1 && map1Type == CV_16SC2) ||(map1Type == CV_32FC1 && map2Type == nulltype) || (map1Type == CV_16SC2 && map2Type == CV_32FC1) || (map1Type == CV_32FC2 && map2Type == CV_32FC1))
|
||
|
|
{
|
||
|
|
cout << "LINEAR don't support the map1Type and map2Type" << endl;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int bordertype[] = {cv::BORDER_CONSTANT,cv::BORDER_REPLICATE/*,BORDER_REFLECT,BORDER_WRAP,BORDER_REFLECT_101*/};
|
||
|
|
const char* borderstr[]={"BORDER_CONSTANT", "BORDER_REPLICATE"/*, "BORDER_REFLECT","BORDER_WRAP","BORDER_REFLECT_101"*/};
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
|
for(int k = 0; k < 2; k++){
|
||
|
|
totalcputick = 0;
|
||
|
|
totalgputick = 0;
|
||
|
|
totalgputick_kernel = 0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::remap(src_roi, dst_roi, map1_roi, map2_roi, interpolation, bordertype[0], val);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start
|
||
|
|
gsrc_roi = src_roi;
|
||
|
|
gdst = dst;
|
||
|
|
gdst_roi = gdst(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
|
||
|
|
t2 = (double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, interpolation, bordertype[0], val);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
|
||
|
|
cv::Mat cpu_dst;
|
||
|
|
gdst.download(cpu_dst);
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end
|
||
|
|
|
||
|
|
if (j == 0)
|
||
|
|
continue;
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
for(int j = 0; j < 2; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
gdst = dst;
|
||
|
|
gdst_roi = gdst(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
gsrc_roi = src_roi;
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, interpolation, bordertype[0], val);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
12 years ago
|
|
||
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
// resize
|
||
|
|
|
||
|
|
PARAM_TEST_CASE(Resize, MatType, cv::Size, double, double, int)
|
||
|
|
{
|
||
|
|
int type;
|
||
|
|
cv::Size dsize;
|
||
|
|
double fx, fy;
|
||
|
|
int interpolation;
|
||
|
|
|
||
|
|
//src mat
|
||
|
|
cv::Mat mat1;
|
||
|
|
cv::Mat dst;
|
||
|
|
|
||
|
|
// set up roi
|
||
|
|
int src_roicols;
|
||
|
|
int src_roirows;
|
||
|
|
int dst_roicols;
|
||
|
|
int dst_roirows;
|
||
|
|
int src1x;
|
||
|
|
int src1y;
|
||
|
|
int dstx;
|
||
|
|
int dsty;
|
||
|
|
|
||
|
|
|
||
|
|
//src mat with roi
|
||
|
|
cv::Mat mat1_roi;
|
||
|
|
cv::Mat dst_roi;
|
||
|
12 years ago
|
//std::vector<cv::ocl::Info> oclinfo;
|
||
|
12 years ago
|
//ocl dst mat for testing
|
||
|
|
cv::ocl::oclMat gdst_whole;
|
||
|
|
|
||
|
|
//ocl mat with roi
|
||
|
|
cv::ocl::oclMat gmat1;
|
||
|
|
cv::ocl::oclMat gdst;
|
||
|
|
|
||
|
|
virtual void SetUp()
|
||
|
|
{
|
||
|
|
type = GET_PARAM(0);
|
||
|
|
dsize = GET_PARAM(1);
|
||
|
|
fx = GET_PARAM(2);
|
||
|
|
fy = GET_PARAM(3);
|
||
|
|
interpolation = GET_PARAM(4);
|
||
|
|
|
||
|
|
cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
cv::Size size(MWIDTH, MHEIGHT);
|
||
|
|
|
||
|
|
if(dsize == cv::Size() && !(fx > 0 && fy > 0))
|
||
|
|
{
|
||
|
|
cout << "invalid dsize and fx fy" << endl;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(dsize == cv::Size())
|
||
|
|
{
|
||
|
|
dsize.width = (int)(size.width * fx);
|
||
|
|
dsize.height = (int)(size.height * fy);
|
||
|
|
}
|
||
|
|
|
||
|
|
mat1 = randomMat(rng, size, type, 5, 16, false);
|
||
|
|
dst = randomMat(rng, dsize, type, 5, 16, false);
|
||
|
|
|
||
|
12 years ago
|
//int devnums = getDevice(oclinfo);
|
||
|
|
//CV_Assert(devnums > 0);
|
||
|
|
////if you want to use undefault device, set it here
|
||
|
|
////setDevice(oclinfo[0]);
|
||
|
|
//cv::ocl::setBinpath(CLBINPATH);
|
||
|
12 years ago
|
}
|
||
|
|
void Has_roi(int b)
|
||
|
|
{
|
||
|
|
//cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
if(b)
|
||
|
|
{
|
||
|
|
//randomize ROI
|
||
|
|
src_roicols = mat1.cols-1; //start
|
||
|
|
src_roirows = mat1.rows-1;
|
||
|
|
dst_roicols=dst.cols-1;
|
||
|
|
dst_roirows=dst.rows-1;
|
||
|
|
src1x = 1;
|
||
|
|
src1y = 1;
|
||
|
|
dstx = 1;
|
||
|
|
dsty =1;
|
||
|
|
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
src_roicols = mat1.cols;
|
||
|
|
src_roirows = mat1.rows;
|
||
|
|
dst_roicols=dst.cols;
|
||
|
|
dst_roirows=dst.rows;
|
||
|
|
src1x = 0;
|
||
|
|
src1y = 0;
|
||
|
|
dstx = 0;
|
||
|
|
dsty = 0;
|
||
|
|
|
||
|
|
};
|
||
|
|
mat1_roi = mat1(Rect(src1x,src1y,src_roicols,src_roirows));
|
||
|
|
dst_roi = dst(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
TEST_P(Resize, Mat)
|
||
|
|
{
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::resize(mat1_roi, dst_roi, dsize, fx, fy, interpolation);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
gdst_whole = dst;
|
||
|
|
gdst = gdst_whole(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
|
||
|
|
gmat1 = mat1_roi;
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::resize(gmat1, gdst, dsize, fx, fy, interpolation);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
cv::Mat cpu_dst;
|
||
|
|
gdst_whole.download (cpu_dst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
gdst_whole = dst;
|
||
|
|
gdst = gdst_whole(Rect(dstx,dsty,dst_roicols,dst_roirows));
|
||
|
|
gmat1 = mat1_roi;
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::resize(gmat1, gdst, dsize, fx, fy, interpolation);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
//threshold
|
||
|
|
|
||
|
|
PARAM_TEST_CASE(Threshold, MatType, ThreshOp)
|
||
|
|
{
|
||
|
|
int type;
|
||
|
|
int threshOp;
|
||
|
|
|
||
|
|
//src mat
|
||
|
|
cv::Mat mat1;
|
||
|
|
cv::Mat dst;
|
||
|
|
|
||
|
|
// set up roi
|
||
|
|
int roicols;
|
||
|
|
int roirows;
|
||
|
|
int src1x;
|
||
|
|
int src1y;
|
||
|
|
int dstx;
|
||
|
|
int dsty;
|
||
|
|
|
||
|
|
//src mat with roi
|
||
|
|
cv::Mat mat1_roi;
|
||
|
|
cv::Mat dst_roi;
|
||
|
12 years ago
|
//std::vector<cv::ocl::Info> oclinfo;
|
||
|
12 years ago
|
//ocl dst mat for testing
|
||
|
|
cv::ocl::oclMat gdst_whole;
|
||
|
|
|
||
|
|
//ocl mat with roi
|
||
|
|
cv::ocl::oclMat gmat1;
|
||
|
|
cv::ocl::oclMat gdst;
|
||
|
|
|
||
|
|
virtual void SetUp()
|
||
|
|
{
|
||
|
|
type = GET_PARAM(0);
|
||
|
|
threshOp = GET_PARAM(1);
|
||
|
|
|
||
|
|
cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
cv::Size size(MWIDTH, MHEIGHT);
|
||
|
|
|
||
|
|
mat1 = randomMat(rng, size, type, 5, 16, false);
|
||
|
|
dst = randomMat(rng, size, type, 5, 16, false);
|
||
|
|
|
||
|
12 years ago
|
//int devnums = getDevice(oclinfo);
|
||
|
|
//CV_Assert(devnums > 0);
|
||
|
|
////if you want to use undefault device, set it here
|
||
|
|
////setDevice(oclinfo[0]);
|
||
|
|
//cv::ocl::setBinpath(CLBINPATH);
|
||
|
12 years ago
|
}
|
||
|
|
void Has_roi(int b)
|
||
|
|
{
|
||
|
|
//cv::RNG& rng = TS::ptr()->get_rng();
|
||
|
|
if(b)
|
||
|
|
{
|
||
|
|
//randomize ROI
|
||
|
|
roicols = mat1.cols-1; //start
|
||
|
|
roirows = mat1.rows-1;
|
||
|
|
src1x = 1;
|
||
|
|
src1y = 1;
|
||
|
|
dstx = 1;
|
||
|
|
dsty =1;
|
||
|
|
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
roicols = mat1.cols;
|
||
|
|
roirows = mat1.rows;
|
||
|
|
src1x = 0;
|
||
|
|
src1y = 0;
|
||
|
|
dstx = 0;
|
||
|
|
dsty = 0;
|
||
|
|
|
||
|
|
};
|
||
|
|
mat1_roi = mat1(Rect(src1x,src1y,roicols,roirows));
|
||
|
|
dst_roi = dst(Rect(dstx,dsty,roicols,roirows));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
TEST_P(Threshold, Mat)
|
||
|
|
{
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
12 years ago
|
for(int k=LOOPROISTART;k<LOOPROIEND;k++){
|
||
|
12 years ago
|
totalcputick=0;
|
||
|
|
totalgputick=0;
|
||
|
|
totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
double maxVal = randomDouble(20.0, 127.0);
|
||
|
|
double thresh = randomDouble(0.0, maxVal);
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
cv::threshold(mat1_roi, dst_roi, thresh, maxVal, threshOp);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
|
||
|
|
gdst_whole = dst;
|
||
|
|
gdst = gdst_whole(Rect(dstx,dsty,roicols,roirows));
|
||
|
|
gmat1 = mat1_roi;
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::threshold(gmat1, gdst, thresh, maxVal, threshOp);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
|
||
|
|
cv::Mat cpu_dst;
|
||
|
|
gdst_whole.download (cpu_dst);//download
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
double maxVal = randomDouble(20.0, 127.0);
|
||
|
|
double thresh = randomDouble(0.0, maxVal);
|
||
|
|
gdst_whole = dst;
|
||
|
|
gdst = gdst_whole(Rect(dstx,dsty,roicols,roirows));
|
||
|
|
gmat1 = mat1_roi;
|
||
|
|
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::threshold(gmat1, gdst, thresh, maxVal, threshOp);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
//meanShift
|
||
|
|
|
||
|
|
PARAM_TEST_CASE(meanShiftTestBase, MatType, MatType, int, int, cv::TermCriteria)
|
||
|
|
{
|
||
|
|
int type, typeCoor;
|
||
|
|
int sp, sr;
|
||
|
|
cv::TermCriteria crit;
|
||
|
|
//src mat
|
||
|
|
cv::Mat src;
|
||
|
|
cv::Mat dst;
|
||
|
|
cv::Mat dstCoor;
|
||
|
|
|
||
|
|
//set up roi
|
||
|
|
int roicols;
|
||
|
|
int roirows;
|
||
|
|
int srcx;
|
||
|
|
int srcy;
|
||
|
|
int dstx;
|
||
|
|
int dsty;
|
||
|
|
|
||
|
|
//src mat with roi
|
||
|
|
cv::Mat src_roi;
|
||
|
|
cv::Mat dst_roi;
|
||
|
|
cv::Mat dstCoor_roi;
|
||
|
|
|
||
|
|
//ocl dst mat
|
||
|
|
cv::ocl::oclMat gdst;
|
||
|
|
cv::ocl::oclMat gdstCoor;
|
||
|
|
|
||
|
12 years ago
|
//std::vector<cv::ocl::Info> oclinfo;
|
||
|
12 years ago
|
//ocl mat with roi
|
||
|
|
cv::ocl::oclMat gsrc_roi;
|
||
|
|
cv::ocl::oclMat gdst_roi;
|
||
|
|
cv::ocl::oclMat gdstCoor_roi;
|
||
|
|
|
||
|
|
virtual void SetUp()
|
||
|
|
{
|
||
|
|
type = GET_PARAM(0);
|
||
|
|
typeCoor = GET_PARAM(1);
|
||
|
|
sp = GET_PARAM(2);
|
||
|
|
sr = GET_PARAM(3);
|
||
|
|
crit = GET_PARAM(4);
|
||
|
|
|
||
|
|
cv::RNG &rng = TS::ptr()->get_rng();
|
||
|
|
|
||
|
|
// MWIDTH=256, MHEIGHT=256. defined in utility.hpp
|
||
|
|
cv::Size size = cv::Size(MWIDTH, MHEIGHT);
|
||
|
|
|
||
|
|
src = randomMat(rng, size, type, 5, 16, false);
|
||
|
|
dst = randomMat(rng, size, type, 5, 16, false);
|
||
|
|
dstCoor = randomMat(rng, size, typeCoor, 5, 16, false);
|
||
|
|
|
||
|
12 years ago
|
//int devnums = getDevice(oclinfo);
|
||
|
|
//CV_Assert(devnums > 0);
|
||
|
|
////if you want to use undefault device, set it here
|
||
|
|
////setDevice(oclinfo[0]);
|
||
|
|
//cv::ocl::setBinpath(CLBINPATH);
|
||
|
12 years ago
|
}
|
||
|
|
|
||
|
|
void Has_roi(int b)
|
||
|
|
{
|
||
|
|
if(b)
|
||
|
|
{
|
||
|
|
//randomize ROI
|
||
|
|
roicols = src.cols - 1;
|
||
|
|
roirows = src.rows - 1;
|
||
|
|
srcx = 1;
|
||
|
|
srcy = 1;
|
||
|
|
dstx = 1;
|
||
|
|
dsty = 1;
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
roicols = src.cols;
|
||
|
|
roirows = src.rows;
|
||
|
|
srcx = 0;
|
||
|
|
srcy = 0;
|
||
|
|
dstx = 0;
|
||
|
|
dsty = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
src_roi = src(Rect(srcx, srcy, roicols, roirows));
|
||
|
|
dst_roi = dst(Rect(dstx, dsty, roicols, roirows));
|
||
|
|
dstCoor_roi = dstCoor(Rect(dstx, dsty, roicols, roirows));
|
||
|
|
|
||
|
|
gdst = dst;
|
||
|
|
gdstCoor = dstCoor;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/////////////////////////meanShiftFiltering/////////////////////////////
|
||
|
|
struct meanShiftFiltering : meanShiftTestBase {};
|
||
|
|
|
||
|
|
TEST_P(meanShiftFiltering, Mat)
|
||
|
|
{
|
||
|
|
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
|
for(int k=0;k<2;k++)
|
||
|
|
{
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
|
||
|
|
gsrc_roi = src_roi;
|
||
|
|
gdst_roi = gdst(Rect(dstx, dsty, roicols, roirows)); //gdst_roi
|
||
|
|
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::meanShiftFiltering(gsrc_roi, gdst_roi, sp, sr, crit);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
|
||
|
|
cv::Mat cpu_gdst;
|
||
|
|
gdst.download(cpu_gdst);//download
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
|
||
|
|
gsrc_roi = src_roi;
|
||
|
|
gdst_roi = gdst(Rect(dstx, dsty, roicols, roirows)); //gdst_roi
|
||
|
|
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::meanShiftFiltering(gsrc_roi, gdst_roi, sp, sr, crit);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
///////////////////////////meanShiftProc//////////////////////////////////
|
||
|
|
struct meanShiftProc : meanShiftTestBase {};
|
||
|
|
|
||
|
|
TEST_P(meanShiftProc, Mat)
|
||
|
|
{
|
||
|
|
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
|
for(int k=0;k<2;k++)
|
||
|
|
{
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
|
||
|
|
gsrc_roi = src_roi;
|
||
|
|
gdst_roi = gdst(Rect(dstx, dsty, roicols, roirows)); //gdst_roi
|
||
|
|
gdstCoor_roi = gdstCoor(Rect(dstx, dsty, roicols, roirows));
|
||
|
|
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::meanShiftProc(gsrc_roi, gdst_roi, gdstCoor_roi, sp, sr, crit);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
|
||
|
|
cv::Mat cpu_gdstCoor;
|
||
|
|
gdstCoor.download(cpu_gdstCoor);//download
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
12 years ago
|
for(int j = LOOPROISTART; j < LOOPROIEND; j ++)
|
||
|
12 years ago
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
|
||
|
|
gsrc_roi = src_roi;
|
||
|
|
gdst_roi = gdst(Rect(dstx, dsty, roicols, roirows)); //gdst_roi
|
||
|
|
gdstCoor_roi = gdstCoor(Rect(dstx, dsty, roicols, roirows));
|
||
|
|
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::meanShiftProc(gsrc_roi, gdst_roi, gdstCoor_roi, sp, sr, crit);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
12 years ago
|
///////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
//hist
|
||
|
|
|
||
|
|
void calcHistGold(const cv::Mat& src, cv::Mat& hist)
|
||
|
|
{
|
||
|
|
hist.create(1, 256, CV_32SC1);
|
||
|
|
hist.setTo(cv::Scalar::all(0));
|
||
|
|
|
||
|
|
int* hist_row = hist.ptr<int>();
|
||
|
|
for (int y = 0; y < src.rows; ++y)
|
||
|
|
{
|
||
|
|
const uchar* src_row = src.ptr(y);
|
||
|
|
|
||
|
|
for (int x = 0; x < src.cols; ++x)
|
||
|
|
++hist_row[src_row[x]];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
PARAM_TEST_CASE(histTestBase, MatType, MatType)
|
||
|
|
{
|
||
|
|
int type_src;
|
||
|
|
|
||
|
|
//src mat
|
||
|
|
cv::Mat src;
|
||
|
|
cv::Mat dst_hist;
|
||
|
|
//set up roi
|
||
|
|
int roicols;
|
||
|
|
int roirows;
|
||
|
|
int srcx;
|
||
|
|
int srcy;
|
||
|
|
//src mat with roi
|
||
|
|
cv::Mat src_roi;
|
||
|
|
//ocl dst mat, dst_hist and gdst_hist don't have roi
|
||
|
|
cv::ocl::oclMat gdst_hist;
|
||
|
|
|
||
|
|
//ocl mat with roi
|
||
|
|
cv::ocl::oclMat gsrc_roi;
|
||
|
|
|
||
|
|
// std::vector<cv::ocl::Info> oclinfo;
|
||
|
|
|
||
|
|
virtual void SetUp()
|
||
|
|
{
|
||
|
|
type_src = GET_PARAM(0);
|
||
|
|
|
||
|
|
cv::RNG &rng = TS::ptr()->get_rng();
|
||
|
|
cv::Size size = cv::Size(MWIDTH, MHEIGHT);
|
||
|
|
|
||
|
|
src = randomMat(rng, size, type_src, 0, 256, false);
|
||
|
|
|
||
|
|
// int devnums = getDevice(oclinfo);
|
||
|
|
// CV_Assert(devnums > 0);
|
||
|
|
//if you want to use undefault device, set it here
|
||
|
|
//setDevice(oclinfo[0]);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Has_roi(int b)
|
||
|
|
{
|
||
|
|
if(b)
|
||
|
|
{
|
||
|
|
//randomize ROI
|
||
|
|
roicols = src.cols-1;
|
||
|
|
roirows = src.rows-1;
|
||
|
|
srcx = 1;
|
||
|
|
srcy = 1;
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
roicols = src.cols;
|
||
|
|
roirows = src.rows;
|
||
|
|
srcx = 0;
|
||
|
|
srcy = 0;
|
||
|
|
};
|
||
|
|
src_roi = src(Rect(srcx, srcy, roicols, roirows));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
///////////////////////////calcHist///////////////////////////////////////
|
||
|
|
struct calcHist : histTestBase {};
|
||
|
|
|
||
|
|
TEST_P(calcHist, Mat)
|
||
|
|
{
|
||
|
|
#ifndef PRINT_KERNEL_RUN_TIME
|
||
|
|
double t0=0;
|
||
|
|
double t1=0;
|
||
|
|
double t2=0;
|
||
|
|
for(int k=0;k<2;k++)
|
||
|
|
{
|
||
|
|
double totalcputick=0;
|
||
|
|
double totalgputick=0;
|
||
|
|
double totalgputick_kernel=0;
|
||
|
|
for(int j = 0; j < LOOP_TIMES+1; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(k);
|
||
|
|
|
||
|
|
t0 = (double)cvGetTickCount();//cpu start
|
||
|
|
calcHistGold(src_roi, dst_hist);
|
||
|
|
t0 = (double)cvGetTickCount() - t0;//cpu end
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount();//gpu start1
|
||
|
|
|
||
|
|
gsrc_roi = src_roi;
|
||
|
|
|
||
|
|
t2=(double)cvGetTickCount();//kernel
|
||
|
|
cv::ocl::calcHist(gsrc_roi, gdst_hist);
|
||
|
|
t2 = (double)cvGetTickCount() - t2;//kernel
|
||
|
|
|
||
|
|
cv::Mat cpu_hist;
|
||
|
|
gdst_hist.download(cpu_hist);//download
|
||
|
|
|
||
|
|
t1 = (double)cvGetTickCount() - t1;//gpu end1
|
||
|
|
|
||
|
|
if(j == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
totalcputick=t0+totalcputick;
|
||
|
|
totalgputick=t1+totalgputick;
|
||
|
|
totalgputick_kernel=t2+totalgputick_kernel;
|
||
|
|
|
||
|
|
}
|
||
|
|
if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";};
|
||
|
|
cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl;
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
for(int j = 0; j < 2; j ++)
|
||
|
|
{
|
||
|
|
Has_roi(j);
|
||
|
|
|
||
|
|
gsrc_roi = src_roi;
|
||
|
|
|
||
|
|
if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";};
|
||
|
|
cv::ocl::calcHist(gsrc_roi, gdst_hist);
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
}
|
||
|
12 years ago
|
|
||
|
|
|
||
|
|
//************test*******************
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(ImgprocTestBase, equalizeHist, Combine(
|
||
|
|
ONE_TYPE(CV_8UC1),
|
||
|
|
NULL_TYPE,
|
||
|
|
ONE_TYPE(CV_8UC1),
|
||
|
|
NULL_TYPE,
|
||
|
|
NULL_TYPE,
|
||
|
|
Values(false))); // Values(false) is the reserved parameter
|
||
|
|
|
||
|
|
//INSTANTIATE_TEST_CASE_P(ImgprocTestBase, bilateralFilter, Combine(
|
||
|
|
// ONE_TYPE(CV_8UC1),
|
||
|
|
// NULL_TYPE,
|
||
|
|
// ONE_TYPE(CV_8UC1),
|
||
|
|
// NULL_TYPE,
|
||
|
|
// NULL_TYPE,
|
||
|
|
// Values(false))); // Values(false) is the reserved parameter
|
||
|
|
//
|
||
|
|
//
|
||
|
|
//INSTANTIATE_TEST_CASE_P(ImgprocTestBase, CopyMakeBorder, Combine(
|
||
|
|
// Values(CV_8UC1, CV_8UC4/*, CV_32SC1*/),
|
||
|
|
// NULL_TYPE,
|
||
|
|
// Values(CV_8UC1,CV_8UC4/*,CV_32SC1*/),
|
||
|
|
// NULL_TYPE,
|
||
|
|
// NULL_TYPE,
|
||
|
|
// Values(false))); // Values(false) is the reserved parameter
|
||
|
|
|
||
|
12 years ago
|
INSTANTIATE_TEST_CASE_P(ImgprocTestBase, cornerMinEigenVal, Combine(
|
||
|
|
Values(CV_8UC1,CV_32FC1),
|
||
|
|
NULL_TYPE,
|
||
|
|
ONE_TYPE(CV_32FC1),
|
||
|
|
NULL_TYPE,
|
||
|
|
NULL_TYPE,
|
||
|
|
Values(false))); // Values(false) is the reserved parameter
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(ImgprocTestBase, cornerHarris, Combine(
|
||
|
|
Values(CV_8UC1,CV_32FC1),
|
||
|
|
NULL_TYPE,
|
||
|
|
ONE_TYPE(CV_32FC1),
|
||
|
|
NULL_TYPE,
|
||
|
|
NULL_TYPE,
|
||
|
|
Values(false))); // Values(false) is the reserved parameter
|
||
|
12 years ago
|
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(ImgprocTestBase, integral, Combine(
|
||
|
|
ONE_TYPE(CV_8UC1),
|
||
|
|
NULL_TYPE,
|
||
|
|
ONE_TYPE(CV_32SC1),
|
||
|
|
ONE_TYPE(CV_32FC1),
|
||
|
|
NULL_TYPE,
|
||
|
|
Values(false))); // Values(false) is the reserved parameter
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(Imgproc, WarpAffine, Combine(
|
||
|
|
Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4),
|
||
|
|
Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR,
|
||
|
|
(MatType)cv::INTER_CUBIC, (MatType)(cv::INTER_NEAREST | cv::WARP_INVERSE_MAP),
|
||
|
|
(MatType)(cv::INTER_LINEAR | cv::WARP_INVERSE_MAP), (MatType)(cv::INTER_CUBIC | cv::WARP_INVERSE_MAP))));
|
||
|
|
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(Imgproc, WarpPerspective, Combine
|
||
|
|
(Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4),
|
||
|
|
Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR,
|
||
|
|
(MatType)cv::INTER_CUBIC, (MatType)(cv::INTER_NEAREST | cv::WARP_INVERSE_MAP),
|
||
|
|
(MatType)(cv::INTER_LINEAR | cv::WARP_INVERSE_MAP), (MatType)(cv::INTER_CUBIC | cv::WARP_INVERSE_MAP))));
|
||
|
|
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(Imgproc, Resize, Combine(
|
||
|
|
Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(cv::Size()),
|
||
|
|
Values(0.5/*, 1.5, 2*/), Values(0.5/*, 1.5, 2*/), Values((MatType)cv::INTER_NEAREST, (MatType)cv::INTER_LINEAR)));
|
||
|
|
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(Imgproc, Threshold, Combine(
|
||
|
|
Values(CV_8UC1, CV_32FC1), Values(ThreshOp(cv::THRESH_BINARY),
|
||
|
|
ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC),
|
||
|
|
ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))));
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftFiltering, Combine(
|
||
|
|
ONE_TYPE(CV_8UC4),
|
||
|
|
ONE_TYPE(CV_16SC2),//it is no use in meanShiftFiltering
|
||
|
|
Values(5),
|
||
|
|
Values(6),
|
||
|
|
Values(cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 5, 1))
|
||
|
|
));
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftProc, Combine(
|
||
|
|
ONE_TYPE(CV_8UC4),
|
||
|
|
ONE_TYPE(CV_16SC2),
|
||
|
|
Values(5),
|
||
|
|
Values(6),
|
||
|
|
Values(cv::TermCriteria(cv::TermCriteria::COUNT+cv::TermCriteria::EPS, 5, 1))
|
||
|
|
));
|
||
|
|
|
||
|
12 years ago
|
INSTANTIATE_TEST_CASE_P(Imgproc, Remap, Combine(
|
||
|
|
Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4),
|
||
|
|
Values(CV_32FC1, CV_16SC2, CV_32FC2),Values(-1,CV_32FC1),
|
||
|
|
Values((int)cv::INTER_NEAREST, (int)cv::INTER_LINEAR),
|
||
|
|
Values((int)cv::BORDER_CONSTANT)));
|
||
|
|
|
||
|
|
INSTANTIATE_TEST_CASE_P(histTestBase, calcHist, Combine(
|
||
|
|
ONE_TYPE(CV_8UC1),
|
||
|
|
ONE_TYPE(CV_32SC1) //no use
|
||
|
|
));
|
||
|
12 years ago
|
|
||
|
|
#endif // HAVE_OPENCL
|