From 91b5c97d8d0dd0ec281dfba5000a24cdde07bac7 Mon Sep 17 00:00:00 2001 From: Anatoly Baksheev Date: Sat, 25 Sep 2010 16:21:32 +0000 Subject: [PATCH] gpu test refactoring --- tests/gpu/src/arithm.cpp | 26 +- tests/gpu/src/imgproc_gpu.cpp | 477 +++++++++++++++------------------- tests/gpu/src/meanshift.cpp | 105 ++++---- tests/gpu/src/morf_filters.cpp | 15 +- tests/gpu/src/operator_async_call.cpp | 32 ++- tests/gpu/src/operator_convert_to.cpp | 11 +- tests/gpu/src/operator_copy_to.cpp | 28 +- tests/gpu/src/operator_set_to.cpp | 8 +- tests/gpu/src/split_merge.cpp | 167 ++++++------ tests/gpu/src/stereo_bm.cpp | 73 +++--- tests/gpu/src/stereo_bm_async.cpp | 92 ++++--- tests/gpu/src/stereo_bp.cpp | 76 +++--- tests/gpu/src/stereo_csbp.cpp | 75 +++--- 13 files changed, 570 insertions(+), 615 deletions(-) diff --git a/tests/gpu/src/arithm.cpp b/tests/gpu/src/arithm.cpp index 36e0221..366af75 100644 --- a/tests/gpu/src/arithm.cpp +++ b/tests/gpu/src/arithm.cpp @@ -240,7 +240,7 @@ struct CV_GpuNppImageMultiplyTest : public CV_GpuArithmTest { CV_GpuNppImageMultiplyTest() : CV_GpuArithmTest( "GPU-NppImageMultiply", "multiply" ) {} - int CV_GpuNppImageMultiplyTest::test( const Mat& mat1, const Mat& mat2 ) + int test( const Mat& mat1, const Mat& mat2 ) { if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1) { @@ -266,7 +266,7 @@ struct CV_GpuNppImageDivideTest : public CV_GpuArithmTest { CV_GpuNppImageDivideTest() : CV_GpuArithmTest( "GPU-NppImageDivide", "divide" ) {} - int CV_GpuNppImageDivideTest::test( const Mat& mat1, const Mat& mat2 ) + int test( const Mat& mat1, const Mat& mat2 ) { if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1) { @@ -292,7 +292,7 @@ struct CV_GpuNppImageTransposeTest : public CV_GpuArithmTest { CV_GpuNppImageTransposeTest() : CV_GpuArithmTest( "GPU-NppImageTranspose", "transpose" ) {} - int CV_GpuNppImageTransposeTest::test( const Mat& mat1, const Mat& ) + int test( const Mat& mat1, const Mat& ) { if (mat1.type() != CV_8UC1) { @@ -317,7 +317,7 @@ struct CV_GpuNppImageAbsdiffTest : public CV_GpuArithmTest { CV_GpuNppImageAbsdiffTest() : CV_GpuArithmTest( "GPU-NppImageAbsdiff", "absdiff" ) {} - int CV_GpuNppImageAbsdiffTest::test( const Mat& mat1, const Mat& mat2 ) + int test( const Mat& mat1, const Mat& mat2 ) { if (mat1.type() != CV_8UC1 && mat1.type() != CV_32FC1) { @@ -343,7 +343,7 @@ struct CV_GpuNppImageCompareTest : public CV_GpuArithmTest { CV_GpuNppImageCompareTest() : CV_GpuArithmTest( "GPU-NppImageCompare", "compare" ) {} - int CV_GpuNppImageCompareTest::test( const Mat& mat1, const Mat& mat2 ) + int test( const Mat& mat1, const Mat& mat2 ) { if (mat1.type() != CV_32FC1) { @@ -383,7 +383,7 @@ struct CV_GpuNppImageMeanStdDevTest : public CV_GpuArithmTest { CV_GpuNppImageMeanStdDevTest() : CV_GpuArithmTest( "GPU-NppImageMeanStdDev", "meanStdDev" ) {} - int CV_GpuNppImageMeanStdDevTest::test( const Mat& mat1, const Mat& ) + int test( const Mat& mat1, const Mat& ) { if (mat1.type() != CV_8UC1) { @@ -424,7 +424,7 @@ struct CV_GpuNppImageNormTest : public CV_GpuArithmTest { CV_GpuNppImageNormTest() : CV_GpuArithmTest( "GPU-NppImageNorm", "norm" ) {} - int CV_GpuNppImageNormTest::test( const Mat& mat1, const Mat& mat2 ) + int test( const Mat& mat1, const Mat& mat2 ) { if (mat1.type() != CV_8UC1) { @@ -462,7 +462,7 @@ struct CV_GpuNppImageFlipTest : public CV_GpuArithmTest { CV_GpuNppImageFlipTest() : CV_GpuArithmTest( "GPU-NppImageFlip", "flip" ) {} - int CV_GpuNppImageFlipTest::test( const Mat& mat1, const Mat& ) + int test( const Mat& mat1, const Mat& ) { if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4) { @@ -501,7 +501,7 @@ struct CV_GpuNppImageSumTest : public CV_GpuArithmTest { CV_GpuNppImageSumTest() : CV_GpuArithmTest( "GPU-NppImageSum", "sum" ) {} - int CV_GpuNppImageSumTest::test( const Mat& mat1, const Mat& ) + int test( const Mat& mat1, const Mat& ) { if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4) { @@ -524,7 +524,7 @@ struct CV_GpuNppImageMinNaxTest : public CV_GpuArithmTest { CV_GpuNppImageMinNaxTest() : CV_GpuArithmTest( "GPU-NppImageMinNax", "minNax" ) {} - int CV_GpuNppImageMinNaxTest::test( const Mat& mat1, const Mat& ) + int test( const Mat& mat1, const Mat& ) { if (mat1.type() != CV_8UC1) { @@ -549,7 +549,7 @@ struct CV_GpuNppImageLUTTest : public CV_GpuArithmTest { CV_GpuNppImageLUTTest() : CV_GpuArithmTest( "GPU-NppImageLUT", "LUT" ) {} - int CV_GpuNppImageLUTTest::test( const Mat& mat1, const Mat& ) + int test( const Mat& mat1, const Mat& ) { if (mat1.type() != CV_8UC1) { @@ -572,7 +572,9 @@ struct CV_GpuNppImageLUTTest : public CV_GpuArithmTest } }; - +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// // If we comment some tests, we may foget/miss to uncomment it after. // Placing all test definitions in one place diff --git a/tests/gpu/src/imgproc_gpu.cpp b/tests/gpu/src/imgproc_gpu.cpp index 74076cf..19e4993 100644 --- a/tests/gpu/src/imgproc_gpu.cpp +++ b/tests/gpu/src/imgproc_gpu.cpp @@ -54,8 +54,8 @@ using namespace gpu; class CV_GpuImageProcTest : public CvTest { public: - CV_GpuImageProcTest(const char* test_name, const char* test_funcs); - virtual ~CV_GpuImageProcTest(); + CV_GpuImageProcTest(const char* test_name, const char* test_funcs) : CvTest(test_name, test_funcs) {} + virtual ~CV_GpuImageProcTest() {} protected: void run(int); @@ -70,11 +70,6 @@ protected: int CheckNorm(const Mat& m1, const Mat& m2); }; -CV_GpuImageProcTest::CV_GpuImageProcTest(const char* test_name, const char* test_funcs): CvTest(test_name, test_funcs) -{ -} - -CV_GpuImageProcTest::~CV_GpuImageProcTest() {} int CV_GpuImageProcTest::test8UC1(const Mat& img) { @@ -188,352 +183,284 @@ void CV_GpuImageProcTest::run( int ) //////////////////////////////////////////////////////////////////////////////// // threshold -class CV_GpuNppImageThresholdTest : public CV_GpuImageProcTest +struct CV_GpuNppImageThresholdTest : public CV_GpuImageProcTest { public: - CV_GpuNppImageThresholdTest(); - -protected: - virtual int test(const Mat& img); -}; + CV_GpuNppImageThresholdTest() : CV_GpuImageProcTest( "GPU-NppImageThreshold", "threshold" ) {} -CV_GpuNppImageThresholdTest::CV_GpuNppImageThresholdTest(): CV_GpuImageProcTest( "GPU-NppImageThreshold", "threshold" ) -{ -} - -int CV_GpuNppImageThresholdTest::test(const Mat& img) -{ - if (img.type() != CV_32FC1) + int test(const Mat& img) { - ts->printf(CvTS::LOG, "\nUnsupported type\n"); - return CvTS::OK; - } - - cv::RNG rng(*ts->get_rng()); - const double thresh = rng; + if (img.type() != CV_32FC1) + { + ts->printf(CvTS::LOG, "\nUnsupported type\n"); + return CvTS::OK; + } - cv::Mat cpuRes; - cv::threshold(img, cpuRes, thresh, 0.0, THRESH_TRUNC); + cv::RNG rng(*ts->get_rng()); + const double thresh = rng; - GpuMat gpu1(img); - GpuMat gpuRes; - cv::gpu::threshold(gpu1, gpuRes, thresh); + cv::Mat cpuRes; + cv::threshold(img, cpuRes, thresh, 0.0, THRESH_TRUNC); - return CheckNorm(cpuRes, gpuRes); -} + GpuMat gpu1(img); + GpuMat gpuRes; + cv::gpu::threshold(gpu1, gpuRes, thresh); -CV_GpuNppImageThresholdTest CV_GpuNppImageThreshold_test; + return CheckNorm(cpuRes, gpuRes); + } +}; //////////////////////////////////////////////////////////////////////////////// // resize -class CV_GpuNppImageResizeTest : public CV_GpuImageProcTest +struct CV_GpuNppImageResizeTest : public CV_GpuImageProcTest { -public: - CV_GpuNppImageResizeTest(); - -protected: - virtual int test(const Mat& img); -}; - -CV_GpuNppImageResizeTest::CV_GpuNppImageResizeTest(): CV_GpuImageProcTest( "GPU-NppImageResize", "resize" ) -{ -} - -int CV_GpuNppImageResizeTest::test(const Mat& img) -{ - if (img.type() != CV_8UC1 && img.type() != CV_8UC4) + CV_GpuNppImageResizeTest() : CV_GpuImageProcTest( "GPU-NppImageResize", "resize" ) {} + int test(const Mat& img) { - ts->printf(CvTS::LOG, "\nUnsupported type\n"); - return CvTS::OK; - } + if (img.type() != CV_8UC1 && img.type() != CV_8UC4) + { + ts->printf(CvTS::LOG, "\nUnsupported type\n"); + return CvTS::OK; + } - int interpolations[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_LANCZOS4}; - const char* interpolations_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_LANCZOS4"}; - int interpolations_num = sizeof(interpolations) / sizeof(int); + int interpolations[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_LANCZOS4}; + const char* interpolations_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_LANCZOS4"}; + int interpolations_num = sizeof(interpolations) / sizeof(int); - int test_res = CvTS::OK; + int test_res = CvTS::OK; - for (int i = 0; i < interpolations_num; ++i) - { - ts->printf(CvTS::LOG, "\nInterpolation type: %s\n", interpolations_str[i]); - - Mat cpu_res; - cv::resize(img, cpu_res, Size(), 0.5, 0.5, interpolations[i]); + for (int i = 0; i < interpolations_num; ++i) + { + ts->printf(CvTS::LOG, "\nInterpolation type: %s\n", interpolations_str[i]); - GpuMat gpu1(img), gpu_res; - cv::gpu::resize(gpu1, gpu_res, Size(), 0.5, 0.5, interpolations[i]); + Mat cpu_res; + cv::resize(img, cpu_res, Size(), 0.5, 0.5, interpolations[i]); - if (CheckNorm(cpu_res, gpu_res) != CvTS::OK) - test_res = CvTS::FAIL_GENERIC; - } + GpuMat gpu1(img), gpu_res; + cv::gpu::resize(gpu1, gpu_res, Size(), 0.5, 0.5, interpolations[i]); - return test_res; -} + if (CheckNorm(cpu_res, gpu_res) != CvTS::OK) + test_res = CvTS::FAIL_GENERIC; + } -//CV_GpuNppImageResizeTest CV_GpuNppImageResize_test; + return test_res; + } +}; //////////////////////////////////////////////////////////////////////////////// // copyMakeBorder -class CV_GpuNppImageCopyMakeBorderTest : public CV_GpuImageProcTest +struct CV_GpuNppImageCopyMakeBorderTest : public CV_GpuImageProcTest { -public: - CV_GpuNppImageCopyMakeBorderTest(); - -protected: - virtual int test(const Mat& img); -}; + CV_GpuNppImageCopyMakeBorderTest() : CV_GpuImageProcTest( "GPU-NppImageCopyMakeBorder", "copyMakeBorder" ) {} -CV_GpuNppImageCopyMakeBorderTest::CV_GpuNppImageCopyMakeBorderTest(): CV_GpuImageProcTest( "GPU-NppImageCopyMakeBorder", "copyMakeBorder" ) -{ -} - -int CV_GpuNppImageCopyMakeBorderTest::test(const Mat& img) -{ - if (img.type() != CV_8UC1 && img.type() != CV_8UC4 && img.type() != CV_32SC1) + int test(const Mat& img) { - ts->printf(CvTS::LOG, "\nUnsupported type\n"); - return CvTS::OK; - } - - cv::RNG rng(*ts->get_rng()); - int top = rng.uniform(1, 10); - int botton = rng.uniform(1, 10); - int left = rng.uniform(1, 10); - int right = rng.uniform(1, 10); - cv::Scalar val(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)); + if (img.type() != CV_8UC1 && img.type() != CV_8UC4 && img.type() != CV_32SC1) + { + ts->printf(CvTS::LOG, "\nUnsupported type\n"); + return CvTS::OK; + } - Mat cpudst; - cv::copyMakeBorder(img, cpudst, top, botton, left, right, BORDER_CONSTANT, val); + cv::RNG rng(*ts->get_rng()); + int top = rng.uniform(1, 10); + int botton = rng.uniform(1, 10); + int left = rng.uniform(1, 10); + int right = rng.uniform(1, 10); + cv::Scalar val(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)); - GpuMat gpu1(img); - GpuMat gpudst; - cv::gpu::copyMakeBorder(gpu1, gpudst, top, botton, left, right, val); + Mat cpudst; + cv::copyMakeBorder(img, cpudst, top, botton, left, right, BORDER_CONSTANT, val); - return CheckNorm(cpudst, gpudst); -} + GpuMat gpu1(img); + GpuMat gpudst; + cv::gpu::copyMakeBorder(gpu1, gpudst, top, botton, left, right, val); -CV_GpuNppImageCopyMakeBorderTest CV_GpuNppImageCopyMakeBorder_test; + return CheckNorm(cpudst, gpudst); + } +}; //////////////////////////////////////////////////////////////////////////////// // warpAffine -class CV_GpuNppImageWarpAffineTest : public CV_GpuImageProcTest +struct CV_GpuNppImageWarpAffineTest : public CV_GpuImageProcTest { -public: - CV_GpuNppImageWarpAffineTest(); + CV_GpuNppImageWarpAffineTest() : CV_GpuImageProcTest( "GPU-NppImageWarpAffine", "warpAffine" ) {} -protected: - virtual int test(const Mat& img); -}; - -CV_GpuNppImageWarpAffineTest::CV_GpuNppImageWarpAffineTest(): CV_GpuImageProcTest( "GPU-NppImageWarpAffine", "warpAffine" ) -{ -} - -int CV_GpuNppImageWarpAffineTest::test(const Mat& img) -{ - if (img.type() == CV_32SC1) + int test(const Mat& img) { - ts->printf(CvTS::LOG, "\nUnsupported type\n"); - return CvTS::OK; - } - - static const double coeffs[2][3] = - { - {cos(3.14 / 6), -sin(3.14 / 6), 100.0}, - {sin(3.14 / 6), cos(3.14 / 6), -100.0} - }; - Mat M(2, 3, CV_64F, (void*)coeffs); - - int flags[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_NEAREST | WARP_INVERSE_MAP, INTER_LINEAR | WARP_INVERSE_MAP, INTER_CUBIC | WARP_INVERSE_MAP}; - const char* flags_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_NEAREST | WARP_INVERSE_MAP", "INTER_LINEAR | WARP_INVERSE_MAP", "INTER_CUBIC | WARP_INVERSE_MAP"}; - int flags_num = sizeof(flags) / sizeof(int); + if (img.type() == CV_32SC1) + { + ts->printf(CvTS::LOG, "\nUnsupported type\n"); + return CvTS::OK; + } + + static const double coeffs[2][3] = + { + {cos(3.14 / 6), -sin(3.14 / 6), 100.0}, + {sin(3.14 / 6), cos(3.14 / 6), -100.0} + }; + Mat M(2, 3, CV_64F, (void*)coeffs); - int test_res = CvTS::OK; + int flags[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_NEAREST | WARP_INVERSE_MAP, INTER_LINEAR | WARP_INVERSE_MAP, INTER_CUBIC | WARP_INVERSE_MAP}; + const char* flags_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_NEAREST | WARP_INVERSE_MAP", "INTER_LINEAR | WARP_INVERSE_MAP", "INTER_CUBIC | WARP_INVERSE_MAP"}; + int flags_num = sizeof(flags) / sizeof(int); - for (int i = 0; i < flags_num; ++i) - { - ts->printf(CvTS::LOG, "\nFlags: %s\n", flags_str[i]); + int test_res = CvTS::OK; - Mat cpudst; - cv::warpAffine(img, cpudst, M, img.size(), flags[i]); + for (int i = 0; i < flags_num; ++i) + { + ts->printf(CvTS::LOG, "\nFlags: %s\n", flags_str[i]); - GpuMat gpu1(img); - GpuMat gpudst; - cv::gpu::warpAffine(gpu1, gpudst, M, gpu1.size(), flags[i]); - - if (CheckNorm(cpudst, gpudst) != CvTS::OK) - test_res = CvTS::FAIL_GENERIC; - } + Mat cpudst; + cv::warpAffine(img, cpudst, M, img.size(), flags[i]); - return test_res; -} + GpuMat gpu1(img); + GpuMat gpudst; + cv::gpu::warpAffine(gpu1, gpudst, M, gpu1.size(), flags[i]); + + if (CheckNorm(cpudst, gpudst) != CvTS::OK) + test_res = CvTS::FAIL_GENERIC; + } -//CV_GpuNppImageWarpAffineTest CV_GpuNppImageWarpAffine_test; + return test_res; + } +}; //////////////////////////////////////////////////////////////////////////////// // warpPerspective -class CV_GpuNppImageWarpPerspectiveTest : public CV_GpuImageProcTest +struct CV_GpuNppImageWarpPerspectiveTest : public CV_GpuImageProcTest { -public: - CV_GpuNppImageWarpPerspectiveTest(); + CV_GpuNppImageWarpPerspectiveTest() : CV_GpuImageProcTest( "GPU-NppImageWarpPerspective", "warpPerspective" ) {} -protected: - virtual int test(const Mat& img); -}; -CV_GpuNppImageWarpPerspectiveTest::CV_GpuNppImageWarpPerspectiveTest(): CV_GpuImageProcTest( "GPU-NppImageWarpPerspective", "warpPerspective" ) -{ -} - -int CV_GpuNppImageWarpPerspectiveTest::test(const Mat& img) -{ - if (img.type() == CV_32SC1) + int test(const Mat& img) { - ts->printf(CvTS::LOG, "\nUnsupported type\n"); - return CvTS::OK; - } - - static const double coeffs[3][3] = - { - {cos(3.14 / 6), -sin(3.14 / 6), 100.0}, - {sin(3.14 / 6), cos(3.14 / 6), -100.0}, - {0.0, 0.0, 1.0} - }; - Mat M(3, 3, CV_64F, (void*)coeffs); - - int flags[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_NEAREST | WARP_INVERSE_MAP, INTER_LINEAR | WARP_INVERSE_MAP, INTER_CUBIC | WARP_INVERSE_MAP}; - const char* flags_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_NEAREST | WARP_INVERSE_MAP", "INTER_LINEAR | WARP_INVERSE_MAP", "INTER_CUBIC | WARP_INVERSE_MAP"}; - int flags_num = sizeof(flags) / sizeof(int); + if (img.type() == CV_32SC1) + { + ts->printf(CvTS::LOG, "\nUnsupported type\n"); + return CvTS::OK; + } + + static const double coeffs[3][3] = + { + {cos(3.14 / 6), -sin(3.14 / 6), 100.0}, + {sin(3.14 / 6), cos(3.14 / 6), -100.0}, + {0.0, 0.0, 1.0} + }; + Mat M(3, 3, CV_64F, (void*)coeffs); - int test_res = CvTS::OK; + int flags[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_NEAREST | WARP_INVERSE_MAP, INTER_LINEAR | WARP_INVERSE_MAP, INTER_CUBIC | WARP_INVERSE_MAP}; + const char* flags_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_NEAREST | WARP_INVERSE_MAP", "INTER_LINEAR | WARP_INVERSE_MAP", "INTER_CUBIC | WARP_INVERSE_MAP"}; + int flags_num = sizeof(flags) / sizeof(int); - for (int i = 0; i < flags_num; ++i) - { - ts->printf(CvTS::LOG, "\nFlags: %s\n", flags_str[i]); + int test_res = CvTS::OK; - Mat cpudst; - cv::warpPerspective(img, cpudst, M, img.size(), flags[i]); + for (int i = 0; i < flags_num; ++i) + { + ts->printf(CvTS::LOG, "\nFlags: %s\n", flags_str[i]); - GpuMat gpu1(img); - GpuMat gpudst; - cv::gpu::warpPerspective(gpu1, gpudst, M, gpu1.size(), flags[i]); + Mat cpudst; + cv::warpPerspective(img, cpudst, M, img.size(), flags[i]); - if (CheckNorm(cpudst, gpudst) != CvTS::OK) - test_res = CvTS::FAIL_GENERIC; - } + GpuMat gpu1(img); + GpuMat gpudst; + cv::gpu::warpPerspective(gpu1, gpudst, M, gpu1.size(), flags[i]); - return test_res; -} + if (CheckNorm(cpudst, gpudst) != CvTS::OK) + test_res = CvTS::FAIL_GENERIC; + } -//CV_GpuNppImageWarpPerspectiveTest CV_GpuNppImageWarpPerspective_test; + return test_res; + } +}; //////////////////////////////////////////////////////////////////////////////// // integral -class CV_GpuNppImageIntegralTest : public CV_GpuImageProcTest -{ -public: - CV_GpuNppImageIntegralTest(); - -protected: - virtual int test(const Mat& img); -}; - -CV_GpuNppImageIntegralTest::CV_GpuNppImageIntegralTest(): CV_GpuImageProcTest( "GPU-NppImageIntegral", "integral" ) +struct CV_GpuNppImageIntegralTest : public CV_GpuImageProcTest { -} + CV_GpuNppImageIntegralTest() : CV_GpuImageProcTest( "GPU-NppImageIntegral", "integral" ) {} -int CV_GpuNppImageIntegralTest::test(const Mat& img) -{ - if (img.type() != CV_8UC1) + int CV_GpuNppImageIntegralTest::test(const Mat& img) { - ts->printf(CvTS::LOG, "\nUnsupported type\n"); - return CvTS::OK; - } - - Mat cpusum, cpusqsum; - cv::integral(img, cpusum, cpusqsum, CV_32S); + if (img.type() != CV_8UC1) + { + ts->printf(CvTS::LOG, "\nUnsupported type\n"); + return CvTS::OK; + } - GpuMat gpu1(img); - GpuMat gpusum, gpusqsum; - cv::gpu::integral(gpu1, gpusum, gpusqsum); + Mat cpusum, cpusqsum; + cv::integral(img, cpusum, cpusqsum, CV_32S); - gpusqsum.convertTo(gpusqsum, CV_64F); + GpuMat gpu1(img); + GpuMat gpusum, gpusqsum; + cv::gpu::integral(gpu1, gpusum, gpusqsum); - int test_res = CvTS::OK; + gpusqsum.convertTo(gpusqsum, CV_64F); - if (CheckNorm(cpusum, gpusum) != CvTS::OK) - { - ts->printf(CvTS::LOG, "\nSum failed\n"); - test_res = CvTS::FAIL_GENERIC; - } - if (CheckNorm(cpusqsum, gpusqsum) != CvTS::OK) - { - ts->printf(CvTS::LOG, "\nSquared sum failed\n"); - test_res = CvTS::FAIL_GENERIC; - } + int test_res = CvTS::OK; - return test_res; -} + if (CheckNorm(cpusum, gpusum) != CvTS::OK) + { + ts->printf(CvTS::LOG, "\nSum failed\n"); + test_res = CvTS::FAIL_GENERIC; + } + if (CheckNorm(cpusqsum, gpusqsum) != CvTS::OK) + { + ts->printf(CvTS::LOG, "\nSquared sum failed\n"); + test_res = CvTS::FAIL_GENERIC; + } -CV_GpuNppImageIntegralTest CV_GpuNppImageIntegral_test; + return test_res; + } +}; //////////////////////////////////////////////////////////////////////////////// // blur -class CV_GpuNppImageBlurTest : public CV_GpuImageProcTest +struct CV_GpuNppImageBlurTest : public CV_GpuImageProcTest { -public: - CV_GpuNppImageBlurTest(); + CV_GpuNppImageBlurTest() : CV_GpuImageProcTest( "GPU-NppImageBlur", "blur" ) {} -protected: - virtual int test(const Mat& img); -}; - -CV_GpuNppImageBlurTest::CV_GpuNppImageBlurTest(): CV_GpuImageProcTest( "GPU-NppImageBlur", "blur" ) -{ -} - -int CV_GpuNppImageBlurTest::test(const Mat& img) -{ - if (img.type() != CV_8UC1 && img.type() != CV_8UC4) + int test(const Mat& img) { - ts->printf(CvTS::LOG, "\nUnsupported type\n"); - return CvTS::OK; - } + if (img.type() != CV_8UC1 && img.type() != CV_8UC4) + { + ts->printf(CvTS::LOG, "\nUnsupported type\n"); + return CvTS::OK; + } - int ksizes[] = {3, 5, 7}; - int ksizes_num = sizeof(ksizes) / sizeof(int); + int ksizes[] = {3, 5, 7}; + int ksizes_num = sizeof(ksizes) / sizeof(int); - int test_res = CvTS::OK; + int test_res = CvTS::OK; - for (int i = 0; i < ksizes_num; ++i) - { - ts->printf(CvTS::LOG, "\nksize = %d\n", ksizes[i]); - - Mat cpudst; - cv::blur(img, cpudst, Size(ksizes[i], ksizes[i])); + for (int i = 0; i < ksizes_num; ++i) + { + ts->printf(CvTS::LOG, "\nksize = %d\n", ksizes[i]); - GpuMat gpu1(img); - GpuMat gpudst; - cv::gpu::blur(gpu1, gpudst, Size(ksizes[i], ksizes[i])); + Mat cpudst; + cv::blur(img, cpudst, Size(ksizes[i], ksizes[i])); - cv::Mat c; - cv::absdiff(cpudst, gpudst, c); + GpuMat gpu1(img); + GpuMat gpudst; + cv::gpu::blur(gpu1, gpudst, Size(ksizes[i], ksizes[i])); - if (CheckNorm(cpudst, gpudst) != CvTS::OK) - test_res = CvTS::FAIL_GENERIC; - } + cv::Mat c; + cv::absdiff(cpudst, gpudst, c); - return test_res; -} + if (CheckNorm(cpudst, gpudst) != CvTS::OK) + test_res = CvTS::FAIL_GENERIC; + } -//CV_GpuNppImageBlurTest CV_GpuNppImageBlur_test; + return test_res; + } +}; //////////////////////////////////////////////////////////////////////////////// // cvtColor class CV_GpuCvtColorTest : public CvTest { public: - CV_GpuCvtColorTest(); + CV_GpuCvtColorTest() : CvTest("GPU-NppCvtColor", "cvtColor") {} + ~CV_GpuCvtColorTest() {}; protected: void run(int); @@ -541,9 +468,6 @@ protected: int CheckNorm(const Mat& m1, const Mat& m2); }; -CV_GpuCvtColorTest::CV_GpuCvtColorTest(): CvTest("GPU-NppCvtColor", "cvtColor") -{ -} int CV_GpuCvtColorTest::CheckNorm(const Mat& m1, const Mat& m2) { @@ -610,4 +534,19 @@ void CV_GpuCvtColorTest::run( int ) ts->set_failed_test_info(testResult); } -CV_GpuCvtColorTest CV_GpuCvtColor_test; +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + +// If we comment some tests, we may foget/miss to uncomment it after. +// Placing all test definitions in one place +// makes us know about what tests are commented. + +CV_GpuNppImageThresholdTest CV_GpuNppImageThreshold_test; +CV_GpuNppImageResizeTest CV_GpuNppImageResize_test; +CV_GpuNppImageCopyMakeBorderTest CV_GpuNppImageCopyMakeBorder_test; +CV_GpuNppImageWarpAffineTest CV_GpuNppImageWarpAffine_test; +CV_GpuNppImageWarpPerspectiveTest CV_GpuNppImageWarpPerspective_test; +CV_GpuNppImageIntegralTest CV_GpuNppImageIntegral_test; +CV_GpuNppImageBlurTest CV_GpuNppImageBlur_test; +CV_GpuCvtColorTest CV_GpuCvtColor_test; \ No newline at end of file diff --git a/tests/gpu/src/meanshift.cpp b/tests/gpu/src/meanshift.cpp index 224db58..06bf9f9 100644 --- a/tests/gpu/src/meanshift.cpp +++ b/tests/gpu/src/meanshift.cpp @@ -47,80 +47,79 @@ #include -class CV_GpuMeanShiftTest : public CvTest +struct CV_GpuMeanShiftTest : public CvTest { -public: - CV_GpuMeanShiftTest(); + CV_GpuMeanShiftTest(): CvTest( "GPU-MeanShift", "MeanShift" ){} -protected: - void run(int); -}; - -CV_GpuMeanShiftTest::CV_GpuMeanShiftTest(): CvTest( "GPU-MeanShift", "MeanShift" ){} - -void CV_GpuMeanShiftTest::run(int) -{ - int spatialRad = 30; - int colorRad = 30; - - cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "meanshift/cones.png"); - cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "meanshift/con_result.png"); - - if (img.empty() || img_template.empty()) + void run(int) { - ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); - return; - } + int spatialRad = 30; + int colorRad = 30; - cv::Mat rgba; - cvtColor(img, rgba, CV_BGR2BGRA); + cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "meanshift/cones.png"); + cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "meanshift/con_result.png"); - try - { - cv::gpu::GpuMat res; - cv::gpu::meanShiftFiltering( cv::gpu::GpuMat(rgba), res, spatialRad, colorRad ); - if (res.type() != CV_8UC4) + if (img.empty() || img_template.empty()) { - ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); + ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); return; } - cv::Mat result; - res.download(result); + cv::Mat rgba; + cvtColor(img, rgba, CV_BGR2BGRA); - uchar maxDiff = 0; - for (int j = 0; j < result.rows; ++j) + try { - const uchar* res_line = result.ptr(j); - const uchar* ref_line = img_template.ptr(j); + cv::gpu::GpuMat res; + cv::gpu::meanShiftFiltering( cv::gpu::GpuMat(rgba), res, spatialRad, colorRad ); + if (res.type() != CV_8UC4) + { + ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); + return; + } - for (int i = 0; i < result.cols; ++i) + cv::Mat result; + res.download(result); + + uchar maxDiff = 0; + for (int j = 0; j < result.rows; ++j) { - for (int k = 0; k < 3; ++k) + const uchar* res_line = result.ptr(j); + const uchar* ref_line = img_template.ptr(j); + + for (int i = 0; i < result.cols; ++i) { - const uchar& ch1 = res_line[result.channels()*i + k]; - const uchar& ch2 = ref_line[img_template.channels()*i + k]; - uchar diff = static_cast(abs(ch1 - ch2)); - if (maxDiff < diff) - maxDiff = diff; + for (int k = 0; k < 3; ++k) + { + const uchar& ch1 = res_line[result.channels()*i + k]; + const uchar& ch2 = ref_line[img_template.channels()*i + k]; + uchar diff = static_cast(abs(ch1 - ch2)); + if (maxDiff < diff) + maxDiff = diff; + } } } + if (maxDiff > 0) + { + ts->printf(CvTS::LOG, "\nMeanShift maxDiff = %d\n", maxDiff); + ts->set_failed_test_info(CvTS::FAIL_GENERIC); + return; + } } - if (maxDiff > 0) + catch(const cv::Exception& e) { - ts->printf(CvTS::LOG, "\nMeanShift maxDiff = %d\n", maxDiff); - ts->set_failed_test_info(CvTS::FAIL_GENERIC); + if (!check_and_treat_gpu_exception(e, ts)) + throw; return; } + + ts->set_failed_test_info(CvTS::OK); } - catch(const cv::Exception& e) - { - if (!check_and_treat_gpu_exception(e, ts)) - throw; - return; - } - ts->set_failed_test_info(CvTS::OK); -} +}; + +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// CV_GpuMeanShiftTest CV_GpuMeanShift_test; diff --git a/tests/gpu/src/morf_filters.cpp b/tests/gpu/src/morf_filters.cpp index d2d4d12..617430a 100644 --- a/tests/gpu/src/morf_filters.cpp +++ b/tests/gpu/src/morf_filters.cpp @@ -147,8 +147,6 @@ protected: } }; -CV_GpuErodeTest CV_GpuErode_test; - //////////////////////////////////////////////////////////////////////////////// // Dilate class CV_GpuDilateTest : public CV_GpuNppMorphogyTest @@ -173,8 +171,6 @@ protected: } }; -CV_GpuDilateTest CV_GpuDilate_test; - //////////////////////////////////////////////////////////////////////////////// // Dilate class CV_GpuMorphExTest : public CV_GpuNppMorphogyTest @@ -211,4 +207,13 @@ protected: } }; -CV_GpuMorphExTest CV_GpuMorphEx_test; + + + +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + +CV_GpuErodeTest CV_GpuErode_test; +CV_GpuDilateTest CV_GpuDilate_test; +CV_GpuMorphExTest CV_GpuMorphEx_test; \ No newline at end of file diff --git a/tests/gpu/src/operator_async_call.cpp b/tests/gpu/src/operator_async_call.cpp index 821e367..2a8b19a 100644 --- a/tests/gpu/src/operator_async_call.cpp +++ b/tests/gpu/src/operator_async_call.cpp @@ -58,8 +58,13 @@ using namespace gpu; class CV_GpuMatAsyncCallTest : public CvTest { public: - CV_GpuMatAsyncCallTest(); - ~CV_GpuMatAsyncCallTest(); + CV_GpuMatAsyncCallTest() : CvTest( "GPU-MatOperatorAsyncCall", "async" ) + { + rows = 234; + cols = 123; + + } + ~CV_GpuMatAsyncCallTest() {} protected: void run(int); @@ -72,21 +77,8 @@ class CV_GpuMatAsyncCallTest : public CvTest int cols; }; -CV_GpuMatAsyncCallTest::CV_GpuMatAsyncCallTest(): CvTest( "GPU-MatOperatorAsyncCall", "async" ) -{ - rows = 234; - cols = 123; - - //#define PRINT_MATRIX -} - -CV_GpuMatAsyncCallTest::~CV_GpuMatAsyncCallTest() {} - template -void CV_GpuMatAsyncCallTest::print_mat(const T & mat, const std::string & name) const -{ - cv::imshow(name, mat); -} +void CV_GpuMatAsyncCallTest::print_mat(const T & mat, const std::string & name) const { cv::imshow(name, mat); } bool CV_GpuMatAsyncCallTest::compare_matrix(cv::Mat & cpumat) { @@ -160,4 +152,10 @@ void CV_GpuMatAsyncCallTest::run( int /* start_from */) ts->set_failed_test_info(CvTS::FAIL_GENERIC); } -//CV_GpuMatAsyncCallTest CV_GpuMatAsyncCall_test; + +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + + +CV_GpuMatAsyncCallTest CV_GpuMatAsyncCall_test; diff --git a/tests/gpu/src/operator_convert_to.cpp b/tests/gpu/src/operator_convert_to.cpp index ab7b015..5b81111 100644 --- a/tests/gpu/src/operator_convert_to.cpp +++ b/tests/gpu/src/operator_convert_to.cpp @@ -55,16 +55,13 @@ using namespace gpu; class CV_GpuMatOpConvertToTest : public CvTest { public: - CV_GpuMatOpConvertToTest(); - ~CV_GpuMatOpConvertToTest(); + CV_GpuMatOpConvertToTest() : CvTest( "GPU-MatOperatorConvertTo", "convertTo" ) {} + ~CV_GpuMatOpConvertToTest() {} protected: void run(int); }; -CV_GpuMatOpConvertToTest::CV_GpuMatOpConvertToTest(): CvTest( "GPU-MatOperatorConvertTo", "convertTo" ) {} -CV_GpuMatOpConvertToTest::~CV_GpuMatOpConvertToTest() {} - void CV_GpuMatOpConvertToTest::run(int /* start_from */) { const Size img_size(67, 35); @@ -123,4 +120,8 @@ void CV_GpuMatOpConvertToTest::run(int /* start_from */) ts->set_failed_test_info(passed ? CvTS::OK : CvTS::FAIL_GENERIC); } +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + CV_GpuMatOpConvertToTest CV_GpuMatOpConvertToTest_test; diff --git a/tests/gpu/src/operator_copy_to.cpp b/tests/gpu/src/operator_copy_to.cpp index f6ecf7d..56a6f11 100644 --- a/tests/gpu/src/operator_copy_to.cpp +++ b/tests/gpu/src/operator_copy_to.cpp @@ -58,8 +58,12 @@ using namespace gpu; class CV_GpuMatOpCopyToTest : public CvTest { public: - CV_GpuMatOpCopyToTest(); - ~CV_GpuMatOpCopyToTest(); + CV_GpuMatOpCopyToTest() : CvTest( "GPU-MatOperatorCopyTo", "copyTo" ) + { + rows = 234; + cols = 123; + } + ~CV_GpuMatOpCopyToTest() {} protected: void run(int); @@ -72,21 +76,8 @@ class CV_GpuMatOpCopyToTest : public CvTest int cols; }; -CV_GpuMatOpCopyToTest::CV_GpuMatOpCopyToTest(): CvTest( "GPU-MatOperatorCopyTo", "copyTo" ) -{ - rows = 234; - cols = 123; - - //#define PRINT_MATRIX -} - -CV_GpuMatOpCopyToTest::~CV_GpuMatOpCopyToTest() {} - template -void CV_GpuMatOpCopyToTest::print_mat(const T & mat, const std::string & name) const -{ - cv::imshow(name, mat); -} +void CV_GpuMatOpCopyToTest::print_mat(const T & mat, const std::string & name) const { cv::imshow(name, mat); } bool CV_GpuMatOpCopyToTest::compare_matrix(cv::Mat & cpumat, gpu::GpuMat & gpumat) { @@ -161,4 +152,9 @@ void CV_GpuMatOpCopyToTest::run( int /* start_from */) ts->set_failed_test_info(CvTS::FAIL_GENERIC); } + +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + CV_GpuMatOpCopyToTest CV_GpuMatOpCopyTo_test; diff --git a/tests/gpu/src/operator_set_to.cpp b/tests/gpu/src/operator_set_to.cpp index c208ea9..e5d28ca 100644 --- a/tests/gpu/src/operator_set_to.cpp +++ b/tests/gpu/src/operator_set_to.cpp @@ -58,7 +58,7 @@ class CV_GpuMatOpSetToTest : public CvTest { public: CV_GpuMatOpSetToTest(); - ~CV_GpuMatOpSetToTest(); + ~CV_GpuMatOpSetToTest() {} protected: void run(int); @@ -85,7 +85,6 @@ CV_GpuMatOpSetToTest::CV_GpuMatOpSetToTest(): CvTest( "GPU-MatOperatorSetTo", "s //#define PRINT_MATRIX } -CV_GpuMatOpSetToTest::~CV_GpuMatOpSetToTest() {} void CV_GpuMatOpSetToTest::print_mat(cv::Mat & mat, std::string name ) { @@ -154,4 +153,9 @@ void CV_GpuMatOpSetToTest::run( int /* start_from */) ts->set_failed_test_info(CvTS::FAIL_GENERIC); } + +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + CV_GpuMatOpSetToTest CV_GpuMatOpSetTo_test; diff --git a/tests/gpu/src/split_merge.cpp b/tests/gpu/src/split_merge.cpp index fcbec17..e662cd9 100644 --- a/tests/gpu/src/split_merge.cpp +++ b/tests/gpu/src/split_merge.cpp @@ -9,13 +9,16 @@ using namespace std; using namespace cv; +//////////////////////////////////////////////////////////////////////////////// +// Merge + struct CV_MergeTest : public CvTest { CV_MergeTest() : CvTest("GPU-Merge", "merge") {} void can_merge(size_t rows, size_t cols); void can_merge_submatrixes(size_t rows, size_t cols); void run(int); -} merge_test; +}; void CV_MergeTest::can_merge(size_t rows, size_t cols) @@ -40,17 +43,17 @@ void CV_MergeTest::can_merge(size_t rows, size_t cols) Mat host_dst = dev_dst; - double err = norm(dst, host_dst, NORM_INF); - - if (err > 1e-3) - { - //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); - //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); - //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); - //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); - //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); - ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); - return; + double err = norm(dst, host_dst, NORM_INF); + + if (err > 1e-3) + { + //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); + //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); + //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); + //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); + //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); + ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); + return; } } } @@ -81,22 +84,21 @@ void CV_MergeTest::can_merge_submatrixes(size_t rows, size_t cols) Mat host_dst = dev_dst; - double err = norm(dst, host_dst, NORM_INF); - - if (err > 1e-3) - { - //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); - //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); - //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); - //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); - //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); - ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); - return; + double err = norm(dst, host_dst, NORM_INF); + + if (err > 1e-3) + { + //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); + //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); + //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); + //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); + //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); + ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); + return; } } } - void CV_MergeTest::run(int) { try @@ -108,22 +110,24 @@ void CV_MergeTest::run(int) can_merge_submatrixes(1, 7); can_merge_submatrixes(53, 7); } - catch(const cv::Exception& e) - { - if (!check_and_treat_gpu_exception(e, ts)) - throw; + catch(const cv::Exception& e) + { + if (!check_and_treat_gpu_exception(e, ts)) + throw; } } +//////////////////////////////////////////////////////////////////////////////// +// Split + struct CV_SplitTest : public CvTest { CV_SplitTest() : CvTest("GPU-Split", "split") {} void can_split(size_t rows, size_t cols); void can_split_submatrix(size_t rows, size_t cols); void run(int); -} split_test; - +}; void CV_SplitTest::can_split(size_t rows, size_t cols) { @@ -147,24 +151,22 @@ void CV_SplitTest::can_split(size_t rows, size_t cols) for (size_t i = 0; i < num_channels; ++i) { Mat host_dst = dev_dst[i]; - double err = norm(dst[i], host_dst, NORM_INF); - - if (err > 1e-3) - { - //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); - //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); - //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); - //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); - //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); - ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); - return; + double err = norm(dst[i], host_dst, NORM_INF); + + if (err > 1e-3) + { + //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); + //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); + //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); + //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); + //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); + ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); + return; } } } } - - void CV_SplitTest::can_split_submatrix(size_t rows, size_t cols) { for (size_t num_channels = 1; num_channels <= 4; ++num_channels) @@ -188,23 +190,22 @@ void CV_SplitTest::can_split_submatrix(size_t rows, size_t cols) for (size_t i = 0; i < num_channels; ++i) { Mat host_dst = dev_dst[i]; - double err = norm(dst[i], host_dst, NORM_INF); - - if (err > 1e-3) - { - //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); - //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); - //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); - //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); - //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); - ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); - return; + double err = norm(dst[i], host_dst, NORM_INF); + + if (err > 1e-3) + { + //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); + //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); + //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); + //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); + //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); + ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); + return; } } } } - void CV_SplitTest::run(int) { try @@ -216,21 +217,23 @@ void CV_SplitTest::run(int) can_split_submatrix(1, 7); can_split_submatrix(7, 53); } - catch(const cv::Exception& e) - { - if (!check_and_treat_gpu_exception(e, ts)) - throw; + catch(const cv::Exception& e) + { + if (!check_and_treat_gpu_exception(e, ts)) + throw; } } + +//////////////////////////////////////////////////////////////////////////////// +// Split and merge struct CV_SplitMergeTest : public CvTest { CV_SplitMergeTest() : CvTest("GPU-SplitMerge", "split merge") {} void can_split_merge(size_t rows, size_t cols); void run(int); -} split_merge_test; - +}; void CV_SplitMergeTest::can_split_merge(size_t rows, size_t cols) { for (size_t num_channels = 1; num_channels <= 4; ++num_channels) @@ -244,16 +247,16 @@ void CV_SplitMergeTest::can_split_merge(size_t rows, size_t cols) { gpu::GpuMat dev_final(rows, cols, CV_MAKETYPE(depth, num_channels)); cv::gpu::merge(dev_vec, dev_final); - double err = cv::norm((Mat)dev_orig, (Mat)dev_final, NORM_INF); - if (err > 1e-3) - { - //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); - //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); - //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); - //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); - //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); - ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); - return; + double err = cv::norm((Mat)dev_orig, (Mat)dev_final, NORM_INF); + if (err > 1e-3) + { + //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); + //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); + //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); + //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); + //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); + ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); + return; } } } @@ -267,9 +270,23 @@ void CV_SplitMergeTest::run(int) can_split_merge(1, 7); can_split_merge(7, 53); } - catch(const cv::Exception& e) - { - if (!check_and_treat_gpu_exception(e, ts)) - throw; + catch(const cv::Exception& e) + { + if (!check_and_treat_gpu_exception(e, ts)) + throw; } } + + +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + +// If we comment some tests, we may foget/miss to uncomment it after. +// Placing all test definitions in one place +// makes us know about what tests are commented. + + +CV_SplitTest split_test; +CV_MergeTest merge_test; +CV_SplitMergeTest split_merge_test; diff --git a/tests/gpu/src/stereo_bm.cpp b/tests/gpu/src/stereo_bm.cpp index 682c7d1..b9211e0 100644 --- a/tests/gpu/src/stereo_bm.cpp +++ b/tests/gpu/src/stereo_bm.cpp @@ -47,53 +47,52 @@ #include -class CV_GpuStereoBMTest : public CvTest +struct CV_GpuStereoBMTest : public CvTest { -public: - CV_GpuStereoBMTest(); + CV_GpuStereoBMTest() : CvTest( "GPU-StereoBM", "StereoBM" ){} + ~CV_GpuStereoBMTest() {} -protected: - void run(int); -}; - -CV_GpuStereoBMTest::CV_GpuStereoBMTest(): CvTest( "GPU-StereoBM", "StereoBM" ){} - -void CV_GpuStereoBMTest::run(int ) -{ - cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png", 0); - cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-R.png", 0); - cv::Mat img_reference = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-disp.png", 0); - - if (img_l.empty() || img_r.empty() || img_reference.empty()) + void run(int ) { - ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); - return; - } + cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png", 0); + cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-R.png", 0); + cv::Mat img_reference = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-disp.png", 0); - try - { - cv::gpu::GpuMat disp; - cv::gpu::StereoBM_GPU bm(0, 128, 19); - bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp); + if (img_l.empty() || img_r.empty() || img_reference.empty()) + { + ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); + return; + } + + try + { + cv::gpu::GpuMat disp; + cv::gpu::StereoBM_GPU bm(0, 128, 19); + bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp); - disp.convertTo(disp, img_reference.type()); - double norm = cv::norm(disp, img_reference, cv::NORM_INF); + disp.convertTo(disp, img_reference.type()); + double norm = cv::norm(disp, img_reference, cv::NORM_INF); - if (norm >= 100) + if (norm >= 100) + { + ts->printf(CvTS::LOG, "\nStereoBM norm = %f\n", norm); + ts->set_failed_test_info(CvTS::FAIL_GENERIC); + return; + } + } + catch(const cv::Exception& e) { - ts->printf(CvTS::LOG, "\nStereoBM norm = %f\n", norm); - ts->set_failed_test_info(CvTS::FAIL_GENERIC); + if (!check_and_treat_gpu_exception(e, ts)) + throw; return; } + + ts->set_failed_test_info(CvTS::OK); } - catch(const cv::Exception& e) - { - if (!check_and_treat_gpu_exception(e, ts)) - throw; - return; - } +}; - ts->set_failed_test_info(CvTS::OK); -} +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// CV_GpuStereoBMTest CV_GpuStereoBM_test; diff --git a/tests/gpu/src/stereo_bm_async.cpp b/tests/gpu/src/stereo_bm_async.cpp index 5d1255c..0ffc3f4 100644 --- a/tests/gpu/src/stereo_bm_async.cpp +++ b/tests/gpu/src/stereo_bm_async.cpp @@ -47,64 +47,60 @@ using namespace cv; using namespace std; -class CV_GpuMatAsyncCallStereoBMTest : public CvTest +struct CV_GpuMatAsyncCallStereoBMTest : public CvTest { public: - CV_GpuMatAsyncCallStereoBMTest(); - ~CV_GpuMatAsyncCallStereoBMTest(); + CV_GpuMatAsyncCallStereoBMTest() : CvTest( "GPU-MatAsyncCallStereoBM", "asyncStereoBM" ) {} + ~CV_GpuMatAsyncCallStereoBMTest() {} - protected: - void run(int); -}; - -CV_GpuMatAsyncCallStereoBMTest::CV_GpuMatAsyncCallStereoBMTest(): CvTest( "GPU-MatAsyncCallStereoBM", "asyncStereoBM" ) -{} - -CV_GpuMatAsyncCallStereoBMTest::~CV_GpuMatAsyncCallStereoBMTest() {} - -void CV_GpuMatAsyncCallStereoBMTest::run( int /* start_from */) -{ - cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png", 0); - cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-R.png", 0); - cv::Mat img_reference = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-disp.png", 0); - - if (img_l.empty() || img_r.empty() || img_reference.empty()) + void run( int /* start_from */) { - ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); - return; - } - - try - { - cv::gpu::GpuMat disp; - cv::gpu::StereoBM_GPU bm(0, 128, 19); - - cv::gpu::Stream stream; + cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png", 0); + cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-R.png", 0); + cv::Mat img_reference = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-disp.png", 0); - for (size_t i = 0; i < 50; i++) - { - bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp, stream); - } - - stream.waitForCompletion(); - disp.convertTo(disp, img_reference.type()); - double norm = cv::norm(disp, img_reference, cv::NORM_INF); + if (img_l.empty() || img_r.empty() || img_reference.empty()) + { + ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); + return; + } - if (norm >= 100) + try + { + cv::gpu::GpuMat disp; + cv::gpu::StereoBM_GPU bm(0, 128, 19); + + cv::gpu::Stream stream; + + for (size_t i = 0; i < 50; i++) + { + bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp, stream); + } + + stream.waitForCompletion(); + disp.convertTo(disp, img_reference.type()); + double norm = cv::norm(disp, img_reference, cv::NORM_INF); + + if (norm >= 100) + { + ts->printf(CvTS::LOG, "\nStereoBM norm = %f\n", norm); + ts->set_failed_test_info(CvTS::FAIL_GENERIC); + return; + } + } + catch(const cv::Exception& e) { - ts->printf(CvTS::LOG, "\nStereoBM norm = %f\n", norm); - ts->set_failed_test_info(CvTS::FAIL_GENERIC); + if (!check_and_treat_gpu_exception(e, ts)) + throw; return; } + + ts->set_failed_test_info(CvTS::OK); } - catch(const cv::Exception& e) - { - if (!check_and_treat_gpu_exception(e, ts)) - throw; - return; - } +}; - ts->set_failed_test_info(CvTS::OK); -} +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// CV_GpuMatAsyncCallStereoBMTest CV_GpuMatAsyncCallStereoBMTest_test; diff --git a/tests/gpu/src/stereo_bp.cpp b/tests/gpu/src/stereo_bp.cpp index a6baf90..601c78f 100644 --- a/tests/gpu/src/stereo_bp.cpp +++ b/tests/gpu/src/stereo_bp.cpp @@ -47,55 +47,55 @@ #include -class CV_GpuStereoBPTest : public CvTest +struct CV_GpuStereoBPTest : public CvTest { - public: - CV_GpuStereoBPTest(); - protected: - void run(int); -}; - -CV_GpuStereoBPTest::CV_GpuStereoBPTest(): CvTest( "GPU-StereoBP", "StereoBP" ){} - -void CV_GpuStereoBPTest::run(int ) -{ - cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png"); - cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-R.png"); - cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-disp.png", 0); - - if (img_l.empty() || img_r.empty() || img_template.empty()) + CV_GpuStereoBPTest() : CvTest( "GPU-StereoBP", "StereoBP" ){} + ~CV_GpuStereoBPTest() {} + + void run(int ) { - ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); - return; - } + cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png"); + cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-R.png"); + cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-disp.png", 0); - try - { - cv::gpu::GpuMat disp; - cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S); + if (img_l.empty() || img_r.empty() || img_template.empty()) + { + ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); + return; + } + + try + { + cv::gpu::GpuMat disp; + cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S); - bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp); + bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp); - //cv::imwrite(std::string(ts->get_data_path()) + "stereobp/aloe-disp.png", disp); + //cv::imwrite(std::string(ts->get_data_path()) + "stereobp/aloe-disp.png", disp); - disp.convertTo(disp, img_template.type()); + disp.convertTo(disp, img_template.type()); - double norm = cv::norm(disp, img_template, cv::NORM_INF); - if (norm >= 0.5) + double norm = cv::norm(disp, img_template, cv::NORM_INF); + if (norm >= 0.5) + { + ts->printf(CvTS::LOG, "\nStereoBP norm = %f\n", norm); + ts->set_failed_test_info(CvTS::FAIL_GENERIC); + return; + } + } + catch(const cv::Exception& e) { - ts->printf(CvTS::LOG, "\nStereoBP norm = %f\n", norm); - ts->set_failed_test_info(CvTS::FAIL_GENERIC); + if (!check_and_treat_gpu_exception(e, ts)) + throw; return; } + + ts->set_failed_test_info(CvTS::OK); } - catch(const cv::Exception& e) - { - if (!check_and_treat_gpu_exception(e, ts)) - throw; - return; - } +}; - ts->set_failed_test_info(CvTS::OK); -} +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// CV_GpuStereoBPTest CV_GpuStereoBP_test; diff --git a/tests/gpu/src/stereo_csbp.cpp b/tests/gpu/src/stereo_csbp.cpp index 3d80c6d..c0cacb7 100644 --- a/tests/gpu/src/stereo_csbp.cpp +++ b/tests/gpu/src/stereo_csbp.cpp @@ -46,56 +46,55 @@ #include #include - -class CV_GpuStereoCSBPTest : public CvTest -{ - public: - CV_GpuStereoCSBPTest(); - protected: - void run(int); -}; - -CV_GpuStereoCSBPTest::CV_GpuStereoCSBPTest(): CvTest( "GPU-StereoCSBP", "ConstantSpaceStereoBP" ){} - -void CV_GpuStereoCSBPTest::run(int ) +struct CV_GpuStereoCSBPTest : public CvTest { - cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-L.png"); - cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-R.png"); - cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-disp.png", 0); + CV_GpuStereoCSBPTest() : CvTest( "GPU-StereoCSBP", "ConstantSpaceStereoBP" ){} + ~CV_GpuStereoCSBPTest() {} - if (img_l.empty() || img_r.empty() || img_template.empty()) + void run(int ) { - ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); - return; - } + cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-L.png"); + cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-R.png"); + cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-disp.png", 0); - try - { - cv::gpu::GpuMat disp; - cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4); + if (img_l.empty() || img_r.empty() || img_template.empty()) + { + ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); + return; + } + + try + { + cv::gpu::GpuMat disp; + cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4); - bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp); + bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp); - //cv::imwrite(std::string(ts->get_data_path()) + "csstereobp/aloe-disp.png", disp); + //cv::imwrite(std::string(ts->get_data_path()) + "csstereobp/aloe-disp.png", disp); - disp.convertTo(disp, img_template.type()); + disp.convertTo(disp, img_template.type()); - double norm = cv::norm(disp, img_template, cv::NORM_INF); - if (norm >= 0.5) + double norm = cv::norm(disp, img_template, cv::NORM_INF); + if (norm >= 0.5) + { + ts->printf(CvTS::LOG, "\nConstantSpaceStereoBP norm = %f\n", norm); + ts->set_failed_test_info(CvTS::FAIL_GENERIC); + return; + } + } + catch(const cv::Exception& e) { - ts->printf(CvTS::LOG, "\nConstantSpaceStereoBP norm = %f\n", norm); - ts->set_failed_test_info(CvTS::FAIL_GENERIC); + if (!check_and_treat_gpu_exception(e, ts)) + throw; return; } + + ts->set_failed_test_info(CvTS::OK); } - catch(const cv::Exception& e) - { - if (!check_and_treat_gpu_exception(e, ts)) - throw; - return; - } +}; - ts->set_failed_test_info(CvTS::OK); -} +///////////////////////////////////////////////////////////////////////////// +/////////////////// tests registration ///////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// CV_GpuStereoCSBPTest CV_GpuCSStereoBP_test; -- 2.7.4