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

gpu test refactoring

Browse Source
pull/13383/head
Anatoly Baksheev 14 years ago
parent 02ced7b44c
commit 91b5c97d8d
13 changed files with 570 additions and 615 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 26
      tests/gpu/src/arithm.cpp
  2. 477
      tests/gpu/src/imgproc_gpu.cpp
  3. 105
      tests/gpu/src/meanshift.cpp
  4. 15
      tests/gpu/src/morf_filters.cpp
  5. 32
      tests/gpu/src/operator_async_call.cpp
  6. 11
      tests/gpu/src/operator_convert_to.cpp
  7. 28
      tests/gpu/src/operator_copy_to.cpp
  8. 8
      tests/gpu/src/operator_set_to.cpp
  9. 167
      tests/gpu/src/split_merge.cpp
  10. 73
      tests/gpu/src/stereo_bm.cpp
  11. 92
      tests/gpu/src/stereo_bm_async.cpp
  12. 76
      tests/gpu/src/stereo_bp.cpp
  13. 75
      tests/gpu/src/stereo_csbp.cpp

26
tests/gpu/src/arithm.cpp
Unescape View File

@ -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
{ {
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
{ {
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
{ {
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
{ {
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
{ {
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
{ {
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
{ {
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
{ {
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
{ {
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
{ {
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
} }
}; };
/////////////////////////////////////////////////////////////////////////////
/////////////////// 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

477
tests/gpu/src/imgproc_gpu.cpp
Unescape View File

@ -54,8 +54,8 @@ using namespace gpu;
class CV_GpuImageProcTest : public CvTest class CV_GpuImageProcTest : public CvTest
{ {
public: public:
CV_GpuImageProcTest(const char* test_name, const char* test_funcs); CV_GpuImageProcTest(const char* test_name, const char* test_funcs) : CvTest(test_name, test_funcs) {}
virtual ~CV_GpuImageProcTest(); virtual ~CV_GpuImageProcTest() {}
protected: protected:
void run(int); void run(int);
@ -70,11 +70,6 @@ protected:
int CheckNorm(const Mat& m1, const Mat& m2); 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) int CV_GpuImageProcTest::test8UC1(const Mat& img)
{ {
@ -188,352 +183,284 @@ void CV_GpuImageProcTest::run( int )
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// threshold // threshold
class CV_GpuNppImageThresholdTest : public CV_GpuImageProcTest struct CV_GpuNppImageThresholdTest : public CV_GpuImageProcTest
{ {
public: public:
CV_GpuNppImageThresholdTest(); CV_GpuNppImageThresholdTest() : CV_GpuImageProcTest( "GPU-NppImageThreshold", "threshold" ) {}
protected:
virtual int test(const Mat& img);
};
CV_GpuNppImageThresholdTest::CV_GpuNppImageThresholdTest(): CV_GpuImageProcTest( "GPU-NppImageThreshold", "threshold" ) int test(const Mat& img)
{
}
int CV_GpuNppImageThresholdTest::test(const Mat& img)
{
if (img.type() != CV_32FC1)
{ {
ts->printf(CvTS::LOG, "\nUnsupported type\n"); if (img.type() != CV_32FC1)
return CvTS::OK; {
} ts->printf(CvTS::LOG, "\nUnsupported type\n");
return CvTS::OK;
cv::RNG rng(*ts->get_rng()); }
const double thresh = rng;
cv::Mat cpuRes; cv::RNG rng(*ts->get_rng());
cv::threshold(img, cpuRes, thresh, 0.0, THRESH_TRUNC); const double thresh = rng;
GpuMat gpu1(img); cv::Mat cpuRes;
GpuMat gpuRes; cv::threshold(img, cpuRes, thresh, 0.0, THRESH_TRUNC);
cv::gpu::threshold(gpu1, gpuRes, thresh);
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 // resize
class CV_GpuNppImageResizeTest : public CV_GpuImageProcTest struct CV_GpuNppImageResizeTest : public CV_GpuImageProcTest
{ {
public: CV_GpuNppImageResizeTest() : CV_GpuImageProcTest( "GPU-NppImageResize", "resize" ) {}
CV_GpuNppImageResizeTest(); int test(const Mat& img)
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)
{ {
ts->printf(CvTS::LOG, "\nUnsupported type\n"); if (img.type() != CV_8UC1 && img.type() != CV_8UC4)
return CvTS::OK; {
} ts->printf(CvTS::LOG, "\nUnsupported type\n");
return CvTS::OK;
}
int interpolations[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_LANCZOS4}; int interpolations[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_LANCZOS4};
const char* interpolations_str[] = {"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_num = sizeof(interpolations) / sizeof(int);
int test_res = CvTS::OK; int test_res = CvTS::OK;
for (int i = 0; i < interpolations_num; ++i) for (int i = 0; i < interpolations_num; ++i)
{ {
ts->printf(CvTS::LOG, "\nInterpolation type: %s\n", interpolations_str[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]);
GpuMat gpu1(img), gpu_res; Mat cpu_res;
cv::gpu::resize(gpu1, gpu_res, Size(), 0.5, 0.5, interpolations[i]); cv::resize(img, cpu_res, Size(), 0.5, 0.5, interpolations[i]);
if (CheckNorm(cpu_res, gpu_res) != CvTS::OK) GpuMat gpu1(img), gpu_res;
test_res = CvTS::FAIL_GENERIC; 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 // copyMakeBorder
class CV_GpuNppImageCopyMakeBorderTest : public CV_GpuImageProcTest struct CV_GpuNppImageCopyMakeBorderTest : public CV_GpuImageProcTest
{ {
public: CV_GpuNppImageCopyMakeBorderTest() : CV_GpuImageProcTest( "GPU-NppImageCopyMakeBorder", "copyMakeBorder" ) {}
CV_GpuNppImageCopyMakeBorderTest();
protected:
virtual int test(const Mat& img);
};
CV_GpuNppImageCopyMakeBorderTest::CV_GpuNppImageCopyMakeBorderTest(): CV_GpuImageProcTest( "GPU-NppImageCopyMakeBorder", "copyMakeBorder" ) int test(const Mat& img)
{
}
int CV_GpuNppImageCopyMakeBorderTest::test(const Mat& img)
{
if (img.type() != CV_8UC1 && img.type() != CV_8UC4 && img.type() != CV_32SC1)
{ {
ts->printf(CvTS::LOG, "\nUnsupported type\n"); if (img.type() != CV_8UC1 && img.type() != CV_8UC4 && img.type() != CV_32SC1)
return CvTS::OK; {
} 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));
Mat cpudst; cv::RNG rng(*ts->get_rng());
cv::copyMakeBorder(img, cpudst, top, botton, left, right, BORDER_CONSTANT, val); 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); Mat cpudst;
GpuMat gpudst; cv::copyMakeBorder(img, cpudst, top, botton, left, right, BORDER_CONSTANT, val);
cv::gpu::copyMakeBorder(gpu1, gpudst, top, botton, left, right, 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 // warpAffine
class CV_GpuNppImageWarpAffineTest : public CV_GpuImageProcTest struct CV_GpuNppImageWarpAffineTest : public CV_GpuImageProcTest
{ {
public: CV_GpuNppImageWarpAffineTest() : CV_GpuImageProcTest( "GPU-NppImageWarpAffine", "warpAffine" ) {}
CV_GpuNppImageWarpAffineTest();
protected: int test(const Mat& img)
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)
{ {
ts->printf(CvTS::LOG, "\nUnsupported type\n"); if (img.type() == CV_32SC1)
return CvTS::OK; {
} 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}, static const double coeffs[2][3] =
{sin(3.14 / 6), cos(3.14 / 6), -100.0} {
}; {cos(3.14 / 6), -sin(3.14 / 6), 100.0},
Mat M(2, 3, CV_64F, (void*)coeffs); {sin(3.14 / 6), cos(3.14 / 6), -100.0}
};
int flags[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_NEAREST | WARP_INVERSE_MAP, INTER_LINEAR | WARP_INVERSE_MAP, INTER_CUBIC | WARP_INVERSE_MAP}; Mat M(2, 3, CV_64F, (void*)coeffs);
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);
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) int test_res = CvTS::OK;
{
ts->printf(CvTS::LOG, "\nFlags: %s\n", flags_str[i]);
Mat cpudst; for (int i = 0; i < flags_num; ++i)
cv::warpAffine(img, cpudst, M, img.size(), flags[i]); {
ts->printf(CvTS::LOG, "\nFlags: %s\n", flags_str[i]);
GpuMat gpu1(img); Mat cpudst;
GpuMat gpudst; cv::warpAffine(img, cpudst, M, img.size(), flags[i]);
cv::gpu::warpAffine(gpu1, gpudst, M, gpu1.size(), flags[i]);
if (CheckNorm(cpudst, gpudst) != CvTS::OK)
test_res = CvTS::FAIL_GENERIC;
}
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 // warpPerspective
class CV_GpuNppImageWarpPerspectiveTest : public CV_GpuImageProcTest struct CV_GpuNppImageWarpPerspectiveTest : public CV_GpuImageProcTest
{ {
public: CV_GpuNppImageWarpPerspectiveTest() : CV_GpuImageProcTest( "GPU-NppImageWarpPerspective", "warpPerspective" ) {}
CV_GpuNppImageWarpPerspectiveTest();
protected:
virtual int test(const Mat& img);
};
CV_GpuNppImageWarpPerspectiveTest::CV_GpuNppImageWarpPerspectiveTest(): CV_GpuImageProcTest( "GPU-NppImageWarpPerspective", "warpPerspective" ) int test(const Mat& img)
{
}
int CV_GpuNppImageWarpPerspectiveTest::test(const Mat& img)
{
if (img.type() == CV_32SC1)
{ {
ts->printf(CvTS::LOG, "\nUnsupported type\n"); if (img.type() == CV_32SC1)
return CvTS::OK; {
} 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}, static const double coeffs[3][3] =
{sin(3.14 / 6), cos(3.14 / 6), -100.0}, {
{0.0, 0.0, 1.0} {cos(3.14 / 6), -sin(3.14 / 6), 100.0},
}; {sin(3.14 / 6), cos(3.14 / 6), -100.0},
Mat M(3, 3, CV_64F, (void*)coeffs); {0.0, 0.0, 1.0}
};
int flags[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_NEAREST | WARP_INVERSE_MAP, INTER_LINEAR | WARP_INVERSE_MAP, INTER_CUBIC | WARP_INVERSE_MAP}; Mat M(3, 3, CV_64F, (void*)coeffs);
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);
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) int test_res = CvTS::OK;
{
ts->printf(CvTS::LOG, "\nFlags: %s\n", flags_str[i]);
Mat cpudst; for (int i = 0; i < flags_num; ++i)
cv::warpPerspective(img, cpudst, M, img.size(), flags[i]); {
ts->printf(CvTS::LOG, "\nFlags: %s\n", flags_str[i]);
GpuMat gpu1(img); Mat cpudst;
GpuMat gpudst; cv::warpPerspective(img, cpudst, M, img.size(), flags[i]);
cv::gpu::warpPerspective(gpu1, gpudst, M, gpu1.size(), flags[i]);
if (CheckNorm(cpudst, gpudst) != CvTS::OK) GpuMat gpu1(img);
test_res = CvTS::FAIL_GENERIC; 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 // integral
class CV_GpuNppImageIntegralTest : public CV_GpuImageProcTest struct CV_GpuNppImageIntegralTest : public CV_GpuImageProcTest
{
public:
CV_GpuNppImageIntegralTest();
protected:
virtual int test(const Mat& img);
};
CV_GpuNppImageIntegralTest::CV_GpuNppImageIntegralTest(): CV_GpuImageProcTest( "GPU-NppImageIntegral", "integral" )
{ {
} CV_GpuNppImageIntegralTest() : CV_GpuImageProcTest( "GPU-NppImageIntegral", "integral" ) {}
int CV_GpuNppImageIntegralTest::test(const Mat& img) int CV_GpuNppImageIntegralTest::test(const Mat& img)
{
if (img.type() != CV_8UC1)
{ {
ts->printf(CvTS::LOG, "\nUnsupported type\n"); if (img.type() != CV_8UC1)
return CvTS::OK; {
} ts->printf(CvTS::LOG, "\nUnsupported type\n");
return CvTS::OK;
Mat cpusum, cpusqsum; }
cv::integral(img, cpusum, cpusqsum, CV_32S);
GpuMat gpu1(img); Mat cpusum, cpusqsum;
GpuMat gpusum, gpusqsum; cv::integral(img, cpusum, cpusqsum, CV_32S);
cv::gpu::integral(gpu1, gpusum, gpusqsum);
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) int test_res = 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;
}
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 // blur
class CV_GpuNppImageBlurTest : public CV_GpuImageProcTest struct CV_GpuNppImageBlurTest : public CV_GpuImageProcTest
{ {
public: CV_GpuNppImageBlurTest() : CV_GpuImageProcTest( "GPU-NppImageBlur", "blur" ) {}
CV_GpuNppImageBlurTest();
protected: int test(const Mat& img)
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)
{ {
ts->printf(CvTS::LOG, "\nUnsupported type\n"); if (img.type() != CV_8UC1 && img.type() != CV_8UC4)
return CvTS::OK; {
} ts->printf(CvTS::LOG, "\nUnsupported type\n");
return CvTS::OK;
}
int ksizes[] = {3, 5, 7}; int ksizes[] = {3, 5, 7};
int ksizes_num = sizeof(ksizes) / sizeof(int); 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) for (int i = 0; i < ksizes_num; ++i)
{ {
ts->printf(CvTS::LOG, "\nksize = %d\n", ksizes[i]); ts->printf(CvTS::LOG, "\nksize = %d\n", ksizes[i]);
Mat cpudst;
cv::blur(img, cpudst, Size(ksizes[i], ksizes[i]));
GpuMat gpu1(img); Mat cpudst;
GpuMat gpudst; cv::blur(img, cpudst, Size(ksizes[i], ksizes[i]));
cv::gpu::blur(gpu1, gpudst, Size(ksizes[i], ksizes[i]));
cv::Mat c; GpuMat gpu1(img);
cv::absdiff(cpudst, gpudst, c); GpuMat gpudst;
cv::gpu::blur(gpu1, gpudst, Size(ksizes[i], ksizes[i]));
if (CheckNorm(cpudst, gpudst) != CvTS::OK) cv::Mat c;
test_res = CvTS::FAIL_GENERIC; 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 // cvtColor
class CV_GpuCvtColorTest : public CvTest class CV_GpuCvtColorTest : public CvTest
{ {
public: public:
CV_GpuCvtColorTest(); CV_GpuCvtColorTest() : CvTest("GPU-NppCvtColor", "cvtColor") {}
~CV_GpuCvtColorTest() {};
protected: protected:
void run(int); void run(int);
@ -541,9 +468,6 @@ protected:
int CheckNorm(const Mat& m1, const Mat& m2); 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) 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); 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;

105
tests/gpu/src/meanshift.cpp
Unescape View File

@ -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;

15
tests/gpu/src/morf_filters.cpp
Unescape View File

@ -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:
} }
}; };
CV_GpuDilateTest CV_GpuDilate_test;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Dilate // Dilate
class CV_GpuMorphExTest : public CV_GpuNppMorphogyTest 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;

32
tests/gpu/src/operator_async_call.cpp
Unescape View File

@ -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
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 */)
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;

11
tests/gpu/src/operator_convert_to.cpp
Unescape View File

@ -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 */)
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;

28
tests/gpu/src/operator_copy_to.cpp
Unescape View File

@ -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
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 */)
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;

8
tests/gpu/src/operator_set_to.cpp
Unescape View File

@ -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
//#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 */)
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;

167
tests/gpu/src/split_merge.cpp
Unescape View File

@ -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)
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)
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)
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)
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)
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)
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) {
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)
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;

73
tests/gpu/src/stereo_bm.cpp
Unescape View File

@ -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;

92
tests/gpu/src/stereo_bm_async.cpp
Unescape View File

@ -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;

76
tests/gpu/src/stereo_bp.cpp
Unescape View File

@ -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;

75
tests/gpu/src/stereo_csbp.cpp
Unescape View File

@ -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;

Write Preview
Loading…
Cancel
Save