generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

call resetDevice if gpu test fails

Browse Source
This commit is contained in:
Vladislav Vinogradov 2012-12-18 16:59:00 +04:00
parent 0973e86d8a
commit ab25fe9e37
36 changed files with 9551 additions and 5795 deletions

48
modules/gpu/app/nv_perf_test/main.cpp

@ -91,6 +91,8 @@ PERF_TEST_P(Image, HoughLinesP,
cv::Mat image = cv::imread(fileName, cv::IMREAD_GRAYSCALE);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_image(image);
cv::gpu::GpuMat d_lines;
@ -103,6 +105,12 @@ PERF_TEST_P(Image, HoughLinesP,
cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat mask;
@ -154,6 +162,8 @@ PERF_TEST_P(Image_Depth, GoodFeaturesToTrack,
mask(cv::Rect(0, 0, 100, 100)).setTo(cv::Scalar::all(0));
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
@ -168,6 +178,12 @@ PERF_TEST_P(Image_Depth, GoodFeaturesToTrack,
d_detector(d_src, d_pts, d_mask);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
if (depth != CV_8U)
@ -243,6 +259,8 @@ PERF_TEST_P(ImagePair_Depth_GraySource, OpticalFlowPyrLKSparse,
}
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src1(src1);
cv::gpu::GpuMat d_src2(src2);
@ -263,6 +281,12 @@ PERF_TEST_P(ImagePair_Depth_GraySource, OpticalFlowPyrLKSparse,
d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
if (depth != CV_8U)
@ -321,6 +345,8 @@ PERF_TEST_P(ImagePair_Depth, OpticalFlowFarneback,
}
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src1(src1);
cv::gpu::GpuMat d_src2(src2);
@ -343,6 +369,12 @@ PERF_TEST_P(ImagePair_Depth, OpticalFlowFarneback,
d_farneback(d_src1, d_src2, d_u, d_v);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
if (depth != CV_8U)
@ -408,6 +440,8 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, OpticalFlowBM,
FAIL() << "Unable to load source image [" << fileNames.second << "]";
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src1(src1);
cv::gpu::GpuMat d_src2(src2);
@ -420,6 +454,12 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, OpticalFlowBM,
cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat velx, vely;
@ -459,6 +499,8 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, FastOpticalFlowBM,
FAIL() << "Unable to load source image [" << fileNames.second << "]";
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src1(src1);
cv::gpu::GpuMat d_src2(src2);
@ -473,6 +515,12 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, FastOpticalFlowBM,
fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat velx, vely;

72
modules/gpu/perf/perf_calib3d.cpp

@ -25,6 +25,8 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(pair_string("gpu/perf/aloe.png",
const int ndisp = 256;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
@ -41,6 +43,12 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(pair_string("gpu/perf/aloe.png",
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::StereoBM bm(preset, ndisp);
@ -74,6 +82,8 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(pair_string("gpu/
const int ndisp = 64;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::StereoBeliefPropagation d_bp(ndisp);
@ -90,6 +100,12 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(pair_string("gpu/
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy.";
@ -112,6 +128,8 @@ PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(pair_string("gpu/st
const int ndisp = 128;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
@ -128,6 +146,12 @@ PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(pair_string("gpu/st
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy.";
@ -148,6 +172,8 @@ PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(pair_string("gpu
const int ndisp = 128;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::DisparityBilateralFilter d_filter(ndisp);
@ -164,6 +190,12 @@ PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(pair_string("gpu
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy.";
@ -186,6 +218,8 @@ PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
const cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -199,6 +233,12 @@ PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy.";
@ -220,6 +260,8 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
const cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -233,6 +275,12 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -282,6 +330,8 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
cv::Mat tvec;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
@ -290,6 +340,12 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
@ -319,6 +375,8 @@ PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES,
fillRandom(Q, 0.1, 1.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -332,6 +390,12 @@ PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES,
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -359,6 +423,8 @@ PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Valu
fillRandom(src, 0, 255);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -372,6 +438,12 @@ PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Valu
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy.";

463
modules/gpu/perf/perf_core.cpp

File diff suppressed because it is too large Load Diff

32
modules/gpu/perf/perf_denoising.cpp

@ -31,6 +31,8 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -44,6 +46,12 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -86,6 +94,8 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans,
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -99,6 +109,12 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans,
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -129,6 +145,8 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans,
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -143,6 +161,12 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans,
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -180,6 +204,8 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -194,6 +220,12 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;

48
modules/gpu/perf/perf_features2d.cpp

@ -18,6 +18,8 @@ PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.png"))
ASSERT_FALSE(img.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::SURF_GPU d_surf;
@ -34,6 +36,12 @@ PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.png"))
GPU_SANITY_CHECK(d_descriptors, 1e-4);
GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::SURF surf;
@ -63,6 +71,8 @@ PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.png"))
ASSERT_FALSE(img.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::FAST_GPU d_fast(20);
@ -78,6 +88,12 @@ PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.png"))
GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
std::vector<cv::KeyPoint> keypoints;
@ -103,6 +119,8 @@ PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.png"))
ASSERT_FALSE(img.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::ORB_GPU d_orb(4000);
@ -119,6 +137,12 @@ PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.png"))
GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
GPU_SANITY_CHECK(d_descriptors);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::ORB orb(4000);
@ -160,6 +184,8 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val
fillRandom(train);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::BFMatcher_GPU d_matcher(normType);
@ -177,6 +203,12 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val
GPU_SANITY_CHECK(d_trainIdx);
GPU_SANITY_CHECK(d_distance);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::BFMatcher matcher(normType);
@ -219,6 +251,8 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
fillRandom(train);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::BFMatcher_GPU d_matcher(normType);
@ -236,6 +270,12 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
GPU_SANITY_CHECK(d_trainIdx);
GPU_SANITY_CHECK(d_distance);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::BFMatcher matcher(normType);
@ -272,6 +312,8 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256
fillRandom(train, 0.0, 1.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::BFMatcher_GPU d_matcher(normType);
@ -289,6 +331,12 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256
GPU_SANITY_CHECK(d_trainIdx);
GPU_SANITY_CHECK(d_distance);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::BFMatcher matcher(normType);

72
modules/gpu/perf/perf_filters.cpp

@ -22,6 +22,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Value
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -35,6 +37,12 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Value
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -65,6 +73,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Valu
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -79,6 +89,12 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Valu
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -108,6 +124,8 @@ PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -122,6 +140,12 @@ PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -152,6 +176,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZE
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -166,6 +192,12 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZE
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -196,6 +228,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES,
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -209,6 +243,12 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES,
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -240,6 +280,8 @@ PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -254,6 +296,12 @@ PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -285,6 +333,8 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -299,6 +349,12 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -336,6 +392,8 @@ PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Val
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -351,6 +409,12 @@ PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Val
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -384,6 +448,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, V
fillRandom(kernel, 0.0, 1.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -397,6 +463,12 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, V
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;

337
modules/gpu/perf/perf_imgproc.cpp

@ -79,6 +79,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
generateMap(xmap, ymap, remapMode);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_xmap(xmap);
@ -94,6 +96,12 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -133,6 +141,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -146,6 +156,12 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -184,6 +200,8 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -197,6 +215,12 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -241,6 +265,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
cv::Mat M(2, 3, CV_64F, (void*) mat);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -254,6 +280,12 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -297,6 +329,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
cv::Mat M(3, 3, CV_64F, (void*) mat);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -310,6 +344,12 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -345,6 +385,8 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -358,6 +400,12 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -392,6 +440,8 @@ PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -405,6 +455,12 @@ PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -429,6 +485,8 @@ PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -443,6 +501,12 @@ PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -467,6 +531,8 @@ PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -480,6 +546,12 @@ PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -498,6 +570,8 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_hist;
@ -512,6 +586,12 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(
GPU_SANITY_CHECK(d_hist);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
int hbins = 30;
@ -547,6 +627,8 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(
int upperLevel[] = {180, 180, 180, 180};
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_hist[4];
@ -561,6 +643,12 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(
GPU_SANITY_CHECK(d_hist0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -578,6 +666,8 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_hist;
@ -591,6 +681,12 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_hist);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -608,6 +704,8 @@ PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -623,6 +721,12 @@ PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_hist);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -647,6 +751,8 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -660,6 +766,12 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -684,6 +796,8 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(
ASSERT_FALSE(image.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_image(image);
cv::gpu::GpuMat d_dst;
@ -698,6 +812,12 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -727,6 +847,8 @@ PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/con
cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(rgba);
cv::gpu::GpuMat d_dst;
@ -740,6 +862,12 @@ PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/con
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -767,6 +895,8 @@ PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.pn
cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(rgba);
cv::gpu::GpuMat d_dstr;
@ -781,6 +911,12 @@ PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.pn
GPU_SANITY_CHECK(d_dstr);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -803,6 +939,8 @@ PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/
cv::Mat dst;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(rgba);
@ -815,6 +953,12 @@ PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/
GPU_SANITY_CHECK(dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -839,6 +983,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Val
fillRandom(img2);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_img1(img1);
cv::gpu::GpuMat d_img2(img2);
@ -855,6 +1001,12 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Val
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -881,6 +1033,8 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES,
templ.setTo(1.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
d_image.upload(image);
@ -900,6 +1054,12 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES,
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
ASSERT_FALSE(ccorr);
@ -943,6 +1103,8 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(
fillRandom(templ);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_image(image);
cv::gpu::GpuMat d_templ(templ);
@ -957,6 +1119,12 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -993,6 +1161,8 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(
fillRandom(templ);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_image(image);
cv::gpu::GpuMat d_templ(templ);
@ -1007,6 +1177,12 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -1043,6 +1219,8 @@ PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(
fillRandom(b, 0, 100);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_a(a);
cv::gpu::GpuMat d_b(b);
@ -1057,6 +1235,12 @@ PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -1088,6 +1272,8 @@ PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)
fillRandom(src2, 0, 100);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src1(src1);
cv::gpu::GpuMat d_src2(src2);
@ -1102,6 +1288,12 @@ PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -1124,6 +1316,8 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
fillRandom(src, 0, 100);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -1137,6 +1331,12 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -1177,6 +1377,8 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
double k = 0.5;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_img(img);
cv::gpu::GpuMat d_dst;
@ -1193,6 +1395,12 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -1230,6 +1438,8 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Com
img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_img(img);
cv::gpu::GpuMat d_dst;
@ -1246,6 +1456,12 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Com
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -1273,6 +1489,8 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)
cv::Mat T = cv::Mat::zeros(1, 3, CV_32F);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_map_x;
cv::gpu::GpuMat d_map_y;
@ -1287,6 +1505,12 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_map_x);
GPU_SANITY_CHECK(d_map_y);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -1304,6 +1528,8 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)
cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_map_x;
cv::gpu::GpuMat d_map_y;
@ -1318,6 +1544,12 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_map_x);
GPU_SANITY_CHECK(d_map_y);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -1335,6 +1567,8 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)
cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_map_x;
cv::gpu::GpuMat d_map_y;
@ -1348,7 +1582,12 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_map_x);
GPU_SANITY_CHECK(d_map_y);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
@ -1378,6 +1617,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -1391,6 +1632,12 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -1415,6 +1662,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -1428,6 +1677,12 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -1461,6 +1716,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -1474,6 +1731,12 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -1532,6 +1795,8 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -1545,6 +1810,12 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -1573,6 +1844,8 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)
const int dstOrder[] = {2, 1, 0, 3};
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
@ -1585,6 +1858,12 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)
GPU_SANITY_CHECK(d_src);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -1612,6 +1891,8 @@ PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values
fillRandom(img2);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_img1(img1);
cv::gpu::GpuMat d_img2(img2);
@ -1626,6 +1907,12 @@ PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -1647,6 +1934,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZE
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
@ -1661,6 +1950,12 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZE
GPU_SANITY_CHECK(d_src);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -1684,6 +1979,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
cv::Size dstSize(size.width / 2 + 10, size.height / 2 + 10);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -1699,6 +1996,12 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -1761,6 +2064,8 @@ PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
}
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_lines;
@ -1779,6 +2084,12 @@ PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
std::sort(begin, end, Vec2fComparator());
SANITY_CHECK(h_lines);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
std::vector<cv::Vec2f> lines;
@ -1817,6 +2128,8 @@ PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "s
cv::Canny(image, mask, 50, 100);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_mask(mask);
cv::gpu::GpuMat d_lines;
@ -1835,6 +2148,12 @@ PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "s
std::sort(begin, end, Vec4iComparator());
SANITY_CHECK(h_lines);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
std::vector<cv::Vec4i> lines;
@ -1882,6 +2201,8 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES,
}
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_circles;
@ -1900,6 +2221,12 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES,
std::sort(begin, end, Vec3fComparator());
SANITY_CHECK(h_circles);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
std::vector<cv::Vec3f> circles;
@ -1966,6 +2293,8 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, Combine(
cv::Sobel(image, dy, CV_32F, 0, 1);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_edges(edges);
cv::gpu::GpuMat d_dx(dx);
@ -1990,6 +2319,12 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, Combine(
GPU_SANITY_CHECK(d_position);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat positions;

8
modules/gpu/perf/perf_labeling.cpp

@ -107,6 +107,8 @@ PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/al
cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat mask;
mask.create(image.rows, image.cols, CV_8UC1);
@ -125,6 +127,12 @@ PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/al
GPU_SANITY_CHECK(components);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
GreedyLabeling host(image);

32
modules/gpu/perf/perf_matop.cpp

@ -19,6 +19,8 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
cv::Scalar val(1, 2, 3, 4);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(size, type);
@ -31,6 +33,12 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
GPU_SANITY_CHECK(d_src);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat src(size, type);
@ -66,6 +74,8 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value
cv::Scalar val(1, 2, 3, 4);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_mask(mask);
@ -79,6 +89,12 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value
GPU_SANITY_CHECK(d_src);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
src.setTo(val, mask);
@ -110,6 +126,8 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu
fillRandom(mask, 0, 2);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_mask(mask);
@ -124,6 +142,12 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;
@ -154,6 +178,8 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
fillRandom(src);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_src(src);
cv::gpu::GpuMat d_dst;
@ -167,6 +193,12 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
GPU_SANITY_CHECK(d_dst);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat dst;

32
modules/gpu/perf/perf_objdetect.cpp

@ -18,6 +18,8 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
std::vector<cv::Rect> found_locations;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_img(img);
@ -31,6 +33,12 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
d_hog.detectMultiScale(d_img, found_locations);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::HOGDescriptor hog;
@ -60,6 +68,8 @@ PERF_TEST_P(HOG, CalTech, Values<string>("gpu/caltech/image_00000009_0.png", "gp
std::vector<cv::Rect> found_locations;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_img(img);
@ -73,6 +83,12 @@ PERF_TEST_P(HOG, CalTech, Values<string>("gpu/caltech/image_00000009_0.png", "gp
d_hog.detectMultiScale(d_img, found_locations);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::HOGDescriptor hog;
@ -102,6 +118,8 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
ASSERT_FALSE(img.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::CascadeClassifier_GPU d_cascade;
ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
@ -118,6 +136,12 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
GPU_SANITY_CHECK(d_objects_buffer);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::CascadeClassifier cascade;
@ -146,6 +170,8 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
ASSERT_FALSE(img.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::CascadeClassifier_GPU d_cascade;
ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
@ -162,6 +188,12 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
GPU_SANITY_CHECK(d_gpu_rects);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::CascadeClassifier cascade;

40
modules/gpu/perf/perf_softcascade.cpp

@ -59,6 +59,8 @@ GPU_PERF_TEST_P(SCascadeTest, detect,
{ }
RUN_GPU(SCascadeTest, detect)
{
try
{
cv::Mat cpu = readImage (GET_PARAM(1));
ASSERT_FALSE(cpu.empty());
@ -83,6 +85,12 @@ RUN_GPU(SCascadeTest, detect)
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTest, detect)
@ -117,6 +125,8 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectInRoi,
{}
RUN_GPU(SCascadeTestRoi, detectInRoi)
{
try
{
cv::Mat cpu = readImage (GET_PARAM(1));
ASSERT_FALSE(cpu.empty());
@ -150,6 +160,12 @@ RUN_GPU(SCascadeTestRoi, detectInRoi)
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTestRoi, detectInRoi)
@ -162,6 +178,8 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectEachRoi,
{}
RUN_GPU(SCascadeTestRoi, detectEachRoi)
{
try
{
cv::Mat cpu = readImage (GET_PARAM(1));
ASSERT_FALSE(cpu.empty());
@ -191,6 +209,12 @@ RUN_GPU(SCascadeTestRoi, detectEachRoi)
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTestRoi, detectEachRoi)
@ -208,6 +232,8 @@ GPU_PERF_TEST_P(SCascadeTest, detectOnIntegral,
}
RUN_GPU(SCascadeTest, detectOnIntegral)
{
try
{
cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
ASSERT_TRUE(fsi.isOpened());
@ -240,6 +266,12 @@ RUN_GPU(SCascadeTest, detectOnIntegral)
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTest, detectOnIntegral)
@ -250,6 +282,8 @@ GPU_PERF_TEST_P(SCascadeTest, detectStream,
{ }
RUN_GPU(SCascadeTest, detectStream)
{
try
{
cv::Mat cpu = readImage (GET_PARAM(1));
ASSERT_FALSE(cpu.empty());
@ -280,5 +314,11 @@ RUN_GPU(SCascadeTest, detectStream)
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTest, detectStream)

144
modules/gpu/perf/perf_video.cpp

@ -35,6 +35,8 @@ PERF_TEST_P(ImagePair, Video_BroxOpticalFlow,
frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
@ -54,6 +56,12 @@ PERF_TEST_P(ImagePair, Video_BroxOpticalFlow,
GPU_SANITY_CHECK(d_u);
GPU_SANITY_CHECK(d_v);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -76,6 +84,8 @@ PERF_TEST_P(ImagePair, Video_InterpolateFrames,
frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
@ -103,6 +113,12 @@ PERF_TEST_P(ImagePair, Video_InterpolateFrames,
GPU_SANITY_CHECK(d_bu);
GPU_SANITY_CHECK(d_bv);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -125,6 +141,8 @@ PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap,
frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
@ -148,6 +166,12 @@ PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap,
GPU_SANITY_CHECK(d_vertex);
GPU_SANITY_CHECK(d_colors);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -169,6 +193,8 @@ PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack,
ASSERT_FALSE(image.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
@ -184,6 +210,12 @@ PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack,
GPU_SANITY_CHECK(d_pts);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat pts;
@ -237,6 +269,8 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse
cv::goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
@ -259,6 +293,12 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse
GPU_SANITY_CHECK(d_status);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat nextPts;
@ -304,6 +344,8 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(
ASSERT_FALSE(frame1.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
@ -325,6 +367,12 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(
GPU_SANITY_CHECK(d_u);
GPU_SANITY_CHECK(d_v);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -354,6 +402,8 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow,
int flags = 0;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
@ -379,6 +429,12 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow,
GPU_SANITY_CHECK(d_u);
GPU_SANITY_CHECK(d_v);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat flow;
@ -409,6 +465,8 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowDual_TVL1,
ASSERT_FALSE(frame1.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
@ -427,6 +485,12 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowDual_TVL1,
GPU_SANITY_CHECK(d_flowx);
GPU_SANITY_CHECK(d_flowy);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat flow;
@ -481,6 +545,8 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowBM,
cv::Size max_range(16, 16);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
@ -496,6 +562,12 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowBM,
GPU_SANITY_CHECK(d_velx);
GPU_SANITY_CHECK(d_vely);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat velx, vely;
@ -528,6 +600,8 @@ PERF_TEST_P(ImagePair, Video_FastOpticalFlowBM,
cv::Size max_range(16, 16);
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
@ -545,6 +619,12 @@ PERF_TEST_P(ImagePair, Video_FastOpticalFlowBM,
GPU_SANITY_CHECK(d_velx);
GPU_SANITY_CHECK(d_vely);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat velx, vely;
@ -580,6 +660,8 @@ PERF_TEST_P(Video, DISABLED_Video_FGDStatModel, Values("gpu/video/768x576.avi",
ASSERT_FALSE(frame.empty());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame(frame);
@ -598,6 +680,12 @@ PERF_TEST_P(Video, DISABLED_Video_FGDStatModel, Values("gpu/video/768x576.avi",
stopTimer();
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
IplImage ipl_frame = frame;
@ -648,6 +736,8 @@ PERF_TEST_P(Video_Cn_LearningRate, DISABLED_Video_MOG,
}
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame(frame);
cv::gpu::MOG_GPU d_mog;
@ -677,6 +767,12 @@ PERF_TEST_P(Video_Cn_LearningRate, DISABLED_Video_MOG,
stopTimer();
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::BackgroundSubtractorMOG mog;
@ -736,6 +832,8 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_MOG2,
}
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame(frame);
cv::gpu::MOG2_GPU d_mog2;
@ -765,6 +863,12 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_MOG2,
stopTimer();
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::BackgroundSubtractorMOG2 mog2;
@ -809,6 +913,8 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage,
cv::Mat frame;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame;
cv::gpu::MOG2_GPU d_mog2;
@ -844,6 +950,12 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage,
GPU_SANITY_CHECK(d_background);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::BackgroundSubtractorMOG2 mog2;
@ -906,6 +1018,8 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_VIBE,
}
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame(frame);
cv::gpu::VIBE_GPU d_vibe;
@ -935,6 +1049,12 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_VIBE,
stopTimer();
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
FAIL() << "No such CPU implementation analogy";
@ -971,6 +1091,8 @@ PERF_TEST_P(Video_Cn_MaxFeatures, DISABLED_Video_GMG,
}
if (PERF_RUN_GPU())
{
try
{
cv::gpu::GpuMat d_frame(frame);
cv::gpu::GpuMat d_fgmask;
@ -1007,6 +1129,12 @@ PERF_TEST_P(Video_Cn_MaxFeatures, DISABLED_Video_GMG,
stopTimer();
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::Mat fgmask;
@ -1065,6 +1193,8 @@ PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video
cv::Mat frame;
if (PERF_RUN_GPU())
{
try
{
cv::gpu::VideoWriter_GPU d_writer;
@ -1085,6 +1215,12 @@ PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video
stopTimer();
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::VideoWriter writer;
@ -1114,6 +1250,8 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
string inputFile = perf::TestBase::getDataPath(GetParam());
if (PERF_RUN_GPU())
{
try
{
cv::gpu::VideoReader_GPU d_reader(inputFile);
ASSERT_TRUE( d_reader.isOpened() );
@ -1129,6 +1267,12 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
GPU_SANITY_CHECK(d_frame);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
else
{
cv::VideoCapture reader(inputFile);

4
modules/gpu/test/nvidia/main_nvidia.cpp

@ -276,6 +276,8 @@ static void devNullOutput(const std::string& msg)
(void)msg;
}
}
bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
{
path = test_data_path.c_str();
@ -292,8 +294,6 @@ bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel
return testListerII.invoke();
}
}
bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
{
path = test_data_path;

56
modules/gpu/test/test_calib3d.cpp

@ -61,6 +61,8 @@ struct StereoBM : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(StereoBM, Regression)
{
try
{
cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
@ -77,6 +79,12 @@ TEST_P(StereoBM, Regression)
EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBM, ALL_DEVICES);
@ -96,6 +104,8 @@ struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(StereoBeliefPropagation, Regression)
{
try
{
cv::Mat left_image = readImage("stereobp/aloe-L.png");
cv::Mat right_image = readImage("stereobp/aloe-R.png");
@ -115,6 +125,12 @@ TEST_P(StereoBeliefPropagation, Regression)
EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBeliefPropagation, ALL_DEVICES);
@ -134,6 +150,8 @@ struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(StereoConstantSpaceBP, Regression)
{
try
{
cv::Mat left_image = readImage("csstereobp/aloe-L.png");
cv::Mat right_image = readImage("csstereobp/aloe-R.png");
@ -159,6 +177,12 @@ TEST_P(StereoConstantSpaceBP, Regression)
EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
@ -178,6 +202,8 @@ struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(TransformPoints, Accuracy)
{
try
{
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@ -207,6 +233,12 @@ TEST_P(TransformPoints, Accuracy)
ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, TransformPoints, ALL_DEVICES);
@ -226,6 +258,8 @@ struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(ProjectPoints, Accuracy)
{
try
{
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@ -257,6 +291,12 @@ TEST_P(ProjectPoints, Accuracy)
ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ProjectPoints, ALL_DEVICES);
@ -276,6 +316,8 @@ struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(SolvePnPRansac, Accuracy)
{
try
{
cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
@ -300,6 +342,12 @@ TEST_P(SolvePnPRansac, Accuracy)
ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3);
ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, SolvePnPRansac, ALL_DEVICES);
@ -325,6 +373,8 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use
};
TEST_P(ReprojectImageTo3D, Accuracy)
{
try
{
cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
@ -337,6 +387,12 @@ TEST_P(ReprojectImageTo3D, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(
ALL_DEVICES,

830
modules/gpu/test/test_color.cpp

File diff suppressed because it is too large Load Diff

8
modules/gpu/test/test_copy_make_border.cpp

@ -70,6 +70,8 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border,
};
TEST_P(CopyMakeBorder, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Scalar val = randomScalar(0, 255);
@ -82,6 +84,12 @@ TEST_P(CopyMakeBorder, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
ALL_DEVICES,

608
modules/gpu/test/test_core.cpp

File diff suppressed because it is too large Load Diff

27
modules/gpu/test/test_denoising.cpp

@ -70,6 +70,8 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType)
};
TEST_P(BilateralFilter, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
@ -83,6 +85,12 @@ TEST_P(BilateralFilter, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Denoising, BilateralFilter, testing::Combine(
ALL_DEVICES,
@ -106,6 +114,8 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(BruteForceNonLocalMeans, Regression)
{
try
{
using cv::gpu::GpuMat;
@ -131,11 +141,15 @@ TEST_P(BruteForceNonLocalMeans, Regression)
EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES);
////////////////////////////////////////////////////////
// Fast Force Non local means
@ -151,6 +165,8 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(FastNonLocalMeans, Regression)
{
try
{
using cv::gpu::GpuMat;
@ -178,8 +194,13 @@ TEST_P(FastNonLocalMeans, Regression)
EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
EXPECT_MAT_NEAR(gray_gold, dgray, 1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES);
#endif // HAVE_CUDA

184
modules/gpu/test/test_features2d.cpp

@ -179,6 +179,8 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves,
};
TEST_P(SURF, Detector)
{
try
{
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
@ -191,20 +193,6 @@ TEST_P(SURF, Detector)
surf.upright = upright;
surf.keypointsRatio = 0.05f;
if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
{
try
{
std::vector<cv::KeyPoint> keypoints;
surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
else
{
std::vector<cv::KeyPoint> keypoints;
surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
@ -224,9 +212,16 @@ TEST_P(SURF, Detector)
EXPECT_GT(matchedRatio, 0.95);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(SURF, Detector_Masked)
{
try
{
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
@ -242,20 +237,6 @@ TEST_P(SURF, Detector_Masked)
surf.upright = upright;
surf.keypointsRatio = 0.05f;
if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
{
try
{
std::vector<cv::KeyPoint> keypoints;
surf(loadMat(image), loadMat(mask), keypoints);
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
else
{
std::vector<cv::KeyPoint> keypoints;
surf(loadMat(image), loadMat(mask), keypoints);
@ -275,9 +256,16 @@ TEST_P(SURF, Detector_Masked)
EXPECT_GT(matchedRatio, 0.95);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(SURF, Descriptor)
{
try
{
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
@ -297,21 +285,6 @@ TEST_P(SURF, Descriptor)
surf_gold.extended = extended;
surf_gold.upright = upright;
if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
{
try
{
std::vector<cv::KeyPoint> keypoints;
cv::gpu::GpuMat descriptors;
surf(loadMat(image), cv::gpu::GpuMat(), keypoints, descriptors);
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
else
{
std::vector<cv::KeyPoint> keypoints;
surf_gold(image, cv::noArray(), keypoints);
@ -330,6 +303,11 @@ TEST_P(SURF, Descriptor)
EXPECT_GT(matchedRatio, 0.6);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
@ -363,6 +341,8 @@ PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression
};
TEST_P(FAST, Accuracy)
{
try
{
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
@ -370,20 +350,6 @@ TEST_P(FAST, Accuracy)
cv::gpu::FAST_GPU fast(threshold);
fast.nonmaxSupression = nonmaxSupression;
if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
{
try
{
std::vector<cv::KeyPoint> keypoints;
fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
else
{
std::vector<cv::KeyPoint> keypoints;
fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
@ -392,6 +358,11 @@ TEST_P(FAST, Accuracy)
ASSERT_KEYPOINTS_EQ(keypoints_gold, keypoints);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
@ -444,6 +415,8 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR
};
TEST_P(ORB, Accuracy)
{
try
{
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
@ -454,21 +427,6 @@ TEST_P(ORB, Accuracy)
cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
orb.blurForDescriptor = blurForDescriptor;
if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
{
try
{
std::vector<cv::KeyPoint> keypoints;
cv::gpu::GpuMat descriptors;
orb(loadMat(image), loadMat(mask), keypoints, descriptors);
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
else
{
std::vector<cv::KeyPoint> keypoints;
cv::gpu::GpuMat descriptors;
orb(loadMat(image), loadMat(mask), keypoints, descriptors);
@ -488,6 +446,11 @@ TEST_P(ORB, Accuracy)
EXPECT_GT(matchedRatio, 0.35);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB, testing::Combine(
@ -569,6 +532,8 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize
};
TEST_P(BruteForceMatcher, Match_Single)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -594,8 +559,16 @@ TEST_P(BruteForceMatcher, Match_Single)
ASSERT_EQ(0, badCount);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(BruteForceMatcher, Match_Collection)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -648,8 +621,16 @@ TEST_P(BruteForceMatcher, Match_Collection)
ASSERT_EQ(0, badCount);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(BruteForceMatcher, KnnMatch_2_Single)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -687,8 +668,16 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Single)
ASSERT_EQ(0, badCount);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(BruteForceMatcher, KnnMatch_3_Single)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -726,8 +715,16 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Single)
ASSERT_EQ(0, badCount);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -788,8 +785,16 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
ASSERT_EQ(0, badCount);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -850,8 +855,16 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
ASSERT_EQ(0, badCount);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(BruteForceMatcher, RadiusMatch_Single)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -899,8 +912,16 @@ TEST_P(BruteForceMatcher, RadiusMatch_Single)
ASSERT_EQ(0, badCount);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(BruteForceMatcher, RadiusMatch_Collection)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -922,20 +943,6 @@ TEST_P(BruteForceMatcher, RadiusMatch_Collection)
masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
}
if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
{
try
{
std::vector< std::vector<cv::DMatch> > matches;
matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks);
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
else
{
std::vector< std::vector<cv::DMatch> > matches;
if (useMask)
@ -977,6 +984,11 @@ TEST_P(BruteForceMatcher, RadiusMatch_Collection)
ASSERT_EQ(0, badCount);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(

72
modules/gpu/test/test_filters.cpp

@ -87,6 +87,8 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use
};
TEST_P(Blur, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
@ -98,6 +100,12 @@ TEST_P(Blur, Accuracy)
EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
ALL_DEVICES,
@ -150,6 +158,8 @@ TEST_P(Sobel, Accuracy)
if (dx == 0 && dy == 0)
return;
try
{
cv::Mat src = randomMat(size, type);
cv::gpu::GpuMat dst = createMat(size, type, useRoi);
@ -160,6 +170,12 @@ TEST_P(Sobel, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
ALL_DEVICES,
@ -213,6 +229,8 @@ TEST_P(Scharr, Accuracy)
if (dx + dy != 1)
return;
try
{
cv::Mat src = randomMat(size, type);
cv::gpu::GpuMat dst = createMat(size, type, useRoi);
@ -223,6 +241,12 @@ TEST_P(Scharr, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
ALL_DEVICES,
@ -269,6 +293,8 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels,
};
TEST_P(GaussianBlur, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
double sigma1 = randomDouble(0.1, 1.0);
@ -297,6 +323,12 @@ TEST_P(GaussianBlur, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, GaussianBlur, testing::Combine(
ALL_DEVICES,
@ -348,6 +380,8 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi
};
TEST_P(Laplacian, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
@ -359,6 +393,12 @@ TEST_P(Laplacian, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine(
ALL_DEVICES,
@ -395,6 +435,8 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration
};
TEST_P(Erode, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
@ -409,6 +451,12 @@ TEST_P(Erode, Accuracy)
EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Erode, testing::Combine(
ALL_DEVICES,
@ -444,6 +492,8 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio
};
TEST_P(Dilate, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
@ -458,6 +508,12 @@ TEST_P(Dilate, Accuracy)
EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Dilate, testing::Combine(
ALL_DEVICES,
@ -498,6 +554,8 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor
};
TEST_P(MorphEx, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
@ -512,6 +570,12 @@ TEST_P(MorphEx, Accuracy)
EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, MorphEx, testing::Combine(
ALL_DEVICES,
@ -552,6 +616,8 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor,
};
TEST_P(Filter2D, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
@ -564,6 +630,12 @@ TEST_P(Filter2D, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
ALL_DEVICES,

8
modules/gpu/test/test_global_motion.cpp

@ -52,6 +52,8 @@ struct CompactPoints : testing::TestWithParam<gpu::DeviceInfo>
};
TEST_P(CompactPoints, CanCompactizeSmallInput)
{
try
{
Mat src0(1, 3, CV_32FC2);
src0.at<Point2f>(0,0) = Point2f(0,0);
@ -83,6 +85,12 @@ TEST_P(CompactPoints, CanCompactizeSmallInput)
ASSERT_TRUE(src1.at<Point2f>(0,0) == Point2f(1,0));
ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_GlobalMotion, CompactPoints, ALL_DEVICES);

72
modules/gpu/test/test_gpumat.cpp

@ -68,6 +68,8 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
};
TEST_P(SetTo, Zero)
{
try
{
cv::Scalar zero = cv::Scalar::all(0);
@ -76,8 +78,16 @@ TEST_P(SetTo, Zero)
EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(SetTo, SameVal)
{
try
{
cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
@ -101,8 +111,16 @@ TEST_P(SetTo, SameVal)
EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(SetTo, DifferentVal)
{
try
{
cv::Scalar val = randomScalar(0.0, 255.0);
@ -126,8 +144,16 @@ TEST_P(SetTo, DifferentVal)
EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(SetTo, Masked)
{
try
{
cv::Scalar val = randomScalar(0.0, 255.0);
cv::Mat mat_gold = randomMat(size, type);
@ -155,6 +181,12 @@ TEST_P(SetTo, Masked)
EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, SetTo, testing::Combine(
ALL_DEVICES,
@ -185,6 +217,8 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
};
TEST_P(CopyTo, WithOutMask)
{
try
{
cv::Mat src = randomMat(size, type);
@ -194,8 +228,16 @@ TEST_P(CopyTo, WithOutMask)
EXPECT_MAT_NEAR(src, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(CopyTo, Masked)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
@ -225,6 +267,12 @@ TEST_P(CopyTo, Masked)
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, CopyTo, testing::Combine(
ALL_DEVICES,
@ -256,6 +304,8 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us
};
TEST_P(ConvertTo, WithOutScaling)
{
try
{
cv::Mat src = randomMat(size, depth1);
@ -284,8 +334,16 @@ TEST_P(ConvertTo, WithOutScaling)
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(ConvertTo, WithScaling)
{
try
{
cv::Mat src = randomMat(size, depth1);
double a = randomDouble(0.0, 1.0);
@ -316,6 +374,12 @@ TEST_P(ConvertTo, WithScaling)
EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, ConvertTo, testing::Combine(
ALL_DEVICES,
@ -337,6 +401,8 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(EnsureSizeIsEnough, BufferReuse)
{
try
{
cv::gpu::GpuMat buffer(100, 100, CV_8U);
cv::gpu::GpuMat old = buffer;
@ -355,6 +421,12 @@ TEST_P(EnsureSizeIsEnough, BufferReuse)
EXPECT_EQ(CV_8UC1, buffer.type());
EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);

24
modules/gpu/test/test_hough.cpp

@ -80,6 +80,8 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi)
};
TEST_P(HoughLines, Accuracy)
{
try
{
const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID());
@ -104,6 +106,12 @@ TEST_P(HoughLines, Accuracy)
ASSERT_MAT_NEAR(src, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughLines, testing::Combine(
ALL_DEVICES,
@ -125,6 +133,8 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi)
};
TEST_P(HoughCircles, Accuracy)
{
try
{
const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID());
@ -175,6 +185,12 @@ TEST_P(HoughCircles, Accuracy)
ASSERT_TRUE(found);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughCircles, testing::Combine(
ALL_DEVICES,
@ -189,6 +205,8 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi)
};
TEST_P(GeneralizedHough, POSITION)
{
try
{
const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID());
@ -246,6 +264,12 @@ TEST_P(GeneralizedHough, POSITION)
ASSERT_TRUE(found);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, GeneralizedHough, testing::Combine(
ALL_DEVICES,

184
modules/gpu/test/test_imgproc.cpp

@ -65,6 +65,8 @@ PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
};
TEST_P(Integral, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_8UC1);
@ -76,6 +78,12 @@ TEST_P(Integral, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine(
ALL_DEVICES,
@ -98,6 +106,8 @@ struct HistEven : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(HistEven, Accuracy)
{
try
{
cv::Mat img = readImage("stereobm/aloe-L.png");
ASSERT_FALSE(img.empty());
@ -126,6 +136,12 @@ TEST_P(HistEven, Accuracy)
EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);
@ -163,6 +179,8 @@ PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size)
};
TEST_P(CalcHist, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_8UC1);
@ -174,6 +192,12 @@ TEST_P(CalcHist, Accuracy)
EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine(
ALL_DEVICES,
@ -197,6 +221,8 @@ PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
};
TEST_P(EqualizeHist, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_8UC1);
@ -208,6 +234,12 @@ TEST_P(EqualizeHist, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine(
ALL_DEVICES,
@ -231,6 +263,8 @@ PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
};
TEST_P(ColumnSum, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_32FC1);
@ -256,6 +290,12 @@ TEST_P(ColumnSum, Accuracy)
}
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ColumnSum, testing::Combine(
ALL_DEVICES,
@ -286,6 +326,8 @@ PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi)
};
TEST_P(Canny, Accuracy)
{
try
{
cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(img.empty());
@ -316,6 +358,12 @@ TEST_P(Canny, Accuracy)
EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine(
ALL_DEVICES,
@ -350,6 +398,8 @@ struct MeanShift : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(MeanShift, Filtering)
{
try
{
cv::Mat img_template;
if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
@ -370,8 +420,16 @@ TEST_P(MeanShift, Filtering)
EXPECT_MAT_NEAR(img_template, result, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(MeanShift, Proc)
{
try
{
cv::FileStorage fs;
if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
@ -396,6 +454,12 @@ TEST_P(MeanShift, Proc)
EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShift, ALL_DEVICES);
@ -419,6 +483,8 @@ PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize)
};
TEST_P(MeanShiftSegmentation, Regression)
{
try
{
cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
ASSERT_FALSE(img.empty());
@ -440,6 +506,12 @@ TEST_P(MeanShiftSegmentation, Regression)
EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(
ALL_DEVICES,
@ -491,6 +563,8 @@ PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
};
TEST_P(Blend, Accuracy)
{
try
{
int depth = CV_MAT_DEPTH(type);
@ -510,6 +584,12 @@ TEST_P(Blend, Accuracy)
EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(
ALL_DEVICES,
@ -581,6 +661,8 @@ PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
};
TEST_P(Convolve, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
@ -593,6 +675,12 @@ TEST_P(Convolve, Accuracy)
EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
ALL_DEVICES,
@ -629,6 +717,8 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Ch
};
TEST_P(MatchTemplate8U, Accuracy)
{
try
{
cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
@ -641,6 +731,12 @@ TEST_P(MatchTemplate8U, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, testing::Combine(
ALL_DEVICES,
@ -675,6 +771,8 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, C
};
TEST_P(MatchTemplate32F, Regression)
{
try
{
cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
@ -687,6 +785,12 @@ TEST_P(MatchTemplate32F, Regression)
EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate32F, testing::Combine(
ALL_DEVICES,
@ -713,6 +817,8 @@ PARAM_TEST_CASE(MatchTemplateBlackSource, cv::gpu::DeviceInfo, TemplateMethod)
};
TEST_P(MatchTemplateBlackSource, Accuracy)
{
try
{
cv::Mat image = readImage("matchtemplate/black.png");
ASSERT_FALSE(image.empty());
@ -733,6 +839,12 @@ TEST_P(MatchTemplateBlackSource, Accuracy)
ASSERT_EQ(maxLocGold, maxLoc);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine(
ALL_DEVICES,
@ -758,6 +870,8 @@ PARAM_TEST_CASE(MatchTemplate_CCOEF_NORMED, cv::gpu::DeviceInfo, std::pair<std::
};
TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
{
try
{
cv::Mat image = readImage(imageName);
ASSERT_FALSE(image.empty());
@ -786,6 +900,12 @@ TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
ASSERT_LE(maxVal, 1.0);
ASSERT_GE(minVal, -1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CCOEF_NORMED, testing::Combine(
ALL_DEVICES,
@ -807,6 +927,8 @@ struct MatchTemplate_CanFindBigTemplate : testing::TestWithParam<cv::gpu::Device
};
TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
{
try
{
cv::Mat scene = readImage("matchtemplate/scene.png");
ASSERT_FALSE(scene.empty());
@ -828,8 +950,16 @@ TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
ASSERT_EQ(344, minLoc.x);
ASSERT_EQ(0, minLoc.y);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
{
try
{
cv::Mat scene = readImage("matchtemplate/scene.png");
ASSERT_FALSE(scene.empty());
@ -850,6 +980,12 @@ TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
ASSERT_EQ(344, minLoc.x);
ASSERT_EQ(0, minLoc.y);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CanFindBigTemplate, ALL_DEVICES);
@ -880,6 +1016,8 @@ PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
};
TEST_P(MulSpectrums, Simple)
{
try
{
cv::gpu::GpuMat c;
cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
@ -889,8 +1027,16 @@ TEST_P(MulSpectrums, Simple)
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(MulSpectrums, Scaled)
{
try
{
float scale = 1.f / size.area();
@ -903,6 +1049,12 @@ TEST_P(MulSpectrums, Scaled)
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MulSpectrums, testing::Combine(
ALL_DEVICES,
@ -949,6 +1101,8 @@ void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplac
}
TEST_P(Dft, C2C)
{
try
{
int cols = randomInt(2, 100);
int rows = randomInt(2, 100);
@ -972,6 +1126,12 @@ TEST_P(Dft, C2C)
testC2C("size 2 1", 2, 1, 0, inplace);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
{
@ -1010,6 +1170,8 @@ void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
}
TEST_P(Dft, R2CThenC2R)
{
try
{
int cols = randomInt(2, 100);
int rows = randomInt(2, 100);
@ -1030,6 +1192,12 @@ TEST_P(Dft, R2CThenC2R)
testR2CThenC2R("single row", cols, 1, true);
testR2CThenC2R("single row 1", cols + 1, 1, true);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Dft, ALL_DEVICES);
@ -1060,6 +1228,8 @@ PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, BlockSiz
};
TEST_P(CornerHarris, Accuracy)
{
try
{
cv::Mat src = readImageType("stereobm/aloe-L.png", type);
ASSERT_FALSE(src.empty());
@ -1074,6 +1244,12 @@ TEST_P(CornerHarris, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(
ALL_DEVICES,
@ -1106,6 +1282,8 @@ PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, BorderType, BlockS
};
TEST_P(CornerMinEigen, Accuracy)
{
try
{
cv::Mat src = readImageType("stereobm/aloe-L.png", type);
ASSERT_FALSE(src.empty());
@ -1118,6 +1296,12 @@ TEST_P(CornerMinEigen, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(
ALL_DEVICES,

8
modules/gpu/test/test_labeling.cpp

@ -167,6 +167,8 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(Labeling, ConnectedComponents)
{
try
{
cv::Mat image;
cvtColor(loat_image(), image, CV_BGR2GRAY);
@ -190,6 +192,12 @@ TEST_P(Labeling, ConnectedComponents)
host.checkCorrectness(cv::Mat(components));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(ConnectedComponents, Labeling, ALL_DEVICES);

99
modules/gpu/test/test_nvidia.cpp

@ -69,83 +69,170 @@ struct NVidiaTest : TestWithParam<cv::gpu::DeviceInfo>
struct NPPST : NVidiaTest {};
struct NCV : NVidiaTest {};
//TEST_P(NPPST, Integral)
//{
// bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
TEST_P(NPPST, Integral)
{
try
{
bool res = nvidia_NPPST_Integral_Image(_path, nvidiaTestOutputLevel);
// ASSERT_TRUE(res);
//}
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NPPST, SquaredIntegral)
{
try
{
bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NPPST, RectStdDev)
{
try
{
bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NPPST, Resize)
{
try
{
bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NPPST, VectorOperations)
{
try
{
bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NPPST, Transpose)
{
try
{
bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NCV, VectorOperations)
{
try
{
bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NCV, HaarCascadeLoader)
{
try
{
bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NCV, HaarCascadeApplication)
{
try
{
bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NCV, HypothesesFiltration)
{
try
{
bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(NCV, Visualization)
{
// this functionality doesn't used in gpu module
try
{
bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_NVidia, NPPST, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(GPU_NVidia, NCV, ALL_DEVICES);

43
modules/gpu/test/test_objdetect.cpp

@ -175,8 +175,9 @@ struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
}
};
// desabled while resize does not fixed
TEST_P(HOG, DISABLED_Detect)
TEST_P(HOG, Detect)
{
try
{
cv::Mat img_rgb = readImage("hog/road.png");
ASSERT_FALSE(img_rgb.empty());
@ -200,8 +201,16 @@ TEST_P(HOG, DISABLED_Detect)
f.close();
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(HOG, GetDescriptors)
{
try
{
// Load image (e.g. train data, composed from windows)
cv::Mat img_rgb = readImage("hog/train_data.png");
@ -284,6 +293,12 @@ TEST_P(HOG, GetDescriptors)
computeBlockHistograms(cv::gpu::GpuMat(img));
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
@ -304,6 +319,8 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::Device
};
TEST_P(CalTech, HOG)
{
try
{
cv::gpu::GpuMat d_img(img);
cv::Mat markedImage(img.clone());
@ -327,6 +344,12 @@ TEST_P(CalTech, HOG)
cv::imshow("Res", markedImage); cv::waitKey();
#endif
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(detect, CalTech, testing::Combine(ALL_DEVICES,
::testing::Values<std::string>("caltech/image_00000009_0.png", "caltech/image_00000032_0.png",
@ -351,11 +374,19 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::gpu::DeviceInfo, int)
};
TEST_P(LBP_Read_classifier, Accuracy)
{
try
{
cv::gpu::CascadeClassifier_GPU classifier;
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
ASSERT_TRUE(classifier.load(classifierXmlPath));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_Read_classifier,
testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
@ -373,6 +404,8 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int)
};
TEST_P(LBP_classify, Accuracy)
{
try
{
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
@ -418,6 +451,12 @@ TEST_P(LBP_classify, Accuracy)
#endif
(void)count;
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
testing::Combine(ALL_DEVICES, testing::Values<int>(0)));

240
modules/gpu/test/test_opengl.cpp

@ -69,6 +69,8 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
};
TEST_P(GlBuffer, Constructor1)
{
try
{
cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
@ -76,8 +78,16 @@ TEST_P(GlBuffer, Constructor1)
EXPECT_EQ(size.width, buf.cols());
EXPECT_EQ(type, buf.type());
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, Constructor2)
{
try
{
cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
@ -85,8 +95,16 @@ TEST_P(GlBuffer, Constructor2)
EXPECT_EQ(size.width, buf.cols());
EXPECT_EQ(type, buf.type());
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, ConstructorFromMat)
{
try
{
cv::Mat gold = randomMat(size, type);
@ -97,8 +115,16 @@ TEST_P(GlBuffer, ConstructorFromMat)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, ConstructorFromGpuMat)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::gpu::GpuMat d_gold(gold);
@ -110,8 +136,16 @@ TEST_P(GlBuffer, ConstructorFromGpuMat)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, ConstructorFromGlBuffer)
{
try
{
cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
@ -122,8 +156,16 @@ TEST_P(GlBuffer, ConstructorFromGlBuffer)
EXPECT_EQ(buf_gold.cols(), buf.cols());
EXPECT_EQ(buf_gold.type(), buf.type());
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, ConstructorFromGlTexture2D)
{
try
{
const int depth = CV_MAT_DEPTH(type);
const int cn = CV_MAT_CN(type);
@ -141,8 +183,16 @@ TEST_P(GlBuffer, ConstructorFromGlTexture2D)
EXPECT_MAT_NEAR(gold, bufData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, Create)
{
try
{
cv::GlBuffer buf;
buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
@ -151,8 +201,16 @@ TEST_P(GlBuffer, Create)
EXPECT_EQ(size.width, buf.cols());
EXPECT_EQ(type, buf.type());
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyFromMat)
{
try
{
cv::Mat gold = randomMat(size, type);
@ -164,8 +222,16 @@ TEST_P(GlBuffer, CopyFromMat)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyFromGpuMat)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::gpu::GpuMat d_gold(gold);
@ -178,8 +244,16 @@ TEST_P(GlBuffer, CopyFromGpuMat)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyFromGlBuffer)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
@ -194,8 +268,16 @@ TEST_P(GlBuffer, CopyFromGlBuffer)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyFromGlTexture2D)
{
try
{
const int depth = CV_MAT_DEPTH(type);
const int cn = CV_MAT_CN(type);
@ -214,8 +296,16 @@ TEST_P(GlBuffer, CopyFromGlTexture2D)
EXPECT_MAT_NEAR(gold, bufData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyToGpuMat)
{
try
{
cv::Mat gold = randomMat(size, type);
@ -226,8 +316,16 @@ TEST_P(GlBuffer, CopyToGpuMat)
EXPECT_MAT_NEAR(gold, dst, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyToGlBuffer)
{
try
{
cv::Mat gold = randomMat(size, type);
@ -243,8 +341,16 @@ TEST_P(GlBuffer, CopyToGlBuffer)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyToGlTexture2D)
{
try
{
const int depth = CV_MAT_DEPTH(type);
const int cn = CV_MAT_CN(type);
@ -264,8 +370,16 @@ TEST_P(GlBuffer, CopyToGlTexture2D)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, Clone)
{
try
{
cv::Mat gold = randomMat(size, type);
@ -280,8 +394,16 @@ TEST_P(GlBuffer, Clone)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, MapHostRead)
{
try
{
cv::Mat gold = randomMat(size, type);
@ -293,8 +415,16 @@ TEST_P(GlBuffer, MapHostRead)
buf.unmapHost();
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, MapHostWrite)
{
try
{
cv::Mat gold = randomMat(size, type);
@ -310,8 +440,16 @@ TEST_P(GlBuffer, MapHostWrite)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, MapDevice)
{
try
{
cv::Mat gold = randomMat(size, type);
@ -323,6 +461,12 @@ TEST_P(GlBuffer, MapDevice)
buf.unmapDevice();
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES));
@ -359,6 +503,8 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
};
TEST_P(GlTexture2D, Constructor1)
{
try
{
cv::GlTexture2D tex(size.height, size.width, format, true);
@ -366,8 +512,16 @@ TEST_P(GlTexture2D, Constructor1)
EXPECT_EQ(size.width, tex.cols());
EXPECT_EQ(format, tex.format());
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, Constructor2)
{
try
{
cv::GlTexture2D tex(size, format, true);
@ -375,8 +529,16 @@ TEST_P(GlTexture2D, Constructor2)
EXPECT_EQ(size.width, tex.cols());
EXPECT_EQ(format, tex.format());
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, ConstructorFromMat)
{
try
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
@ -387,8 +549,16 @@ TEST_P(GlTexture2D, ConstructorFromMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, ConstructorFromGpuMat)
{
try
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::gpu::GpuMat d_gold(gold);
@ -400,8 +570,16 @@ TEST_P(GlTexture2D, ConstructorFromGpuMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, ConstructorFromGlBuffer)
{
try
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
@ -413,8 +591,16 @@ TEST_P(GlTexture2D, ConstructorFromGlBuffer)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
{
try
{
cv::GlTexture2D tex_gold(size, format, true);
cv::GlTexture2D tex(tex_gold);
@ -424,8 +610,16 @@ TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
EXPECT_EQ(tex_gold.cols(), tex.cols());
EXPECT_EQ(tex_gold.format(), tex.format());
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, Create)
{
try
{
cv::GlTexture2D tex;
tex.create(size.height, size.width, format, true);
@ -434,8 +628,16 @@ TEST_P(GlTexture2D, Create)
EXPECT_EQ(size.width, tex.cols());
EXPECT_EQ(format, tex.format());
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, CopyFromMat)
{
try
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
@ -447,8 +649,16 @@ TEST_P(GlTexture2D, CopyFromMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, CopyFromGpuMat)
{
try
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::gpu::GpuMat d_gold(gold);
@ -461,8 +671,16 @@ TEST_P(GlTexture2D, CopyFromGpuMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, CopyFromGlBuffer)
{
try
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
@ -475,8 +693,16 @@ TEST_P(GlTexture2D, CopyFromGlBuffer)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, CopyToGpuMat)
{
try
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
@ -487,8 +713,16 @@ TEST_P(GlTexture2D, CopyToGpuMat)
EXPECT_MAT_NEAR(gold, dst, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlTexture2D, CopyToGlBuffer)
{
try
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
@ -502,6 +736,12 @@ TEST_P(GlTexture2D, CopyToGlBuffer)
EXPECT_MAT_NEAR(gold, bufData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4)));

16
modules/gpu/test/test_pyramids.cpp

@ -65,6 +65,8 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
};
TEST_P(PyrDown, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
@ -76,6 +78,12 @@ TEST_P(PyrDown, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine(
ALL_DEVICES,
@ -105,6 +113,8 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
};
TEST_P(PyrUp, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
@ -116,6 +126,12 @@ TEST_P(PyrUp, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine(
ALL_DEVICES,

8
modules/gpu/test/test_remap.cpp

@ -153,6 +153,8 @@ PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Bo
};
TEST_P(Remap, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Scalar val = randomScalar(0.0, 255.0);
@ -165,6 +167,12 @@ TEST_P(Remap, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine(
ALL_DEVICES,

24
modules/gpu/test/test_resize.cpp

@ -137,6 +137,8 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol
};
TEST_P(Resize, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
@ -148,6 +150,12 @@ TEST_P(Resize, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
ALL_DEVICES,
@ -183,6 +191,8 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double
// downscaling only: used for classifiers
TEST_P(ResizeSameAsHost, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
@ -194,6 +204,12 @@ TEST_P(ResizeSameAsHost, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
ALL_DEVICES,
@ -225,6 +241,8 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation)
};
TEST_P(ResizeNPP, Accuracy)
{
try
{
cv::Mat src = readImageType("stereobp/aloe-L.png", type);
ASSERT_FALSE(src.empty());
@ -237,6 +255,12 @@ TEST_P(ResizeNPP, Accuracy)
EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeNPP, testing::Combine(
ALL_DEVICES,

43
modules/gpu/test/test_softcascade.cpp

@ -40,7 +40,7 @@
//
//M*/
#include <test_precomp.hpp>
#include "test_precomp.hpp"
#include <time.h>
#ifdef HAVE_CUDA
@ -157,6 +157,8 @@ GPU_TEST_P(SCascadeTestRoi, detect,
testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
testing::Range(0, 5)))
{
try
{
cv::gpu::setDevice(GET_PARAM(0).deviceID());
cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
@ -202,10 +204,17 @@ GPU_TEST_P(SCascadeTestRoi, detect,
}
SHOW(result);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST(SCascadeTest, readCascade)
{
try
{
std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
cv::gpu::SCascade cascade;
@ -215,11 +224,19 @@ TEST(SCascadeTest, readCascade)
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
GPU_TEST_P(SCascadeTestAll, detect,
ALL_DEVICES
)
{
try
{
cv::gpu::setDevice(GetParam().deviceID());
std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
@ -247,10 +264,18 @@ GPU_TEST_P(SCascadeTestAll, detect,
int a = *(detections.ptr<int>(0));
ASSERT_EQ(a, 2448);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
ALL_DEVICES
)
{
try
{
cv::gpu::setDevice(GetParam().deviceID());
std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
@ -286,10 +311,18 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
ASSERT_EQ(a, 1024);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
GPU_TEST_P(SCascadeTestAll, detectStream,
ALL_DEVICES
)
{
try
{
cv::gpu::setDevice(GetParam().deviceID());
std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
@ -320,6 +353,12 @@ GPU_TEST_P(SCascadeTestAll, detectStream,
int a = *(detections.ptr<int>(0));
ASSERT_EQ(a, 2448);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
#endif

8
modules/gpu/test/test_threshold.cpp

@ -67,6 +67,8 @@ PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, Use
};
TEST_P(Threshold, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
double maxVal = randomDouble(20.0, 127.0);
@ -80,6 +82,12 @@ TEST_P(Threshold, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(
ALL_DEVICES,

150
modules/gpu/test/test_video.cpp

@ -64,6 +64,8 @@ struct BroxOpticalFlow : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(BroxOpticalFlow, Regression)
{
try
{
cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
ASSERT_FALSE(frame0.empty());
@ -124,9 +126,14 @@ TEST_P(BroxOpticalFlow, Regression)
for (int i = 0; i < v.rows; ++i)
f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
#endif
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
@ -150,6 +157,8 @@ PARAM_TEST_CASE(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
};
TEST_P(GoodFeaturesToTrack, Accuracy)
{
try
{
cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
@ -159,20 +168,6 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
{
try
{
cv::gpu::GpuMat d_pts;
detector(loadMat(image), d_pts);
}
catch (const cv::Exception& e)
{
ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
else
{
cv::gpu::GpuMat d_pts;
detector(loadMat(image), d_pts);
@ -201,9 +196,16 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
ASSERT_LE(bad_ratio, 0.01);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GoodFeaturesToTrack, EmptyCorners)
{
try
{
int maxCorners = 1000;
double qualityLevel = 0.01;
@ -217,6 +219,12 @@ TEST_P(GoodFeaturesToTrack, EmptyCorners)
ASSERT_TRUE( corners.empty() );
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
ALL_DEVICES,
@ -242,6 +250,8 @@ PARAM_TEST_CASE(PyrLKOpticalFlow, cv::gpu::DeviceInfo, UseGray)
};
TEST_P(PyrLKOpticalFlow, Sparse)
{
try
{
cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
ASSERT_FALSE(frame0.empty());
@ -308,6 +318,12 @@ TEST_P(PyrLKOpticalFlow, Sparse)
ASSERT_LE(bad_ratio, 0.01);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
ALL_DEVICES,
@ -342,6 +358,8 @@ PARAM_TEST_CASE(FarnebackOpticalFlow, cv::gpu::DeviceInfo, PyrScale, PolyN, Farn
};
TEST_P(FarnebackOpticalFlow, Accuracy)
{
try
{
cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame0.empty());
@ -383,6 +401,12 @@ TEST_P(FarnebackOpticalFlow, Accuracy)
EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
ALL_DEVICES,
@ -394,6 +418,8 @@ INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
struct OpticalFlowNan : public BroxOpticalFlow {};
TEST_P(OpticalFlowNan, Regression)
{
try
{
cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
ASSERT_FALSE(frame0.empty());
@ -416,6 +442,12 @@ TEST_P(OpticalFlowNan, Regression)
v.download(h_v);
EXPECT_TRUE(cv::checkRange(h_u));
EXPECT_TRUE(cv::checkRange(h_v));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
};
INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowNan, ALL_DEVICES);
@ -428,6 +460,8 @@ PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi)
};
TEST_P(OpticalFlowDual_TVL1, Accuracy)
{
try
{
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID());
@ -454,6 +488,12 @@ TEST_P(OpticalFlowDual_TVL1, Accuracy)
EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
ALL_DEVICES,
@ -485,6 +525,8 @@ struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(OpticalFlowBM, Accuracy)
{
try
{
cv::gpu::DeviceInfo devInfo = GetParam();
cv::gpu::setDevice(devInfo.deviceID());
@ -510,6 +552,12 @@ TEST_P(OpticalFlowBM, Accuracy)
EXPECT_MAT_NEAR(velx, d_velx, 0);
EXPECT_MAT_NEAR(vely, d_vely, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
@ -585,6 +633,8 @@ struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
};
TEST_P(FastOpticalFlowBM, Accuracy)
{
try
{
const double MAX_RMSE = 0.6;
@ -625,6 +675,12 @@ TEST_P(FastOpticalFlowBM, Accuracy)
err = calc_rmse(flowy, cv::Mat(d_flowy));
EXPECT_LE(err, MAX_RMSE);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
@ -657,6 +713,8 @@ PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels)
};
TEST_P(FGDStatModel, Update)
{
try
{
cv::VideoCapture cap(inputFile);
ASSERT_TRUE(cap.isOpened());
@ -709,6 +767,12 @@ TEST_P(FGDStatModel, Update)
ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, FGDStatModel, testing::Combine(
ALL_DEVICES,
@ -744,6 +808,8 @@ PARAM_TEST_CASE(MOG, cv::gpu::DeviceInfo, std::string, UseGray, LearningRate, Us
};
TEST_P(MOG, Update)
{
try
{
cv::VideoCapture cap(inputFile);
ASSERT_TRUE(cap.isOpened());
@ -777,6 +843,12 @@ TEST_P(MOG, Update)
ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, MOG, testing::Combine(
ALL_DEVICES,
@ -809,6 +881,8 @@ PARAM_TEST_CASE(MOG2, cv::gpu::DeviceInfo, std::string, UseGray, UseRoi)
};
TEST_P(MOG2, Update)
{
try
{
cv::VideoCapture cap(inputFile);
ASSERT_TRUE(cap.isOpened());
@ -846,12 +920,20 @@ TEST_P(MOG2, Update)
ASSERT_LE(norm, 0.09);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(MOG2, getBackgroundImage)
{
if (useGray)
return;
try
{
cv::VideoCapture cap(inputFile);
ASSERT_TRUE(cap.isOpened());
@ -881,6 +963,12 @@ TEST_P(MOG2, getBackgroundImage)
ASSERT_MAT_NEAR(background_gold, background, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
ALL_DEVICES,
@ -896,6 +984,8 @@ PARAM_TEST_CASE(VIBE, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
};
TEST_P(VIBE, Accuracy)
{
try
{
const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID());
@ -922,6 +1012,12 @@ TEST_P(VIBE, Accuracy)
// now fgmask should be entirely foreground
ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, VIBE, testing::Combine(
ALL_DEVICES,
@ -937,6 +1033,8 @@ PARAM_TEST_CASE(GMG, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
};
TEST_P(GMG, Accuracy)
{
try
{
const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID());
@ -975,6 +1073,12 @@ TEST_P(GMG, Accuracy)
// now fgmask should be entirely foreground
ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
ALL_DEVICES,
@ -1008,6 +1112,8 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
};
TEST_P(VideoWriter, Regression)
{
try
{
const double FPS = 25.0;
@ -1044,6 +1150,12 @@ TEST_P(VideoWriter, Regression)
ASSERT_FALSE( frame.empty() );
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, VideoWriter, testing::Combine(
ALL_DEVICES,
@ -1069,6 +1181,8 @@ PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
};
TEST_P(VideoReader, Regression)
{
try
{
cv::gpu::VideoReader_GPU reader(inputFile);
ASSERT_TRUE( reader.isOpened() );
@ -1084,6 +1198,12 @@ TEST_P(VideoReader, Regression)
reader.close();
ASSERT_FALSE( reader.isOpened() );
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
ALL_DEVICES,

24
modules/gpu/test/test_warp_affine.cpp

@ -75,6 +75,8 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse)
};
TEST_P(BuildWarpAffineMaps, Accuracy)
{
try
{
cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
cv::gpu::GpuMat xmap, ymap;
@ -95,6 +97,12 @@ TEST_P(BuildWarpAffineMaps, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpAffineMaps, testing::Combine(
ALL_DEVICES,
@ -200,6 +208,8 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int
};
TEST_P(WarpAffine, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
@ -216,6 +226,12 @@ TEST_P(WarpAffine, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine(
ALL_DEVICES,
@ -248,6 +264,8 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat
};
TEST_P(WarpAffineNPP, Accuracy)
{
try
{
cv::Mat src = readImageType("stereobp/aloe-L.png", type);
cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
@ -263,6 +281,12 @@ TEST_P(WarpAffineNPP, Accuracy)
EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine(
ALL_DEVICES,

24
modules/gpu/test/test_warp_perspective.cpp

@ -76,6 +76,8 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse
};
TEST_P(BuildWarpPerspectiveMaps, Accuracy)
{
try
{
cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
cv::gpu::GpuMat xmap, ymap;
@ -93,6 +95,12 @@ TEST_P(BuildWarpPerspectiveMaps, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpPerspectiveMaps, testing::Combine(
ALL_DEVICES,
@ -200,6 +208,8 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse
};
TEST_P(WarpPerspective, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
@ -216,6 +226,12 @@ TEST_P(WarpPerspective, Accuracy)
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine(
ALL_DEVICES,
@ -248,6 +264,8 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter
};
TEST_P(WarpPerspectiveNPP, Accuracy)
{
try
{
cv::Mat src = readImageType("stereobp/aloe-L.png", type);
cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
@ -263,6 +281,12 @@ TEST_P(WarpPerspectiveNPP, Accuracy)
EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(
ALL_DEVICES,