Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #1326 from ilya-lavrenov:perf_ocl

Browse Source
pull/1311/merge
Roman Donchenko 12 years ago committed by OpenCV Buildbot
parent d44adcd6e8 d02ccc9590
commit b43890a7e1
25 changed files with 2152 additions and 3746 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 131
      modules/ocl/perf/main.cpp
  2. 1476
      modules/ocl/perf/perf_arithm.cpp
  3. 90
      modules/ocl/perf/perf_blend.cpp
  4. 186
      modules/ocl/perf/perf_brute_force_matcher.cpp
  5. 62
      modules/ocl/perf/perf_calib3d.cpp
  6. 52
      modules/ocl/perf/perf_canny.cpp
  7. 57
      modules/ocl/perf/perf_color.cpp
  8. 56
      modules/ocl/perf/perf_fft.cpp
  9. 430
      modules/ocl/perf/perf_filters.cpp
  10. 58
      modules/ocl/perf/perf_gemm.cpp
  11. 74
      modules/ocl/perf/perf_gftt.cpp
  12. 72
      modules/ocl/perf/perf_haar.cpp
  13. 59
      modules/ocl/perf/perf_hog.cpp
  14. 937
      modules/ocl/perf/perf_imgproc.cpp
  15. 138
      modules/ocl/perf/perf_match_template.cpp
  16. 185
      modules/ocl/perf/perf_matrix_operation.cpp
  17. 65
      modules/ocl/perf/perf_moments.cpp
  18. 56
      modules/ocl/perf/perf_norm.cpp
  19. 447
      modules/ocl/perf/perf_opticalflow.cpp
  20. 449
      modules/ocl/perf/perf_precomp.cpp
  21. 472
      modules/ocl/perf/perf_precomp.hpp
  22. 116
      modules/ocl/perf/perf_pyramid.cpp
  23. 165
      modules/ocl/perf/perf_split_merge.cpp
  24. 2
      modules/ocl/src/arithm.cpp
  25. 63
      modules/ocl/test/test_norm.cpp

131
modules/ocl/perf/main.cpp
Unescape View File

@ -42,123 +42,54 @@
#include "perf_precomp.hpp"
int main(int argc, const char *argv[])
const char * impls[] =
{
const char *keys =
"{ h | help | false | print help message }"
"{ f | filter | | filter for test }"
"{ w | workdir | | set working directory }"
"{ l | list | false | show all tests }"
"{ d | device | 0 | device id }"
"{ c | cpu_ocl | false | use cpu as ocl device}"
"{ i | iters | 10 | iteration count }"
"{ m | warmup | 1 | gpu warm up iteration count}"
"{ t | xtop | 1.1 | xfactor top boundary}"
"{ b | xbottom | 0.9 | xfactor bottom boundary}"
"{ v | verify | false | only run gpu once to verify if problems occur}";
IMPL_OCL,
IMPL_PLAIN,
#ifdef HAVE_OPENCV_GPU
IMPL_GPU
#endif
};
int main(int argc, char ** argv)
{
const char * keys =
"{ h | help | false | print help message }"
"{ t | type | gpu | set device type:cpu or gpu}"
"{ p | platform | 0 | set platform id }"
"{ d | device | 0 | set device id }";
redirectError(cvErrorCallback);
CommandLineParser cmd(argc, argv, keys);
if (cmd.get<bool>("help"))
{
cout << "Avaible options:" << endl;
cout << "Available options besides google test option:" << endl;
cmd.printParams();
return 0;
}
// get ocl devices
bool use_cpu = cmd.get<bool>("c");
vector<ocl::Info> oclinfo;
int num_devices = 0;
if(use_cpu)
num_devices = getDevice(oclinfo, ocl::CVCL_DEVICE_TYPE_CPU);
else
num_devices = getDevice(oclinfo);
if (num_devices < 1)
{
cerr << "no device found\n";
return -1;
}
// show device info
int devidx = 0;
for (size_t i = 0; i < oclinfo.size(); i++)
{
for (size_t j = 0; j < oclinfo[i].DeviceName.size(); j++)
{
cout << "device " << devidx++ << ": " << oclinfo[i].DeviceName[j] << endl;
}
}
string type = cmd.get<string>("type");
unsigned int pid = cmd.get<unsigned int>("platform");
int device = cmd.get<int>("device");
if (device < 0 || device >= num_devices)
{
cerr << "Invalid device ID" << endl;
return -1;
}
// set this to overwrite binary cache every time the test starts
ocl::setBinaryDiskCache(ocl::CACHE_UPDATE);
if (cmd.get<bool>("verify"))
{
TestSystem::instance().setNumIters(1);
TestSystem::instance().setGPUWarmupIters(0);
TestSystem::instance().setCPUIters(0);
}
int flag = type == "cpu" ? cv::ocl::CVCL_DEVICE_TYPE_CPU :
cv::ocl::CVCL_DEVICE_TYPE_GPU;
devidx = 0;
for (size_t i = 0; i < oclinfo.size(); i++)
std::vector<cv::ocl::Info> oclinfo;
int devnums = cv::ocl::getDevice(oclinfo, flag);
if (devnums <= device || device < 0)
{
for (size_t j = 0; j < oclinfo[i].DeviceName.size(); j++, devidx++)
{
if (device == devidx)
{
ocl::setDevice(oclinfo[i], (int)j);
TestSystem::instance().setRecordName(oclinfo[i].DeviceName[j]);
cout << "use " << devidx << ": " <<oclinfo[i].DeviceName[j] << endl;
goto END_DEV;
}
}
}
END_DEV:
string filter = cmd.get<string>("filter");
string workdir = cmd.get<string>("workdir");
bool list = cmd.get<bool>("list");
int iters = cmd.get<int>("iters");
int wu_iters = cmd.get<int>("warmup");
double x_top = cmd.get<double>("xtop");
double x_bottom = cmd.get<double>("xbottom");
TestSystem::instance().setTopThreshold(x_top);
TestSystem::instance().setBottomThreshold(x_bottom);
if (!filter.empty())
{
TestSystem::instance().setTestFilter(filter);
}
if (!workdir.empty())
{
if (workdir[workdir.size() - 1] != '/' && workdir[workdir.size() - 1] != '\\')
{
workdir += '/';
}
TestSystem::instance().setWorkingDir(workdir);
std::cout << "device invalid\n";
return -1;
}
if (list)
if (pid >= oclinfo.size())
{
TestSystem::instance().setListMode(true);
std::cout << "platform invalid\n";
return -1;
}
TestSystem::instance().setNumIters(iters);
TestSystem::instance().setGPUWarmupIters(wu_iters);
TestSystem::instance().run();
cv::ocl::setDevice(oclinfo[pid], device);
cv::ocl::setBinaryDiskCache(cv::ocl::CACHE_UPDATE);
return 0;
CV_PERF_TEST_MAIN_INTERNALS(ocl, impls)
}

1476
modules/ocl/perf/perf_arithm.cpp
View File

File diff suppressed because it is too large Load Diff

90
modules/ocl/perf/perf_blend.cpp
Unescape View File

@ -45,9 +45,15 @@
//M*/
#include "perf_precomp.hpp"
using namespace perf;
///////////// blend ////////////////////////
template <typename T>
void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &weights1, const cv::Mat &weights2, cv::Mat &result_gold)
static void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2,
const cv::Mat &weights1, const cv::Mat &weights2,
cv::Mat &result_gold)
{
result_gold.create(img1.size(), img1.type());
@ -63,60 +69,46 @@ void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &we
for (int x = 0; x < img1.cols * cn; ++x)
{
float w1 = weights1_row[x / cn];
float w2 = weights2_row[x / cn];
result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f));
int x1 = x * cn;
float w1 = weights1_row[x];
float w2 = weights2_row[x];
result_gold_row[x] = static_cast<T>((img1_row[x1] * w1
+ img2_row[x1] * w2) / (w1 + w2 + 1e-5f));
}
}
}
PERFTEST(blend)
typedef TestBaseWithParam<Size> blendLinearFixture;
PERF_TEST_P(blendLinearFixture, blendLinear, OCL_TYPICAL_MAT_SIZES)
{
Mat src1, src2, weights1, weights2, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_weights1, d_weights2, d_dst;
const Size srcSize = GetParam();
const int type = CV_8UC1;
Mat src1(srcSize, type), src2(srcSize, CV_8UC1), dst;
Mat weights1(srcSize, CV_32FC1), weights2(srcSize, CV_32FC1);
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
declare.in(src1, src2, WARMUP_RNG);
randu(weights1, 0.0f, 1.0f);
randu(weights2, 0.0f, 1.0f);
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
if (RUN_OCL_IMPL)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] << " and CV_32FC1";
gen(src1, size, size, all_type[j], 0, 256);
gen(src2, size, size, all_type[j], 0, 256);
gen(weights1, size, size, CV_32FC1, 0, 1);
gen(weights2, size, size, CV_32FC1, 0, 1);
blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
CPU_ON;
blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
CPU_OFF;
d_src1.upload(src1);
d_src2.upload(src2);
d_weights1.upload(weights1);
d_weights2.upload(weights2);
WARMUP_ON;
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
WARMUP_OFF;
GPU_ON;
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
GPU_OFF;
GPU_FULL_ON;
d_src1.upload(src1);
d_src2.upload(src2);
d_weights1.upload(weights1);
d_weights2.upload(weights2);
ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.f);
}
ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst;
ocl::oclMat oclWeights1(weights1), oclWeights2(weights2);
TEST_CYCLE() cv::ocl::blendLinear(oclSrc1, oclSrc2, oclWeights1, oclWeights2, oclDst);
oclDst.download(dst);
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}

186
modules/ocl/perf/perf_brute_force_matcher.cpp
Unescape View File

@ -45,123 +45,119 @@
//M*/
#include "perf_precomp.hpp"
//////////////////// BruteForceMatch /////////////////
PERFTEST(BruteForceMatcher)
{
Mat trainIdx_cpu;
Mat distance_cpu;
Mat allDist_cpu;
Mat nMatches_cpu;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
// Init CPU matcher
int desc_len = 64;
BFMatcher matcher(NORM_L2);
Mat query;
gen(query, size, desc_len, CV_32F, 0, 1);
Mat train;
gen(train, size, desc_len, CV_32F, 0, 1);
// Output
vector< vector<DMatch> > matches(2);
vector< vector<DMatch> > d_matches(2);
// Init GPU matcher
ocl::BruteForceMatcher_OCL_base d_matcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
using namespace perf;
ocl::oclMat d_query(query);
ocl::oclMat d_train(train);
#define OCL_BFMATCHER_TYPICAL_MAT_SIZES ::testing::Values(cv::Size(128, 500), cv::Size(128, 1000), cv::Size(128, 2000))
ocl::oclMat d_trainIdx, d_distance, d_allDist, d_nMatches;
SUBTEST << size << "; match";
matcher.match(query, train, matches[0]);
//////////////////// BruteForceMatch /////////////////
CPU_ON;
matcher.match(query, train, matches[0]);
CPU_OFF;
typedef TestBaseWithParam<Size> BruteForceMatcherFixture;
WARMUP_ON;
d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
WARMUP_OFF;
PERF_TEST_P(BruteForceMatcherFixture, DISABLED_match,
OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too big difference between implementations
{
const Size srcSize = GetParam();
GPU_ON;
d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
GPU_OFF;
vector<DMatch> matches;
Mat query(srcSize, CV_32F), train(srcSize, CV_32F);
declare.in(query, train).time(srcSize.height == 2000 ? 8 : 4 );
randu(query, 0.0f, 1.0f);
randu(train, 0.0f, 1.0f);
GPU_FULL_ON;
d_query.upload(query);
d_train.upload(train);
d_matcher.match(d_query, d_train, d_matches[0]);
GPU_FULL_OFF;
if (RUN_PLAIN_IMPL)
{
BFMatcher matcher(NORM_L2);
TEST_CYCLE() matcher.match(query, train, matches);
int diff = abs((int)d_matches[0].size() - (int)matches[0].size());
if(diff == 0)
TestSystem::instance().setAccurate(1, 0);
else
TestSystem::instance().setAccurate(0, diff);
SANITY_CHECK_MATCHES(matches);
}
else if (RUN_OCL_IMPL)
{
ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
ocl::oclMat oclQuery(query), oclTrain(train);
SUBTEST << size << "; knnMatch";
TEST_CYCLE() oclMatcher.match(oclQuery, oclTrain, matches);
matcher.knnMatch(query, train, matches, 2);
SANITY_CHECK_MATCHES(matches);
}
else
OCL_PERF_ELSE
}
CPU_ON;
matcher.knnMatch(query, train, matches, 2);
CPU_OFF;
PERF_TEST_P(BruteForceMatcherFixture, DISABLED_knnMatch,
OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too many outliers
{
const Size srcSize = GetParam();
WARMUP_ON;
d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
WARMUP_OFF;
vector<vector<DMatch> > matches(2);
Mat query(srcSize, CV_32F), train(srcSize, CV_32F);
randu(query, 0.0f, 1.0f);
randu(train, 0.0f, 1.0f);
GPU_ON;
d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
GPU_OFF;
declare.in(query, train);
if (srcSize.height == 2000)
declare.time(8);
GPU_FULL_ON;
d_query.upload(query);
d_train.upload(train);
d_matcher.knnMatch(d_query, d_train, d_matches, 2);
GPU_FULL_OFF;
if (RUN_PLAIN_IMPL)
{
BFMatcher matcher (NORM_L2);
TEST_CYCLE() matcher.knnMatch(query, train, matches, 2);
diff = abs((int)d_matches[0].size() - (int)matches[0].size());
if(diff == 0)
TestSystem::instance().setAccurate(1, 0);
else
TestSystem::instance().setAccurate(0, diff);
std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
SANITY_CHECK_MATCHES(matches0);
SANITY_CHECK_MATCHES(matches1);
}
else if (RUN_OCL_IMPL)
{
ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
ocl::oclMat oclQuery(query), oclTrain(train);
SUBTEST << size << "; radiusMatch";
TEST_CYCLE() oclMatcher.knnMatch(oclQuery, oclTrain, matches, 2);
float max_distance = 2.0f;
std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
SANITY_CHECK_MATCHES(matches0);
SANITY_CHECK_MATCHES(matches1);
}
else
OCL_PERF_ELSE
}
matcher.radiusMatch(query, train, matches, max_distance);
PERF_TEST_P(BruteForceMatcherFixture, DISABLED_radiusMatch,
OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too many outliers
{
const Size srcSize = GetParam();
CPU_ON;
matcher.radiusMatch(query, train, matches, max_distance);
CPU_OFF;
const float max_distance = 2.0f;
vector<vector<DMatch> > matches(2);
Mat query(srcSize, CV_32F), train(srcSize, CV_32F);
declare.in(query, train);
Mat trainIdx, distance, allDist;
d_trainIdx.release();
randu(query, 0.0f, 1.0f);
randu(train, 0.0f, 1.0f);
WARMUP_ON;
d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
WARMUP_OFF;
if (RUN_PLAIN_IMPL)
{
BFMatcher matcher (NORM_L2);
TEST_CYCLE() matcher.radiusMatch(query, matches, max_distance);
GPU_ON;
d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
GPU_OFF;
std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
SANITY_CHECK_MATCHES(matches0);
SANITY_CHECK_MATCHES(matches1);
}
else if (RUN_OCL_IMPL)
{
ocl::oclMat oclQuery(query), oclTrain(train);
ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
GPU_FULL_ON;
d_query.upload(query);
d_train.upload(train);
d_matcher.radiusMatch(d_query, d_train, d_matches, max_distance);
GPU_FULL_OFF;
TEST_CYCLE() oclMatcher.radiusMatch(oclQuery, oclTrain, matches, max_distance);
diff = abs((int)d_matches[0].size() - (int)matches[0].size());
if(diff == 0)
TestSystem::instance().setAccurate(1, 0);
else
TestSystem::instance().setAccurate(0, diff);
std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
SANITY_CHECK_MATCHES(matches0);
SANITY_CHECK_MATCHES(matches1);
}
else
OCL_PERF_ELSE
}
#undef OCL_BFMATCHER_TYPICAL_MAT_SIZES

62
modules/ocl/perf/perf_calib3d.cpp
Unescape View File

@ -45,48 +45,44 @@
//M*/
#include "perf_precomp.hpp"
///////////// StereoMatchBM ////////////////////////
PERFTEST(StereoMatchBM)
{
Mat left_image = imread(abspath("aloeL.jpg"), cv::IMREAD_GRAYSCALE);
Mat right_image = imread(abspath("aloeR.jpg"), cv::IMREAD_GRAYSCALE);
Mat disp,dst;
ocl::oclMat d_left, d_right,d_disp;
int n_disp= 128;
int winSize =19;
SUBTEST << left_image.cols << 'x' << left_image.rows << "; aloeL.jpg ;"<< right_image.cols << 'x' << right_image.rows << "; aloeR.jpg ";
PERF_TEST(StereoMatchBMFixture, DISABLED_StereoMatchBM) // TODO doesn't work properly
{
Mat left_image = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE);
Mat right_image = imread(getDataPath("gpu/stereobm/aloe-R.png"), cv::IMREAD_GRAYSCALE);
StereoBM bm(0, n_disp, winSize);
bm(left_image, right_image, dst);
ASSERT_TRUE(!left_image.empty()) << "no input image";
ASSERT_TRUE(!right_image.empty()) << "no input image";
ASSERT_TRUE(right_image.size() == left_image.size());
ASSERT_TRUE(right_image.size() == left_image.size());
CPU_ON;
bm(left_image, right_image, dst);
CPU_OFF;
const int n_disp = 128, winSize = 19;
Mat disp(left_image.size(), CV_16SC1);
d_left.upload(left_image);
d_right.upload(right_image);
declare.in(left_image, right_image).out(disp);
ocl::StereoBM_OCL d_bm(0, n_disp, winSize);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclLeft(left_image), oclRight(right_image),
oclDisp(left_image.size(), CV_16SC1);
ocl::StereoBM_OCL oclBM(0, n_disp, winSize);
WARMUP_ON;
d_bm(d_left, d_right, d_disp);
WARMUP_OFF;
TEST_CYCLE() oclBM(oclLeft, oclRight, oclDisp);
cv::Mat ocl_mat;
d_disp.download(ocl_mat);
ocl_mat.convertTo(ocl_mat, dst.type());
oclDisp.download(disp);
GPU_ON;
d_bm(d_left, d_right, d_disp);
GPU_OFF;
SANITY_CHECK(disp);
}
else if (RUN_PLAIN_IMPL)
{
StereoBM bm(0, n_disp, winSize);
GPU_FULL_ON;
d_left.upload(left_image);
d_right.upload(right_image);
d_bm(d_left, d_right, d_disp);
d_disp.download(disp);
GPU_FULL_OFF;
TEST_CYCLE() bm(left_image, right_image, disp);
TestSystem::instance().setAccurate(-1, 0.);
SANITY_CHECK(disp);
}
else
OCL_PERF_ELSE
}

52
modules/ocl/perf/perf_canny.cpp
Unescape View File

@ -45,41 +45,33 @@
//M*/
#include "perf_precomp.hpp"
///////////// Canny ////////////////////////
PERFTEST(Canny)
{
Mat img = imread(abspath("aloeL.jpg"), CV_LOAD_IMAGE_GRAYSCALE);
if (img.empty())
{
throw runtime_error("can't open aloeL.jpg");
}
SUBTEST << img.cols << 'x' << img.rows << "; aloeL.jpg" << "; edges" << "; CV_8UC1";
using namespace perf;
Mat edges(img.size(), CV_8UC1), ocl_edges;
///////////// Canny ////////////////////////
CPU_ON;
Canny(img, edges, 50.0, 100.0);
CPU_OFF;
PERF_TEST(CannyFixture, DISABLED_Canny) // TODO difference between implmentations
{
Mat img = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE),
edges(img.size(), CV_8UC1);
ASSERT_TRUE(!img.empty()) << "can't open aloe-L.png";
ocl::oclMat d_img(img);
ocl::oclMat d_edges;
ocl::CannyBuf d_buf;
declare.in(img).out(edges);
WARMUP_ON;
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclImg(img), oclEdges(img.size(), CV_8UC1);
GPU_ON;
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
GPU_OFF;
TEST_CYCLE() ocl::Canny(oclImg, oclEdges, 50.0, 100.0);
oclEdges.download(edges);
GPU_FULL_ON;
d_img.upload(img);
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
d_edges.download(ocl_edges);
GPU_FULL_OFF;
SANITY_CHECK(edges);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() Canny(img, edges, 50.0, 100.0);
TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2);
SANITY_CHECK(edges);
}
else
OCL_PERF_ELSE
}

57
modules/ocl/perf/perf_color.cpp
Unescape View File

@ -45,49 +45,34 @@
//M*/
#include "perf_precomp.hpp"
///////////// cvtColor////////////////////////
PERFTEST(cvtColor)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC4};
std::string type_name[] = {"CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
gen(src, size, size, all_type[j], 0, 256);
SUBTEST << size << "x" << size << "; " << type_name[j] << " ; CV_RGBA2GRAY";
cvtColor(src, dst, CV_RGBA2GRAY, 4);
CPU_ON;
cvtColor(src, dst, CV_RGBA2GRAY, 4);
CPU_OFF;
using namespace perf;
d_src.upload(src);
///////////// cvtColor////////////////////////
WARMUP_ON;
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
WARMUP_OFF;
typedef TestBaseWithParam<Size> cvtColorFixture;
GPU_ON;
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
GPU_OFF;
PERF_TEST_P(cvtColorFixture, cvtColor, OCL_TYPICAL_MAT_SIZES)
{
const Size srcSize = GetParam();
GPU_FULL_ON;
d_src.upload(src);
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
Mat src(srcSize, CV_8UC4), dst(srcSize, CV_8UC4);
declare.in(src, WARMUP_RNG).out(dst);
TestSystem::instance().ExceptedMatSimilar(dst, ocl_dst, 1e-5);
}
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(src.size(), CV_8UC4);
TEST_CYCLE() ocl::cvtColor(oclSrc, oclDst, CV_RGBA2GRAY, 4);
oclDst.download(dst);
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::cvtColor(src, dst, CV_RGBA2GRAY, 4);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}

56
modules/ocl/perf/perf_fft.cpp
Unescape View File

@ -45,47 +45,39 @@
//M*/
#include "perf_precomp.hpp"
///////////// dft ////////////////////////
PERFTEST(dft)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_32FC2};
std::string type_name[] = {"CV_32FC2"};
using namespace perf;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; complex-to-complex";
///////////// dft ////////////////////////
gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(1));
typedef TestBaseWithParam<Size> dftFixture;
dft(src, dst);
PERF_TEST_P(dftFixture, DISABLED_dft, OCL_TYPICAL_MAT_SIZES) // TODO not implemented
{
const Size srcSize = GetParam();
CPU_ON;
dft(src, dst);
CPU_OFF;
Mat src(srcSize, CV_32FC2), dst;
randu(src, 0.0f, 1.0f);
declare.in(src);
d_src.upload(src);
if (srcSize == OCL_SIZE_4000)
declare.time(7.4);
WARMUP_ON;
ocl::dft(d_src, d_dst, Size(size, size));
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst;
GPU_ON;
ocl::dft(d_src, d_dst, Size(size, size));
GPU_OFF;
TEST_CYCLE() cv::ocl::dft(oclSrc, oclDst);
GPU_FULL_ON;
d_src.upload(src);
ocl::dft(d_src, d_dst, Size(size, size));
d_dst.download(ocl_dst);
GPU_FULL_OFF;
oclDst.download(dst);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, src.size().area() * 1e-4);
}
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::dft(src, dst);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}

430
modules/ocl/perf/perf_filters.cpp
Unescape View File

@ -45,333 +45,279 @@
//M*/
#include "perf_precomp.hpp"
///////////// Blur////////////////////////
PERFTEST(Blur)
{
Mat src1, dst, ocl_dst;
ocl::oclMat d_src1, d_dst;
using namespace perf;
using std::tr1::get;
using std::tr1::tuple;
Size ksize = Size(3, 3);
int bordertype = BORDER_CONSTANT;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
///////////// Blur////////////////////////
gen(src1, size, size, all_type[j], 0, 256);
gen(dst, size, size, all_type[j], 0, 256);
typedef Size_MatType BlurFixture;
blur(src1, dst, ksize, Point(-1, -1), bordertype);
PERF_TEST_P(BlurFixture, Blur,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params), ksize(3, 3);
const int type = get<1>(params), bordertype = BORDER_CONSTANT;
CPU_ON;
blur(src1, dst, ksize, Point(-1, -1), bordertype);
CPU_OFF;
Mat src(srcSize, type), dst(srcSize, type);
declare.in(src, WARMUP_RNG).out(dst);
d_src1.upload(src1);
if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
declare.time(5);
WARMUP_ON;
ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type);
GPU_ON;
ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
GPU_OFF;
TEST_CYCLE() cv::ocl::blur(oclSrc, oclDst, ksize, Point(-1, -1), bordertype);
GPU_FULL_ON;
d_src1.upload(src1);
ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
oclDst.download(dst);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
}
SANITY_CHECK(dst, 1 + DBL_EPSILON);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::blur(src, dst, ksize, Point(-1, -1), bordertype);
SANITY_CHECK(dst, 1 + DBL_EPSILON);
}
else
OCL_PERF_ELSE
}
///////////// Laplacian////////////////////////
PERFTEST(Laplacian)
{
Mat src1, dst, ocl_dst;
ocl::oclMat d_src1, d_dst;
int ksize = 3;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
///////////// Laplacian////////////////////////
gen(src1, size, size, all_type[j], 0, 256);
gen(dst, size, size, all_type[j], 0, 256);
typedef Size_MatType LaplacianFixture;
Laplacian(src1, dst, -1, ksize, 1);
PERF_TEST_P(LaplacianFixture, Laplacian,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params), ksize = 3;
CPU_ON;
Laplacian(src1, dst, -1, ksize, 1);
CPU_OFF;
Mat src(srcSize, type), dst(srcSize, type);
declare.in(src, WARMUP_RNG).out(dst);
d_src1.upload(src1);
if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
declare.time(6);
WARMUP_ON;
ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type);
GPU_ON;
ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
GPU_OFF;
TEST_CYCLE() cv::ocl::Laplacian(oclSrc, oclDst, -1, ksize, 1);
GPU_FULL_ON;
d_src1.upload(src1);
ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
oclDst.download(dst);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
}
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::Laplacian(src, dst, -1, ksize, 1);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
///////////// Erode ////////////////////
PERFTEST(Erode)
{
Mat src, dst, ker, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4", "CV_32FC1", "CV_32FC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(256));
ker = getStructuringElement(MORPH_RECT, Size(3, 3));
typedef Size_MatType ErodeFixture;
erode(src, dst, ker);
PERF_TEST_P(ErodeFixture, Erode,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params), ksize = 3;
const Mat ker = getStructuringElement(MORPH_RECT, Size(ksize, ksize));
CPU_ON;
erode(src, dst, ker);
CPU_OFF;
Mat src(srcSize, type), dst(srcSize, type);
declare.in(src, WARMUP_RNG).out(dst).in(ker);
d_src.upload(src);
if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
declare.time(5);
WARMUP_ON;
ocl::erode(d_src, d_dst, ker);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type), oclKer(ker);
GPU_ON;
ocl::erode(d_src, d_dst, ker);
GPU_OFF;
TEST_CYCLE() cv::ocl::erode(oclSrc, oclDst, oclKer);
GPU_FULL_ON;
d_src.upload(src);
ocl::erode(d_src, d_dst, ker);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
oclDst.download(dst);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
}
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::erode(src, dst, ker);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
///////////// Sobel ////////////////////////
PERFTEST(Sobel)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int dx = 1;
int dy = 1;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
gen(src, size, size, all_type[j], 0, 256);
typedef Size_MatType SobelFixture;
Sobel(src, dst, -1, dx, dy);
PERF_TEST_P(SobelFixture, Sobel,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params), dx = 1, dy = 1;
CPU_ON;
Sobel(src, dst, -1, dx, dy);
CPU_OFF;
Mat src(srcSize, type), dst(srcSize, type);
declare.in(src, WARMUP_RNG).out(dst);
d_src.upload(src);
if ((srcSize == OCL_SIZE_2000 && type == CV_8UC4) ||
(srcSize == OCL_SIZE_4000 && type == CV_8UC1))
declare.time(5.5);
else if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
declare.time(20);
WARMUP_ON;
ocl::Sobel(d_src, d_dst, -1, dx, dy);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type);
GPU_ON;
ocl::Sobel(d_src, d_dst, -1, dx, dy);
GPU_OFF;
TEST_CYCLE() cv::ocl::Sobel(oclSrc, oclDst, -1, dx, dy);
GPU_FULL_ON;
d_src.upload(src);
ocl::Sobel(d_src, d_dst, -1, dx, dy);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
oclDst.download(dst);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
}
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::Sobel(src, dst, -1, dx, dy);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
///////////// Scharr ////////////////////////
PERFTEST(Scharr)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int dx = 1;
int dy = 0;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
///////////// Scharr ////////////////////////
gen(src, size, size, all_type[j], 0, 256);
typedef Size_MatType ScharrFixture;
Scharr(src, dst, -1, dx, dy);
PERF_TEST_P(ScharrFixture, Scharr,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params), dx = 1, dy = 0;
CPU_ON;
Scharr(src, dst, -1, dx, dy);
CPU_OFF;
Mat src(srcSize, type), dst(srcSize, type);
declare.in(src, WARMUP_RNG).out(dst);
d_src.upload(src);
if ((srcSize == OCL_SIZE_2000 && type == CV_8UC4) ||
(srcSize == OCL_SIZE_4000 && type == CV_8UC1))
declare.time(5.5);
else if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
declare.time(21);
WARMUP_ON;
ocl::Scharr(d_src, d_dst, -1, dx, dy);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type);
GPU_ON;
ocl::Scharr(d_src, d_dst, -1, dx, dy);
GPU_OFF;
TEST_CYCLE() cv::ocl::Scharr(oclSrc, oclDst, -1, dx, dy);
GPU_FULL_ON;
d_src.upload(src);
ocl::Scharr(d_src, d_dst, -1, dx, dy);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
oclDst.download(dst);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1);
}
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::Scharr(src, dst, -1, dx, dy);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
///////////// GaussianBlur ////////////////////////
PERFTEST(GaussianBlur)
{
Mat src, dst, ocl_dst;
int all_type[] = {CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4", "CV_32FC1", "CV_32FC4"};
const int ksize = 7;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
gen(src, size, size, all_type[j], 0, 256);
typedef Size_MatType GaussianBlurFixture;
GaussianBlur(src, dst, Size(ksize, ksize), 0);
PERF_TEST_P(GaussianBlurFixture, GaussianBlur,
::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000),
OCL_PERF_ENUM(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params), ksize = 7;
CPU_ON;
GaussianBlur(src, dst, Size(ksize, ksize), 0);
CPU_OFF;
Mat src(srcSize, type), dst(srcSize, type);
declare.in(src, WARMUP_RNG).out(dst);
ocl::oclMat d_src(src);
ocl::oclMat d_dst;
const double eps = src.depth() == CV_8U ? 1 + DBL_EPSILON : 3e-4;
WARMUP_ON;
ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type);
GPU_ON;
ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0);
GPU_OFF;
TEST_CYCLE() cv::ocl::GaussianBlur(oclSrc, oclDst, Size(ksize, ksize), 0);
GPU_FULL_ON;
d_src.upload(src);
ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
oclDst.download(dst);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0);
}
SANITY_CHECK(dst, eps);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::GaussianBlur(src, dst, Size(ksize, ksize), 0);
SANITY_CHECK(dst, eps);
}
else
OCL_PERF_ELSE
}
///////////// filter2D////////////////////////
PERFTEST(filter2D)
{
Mat src;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
gen(src, size, size, all_type[j], 0, 256);
const int ksize = 3;
SUBTEST << "ksize = " << ksize << "; " << size << 'x' << size << "; " << type_name[j] ;
Mat kernel;
gen(kernel, ksize, ksize, CV_32SC1, -3.0, 3.0);
typedef Size_MatType filter2DFixture;
Mat dst, ocl_dst;
cv::filter2D(src, dst, -1, kernel);
CPU_ON;
cv::filter2D(src, dst, -1, kernel);
CPU_OFF;
ocl::oclMat d_src(src), d_dst;
PERF_TEST_P(filter2DFixture, filter2D,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params), ksize = 3;
WARMUP_ON;
ocl::filter2D(d_src, d_dst, -1, kernel);
WARMUP_OFF;
Mat src(srcSize, type), dst(srcSize, type), kernel(ksize, ksize, CV_32SC1);
declare.in(src, WARMUP_RNG).in(kernel).out(dst);
randu(kernel, -3.0, 3.0);
GPU_ON;
ocl::filter2D(d_src, d_dst, -1, kernel);
GPU_OFF;
if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
declare.time(8);
GPU_FULL_ON;
d_src.upload(src);
ocl::filter2D(d_src, d_dst, -1, kernel);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type), oclKernel(kernel);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5);
TEST_CYCLE() cv::ocl::filter2D(oclSrc, oclDst, -1, oclKernel);
}
oclDst.download(dst);
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::filter2D(src, dst, -1, kernel);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}

58
modules/ocl/perf/perf_gemm.cpp
Unescape View File

@ -45,46 +45,40 @@
//M*/
#include "perf_precomp.hpp"
///////////// gemm ////////////////////////
PERFTEST(gemm)
{
Mat src1, src2, src3, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_src3, d_dst;
using namespace perf;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
SUBTEST << size << 'x' << size;
///////////// gemm ////////////////////////
gen(src1, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
gen(src2, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
gen(src3, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
typedef TestBaseWithParam<Size> gemmFixture;
gemm(src1, src2, 1.0, src3, 1.0, dst);
PERF_TEST_P(gemmFixture, DISABLED_gemm, OCL_TYPICAL_MAT_SIZES) // TODO not implemented
{
const Size srcSize = GetParam();
CPU_ON;
gemm(src1, src2, 1.0, src3, 1.0, dst);
CPU_OFF;
Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1),
src3(srcSize, CV_32FC1), dst(srcSize, CV_32FC1);
declare.in(src1, src2, src3).out(dst);
randu(src1, -10.0f, 10.0f);
randu(src2, -10.0f, 10.0f);
randu(src3, -10.0f, 10.0f);
d_src1.upload(src1);
d_src2.upload(src2);
d_src3.upload(src3);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc1(src1), oclSrc2(src2),
oclSrc3(src3), oclDst(srcSize, CV_32FC1);
WARMUP_ON;
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
WARMUP_OFF;
TEST_CYCLE() cv::ocl::gemm(oclSrc1, oclSrc2, 1.0, oclSrc3, 1.0, oclDst);
GPU_ON;
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
GPU_OFF;
oclDst.download(dst);
GPU_FULL_ON;
d_src1.upload(src1);
d_src2.upload(src2);
d_src3.upload(src3);
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst);
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, src1.cols * src1.rows * 1e-4);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}

74
modules/ocl/perf/perf_gftt.cpp
Unescape View File

@ -46,56 +46,50 @@
#include "perf_precomp.hpp"
///////////// GoodFeaturesToTrack ////////////////////////
PERFTEST(GoodFeaturesToTrack)
{
using namespace cv;
int maxCorners = 2000;
double qualityLevel = 0.01;
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
std::string images[] = { "rubberwhale1.png", "aloeL.jpg" };
std::vector<cv::Point2f> pts_gold, pts_ocl;
for(size_t imgIdx = 0; imgIdx < (sizeof(images)/sizeof(std::string)); ++imgIdx)
{
Mat frame = imread(abspath(images[imgIdx]), IMREAD_GRAYSCALE);
CV_Assert(!frame.empty());
///////////// GoodFeaturesToTrack ////////////////////////
for(float minDistance = 0; minDistance < 4; minDistance += 3.0)
{
SUBTEST << "image = " << images[imgIdx] << "; ";
SUBTEST << "minDistance = " << minDistance << "; ";
typedef tuple<string, double> GoodFeaturesToTrackParams;
typedef TestBaseWithParam<GoodFeaturesToTrackParams> GoodFeaturesToTrackFixture;
cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
PERF_TEST_P(GoodFeaturesToTrackFixture, GoodFeaturesToTrack,
::testing::Combine(::testing::Values(string("gpu/opticalflow/rubberwhale1.png"),
string("gpu/stereobm/aloe-L.png")),
::testing::Range(0.0, 4.0, 3.0)))
{
CPU_ON;
cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
CPU_OFF;
const GoodFeaturesToTrackParams param = GetParam();
const string fileName = getDataPath(get<0>(param));
const int maxCorners = 2000;
const double qualityLevel = 0.01, minDistance = get<1>(param);
cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance);
Mat frame = imread(fileName, IMREAD_GRAYSCALE);
ASSERT_TRUE(!frame.empty()) << "no input image";
ocl::oclMat frame_ocl(frame), pts_oclmat;
vector<Point2f> pts_gold;
declare.in(frame);
WARMUP_ON;
detector(frame_ocl, pts_oclmat);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclFrame(frame), pts_oclmat;
ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance);
detector.downloadPoints(pts_oclmat, pts_ocl);
TEST_CYCLE() detector(oclFrame, pts_oclmat);
double diff = abs(static_cast<float>(pts_gold.size() - pts_ocl.size()));
TestSystem::instance().setAccurate(diff == 0.0, diff);
detector.downloadPoints(pts_oclmat, pts_gold);
GPU_ON;
detector(frame_ocl, pts_oclmat);
GPU_OFF;
SANITY_CHECK(pts_gold);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::goodFeaturesToTrack(frame, pts_gold,
maxCorners, qualityLevel, minDistance);
GPU_FULL_ON;
frame_ocl.upload(frame);
detector(frame_ocl, pts_oclmat);
detector.downloadPoints(pts_oclmat, pts_ocl);
GPU_FULL_OFF;
}
SANITY_CHECK(pts_gold);
}
else
OCL_PERF_ELSE
}

72
modules/ocl/perf/perf_haar.cpp
Unescape View File

@ -45,6 +45,8 @@
//M*/
#include "perf_precomp.hpp"
using namespace perf;
///////////// Haar ////////////////////////
namespace cv
{
@ -83,61 +85,39 @@ public:
}
}
PERFTEST(Haar)
{
Mat img = imread(abspath("basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE);
if (img.empty())
{
throw runtime_error("can't open basketball1.png");
}
CascadeClassifier faceCascadeCPU;
if (!faceCascadeCPU.load(abspath("haarcascade_frontalface_alt.xml")))
{
throw runtime_error("can't load haarcascade_frontalface_alt.xml");
}
PERF_TEST(HaarFixture, Haar)
{
vector<Rect> faces;
SUBTEST << img.cols << "x" << img.rows << "; scale image";
CPU_ON;
faceCascadeCPU.detectMultiScale(img, faces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
CPU_OFF;
Mat img = imread(getDataPath("gpu/haarcascade/basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE);
ASSERT_TRUE(!img.empty()) << "can't open basketball1.png";
declare.in(img);
if (RUN_PLAIN_IMPL)
{
CascadeClassifier faceCascade;
ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml")))
<< "can't load haarcascade_frontalface_alt.xml";
vector<Rect> oclfaces;
ocl::CascadeClassifier_GPU faceCascade;
TEST_CYCLE() faceCascade.detectMultiScale(img, faces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
if (!faceCascade.load(abspath("haarcascade_frontalface_alt.xml")))
{
throw runtime_error("can't load haarcascade_frontalface_alt.xml");
SANITY_CHECK(faces, 4 + 1e-4);
}
else if (RUN_OCL_IMPL)
{
ocl::CascadeClassifier_GPU faceCascade;
ocl::oclMat oclImg(img);
ocl::oclMat d_img(img);
ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml")))
<< "can't load haarcascade_frontalface_alt.xml";
WARMUP_ON;
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
WARMUP_OFF;
TEST_CYCLE() faceCascade.detectMultiScale(oclImg, faces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
if(faces.size() == oclfaces.size())
TestSystem::instance().setAccurate(1, 0);
SANITY_CHECK(faces, 4 + 1e-4);
}
else
TestSystem::instance().setAccurate(0, abs((int)faces.size() - (int)oclfaces.size()));
faces.clear();
GPU_ON;
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
GPU_OFF;
GPU_FULL_ON;
d_img.upload(img);
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
GPU_FULL_OFF;
OCL_PERF_ELSE
}

59
modules/ocl/perf/perf_hog.cpp
Unescape View File

@ -45,50 +45,37 @@
//M*/
#include "perf_precomp.hpp"
using namespace perf;
///////////// HOG////////////////////////
PERFTEST(HOG)
PERF_TEST(HOGFixture, HOG)
{
Mat src = imread(abspath("road.png"), cv::IMREAD_GRAYSCALE);
if (src.empty())
{
throw runtime_error("can't open road.png");
}
cv::HOGDescriptor hog;
hog.setSVMDetector(hog.getDefaultPeopleDetector());
std::vector<cv::Rect> found_locations;
std::vector<cv::Rect> d_found_locations;
Mat src = imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE);
ASSERT_TRUE(!src.empty()) << "can't open input image road.png";
SUBTEST << src.cols << 'x' << src.rows << "; road.png";
vector<cv::Rect> found_locations;
declare.in(src).time(5);
hog.detectMultiScale(src, found_locations);
if (RUN_PLAIN_IMPL)
{
HOGDescriptor hog;
hog.setSVMDetector(hog.getDefaultPeopleDetector());
CPU_ON;
hog.detectMultiScale(src, found_locations);
CPU_OFF;
TEST_CYCLE() hog.detectMultiScale(src, found_locations);
cv::ocl::HOGDescriptor ocl_hog;
ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
ocl::oclMat d_src;
d_src.upload(src);
SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
}
else if (RUN_OCL_IMPL)
{
ocl::HOGDescriptor ocl_hog;
ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
ocl::oclMat oclSrc(src);
WARMUP_ON;
ocl_hog.detectMultiScale(d_src, d_found_locations);
WARMUP_OFF;
TEST_CYCLE() ocl_hog.detectMultiScale(oclSrc, found_locations);
if(d_found_locations.size() == found_locations.size())
TestSystem::instance().setAccurate(1, 0);
SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
}
else
TestSystem::instance().setAccurate(0, abs((int)found_locations.size() - (int)d_found_locations.size()));
GPU_ON;
ocl_hog.detectMultiScale(d_src, found_locations);
GPU_OFF;
GPU_FULL_ON;
d_src.upload(src);
ocl_hog.detectMultiScale(d_src, found_locations);
GPU_FULL_OFF;
OCL_PERF_ELSE
}

937
modules/ocl/perf/perf_imgproc.cpp
View File

File diff suppressed because it is too large Load Diff

138
modules/ocl/perf/perf_match_template.cpp
Unescape View File

@ -45,101 +45,77 @@
//M*/
#include "perf_precomp.hpp"
/////////// matchTemplate ////////////////////////
//void InitMatchTemplate()
//{
// Mat src; gen(src, 500, 500, CV_32F, 0, 1);
// Mat templ; gen(templ, 500, 500, CV_32F, 0, 1);
// ocl::oclMat d_src(src), d_templ(templ), d_dst;
// ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
//}
PERFTEST(matchTemplate)
{
//InitMatchTemplate();
Mat src, templ, dst, ocl_dst;
int templ_size = 5;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
int all_type[] = {CV_32FC1, CV_32FC4};
std::string type_name[] = {"CV_32FC1", "CV_32FC4"};
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
for(templ_size = 5; templ_size <= 5; templ_size *= 5)
{
gen(src, size, size, all_type[j], 0, 1);
SUBTEST << src.cols << 'x' << src.rows << "; " << type_name[j] << "; templ " << templ_size << 'x' << templ_size << "; CCORR";
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
gen(templ, templ_size, templ_size, all_type[j], 0, 1);
matchTemplate(src, templ, dst, CV_TM_CCORR);
CPU_ON;
matchTemplate(src, templ, dst, CV_TM_CCORR);
CPU_OFF;
ocl::oclMat d_src(src), d_templ(templ), d_dst;
WARMUP_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
WARMUP_OFF;
/////////// matchTemplate ////////////////////////
GPU_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
GPU_OFF;
typedef Size_MatType CV_TM_CCORRFixture;
GPU_FULL_ON;
d_src.upload(src);
d_templ.upload(templ);
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
PERF_TEST_P(CV_TM_CCORRFixture, matchTemplate,
::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000),
OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params), templSize(5, 5);
const int type = get<1>(params);
Mat src(srcSize, type), templ(templSize, type);
const Size dstSize(src.cols - templ.cols + 1, src.rows - templ.rows + 1);
Mat dst(dstSize, CV_32F);
randu(src, 0.0f, 1.0f);
randu(templ, 0.0f, 1.0f);
declare.time(srcSize == OCL_SIZE_2000 ? 20 : 6).in(src, templ).out(dst);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclTempl(templ), oclDst(dstSize, CV_32F);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
}
}
TEST_CYCLE() cv::ocl::matchTemplate(oclSrc, oclTempl, oclDst, CV_TM_CCORR);
int all_type_8U[] = {CV_8UC1};
std::string type_name_8U[] = {"CV_8UC1"};
oclDst.download(dst);
for (size_t j = 0; j < sizeof(all_type_8U) / sizeof(int); j++)
{
for(templ_size = 5; templ_size <= 5; templ_size *= 5)
{
SUBTEST << src.cols << 'x' << src.rows << "; " << type_name_8U[j] << "; templ " << templ_size << 'x' << templ_size << "; CCORR_NORMED";
SANITY_CHECK(dst, 1e-4);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::matchTemplate(src, templ, dst, CV_TM_CCORR);
gen(src, size, size, all_type_8U[j], 0, 255);
SANITY_CHECK(dst, 1e-4);
}
else
OCL_PERF_ELSE
}
gen(templ, templ_size, templ_size, all_type_8U[j], 0, 255);
typedef TestBaseWithParam<Size> CV_TM_CCORR_NORMEDFixture;
matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED);
PERF_TEST_P(CV_TM_CCORR_NORMEDFixture, matchTemplate, OCL_TYPICAL_MAT_SIZES)
{
const Size srcSize = GetParam(), templSize(5, 5);
CPU_ON;
matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED);
CPU_OFF;
Mat src(srcSize, CV_8UC1), templ(templSize, CV_8UC1), dst;
const Size dstSize(src.cols - templ.cols + 1, src.rows - templ.rows + 1);
dst.create(dstSize, CV_8UC1);
declare.in(src, templ, WARMUP_RNG).out(dst)
.time(srcSize == OCL_SIZE_2000 ? 10 : srcSize == OCL_SIZE_4000 ? 23 : 2);
ocl::oclMat d_src(src);
ocl::oclMat d_templ(templ), d_dst;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclTempl(templ), oclDst(dstSize, CV_8UC1);
WARMUP_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
WARMUP_OFF;
TEST_CYCLE() cv::ocl::matchTemplate(oclSrc, oclTempl, oclDst, CV_TM_CCORR_NORMED);
GPU_ON;
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
GPU_OFF;
oclDst.download(dst);
GPU_FULL_ON;
d_src.upload(src);
d_templ.upload(templ);
ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
SANITY_CHECK(dst, 2e-2);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
}
}
SANITY_CHECK(dst, 2e-2);
}
else
OCL_PERF_ELSE
}

185
modules/ocl/perf/perf_matrix_operation.cpp
Unescape View File

@ -45,142 +45,113 @@
//M*/
#include "perf_precomp.hpp"
///////////// ConvertTo////////////////////////
PERFTEST(ConvertTo)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] << " to 32FC1";
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
gen(src, size, size, all_type[j], 0, 256);
//gen(dst, size, size, all_type[j], 0, 256);
//d_dst.upload(dst);
src.convertTo(dst, CV_32FC1);
///////////// ConvertTo////////////////////////
CPU_ON;
src.convertTo(dst, CV_32FC1);
CPU_OFF;
typedef Size_MatType ConvertToFixture;
d_src.upload(src);
PERF_TEST_P(ConvertToFixture, ConvertTo,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
WARMUP_ON;
d_src.convertTo(d_dst, CV_32FC1);
WARMUP_OFF;
Mat src(srcSize, type), dst;
const int dstType = CV_MAKE_TYPE(CV_32F, src.channels());
dst.create(srcSize, dstType);
declare.in(src, WARMUP_RNG).out(dst);
GPU_ON;
d_src.convertTo(d_dst, CV_32FC1);
GPU_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, dstType);
GPU_FULL_ON;
d_src.upload(src);
d_src.convertTo(d_dst, CV_32FC1);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TEST_CYCLE() oclSrc.convertTo(oclDst, dstType);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
oclDst.download(dst);
SANITY_CHECK(dst);
}
}
///////////// copyTo////////////////////////
PERFTEST(copyTo)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
else if (RUN_PLAIN_IMPL)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
TEST_CYCLE() src.convertTo(dst, dstType);
gen(src, size, size, all_type[j], 0, 256);
//gen(dst, size, size, all_type[j], 0, 256);
//d_dst.upload(dst);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
src.copyTo(dst);
///////////// copyTo////////////////////////
CPU_ON;
src.copyTo(dst);
CPU_OFF;
typedef Size_MatType copyToFixture;
d_src.upload(src);
PERF_TEST_P(copyToFixture, copyTo,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
WARMUP_ON;
d_src.copyTo(d_dst);
WARMUP_OFF;
Mat src(srcSize, type), dst(srcSize, type);
declare.in(src, WARMUP_RNG).out(dst);
GPU_ON;
d_src.copyTo(d_dst);
GPU_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(srcSize, type);
GPU_FULL_ON;
d_src.upload(src);
d_src.copyTo(d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TEST_CYCLE() oclSrc.copyTo(oclDst);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
oclDst.download(dst);
SANITY_CHECK(dst);
}
}
///////////// setTo////////////////////////
PERFTEST(setTo)
{
Mat src, ocl_src;
Scalar val(1, 2, 3, 4);
ocl::oclMat d_src;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
else if (RUN_PLAIN_IMPL)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
TEST_CYCLE() src.copyTo(dst);
gen(src, size, size, all_type[j], 0, 256);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
src.setTo(val);
///////////// setTo////////////////////////
CPU_ON;
src.setTo(val);
CPU_OFF;
typedef Size_MatType setToFixture;
d_src.upload(src);
PERF_TEST_P(setToFixture, setTo,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
const Scalar val(1, 2, 3, 4);
WARMUP_ON;
d_src.setTo(val);
WARMUP_OFF;
Mat src(srcSize, type);
declare.in(src);
d_src.download(ocl_src);
TestSystem::instance().ExpectedMatNear(src, ocl_src, 1.0);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(srcSize, type);
GPU_ON;;
d_src.setTo(val);
GPU_OFF;
TEST_CYCLE() oclSrc.setTo(val);
oclSrc.download(src);
GPU_FULL_ON;
d_src.upload(src);
d_src.setTo(val);
GPU_FULL_OFF;
}
SANITY_CHECK(src);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() src.setTo(val);
SANITY_CHECK(src);
}
else
OCL_PERF_ELSE
}

65
modules/ocl/perf/perf_moments.cpp
Unescape View File

@ -43,50 +43,47 @@
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "perf_precomp.hpp"
///////////// Moments ////////////////////////
PERFTEST(Moments)
{
Mat src;
bool binaryImage = 0;
int all_type[] = {CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1};
std::string type_name[] = {"CV_8UC1", "CV_16SC1", "CV_32FC1", "CV_64FC1"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j];
#include "perf_precomp.hpp"
gen(src, size, size, all_type[j], 0, 256);
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
cv::Moments CvMom = moments(src, binaryImage);
///////////// Moments ////////////////////////
CPU_ON;
moments(src, binaryImage);
CPU_OFF;
typedef Size_MatType MomentsFixture;
cv::Moments oclMom;
WARMUP_ON;
oclMom = ocl::ocl_moments(src, binaryImage);
WARMUP_OFF;
PERF_TEST_P(MomentsFixture, DISABLED_Moments,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1))) // TODO does not work properly (see below)
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
Mat gpu_dst, cpu_dst;
HuMoments(CvMom, cpu_dst);
HuMoments(oclMom, gpu_dst);
Mat src(srcSize, type), dst(7, 1, CV_64F);
const bool binaryImage = false;
cv::Moments mom;
GPU_ON;
ocl::ocl_moments(src, binaryImage);
GPU_OFF;
declare.in(src, WARMUP_RNG).out(dst);
GPU_FULL_ON;
ocl::ocl_moments(src, binaryImage);
GPU_FULL_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src);
TestSystem::instance().ExpectedMatNear(gpu_dst, cpu_dst, .5);
TEST_CYCLE() mom = cv::ocl::ocl_moments(oclSrc, binaryImage); // TODO Use oclSrc
cv::HuMoments(mom, dst);
}
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() mom = cv::moments(src, binaryImage);
cv::HuMoments(mom, dst);
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}

56
modules/ocl/perf/perf_norm.cpp
Unescape View File

@ -45,43 +45,39 @@
//M*/
#include "perf_precomp.hpp"
///////////// norm////////////////////////
PERFTEST(norm)
{
Mat src1, src2, ocl_src1;
ocl::oclMat d_src1, d_src2;
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
SUBTEST << size << 'x' << size << "; CV_8UC1; NORM_INF";
gen(src1, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
gen(src2, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1));
///////////// norm////////////////////////
norm(src1, src2, NORM_INF);
typedef TestBaseWithParam<Size> normFixture;
CPU_ON;
norm(src1, src2, NORM_INF);
CPU_OFF;
PERF_TEST_P(normFixture, DISABLED_norm, OCL_TYPICAL_MAT_SIZES) // TODO doesn't work properly
{
const Size srcSize = GetParam();
const std::string impl = getSelectedImpl();
double value = 0.0;
d_src1.upload(src1);
d_src2.upload(src2);
Mat src1(srcSize, CV_8UC1), src2(srcSize, CV_8UC1);
declare.in(src1, src2);
randu(src1, 0, 1);
randu(src2, 0, 1);
WARMUP_ON;
ocl::norm(d_src1, d_src2, NORM_INF);
WARMUP_OFF;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc1(src1), oclSrc2(src2);
d_src1.download(ocl_src1);
TestSystem::instance().ExpectedMatNear(src1, ocl_src1, .5);
TEST_CYCLE() value = cv::ocl::norm(oclSrc1, oclSrc2, NORM_INF);
GPU_ON;
ocl::norm(d_src1, d_src2, NORM_INF);
GPU_OFF;
SANITY_CHECK(value);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() value = cv::norm(src1, src2, NORM_INF);
GPU_FULL_ON;
d_src1.upload(src1);
d_src2.upload(src2);
ocl::norm(d_src1, d_src2, NORM_INF);
GPU_FULL_OFF;
SANITY_CHECK(value);
}
else
OCL_PERF_ELSE
}

447
modules/ocl/perf/perf_opticalflow.cpp
Unescape View File

@ -46,311 +46,228 @@
#include "perf_precomp.hpp"
///////////// PyrLKOpticalFlow ////////////////////////
PERFTEST(PyrLKOpticalFlow)
{
std::string images1[] = {"rubberwhale1.png", "aloeL.jpg"};
std::string images2[] = {"rubberwhale2.png", "aloeR.jpg"};
for (size_t i = 0; i < sizeof(images1) / sizeof(std::string); i++)
{
Mat frame0 = imread(abspath(images1[i]), i == 0 ? IMREAD_COLOR : IMREAD_GRAYSCALE);
using namespace perf;
using std::tr1::get;
using std::tr1::tuple;
using std::tr1::make_tuple;
if (frame0.empty())
{
std::string errstr = "can't open " + images1[i];
throw runtime_error(errstr);
}
template <typename T>
static vector<T> & MatToVector(const ocl::oclMat & oclSrc, vector<T> & instance)
{
Mat src;
oclSrc.download(src);
Mat frame1 = imread(abspath(images2[i]), i == 0 ? IMREAD_COLOR : IMREAD_GRAYSCALE);
for (int i = 0; i < src.cols; ++i)
instance.push_back(src.at<T>(0, i));
if (frame1.empty())
{
std::string errstr = "can't open " + images2[i];
throw runtime_error(errstr);
}
return instance;
}
Mat gray_frame;
CV_ENUM(LoadMode, IMREAD_GRAYSCALE, IMREAD_COLOR)
typedef tuple<int, tuple<string, string, LoadMode> > PyrLKOpticalFlowParamType;
typedef TestBaseWithParam<PyrLKOpticalFlowParamType> PyrLKOpticalFlowFixture;
PERF_TEST_P(PyrLKOpticalFlowFixture,
DISABLED_PyrLKOpticalFlow,
::testing::Combine(
::testing::Values(1000, 2000, 4000),
::testing::Values(
make_tuple<string, string, LoadMode>
(
string("gpu/opticalflow/rubberwhale1.png"),
string("gpu/opticalflow/rubberwhale2.png"),
LoadMode(IMREAD_COLOR)
)
, make_tuple<string, string, LoadMode>
(
string("gpu/stereobm/aloe-L.png"),
string("gpu/stereobm/aloe-R.png"),
LoadMode(IMREAD_GRAYSCALE)
)
)
)
) // TODO to big difference between implementations
{
PyrLKOpticalFlowParamType params = GetParam();
tuple<string, string, LoadMode> fileParam = get<1>(params);
const int pointsCount = get<0>(params);
const int openMode = static_cast<int>(get<2>(fileParam));
const string fileName0 = get<0>(fileParam), fileName1 = get<1>(fileParam);
Mat frame0 = imread(getDataPath(fileName0), openMode);
Mat frame1 = imread(getDataPath(fileName1), openMode);
ASSERT_FALSE(frame0.empty()) << "can't load " << fileName0;
ASSERT_FALSE(frame1.empty()) << "can't load " << fileName1;
Mat grayFrame;
if (openMode == IMREAD_COLOR)
cvtColor(frame0, grayFrame, COLOR_BGR2GRAY);
else
grayFrame = frame0;
vector<Point2f> pts, nextPts;
vector<unsigned char> status;
vector<float> err;
goodFeaturesToTrack(grayFrame, pts, pointsCount, 0.01, 0.0);
if (RUN_PLAIN_IMPL)
{
TEST_CYCLE()
cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
if (i == 0)
{
cvtColor(frame0, gray_frame, COLOR_BGR2GRAY);
}
SANITY_CHECK(nextPts);
SANITY_CHECK(status);
SANITY_CHECK(err);
}
else if (RUN_OCL_IMPL)
{
ocl::PyrLKOpticalFlow oclPyrLK;
ocl::oclMat oclFrame0(frame0), oclFrame1(frame1);
ocl::oclMat oclPts(1, static_cast<int>(pts.size()), CV_32FC2, (void *)&pts[0]);
ocl::oclMat oclNextPts, oclStatus, oclErr;
for (int points = Min_Size; points <= Max_Size; points *= Multiple)
{
if (i == 0)
SUBTEST << frame0.cols << "x" << frame0.rows << "; color; " << points << " points";
else
SUBTEST << frame0.cols << "x" << frame0.rows << "; gray; " << points << " points";
Mat ocl_nextPts;
Mat ocl_status;
vector<Point2f> pts;
goodFeaturesToTrack(i == 0 ? gray_frame : frame0, pts, points, 0.01, 0.0);
vector<Point2f> nextPts;
vector<unsigned char> status;
vector<float> err;
calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
CPU_ON;
calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
CPU_OFF;
ocl::PyrLKOpticalFlow d_pyrLK;
ocl::oclMat d_frame0(frame0);
ocl::oclMat d_frame1(frame1);
ocl::oclMat d_pts;
Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void *)&pts[0]);
d_pts.upload(pts_mat);
ocl::oclMat d_nextPts;
ocl::oclMat d_status;
ocl::oclMat d_err;
WARMUP_ON;
d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
WARMUP_OFF;
GPU_ON;
d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
GPU_OFF;
GPU_FULL_ON;
d_frame0.upload(frame0);
d_frame1.upload(frame1);
d_pts.upload(pts_mat);
d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
if (!d_nextPts.empty())
d_nextPts.download(ocl_nextPts);
if (!d_status.empty())
d_status.download(ocl_status);
GPU_FULL_OFF;
size_t mismatch = 0;
for (int i = 0; i < (int)nextPts.size(); ++i)
{
if(status[i] != ocl_status.at<unsigned char>(0, i))
{
mismatch++;
continue;
}
if(status[i])
{
Point2f gpu_rst = ocl_nextPts.at<Point2f>(0, i);
Point2f cpu_rst = nextPts[i];
if(fabs(gpu_rst.x - cpu_rst.x) >= 1. || fabs(gpu_rst.y - cpu_rst.y) >= 1.)
mismatch++;
}
}
double ratio = (double)mismatch / (double)nextPts.size();
if(ratio < .02)
TestSystem::instance().setAccurate(1, ratio);
else
TestSystem::instance().setAccurate(0, ratio);
}
TEST_CYCLE()
oclPyrLK.sparse(oclFrame0, oclFrame1, oclPts, oclNextPts, oclStatus, &oclErr);
MatToVector(oclNextPts, nextPts);
MatToVector(oclStatus, status);
MatToVector(oclErr, err);
SANITY_CHECK(nextPts);
SANITY_CHECK(status);
SANITY_CHECK(err);
}
else
OCL_PERF_ELSE
}
PERFTEST(tvl1flow)
PERF_TEST(tvl1flowFixture, tvl1flow)
{
cv::Mat frame0 = imread("rubberwhale1.png", cv::IMREAD_GRAYSCALE);
assert(!frame0.empty());
Mat frame0 = imread(getDataPath("gpu/opticalflow/rubberwhale1.png"), cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame0.empty()) << "can't load rubberwhale1.png";
cv::Mat frame1 = imread("rubberwhale2.png", cv::IMREAD_GRAYSCALE);
assert(!frame1.empty());
Mat frame1 = imread(getDataPath("gpu/opticalflow/rubberwhale2.png"), cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame1.empty()) << "can't load rubberwhale2.png";
cv::ocl::OpticalFlowDual_TVL1_OCL d_alg;
cv::ocl::oclMat d_flowx(frame0.size(), CV_32FC1);
cv::ocl::oclMat d_flowy(frame1.size(), CV_32FC1);
const Size srcSize = frame0.size();
const double eps = 1.2;
Mat flow(srcSize, CV_32FC2), flow1(srcSize, CV_32FC1), flow2(srcSize, CV_32FC1);
declare.in(frame0, frame1).out(flow1, flow2).time(159);
cv::Ptr<cv::DenseOpticalFlow> alg = cv::createOptFlow_DualTVL1();
cv::Mat flow;
if (RUN_PLAIN_IMPL)
{
Ptr<DenseOpticalFlow> alg = createOptFlow_DualTVL1();
TEST_CYCLE() alg->calc(frame0, frame1, flow);
SUBTEST << frame0.cols << 'x' << frame0.rows << "; rubberwhale1.png; "<<frame1.cols<<'x'<<frame1.rows<<"; rubberwhale2.png";
alg->collectGarbage();
Mat flows[2] = { flow1, flow2 };
split(flow, flows);
alg->calc(frame0, frame1, flow);
SANITY_CHECK(flow1, eps);
SANITY_CHECK(flow2, eps);
}
else if (RUN_OCL_IMPL)
{
ocl::OpticalFlowDual_TVL1_OCL oclAlg;
ocl::oclMat oclFrame0(frame0), oclFrame1(frame1), oclFlow1(srcSize, CV_32FC1),
oclFlow2(srcSize, CV_32FC1);
CPU_ON;
alg->calc(frame0, frame1, flow);
CPU_OFF;
TEST_CYCLE() oclAlg(oclFrame0, oclFrame1, oclFlow1, oclFlow2);
cv::Mat gold[2];
cv::split(flow, gold);
oclAlg.collectGarbage();
cv::ocl::oclMat d0(frame0.size(), CV_32FC1);
d0.upload(frame0);
cv::ocl::oclMat d1(frame1.size(), CV_32FC1);
d1.upload(frame1);
oclFlow1.download(flow1);
oclFlow2.download(flow2);
WARMUP_ON;
d_alg(d0, d1, d_flowx, d_flowy);
WARMUP_OFF;
/*
double diff1 = 0.0, diff2 = 0.0;
if(ExceptedMatSimilar(gold[0], cv::Mat(d_flowx), 3e-3, diff1) == 1
&&ExceptedMatSimilar(gold[1], cv::Mat(d_flowy), 3e-3, diff2) == 1)
TestSystem::instance().setAccurate(1);
else
TestSystem::instance().setAccurate(0);
SANITY_CHECK(flow1, eps);
SANITY_CHECK(flow2, eps);
}
else
OCL_PERF_ELSE
}
TestSystem::instance().setDiff(diff1);
TestSystem::instance().setDiff(diff2);
*/
///////////// FarnebackOpticalFlow ////////////////////////
CV_ENUM(farneFlagType, 0, OPTFLOW_FARNEBACK_GAUSSIAN)
GPU_ON;
d_alg(d0, d1, d_flowx, d_flowy);
d_alg.collectGarbage();
GPU_OFF;
typedef tuple<tuple<int, double>, farneFlagType, bool> FarnebackOpticalFlowParams;
typedef TestBaseWithParam<FarnebackOpticalFlowParams> FarnebackOpticalFlowFixture;
PERF_TEST_P(FarnebackOpticalFlowFixture, FarnebackOpticalFlow,
::testing::Combine(
::testing::Values(make_tuple<int, double>(5, 1.1),
make_tuple<int, double>(7, 1.5)),
farneFlagType::all(),
::testing::Bool()))
{
Mat frame0 = imread(getDataPath("gpu/opticalflow/rubberwhale1.png"), cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame0.empty()) << "can't load rubberwhale1.png";
cv::Mat flowx, flowy;
Mat frame1 = imread(getDataPath("gpu/opticalflow/rubberwhale2.png"), cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame1.empty()) << "can't load rubberwhale2.png";
GPU_FULL_ON;
d0.upload(frame0);
d1.upload(frame1);
d_alg(d0, d1, d_flowx, d_flowy);
d_alg.collectGarbage();
d_flowx.download(flowx);
d_flowy.download(flowy);
GPU_FULL_OFF;
const Size srcSize = frame0.size();
TestSystem::instance().ExceptedMatSimilar(gold[0], flowx, 3e-3);
TestSystem::instance().ExceptedMatSimilar(gold[1], flowy, 3e-3);
}
const FarnebackOpticalFlowParams params = GetParam();
const tuple<int, double> polyParams = get<0>(params);
const int polyN = get<0>(polyParams), flags = get<1>(params);
const double polySigma = get<1>(polyParams), pyrScale = 0.5;
const bool useInitFlow = get<2>(params);
const double eps = 1.5;
///////////// FarnebackOpticalFlow ////////////////////////
PERFTEST(FarnebackOpticalFlow)
{
cv::Mat frame0 = imread("rubberwhale1.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame0.empty());
Mat flowx(srcSize, CV_32FC1), flowy(srcSize, CV_32FC1), flow(srcSize, CV_32FC2);
declare.in(frame0, frame1).out(flowx, flowy);
cv::Mat frame1 = imread("rubberwhale2.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame1.empty());
ocl::FarnebackOpticalFlow farn;
farn.pyrScale = pyrScale;
farn.polyN = polyN;
farn.polySigma = polySigma;
farn.flags = flags;
cv::ocl::oclMat d_frame0(frame0), d_frame1(frame1);
if (RUN_PLAIN_IMPL)
{
if (useInitFlow)
{
calcOpticalFlowFarneback(
frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize,
farn.numIters, farn.polyN, farn.polySigma, farn.flags);
farn.flags |= OPTFLOW_USE_INITIAL_FLOW;
}
int polyNs[2] = { 5, 7 };
double polySigmas[2] = { 1.1, 1.5 };
int farneFlags[2] = { 0, cv::OPTFLOW_FARNEBACK_GAUSSIAN };
bool UseInitFlows[2] = { false, true };
double pyrScale = 0.5;
TEST_CYCLE()
calcOpticalFlowFarneback(
frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize,
farn.numIters, farn.polyN, farn.polySigma, farn.flags);
string farneFlagStrs[2] = { "BoxFilter", "GaussianBlur" };
string useInitFlowStrs[2] = { "", "UseInitFlow" };
Mat flowxy[2] = { flowx, flowy };
split(flow, flowxy);
for ( int i = 0; i < 2; ++i)
SANITY_CHECK(flowx, eps);
SANITY_CHECK(flowy, eps);
}
else if (RUN_OCL_IMPL)
{
int polyN = polyNs[i];
double polySigma = polySigmas[i];
ocl::oclMat oclFrame0(frame0), oclFrame1(frame1),
oclFlowx(srcSize, CV_32FC1), oclFlowy(srcSize, CV_32FC1);
for ( int j = 0; j < 2; ++j)
if (useInitFlow)
{
int flags = farneFlags[j];
for ( int k = 0; k < 2; ++k)
{
bool useInitFlow = UseInitFlows[k];
SUBTEST << "polyN(" << polyN << "); " << farneFlagStrs[j] << "; " << useInitFlowStrs[k];
cv::ocl::FarnebackOpticalFlow farn;
farn.pyrScale = pyrScale;
farn.polyN = polyN;
farn.polySigma = polySigma;
farn.flags = flags;
cv::ocl::oclMat d_flowx, d_flowy;
cv::Mat flow, flowBuf, flowxBuf, flowyBuf;
WARMUP_ON;
farn(d_frame0, d_frame1, d_flowx, d_flowy);
if (useInitFlow)
{
cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
cv::merge(flowxy, 2, flow);
flow.copyTo(flowBuf);
flowxy[0].copyTo(flowxBuf);
flowxy[1].copyTo(flowyBuf);
farn.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
farn(d_frame0, d_frame1, d_flowx, d_flowy);
}
WARMUP_OFF;
cv::calcOpticalFlowFarneback(
frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize,
farn.numIters, farn.polyN, farn.polySigma, farn.flags);
std::vector<cv::Mat> flowxy;
cv::split(flow, flowxy);
farn(oclFrame0, oclFrame1, oclFlowx, oclFlowy);
farn.flags |= OPTFLOW_USE_INITIAL_FLOW;
}
Mat md_flowx = cv::Mat(d_flowx);
Mat md_flowy = cv::Mat(d_flowy);
TestSystem::instance().ExceptedMatSimilar(flowxy[0], md_flowx, 0.1);
TestSystem::instance().ExceptedMatSimilar(flowxy[1], md_flowy, 0.1);
TEST_CYCLE()
farn(oclFrame0, oclFrame1, oclFlowx, oclFlowy);
if (useInitFlow)
{
cv::Mat flowx, flowy;
farn.flags = (flags | cv::OPTFLOW_USE_INITIAL_FLOW);
oclFlowx.download(flowx);
oclFlowy.download(flowy);
CPU_ON;
cv::calcOpticalFlowFarneback(
frame0, frame1, flowBuf, farn.pyrScale, farn.numLevels, farn.winSize,
farn.numIters, farn.polyN, farn.polySigma, farn.flags);
CPU_OFF;
GPU_ON;
farn(d_frame0, d_frame1, d_flowx, d_flowy);
GPU_OFF;
GPU_FULL_ON;
d_frame0.upload(frame0);
d_frame1.upload(frame1);
d_flowx.upload(flowxBuf);
d_flowy.upload(flowyBuf);
farn(d_frame0, d_frame1, d_flowx, d_flowy);
d_flowx.download(flowx);
d_flowy.download(flowy);
GPU_FULL_OFF;
}
else
{
cv::Mat flow, flowx, flowy;
cv::ocl::oclMat d_flowx, d_flowy;
farn.flags = flags;
CPU_ON;
cv::calcOpticalFlowFarneback(
frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize,
farn.numIters, farn.polyN, farn.polySigma, farn.flags);
CPU_OFF;
GPU_ON;
farn(d_frame0, d_frame1, d_flowx, d_flowy);
GPU_OFF;
GPU_FULL_ON;
d_frame0.upload(frame0);
d_frame1.upload(frame1);
farn(d_frame0, d_frame1, d_flowx, d_flowy);
d_flowx.download(flowx);
d_flowy.download(flowy);
GPU_FULL_OFF;
}
}
}
SANITY_CHECK(flowx, eps);
SANITY_CHECK(flowy, eps);
}
else
OCL_PERF_ELSE
}

449
modules/ocl/perf/perf_precomp.cpp
Unescape View File

@ -41,452 +41,3 @@
//M*/
#include "perf_precomp.hpp"
#if GTEST_OS_WINDOWS
#ifndef NOMINMAX
#define NOMINMAX
#endif
# include <windows.h>
#endif
// This program test most of the functions in ocl module and generate data metrix of x-factor in .csv files
// All images needed in this test are in samples/gpu folder.
// For haar template, haarcascade_frontalface_alt.xml shouold be in working directory
void TestSystem::run()
{
if (is_list_mode_)
{
for (vector<Runnable *>::iterator it = tests_.begin(); it != tests_.end(); ++it)
{
cout << (*it)->name() << endl;
}
return;
}
// Run test initializers
for (vector<Runnable *>::iterator it = inits_.begin(); it != inits_.end(); ++it)
{
if ((*it)->name().find(test_filter_, 0) != string::npos)
{
(*it)->run();
}
}
printHeading();
writeHeading();
// Run tests
for (vector<Runnable *>::iterator it = tests_.begin(); it != tests_.end(); ++it)
{
try
{
if ((*it)->name().find(test_filter_, 0) != string::npos)
{
cout << endl << (*it)->name() << ":\n";
setCurrentTest((*it)->name());
//fprintf(record_,"%s\n",(*it)->name().c_str());
(*it)->run();
finishCurrentSubtest();
}
}
catch (const Exception &)
{
// Message is printed via callback
resetCurrentSubtest();
}
catch (const runtime_error &e)
{
printError(e.what());
resetCurrentSubtest();
}
}
printSummary();
writeSummary();
}
void TestSystem::finishCurrentSubtest()
{
if (cur_subtest_is_empty_)
// There is no need to print subtest statistics
{
return;
}
double cpu_time = cpu_elapsed_ / getTickFrequency() * 1000.0;
double gpu_time = gpu_elapsed_ / getTickFrequency() * 1000.0;
double gpu_full_time = gpu_full_elapsed_ / getTickFrequency() * 1000.0;
double speedup = static_cast<double>(cpu_elapsed_) / std::max(1.0, gpu_elapsed_);
speedup_total_ += speedup;
double fullspeedup = static_cast<double>(cpu_elapsed_) / std::max(1.0, gpu_full_elapsed_);
speedup_full_total_ += fullspeedup;
if (speedup > top_)
{
speedup_faster_count_++;
}
else if (speedup < bottom_)
{
speedup_slower_count_++;
}
else
{
speedup_equal_count_++;
}
if (fullspeedup > top_)
{
speedup_full_faster_count_++;
}
else if (fullspeedup < bottom_)
{
speedup_full_slower_count_++;
}
else
{
speedup_full_equal_count_++;
}
// compute min, max and
std::sort(gpu_times_.begin(), gpu_times_.end());
double gpu_min = gpu_times_.front() / getTickFrequency() * 1000.0;
double gpu_max = gpu_times_.back() / getTickFrequency() * 1000.0;
double deviation = 0;
if (gpu_times_.size() > 1)
{
double sum = 0;
for (size_t i = 0; i < gpu_times_.size(); i++)
{
int64 diff = gpu_times_[i] - static_cast<int64>(gpu_elapsed_);
double diff_time = diff * 1000 / getTickFrequency();
sum += diff_time * diff_time;
}
deviation = std::sqrt(sum / gpu_times_.size());
}
printMetrics(is_accurate_, cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup);
writeMetrics(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, gpu_min, gpu_max, deviation);
num_subtests_called_++;
resetCurrentSubtest();
}
double TestSystem::meanTime(const vector<int64> &samples)
{
double sum = accumulate(samples.begin(), samples.end(), 0.);
return sum / samples.size();
}
void TestSystem::printHeading()
{
cout << endl;
cout<< setiosflags(ios_base::left);
#if 0
cout<<TAB<<setw(7)<< "Accu." << setw(10) << "CPU (ms)" << setw(10) << "GPU, ms"
<< setw(8) << "Speedup"<< setw(10)<<"GPUTotal" << setw(10) << "Total"
<< "Description\n";
cout<<TAB<<setw(7)<<""<<setw(10)<<""<<setw(10)<<""<<setw(8)<<""<<setw(10)<<"(ms)"<<setw(10)<<"Speedup\n";
#endif
cout<<TAB<< setw(10) << "CPU (ms)" << setw(10) << "GPU, ms"
<< setw(8) << "Speedup"<< setw(10)<<"GPUTotal" << setw(10) << "Total"
<< "Description\n";
cout<<TAB<<setw(10)<<""<<setw(10)<<""<<setw(8)<<""<<setw(10)<<"(ms)"<<setw(10)<<"Speedup\n";
cout << resetiosflags(ios_base::left);
}
void TestSystem::writeHeading()
{
if (!record_)
{
recordname_ += "_OCL.csv";
record_ = fopen(recordname_.c_str(), "w");
if(record_ == NULL)
{
cout<<".csv file open failed.\n";
exit(0);
}
}
fprintf(record_, "NAME,DESCRIPTION,ACCURACY,DIFFERENCE,CPU (ms),GPU (ms),SPEEDUP,GPUTOTAL (ms),TOTALSPEEDUP,GPU Min (ms),GPU Max (ms), Standard deviation (ms)\n");
fflush(record_);
}
void TestSystem::printSummary()
{
cout << setiosflags(ios_base::fixed);
cout << "\naverage GPU speedup: x"
<< setprecision(3) << speedup_total_ / std::max(1, num_subtests_called_)
<< endl;
cout << "\nGPU exceeded: "
<< setprecision(3) << speedup_faster_count_
<< "\nGPU passed: "
<< setprecision(3) << speedup_equal_count_
<< "\nGPU failed: "
<< setprecision(3) << speedup_slower_count_
<< endl;
cout << "\nGPU exceeded rate: "
<< setprecision(3) << (float)speedup_faster_count_ / std::max(1, num_subtests_called_) * 100
<< "%"
<< "\nGPU passed rate: "
<< setprecision(3) << (float)speedup_equal_count_ / std::max(1, num_subtests_called_) * 100
<< "%"
<< "\nGPU failed rate: "
<< setprecision(3) << (float)speedup_slower_count_ / std::max(1, num_subtests_called_) * 100
<< "%"
<< endl;
cout << "\naverage GPUTOTAL speedup: x"
<< setprecision(3) << speedup_full_total_ / std::max(1, num_subtests_called_)
<< endl;
cout << "\nGPUTOTAL exceeded: "
<< setprecision(3) << speedup_full_faster_count_
<< "\nGPUTOTAL passed: "
<< setprecision(3) << speedup_full_equal_count_
<< "\nGPUTOTAL failed: "
<< setprecision(3) << speedup_full_slower_count_
<< endl;
cout << "\nGPUTOTAL exceeded rate: "
<< setprecision(3) << (float)speedup_full_faster_count_ / std::max(1, num_subtests_called_) * 100
<< "%"
<< "\nGPUTOTAL passed rate: "
<< setprecision(3) << (float)speedup_full_equal_count_ / std::max(1, num_subtests_called_) * 100
<< "%"
<< "\nGPUTOTAL failed rate: "
<< setprecision(3) << (float)speedup_full_slower_count_ / std::max(1, num_subtests_called_) * 100
<< "%"
<< endl;
cout << resetiosflags(ios_base::fixed);
}
enum GTestColor {
COLOR_DEFAULT,
COLOR_RED,
COLOR_GREEN,
COLOR_YELLOW
};
#if GTEST_OS_WINDOWS&&!GTEST_OS_WINDOWS_MOBILE
// Returns the character attribute for the given color.
static WORD GetColorAttribute(GTestColor color) {
switch (color) {
case COLOR_RED: return FOREGROUND_RED;
case COLOR_GREEN: return FOREGROUND_GREEN;
case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
default: return 0;
}
}
#else
static const char* GetAnsiColorCode(GTestColor color) {
switch (color) {
case COLOR_RED: return "1";
case COLOR_GREEN: return "2";
case COLOR_YELLOW: return "3";
default: return NULL;
};
}
#endif
static void printMetricsUti(double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup, std::stringstream& stream, std::stringstream& cur_subtest_description)
{
//cout <<TAB<< setw(7) << stream.str();
cout <<TAB;
stream.str("");
stream << cpu_time;
cout << setw(10) << stream.str();
stream.str("");
stream << gpu_time;
cout << setw(10) << stream.str();
stream.str("");
stream << "x" << setprecision(3) << speedup;
cout << setw(8) << stream.str();
stream.str("");
stream << gpu_full_time;
cout << setw(10) << stream.str();
stream.str("");
stream << "x" << setprecision(3) << fullspeedup;
cout << setw(10) << stream.str();
cout << cur_subtest_description.str();
cout << resetiosflags(ios_base::left) << endl;
}
void TestSystem::printMetrics(int is_accurate, double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup)
{
cout << setiosflags(ios_base::left);
stringstream stream;
std::stringstream &cur_subtest_description = getCurSubtestDescription();
#if GTEST_OS_WINDOWS&&!GTEST_OS_WINDOWS_MOBILE
WORD color;
const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
// Gets the current text color.
CONSOLE_SCREEN_BUFFER_INFO buffer_info;
GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
const WORD old_color_attrs = buffer_info.wAttributes;
// We need to flush the stream buffers into the console before each
// SetConsoleTextAttribute call lest it affect the text that is already
// printed but has not yet reached the console.
fflush(stdout);
if(is_accurate == 1||is_accurate == -1)
{
color = old_color_attrs;
printMetricsUti(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, stream, cur_subtest_description);
}else
{
color = GetColorAttribute(COLOR_RED);
SetConsoleTextAttribute(stdout_handle,
color| FOREGROUND_INTENSITY);
printMetricsUti(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, stream, cur_subtest_description);
fflush(stdout);
// Restores the text color.
SetConsoleTextAttribute(stdout_handle, old_color_attrs);
}
#else
GTestColor color = COLOR_RED;
if(is_accurate == 1|| is_accurate == -1)
{
printMetricsUti(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, stream, cur_subtest_description);
}else
{
printf("\033[0;3%sm", GetAnsiColorCode(color));
printMetricsUti(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, stream, cur_subtest_description);
printf("\033[m"); // Resets the terminal to default.
}
#endif
}
void TestSystem::writeMetrics(double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup, double gpu_min, double gpu_max, double std_dev)
{
if (!record_)
{
recordname_ += ".csv";
record_ = fopen(recordname_.c_str(), "w");
}
string _is_accurate_;
if(is_accurate_ == 1)
_is_accurate_ = "Pass";
else if(is_accurate_ == 0)
_is_accurate_ = "Fail";
else if(is_accurate_ == -1)
_is_accurate_ = " ";
else
{
std::cout<<"is_accurate errer: "<<is_accurate_<<"\n";
exit(-1);
}
fprintf(record_, "%s,%s,%s,%.2f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n",
itname_changed_ ? itname_.c_str() : "",
cur_subtest_description_.str().c_str(),
_is_accurate_.c_str(),
accurate_diff_,
cpu_time, gpu_time, speedup, gpu_full_time, fullspeedup,
gpu_min, gpu_max, std_dev);
if (itname_changed_)
{
itname_changed_ = false;
}
fflush(record_);
}
void TestSystem::writeSummary()
{
if (!record_)
{
recordname_ += ".csv";
record_ = fopen(recordname_.c_str(), "w");
}
fprintf(record_, "\nAverage GPU speedup: %.3f\n"
"exceeded: %d (%.3f%%)\n"
"passed: %d (%.3f%%)\n"
"failed: %d (%.3f%%)\n"
"\nAverage GPUTOTAL speedup: %.3f\n"
"exceeded: %d (%.3f%%)\n"
"passed: %d (%.3f%%)\n"
"failed: %d (%.3f%%)\n",
speedup_total_ / std::max(1, num_subtests_called_),
speedup_faster_count_, (float)speedup_faster_count_ / std::max(1, num_subtests_called_) * 100,
speedup_equal_count_, (float)speedup_equal_count_ / std::max(1, num_subtests_called_) * 100,
speedup_slower_count_, (float)speedup_slower_count_ / std::max(1, num_subtests_called_) * 100,
speedup_full_total_ / std::max(1, num_subtests_called_),
speedup_full_faster_count_, (float)speedup_full_faster_count_ / std::max(1, num_subtests_called_) * 100,
speedup_full_equal_count_, (float)speedup_full_equal_count_ / std::max(1, num_subtests_called_) * 100,
speedup_full_slower_count_, (float)speedup_full_slower_count_ / std::max(1, num_subtests_called_) * 100
);
fflush(record_);
}
void TestSystem::printError(const std::string &msg)
{
if(msg != "CL_INVALID_BUFFER_SIZE")
{
cout << TAB << "[error: " << msg << "] " << cur_subtest_description_.str() << endl;
}
}
void gen(Mat &mat, int rows, int cols, int type, Scalar low, Scalar high)
{
mat.create(rows, cols, type);
RNG rng(0);
rng.fill(mat, RNG::UNIFORM, low, high);
}
string abspath(const string &relpath)
{
return TestSystem::instance().workingDir() + relpath;
}
int CV_CDECL cvErrorCallback(int /*status*/, const char * /*func_name*/,
const char *err_msg, const char * /*file_name*/,
int /*line*/, void * /*userdata*/)
{
TestSystem::instance().printError(err_msg);
return 0;
}
double checkNorm(const Mat &m)
{
return norm(m, NORM_INF);
}
double checkNorm(const Mat &m1, const Mat &m2)
{
return norm(m1, m2, NORM_INF);
}
double checkSimilarity(const Mat &m1, const Mat &m2)
{
Mat diff;
matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED);
return std::abs(diff.at<float>(0, 0) - 1.f);
}

472
modules/ocl/perf/perf_precomp.hpp
Unescape View File

@ -40,6 +40,14 @@
//
//M*/
#ifdef __GNUC__
# pragma GCC diagnostic ignored "-Wmissing-declarations"
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic ignored "-Wmissing-prototypes"
# pragma GCC diagnostic ignored "-Wextra"
# endif
#endif
#ifndef __OPENCV_PERF_PRECOMP_HPP__
#define __OPENCV_PERF_PRECOMP_HPP__
@ -50,6 +58,7 @@
#include <cstdio>
#include <vector>
#include <numeric>
#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
@ -59,455 +68,38 @@
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/ocl/ocl.hpp"
#include "opencv2/ts/ts.hpp"
#include "opencv2/ts/ts_perf.hpp"
#include "opencv2/ts/ts_gtest.h"
#define Min_Size 1000
#define Max_Size 4000
#define Multiple 2
#define TAB " "
using namespace std;
using namespace cv;
void gen(Mat &mat, int rows, int cols, int type, Scalar low, Scalar high);
void gen(Mat &mat, int rows, int cols, int type, int low, int high, int n);
string abspath(const string &relpath);
int CV_CDECL cvErrorCallback(int, const char *, const char *, const char *, int, void *);
typedef struct
{
short x;
short y;
} COOR;
COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep,
cv::Size size, int sp, int sr, int maxIter, float eps, int *tab);
void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi,
int sp, int sr, cv::TermCriteria crit);
template<class T1, class T2>
int ExpectedEQ(T1 expected, T2 actual)
{
if(expected == actual)
return 1;
return 0;
}
template<class T1>
int EeceptDoubleEQ(T1 expected, T1 actual)
{
testing::internal::Double lhs(expected);
testing::internal::Double rhs(actual);
if (lhs.AlmostEquals(rhs))
{
return 1;
}
return 0;
}
template<class T>
int AssertEQ(T expected, T actual)
{
if(expected == actual)
{
return 1;
}
return 0;
}
int ExceptDoubleNear(double val1, double val2, double abs_error);
bool match_rect(cv::Rect r1, cv::Rect r2, int threshold);
double checkNorm(const cv::Mat &m);
double checkNorm(const cv::Mat &m1, const cv::Mat &m2);
double checkSimilarity(const cv::Mat &m1, const cv::Mat &m2);
int ExpectedMatNear(cv::Mat dst, cv::Mat cpu_dst, double eps);
int ExceptedMatSimilar(cv::Mat dst, cv::Mat cpu_dst, double eps);
class Runnable
{
public:
explicit Runnable(const std::string &runname): name_(runname) {}
virtual ~Runnable() {}
const std::string &name() const
{
return name_;
}
virtual void run() = 0;
private:
std::string name_;
};
class TestSystem
{
public:
static TestSystem &instance()
{
static TestSystem me;
return me;
}
void setWorkingDir(const std::string &val)
{
working_dir_ = val;
}
const std::string &workingDir() const
{
return working_dir_;
}
void setTestFilter(const std::string &val)
{
test_filter_ = val;
}
const std::string &testFilter() const
{
return test_filter_;
}
void setNumIters(int num_iters)
{
num_iters_ = num_iters;
}
void setGPUWarmupIters(int num_iters)
{
gpu_warmup_iters_ = num_iters;
}
void setCPUIters(int num_iters)
{
cpu_num_iters_ = num_iters;
}
void setTopThreshold(double top)
{
top_ = top;
}
void setBottomThreshold(double bottom)
{
bottom_ = bottom;
}
void addInit(Runnable *init)
{
inits_.push_back(init);
}
void addTest(Runnable *test)
{
tests_.push_back(test);
}
void run();
// It's public because OpenCV callback uses it
void printError(const std::string &msg);
std::stringstream &startNewSubtest()
{
finishCurrentSubtest();
return cur_subtest_description_;
}
bool stop() const
{
return cur_iter_idx_ >= num_iters_;
}
bool cpu_stop() const
{
return cur_iter_idx_ >= cpu_num_iters_;
}
int get_cur_iter_idx()
{
return cur_iter_idx_;
}
int get_cpu_num_iters()
{
return cpu_num_iters_;
}
bool warmupStop()
{
return cur_warmup_idx_++ >= gpu_warmup_iters_;
}
void warmupComplete()
{
cur_warmup_idx_ = 0;
}
#define OCL_SIZE_1000 Size(1000, 1000)
#define OCL_SIZE_2000 Size(2000, 2000)
#define OCL_SIZE_4000 Size(4000, 4000)
void cpuOn()
{
cpu_started_ = cv::getTickCount();
}
void cpuOff()
{
int64 delta = cv::getTickCount() - cpu_started_;
cpu_times_.push_back(delta);
++cur_iter_idx_;
}
void cpuComplete()
{
cpu_elapsed_ += meanTime(cpu_times_);
cur_subtest_is_empty_ = false;
cur_iter_idx_ = 0;
}
#define OCL_TYPICAL_MAT_SIZES ::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000, OCL_SIZE_4000)
void gpuOn()
{
gpu_started_ = cv::getTickCount();
}
void gpuOff()
{
int64 delta = cv::getTickCount() - gpu_started_;
gpu_times_.push_back(delta);
++cur_iter_idx_;
}
void gpuComplete()
{
gpu_elapsed_ += meanTime(gpu_times_);
cur_subtest_is_empty_ = false;
cur_iter_idx_ = 0;
}
#define OCL_PERF_ENUM(type, ...) ::testing::Values(type, ## __VA_ARGS__ )
void gpufullOn()
{
gpu_full_started_ = cv::getTickCount();
}
void gpufullOff()
{
int64 delta = cv::getTickCount() - gpu_full_started_;
gpu_full_times_.push_back(delta);
++cur_iter_idx_;
}
void gpufullComplete()
{
gpu_full_elapsed_ += meanTime(gpu_full_times_);
cur_subtest_is_empty_ = false;
cur_iter_idx_ = 0;
}
#define IMPL_OCL "ocl"
#define IMPL_GPU "gpu"
#define IMPL_PLAIN "plain"
bool isListMode() const
{
return is_list_mode_;
}
void setListMode(bool value)
{
is_list_mode_ = value;
}
#define RUN_OCL_IMPL (IMPL_OCL == getSelectedImpl())
#define RUN_PLAIN_IMPL (IMPL_PLAIN == getSelectedImpl())
void setRecordName(const std::string &name)
{
recordname_ = name;
}
void setCurrentTest(const std::string &name)
{
itname_ = name;
itname_changed_ = true;
}
void setAccurate(int accurate, double diff)
{
is_accurate_ = accurate;
accurate_diff_ = diff;
}
void ExpectMatsNear(vector<Mat>& dst, vector<Mat>& cpu_dst, vector<double>& eps)
{
assert(dst.size() == cpu_dst.size());
assert(cpu_dst.size() == eps.size());
is_accurate_ = 1;
for(size_t i=0; i<dst.size(); i++)
{
double cur_diff = checkNorm(dst[i], cpu_dst[i]);
accurate_diff_ = max(accurate_diff_, cur_diff);
if(cur_diff > eps[i])
is_accurate_ = 0;
}
}
void ExpectedMatNear(cv::Mat& dst, cv::Mat& cpu_dst, double eps)
{
assert(dst.type() == cpu_dst.type());
assert(dst.size() == cpu_dst.size());
accurate_diff_ = checkNorm(dst, cpu_dst);
if(accurate_diff_ <= eps)
is_accurate_ = 1;
else
is_accurate_ = 0;
}
void ExceptedMatSimilar(cv::Mat& dst, cv::Mat& cpu_dst, double eps)
{
assert(dst.type() == cpu_dst.type());
assert(dst.size() == cpu_dst.size());
accurate_diff_ = checkSimilarity(cpu_dst, dst);
if(accurate_diff_ <= eps)
is_accurate_ = 1;
else
is_accurate_ = 0;
}
std::stringstream &getCurSubtestDescription()
{
return cur_subtest_description_;
}
private:
TestSystem():
cur_subtest_is_empty_(true), cpu_elapsed_(0),
gpu_elapsed_(0), gpu_full_elapsed_(0), speedup_total_(0.0),
num_subtests_called_(0),
speedup_faster_count_(0), speedup_slower_count_(0), speedup_equal_count_(0),
speedup_full_faster_count_(0), speedup_full_slower_count_(0), speedup_full_equal_count_(0), is_list_mode_(false),
num_iters_(10), cpu_num_iters_(2),
gpu_warmup_iters_(1), cur_iter_idx_(0), cur_warmup_idx_(0),
record_(0), recordname_("performance"), itname_changed_(true),
is_accurate_(-1), accurate_diff_(0.)
{
cpu_times_.reserve(num_iters_);
gpu_times_.reserve(num_iters_);
gpu_full_times_.reserve(num_iters_);
}
void finishCurrentSubtest();
void resetCurrentSubtest()
{
cpu_elapsed_ = 0;
gpu_elapsed_ = 0;
gpu_full_elapsed_ = 0;
cur_subtest_description_.str("");
cur_subtest_is_empty_ = true;
cur_iter_idx_ = 0;
cur_warmup_idx_ = 0;
cpu_times_.clear();
gpu_times_.clear();
gpu_full_times_.clear();
is_accurate_ = -1;
accurate_diff_ = 0.;
}
double meanTime(const std::vector<int64> &samples);
void printHeading();
void printSummary();
void printMetrics(int is_accurate, double cpu_time, double gpu_time = 0.0f, double gpu_full_time = 0.0f, double speedup = 0.0f, double fullspeedup = 0.0f);
void writeHeading();
void writeSummary();
void writeMetrics(double cpu_time, double gpu_time = 0.0f, double gpu_full_time = 0.0f,
double speedup = 0.0f, double fullspeedup = 0.0f,
double gpu_min = 0.0f, double gpu_max = 0.0f, double std_dev = 0.0f);
std::string working_dir_;
std::string test_filter_;
std::vector<Runnable *> inits_;
std::vector<Runnable *> tests_;
std::stringstream cur_subtest_description_;
bool cur_subtest_is_empty_;
int64 cpu_started_;
int64 gpu_started_;
int64 gpu_full_started_;
double cpu_elapsed_;
double gpu_elapsed_;
double gpu_full_elapsed_;
double speedup_total_;
double speedup_full_total_;
int num_subtests_called_;
int speedup_faster_count_;
int speedup_slower_count_;
int speedup_equal_count_;
int speedup_full_faster_count_;
int speedup_full_slower_count_;
int speedup_full_equal_count_;
bool is_list_mode_;
double top_;
double bottom_;
int num_iters_;
int cpu_num_iters_; //there's no need to set cpu running same times with gpu
int gpu_warmup_iters_; //gpu warm up times, default is 1
int cur_iter_idx_;
int cur_warmup_idx_; //current gpu warm up times
std::vector<int64> cpu_times_;
std::vector<int64> gpu_times_;
std::vector<int64> gpu_full_times_;
FILE *record_;
std::string recordname_;
std::string itname_;
bool itname_changed_;
int is_accurate_;
double accurate_diff_;
};
#define GLOBAL_INIT(name) \
struct name##_init: Runnable { \
name##_init(): Runnable(#name) { \
TestSystem::instance().addInit(this); \
} \
void run(); \
} name##_init_instance; \
void name##_init::run()
#define PERFTEST(name) \
struct name##_test: Runnable { \
name##_test(): Runnable(#name) { \
TestSystem::instance().addTest(this); \
} \
void run(); \
} name##_test_instance; \
void name##_test::run()
#define SUBTEST TestSystem::instance().startNewSubtest()
#define CPU_ON \
while (!TestSystem::instance().cpu_stop()) { \
TestSystem::instance().cpuOn()
#define CPU_OFF \
TestSystem::instance().cpuOff(); \
} TestSystem::instance().cpuComplete()
#define GPU_ON \
while (!TestSystem::instance().stop()) { \
TestSystem::instance().gpuOn()
#define GPU_OFF \
ocl::finish();\
TestSystem::instance().gpuOff(); \
} TestSystem::instance().gpuComplete()
#define GPU_FULL_ON \
while (!TestSystem::instance().stop()) { \
TestSystem::instance().gpufullOn()
#define GPU_FULL_OFF \
TestSystem::instance().gpufullOff(); \
} TestSystem::instance().gpufullComplete()
#ifdef HAVE_OPENCV_GPU
# define RUN_GPU_IMPL (IMPL_GPU == getSelectedImpl())
#endif
#define WARMUP_ON \
while (!TestSystem::instance().warmupStop()) {
#define WARMUP_OFF \
ocl::finish();\
} TestSystem::instance().warmupComplete()
#ifdef HAVE_OPENCV_GPU
#define OCL_PERF_ELSE \
if (RUN_GPU_IMPL) \
CV_TEST_FAIL_NO_IMPL(); \
else \
CV_TEST_FAIL_NO_IMPL();
#else
#define OCL_PERF_ELSE \
CV_TEST_FAIL_NO_IMPL();
#endif
#endif

116
modules/ocl/perf/perf_pyramid.cpp
Unescape View File

@ -45,88 +45,80 @@
//M*/
#include "perf_precomp.hpp"
///////////// pyrDown //////////////////////
PERFTEST(pyrDown)
{
Mat src, dst, ocl_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
///////////// pyrDown //////////////////////
gen(src, size, size, all_type[j], 0, 256);
typedef Size_MatType pyrDownFixture;
pyrDown(src, dst);
PERF_TEST_P(pyrDownFixture, pyrDown,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
CPU_ON;
pyrDown(src, dst);
CPU_OFF;
Mat src(srcSize, type), dst;
Size dstSize((srcSize.height + 1) >> 1, (srcSize.width + 1) >> 1);
dst.create(dstSize, type);
declare.in(src, WARMUP_RNG).out(dst);
ocl::oclMat d_src(src);
ocl::oclMat d_dst;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(dstSize, type);
WARMUP_ON;
ocl::pyrDown(d_src, d_dst);
WARMUP_OFF;
TEST_CYCLE() ocl::pyrDown(oclSrc, oclDst);
GPU_ON;
ocl::pyrDown(d_src, d_dst);
GPU_OFF;
oclDst.download(dst);
GPU_FULL_ON;
d_src.upload(src);
ocl::pyrDown(d_src, d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() pyrDown(src, dst);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, dst.depth() == CV_32F ? 1e-4f : 1.0f);
}
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
///////////// pyrUp ////////////////////////
PERFTEST(pyrUp)
{
Mat src, dst, ocl_dst;
int all_type[] = {CV_8UC1, CV_8UC4};
std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
for (int size = 500; size <= 2000; size *= 2)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
gen(src, size, size, all_type[j], 0, 256);
typedef Size_MatType pyrUpFixture;
pyrUp(src, dst);
PERF_TEST_P(pyrUpFixture, pyrUp,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
CPU_ON;
pyrUp(src, dst);
CPU_OFF;
Mat src(srcSize, type), dst;
Size dstSize(srcSize.height << 1, srcSize.width << 1);
dst.create(dstSize, type);
declare.in(src, WARMUP_RNG).out(dst);
ocl::oclMat d_src(src);
ocl::oclMat d_dst;
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src), oclDst(dstSize, type);
WARMUP_ON;
ocl::pyrUp(d_src, d_dst);
WARMUP_OFF;
TEST_CYCLE() ocl::pyrDown(oclSrc, oclDst);
GPU_ON;
ocl::pyrUp(d_src, d_dst);
GPU_OFF;
oclDst.download(dst);
GPU_FULL_ON;
d_src.upload(src);
ocl::pyrUp(d_src, d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() pyrDown(src, dst);
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, (src.depth() == CV_32F ? 1e-4f : 1.0));
}
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}

165
modules/ocl/perf/perf_split_merge.cpp
Unescape View File

@ -45,110 +45,97 @@
//M*/
#include "perf_precomp.hpp"
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
///////////// Merge////////////////////////
PERFTEST(Merge)
{
Mat dst, ocl_dst;
ocl::oclMat d_dst;
int channels = 4;
int all_type[] = {CV_8UC1, CV_32FC1};
std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
typedef Size_MatType MergeFixture;
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
PERF_TEST_P(MergeFixture, Merge,
::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000),
OCL_PERF_ENUM(CV_8U, CV_32F)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int depth = get<1>(params), channels = 3;
const int dstType = CV_MAKE_TYPE(depth, channels);
Mat dst(srcSize, dstType);
vector<Mat> src(channels);
for (vector<Mat>::iterator i = src.begin(), end = src.end(); i != end; ++i)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j] ;
Size size1 = Size(size, size);
std::vector<Mat> src(channels);
for (int i = 0; i < channels; ++i)
{
src[i] = Mat(size1, all_type[j], cv::Scalar::all(i));
}
merge(src, dst);
CPU_ON;
merge(src, dst);
CPU_OFF;
std::vector<ocl::oclMat> d_src(channels);
for (int i = 0; i < channels; ++i)
{
d_src[i] = ocl::oclMat(size1, all_type[j], cv::Scalar::all(i));
}
WARMUP_ON;
ocl::merge(d_src, d_dst);
WARMUP_OFF;
GPU_ON;
ocl::merge(d_src, d_dst);
GPU_OFF;
GPU_FULL_ON;
for (int i = 0; i < channels; ++i)
{
d_src[i] = ocl::oclMat(size1, all_type[j], cv::Scalar::all(i));
}
ocl::merge(d_src, d_dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
}
i->create(srcSize, CV_MAKE_TYPE(depth, 1));
declare.in(*i, WARMUP_RNG);
}
}
declare.out(dst);
///////////// Split////////////////////////
PERFTEST(Split)
{
//int channels = 4;
int all_type[] = {CV_8UC1, CV_32FC1};
std::string type_name[] = {"CV_8UC1", "CV_32FC1"};
for (int size = Min_Size; size <= Max_Size; size *= Multiple)
if (RUN_OCL_IMPL)
{
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
{
SUBTEST << size << 'x' << size << "; " << type_name[j];
Size size1 = Size(size, size);
Mat src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4));
ocl::oclMat oclDst(srcSize, dstType);
vector<ocl::oclMat> oclSrc(src.size());
for (vector<ocl::oclMat>::size_type i = 0, end = src.size(); i < end; ++i)
oclSrc[i] = src[i];
std::vector<cv::Mat> dst, ocl_dst(4);
TEST_CYCLE() cv::ocl::merge(oclSrc, oclDst);
split(src, dst);
oclDst.download(dst);
CPU_ON;
split(src, dst);
CPU_OFF;
SANITY_CHECK(dst);
}
else if (RUN_PLAIN_IMPL)
{
TEST_CYCLE() cv::merge(src, dst);
ocl::oclMat d_src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4));
std::vector<cv::ocl::oclMat> d_dst;
SANITY_CHECK(dst);
}
else
OCL_PERF_ELSE
}
WARMUP_ON;
ocl::split(d_src, d_dst);
WARMUP_OFF;
///////////// Split////////////////////////
GPU_ON;
ocl::split(d_src, d_dst);
GPU_OFF;
typedef Size_MatType SplitFixture;
GPU_FULL_ON;
d_src.upload(src);
ocl::split(d_src, d_dst);
for(size_t i = 0; i < dst.size(); i++)
d_dst[i].download(ocl_dst[i]);
GPU_FULL_OFF;
PERF_TEST_P(SplitFixture, Split,
::testing::Combine(OCL_TYPICAL_MAT_SIZES,
OCL_PERF_ENUM(CV_8U, CV_32F)))
{
const Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int depth = get<1>(params), channels = 3;
vector<double> eps(4, 0.);
TestSystem::instance().ExpectMatsNear(dst, ocl_dst, eps);
}
Mat src(srcSize, CV_MAKE_TYPE(depth, channels));
declare.in(src, WARMUP_RNG);
if (RUN_OCL_IMPL)
{
ocl::oclMat oclSrc(src);
vector<ocl::oclMat> oclDst(channels, ocl::oclMat(srcSize, CV_MAKE_TYPE(depth, 1)));
TEST_CYCLE() cv::ocl::split(oclSrc, oclDst);
ASSERT_EQ(3, channels);
Mat dst0, dst1, dst2;
oclDst[0].download(dst0);
oclDst[1].download(dst1);
oclDst[2].download(dst2);
SANITY_CHECK(dst0);
SANITY_CHECK(dst1);
SANITY_CHECK(dst2);
}
else if (RUN_PLAIN_IMPL)
{
vector<Mat> dst(channels, Mat(srcSize, CV_MAKE_TYPE(depth, 1)));
TEST_CYCLE() cv::split(src, dst);
ASSERT_EQ(3, channels);
Mat & dst0 = dst[0], & dst1 = dst[1], & dst2 = dst[2];
SANITY_CHECK(dst0);
SANITY_CHECK(dst1);
SANITY_CHECK(dst2);
}
else
OCL_PERF_ELSE
}

2
modules/ocl/src/arithm.cpp
Unescape View File

@ -2336,7 +2336,7 @@ void cv::ocl::pow(const oclMat &x, double p, oclMat &y)
return;
}
CV_Assert((x.type() == y.type() && x.size() == y.size() && x.depth() == CV_32F) || x.depth() == CV_64F);
CV_Assert(x.depth() == CV_32F || x.depth() == CV_64F);
y.create(x.size(), x.type());
string kernelName = "arithm_pow";

63
modules/ocl/test/test_norm.cpp
Unescape View File

@ -0,0 +1,63 @@
/*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) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// 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 "test_precomp.hpp"
typedef ::testing::TestWithParam<cv::Size> normFixture;
TEST_P(normFixture, DISABLED_accuracy)
{
const cv::Size srcSize = GetParam();
cv::Mat src1(srcSize, CV_8UC1), src2(srcSize, CV_8UC1);
cv::randu(src1, 0, 2);
cv::randu(src2, 0, 2);
cv::ocl::oclMat oclSrc1(src1), oclSrc2(src2);
double value = cv::norm(src1, src2, cv::NORM_INF);
double oclValue = cv::ocl::norm(oclSrc1, oclSrc2, cv::NORM_INF);
ASSERT_EQ(value, oclValue);
}
INSTANTIATE_TEST_CASE_P(oclNormTest, normFixture,
::testing::Values(cv::Size(500, 500), cv::Size(1000, 1000)));
Write Preview
Loading…
Cancel
Save