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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

32
modules/gpu/perf/perf_denoising.cpp
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

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

44
modules/gpu/perf/perf_softcascade.cpp
View File

@ -60,6 +60,8 @@ GPU_PERF_TEST_P(SCascadeTest, detect,
RUN_GPU(SCascadeTest, detect)
{
try
{
cv::Mat cpu = readImage (GET_PARAM(1));
ASSERT_FALSE(cpu.empty());
cv::gpu::GpuMat colored(cpu);
@ -82,6 +84,12 @@ RUN_GPU(SCascadeTest, detect)
}
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTest, detect)
@ -118,6 +126,8 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectInRoi,
RUN_GPU(SCascadeTestRoi, detectInRoi)
{
try
{
cv::Mat cpu = readImage (GET_PARAM(1));
ASSERT_FALSE(cpu.empty());
cv::gpu::GpuMat colored(cpu);
@ -149,6 +159,12 @@ RUN_GPU(SCascadeTestRoi, detectInRoi)
}
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTestRoi, detectInRoi)
@ -163,6 +179,8 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectEachRoi,
RUN_GPU(SCascadeTestRoi, detectEachRoi)
{
try
{
cv::Mat cpu = readImage (GET_PARAM(1));
ASSERT_FALSE(cpu.empty());
cv::gpu::GpuMat colored(cpu);
@ -190,6 +208,12 @@ RUN_GPU(SCascadeTestRoi, detectEachRoi)
}
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTestRoi, detectEachRoi)
@ -209,6 +233,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());
@ -239,6 +265,12 @@ RUN_GPU(SCascadeTest, detectOnIntegral)
}
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTest, detectOnIntegral)
@ -251,6 +283,8 @@ GPU_PERF_TEST_P(SCascadeTest, detectStream,
RUN_GPU(SCascadeTest, detectStream)
{
try
{
cv::Mat cpu = readImage (GET_PARAM(1));
ASSERT_FALSE(cpu.empty());
cv::gpu::GpuMat colored(cpu);
@ -274,11 +308,17 @@ RUN_GPU(SCascadeTest, detectStream)
cascade.detect(colored, rois, objectBoxes, s);
}
#ifdef HAVE_CUDA
#ifdef HAVE_CUDA
cudaDeviceSynchronize();
#endif
#endif
SANITY_CHECK(sortDetections(objectBoxes));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
NO_CPU(SCascadeTest, detectStream)

144
modules/gpu/perf/perf_video.cpp
View File

@ -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
View File

@ -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
View File

@ -62,6 +62,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);
cv::Mat disp_gold = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
@ -76,6 +78,12 @@ TEST_P(StereoBM, Regression)
bm(loadMat(left_image), loadMat(right_image), disp);
EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBM, ALL_DEVICES);
@ -97,6 +105,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");
cv::Mat disp_gold = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
@ -114,6 +124,12 @@ TEST_P(StereoBeliefPropagation, Regression)
h_disp.convertTo(h_disp, disp_gold.depth());
EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBeliefPropagation, ALL_DEVICES);
@ -135,6 +151,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");
@ -158,6 +176,12 @@ TEST_P(StereoConstantSpaceBP, Regression)
h_disp.convertTo(h_disp, disp_gold.depth());
EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
@ -179,6 +203,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);
cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@ -206,6 +232,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);
@ -227,6 +259,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);
cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@ -256,6 +290,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);
@ -277,6 +317,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);
camera_mat.at<float>(0, 1) = 0.f;
@ -299,6 +341,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);
@ -326,6 +374,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);
@ -336,6 +386,12 @@ TEST_P(ReprojectImageTo3D, Accuracy)
cv::reprojectImageTo3D(disp, dst_gold, Q, false);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(

858
modules/gpu/test/test_color.cpp
View File

File diff suppressed because it is too large Load Diff

8
modules/gpu/test/test_copy_make_border.cpp
View File

@ -71,6 +71,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);
@ -81,6 +83,12 @@ TEST_P(CopyMakeBorder, Accuracy)
cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(

608
modules/gpu/test/test_core.cpp
View File

File diff suppressed because it is too large Load Diff

35
modules/gpu/test/test_denoising.cpp
View File

@ -71,6 +71,8 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType)
TEST_P(BilateralFilter, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
src.convertTo(src, type);
@ -82,6 +84,12 @@ TEST_P(BilateralFilter, Accuracy)
cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
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(
@ -107,6 +115,8 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
TEST_P(BruteForceNonLocalMeans, Regression)
{
try
{
using cv::gpu::GpuMat;
cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
@ -119,10 +129,10 @@ TEST_P(BruteForceNonLocalMeans, Regression)
cv::gpu::nonLocalMeans(GpuMat(bgr), dbgr, 20);
cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
#if 0
#if 0
dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
#endif
#endif
cv::Mat bgr_gold = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
cv::Mat gray_gold = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
@ -130,12 +140,16 @@ 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
@ -152,6 +166,8 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
TEST_P(FastNonLocalMeans, Regression)
{
try
{
using cv::gpu::GpuMat;
cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
@ -166,10 +182,10 @@ TEST_P(FastNonLocalMeans, Regression)
fnlmd.simpleMethod(GpuMat(gray), dgray, 20);
fnlmd.labMethod(GpuMat(bgr), dbgr, 20, 10);
#if 0
#if 0
//dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
//dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
#endif
#endif
cv::Mat bgr_gold = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
cv::Mat gray_gold = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
@ -177,9 +193,14 @@ 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
View File

@ -180,6 +180,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,10 +212,17 @@ 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,10 +256,17 @@ 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(
@ -364,26 +342,14 @@ 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());
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(
@ -445,6 +416,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(
@ -570,6 +533,8 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize
TEST_P(BruteForceMatcher, Match_Single)
{
try
{
cv::gpu::BFMatcher_GPU matcher(normCode);
cv::gpu::GpuMat mask;
@ -593,10 +558,18 @@ 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);
cv::gpu::GpuMat d_train(train);
@ -647,10 +620,18 @@ 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);
const int knn = 2;
@ -686,10 +667,18 @@ 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);
const int knn = 3;
@ -725,10 +714,18 @@ 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);
const int knn = 2;
@ -787,10 +784,18 @@ 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);
const int knn = 3;
@ -849,10 +854,18 @@ 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);
const float radius = 1.f / countFactor;
@ -898,10 +911,18 @@ 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);
const int n = 3;
@ -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
View File

@ -88,6 +88,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);
cv::gpu::GpuMat dst = createMat(size, type, useRoi);
@ -97,6 +99,12 @@ TEST_P(Blur, Accuracy)
cv::blur(src, dst_gold, ksize, anchor);
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(
@ -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);
@ -159,6 +169,12 @@ TEST_P(Sobel, Accuracy)
cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
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(
@ -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);
@ -222,6 +240,12 @@ TEST_P(Scharr, Accuracy)
cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
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(
@ -270,6 +294,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);
double sigma2 = randomDouble(0.1, 1.0);
@ -296,6 +322,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(
@ -349,6 +381,8 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi
TEST_P(Laplacian, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::gpu::GpuMat dst = createMat(size, type, useRoi);
@ -358,6 +392,12 @@ TEST_P(Laplacian, Accuracy)
cv::Laplacian(src, dst_gold, -1, ksize.width);
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(
@ -396,6 +436,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);
@ -408,6 +450,12 @@ TEST_P(Erode, Accuracy)
cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
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(
@ -445,6 +493,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);
@ -457,6 +507,12 @@ TEST_P(Dilate, Accuracy)
cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
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(
@ -499,6 +555,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);
@ -511,6 +569,12 @@ TEST_P(MorphEx, Accuracy)
cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
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(
@ -553,6 +617,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);
@ -563,6 +629,12 @@ TEST_P(Filter2D, Accuracy)
cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
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(

8
modules/gpu/test/test_global_motion.cpp
View File

@ -53,6 +53,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);
src0.at<Point2f>(0,1) = Point2f(0,1);
@ -82,6 +84,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
View File

@ -69,16 +69,26 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
TEST_P(SetTo, Zero)
{
try
{
cv::Scalar zero = cv::Scalar::all(0);
cv::gpu::GpuMat mat = createMat(size, type, useRoi);
mat.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));
if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
@ -100,10 +110,18 @@ 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);
if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
@ -125,10 +143,18 @@ 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);
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
@ -154,6 +180,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(
@ -186,6 +218,8 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
TEST_P(CopyTo, WithOutMask)
{
try
{
cv::Mat src = randomMat(size, type);
cv::gpu::GpuMat d_src = loadMat(src, useRoi);
@ -193,10 +227,18 @@ TEST_P(CopyTo, WithOutMask)
d_src.copyTo(dst);
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);
@ -224,6 +266,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(
@ -257,6 +305,8 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us
TEST_P(ConvertTo, WithOutScaling)
{
try
{
cv::Mat src = randomMat(size, depth1);
if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
@ -283,10 +333,18 @@ 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);
double b = randomDouble(-10.0, 10.0);
@ -315,6 +373,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(
@ -338,6 +402,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;
@ -354,6 +420,12 @@ TEST_P(EnsureSizeIsEnough, BufferReuse)
EXPECT_EQ(30, buffer.cols);
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
View File

@ -81,6 +81,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());
const cv::Size size = GET_PARAM(1);
@ -103,6 +105,12 @@ TEST_P(HoughLines, Accuracy)
drawLines(dst, lines);
ASSERT_MAT_NEAR(src, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughLines, testing::Combine(
@ -126,6 +134,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());
const cv::Size size = GET_PARAM(1);
@ -174,6 +184,12 @@ TEST_P(HoughCircles, Accuracy)
ASSERT_TRUE(found);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughCircles, testing::Combine(
@ -190,6 +206,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());
const bool useRoi = GET_PARAM(1);
@ -245,6 +263,12 @@ TEST_P(GeneralizedHough, POSITION)
ASSERT_TRUE(found);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, GeneralizedHough, testing::Combine(

184
modules/gpu/test/test_imgproc.cpp
View File

@ -66,6 +66,8 @@ PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
TEST_P(Integral, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_8UC1);
cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
@ -75,6 +77,12 @@ TEST_P(Integral, Accuracy)
cv::integral(src, dst_gold, CV_32S);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine(
@ -99,6 +107,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());
@ -125,6 +135,12 @@ TEST_P(HistEven, Accuracy)
hist_gold.convertTo(hist_gold, CV_32S);
EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);
@ -164,6 +180,8 @@ PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size)
TEST_P(CalcHist, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_8UC1);
cv::gpu::GpuMat hist;
@ -173,6 +191,12 @@ TEST_P(CalcHist, Accuracy)
calcHistGold(src, hist_gold);
EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine(
@ -198,6 +222,8 @@ PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
TEST_P(EqualizeHist, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_8UC1);
cv::gpu::GpuMat dst;
@ -207,6 +233,12 @@ TEST_P(EqualizeHist, Accuracy)
cv::equalizeHist(src, dst_gold);
EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine(
@ -232,6 +264,8 @@ PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
TEST_P(ColumnSum, Accuracy)
{
try
{
cv::Mat src = randomMat(size, CV_32FC1);
cv::gpu::GpuMat d_dst;
@ -255,6 +289,12 @@ TEST_P(ColumnSum, Accuracy)
ASSERT_NEAR(res, gold, 1e-5);
}
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ColumnSum, testing::Combine(
@ -287,6 +327,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());
@ -315,6 +357,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(
@ -351,6 +399,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))
img_template = readImage("meanshift/con_result.png");
@ -369,10 +419,18 @@ TEST_P(MeanShift, Filtering)
cv::cvtColor(dst, result, CV_BGRA2BGR);
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))
fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
@ -395,6 +453,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);
@ -420,6 +484,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());
@ -439,6 +505,12 @@ TEST_P(MeanShiftSegmentation, Regression)
cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(
@ -492,6 +564,8 @@ PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
TEST_P(Blend, Accuracy)
{
try
{
int depth = CV_MAT_DEPTH(type);
cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
@ -509,6 +583,12 @@ TEST_P(Blend, Accuracy)
blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
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(
@ -582,6 +662,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);
@ -592,6 +674,12 @@ TEST_P(Convolve, Accuracy)
convolveDFT(src, kernel, dst_gold, ccorr);
EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
@ -630,6 +718,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));
@ -640,6 +730,12 @@ TEST_P(MatchTemplate8U, Accuracy)
cv::matchTemplate(image, templ, dst_gold, method);
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(
@ -676,6 +772,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));
@ -686,6 +784,12 @@ TEST_P(MatchTemplate32F, Regression)
cv::matchTemplate(image, templ, dst_gold, method);
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(
@ -714,6 +818,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());
@ -732,6 +838,12 @@ TEST_P(MatchTemplateBlackSource, Accuracy)
cv::Point maxLocGold = cv::Point(284, 12);
ASSERT_EQ(maxLocGold, maxLoc);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine(
@ -759,6 +871,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());
@ -785,6 +899,12 @@ TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
ASSERT_EQ(maxLocGold, maxLoc);
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(
@ -808,6 +928,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());
@ -827,10 +949,18 @@ TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
ASSERT_LT(minVal, 1e-3);
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());
@ -849,6 +979,12 @@ TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
ASSERT_GE(minVal, 0);
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);
@ -881,6 +1017,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);
@ -888,10 +1026,18 @@ TEST_P(MulSpectrums, Simple)
cv::mulSpectrums(a, b, c_gold, flag, false);
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(MulSpectrums, Scaled)
{
try
{
float scale = 1.f / size.area();
cv::gpu::GpuMat c;
@ -902,6 +1048,12 @@ TEST_P(MulSpectrums, Scaled)
c_gold.convertTo(c_gold, c_gold.type(), scale);
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MulSpectrums, testing::Combine(
@ -950,6 +1102,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);
@ -971,6 +1125,12 @@ TEST_P(Dft, C2C)
testC2C("size 1 2", 1, 2, 0, inplace);
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)
@ -1011,6 +1171,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);
@ -1029,6 +1191,12 @@ TEST_P(Dft, R2CThenC2R)
testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
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);
@ -1061,6 +1229,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());
@ -1073,6 +1243,12 @@ TEST_P(CornerHarris, Accuracy)
cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(
@ -1107,6 +1283,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());
@ -1117,6 +1295,12 @@ TEST_P(CornerMinEigen, Accuracy)
cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(

8
modules/gpu/test/test_labeling.cpp
View File

@ -168,6 +168,8 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo>
TEST_P(Labeling, ConnectedComponents)
{
try
{
cv::Mat image;
cvtColor(loat_image(), image, CV_BGR2GRAY);
@ -189,6 +191,12 @@ TEST_P(Labeling, ConnectedComponents)
ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
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
View File

@ -69,82 +69,169 @@ 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);

61
modules/gpu/test/test_objdetect.cpp
View File

@ -175,19 +175,20 @@ 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());
#ifdef DUMP
#ifdef DUMP
f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
ASSERT_TRUE(f.is_open());
#else
#else
f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
ASSERT_TRUE(f.is_open());
#endif
#endif
// Test on color image
cv::Mat img;
@ -199,10 +200,18 @@ TEST_P(HOG, DISABLED_Detect)
testDetect(img);
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");
ASSERT_FALSE(img_rgb.empty());
@ -283,6 +292,12 @@ TEST_P(HOG, GetDescriptors)
cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
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);
@ -305,6 +320,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());
@ -315,7 +332,7 @@ TEST_P(CalTech, HOG)
std::vector<cv::Rect> found_locations;
d_hog.detectMultiScale(d_img, found_locations);
#if defined (LOG_CASCADE_STATISTIC)
#if defined (LOG_CASCADE_STATISTIC)
for (int i = 0; i < (int)found_locations.size(); i++)
{
cv::Rect r = found_locations[i];
@ -325,7 +342,13 @@ TEST_P(CalTech, HOG)
}
cv::imshow("Res", markedImage); cv::waitKey();
#endif
#endif
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(detect, CalTech, testing::Combine(ALL_DEVICES,
@ -352,9 +375,17 @@ 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,
@ -374,6 +405,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";
@ -401,7 +434,7 @@ TEST_P(LBP_classify, Accuracy)
cv::gpu::GpuMat tested(grey);
int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
#if defined (LOG_CASCADE_STATISTIC)
#if defined (LOG_CASCADE_STATISTIC)
cv::Mat downloaded(gpu_rects);
const cv::Rect* faces = downloaded.ptr<cv::Rect>();
for (int i = 0; i < count; i++)
@ -411,12 +444,18 @@ TEST_P(LBP_classify, Accuracy)
std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl;
cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
}
#endif
#endif
#if defined (LOG_CASCADE_STATISTIC)
#if defined (LOG_CASCADE_STATISTIC)
cv::imshow("Res", markedImage); cv::waitKey();
#endif
#endif
(void)count;
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,

240
modules/gpu/test/test_opengl.cpp
View File

@ -70,24 +70,42 @@ 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);
EXPECT_EQ(size.height, buf.rows());
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);
EXPECT_EQ(size.height, buf.rows());
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);
cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
@ -96,10 +114,18 @@ TEST_P(GlBuffer, ConstructorFromMat)
buf.copyTo(bufData);
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);
@ -109,10 +135,18 @@ TEST_P(GlBuffer, ConstructorFromGpuMat)
buf.copyTo(bufData);
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);
cv::GlBuffer buf(buf_gold);
@ -121,10 +155,18 @@ TEST_P(GlBuffer, ConstructorFromGlBuffer)
EXPECT_EQ(buf_gold.rows(), buf.rows());
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);
@ -140,20 +182,36 @@ TEST_P(GlBuffer, ConstructorFromGlTexture2D)
buf.copyTo(bufData);
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);
EXPECT_EQ(size.height, buf.rows());
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);
cv::GlBuffer buf;
@ -163,10 +221,18 @@ TEST_P(GlBuffer, CopyFromMat)
buf.copyTo(bufData);
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);
@ -177,10 +243,18 @@ TEST_P(GlBuffer, CopyFromGpuMat)
buf.copyTo(bufData);
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);
@ -193,10 +267,18 @@ TEST_P(GlBuffer, CopyFromGlBuffer)
buf.copyTo(bufData);
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);
@ -213,10 +295,18 @@ TEST_P(GlBuffer, CopyFromGlTexture2D)
buf.copyTo(bufData);
EXPECT_MAT_NEAR(gold, bufData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyToGpuMat)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
@ -225,10 +315,18 @@ TEST_P(GlBuffer, CopyToGpuMat)
buf.copyTo(dst);
EXPECT_MAT_NEAR(gold, dst, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, CopyToGlBuffer)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
@ -242,10 +340,18 @@ TEST_P(GlBuffer, CopyToGlBuffer)
dst.copyTo(bufData);
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);
@ -263,10 +369,18 @@ TEST_P(GlBuffer, CopyToGlTexture2D)
tex.copyTo(texData);
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, Clone)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
@ -279,10 +393,18 @@ TEST_P(GlBuffer, Clone)
dst.copyTo(bufData);
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, MapHostRead)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
@ -292,10 +414,18 @@ TEST_P(GlBuffer, MapHostRead)
EXPECT_MAT_NEAR(gold, dst, 0);
buf.unmapHost();
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, MapHostWrite)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
@ -309,10 +439,18 @@ TEST_P(GlBuffer, MapHostWrite)
buf.copyTo(bufData);
EXPECT_MAT_NEAR(gold, bufData, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(GlBuffer, MapDevice)
{
try
{
cv::Mat gold = randomMat(size, type);
cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
@ -322,6 +460,12 @@ TEST_P(GlBuffer, MapDevice)
EXPECT_MAT_NEAR(gold, dst, 0);
buf.unmapDevice();
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES));
@ -360,24 +504,42 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
TEST_P(GlTexture2D, Constructor1)
{
try
{
cv::GlTexture2D tex(size.height, size.width, format, true);
EXPECT_EQ(size.height, tex.rows());
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);
EXPECT_EQ(size.height, tex.rows());
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);
cv::GlTexture2D tex(gold, true);
@ -386,10 +548,18 @@ TEST_P(GlTexture2D, ConstructorFromMat)
tex.copyTo(texData, depth);
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);
@ -399,10 +569,18 @@ TEST_P(GlTexture2D, ConstructorFromGpuMat)
tex.copyTo(texData, depth);
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);
@ -412,10 +590,18 @@ TEST_P(GlTexture2D, ConstructorFromGlBuffer)
tex.copyTo(texData, depth);
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);
@ -423,20 +609,36 @@ TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
EXPECT_EQ(tex_gold.rows(), tex.rows());
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);
EXPECT_EQ(size.height, tex.rows());
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);
cv::GlTexture2D tex;
@ -446,10 +648,18 @@ TEST_P(GlTexture2D, CopyFromMat)
tex.copyTo(texData, depth);
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);
@ -460,10 +670,18 @@ TEST_P(GlTexture2D, CopyFromGpuMat)
tex.copyTo(texData, depth);
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);
@ -474,10 +692,18 @@ TEST_P(GlTexture2D, CopyFromGlBuffer)
tex.copyTo(texData, depth);
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);
cv::GlTexture2D tex(gold, true);
@ -486,10 +712,18 @@ TEST_P(GlTexture2D, CopyToGpuMat)
tex.copyTo(dst, depth);
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);
cv::GlTexture2D tex(gold, true);
@ -501,6 +735,12 @@ TEST_P(GlTexture2D, CopyToGlBuffer)
dst.copyTo(bufData);
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
View File

@ -66,6 +66,8 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
TEST_P(PyrDown, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
@ -75,6 +77,12 @@ TEST_P(PyrDown, Accuracy)
cv::pyrDown(src, dst_gold);
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(
@ -106,6 +114,8 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
TEST_P(PyrUp, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
@ -115,6 +125,12 @@ TEST_P(PyrUp, Accuracy)
cv::pyrUp(src, dst_gold);
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(

8
modules/gpu/test/test_remap.cpp
View File

@ -154,6 +154,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);
@ -164,6 +166,12 @@ TEST_P(Remap, Accuracy)
remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
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(

24
modules/gpu/test/test_resize.cpp
View File

@ -138,6 +138,8 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol
TEST_P(Resize, Accuracy)
{
try
{
cv::Mat src = randomMat(size, type);
cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
@ -147,6 +149,12 @@ TEST_P(Resize, Accuracy)
resizeGold(src, dst_gold, coeff, coeff, interpolation);
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(
@ -184,6 +192,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);
cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
@ -193,6 +203,12 @@ TEST_P(ResizeSameAsHost, Accuracy)
cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
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(
@ -226,6 +242,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());
@ -236,6 +254,12 @@ TEST_P(ResizeNPP, Accuracy)
resizeGold(src, dst_gold, coeff, coeff, interpolation);
EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeNPP, testing::Combine(

49
modules/gpu/test/test_softcascade.cpp
View File

@ -40,7 +40,7 @@
//
//M*/
#include <test_precomp.hpp>
#include "test_precomp.hpp"
#include <time.h>
#ifdef HAVE_CUDA
@ -158,6 +158,8 @@ GPU_TEST_P(SCascadeTestRoi, detect,
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));
ASSERT_FALSE(coloredCpu.empty());
@ -202,11 +204,18 @@ 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;
@ -214,6 +223,12 @@ TEST(SCascadeTest, readCascade)
ASSERT_TRUE(fs.isOpened());
ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
@ -221,6 +236,8 @@ 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";
cv::gpu::SCascade cascade;
@ -245,13 +262,21 @@ GPU_TEST_P(SCascadeTestAll, detect,
typedef cv::gpu::SCascade::Detection Detection;
cv::Mat detections(objectBoxes);
int a = *(detections.ptr<int>(0));
ASSERT_EQ(a ,2448);
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";
cv::gpu::SCascade cascade;
@ -284,13 +309,21 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
cv::Mat detections(objectBoxes);
int a = *(detections.ptr<int>(0));
ASSERT_EQ( a ,1024);
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";
cv::gpu::SCascade cascade;
@ -318,7 +351,13 @@ GPU_TEST_P(SCascadeTestAll, detectStream,
typedef cv::gpu::SCascade::Detection Detection;
cv::Mat detections(objectBoxes);
int a = *(detections.ptr<int>(0));
ASSERT_EQ(a ,2448);
ASSERT_EQ(a, 2448);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}

8
modules/gpu/test/test_threshold.cpp
View File

@ -68,6 +68,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);
double thresh = randomDouble(0.0, maxVal);
@ -79,6 +81,12 @@ TEST_P(Threshold, Accuracy)
cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(

156
modules/gpu/test/test_video.cpp
View File

@ -65,6 +65,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());
@ -78,7 +80,7 @@ TEST_P(BroxOpticalFlow, Regression)
cv::gpu::GpuMat v;
brox(loadMat(frame0), loadMat(frame1), u, v);
#ifndef DUMP
#ifndef DUMP
std::string fname(cvtest::TS::ptr()->get_data_path());
if (devInfo.majorVersion() >= 2)
fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
@ -104,7 +106,7 @@ TEST_P(BroxOpticalFlow, Regression)
EXPECT_MAT_NEAR(u_gold, u, 0);
EXPECT_MAT_NEAR(v_gold, v, 0);
#else
#else
std::string fname(cvtest::TS::ptr()->get_data_path());
if (devInfo.majorVersion() >= 2)
fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
@ -124,8 +126,13 @@ TEST_P(BroxOpticalFlow, Regression)
for (int i = 0; i < v.rows; ++i)
f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
#endif
#endif
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
@ -151,6 +158,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,10 +196,17 @@ 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;
@ -216,6 +218,12 @@ TEST_P(GoodFeaturesToTrack, EmptyCorners)
detector(src, corners);
ASSERT_TRUE( corners.empty() );
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
@ -243,6 +251,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());
@ -307,6 +317,12 @@ TEST_P(PyrLKOpticalFlow, Sparse)
double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
ASSERT_LE(bad_ratio, 0.01);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
@ -343,6 +359,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());
@ -382,6 +400,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(
@ -395,6 +419,8 @@ struct OpticalFlowNan : public BroxOpticalFlow {};
TEST_P(OpticalFlowNan, Regression)
{
try
{
cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
ASSERT_FALSE(frame0.empty());
cv::Mat r_frame0, r_frame1;
@ -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);
@ -429,6 +461,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());
@ -453,6 +487,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(
@ -486,6 +526,8 @@ struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
TEST_P(OpticalFlowBM, Accuracy)
{
try
{
cv::gpu::DeviceInfo devInfo = GetParam();
cv::gpu::setDevice(devInfo.deviceID());
@ -509,6 +551,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);
@ -586,6 +634,8 @@ struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
TEST_P(FastOpticalFlowBM, Accuracy)
{
try
{
const double MAX_RMSE = 0.6;
int search_window = 15;
@ -624,6 +674,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);
@ -658,6 +714,8 @@ PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels)
TEST_P(FGDStatModel, Update)
{
try
{
cv::VideoCapture cap(inputFile);
ASSERT_TRUE(cap.isOpened());
@ -708,6 +766,12 @@ TEST_P(FGDStatModel, Update)
ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, FGDStatModel, testing::Combine(
@ -745,6 +809,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());
@ -776,6 +842,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(
@ -810,6 +882,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());
@ -845,6 +919,12 @@ TEST_P(MOG2, Update)
ASSERT_LE(norm, 0.09);
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
TEST_P(MOG2, getBackgroundImage)
@ -852,6 +932,8 @@ TEST_P(MOG2, getBackgroundImage)
if (useGray)
return;
try
{
cv::VideoCapture cap(inputFile);
ASSERT_TRUE(cap.isOpened());
@ -880,6 +962,12 @@ TEST_P(MOG2, getBackgroundImage)
mog2_gold.getBackgroundImage(background_gold);
ASSERT_MAT_NEAR(background_gold, background, 0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
@ -897,6 +985,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());
const cv::Size size = GET_PARAM(1);
@ -921,6 +1011,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(
@ -938,6 +1034,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());
const cv::Size size = GET_PARAM(1);
@ -974,6 +1072,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(
@ -1009,6 +1113,8 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
TEST_P(VideoWriter, Regression)
{
try
{
const double FPS = 25.0;
cv::VideoCapture reader(inputFile);
@ -1043,6 +1149,12 @@ TEST_P(VideoWriter, Regression)
reader >> frame;
ASSERT_FALSE( frame.empty() );
}
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_Video, VideoWriter, testing::Combine(
@ -1070,6 +1182,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() );
@ -1083,6 +1197,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(

24
modules/gpu/test/test_warp_affine.cpp
View File

@ -76,6 +76,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;
cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
@ -94,6 +96,12 @@ TEST_P(BuildWarpAffineMaps, Accuracy)
cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpAffineMaps, testing::Combine(
@ -201,6 +209,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);
int flags = interpolation;
@ -215,6 +225,12 @@ TEST_P(WarpAffine, Accuracy)
warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
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(
@ -249,6 +265,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);
int flags = interpolation;
@ -262,6 +280,12 @@ TEST_P(WarpAffineNPP, Accuracy)
warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine(

24
modules/gpu/test/test_warp_perspective.cpp
View File

@ -77,6 +77,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;
cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
@ -92,6 +94,12 @@ TEST_P(BuildWarpPerspectiveMaps, Accuracy)
cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpPerspectiveMaps, testing::Combine(
@ -201,6 +209,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);
int flags = interpolation;
@ -215,6 +225,12 @@ TEST_P(WarpPerspective, Accuracy)
warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
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(
@ -249,6 +265,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);
int flags = interpolation;
@ -262,6 +280,12 @@ TEST_P(WarpPerspectiveNPP, Accuracy)
warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
}
catch (...)
{
cv::gpu::resetDevice();
throw;
}
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(