Skip to content

O
opencv
Commit 4c28a6f0 authored by ilya-lavrenov's avatar ilya-lavrenov
Browse files
Options

most of the performance tests was rewritten in google-test manner

parent 6c4ad9b5
Expand all Show whitespace changes
Inline Side-by-side
Showing with 356 additions and 357 deletions
modules/ocl/perf/main.cpp
View file @ 4c28a6f0
...@@ -42,7 +42,7 @@ ...@@ -42,7 +42,7 @@
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
int main(int argc, const char *argv[]) static int old_main(int argc, const char *argv[])
{ {
const char *keys = const char *keys =
"{ h | help | false | print help message }" "{ h | help | false | print help message }"
...@@ -162,3 +162,33 @@ END_DEV: ...@@ -162,3 +162,33 @@ END_DEV:
return 0; return 0;
} }
const char * impls[] =
{
"ocl",
"plain",
#ifdef HAVE_OPENCV_GPU
"gpu"
#endif
};
int main(int argc, char **argv)
{
// temp solution: if no '--gtest_' and '--perf_' args switch to old behavior
bool useGTest = false;
for(int i=1; i<argc; i++)
{
std::string arg( argv[i] );
if( arg.find("--gtest_")==0 || arg.find("--perf_")==0 )
useGTest = true;
// if (arg == "--perf_verify_sanity")
// argv[i] = (char*)"--perf_no_verify_sanity";
}
if( !useGTest )
return old_main(argc, (const char**)argv);
CV_PERF_TEST_MAIN_INTERNALS(ocl, impls)
}
modules/ocl/perf/perf_arithm.cpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_blend.cpp
View file @ 4c28a6f0
...@@ -45,9 +45,15 @@ ...@@ -45,9 +45,15 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
using namespace perf;
///////////// blend //////////////////////// ///////////// blend ////////////////////////
template <typename T> 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()); result_gold.create(img1.size(), img1.type());
...@@ -63,60 +69,54 @@ void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &we ...@@ -63,60 +69,54 @@ void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &we
for (int x = 0; x < img1.cols * cn; ++x) for (int x = 0; x < img1.cols * cn; ++x)
{ {
float w1 = weights1_row[x / cn]; int x1 = x * cn;
float w2 = weights2_row[x / cn]; float w1 = weights1_row[x];
result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f)); 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; // getting params
ocl::oclMat d_src1, d_src2, d_weights1, d_weights2, d_dst; const Size srcSize = GetParam();
const int type = CV_8UC1;
const std::string impl = getSelectedImpl();
int all_type[] = {CV_8UC1, CV_8UC4}; // creating src data
std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; Mat src1(srcSize, type), src2(srcSize, CV_8UC1), dst;
Mat weights1(srcSize, CV_32FC1), weights2(srcSize, CV_32FC1);
for (int size = Min_Size; size <= Max_Size; size *= Multiple) declare.in(src1, src2, WARMUP_RNG);
{ randu(weights1, 0.0f, 1.0f);
for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) randu(weights2, 0.0f, 1.0f);
// select implementation
if (impl == "ocl")
{ {
SUBTEST << size << 'x' << size << "; " << type_name[j] << " and CV_32FC1"; ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst;
ocl::oclMat oclWeights1(weights1), oclWeights2(weights2);
gen(src1, size, size, all_type[j], 0, 256);
gen(src2, size, size, all_type[j], 0, 256); TEST_CYCLE() cv::ocl::blendLinear(oclSrc1, oclSrc2, oclWeights1, oclWeights2, oclDst);
gen(weights1, size, size, CV_32FC1, 0, 1);
gen(weights2, size, size, CV_32FC1, 0, 1); oclDst.download(dst);
blendLinearGold<uchar>(src1, src2, weights1, weights2, dst); SANITY_CHECK(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);
} }
else if (impl == "plain")
{
TEST_CYCLE() blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
SANITY_CHECK(dst);
} }
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_calib3d.cpp
View file @ 4c28a6f0
...@@ -45,48 +45,49 @@ ...@@ -45,48 +45,49 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
///////////// StereoMatchBM //////////////////////// ///////////// StereoMatchBM ////////////////////////
PERFTEST(StereoMatchBM)
PERF_TEST(StereoMatchBMFixture, DISABLED_StereoMatchBM)
{ {
Mat left_image = imread(abspath("aloeL.jpg"), cv::IMREAD_GRAYSCALE); Mat left_image = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE);
Mat right_image = imread(abspath("aloeR.jpg"), cv::IMREAD_GRAYSCALE); Mat right_image = imread(getDataPath("gpu/stereobm/aloe-R.png"), 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 "; 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());
StereoBM bm(0, n_disp, winSize); const std::string impl = getSelectedImpl();
bm(left_image, right_image, dst); const int n_disp = 128, winSize = 19;
Mat disp(left_image.size(), CV_16SC1);
CPU_ON; declare.in(left_image, right_image).out(disp);
bm(left_image, right_image, dst);
CPU_OFF;
d_left.upload(left_image); if (impl == "ocl")
d_right.upload(right_image); {
ocl::oclMat oclLeft(left_image), oclRight(right_image),
oclDisp(left_image.size(), CV_16SC1);
ocl::StereoBM_OCL oclBM(0, n_disp, winSize);
ocl::StereoBM_OCL d_bm(0, n_disp, winSize); TEST_CYCLE() oclBM(oclLeft, oclRight, oclDisp);
WARMUP_ON; oclDisp.download(disp);
d_bm(d_left, d_right, d_disp);
WARMUP_OFF;
cv::Mat ocl_mat; SANITY_CHECK(disp);
d_disp.download(ocl_mat); }
ocl_mat.convertTo(ocl_mat, dst.type()); else if (impl == "plain")
{
GPU_ON; StereoBM bm(0, n_disp, winSize);
d_bm(d_left, d_right, d_disp);
GPU_OFF;
GPU_FULL_ON; TEST_CYCLE() bm(left_image, right_image, disp);
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;
TestSystem::instance().setAccurate(-1, 0.); SANITY_CHECK(disp);
}
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_canny.cpp
View file @ 4c28a6f0
...@@ -45,41 +45,38 @@ ...@@ -45,41 +45,38 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
///////////// Canny //////////////////////// using namespace perf;
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";
Mat edges(img.size(), CV_8UC1), ocl_edges; ///////////// Canny ////////////////////////
CPU_ON; PERF_TEST(CannyFixture, Canny)
Canny(img, edges, 50.0, 100.0); {
CPU_OFF; Mat img = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE),
edges(img.size(), CV_8UC1);
ASSERT_TRUE(!img.empty()) << "can't open aloeL.jpg";
ocl::oclMat d_img(img); const std::string impl = getSelectedImpl();
ocl::oclMat d_edges; declare.in(img).out(edges);
ocl::CannyBuf d_buf;
WARMUP_ON; if (impl == "ocl")
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0); {
WARMUP_OFF; ocl::oclMat oclImg(img), oclEdges(img.size(), CV_8UC1);
GPU_ON; TEST_CYCLE() Canny(oclImg, oclEdges, 50.0, 100.0);
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0); oclEdges.download(edges);
GPU_OFF;
GPU_FULL_ON; SANITY_CHECK(edges);
d_img.upload(img); }
ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0); else if (impl == "plain")
d_edges.download(ocl_edges); {
GPU_FULL_OFF; TEST_CYCLE() Canny(img, edges, 50.0, 100.0);
TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2); SANITY_CHECK(edges);
}
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_color.cpp
View file @ 4c28a6f0
...@@ -45,49 +45,39 @@ ...@@ -45,49 +45,39 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
///////////// cvtColor//////////////////////// using namespace perf;
PERFTEST(cvtColor)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_8UC4}; ///////////// cvtColor////////////////////////
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; typedef TestBaseWithParam<Size> cvtColorFixture;
cvtColor(src, dst, CV_RGBA2GRAY, 4);
CPU_OFF;
d_src.upload(src); PERF_TEST_P(cvtColorFixture, cvtColor, OCL_TYPICAL_MAT_SIZES)
{
const Size srcSize = GetParam();
const std::string impl = getSelectedImpl();
WARMUP_ON; Mat src(srcSize, CV_8UC4), dst(srcSize, CV_8UC4);
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4); declare.in(src).out(dst);
WARMUP_OFF;
GPU_ON; if (impl == "ocl")
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4); {
GPU_OFF; ocl::oclMat oclSrc(src), oclDst(src.size(), CV_8UC4);
GPU_FULL_ON; TEST_CYCLE() ocl::cvtColor(oclSrc, oclDst, CV_RGBA2GRAY, 4);
d_src.upload(src); oclDst.download(dst);
ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TestSystem::instance().ExceptedMatSimilar(dst, ocl_dst, 1e-5); SANITY_CHECK(dst);
} }
else if (impl == "plain")
{
TEST_CYCLE() cv::cvtColor(src, dst, CV_RGBA2GRAY, 4);
SANITY_CHECK(dst);
} }
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_fft.cpp
View file @ 4c28a6f0
...@@ -45,47 +45,43 @@ ...@@ -45,47 +45,43 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
///////////// dft //////////////////////// using namespace perf;
PERFTEST(dft)
{
Mat src, dst, ocl_dst;
ocl::oclMat d_src, d_dst;
int all_type[] = {CV_32FC2};
std::string type_name[] = {"CV_32FC2"};
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";
gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(1)); ///////////// dft ////////////////////////
dft(src, dst); typedef TestBaseWithParam<Size> dftFixture;
CPU_ON; PERF_TEST_P(dftFixture, DISABLED_dft, OCL_TYPICAL_MAT_SIZES)
dft(src, dst); {
CPU_OFF; const std::string impl = getSelectedImpl();
Size srcSize = GetParam();
d_src.upload(src); Mat src(srcSize, CV_32FC2), dst;
randu(src, 0.0f, 1.0f);
declare.in(src);
WARMUP_ON; if (impl == "ocl")
ocl::dft(d_src, d_dst, Size(size, size)); {
WARMUP_OFF; ocl::oclMat oclSrc(src), oclDst;
GPU_ON; EXPECT_NO_THROW({
ocl::dft(d_src, d_dst, Size(size, size)); TEST_CYCLE() cv::ocl::dft(oclSrc, oclDst);
GPU_OFF; });
GPU_FULL_ON; oclDst.download(dst);
d_src.upload(src);
ocl::dft(d_src, d_dst, Size(size, size));
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TestSystem::instance().ExpectedMatNear(dst, ocl_dst, src.size().area() * 1e-4); SANITY_CHECK(dst);
} }
else if (impl == "plain")
{
TEST_CYCLE() cv::dft(src, dst);
SANITY_CHECK(dst);
} }
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_filters.cpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_gemm.cpp
View file @ 4c28a6f0
...@@ -45,46 +45,46 @@ ...@@ -45,46 +45,46 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
///////////// gemm //////////////////////// using namespace perf;
PERFTEST(gemm)
{
Mat src1, src2, src3, dst, ocl_dst;
ocl::oclMat d_src1, d_src2, d_src3, d_dst;
for (int size = Min_Size; size <= Max_Size; size *= Multiple) ///////////// gemm ////////////////////////
{
SUBTEST << size << 'x' << size;
gen(src1, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10)); typedef TestBaseWithParam<Size> gemmFixture;
gen(src2, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
gen(src3, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
gemm(src1, src2, 1.0, src3, 1.0, dst); PERF_TEST_P(gemmFixture, DISABLED_gemm, OCL_TYPICAL_MAT_SIZES)
{
// getting params
const Size srcSize = GetParam();
const std::string impl = getSelectedImpl();
CPU_ON; Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1),
gemm(src1, src2, 1.0, src3, 1.0, dst); src3(srcSize, CV_32FC1), dst(srcSize, CV_32FC1);
CPU_OFF; 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); if (impl == "ocl")
d_src2.upload(src2); {
d_src3.upload(src3); ocl::oclMat oclSrc1(src1), oclSrc2(src2),
oclSrc3(src3), oclDst(srcSize, CV_32FC1);
WARMUP_ON; TEST_CYCLE() cv::ocl::gemm(oclSrc1, oclSrc2, 1.0, oclSrc3, 1.0, oclDst);
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
WARMUP_OFF;
GPU_ON; oclDst.download(dst);
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
GPU_OFF;
GPU_FULL_ON; SANITY_CHECK(dst);
d_src1.upload(src1); }
d_src2.upload(src2); else if (impl == "plain")
d_src3.upload(src3); {
ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst); TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst);
d_dst.download(ocl_dst);
GPU_FULL_OFF;
TestSystem::instance().ExpectedMatNear(ocl_dst, dst, src1.cols * src1.rows * 1e-4); SANITY_CHECK(dst);
} }
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_gftt.cpp
View file @ 4c28a6f0
...@@ -46,56 +46,54 @@ ...@@ -46,56 +46,54 @@
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
using namespace perf;
using std::tr1::tuple;
using std::tr1::get;
///////////// GoodFeaturesToTrack //////////////////////// ///////////// GoodFeaturesToTrack ////////////////////////
PERFTEST(GoodFeaturesToTrack)
{
using namespace cv;
int maxCorners = 2000; typedef tuple<string, double> GoodFeaturesToTrackParams;
double qualityLevel = 0.01; typedef TestBaseWithParam<GoodFeaturesToTrackParams> GoodFeaturesToTrackFixture;
std::string images[] = { "rubberwhale1.png", "aloeL.jpg" }; 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)))
{
std::vector<cv::Point2f> pts_gold;
std::vector<cv::Point2f> pts_gold, pts_ocl; // getting params
GoodFeaturesToTrackParams param = GetParam();
const string fileName = getDataPath(get<0>(param)), impl = getSelectedImpl();
const int maxCorners = 2000;
const double qualityLevel = 0.01, minDistance = get<1>(param);
for(size_t imgIdx = 0; imgIdx < (sizeof(images)/sizeof(std::string)); ++imgIdx) Mat frame = imread(fileName, IMREAD_GRAYSCALE);
{ declare.in(frame);
Mat frame = imread(abspath(images[imgIdx]), IMREAD_GRAYSCALE); ASSERT_TRUE(!frame.empty()) << "no input image";
CV_Assert(!frame.empty());
for(float minDistance = 0; minDistance < 4; minDistance += 3.0) if (impl == "ocl")
{ {
SUBTEST << "image = " << images[imgIdx] << "; "; ocl::oclMat oclFrame(frame), pts_oclmat;
SUBTEST << "minDistance = " << minDistance << "; ";
cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
CPU_ON;
cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
CPU_OFF;
cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance); cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance);
ocl::oclMat frame_ocl(frame), pts_oclmat; TEST_CYCLE() detector(oclFrame, pts_oclmat);
WARMUP_ON;
detector(frame_ocl, pts_oclmat);
WARMUP_OFF;
detector.downloadPoints(pts_oclmat, pts_ocl);
double diff = abs(static_cast<float>(pts_gold.size() - pts_ocl.size())); detector.downloadPoints(pts_oclmat, pts_gold);
TestSystem::instance().setAccurate(diff == 0.0, diff);
GPU_ON; SANITY_CHECK(pts_gold);
detector(frame_ocl, pts_oclmat);
GPU_OFF;
GPU_FULL_ON;
frame_ocl.upload(frame);
detector(frame_ocl, pts_oclmat);
detector.downloadPoints(pts_oclmat, pts_ocl);
GPU_FULL_OFF;
} }
else if (impl == "plain")
{
TEST_CYCLE() cv::goodFeaturesToTrack(frame, pts_gold,
maxCorners, qualityLevel, minDistance);
SANITY_CHECK(pts_gold);
} }
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_haar.cpp
View file @ 4c28a6f0
...@@ -45,6 +45,8 @@ ...@@ -45,6 +45,8 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
using namespace perf;
///////////// Haar //////////////////////// ///////////// Haar ////////////////////////
namespace cv namespace cv
{ {
...@@ -83,61 +85,45 @@ public: ...@@ -83,61 +85,45 @@ public:
} }
} }
PERFTEST(Haar)
{
Mat img = imread(abspath("basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE);
if (img.empty()) PERF_TEST(HaarFixture, Haar)
{ {
throw runtime_error("can't open basketball1.png"); const std::string impl = getSelectedImpl();
} vector<Rect> faces;
CascadeClassifier faceCascadeCPU; 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 (!faceCascadeCPU.load(abspath("haarcascade_frontalface_alt.xml"))) if (impl == "plain")
{ {
throw runtime_error("can't load haarcascade_frontalface_alt.xml"); CascadeClassifier faceCascade;
} ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml")))
<< "can't load haarcascade_frontalface_alt.xml";
vector<Rect> faces;
SUBTEST << img.cols << "x" << img.rows << "; scale image"; TEST_CYCLE() faceCascade.detectMultiScale(img, faces,
CPU_ON;
faceCascadeCPU.detectMultiScale(img, faces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
CPU_OFF;
vector<Rect> oclfaces;
ocl::CascadeClassifier_GPU faceCascade;
if (!faceCascade.load(abspath("haarcascade_frontalface_alt.xml"))) SANITY_CHECK(faces, 4 + 1e-4);
{
throw runtime_error("can't load haarcascade_frontalface_alt.xml");
} }
else if (impl == "ocl")
{
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; TEST_CYCLE() faceCascade.detectMultiScale(oclImg, faces,
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
WARMUP_OFF;
if(faces.size() == oclfaces.size())
TestSystem::instance().setAccurate(1, 0);
else
TestSystem::instance().setAccurate(0, abs((int)faces.size() - (int)oclfaces.size()));
faces.clear(); SANITY_CHECK(faces, 4 + 1e-4);
}
GPU_ON;
faceCascade.detectMultiScale(d_img, oclfaces,
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
GPU_OFF;
GPU_FULL_ON; #ifdef HAVE_OPENCV_GPU
d_img.upload(img); else if (impl == "gpu")
faceCascade.detectMultiScale(d_img, oclfaces, CV_TEST_FAIL_NO_IMPL();
1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); #endif
GPU_FULL_OFF; else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_hog.cpp
View file @ 4c28a6f0
...@@ -45,50 +45,42 @@ ...@@ -45,50 +45,42 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
using namespace perf;
///////////// HOG//////////////////////// ///////////// HOG////////////////////////
PERFTEST(HOG) PERF_TEST(HOGFixture, HOG)
{ {
Mat src = imread(abspath("road.png"), cv::IMREAD_GRAYSCALE); Mat src = imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE);
ASSERT_TRUE(!src.empty()) << "can't open input image road.png";
if (src.empty()) const std::string impl = getSelectedImpl();
{ std::vector<cv::Rect> found_locations;
throw runtime_error("can't open road.png"); declare.in(src).time(5);
}
if (impl == "plain")
{
cv::HOGDescriptor hog; cv::HOGDescriptor hog;
hog.setSVMDetector(hog.getDefaultPeopleDetector()); hog.setSVMDetector(hog.getDefaultPeopleDetector());
std::vector<cv::Rect> found_locations;
std::vector<cv::Rect> d_found_locations;
SUBTEST << src.cols << 'x' << src.rows << "; road.png";
hog.detectMultiScale(src, found_locations); TEST_CYCLE() hog.detectMultiScale(src, found_locations);
CPU_ON;
hog.detectMultiScale(src, found_locations);
CPU_OFF;
SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
}
else if (impl == "ocl")
{
cv::ocl::HOGDescriptor ocl_hog; cv::ocl::HOGDescriptor ocl_hog;
ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector()); ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
ocl::oclMat d_src; ocl::oclMat oclSrc(src);
d_src.upload(src);
WARMUP_ON; TEST_CYCLE() ocl_hog.detectMultiScale(oclSrc, found_locations);
ocl_hog.detectMultiScale(d_src, d_found_locations);
WARMUP_OFF;
if(d_found_locations.size() == found_locations.size()) SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
TestSystem::instance().setAccurate(1, 0); }
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else else
TestSystem::instance().setAccurate(0, abs((int)found_locations.size() - (int)d_found_locations.size())); CV_TEST_FAIL_NO_IMPL();
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;
} }
modules/ocl/perf/perf_imgproc.cpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_match_template.cpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_matrix_operation.cpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_moments.cpp
View file @ 4c28a6f0
...@@ -43,50 +43,59 @@ ...@@ -43,50 +43,59 @@
// the use of this software, even if advised of the possibility of such damage. // the use of this software, even if advised of the possibility of such damage.
// //
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
///////////// Moments ////////////////////////
PERFTEST(Moments)
{
Mat src;
bool binaryImage = 0;
int all_type[] = {CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1}; using namespace perf;
std::string type_name[] = {"CV_8UC1", "CV_16SC1", "CV_32FC1", "CV_64FC1"}; using std::tr1::tuple;
using std::tr1::get;
for (int size = Min_Size; size <= Max_Size; size *= Multiple) ///////////// Moments ////////////////////////
{
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); CV_ENUM(MomentsMatType, CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1)
cv::Moments CvMom = moments(src, binaryImage); typedef tuple<Size, MomentsMatType> MomentsParams;
typedef TestBaseWithParam<MomentsParams> MomentsFixture;
CPU_ON; PERF_TEST_P(MomentsFixture, DISABLED_Moments,
moments(src, binaryImage); ::testing::Combine(OCL_TYPICAL_MAT_SIZES,
CPU_OFF; MomentsMatType::all()))
{
// getting params
MomentsParams params = GetParam();
const Size srcSize = get<0>(params);
const int type = get<1>(params);
cv::Moments oclMom; std::string impl = getSelectedImpl();
WARMUP_ON;
oclMom = ocl::ocl_moments(src, binaryImage);
WARMUP_OFF;
Mat gpu_dst, cpu_dst; // creating src data
HuMoments(CvMom, cpu_dst); Mat src(srcSize, type), dst(7, 1, CV_64F);
HuMoments(oclMom, gpu_dst); const bool binaryImage = false;
cv::Moments mom;
GPU_ON; declare.in(src, WARMUP_RNG).out(dst);
ocl::ocl_moments(src, binaryImage);
GPU_OFF;
GPU_FULL_ON; // select implementation
ocl::ocl_moments(src, binaryImage); if (impl == "ocl")
GPU_FULL_OFF; {
ocl::oclMat oclSrc(src);
TestSystem::instance().ExpectedMatNear(gpu_dst, cpu_dst, .5); TEST_CYCLE() mom = cv::ocl::ocl_moments(oclSrc, binaryImage);
cv::HuMoments(mom, dst);
SANITY_CHECK(dst);
} }
else if (impl == "plain")
{
TEST_CYCLE() mom = cv::moments(src, binaryImage);
cv::HuMoments(mom, dst);
SANITY_CHECK(dst);
} }
#ifdef HAVE_OPENCV_GPU
else if (impl == "gpu")
CV_TEST_FAIL_NO_IMPL();
#endif
else
CV_TEST_FAIL_NO_IMPL();
} }
modules/ocl/perf/perf_norm.cpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_opticalflow.cpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_precomp.hpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_pyramid.cpp
View file @ 4c28a6f0
This diff is collapsed.
modules/ocl/perf/perf_split_merge.cpp
View file @ 4c28a6f0
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment