Skip to content

O
opencv
Commit 91b5c97d authored by Anatoly Baksheev's avatar Anatoly Baksheev
Browse files
Options

gpu test refactoring

parent 02ced7b4
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 363 additions and 346 deletions
tests/gpu/src/arithm.cpp
View file @ 91b5c97d
...@@ -240,7 +240,7 @@ struct CV_GpuNppImageMultiplyTest : public CV_GpuArithmTest ...@@ -240,7 +240,7 @@ struct CV_GpuNppImageMultiplyTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageMultiplyTest() : CV_GpuArithmTest( "GPU-NppImageMultiply", "multiply" ) {} 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) if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1)
{ {
...@@ -266,7 +266,7 @@ struct CV_GpuNppImageDivideTest : public CV_GpuArithmTest ...@@ -266,7 +266,7 @@ struct CV_GpuNppImageDivideTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageDivideTest() : CV_GpuArithmTest( "GPU-NppImageDivide", "divide" ) {} 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) if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1)
{ {
...@@ -292,7 +292,7 @@ struct CV_GpuNppImageTransposeTest : public CV_GpuArithmTest ...@@ -292,7 +292,7 @@ struct CV_GpuNppImageTransposeTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageTransposeTest() : CV_GpuArithmTest( "GPU-NppImageTranspose", "transpose" ) {} 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) if (mat1.type() != CV_8UC1)
{ {
...@@ -317,7 +317,7 @@ struct CV_GpuNppImageAbsdiffTest : public CV_GpuArithmTest ...@@ -317,7 +317,7 @@ struct CV_GpuNppImageAbsdiffTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageAbsdiffTest() : CV_GpuArithmTest( "GPU-NppImageAbsdiff", "absdiff" ) {} 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) if (mat1.type() != CV_8UC1 && mat1.type() != CV_32FC1)
{ {
...@@ -343,7 +343,7 @@ struct CV_GpuNppImageCompareTest : public CV_GpuArithmTest ...@@ -343,7 +343,7 @@ struct CV_GpuNppImageCompareTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageCompareTest() : CV_GpuArithmTest( "GPU-NppImageCompare", "compare" ) {} 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) if (mat1.type() != CV_32FC1)
{ {
...@@ -383,7 +383,7 @@ struct CV_GpuNppImageMeanStdDevTest : public CV_GpuArithmTest ...@@ -383,7 +383,7 @@ struct CV_GpuNppImageMeanStdDevTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageMeanStdDevTest() : CV_GpuArithmTest( "GPU-NppImageMeanStdDev", "meanStdDev" ) {} 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) if (mat1.type() != CV_8UC1)
{ {
...@@ -424,7 +424,7 @@ struct CV_GpuNppImageNormTest : public CV_GpuArithmTest ...@@ -424,7 +424,7 @@ struct CV_GpuNppImageNormTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageNormTest() : CV_GpuArithmTest( "GPU-NppImageNorm", "norm" ) {} 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) if (mat1.type() != CV_8UC1)
{ {
...@@ -462,7 +462,7 @@ struct CV_GpuNppImageFlipTest : public CV_GpuArithmTest ...@@ -462,7 +462,7 @@ struct CV_GpuNppImageFlipTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageFlipTest() : CV_GpuArithmTest( "GPU-NppImageFlip", "flip" ) {} 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) if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4)
{ {
...@@ -501,7 +501,7 @@ struct CV_GpuNppImageSumTest : public CV_GpuArithmTest ...@@ -501,7 +501,7 @@ struct CV_GpuNppImageSumTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageSumTest() : CV_GpuArithmTest( "GPU-NppImageSum", "sum" ) {} 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) if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4)
{ {
...@@ -524,7 +524,7 @@ struct CV_GpuNppImageMinNaxTest : public CV_GpuArithmTest ...@@ -524,7 +524,7 @@ struct CV_GpuNppImageMinNaxTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageMinNaxTest() : CV_GpuArithmTest( "GPU-NppImageMinNax", "minNax" ) {} 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) if (mat1.type() != CV_8UC1)
{ {
...@@ -549,7 +549,7 @@ struct CV_GpuNppImageLUTTest : public CV_GpuArithmTest ...@@ -549,7 +549,7 @@ struct CV_GpuNppImageLUTTest : public CV_GpuArithmTest
{ {
CV_GpuNppImageLUTTest() : CV_GpuArithmTest( "GPU-NppImageLUT", "LUT" ) {} 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) if (mat1.type() != CV_8UC1)
{ {
...@@ -572,7 +572,9 @@ struct CV_GpuNppImageLUTTest : public CV_GpuArithmTest ...@@ -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. // If we comment some tests, we may foget/miss to uncomment it after.
// Placing all test definitions in one place // Placing all test definitions in one place
......
tests/gpu/src/imgproc_gpu.cpp
View file @ 91b5c97d
This diff is collapsed.
tests/gpu/src/meanshift.cpp
View file @ 91b5c97d
...@@ -47,80 +47,79 @@ ...@@ -47,80 +47,79 @@
#include <string> #include <string>
class CV_GpuMeanShiftTest : public CvTest struct CV_GpuMeanShiftTest : public CvTest
{ {
public: CV_GpuMeanShiftTest(): CvTest( "GPU-MeanShift", "MeanShift" ){}
CV_GpuMeanShiftTest();
protected: void run(int)
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())
{ {
ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); int spatialRad = 30;
return; int colorRad = 30;
}
cv::Mat rgba; cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "meanshift/cones.png");
cvtColor(img, rgba, CV_BGR2BGRA); cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "meanshift/con_result.png");
try if (img.empty() || img_template.empty())
{
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); ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA);
return; return;
} }
cv::Mat result; cv::Mat rgba;
res.download(result); cvtColor(img, rgba, CV_BGR2BGRA);
uchar maxDiff = 0; try
for (int j = 0; j < result.rows; ++j)
{ {
const uchar* res_line = result.ptr<uchar>(j); cv::gpu::GpuMat res;
const uchar* ref_line = img_template.ptr<uchar>(j); 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<uchar>(j);
const uchar* ref_line = img_template.ptr<uchar>(j);
for (int i = 0; i < result.cols; ++i)
{ {
const uchar& ch1 = res_line[result.channels()*i + k]; for (int k = 0; k < 3; ++k)
const uchar& ch2 = ref_line[img_template.channels()*i + k]; {
uchar diff = static_cast<uchar>(abs(ch1 - ch2)); const uchar& ch1 = res_line[result.channels()*i + k];
if (maxDiff < diff) const uchar& ch2 = ref_line[img_template.channels()*i + k];
maxDiff = diff; uchar diff = static_cast<uchar>(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); if (!check_and_treat_gpu_exception(e, ts))
ts->set_failed_test_info(CvTS::FAIL_GENERIC); throw;
return; 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; CV_GpuMeanShiftTest CV_GpuMeanShift_test;
tests/gpu/src/morf_filters.cpp
View file @ 91b5c97d
...@@ -147,8 +147,6 @@ protected: ...@@ -147,8 +147,6 @@ protected:
} }
}; };
CV_GpuErodeTest CV_GpuErode_test;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Dilate // Dilate
class CV_GpuDilateTest : public CV_GpuNppMorphogyTest class CV_GpuDilateTest : public CV_GpuNppMorphogyTest
...@@ -173,8 +171,6 @@ protected: ...@@ -173,8 +171,6 @@ protected:
} }
}; };
CV_GpuDilateTest CV_GpuDilate_test;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Dilate // Dilate
class CV_GpuMorphExTest : public CV_GpuNppMorphogyTest class CV_GpuMorphExTest : public CV_GpuNppMorphogyTest
...@@ -211,4 +207,13 @@ protected: ...@@ -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
tests/gpu/src/operator_async_call.cpp
View file @ 91b5c97d
...@@ -58,8 +58,13 @@ using namespace gpu; ...@@ -58,8 +58,13 @@ using namespace gpu;
class CV_GpuMatAsyncCallTest : public CvTest class CV_GpuMatAsyncCallTest : public CvTest
{ {
public: public:
CV_GpuMatAsyncCallTest(); CV_GpuMatAsyncCallTest() : CvTest( "GPU-MatOperatorAsyncCall", "async" )
~CV_GpuMatAsyncCallTest(); {
rows = 234;
cols = 123;
}
~CV_GpuMatAsyncCallTest() {}
protected: protected:
void run(int); void run(int);
...@@ -72,21 +77,8 @@ class CV_GpuMatAsyncCallTest : public CvTest ...@@ -72,21 +77,8 @@ class CV_GpuMatAsyncCallTest : public CvTest
int cols; int cols;
}; };
CV_GpuMatAsyncCallTest::CV_GpuMatAsyncCallTest(): CvTest( "GPU-MatOperatorAsyncCall", "async" )
{
rows = 234;
cols = 123;
//#define PRINT_MATRIX
}
CV_GpuMatAsyncCallTest::~CV_GpuMatAsyncCallTest() {}
template<typename T> template<typename T>
void CV_GpuMatAsyncCallTest::print_mat(const T & mat, const std::string & name) const void CV_GpuMatAsyncCallTest::print_mat(const T & mat, const std::string & name) const { cv::imshow(name, mat); }
{
cv::imshow(name, mat);
}
bool CV_GpuMatAsyncCallTest::compare_matrix(cv::Mat & cpumat) bool CV_GpuMatAsyncCallTest::compare_matrix(cv::Mat & cpumat)
{ {
...@@ -160,4 +152,10 @@ void CV_GpuMatAsyncCallTest::run( int /* start_from */) ...@@ -160,4 +152,10 @@ void CV_GpuMatAsyncCallTest::run( int /* start_from */)
ts->set_failed_test_info(CvTS::FAIL_GENERIC); ts->set_failed_test_info(CvTS::FAIL_GENERIC);
} }
//CV_GpuMatAsyncCallTest CV_GpuMatAsyncCall_test;
/////////////////////////////////////////////////////////////////////////////
/////////////////// tests registration /////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
CV_GpuMatAsyncCallTest CV_GpuMatAsyncCall_test;
tests/gpu/src/operator_convert_to.cpp
View file @ 91b5c97d
...@@ -55,16 +55,13 @@ using namespace gpu; ...@@ -55,16 +55,13 @@ using namespace gpu;
class CV_GpuMatOpConvertToTest : public CvTest class CV_GpuMatOpConvertToTest : public CvTest
{ {
public: public:
CV_GpuMatOpConvertToTest(); CV_GpuMatOpConvertToTest() : CvTest( "GPU-MatOperatorConvertTo", "convertTo" ) {}
~CV_GpuMatOpConvertToTest(); ~CV_GpuMatOpConvertToTest() {}
protected: protected:
void run(int); void run(int);
}; };
CV_GpuMatOpConvertToTest::CV_GpuMatOpConvertToTest(): CvTest( "GPU-MatOperatorConvertTo", "convertTo" ) {}
CV_GpuMatOpConvertToTest::~CV_GpuMatOpConvertToTest() {}
void CV_GpuMatOpConvertToTest::run(int /* start_from */) void CV_GpuMatOpConvertToTest::run(int /* start_from */)
{ {
const Size img_size(67, 35); const Size img_size(67, 35);
...@@ -123,4 +120,8 @@ void CV_GpuMatOpConvertToTest::run(int /* start_from */) ...@@ -123,4 +120,8 @@ void CV_GpuMatOpConvertToTest::run(int /* start_from */)
ts->set_failed_test_info(passed ? CvTS::OK : CvTS::FAIL_GENERIC); ts->set_failed_test_info(passed ? CvTS::OK : CvTS::FAIL_GENERIC);
} }
/////////////////////////////////////////////////////////////////////////////
/////////////////// tests registration /////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
CV_GpuMatOpConvertToTest CV_GpuMatOpConvertToTest_test; CV_GpuMatOpConvertToTest CV_GpuMatOpConvertToTest_test;
tests/gpu/src/operator_copy_to.cpp
View file @ 91b5c97d
...@@ -58,8 +58,12 @@ using namespace gpu; ...@@ -58,8 +58,12 @@ using namespace gpu;
class CV_GpuMatOpCopyToTest : public CvTest class CV_GpuMatOpCopyToTest : public CvTest
{ {
public: public:
CV_GpuMatOpCopyToTest(); CV_GpuMatOpCopyToTest() : CvTest( "GPU-MatOperatorCopyTo", "copyTo" )
~CV_GpuMatOpCopyToTest(); {
rows = 234;
cols = 123;
}
~CV_GpuMatOpCopyToTest() {}
protected: protected:
void run(int); void run(int);
...@@ -72,21 +76,8 @@ class CV_GpuMatOpCopyToTest : public CvTest ...@@ -72,21 +76,8 @@ class CV_GpuMatOpCopyToTest : public CvTest
int cols; int cols;
}; };
CV_GpuMatOpCopyToTest::CV_GpuMatOpCopyToTest(): CvTest( "GPU-MatOperatorCopyTo", "copyTo" )
{
rows = 234;
cols = 123;
//#define PRINT_MATRIX
}
CV_GpuMatOpCopyToTest::~CV_GpuMatOpCopyToTest() {}
template<typename T> template<typename T>
void CV_GpuMatOpCopyToTest::print_mat(const T & mat, const std::string & name) const void CV_GpuMatOpCopyToTest::print_mat(const T & mat, const std::string & name) const { cv::imshow(name, mat); }
{
cv::imshow(name, mat);
}
bool CV_GpuMatOpCopyToTest::compare_matrix(cv::Mat & cpumat, gpu::GpuMat & gpumat) bool CV_GpuMatOpCopyToTest::compare_matrix(cv::Mat & cpumat, gpu::GpuMat & gpumat)
{ {
...@@ -161,4 +152,9 @@ void CV_GpuMatOpCopyToTest::run( int /* start_from */) ...@@ -161,4 +152,9 @@ void CV_GpuMatOpCopyToTest::run( int /* start_from */)
ts->set_failed_test_info(CvTS::FAIL_GENERIC); ts->set_failed_test_info(CvTS::FAIL_GENERIC);
} }
/////////////////////////////////////////////////////////////////////////////
/////////////////// tests registration /////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
CV_GpuMatOpCopyToTest CV_GpuMatOpCopyTo_test; CV_GpuMatOpCopyToTest CV_GpuMatOpCopyTo_test;
tests/gpu/src/operator_set_to.cpp
View file @ 91b5c97d
...@@ -58,7 +58,7 @@ class CV_GpuMatOpSetToTest : public CvTest ...@@ -58,7 +58,7 @@ class CV_GpuMatOpSetToTest : public CvTest
{ {
public: public:
CV_GpuMatOpSetToTest(); CV_GpuMatOpSetToTest();
~CV_GpuMatOpSetToTest(); ~CV_GpuMatOpSetToTest() {}
protected: protected:
void run(int); void run(int);
...@@ -85,7 +85,6 @@ CV_GpuMatOpSetToTest::CV_GpuMatOpSetToTest(): CvTest( "GPU-MatOperatorSetTo", "s ...@@ -85,7 +85,6 @@ CV_GpuMatOpSetToTest::CV_GpuMatOpSetToTest(): CvTest( "GPU-MatOperatorSetTo", "s
//#define PRINT_MATRIX //#define PRINT_MATRIX
} }
CV_GpuMatOpSetToTest::~CV_GpuMatOpSetToTest() {}
void CV_GpuMatOpSetToTest::print_mat(cv::Mat & mat, std::string name ) void CV_GpuMatOpSetToTest::print_mat(cv::Mat & mat, std::string name )
{ {
...@@ -154,4 +153,9 @@ void CV_GpuMatOpSetToTest::run( int /* start_from */) ...@@ -154,4 +153,9 @@ void CV_GpuMatOpSetToTest::run( int /* start_from */)
ts->set_failed_test_info(CvTS::FAIL_GENERIC); ts->set_failed_test_info(CvTS::FAIL_GENERIC);
} }
/////////////////////////////////////////////////////////////////////////////
/////////////////// tests registration /////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
CV_GpuMatOpSetToTest CV_GpuMatOpSetTo_test; CV_GpuMatOpSetToTest CV_GpuMatOpSetTo_test;
tests/gpu/src/split_merge.cpp
View file @ 91b5c97d
...@@ -9,13 +9,16 @@ ...@@ -9,13 +9,16 @@
using namespace std; using namespace std;
using namespace cv; using namespace cv;
////////////////////////////////////////////////////////////////////////////////
// Merge
struct CV_MergeTest : public CvTest struct CV_MergeTest : public CvTest
{ {
CV_MergeTest() : CvTest("GPU-Merge", "merge") {} CV_MergeTest() : CvTest("GPU-Merge", "merge") {}
void can_merge(size_t rows, size_t cols); void can_merge(size_t rows, size_t cols);
void can_merge_submatrixes(size_t rows, size_t cols); void can_merge_submatrixes(size_t rows, size_t cols);
void run(int); void run(int);
} merge_test; };
void CV_MergeTest::can_merge(size_t rows, size_t cols) 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) ...@@ -40,17 +43,17 @@ void CV_MergeTest::can_merge(size_t rows, size_t cols)
Mat host_dst = dev_dst; Mat host_dst = dev_dst;
double err = norm(dst, host_dst, NORM_INF); double err = norm(dst, host_dst, NORM_INF);
if (err > 1e-3) if (err > 1e-3)
{ {
//ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err);
//ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth);
//ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows);
//ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols);
//ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels);
ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);
return; return;
} }
} }
} }
...@@ -81,22 +84,21 @@ void CV_MergeTest::can_merge_submatrixes(size_t rows, size_t cols) ...@@ -81,22 +84,21 @@ void CV_MergeTest::can_merge_submatrixes(size_t rows, size_t cols)
Mat host_dst = dev_dst; Mat host_dst = dev_dst;
double err = norm(dst, host_dst, NORM_INF); double err = norm(dst, host_dst, NORM_INF);
if (err > 1e-3) if (err > 1e-3)
{ {
//ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err);
//ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth);
//ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows);
//ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols);
//ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels);
ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);
return; return;
} }
} }
} }
void CV_MergeTest::run(int) void CV_MergeTest::run(int)
{ {
try try
...@@ -108,22 +110,24 @@ void CV_MergeTest::run(int) ...@@ -108,22 +110,24 @@ void CV_MergeTest::run(int)
can_merge_submatrixes(1, 7); can_merge_submatrixes(1, 7);
can_merge_submatrixes(53, 7); can_merge_submatrixes(53, 7);
} }
catch(const cv::Exception& e) catch(const cv::Exception& e)
{ {
if (!check_and_treat_gpu_exception(e, ts)) if (!check_and_treat_gpu_exception(e, ts))
throw; throw;
} }
} }
////////////////////////////////////////////////////////////////////////////////
// Split
struct CV_SplitTest : public CvTest struct CV_SplitTest : public CvTest
{ {
CV_SplitTest() : CvTest("GPU-Split", "split") {} CV_SplitTest() : CvTest("GPU-Split", "split") {}
void can_split(size_t rows, size_t cols); void can_split(size_t rows, size_t cols);
void can_split_submatrix(size_t rows, size_t cols); void can_split_submatrix(size_t rows, size_t cols);
void run(int); void run(int);
} split_test; };
void CV_SplitTest::can_split(size_t rows, size_t cols) 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) ...@@ -147,24 +151,22 @@ void CV_SplitTest::can_split(size_t rows, size_t cols)
for (size_t i = 0; i < num_channels; ++i) for (size_t i = 0; i < num_channels; ++i)
{ {
Mat host_dst = dev_dst[i]; Mat host_dst = dev_dst[i];
double err = norm(dst[i], host_dst, NORM_INF); double err = norm(dst[i], host_dst, NORM_INF);
if (err > 1e-3) if (err > 1e-3)
{ {
//ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err);
//ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth);
//ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows);
//ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols);
//ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels);
ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);
return; return;
} }
} }
} }
} }
void CV_SplitTest::can_split_submatrix(size_t rows, size_t cols) void CV_SplitTest::can_split_submatrix(size_t rows, size_t cols)
{ {
for (size_t num_channels = 1; num_channels <= 4; ++num_channels) 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) ...@@ -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) for (size_t i = 0; i < num_channels; ++i)
{ {
Mat host_dst = dev_dst[i]; Mat host_dst = dev_dst[i];
double err = norm(dst[i], host_dst, NORM_INF); double err = norm(dst[i], host_dst, NORM_INF);
if (err > 1e-3) if (err > 1e-3)
{ {
//ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err);
//ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth);
//ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows);
//ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols);
//ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels);
ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);
return; return;
} }
} }
} }
} }
void CV_SplitTest::run(int) void CV_SplitTest::run(int)
{ {
try try
...@@ -216,21 +217,23 @@ void CV_SplitTest::run(int) ...@@ -216,21 +217,23 @@ void CV_SplitTest::run(int)
can_split_submatrix(1, 7); can_split_submatrix(1, 7);
can_split_submatrix(7, 53); can_split_submatrix(7, 53);
} }
catch(const cv::Exception& e) catch(const cv::Exception& e)
{ {
if (!check_and_treat_gpu_exception(e, ts)) if (!check_and_treat_gpu_exception(e, ts))
throw; throw;
} }
} }
////////////////////////////////////////////////////////////////////////////////
// Split and merge
struct CV_SplitMergeTest : public CvTest struct CV_SplitMergeTest : public CvTest
{ {
CV_SplitMergeTest() : CvTest("GPU-SplitMerge", "split merge") {} CV_SplitMergeTest() : CvTest("GPU-SplitMerge", "split merge") {}
void can_split_merge(size_t rows, size_t cols); void can_split_merge(size_t rows, size_t cols);
void run(int); void run(int);
} split_merge_test; };
void CV_SplitMergeTest::can_split_merge(size_t rows, size_t cols) { void CV_SplitMergeTest::can_split_merge(size_t rows, size_t cols) {
for (size_t num_channels = 1; num_channels <= 4; ++num_channels) 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) { ...@@ -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)); gpu::GpuMat dev_final(rows, cols, CV_MAKETYPE(depth, num_channels));
cv::gpu::merge(dev_vec, dev_final); cv::gpu::merge(dev_vec, dev_final);
double err = cv::norm((Mat)dev_orig, (Mat)dev_final, NORM_INF); double err = cv::norm((Mat)dev_orig, (Mat)dev_final, NORM_INF);
if (err > 1e-3) if (err > 1e-3)
{ {
//ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err); //ts->printf(CvTS::CONSOLE, "\nNorm: %f\n", err);
//ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth); //ts->printf(CvTS::CONSOLE, "Depth: %d\n", depth);
//ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows); //ts->printf(CvTS::CONSOLE, "Rows: %d\n", rows);
//ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols); //ts->printf(CvTS::CONSOLE, "Cols: %d\n", cols);
//ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels); //ts->printf(CvTS::CONSOLE, "NumChannels: %d\n", num_channels);
ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT); ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);
return; return;
} }
} }
} }
...@@ -267,9 +270,23 @@ void CV_SplitMergeTest::run(int) ...@@ -267,9 +270,23 @@ void CV_SplitMergeTest::run(int)
can_split_merge(1, 7); can_split_merge(1, 7);
can_split_merge(7, 53); can_split_merge(7, 53);
} }
catch(const cv::Exception& e) catch(const cv::Exception& e)
{ {
if (!check_and_treat_gpu_exception(e, ts)) if (!check_and_treat_gpu_exception(e, ts))
throw; 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;
tests/gpu/src/stereo_bm.cpp
View file @ 91b5c97d
...@@ -47,53 +47,52 @@ ...@@ -47,53 +47,52 @@
#include <string> #include <string>
class CV_GpuStereoBMTest : public CvTest struct CV_GpuStereoBMTest : public CvTest
{ {
public: CV_GpuStereoBMTest() : CvTest( "GPU-StereoBM", "StereoBM" ){}
CV_GpuStereoBMTest(); ~CV_GpuStereoBMTest() {}
protected: void run(int )
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())
{ {
ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png", 0);
return; 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 if (img_l.empty() || img_r.empty() || img_reference.empty())
{ {
cv::gpu::GpuMat disp; ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA);
cv::gpu::StereoBM_GPU bm(0, 128, 19); return;
bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp); }
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()); disp.convertTo(disp, img_reference.type());
double norm = cv::norm(disp, img_reference, cv::NORM_INF); 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); if (!check_and_treat_gpu_exception(e, ts))
ts->set_failed_test_info(CvTS::FAIL_GENERIC); throw;
return; 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; CV_GpuStereoBMTest CV_GpuStereoBM_test;
tests/gpu/src/stereo_bm_async.cpp
View file @ 91b5c97d
...@@ -47,64 +47,60 @@ ...@@ -47,64 +47,60 @@
using namespace cv; using namespace cv;
using namespace std; using namespace std;
class CV_GpuMatAsyncCallStereoBMTest : public CvTest struct CV_GpuMatAsyncCallStereoBMTest : public CvTest
{ {
public: public:
CV_GpuMatAsyncCallStereoBMTest(); CV_GpuMatAsyncCallStereoBMTest() : CvTest( "GPU-MatAsyncCallStereoBM", "asyncStereoBM" ) {}
~CV_GpuMatAsyncCallStereoBMTest(); ~CV_GpuMatAsyncCallStereoBMTest() {}
protected: void run( int /* start_from */)
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())
{ {
ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png", 0);
return; 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);
cv::gpu::Stream stream;
for (size_t i = 0; i < 50; i++) if (img_l.empty() || img_r.empty() || img_reference.empty())
{ {
bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp, stream); ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA);
} return;
}
stream.waitForCompletion();
disp.convertTo(disp, img_reference.type());
double norm = cv::norm(disp, img_reference, cv::NORM_INF);
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); if (!check_and_treat_gpu_exception(e, ts))
ts->set_failed_test_info(CvTS::FAIL_GENERIC); throw;
return; 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; CV_GpuMatAsyncCallStereoBMTest CV_GpuMatAsyncCallStereoBMTest_test;
tests/gpu/src/stereo_bp.cpp
View file @ 91b5c97d
...@@ -47,55 +47,55 @@ ...@@ -47,55 +47,55 @@
#include <string> #include <string>
class CV_GpuStereoBPTest : public CvTest struct CV_GpuStereoBPTest : public CvTest
{ {
public: CV_GpuStereoBPTest() : CvTest( "GPU-StereoBP", "StereoBP" ){}
CV_GpuStereoBPTest(); ~CV_GpuStereoBPTest() {}
protected:
void run(int); 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())
{ {
ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png");
return; 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 if (img_l.empty() || img_r.empty() || img_template.empty())
{ {
cv::gpu::GpuMat disp; ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA);
cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S); 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); double norm = cv::norm(disp, img_template, cv::NORM_INF);
if (norm >= 0.5) 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); if (!check_and_treat_gpu_exception(e, ts))
ts->set_failed_test_info(CvTS::FAIL_GENERIC); throw;
return; 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; CV_GpuStereoBPTest CV_GpuStereoBP_test;
tests/gpu/src/stereo_csbp.cpp
View file @ 91b5c97d
...@@ -46,56 +46,55 @@ ...@@ -46,56 +46,55 @@
#include <iostream> #include <iostream>
#include <string> #include <string>
struct CV_GpuStereoCSBPTest : public CvTest
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 )
{ {
cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-L.png"); CV_GpuStereoCSBPTest() : CvTest( "GPU-StereoCSBP", "ConstantSpaceStereoBP" ){}
cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-R.png"); ~CV_GpuStereoCSBPTest() {}
cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-disp.png", 0);
if (img_l.empty() || img_r.empty() || img_template.empty()) void run(int )
{ {
ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA); cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-L.png");
return; 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 if (img_l.empty() || img_r.empty() || img_template.empty())
{ {
cv::gpu::GpuMat disp; ts->set_failed_test_info(CvTS::FAIL_MISSING_TEST_DATA);
cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4); 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); double norm = cv::norm(disp, img_template, cv::NORM_INF);
if (norm >= 0.5) 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); if (!check_and_treat_gpu_exception(e, ts))
ts->set_failed_test_info(CvTS::FAIL_GENERIC); throw;
return; 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; CV_GpuStereoCSBPTest CV_GpuCSStereoBP_test;
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