diff --git a/modules/gpu/app/nv_perf_test/main.cpp b/modules/gpu/app/nv_perf_test/main.cpp index 928b30a19..96a5151c6 100644 --- a/modules/gpu/app/nv_perf_test/main.cpp +++ b/modules/gpu/app/nv_perf_test/main.cpp @@ -92,15 +92,23 @@ PERF_TEST_P(Image, HoughLinesP, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_image(image); - cv::gpu::GpuMat d_lines; - cv::gpu::HoughLinesBuf d_buf; - - cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap); - - TEST_CYCLE() + try { + cv::gpu::GpuMat d_image(image); + cv::gpu::GpuMat d_lines; + cv::gpu::HoughLinesBuf d_buf; + cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap); + + TEST_CYCLE() + { + cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -155,17 +163,25 @@ PERF_TEST_P(Image_Depth, GoodFeaturesToTrack, if (PERF_RUN_GPU()) { - cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k); - - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_mask(mask); - cv::gpu::GpuMat d_pts; - - d_detector(d_src, d_pts, d_mask); - - TEST_CYCLE() + try { + cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k); + + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_mask(mask); + cv::gpu::GpuMat d_pts; + d_detector(d_src, d_pts, d_mask); + + TEST_CYCLE() + { + d_detector(d_src, d_pts, d_mask); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -244,23 +260,31 @@ PERF_TEST_P(ImagePair_Depth_GraySource, OpticalFlowPyrLKSparse, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_pts(pts.reshape(2, 1)); - cv::gpu::GpuMat d_nextPts; - cv::gpu::GpuMat d_status; - - cv::gpu::PyrLKOpticalFlow d_pyrLK; - d_pyrLK.winSize = winSize; - d_pyrLK.maxLevel = maxLevel; - d_pyrLK.iters = criteria.maxCount; - d_pyrLK.useInitialFlow = false; - - d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status); - - TEST_CYCLE() + try { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_pts(pts.reshape(2, 1)); + cv::gpu::GpuMat d_nextPts; + cv::gpu::GpuMat d_status; + + cv::gpu::PyrLKOpticalFlow d_pyrLK; + d_pyrLK.winSize = winSize; + d_pyrLK.maxLevel = maxLevel; + d_pyrLK.iters = criteria.maxCount; + d_pyrLK.useInitialFlow = false; + d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status); + + TEST_CYCLE() + { + d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -322,25 +346,33 @@ PERF_TEST_P(ImagePair_Depth, OpticalFlowFarneback, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0)); - cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0)); - - cv::gpu::FarnebackOpticalFlow d_farneback; - d_farneback.pyrScale = pyrScale; - d_farneback.numLevels = numLevels; - d_farneback.winSize = winSize; - d_farneback.numIters = numIters; - d_farneback.polyN = polyN; - d_farneback.polySigma = polySigma; - d_farneback.flags = flags; - - d_farneback(d_src1, d_src2, d_u, d_v); - - TEST_CYCLE_N(10) + try { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0)); + cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0)); + + cv::gpu::FarnebackOpticalFlow d_farneback; + d_farneback.pyrScale = pyrScale; + d_farneback.numLevels = numLevels; + d_farneback.winSize = winSize; + d_farneback.numIters = numIters; + d_farneback.polyN = polyN; + d_farneback.polySigma = polySigma; + d_farneback.flags = flags; + d_farneback(d_src1, d_src2, d_u, d_v); + + TEST_CYCLE_N(10) + { + d_farneback(d_src1, d_src2, d_u, d_v); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -409,15 +441,23 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, OpticalFlowBM, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_velx, d_vely, buf; - - cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf); - - TEST_CYCLE_N(10) + try { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_velx, d_vely, buf; + cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf); + + TEST_CYCLE_N(10) + { + 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 @@ -460,17 +500,25 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, FastOpticalFlowBM, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_velx, d_vely; - - cv::gpu::FastOpticalFlowBM fastBM; - - fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width); - - TEST_CYCLE_N(10) + try { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_velx, d_vely; + + cv::gpu::FastOpticalFlowBM fastBM; + fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width); + + TEST_CYCLE_N(10) + { + fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp index 906024f64..3a086d9a8 100644 --- a/modules/gpu/perf/perf_calib3d.cpp +++ b/modules/gpu/perf/perf_calib3d.cpp @@ -26,20 +26,28 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(pair_string("gpu/perf/aloe.png", if (PERF_RUN_GPU()) { - cv::gpu::StereoBM_GPU d_bm(preset, ndisp); - - cv::gpu::GpuMat d_imgLeft(imgLeft); - cv::gpu::GpuMat d_imgRight(imgRight); - cv::gpu::GpuMat d_dst; - - d_bm(d_imgLeft, d_imgRight, d_dst); - - TEST_CYCLE() + try { - d_bm(d_imgLeft, d_imgRight, d_dst); - } + cv::gpu::StereoBM_GPU d_bm(preset, ndisp); - GPU_SANITY_CHECK(d_dst); + cv::gpu::GpuMat d_imgLeft(imgLeft); + cv::gpu::GpuMat d_imgRight(imgRight); + cv::gpu::GpuMat d_dst; + + d_bm(d_imgLeft, d_imgRight, d_dst); + + TEST_CYCLE() + { + d_bm(d_imgLeft, d_imgRight, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -75,20 +83,28 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(pair_string("gpu/ if (PERF_RUN_GPU()) { - cv::gpu::StereoBeliefPropagation d_bp(ndisp); - - cv::gpu::GpuMat d_imgLeft(imgLeft); - cv::gpu::GpuMat d_imgRight(imgRight); - cv::gpu::GpuMat d_dst; - - d_bp(d_imgLeft, d_imgRight, d_dst); - - TEST_CYCLE() + try { - d_bp(d_imgLeft, d_imgRight, d_dst); - } + cv::gpu::StereoBeliefPropagation d_bp(ndisp); - GPU_SANITY_CHECK(d_dst); + cv::gpu::GpuMat d_imgLeft(imgLeft); + cv::gpu::GpuMat d_imgRight(imgRight); + cv::gpu::GpuMat d_dst; + + d_bp(d_imgLeft, d_imgRight, d_dst); + + TEST_CYCLE() + { + d_bp(d_imgLeft, d_imgRight, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -113,20 +129,28 @@ PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(pair_string("gpu/st if (PERF_RUN_GPU()) { - cv::gpu::StereoConstantSpaceBP d_csbp(ndisp); - - cv::gpu::GpuMat d_imgLeft(imgLeft); - cv::gpu::GpuMat d_imgRight(imgRight); - cv::gpu::GpuMat d_dst; - - d_csbp(d_imgLeft, d_imgRight, d_dst); - - TEST_CYCLE() + try { - d_csbp(d_imgLeft, d_imgRight, d_dst); - } + cv::gpu::StereoConstantSpaceBP d_csbp(ndisp); - GPU_SANITY_CHECK(d_dst); + cv::gpu::GpuMat d_imgLeft(imgLeft); + cv::gpu::GpuMat d_imgRight(imgRight); + cv::gpu::GpuMat d_dst; + + d_csbp(d_imgLeft, d_imgRight, d_dst); + + TEST_CYCLE() + { + d_csbp(d_imgLeft, d_imgRight, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -149,20 +173,28 @@ PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(pair_string("gpu if (PERF_RUN_GPU()) { - cv::gpu::DisparityBilateralFilter d_filter(ndisp); - - cv::gpu::GpuMat d_img(img); - cv::gpu::GpuMat d_disp(disp); - cv::gpu::GpuMat d_dst; - - d_filter(d_disp, d_img, d_dst); - - TEST_CYCLE() + try { - d_filter(d_disp, d_img, d_dst); - } + cv::gpu::DisparityBilateralFilter d_filter(ndisp); - GPU_SANITY_CHECK(d_dst); + cv::gpu::GpuMat d_img(img); + cv::gpu::GpuMat d_disp(disp); + cv::gpu::GpuMat d_dst; + + d_filter(d_disp, d_img, d_dst); + + TEST_CYCLE() + { + d_filter(d_disp, d_img, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -187,17 +219,25 @@ PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000)) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::transformPoints(d_src, rvec, tvec, d_dst); - - TEST_CYCLE() + try { - cv::gpu::transformPoints(d_src, rvec, tvec, d_dst); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::transformPoints(d_src, rvec, tvec, d_dst); + + TEST_CYCLE() + { + cv::gpu::transformPoints(d_src, rvec, tvec, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -221,17 +261,25 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000)) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst); - - TEST_CYCLE() + try { - cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst); + + TEST_CYCLE() + { + cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -283,11 +331,19 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000)) if (PERF_RUN_GPU()) { - cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec); - - TEST_CYCLE() + try { cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec); + + TEST_CYCLE() + { + cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -320,17 +376,25 @@ PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::reprojectImageTo3D(d_src, d_dst, Q); - - TEST_CYCLE() + try { - cv::gpu::reprojectImageTo3D(d_src, d_dst, Q); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::reprojectImageTo3D(d_src, d_dst, Q); + + TEST_CYCLE() + { + cv::gpu::reprojectImageTo3D(d_src, d_dst, Q); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -360,17 +424,25 @@ PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Valu if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::drawColorDisp(d_src, d_dst, 255); - - TEST_CYCLE() + try { - cv::gpu::drawColorDisp(d_src, d_dst, 255); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::drawColorDisp(d_src, d_dst, 255); + + TEST_CYCLE() + { + cv::gpu::drawColorDisp(d_src, d_dst, 255); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { diff --git a/modules/gpu/perf/perf_core.cpp b/modules/gpu/perf/perf_core.cpp index ad722fa3b..92d87c2e2 100644 --- a/modules/gpu/perf/perf_core.cpp +++ b/modules/gpu/perf/perf_core.cpp @@ -22,15 +22,23 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Merge, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D if (PERF_RUN_GPU()) { - std::vector d_src(channels); - for (int i = 0; i < channels; ++i) - d_src[i].upload(src[i]); + try + { + std::vector d_src(channels); + for (int i = 0; i < channels; ++i) + d_src[i].upload(src[i]); - cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::merge(d_src, d_dst); + TEST_CYCLE() cv::gpu::merge(d_src, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-12); + GPU_SANITY_CHECK(d_dst, 1e-12); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -55,14 +63,22 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Split, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); + try + { + cv::gpu::GpuMat d_src(src); - std::vector d_dst; + std::vector d_dst; - TEST_CYCLE() cv::gpu::split(d_src, d_dst); + TEST_CYCLE() cv::gpu::split(d_src, d_dst); - cv::gpu::GpuMat first = d_dst[0]; - GPU_SANITY_CHECK(first, 1e-12); + cv::gpu::GpuMat first = d_dst[0]; + GPU_SANITY_CHECK(first, 1e-12); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -90,13 +106,21 @@ PERF_TEST_P(Sz_Depth, Core_AddMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEP if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst); + TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -123,12 +147,20 @@ PERF_TEST_P(Sz_Depth, Core_AddScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_ if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::add(d_src, s, d_dst); + TEST_CYCLE() cv::gpu::add(d_src, s, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -156,13 +188,21 @@ PERF_TEST_P(Sz_Depth, Core_SubtractMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst); + TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -189,12 +229,20 @@ PERF_TEST_P(Sz_Depth, Core_SubtractScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst); + TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -222,13 +270,21 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst); + TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -255,14 +311,22 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - cv::gpu::multiply(d_src, s, d_dst); + cv::gpu::multiply(d_src, s, d_dst); - TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst); + TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -290,13 +354,21 @@ PERF_TEST_P(Sz_Depth, Core_DivideMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_ if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst); + TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -323,12 +395,20 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_M if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst); + TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -355,12 +435,20 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalarInv, Combine(GPU_TYPICAL_MAT_SIZES, ARITH if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst); + TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -388,13 +476,21 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst); + TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -421,12 +517,20 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_ if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst); + TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -451,12 +555,20 @@ PERF_TEST_P(Sz_Depth, Core_Abs, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_16S, CV if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::abs(d_src, d_dst); + TEST_CYCLE() cv::gpu::abs(d_src, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else FAIL_NO_CPU(); } @@ -474,12 +586,20 @@ PERF_TEST_P(Sz_Depth, Core_Sqr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_ if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::sqr(d_src, d_dst); + TEST_CYCLE() cv::gpu::sqr(d_src, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else FAIL_NO_CPU(); } @@ -497,12 +617,20 @@ PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst); + TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -527,12 +655,20 @@ PERF_TEST_P(Sz_Depth, Core_Log, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_ if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::log(d_src, d_dst); + TEST_CYCLE() cv::gpu::log(d_src, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -557,12 +693,20 @@ PERF_TEST_P(Sz_Depth, Core_Exp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_ if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::exp(d_src, d_dst); + TEST_CYCLE() cv::gpu::exp(d_src, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -590,12 +734,20 @@ PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8 if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst); + TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -629,13 +781,21 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITH if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code); + TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -663,12 +823,20 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar, Combine(GPU_TYPICAL_MAT_SIZES, AR if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code); + TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -693,12 +861,20 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseNot, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_ if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst); + TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -726,13 +902,21 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseAndMat, Combine(GPU_TYPICAL_MAT_SIZES, Values( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst); + TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -760,12 +944,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine(GPU_TYPICAL_MAT_SIZES, V if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst); + TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -793,13 +985,21 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseOrMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(C if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst); + TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -829,12 +1029,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine(GPU_TYPICAL_MAT_SIZES, Va if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst); + TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -862,13 +1070,21 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseXorMat, Combine(GPU_TYPICAL_MAT_SIZES, Values( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst); + TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -896,12 +1112,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine(GPU_TYPICAL_MAT_SIZES, V if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst); + TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -931,12 +1155,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_RShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8 if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst); + TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -962,12 +1194,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_LShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8 if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst); + TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -991,13 +1231,21 @@ PERF_TEST_P(Sz_Depth, Core_MinMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst); + TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1024,12 +1272,20 @@ PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8 if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::min(d_src, val,d_dst); + TEST_CYCLE() cv::gpu::min(d_src, val,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1057,13 +1313,21 @@ PERF_TEST_P(Sz_Depth, Core_MaxMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst); + TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1090,12 +1354,20 @@ PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8 if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::max(d_src, val,d_dst); + TEST_CYCLE() cv::gpu::max(d_src, val,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1131,13 +1403,21 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth); + TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1152,6 +1432,8 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine( ////////////////////////////////////////////////////////////////////// // GEMM +#ifdef HAVE_CUBLAS + CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T) #define ALL_GEMM_FLAGS Values(0, CV_GEMM_A_T, CV_GEMM_B_T, CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T, CV_GEMM_A_T | CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T) @@ -1179,14 +1461,22 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_src3(src3); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_src3(src3); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags); + TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1200,6 +1490,8 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine( } } +#endif // HAVE_CUBLAS + ////////////////////////////////////////////////////////////////////// // Transpose @@ -1215,12 +1507,20 @@ PERF_TEST_P(Sz_Type, Core_Transpose, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::transpose(d_src,d_dst); + TEST_CYCLE() cv::gpu::transpose(d_src,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1259,12 +1559,20 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Core_Flip, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode); + TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1294,12 +1602,20 @@ PERF_TEST_P(Sz_Type, Core_LutOneChannel, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst); + TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1329,12 +1645,20 @@ PERF_TEST_P(Sz_Type, Core_LutMultiChannel, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst); + TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1358,12 +1682,20 @@ PERF_TEST_P(Sz, Core_MagnitudeComplex, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst); + TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1390,12 +1722,20 @@ PERF_TEST_P(Sz, Core_MagnitudeSqrComplex, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst); + TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1418,13 +1758,21 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst); + TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1433,7 +1781,6 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES) TEST_CYCLE() cv::magnitude(src1, src2, dst); CPU_SANITY_CHECK(dst, 1e-8); - } } @@ -1452,13 +1799,21 @@ PERF_TEST_P(Sz, Core_MagnitudeSqr, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst); + TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst); - GPU_SANITY_CHECK(d_dst); + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1484,13 +1839,21 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_Phase, Combine(GPU_TYPICAL_MAT_SIZES, Bool() if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees); + TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees); - GPU_SANITY_CHECK(d_dst, 1e-8); + GPU_SANITY_CHECK(d_dst, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1518,16 +1881,23 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_CartToPolar, Combine(GPU_TYPICAL_MAT_SIZES, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_magnitude; - cv::gpu::GpuMat d_angle; + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_magnitude; + cv::gpu::GpuMat d_angle; - TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees); - - GPU_SANITY_CHECK(d_magnitude, 1e-8); - GPU_SANITY_CHECK(d_angle, 1e-8); + TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees); + GPU_SANITY_CHECK(d_magnitude, 1e-8); + GPU_SANITY_CHECK(d_angle, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1557,15 +1927,23 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_PolarToCart, Combine(GPU_TYPICAL_MAT_SIZES, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_magnitude(magnitude); - cv::gpu::GpuMat d_angle(angle); - cv::gpu::GpuMat d_x; - cv::gpu::GpuMat d_y; + try + { + cv::gpu::GpuMat d_magnitude(magnitude); + cv::gpu::GpuMat d_angle(angle); + cv::gpu::GpuMat d_x; + cv::gpu::GpuMat d_y; - TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees); + TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees); - GPU_SANITY_CHECK(d_x, 1e-8); - GPU_SANITY_CHECK(d_y, 1e-8); + GPU_SANITY_CHECK(d_x, 1e-8); + GPU_SANITY_CHECK(d_y, 1e-8); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1594,10 +1972,18 @@ PERF_TEST_P(Sz, Core_MeanStdDev, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_buf; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_buf; - TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf); + TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1628,10 +2014,18 @@ PERF_TEST_P(Sz_Depth_Norm, Core_Norm, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_buf; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_buf; - TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf); + TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1663,11 +2057,18 @@ PERF_TEST_P(Sz_Norm, Core_NormDiff, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - - TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType); + try + { + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1698,10 +2099,18 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_buf; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_buf; - TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf); + TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1732,12 +2141,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_buf; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_buf; - TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf); + TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf); - SANITY_CHECK(dst, 1e-6); + SANITY_CHECK(dst, 1e-6); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1766,12 +2183,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_buf; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_buf; - TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf); + TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf); - SANITY_CHECK(dst, 1e-6); + SANITY_CHECK(dst, 1e-6); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1796,13 +2221,21 @@ PERF_TEST_P(Sz_Depth, Core_MinMax, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_buf; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_buf; - TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf); + TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf); - SANITY_CHECK(minVal); - SANITY_CHECK(maxVal); + SANITY_CHECK(minVal); + SANITY_CHECK(maxVal); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1828,10 +2261,18 @@ PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_valbuf, d_locbuf; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_valbuf, d_locbuf; - TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf); + TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1863,10 +2304,18 @@ PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_buf; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_buf; - TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf); + TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1908,12 +2357,20 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; + try + { + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp); + TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp); - GPU_SANITY_CHECK(d_dst, 1); + GPU_SANITY_CHECK(d_dst, 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { diff --git a/modules/gpu/perf/perf_denoising.cpp b/modules/gpu/perf/perf_denoising.cpp index ed63177dd..0be16cbfd 100644 --- a/modules/gpu/perf/perf_denoising.cpp +++ b/modules/gpu/perf/perf_denoising.cpp @@ -30,19 +30,27 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter, cv::Mat src(size, type); fillRandom(src); - if (PERF_RUN_GPU()) + if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode); - - TEST_CYCLE() + try { - cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode); + + TEST_CYCLE() + { + cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -87,17 +95,25 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode); - - TEST_CYCLE() + try { - cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode); + + TEST_CYCLE() + { + cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -130,18 +146,26 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::FastNonLocalMeansDenoising fnlmd; - - fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size); - - TEST_CYCLE() + try { - fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::FastNonLocalMeansDenoising fnlmd; - GPU_SANITY_CHECK(d_dst); + fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size); + + TEST_CYCLE() + { + fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -181,18 +205,26 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::FastNonLocalMeansDenoising fnlmd; - - fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size); - - TEST_CYCLE() + try { - fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::FastNonLocalMeansDenoising fnlmd; - GPU_SANITY_CHECK(d_dst); + fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size); + + TEST_CYCLE() + { + fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -206,4 +238,4 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored, CPU_SANITY_CHECK(dst); } -} \ No newline at end of file +} diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp index a93cef9b3..a0ecf0435 100644 --- a/modules/gpu/perf/perf_features2d.cpp +++ b/modules/gpu/perf/perf_features2d.cpp @@ -19,20 +19,28 @@ PERF_TEST_P(Image, Features2D_SURF, Values("gpu/perf/aloe.png")) if (PERF_RUN_GPU()) { - cv::gpu::SURF_GPU d_surf; - - cv::gpu::GpuMat d_img(img); - cv::gpu::GpuMat d_keypoints, d_descriptors; - - d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors); - - TEST_CYCLE() + try { - d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors); - } + cv::gpu::SURF_GPU d_surf; - GPU_SANITY_CHECK(d_descriptors, 1e-4); - GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints); + cv::gpu::GpuMat d_img(img); + cv::gpu::GpuMat d_keypoints, d_descriptors; + + d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors); + + TEST_CYCLE() + { + d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors); + } + + GPU_SANITY_CHECK(d_descriptors, 1e-4); + GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -64,19 +72,27 @@ PERF_TEST_P(Image, Features2D_FAST, Values("gpu/perf/aloe.png")) if (PERF_RUN_GPU()) { - cv::gpu::FAST_GPU d_fast(20); - - cv::gpu::GpuMat d_img(img); - cv::gpu::GpuMat d_keypoints; - - d_fast(d_img, cv::gpu::GpuMat(), d_keypoints); - - TEST_CYCLE() + try { - d_fast(d_img, cv::gpu::GpuMat(), d_keypoints); - } + cv::gpu::FAST_GPU d_fast(20); - GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints); + cv::gpu::GpuMat d_img(img); + cv::gpu::GpuMat d_keypoints; + + d_fast(d_img, cv::gpu::GpuMat(), d_keypoints); + + TEST_CYCLE() + { + d_fast(d_img, cv::gpu::GpuMat(), d_keypoints); + } + + GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -104,20 +120,28 @@ PERF_TEST_P(Image, Features2D_ORB, Values("gpu/perf/aloe.png")) if (PERF_RUN_GPU()) { - cv::gpu::ORB_GPU d_orb(4000); - - cv::gpu::GpuMat d_img(img); - cv::gpu::GpuMat d_keypoints, d_descriptors; - - d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors); - - TEST_CYCLE() + try { - d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors); - } + cv::gpu::ORB_GPU d_orb(4000); - GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints); - GPU_SANITY_CHECK(d_descriptors); + cv::gpu::GpuMat d_img(img); + cv::gpu::GpuMat d_keypoints, d_descriptors; + + d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors); + + TEST_CYCLE() + { + d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors); + } + + GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints); + GPU_SANITY_CHECK(d_descriptors); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -161,21 +185,29 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val if (PERF_RUN_GPU()) { - cv::gpu::BFMatcher_GPU d_matcher(normType); - - cv::gpu::GpuMat d_query(query); - cv::gpu::GpuMat d_train(train); - cv::gpu::GpuMat d_trainIdx, d_distance; - - d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance); - - TEST_CYCLE() + try { - d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance); - } + cv::gpu::BFMatcher_GPU d_matcher(normType); - GPU_SANITY_CHECK(d_trainIdx); - GPU_SANITY_CHECK(d_distance); + cv::gpu::GpuMat d_query(query); + cv::gpu::GpuMat d_train(train); + cv::gpu::GpuMat d_trainIdx, d_distance; + + d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance); + + TEST_CYCLE() + { + d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance); + } + + GPU_SANITY_CHECK(d_trainIdx); + GPU_SANITY_CHECK(d_distance); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -220,21 +252,29 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine( if (PERF_RUN_GPU()) { - cv::gpu::BFMatcher_GPU d_matcher(normType); - - cv::gpu::GpuMat d_query(query); - cv::gpu::GpuMat d_train(train); - cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist; - - d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k); - - TEST_CYCLE() + try { - d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k); - } + cv::gpu::BFMatcher_GPU d_matcher(normType); - GPU_SANITY_CHECK(d_trainIdx); - GPU_SANITY_CHECK(d_distance); + cv::gpu::GpuMat d_query(query); + cv::gpu::GpuMat d_train(train); + cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist; + + d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k); + + TEST_CYCLE() + { + d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k); + } + + GPU_SANITY_CHECK(d_trainIdx); + GPU_SANITY_CHECK(d_distance); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -273,21 +313,29 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256 if (PERF_RUN_GPU()) { - cv::gpu::BFMatcher_GPU d_matcher(normType); - - cv::gpu::GpuMat d_query(query); - cv::gpu::GpuMat d_train(train); - cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance; - - d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0); - - TEST_CYCLE() + try { - d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0); - } + cv::gpu::BFMatcher_GPU d_matcher(normType); - GPU_SANITY_CHECK(d_trainIdx); - GPU_SANITY_CHECK(d_distance); + cv::gpu::GpuMat d_query(query); + cv::gpu::GpuMat d_train(train); + cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance; + + d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0); + + TEST_CYCLE() + { + d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0); + } + + GPU_SANITY_CHECK(d_trainIdx); + GPU_SANITY_CHECK(d_distance); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp index 7faf93e97..47265fe11 100644 --- a/modules/gpu/perf/perf_filters.cpp +++ b/modules/gpu/perf/perf_filters.cpp @@ -23,17 +23,25 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Value if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize)); - - TEST_CYCLE() + try { - cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize)); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize)); + + TEST_CYCLE() + { + cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize)); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -66,18 +74,26 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Valu if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_buf; - - cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize); - - TEST_CYCLE() + try { - cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize); + + TEST_CYCLE() + { + cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -109,18 +125,26 @@ PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_buf; - - cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf); - - TEST_CYCLE() + try { - cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf); + + TEST_CYCLE() + { + cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -153,18 +177,26 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZE if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_buf; - - cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5); - - TEST_CYCLE() + try { - cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5); + + TEST_CYCLE() + { + cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -197,17 +229,25 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::Laplacian(d_src, d_dst, -1, ksize); - - TEST_CYCLE() + try { - cv::gpu::Laplacian(d_src, d_dst, -1, ksize); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::Laplacian(d_src, d_dst, -1, ksize); + + TEST_CYCLE() + { + cv::gpu::Laplacian(d_src, d_dst, -1, ksize); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -241,18 +281,26 @@ PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_buf; - - cv::gpu::erode(d_src, d_dst, ker, d_buf); - - TEST_CYCLE() + try { - cv::gpu::erode(d_src, d_dst, ker, d_buf); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::erode(d_src, d_dst, ker, d_buf); + + TEST_CYCLE() + { + cv::gpu::erode(d_src, d_dst, ker, d_buf); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -286,18 +334,26 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_buf; - - cv::gpu::dilate(d_src, d_dst, ker, d_buf); - - TEST_CYCLE() + try { - cv::gpu::dilate(d_src, d_dst, ker, d_buf); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::dilate(d_src, d_dst, ker, d_buf); + + TEST_CYCLE() + { + cv::gpu::dilate(d_src, d_dst, ker, d_buf); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -337,19 +393,27 @@ PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Val if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_buf1; - cv::gpu::GpuMat d_buf2; - - cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2); - - TEST_CYCLE() + try { - cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_buf1; + cv::gpu::GpuMat d_buf2; - GPU_SANITY_CHECK(d_dst); + cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2); + + TEST_CYCLE() + { + cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -385,17 +449,25 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, V if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::filter2D(d_src, d_dst, -1, kernel); - - TEST_CYCLE() + try { - cv::gpu::filter2D(d_src, d_dst, -1, kernel); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::filter2D(d_src, d_dst, -1, kernel); + + TEST_CYCLE() + { + cv::gpu::filter2D(d_src, d_dst, -1, kernel); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp index ee0968442..545b8df5a 100644 --- a/modules/gpu/perf/perf_imgproc.cpp +++ b/modules/gpu/perf/perf_imgproc.cpp @@ -80,19 +80,27 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_xmap(xmap); - cv::gpu::GpuMat d_ymap(ymap); - cv::gpu::GpuMat d_dst; - - cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode); - - TEST_CYCLE() + try { - cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_xmap(xmap); + cv::gpu::GpuMat d_ymap(ymap); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode); + + TEST_CYCLE() + { + cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -134,17 +142,25 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation); - - TEST_CYCLE() + try { - cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation); + + TEST_CYCLE() + { + cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -185,17 +201,25 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation); - - TEST_CYCLE() + try { - cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation); + + TEST_CYCLE() + { + cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -242,17 +266,25 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode); - - TEST_CYCLE() + try { - cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode); + + TEST_CYCLE() + { + cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -298,17 +330,25 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode); - - TEST_CYCLE() + try { - cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode); + + TEST_CYCLE() + { + cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -346,17 +386,25 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode); - - TEST_CYCLE() + try { - cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode); + + TEST_CYCLE() + { + cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -393,17 +441,25 @@ PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp); - - TEST_CYCLE() + try { - cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp); + + TEST_CYCLE() + { + cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -430,18 +486,26 @@ PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_buf; - - cv::gpu::integralBuffered(d_src, d_dst, d_buf); - - TEST_CYCLE() + try { - cv::gpu::integralBuffered(d_src, d_dst, d_buf); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::integralBuffered(d_src, d_dst, d_buf); + + TEST_CYCLE() + { + cv::gpu::integralBuffered(d_src, d_dst, d_buf); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -468,17 +532,25 @@ PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::sqrIntegral(d_src, d_dst); - - TEST_CYCLE() + try { - cv::gpu::sqrIntegral(d_src, d_dst); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::sqrIntegral(d_src, d_dst); + + TEST_CYCLE() + { + cv::gpu::sqrIntegral(d_src, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -499,18 +571,26 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_hist; - cv::gpu::GpuMat d_buf; - - cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180); - - TEST_CYCLE() + try { - cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_hist; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_hist); + cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180); + + TEST_CYCLE() + { + cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180); + } + + GPU_SANITY_CHECK(d_hist); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -548,18 +628,26 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_hist[4]; - cv::gpu::GpuMat d_buf, d_hist0; - - cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel); - - TEST_CYCLE() + try { - cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_hist[4]; + cv::gpu::GpuMat d_buf, d_hist0; - GPU_SANITY_CHECK(d_hist0); + cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel); + + TEST_CYCLE() + { + cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel); + } + + GPU_SANITY_CHECK(d_hist0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -579,17 +667,25 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_hist; - - cv::gpu::calcHist(d_src, d_hist); - - TEST_CYCLE() + try { - cv::gpu::calcHist(d_src, d_hist); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_hist; - GPU_SANITY_CHECK(d_hist); + cv::gpu::calcHist(d_src, d_hist); + + TEST_CYCLE() + { + cv::gpu::calcHist(d_src, d_hist); + } + + GPU_SANITY_CHECK(d_hist); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -609,19 +705,27 @@ PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_hist; - cv::gpu::GpuMat d_buf; - - cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf); - - TEST_CYCLE() + try { - cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_hist; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_hist); + cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf); + + TEST_CYCLE() + { + cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf); + } + + GPU_SANITY_CHECK(d_hist); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -648,17 +752,25 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::columnSum(d_src, d_dst); - - TEST_CYCLE() + try { - cv::gpu::columnSum(d_src, d_dst); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::columnSum(d_src, d_dst); + + TEST_CYCLE() + { + cv::gpu::columnSum(d_src, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -685,18 +797,26 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_image(image); - cv::gpu::GpuMat d_dst; - cv::gpu::CannyBuf d_buf; - - cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient); - - TEST_CYCLE() + try { - cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient); - } + cv::gpu::GpuMat d_image(image); + cv::gpu::GpuMat d_dst; + cv::gpu::CannyBuf d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient); + + TEST_CYCLE() + { + cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -728,17 +848,25 @@ PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values("gpu/meanshift/con if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(rgba); - cv::gpu::GpuMat d_dst; - - cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50); - - TEST_CYCLE() + try { - cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50); - } + cv::gpu::GpuMat d_src(rgba); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50); + + TEST_CYCLE() + { + cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -768,18 +896,26 @@ PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values("gpu/meanshift/cones.pn if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(rgba); - cv::gpu::GpuMat d_dstr; - cv::gpu::GpuMat d_dstsp; - - cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50); - - TEST_CYCLE() + try { - cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50); - } + cv::gpu::GpuMat d_src(rgba); + cv::gpu::GpuMat d_dstr; + cv::gpu::GpuMat d_dstsp; - GPU_SANITY_CHECK(d_dstr); + cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50); + + TEST_CYCLE() + { + cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50); + } + + GPU_SANITY_CHECK(d_dstr); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -804,16 +940,24 @@ PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values("gpu/meanshift/ if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(rgba); - - cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20); - - TEST_CYCLE() + try { - cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20); - } + cv::gpu::GpuMat d_src(rgba); - GPU_SANITY_CHECK(dst); + cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20); + + TEST_CYCLE() + { + cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20); + } + + GPU_SANITY_CHECK(dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -840,20 +984,28 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Val if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_img1(img1); - cv::gpu::GpuMat d_img2(img2); - cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5)); - cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5)); - cv::gpu::GpuMat d_dst; - - cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst); - - TEST_CYCLE() + try { - cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst); - } + cv::gpu::GpuMat d_img1(img1); + cv::gpu::GpuMat d_img2(img2); + cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5)); + cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5)); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst); + + TEST_CYCLE() + { + cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -882,23 +1034,31 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1); - d_image.upload(image); - - cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1); - d_templ.upload(templ); - - cv::gpu::GpuMat d_dst; - cv::gpu::ConvolveBuf d_buf; - - cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf); - - TEST_CYCLE() + try { - cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf); - } + cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1); + d_image.upload(image); - GPU_SANITY_CHECK(d_dst); + cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1); + d_templ.upload(templ); + + cv::gpu::GpuMat d_dst; + cv::gpu::ConvolveBuf d_buf; + + cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf); + + TEST_CYCLE() + { + cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -944,18 +1104,26 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_image(image); - cv::gpu::GpuMat d_templ(templ); - cv::gpu::GpuMat d_dst; - - cv::gpu::matchTemplate(d_image, d_templ, d_dst, method); - - TEST_CYCLE() + try { - cv::gpu::matchTemplate(d_image, d_templ, d_dst, method); - } + cv::gpu::GpuMat d_image(image); + cv::gpu::GpuMat d_templ(templ); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::matchTemplate(d_image, d_templ, d_dst, method); + + TEST_CYCLE() + { + cv::gpu::matchTemplate(d_image, d_templ, d_dst, method); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -994,18 +1162,26 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_image(image); - cv::gpu::GpuMat d_templ(templ); - cv::gpu::GpuMat d_dst; - - cv::gpu::matchTemplate(d_image, d_templ, d_dst, method); - - TEST_CYCLE() + try { - cv::gpu::matchTemplate(d_image, d_templ, d_dst, method); - } + cv::gpu::GpuMat d_image(image); + cv::gpu::GpuMat d_templ(templ); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::matchTemplate(d_image, d_templ, d_dst, method); + + TEST_CYCLE() + { + cv::gpu::matchTemplate(d_image, d_templ, d_dst, method); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1044,18 +1220,26 @@ PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_a(a); - cv::gpu::GpuMat d_b(b); - cv::gpu::GpuMat d_dst; - - cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag); - - TEST_CYCLE() + try { - cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag); - } + cv::gpu::GpuMat d_a(a); + cv::gpu::GpuMat d_b(b); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag); + + TEST_CYCLE() + { + cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1089,18 +1273,26 @@ PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src1(src1); - cv::gpu::GpuMat d_src2(src2); - cv::gpu::GpuMat d_dst; - - cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false); - - TEST_CYCLE() + try { - cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false); - } + cv::gpu::GpuMat d_src1(src1); + cv::gpu::GpuMat d_src2(src2); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false); + + TEST_CYCLE() + { + cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1125,17 +1317,25 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::dft(d_src, d_dst, size, flag); - - TEST_CYCLE() + try { - cv::gpu::dft(d_src, d_dst, size, flag); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::dft(d_src, d_dst, size, flag); + + TEST_CYCLE() + { + cv::gpu::dft(d_src, d_dst, size, flag); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1178,20 +1378,28 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_img(img); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_Dx; - cv::gpu::GpuMat d_Dy; - cv::gpu::GpuMat d_buf; - - cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode); - - TEST_CYCLE() + try { - cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode); - } + cv::gpu::GpuMat d_img(img); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_Dx; + cv::gpu::GpuMat d_Dy; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode); + + TEST_CYCLE() + { + cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1231,20 +1439,28 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Com if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_img(img); - cv::gpu::GpuMat d_dst; - cv::gpu::GpuMat d_Dx; - cv::gpu::GpuMat d_Dy; - cv::gpu::GpuMat d_buf; - - cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode); - - TEST_CYCLE() + try { - cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode); - } + cv::gpu::GpuMat d_img(img); + cv::gpu::GpuMat d_dst; + cv::gpu::GpuMat d_Dx; + cv::gpu::GpuMat d_Dy; + cv::gpu::GpuMat d_buf; - GPU_SANITY_CHECK(d_dst); + cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode); + + TEST_CYCLE() + { + cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1274,18 +1490,26 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_map_x; - cv::gpu::GpuMat d_map_y; - - cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y); - - TEST_CYCLE() + try { - cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y); - } + cv::gpu::GpuMat d_map_x; + cv::gpu::GpuMat d_map_y; - GPU_SANITY_CHECK(d_map_x); - GPU_SANITY_CHECK(d_map_y); + cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y); + + TEST_CYCLE() + { + cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y); + } + + GPU_SANITY_CHECK(d_map_x); + GPU_SANITY_CHECK(d_map_y); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1305,18 +1529,26 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_map_x; - cv::gpu::GpuMat d_map_y; - - cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y); - - TEST_CYCLE() + try { - cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y); - } + cv::gpu::GpuMat d_map_x; + cv::gpu::GpuMat d_map_y; - GPU_SANITY_CHECK(d_map_x); - GPU_SANITY_CHECK(d_map_y); + cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y); + + TEST_CYCLE() + { + cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y); + } + + GPU_SANITY_CHECK(d_map_x); + GPU_SANITY_CHECK(d_map_y); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1336,19 +1568,26 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_map_x; - cv::gpu::GpuMat d_map_y; - - cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y); - - TEST_CYCLE() + try { + cv::gpu::GpuMat d_map_x; + cv::gpu::GpuMat d_map_y; + cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y); + + TEST_CYCLE() + { + cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y); + } + + GPU_SANITY_CHECK(d_map_x); + GPU_SANITY_CHECK(d_map_y); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } - - GPU_SANITY_CHECK(d_map_x); - GPU_SANITY_CHECK(d_map_y); - } else { @@ -1379,17 +1618,25 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation); - - TEST_CYCLE() + try { - cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation); + + TEST_CYCLE() + { + cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1416,17 +1663,25 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::pyrDown(d_src, d_dst); - - TEST_CYCLE() + try { - cv::gpu::pyrDown(d_src, d_dst); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::pyrDown(d_src, d_dst); + + TEST_CYCLE() + { + cv::gpu::pyrDown(d_src, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1462,17 +1717,25 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::pyrUp(d_src, d_dst); - - TEST_CYCLE() + try { - cv::gpu::pyrUp(d_src, d_dst); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::pyrUp(d_src, d_dst); + + TEST_CYCLE() + { + cv::gpu::pyrUp(d_src, d_dst); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1533,17 +1796,25 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn); - - TEST_CYCLE() + try { - cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn); + + TEST_CYCLE() + { + cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1574,16 +1845,24 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - - cv::gpu::swapChannels(d_src, dstOrder); - - TEST_CYCLE() + try { - cv::gpu::swapChannels(d_src, dstOrder); - } + cv::gpu::GpuMat d_src(src); - GPU_SANITY_CHECK(d_src); + cv::gpu::swapChannels(d_src, dstOrder); + + TEST_CYCLE() + { + cv::gpu::swapChannels(d_src, dstOrder); + } + + GPU_SANITY_CHECK(d_src); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1613,18 +1892,26 @@ PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_img1(img1); - cv::gpu::GpuMat d_img2(img2); - cv::gpu::GpuMat d_dst; - - cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op); - - TEST_CYCLE() + try { - cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op); - } + cv::gpu::GpuMat d_img1(img1); + cv::gpu::GpuMat d_img2(img2); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op); + + TEST_CYCLE() + { + cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1648,18 +1935,26 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZE if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - - cv::gpu::ImagePyramid d_pyr; - - d_pyr.build(d_src, 5); - - TEST_CYCLE() + try { - d_pyr.build(d_src, 5); - } + cv::gpu::GpuMat d_src(src); - GPU_SANITY_CHECK(d_src); + cv::gpu::ImagePyramid d_pyr; + + d_pyr.build(d_src, 5); + + TEST_CYCLE() + { + d_pyr.build(d_src, 5); + } + + GPU_SANITY_CHECK(d_src); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1685,19 +1980,27 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - cv::gpu::ImagePyramid d_pyr(d_src, 3); - - d_pyr.getLayer(d_dst, dstSize); - - TEST_CYCLE() + try { - d_pyr.getLayer(d_dst, dstSize); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + cv::gpu::ImagePyramid d_pyr(d_src, 3); + + d_pyr.getLayer(d_dst, dstSize); + + TEST_CYCLE() + { + d_pyr.getLayer(d_dst, dstSize); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1762,22 +2065,30 @@ PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_lines; - cv::gpu::HoughLinesBuf d_buf; - - cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold); - - TEST_CYCLE() + try { - cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_lines; + cv::gpu::HoughLinesBuf d_buf; - cv::Mat h_lines(d_lines); - cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr(0)); - cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr(0) + (h_lines.cols) * 2 * sizeof(float)); - std::sort(begin, end, Vec2fComparator()); - SANITY_CHECK(h_lines); + cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold); + + TEST_CYCLE() + { + cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold); + } + + cv::Mat h_lines(d_lines); + cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr(0)); + cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr(0) + (h_lines.cols) * 2 * sizeof(float)); + std::sort(begin, end, Vec2fComparator()); + SANITY_CHECK(h_lines); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1818,22 +2129,30 @@ PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "s if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_mask(mask); - cv::gpu::GpuMat d_lines; - cv::gpu::HoughLinesBuf d_buf; - - cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap); - - TEST_CYCLE() + try { - cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap); - } + cv::gpu::GpuMat d_mask(mask); + cv::gpu::GpuMat d_lines; + cv::gpu::HoughLinesBuf d_buf; - cv::Mat h_lines(d_lines); - cv::Vec4i* begin = h_lines.ptr(); - cv::Vec4i* end = h_lines.ptr() + h_lines.cols; - std::sort(begin, end, Vec4iComparator()); - SANITY_CHECK(h_lines); + cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap); + + TEST_CYCLE() + { + cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap); + } + + cv::Mat h_lines(d_lines); + cv::Vec4i* begin = h_lines.ptr(); + cv::Vec4i* end = h_lines.ptr() + h_lines.cols; + std::sort(begin, end, Vec4iComparator()); + SANITY_CHECK(h_lines); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1883,22 +2202,30 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_circles; - cv::gpu::HoughCirclesBuf d_buf; - - cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius); - - TEST_CYCLE() + try { - cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_circles; + cv::gpu::HoughCirclesBuf d_buf; - cv::Mat h_circles(d_circles); - cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr(0)); - cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr(0) + (h_circles.cols) * 3 * sizeof(float)); - std::sort(begin, end, Vec3fComparator()); - SANITY_CHECK(h_circles); + cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius); + + TEST_CYCLE() + { + cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius); + } + + cv::Mat h_circles(d_circles); + cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr(0)); + cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr(0) + (h_circles.cols) * 3 * sizeof(float)); + std::sort(begin, end, Vec3fComparator()); + SANITY_CHECK(h_circles); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -1967,28 +2294,36 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_edges(edges); - cv::gpu::GpuMat d_dx(dx); - cv::gpu::GpuMat d_dy(dy); - cv::gpu::GpuMat d_position; - - cv::Ptr d_hough = cv::gpu::GeneralizedHough_GPU::create(method); - if (method & cv::GHT_ROTATION) + try { - d_hough->set("maxAngle", 90.0); - d_hough->set("angleStep", 2.0); - } + cv::gpu::GpuMat d_edges(edges); + cv::gpu::GpuMat d_dx(dx); + cv::gpu::GpuMat d_dy(dy); + cv::gpu::GpuMat d_position; - d_hough->setTemplate(cv::gpu::GpuMat(templ)); + cv::Ptr d_hough = cv::gpu::GeneralizedHough_GPU::create(method); + if (method & cv::GHT_ROTATION) + { + d_hough->set("maxAngle", 90.0); + d_hough->set("angleStep", 2.0); + } - d_hough->detect(d_edges, d_dx, d_dy, d_position); + d_hough->setTemplate(cv::gpu::GpuMat(templ)); - TEST_CYCLE() - { d_hough->detect(d_edges, d_dx, d_dy, d_position); - } - GPU_SANITY_CHECK(d_position); + TEST_CYCLE() + { + d_hough->detect(d_edges, d_dx, d_dy, d_position); + } + + GPU_SANITY_CHECK(d_position); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { diff --git a/modules/gpu/perf/perf_labeling.cpp b/modules/gpu/perf/perf_labeling.cpp index 3b10ba3be..0fb81aa13 100644 --- a/modules/gpu/perf/perf_labeling.cpp +++ b/modules/gpu/perf/perf_labeling.cpp @@ -108,22 +108,30 @@ PERF_TEST_P(Image, Labeling_ConnectedComponents, Values("gpu/labeling/al if (PERF_RUN_GPU()) { - cv::gpu::GpuMat mask; - mask.create(image.rows, image.cols, CV_8UC1); - - cv::gpu::GpuMat components; - components.create(image.rows, image.cols, CV_32SC1); - - cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2)); - - ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components)); - - TEST_CYCLE() + try { - cv::gpu::labelComponents(mask, components); - } + cv::gpu::GpuMat mask; + mask.create(image.rows, image.cols, CV_8UC1); - GPU_SANITY_CHECK(components); + cv::gpu::GpuMat components; + components.create(image.rows, image.cols, CV_32SC1); + + cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2)); + + ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components)); + + TEST_CYCLE() + { + cv::gpu::labelComponents(mask, components); + } + + GPU_SANITY_CHECK(components); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { diff --git a/modules/gpu/perf/perf_matop.cpp b/modules/gpu/perf/perf_matop.cpp index b6d4a110f..97f6dd1d1 100644 --- a/modules/gpu/perf/perf_matop.cpp +++ b/modules/gpu/perf/perf_matop.cpp @@ -20,16 +20,24 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8 if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(size, type); - - d_src.setTo(val); - - TEST_CYCLE() + try { - d_src.setTo(val); - } + cv::gpu::GpuMat d_src(size, type); - GPU_SANITY_CHECK(d_src); + d_src.setTo(val); + + TEST_CYCLE() + { + d_src.setTo(val); + } + + GPU_SANITY_CHECK(d_src); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -67,17 +75,25 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_mask(mask); - - d_src.setTo(val, d_mask); - - TEST_CYCLE() + try { - d_src.setTo(val, d_mask); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_mask(mask); - GPU_SANITY_CHECK(d_src); + d_src.setTo(val, d_mask); + + TEST_CYCLE() + { + d_src.setTo(val, d_mask); + } + + GPU_SANITY_CHECK(d_src); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -111,18 +127,26 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_mask(mask); - cv::gpu::GpuMat d_dst; - - d_src.copyTo(d_dst, d_mask); - - TEST_CYCLE() + try { - d_src.copyTo(d_dst, d_mask); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_mask(mask); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + d_src.copyTo(d_dst, d_mask); + + TEST_CYCLE() + { + d_src.copyTo(d_dst, d_mask); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -155,17 +179,25 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_src(src); - cv::gpu::GpuMat d_dst; - - d_src.convertTo(d_dst, depth2, 0.5, 1.0); - - TEST_CYCLE() + try { - d_src.convertTo(d_dst, depth2, 0.5, 1.0); - } + cv::gpu::GpuMat d_src(src); + cv::gpu::GpuMat d_dst; - GPU_SANITY_CHECK(d_dst); + d_src.convertTo(d_dst, depth2, 0.5, 1.0); + + TEST_CYCLE() + { + d_src.convertTo(d_dst, depth2, 0.5, 1.0); + } + + GPU_SANITY_CHECK(d_dst); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp index 6d040ac02..4c74bba36 100644 --- a/modules/gpu/perf/perf_objdetect.cpp +++ b/modules/gpu/perf/perf_objdetect.cpp @@ -19,16 +19,24 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values("gpu/hog/road.png")) if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_img(img); - - cv::gpu::HOGDescriptor d_hog; - d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector()); - - d_hog.detectMultiScale(d_img, found_locations); - - TEST_CYCLE() + try { + cv::gpu::GpuMat d_img(img); + + cv::gpu::HOGDescriptor d_hog; + d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector()); + d_hog.detectMultiScale(d_img, found_locations); + + TEST_CYCLE() + { + d_hog.detectMultiScale(d_img, found_locations); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -61,16 +69,24 @@ PERF_TEST_P(HOG, CalTech, Values("gpu/caltech/image_00000009_0.png", "gp if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_img(img); - - cv::gpu::HOGDescriptor d_hog; - d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector()); - - d_hog.detectMultiScale(d_img, found_locations); - - TEST_CYCLE() + try { + cv::gpu::GpuMat d_img(img); + + cv::gpu::HOGDescriptor d_hog; + d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector()); + d_hog.detectMultiScale(d_img, found_locations); + + TEST_CYCLE() + { + d_hog.detectMultiScale(d_img, found_locations); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -103,20 +119,28 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier, if (PERF_RUN_GPU()) { - cv::gpu::CascadeClassifier_GPU d_cascade; - ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second))); - - cv::gpu::GpuMat d_img(img); - cv::gpu::GpuMat d_objects_buffer; - - d_cascade.detectMultiScale(d_img, d_objects_buffer); - - TEST_CYCLE() + try { - d_cascade.detectMultiScale(d_img, d_objects_buffer); - } + cv::gpu::CascadeClassifier_GPU d_cascade; + ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second))); - GPU_SANITY_CHECK(d_objects_buffer); + cv::gpu::GpuMat d_img(img); + cv::gpu::GpuMat d_objects_buffer; + + d_cascade.detectMultiScale(d_img, d_objects_buffer); + + TEST_CYCLE() + { + d_cascade.detectMultiScale(d_img, d_objects_buffer); + } + + GPU_SANITY_CHECK(d_objects_buffer); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -147,20 +171,28 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier, if (PERF_RUN_GPU()) { - cv::gpu::CascadeClassifier_GPU d_cascade; - ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second))); - - cv::gpu::GpuMat d_img(img); - cv::gpu::GpuMat d_gpu_rects; - - d_cascade.detectMultiScale(d_img, d_gpu_rects); - - TEST_CYCLE() + try { - d_cascade.detectMultiScale(d_img, d_gpu_rects); - } + cv::gpu::CascadeClassifier_GPU d_cascade; + ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second))); - GPU_SANITY_CHECK(d_gpu_rects); + cv::gpu::GpuMat d_img(img); + cv::gpu::GpuMat d_gpu_rects; + + d_cascade.detectMultiScale(d_img, d_gpu_rects); + + TEST_CYCLE() + { + d_cascade.detectMultiScale(d_img, d_gpu_rects); + } + + GPU_SANITY_CHECK(d_gpu_rects); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -180,4 +212,4 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier, } } -} // namespace \ No newline at end of file +} // namespace diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp index 9645beeaf..1d3ebe837 100644 --- a/modules/gpu/perf/perf_softcascade.cpp +++ b/modules/gpu/perf/perf_softcascade.cpp @@ -60,28 +60,36 @@ GPU_PERF_TEST_P(SCascadeTest, detect, RUN_GPU(SCascadeTest, detect) { - cv::Mat cpu = readImage (GET_PARAM(1)); - ASSERT_FALSE(cpu.empty()); - cv::gpu::GpuMat colored(cpu); - - cv::gpu::SCascade cascade; - - cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); - - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - - cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1); - rois.setTo(1); - - cascade.detect(colored, rois, objectBoxes); - - TEST_CYCLE() + try { - cascade.detect(colored, rois, objectBoxes); - } + cv::Mat cpu = readImage (GET_PARAM(1)); + ASSERT_FALSE(cpu.empty()); + cv::gpu::GpuMat colored(cpu); - SANITY_CHECK(sortDetections(objectBoxes)); + cv::gpu::SCascade cascade; + + cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); + + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + + cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1); + rois.setTo(1); + + cascade.detect(colored, rois, objectBoxes); + + TEST_CYCLE() + { + cascade.detect(colored, rois, objectBoxes); + } + + SANITY_CHECK(sortDetections(objectBoxes)); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } NO_CPU(SCascadeTest, detect) @@ -118,37 +126,45 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectInRoi, RUN_GPU(SCascadeTestRoi, detectInRoi) { - cv::Mat cpu = readImage (GET_PARAM(1)); - ASSERT_FALSE(cpu.empty()); - cv::gpu::GpuMat colored(cpu); - - cv::gpu::SCascade cascade; - - cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); - - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - - cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1); - rois.setTo(0); - - int nroi = GET_PARAM(2); - cv::RNG rng; - for (int i = 0; i < nroi; ++i) + try { - cv::Rect r = getFromTable(rng(10)); - cv::gpu::GpuMat sub(rois, r); - sub.setTo(1); - } + cv::Mat cpu = readImage (GET_PARAM(1)); + ASSERT_FALSE(cpu.empty()); + cv::gpu::GpuMat colored(cpu); - cascade.detect(colored, rois, objectBoxes); + cv::gpu::SCascade cascade; + + cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); + + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + + cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1); + rois.setTo(0); + + int nroi = GET_PARAM(2); + cv::RNG rng; + for (int i = 0; i < nroi; ++i) + { + cv::Rect r = getFromTable(rng(10)); + cv::gpu::GpuMat sub(rois, r); + sub.setTo(1); + } - TEST_CYCLE() - { cascade.detect(colored, rois, objectBoxes); - } - SANITY_CHECK(sortDetections(objectBoxes)); + TEST_CYCLE() + { + cascade.detect(colored, rois, objectBoxes); + } + + SANITY_CHECK(sortDetections(objectBoxes)); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } NO_CPU(SCascadeTestRoi, detectInRoi) @@ -163,33 +179,41 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectEachRoi, RUN_GPU(SCascadeTestRoi, detectEachRoi) { - cv::Mat cpu = readImage (GET_PARAM(1)); - ASSERT_FALSE(cpu.empty()); - cv::gpu::GpuMat colored(cpu); - - cv::gpu::SCascade cascade; - - cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); - - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - - cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1); - rois.setTo(0); - - int idx = GET_PARAM(2); - cv::Rect r = getFromTable(idx); - cv::gpu::GpuMat sub(rois, r); - sub.setTo(1); - - cascade.detect(colored, rois, objectBoxes); - - TEST_CYCLE() + try { - cascade.detect(colored, rois, objectBoxes); - } + cv::Mat cpu = readImage (GET_PARAM(1)); + ASSERT_FALSE(cpu.empty()); + cv::gpu::GpuMat colored(cpu); - SANITY_CHECK(sortDetections(objectBoxes)); + cv::gpu::SCascade cascade; + + cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); + + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + + cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1); + rois.setTo(0); + + int idx = GET_PARAM(2); + cv::Rect r = getFromTable(idx); + cv::gpu::GpuMat sub(rois, r); + sub.setTo(1); + + cascade.detect(colored, rois, objectBoxes); + + TEST_CYCLE() + { + cascade.detect(colored, rois, objectBoxes); + } + + SANITY_CHECK(sortDetections(objectBoxes)); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } NO_CPU(SCascadeTestRoi, detectEachRoi) @@ -209,36 +233,44 @@ GPU_PERF_TEST_P(SCascadeTest, detectOnIntegral, RUN_GPU(SCascadeTest, detectOnIntegral) { - cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ); - ASSERT_TRUE(fsi.isOpened()); - - cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1); - for (int i = 0; i < 10; ++i) + try { - cv::Mat channel; - fsi[std::string("channel") + itoa(i)] >> channel; - cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121)); - gchannel.upload(channel); - } + cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ); + ASSERT_TRUE(fsi.isOpened()); - cv::gpu::SCascade cascade; + cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1); + for (int i = 0; i < 10; ++i) + { + cv::Mat channel; + fsi[std::string("channel") + itoa(i)] >> channel; + cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121)); + gchannel.upload(channel); + } - cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); + cv::gpu::SCascade cascade; - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); - cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1); - rois.setTo(1); + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - cascade.detect(hogluv, rois, objectBoxes); + cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1); + rois.setTo(1); - TEST_CYCLE() - { cascade.detect(hogluv, rois, objectBoxes); - } - SANITY_CHECK(sortDetections(objectBoxes)); + TEST_CYCLE() + { + cascade.detect(hogluv, rois, objectBoxes); + } + + SANITY_CHECK(sortDetections(objectBoxes)); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } NO_CPU(SCascadeTest, detectOnIntegral) @@ -251,34 +283,42 @@ GPU_PERF_TEST_P(SCascadeTest, detectStream, RUN_GPU(SCascadeTest, detectStream) { - cv::Mat cpu = readImage (GET_PARAM(1)); - ASSERT_FALSE(cpu.empty()); - cv::gpu::GpuMat colored(cpu); - - cv::gpu::SCascade cascade; - - cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); - - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - - cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1); - rois.setTo(1); - - cv::gpu::Stream s; - - cascade.detect(colored, rois, objectBoxes, s); - - TEST_CYCLE() + try { + cv::Mat cpu = readImage (GET_PARAM(1)); + ASSERT_FALSE(cpu.empty()); + cv::gpu::GpuMat colored(cpu); + + cv::gpu::SCascade cascade; + + cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); + + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + + cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1); + rois.setTo(1); + + cv::gpu::Stream s; + cascade.detect(colored, rois, objectBoxes, s); + + TEST_CYCLE() + { + cascade.detect(colored, rois, objectBoxes, s); + } + + #ifdef HAVE_CUDA + cudaDeviceSynchronize(); + #endif + + SANITY_CHECK(sortDetections(objectBoxes)); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } - -#ifdef HAVE_CUDA - cudaDeviceSynchronize(); -#endif - - SANITY_CHECK(sortDetections(objectBoxes)); } NO_CPU(SCascadeTest, detectStream) diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp index 5afe0d15f..661050e0e 100644 --- a/modules/gpu/perf/perf_video.cpp +++ b/modules/gpu/perf/perf_video.cpp @@ -36,23 +36,31 @@ PERF_TEST_P(ImagePair, Video_BroxOpticalFlow, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_u; - cv::gpu::GpuMat d_v; - - cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, - 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); - - d_flow(d_frame0, d_frame1, d_u, d_v); - - TEST_CYCLE() + try { - d_flow(d_frame0, d_frame1, d_u, d_v); - } + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_u; + cv::gpu::GpuMat d_v; - GPU_SANITY_CHECK(d_u); - GPU_SANITY_CHECK(d_v); + cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, + 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); + + d_flow(d_frame0, d_frame1, d_u, d_v); + + TEST_CYCLE() + { + d_flow(d_frame0, d_frame1, d_u, d_v); + } + + GPU_SANITY_CHECK(d_u); + GPU_SANITY_CHECK(d_v); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -77,31 +85,39 @@ PERF_TEST_P(ImagePair, Video_InterpolateFrames, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_fu, d_fv; - cv::gpu::GpuMat d_bu, d_bv; - - cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, - 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); - - d_flow(d_frame0, d_frame1, d_fu, d_fv); - d_flow(d_frame1, d_frame0, d_bu, d_bv); - - cv::gpu::GpuMat d_newFrame; - cv::gpu::GpuMat d_buf; - - cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf); - - TEST_CYCLE() + try { - cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf); - } + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_fu, d_fv; + cv::gpu::GpuMat d_bu, d_bv; - GPU_SANITY_CHECK(d_fu); - GPU_SANITY_CHECK(d_fv); - GPU_SANITY_CHECK(d_bu); - GPU_SANITY_CHECK(d_bv); + cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, + 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); + + d_flow(d_frame0, d_frame1, d_fu, d_fv); + d_flow(d_frame1, d_frame0, d_bu, d_bv); + + cv::gpu::GpuMat d_newFrame; + cv::gpu::GpuMat d_buf; + + cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf); + + TEST_CYCLE() + { + cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf); + } + + GPU_SANITY_CHECK(d_fu); + GPU_SANITY_CHECK(d_fv); + GPU_SANITY_CHECK(d_bu); + GPU_SANITY_CHECK(d_bv); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -126,27 +142,35 @@ PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_u; - cv::gpu::GpuMat d_v; - - cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, - 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); - - d_flow(d_frame0, d_frame1, d_u, d_v); - - cv::gpu::GpuMat d_vertex, d_colors; - - cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors); - - TEST_CYCLE() + try { - cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors); - } + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_u; + cv::gpu::GpuMat d_v; - GPU_SANITY_CHECK(d_vertex); - GPU_SANITY_CHECK(d_colors); + cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, + 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); + + d_flow(d_frame0, d_frame1, d_u, d_v); + + cv::gpu::GpuMat d_vertex, d_colors; + + cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors); + + TEST_CYCLE() + { + cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors); + } + + GPU_SANITY_CHECK(d_vertex); + GPU_SANITY_CHECK(d_colors); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -170,19 +194,27 @@ PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack, if (PERF_RUN_GPU()) { - cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance); - - cv::gpu::GpuMat d_image(image); - cv::gpu::GpuMat d_pts; - - d_detector(d_image, d_pts); - - TEST_CYCLE() + try { - d_detector(d_image, d_pts); - } + cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance); - GPU_SANITY_CHECK(d_pts); + cv::gpu::GpuMat d_image(image); + cv::gpu::GpuMat d_pts; + + d_detector(d_image, d_pts); + + TEST_CYCLE() + { + d_detector(d_image, d_pts); + } + + GPU_SANITY_CHECK(d_pts); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -238,26 +270,34 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_pts(pts.reshape(2, 1)); - - cv::gpu::PyrLKOpticalFlow d_pyrLK; - d_pyrLK.winSize = cv::Size(winSize, winSize); - d_pyrLK.maxLevel = levels - 1; - d_pyrLK.iters = iters; - - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_nextPts; - cv::gpu::GpuMat d_status; - - d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status); - - TEST_CYCLE() + try { - d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status); - } + cv::gpu::GpuMat d_pts(pts.reshape(2, 1)); - GPU_SANITY_CHECK(d_status); + cv::gpu::PyrLKOpticalFlow d_pyrLK; + d_pyrLK.winSize = cv::Size(winSize, winSize); + d_pyrLK.maxLevel = levels - 1; + d_pyrLK.iters = iters; + + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_nextPts; + cv::gpu::GpuMat d_status; + + d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status); + + TEST_CYCLE() + { + d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status); + } + + GPU_SANITY_CHECK(d_status); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -305,25 +345,33 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine( if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_u; - cv::gpu::GpuMat d_v; - - cv::gpu::PyrLKOpticalFlow d_pyrLK; - d_pyrLK.winSize = cv::Size(winSize, winSize); - d_pyrLK.maxLevel = levels - 1; - d_pyrLK.iters = iters; - - d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v); - - TEST_CYCLE() + try { - d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v); - } + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_u; + cv::gpu::GpuMat d_v; - GPU_SANITY_CHECK(d_u); - GPU_SANITY_CHECK(d_v); + cv::gpu::PyrLKOpticalFlow d_pyrLK; + d_pyrLK.winSize = cv::Size(winSize, winSize); + d_pyrLK.maxLevel = levels - 1; + d_pyrLK.iters = iters; + + d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v); + + TEST_CYCLE() + { + d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v); + } + + GPU_SANITY_CHECK(d_u); + GPU_SANITY_CHECK(d_v); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -355,29 +403,37 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_u; - cv::gpu::GpuMat d_v; - - cv::gpu::FarnebackOpticalFlow d_farneback; - d_farneback.numLevels = numLevels; - d_farneback.pyrScale = pyrScale; - d_farneback.winSize = winSize; - d_farneback.numIters = numIters; - d_farneback.polyN = polyN; - d_farneback.polySigma = polySigma; - d_farneback.flags = flags; - - d_farneback(d_frame0, d_frame1, d_u, d_v); - - TEST_CYCLE() + try { - d_farneback(d_frame0, d_frame1, d_u, d_v); - } + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_u; + cv::gpu::GpuMat d_v; - GPU_SANITY_CHECK(d_u); - GPU_SANITY_CHECK(d_v); + cv::gpu::FarnebackOpticalFlow d_farneback; + d_farneback.numLevels = numLevels; + d_farneback.pyrScale = pyrScale; + d_farneback.winSize = winSize; + d_farneback.numIters = numIters; + d_farneback.polyN = polyN; + d_farneback.polySigma = polySigma; + d_farneback.flags = flags; + + d_farneback(d_frame0, d_frame1, d_u, d_v); + + TEST_CYCLE() + { + d_farneback(d_frame0, d_frame1, d_u, d_v); + } + + GPU_SANITY_CHECK(d_u); + GPU_SANITY_CHECK(d_v); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -410,22 +466,30 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowDual_TVL1, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_flowx; - cv::gpu::GpuMat d_flowy; - - cv::gpu::OpticalFlowDual_TVL1_GPU d_alg; - - d_alg(d_frame0, d_frame1, d_flowx, d_flowy); - - TEST_CYCLE() + try { - d_alg(d_frame0, d_frame1, d_flowx, d_flowy); - } + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_flowx; + cv::gpu::GpuMat d_flowy; - GPU_SANITY_CHECK(d_flowx); - GPU_SANITY_CHECK(d_flowy); + cv::gpu::OpticalFlowDual_TVL1_GPU d_alg; + + d_alg(d_frame0, d_frame1, d_flowx, d_flowy); + + TEST_CYCLE() + { + d_alg(d_frame0, d_frame1, d_flowx, d_flowy); + } + + GPU_SANITY_CHECK(d_flowx); + GPU_SANITY_CHECK(d_flowy); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -482,19 +546,27 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowBM, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_velx, d_vely, buf; - - cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf); - - TEST_CYCLE() + try { - cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf); - } + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_velx, d_vely, buf; - GPU_SANITY_CHECK(d_velx); - GPU_SANITY_CHECK(d_vely); + cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf); + + TEST_CYCLE() + { + cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf); + } + + GPU_SANITY_CHECK(d_velx); + GPU_SANITY_CHECK(d_vely); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -529,21 +601,29 @@ PERF_TEST_P(ImagePair, Video_FastOpticalFlowBM, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame0(frame0); - cv::gpu::GpuMat d_frame1(frame1); - cv::gpu::GpuMat d_velx, d_vely; - - cv::gpu::FastOpticalFlowBM fastBM; - - fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width); - - TEST_CYCLE() + try { - fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width); - } + cv::gpu::GpuMat d_frame0(frame0); + cv::gpu::GpuMat d_frame1(frame1); + cv::gpu::GpuMat d_velx, d_vely; - GPU_SANITY_CHECK(d_velx); - GPU_SANITY_CHECK(d_vely); + cv::gpu::FastOpticalFlowBM fastBM; + + fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width); + + TEST_CYCLE() + { + fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width); + } + + GPU_SANITY_CHECK(d_velx); + GPU_SANITY_CHECK(d_vely); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -581,21 +661,29 @@ PERF_TEST_P(Video, DISABLED_Video_FGDStatModel, Values("gpu/video/768x576.avi", if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame(frame); - - cv::gpu::FGDStatModel d_model(4); - d_model.create(d_frame); - - for (int i = 0; i < 10; ++i) + try { - cap >> frame; - ASSERT_FALSE(frame.empty()); + cv::gpu::GpuMat d_frame(frame); - d_frame.upload(frame); + cv::gpu::FGDStatModel d_model(4); + d_model.create(d_frame); - startTimer(); next(); - d_model.update(d_frame); - stopTimer(); + for (int i = 0; i < 10; ++i) + { + cap >> frame; + ASSERT_FALSE(frame.empty()); + + d_frame.upload(frame); + + startTimer(); next(); + d_model.update(d_frame); + stopTimer(); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -649,32 +737,40 @@ PERF_TEST_P(Video_Cn_LearningRate, DISABLED_Video_MOG, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame(frame); - cv::gpu::MOG_GPU d_mog; - cv::gpu::GpuMat d_foreground; - - d_mog(d_frame, d_foreground, learningRate); - - for (int i = 0; i < 10; ++i) + try { - cap >> frame; - ASSERT_FALSE(frame.empty()); + cv::gpu::GpuMat d_frame(frame); + cv::gpu::MOG_GPU d_mog; + cv::gpu::GpuMat d_foreground; - if (cn != 3) - { - cv::Mat temp; - if (cn == 1) - cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); - else - cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); - cv::swap(temp, frame); - } - - d_frame.upload(frame); - - startTimer(); next(); d_mog(d_frame, d_foreground, learningRate); - stopTimer(); + + for (int i = 0; i < 10; ++i) + { + cap >> frame; + ASSERT_FALSE(frame.empty()); + + if (cn != 3) + { + cv::Mat temp; + if (cn == 1) + cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); + else + cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); + cv::swap(temp, frame); + } + + d_frame.upload(frame); + + startTimer(); next(); + d_mog(d_frame, d_foreground, learningRate); + stopTimer(); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -737,32 +833,40 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_MOG2, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame(frame); - cv::gpu::MOG2_GPU d_mog2; - cv::gpu::GpuMat d_foreground; - - d_mog2(d_frame, d_foreground); - - for (int i = 0; i < 10; ++i) + try { - cap >> frame; - ASSERT_FALSE(frame.empty()); + cv::gpu::GpuMat d_frame(frame); + cv::gpu::MOG2_GPU d_mog2; + cv::gpu::GpuMat d_foreground; - if (cn != 3) - { - cv::Mat temp; - if (cn == 1) - cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); - else - cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); - cv::swap(temp, frame); - } - - d_frame.upload(frame); - - startTimer(); next(); d_mog2(d_frame, d_foreground); - stopTimer(); + + for (int i = 0; i < 10; ++i) + { + cap >> frame; + ASSERT_FALSE(frame.empty()); + + if (cn != 3) + { + cv::Mat temp; + if (cn == 1) + cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); + else + cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); + cv::swap(temp, frame); + } + + d_frame.upload(frame); + + startTimer(); next(); + d_mog2(d_frame, d_foreground); + stopTimer(); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -810,39 +914,47 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame; - cv::gpu::MOG2_GPU d_mog2; - cv::gpu::GpuMat d_foreground; - - for (int i = 0; i < 10; ++i) + try { - cap >> frame; - ASSERT_FALSE(frame.empty()); + cv::gpu::GpuMat d_frame; + cv::gpu::MOG2_GPU d_mog2; + cv::gpu::GpuMat d_foreground; - if (cn != 3) + for (int i = 0; i < 10; ++i) { - cv::Mat temp; - if (cn == 1) - cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); - else - cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); - cv::swap(temp, frame); + cap >> frame; + ASSERT_FALSE(frame.empty()); + + if (cn != 3) + { + cv::Mat temp; + if (cn == 1) + cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); + else + cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); + cv::swap(temp, frame); + } + + d_frame.upload(frame); + + d_mog2(d_frame, d_foreground); } - d_frame.upload(frame); - - d_mog2(d_frame, d_foreground); - } - - cv::gpu::GpuMat d_background; - d_mog2.getBackgroundImage(d_background); - - TEST_CYCLE() - { + cv::gpu::GpuMat d_background; d_mog2.getBackgroundImage(d_background); - } - GPU_SANITY_CHECK(d_background); + TEST_CYCLE() + { + d_mog2.getBackgroundImage(d_background); + } + + GPU_SANITY_CHECK(d_background); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { @@ -907,32 +1019,40 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_VIBE, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame(frame); - cv::gpu::VIBE_GPU d_vibe; - cv::gpu::GpuMat d_foreground; - - d_vibe(d_frame, d_foreground); - - for (int i = 0; i < 10; ++i) + try { - cap >> frame; - ASSERT_FALSE(frame.empty()); + cv::gpu::GpuMat d_frame(frame); + cv::gpu::VIBE_GPU d_vibe; + cv::gpu::GpuMat d_foreground; - if (cn != 3) - { - cv::Mat temp; - if (cn == 1) - cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); - else - cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); - cv::swap(temp, frame); - } - - d_frame.upload(frame); - - startTimer(); next(); d_vibe(d_frame, d_foreground); - stopTimer(); + + for (int i = 0; i < 10; ++i) + { + cap >> frame; + ASSERT_FALSE(frame.empty()); + + if (cn != 3) + { + cv::Mat temp; + if (cn == 1) + cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); + else + cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); + cv::swap(temp, frame); + } + + d_frame.upload(frame); + + startTimer(); next(); + d_vibe(d_frame, d_foreground); + stopTimer(); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -972,39 +1092,47 @@ PERF_TEST_P(Video_Cn_MaxFeatures, DISABLED_Video_GMG, if (PERF_RUN_GPU()) { - cv::gpu::GpuMat d_frame(frame); - cv::gpu::GpuMat d_fgmask; - - cv::gpu::GMG_GPU d_gmg; - d_gmg.maxFeatures = maxFeatures; - - d_gmg(d_frame, d_fgmask); - - for (int i = 0; i < 150; ++i) + try { - cap >> frame; - if (frame.empty()) - { - cap.release(); - cap.open(inputFile); - cap >> frame; - } + cv::gpu::GpuMat d_frame(frame); + cv::gpu::GpuMat d_fgmask; - if (cn != 3) - { - cv::Mat temp; - if (cn == 1) - cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); - else - cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); - cv::swap(temp, frame); - } + cv::gpu::GMG_GPU d_gmg; + d_gmg.maxFeatures = maxFeatures; - d_frame.upload(frame); - - startTimer(); next(); d_gmg(d_frame, d_fgmask); - stopTimer(); + + for (int i = 0; i < 150; ++i) + { + cap >> frame; + if (frame.empty()) + { + cap.release(); + cap.open(inputFile); + cap >> frame; + } + + if (cn != 3) + { + cv::Mat temp; + if (cn == 1) + cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); + else + cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA); + cv::swap(temp, frame); + } + + d_frame.upload(frame); + + startTimer(); next(); + d_gmg(d_frame, d_fgmask); + stopTimer(); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -1066,23 +1194,31 @@ PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video if (PERF_RUN_GPU()) { - cv::gpu::VideoWriter_GPU d_writer; - - cv::gpu::GpuMat d_frame; - - for (int i = 0; i < 10; ++i) + try { - reader >> frame; - ASSERT_FALSE(frame.empty()); + cv::gpu::VideoWriter_GPU d_writer; - d_frame.upload(frame); + cv::gpu::GpuMat d_frame; - if (!d_writer.isOpened()) - d_writer.open(outputFile, frame.size(), FPS); + for (int i = 0; i < 10; ++i) + { + reader >> frame; + ASSERT_FALSE(frame.empty()); - startTimer(); next(); - d_writer.write(d_frame); - stopTimer(); + d_frame.upload(frame); + + if (!d_writer.isOpened()) + d_writer.open(outputFile, frame.size(), FPS); + + startTimer(); next(); + d_writer.write(d_frame); + stopTimer(); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } else @@ -1115,19 +1251,27 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video if (PERF_RUN_GPU()) { - cv::gpu::VideoReader_GPU d_reader(inputFile); - ASSERT_TRUE( d_reader.isOpened() ); - - cv::gpu::GpuMat d_frame; - - d_reader.read(d_frame); - - TEST_CYCLE_N(10) + try { - d_reader.read(d_frame); - } + cv::gpu::VideoReader_GPU d_reader(inputFile); + ASSERT_TRUE( d_reader.isOpened() ); - GPU_SANITY_CHECK(d_frame); + cv::gpu::GpuMat d_frame; + + d_reader.read(d_frame); + + TEST_CYCLE_N(10) + { + d_reader.read(d_frame); + } + + GPU_SANITY_CHECK(d_frame); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } else { diff --git a/modules/gpu/test/nvidia/main_nvidia.cpp b/modules/gpu/test/nvidia/main_nvidia.cpp index 7873563ce..43c92ce1e 100644 --- a/modules/gpu/test/nvidia/main_nvidia.cpp +++ b/modules/gpu/test/nvidia/main_nvidia.cpp @@ -276,6 +276,8 @@ static void devNullOutput(const std::string& msg) (void)msg; } +} + bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel) { path = test_data_path.c_str(); @@ -292,8 +294,6 @@ bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel return testListerII.invoke(); } -} - bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel) { path = test_data_path; @@ -439,4 +439,4 @@ bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel out return testListerVisualize.invoke(); } -#endif /* CUDA_DISABLER */ \ No newline at end of file +#endif /* CUDA_DISABLER */ diff --git a/modules/gpu/test/test_calib3d.cpp b/modules/gpu/test/test_calib3d.cpp index a294a3df9..4a53c6093 100644 --- a/modules/gpu/test/test_calib3d.cpp +++ b/modules/gpu/test/test_calib3d.cpp @@ -62,20 +62,28 @@ struct StereoBM : testing::TestWithParam TEST_P(StereoBM, Regression) { - 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); + 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); - ASSERT_FALSE(left_image.empty()); - ASSERT_FALSE(right_image.empty()); - ASSERT_FALSE(disp_gold.empty()); + ASSERT_FALSE(left_image.empty()); + ASSERT_FALSE(right_image.empty()); + ASSERT_FALSE(disp_gold.empty()); - cv::gpu::StereoBM_GPU bm(0, 128, 19); - cv::gpu::GpuMat disp; + cv::gpu::StereoBM_GPU bm(0, 128, 19); + cv::gpu::GpuMat disp; - bm(loadMat(left_image), loadMat(right_image), disp); + bm(loadMat(left_image), loadMat(right_image), disp); - EXPECT_MAT_NEAR(disp_gold, disp, 0.0); + EXPECT_MAT_NEAR(disp_gold, disp, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBM, ALL_DEVICES); @@ -97,23 +105,31 @@ struct StereoBeliefPropagation : testing::TestWithParam TEST_P(StereoBeliefPropagation, Regression) { - 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); + 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); - ASSERT_FALSE(left_image.empty()); - ASSERT_FALSE(right_image.empty()); - ASSERT_FALSE(disp_gold.empty()); + ASSERT_FALSE(left_image.empty()); + ASSERT_FALSE(right_image.empty()); + ASSERT_FALSE(disp_gold.empty()); - cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S); - cv::gpu::GpuMat disp; + cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S); + cv::gpu::GpuMat disp; - bp(loadMat(left_image), loadMat(right_image), disp); + bp(loadMat(left_image), loadMat(right_image), disp); - cv::Mat h_disp(disp); - h_disp.convertTo(h_disp, disp_gold.depth()); + cv::Mat h_disp(disp); + h_disp.convertTo(h_disp, disp_gold.depth()); - EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0); + EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBeliefPropagation, ALL_DEVICES); @@ -135,29 +151,37 @@ struct StereoConstantSpaceBP : testing::TestWithParam TEST_P(StereoConstantSpaceBP, Regression) { - cv::Mat left_image = readImage("csstereobp/aloe-L.png"); - cv::Mat right_image = readImage("csstereobp/aloe-R.png"); + try + { + cv::Mat left_image = readImage("csstereobp/aloe-L.png"); + cv::Mat right_image = readImage("csstereobp/aloe-R.png"); - cv::Mat disp_gold; + cv::Mat disp_gold; - if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20)) - disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE); - else - disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE); + if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20)) + disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE); + else + disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(left_image.empty()); - ASSERT_FALSE(right_image.empty()); - ASSERT_FALSE(disp_gold.empty()); + ASSERT_FALSE(left_image.empty()); + ASSERT_FALSE(right_image.empty()); + ASSERT_FALSE(disp_gold.empty()); - cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4); - cv::gpu::GpuMat disp; + cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4); + cv::gpu::GpuMat disp; - csbp(loadMat(left_image), loadMat(right_image), disp); + csbp(loadMat(left_image), loadMat(right_image), disp); - cv::Mat h_disp(disp); - h_disp.convertTo(h_disp, disp_gold.depth()); + cv::Mat h_disp(disp); + h_disp.convertTo(h_disp, disp_gold.depth()); - EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0); + EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoConstantSpaceBP, ALL_DEVICES); @@ -179,32 +203,40 @@ struct TransformPoints : testing::TestWithParam TEST_P(TransformPoints, Accuracy) { - 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); - - cv::gpu::GpuMat dst; - cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst); - - ASSERT_EQ(src.size(), dst.size()); - ASSERT_EQ(src.type(), dst.type()); - - cv::Mat h_dst(dst); - - cv::Mat rot; - cv::Rodrigues(rvec, rot); - - for (int i = 0; i < h_dst.cols; ++i) + try { - cv::Point3f res = h_dst.at(0, i); + 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); - cv::Point3f p = src.at(0, i); - cv::Point3f res_gold( - rot.at(0, 0) * p.x + rot.at(0, 1) * p.y + rot.at(0, 2) * p.z + tvec.at(0, 0), - rot.at(1, 0) * p.x + rot.at(1, 1) * p.y + rot.at(1, 2) * p.z + tvec.at(0, 1), - rot.at(2, 0) * p.x + rot.at(2, 1) * p.y + rot.at(2, 2) * p.z + tvec.at(0, 2)); + cv::gpu::GpuMat dst; + cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst); - ASSERT_POINT3_NEAR(res_gold, res, 1e-5); + ASSERT_EQ(src.size(), dst.size()); + ASSERT_EQ(src.type(), dst.type()); + + cv::Mat h_dst(dst); + + cv::Mat rot; + cv::Rodrigues(rvec, rot); + + for (int i = 0; i < h_dst.cols; ++i) + { + cv::Point3f res = h_dst.at(0, i); + + cv::Point3f p = src.at(0, i); + cv::Point3f res_gold( + rot.at(0, 0) * p.x + rot.at(0, 1) * p.y + rot.at(0, 2) * p.z + tvec.at(0, 0), + rot.at(1, 0) * p.x + rot.at(1, 1) * p.y + rot.at(1, 2) * p.z + tvec.at(0, 1), + rot.at(2, 0) * p.x + rot.at(2, 1) * p.y + rot.at(2, 2) * p.z + tvec.at(0, 2)); + + ASSERT_POINT3_NEAR(res_gold, res, 1e-5); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } @@ -227,34 +259,42 @@ struct ProjectPoints : testing::TestWithParam TEST_P(ProjectPoints, Accuracy) { - 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); - cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1); - camera_mat.at(0, 1) = 0.f; - camera_mat.at(1, 0) = 0.f; - camera_mat.at(2, 0) = 0.f; - camera_mat.at(2, 1) = 0.f; - - cv::gpu::GpuMat dst; - cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst); - - ASSERT_EQ(1, dst.rows); - ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type())); - - std::vector dst_gold; - cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold); - - ASSERT_EQ(dst_gold.size(), static_cast(dst.cols)); - - cv::Mat h_dst(dst); - - for (size_t i = 0; i < dst_gold.size(); ++i) + try { - cv::Point2f res = h_dst.at(0, (int)i); - cv::Point2f res_gold = dst_gold[i]; + 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); + cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1); + camera_mat.at(0, 1) = 0.f; + camera_mat.at(1, 0) = 0.f; + camera_mat.at(2, 0) = 0.f; + camera_mat.at(2, 1) = 0.f; - ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f); + cv::gpu::GpuMat dst; + cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst); + + ASSERT_EQ(1, dst.rows); + ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type())); + + std::vector dst_gold; + cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold); + + ASSERT_EQ(dst_gold.size(), static_cast(dst.cols)); + + cv::Mat h_dst(dst); + + for (size_t i = 0; i < dst_gold.size(); ++i) + { + cv::Point2f res = h_dst.at(0, (int)i); + cv::Point2f res_gold = dst_gold[i]; + + ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } @@ -277,28 +317,36 @@ struct SolvePnPRansac : testing::TestWithParam TEST_P(SolvePnPRansac, Accuracy) { - 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(0, 1) = 0.f; - camera_mat.at(1, 0) = 0.f; - camera_mat.at(2, 0) = 0.f; - camera_mat.at(2, 1) = 0.f; + 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(0, 1) = 0.f; + camera_mat.at(1, 0) = 0.f; + camera_mat.at(2, 0) = 0.f; + camera_mat.at(2, 1) = 0.f; - std::vector image_vec; - cv::Mat rvec_gold; - cv::Mat tvec_gold; - rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1); - tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1); - cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec); + std::vector image_vec; + cv::Mat rvec_gold; + cv::Mat tvec_gold; + rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1); + tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1); + cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec); - cv::Mat rvec, tvec; - std::vector inliers; - cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)image_vec.size(), CV_32FC2, &image_vec[0]), - camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), - rvec, tvec, false, 200, 2.f, 100, &inliers); + cv::Mat rvec, tvec; + std::vector inliers; + cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)image_vec.size(), CV_32FC2, &image_vec[0]), + camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), + rvec, tvec, false, 200, 2.f, 100, &inliers); - ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3); - ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3); + 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,16 +374,24 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use TEST_P(ReprojectImageTo3D, Accuracy) { - cv::Mat disp = randomMat(size, depth, 5.0, 30.0); - cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0); + 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); - cv::gpu::GpuMat dst; - cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3); + cv::gpu::GpuMat dst; + cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3); - cv::Mat dst_gold; - cv::reprojectImageTo3D(disp, dst_gold, Q, false); + cv::Mat dst_gold; + cv::reprojectImageTo3D(disp, dst_gold, Q, false); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine( diff --git a/modules/gpu/test/test_color.cpp b/modules/gpu/test/test_color.cpp index 2510f564d..e350ee965 100644 --- a/modules/gpu/test/test_color.cpp +++ b/modules/gpu/test/test_color.cpp @@ -72,165 +72,261 @@ PARAM_TEST_CASE(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(CvtColor, BGR2RGB) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2RGBA) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2BGRA) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGRA2RGB) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGRA2BGR) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGRA2RGBA) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2GRAY) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2GRAY) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, GRAY2BGR) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2GRAY); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2GRAY); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, GRAY2BGRA) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2GRAY); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2GRAY); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGRA2GRAY) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2GRAY) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2BGR565) @@ -238,15 +334,23 @@ TEST_P(CvtColor, BGR2BGR565) if (depth != CV_8U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2BGR565) @@ -254,15 +358,23 @@ TEST_P(CvtColor, RGB2BGR565) if (depth != CV_8U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5652BGR) @@ -270,16 +382,24 @@ TEST_P(CvtColor, BGR5652BGR) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5652RGB) @@ -287,16 +407,24 @@ TEST_P(CvtColor, BGR5652RGB) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGRA2BGR565) @@ -304,16 +432,24 @@ TEST_P(CvtColor, BGRA2BGR565) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2BGR565) @@ -321,16 +457,24 @@ TEST_P(CvtColor, RGBA2BGR565) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5652BGRA) @@ -338,16 +482,24 @@ TEST_P(CvtColor, BGR5652BGRA) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5652RGBA) @@ -355,16 +507,24 @@ TEST_P(CvtColor, BGR5652RGBA) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, GRAY2BGR565) @@ -372,16 +532,24 @@ TEST_P(CvtColor, GRAY2BGR565) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2GRAY); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2GRAY); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5652GRAY) @@ -389,16 +557,24 @@ TEST_P(CvtColor, BGR5652GRAY) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR565); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2BGR555) @@ -406,15 +582,23 @@ TEST_P(CvtColor, BGR2BGR555) if (depth != CV_8U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2BGR555) @@ -422,15 +606,23 @@ TEST_P(CvtColor, RGB2BGR555) if (depth != CV_8U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5552BGR) @@ -438,16 +630,24 @@ TEST_P(CvtColor, BGR5552BGR) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5552RGB) @@ -455,16 +655,24 @@ TEST_P(CvtColor, BGR5552RGB) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGRA2BGR555) @@ -472,16 +680,24 @@ TEST_P(CvtColor, BGRA2BGR555) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2BGR555) @@ -489,16 +705,24 @@ TEST_P(CvtColor, RGBA2BGR555) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5552BGRA) @@ -506,16 +730,24 @@ TEST_P(CvtColor, BGR5552BGRA) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5552RGBA) @@ -523,16 +755,24 @@ TEST_P(CvtColor, BGR5552RGBA) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, GRAY2BGR555) @@ -540,16 +780,24 @@ TEST_P(CvtColor, GRAY2BGR555) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2GRAY); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2GRAY); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR5552GRAY) @@ -557,286 +805,422 @@ TEST_P(CvtColor, BGR5552GRAY) if (depth != CV_8U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGR555); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2XYZ) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2XYZ) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2XYZ4) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGRA2XYZ4) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2BGRA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, XYZ2BGR) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2XYZ); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2XYZ); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, XYZ2RGB) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2XYZ); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2XYZ); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, XYZ42BGR) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2XYZ); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2XYZ); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, XYZ42BGRA) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2XYZ); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2XYZ); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2YCrCb) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2YCrCb) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2YCrCb4) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2YCrCb4) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, YCrCb2BGR) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, YCrCb2RGB) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, YCrCb42RGB) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, YCrCb42RGBA) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2HSV) @@ -844,15 +1228,23 @@ TEST_P(CvtColor, BGR2HSV) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2HSV) @@ -860,15 +1252,23 @@ TEST_P(CvtColor, RGB2HSV) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2HSV4) @@ -876,23 +1276,31 @@ TEST_P(CvtColor, RGB2HSV4) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2HSV4) @@ -900,24 +1308,32 @@ TEST_P(CvtColor, RGBA2HSV4) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2HLS) @@ -925,15 +1341,23 @@ TEST_P(CvtColor, BGR2HLS) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2HLS) @@ -941,15 +1365,23 @@ TEST_P(CvtColor, RGB2HLS) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2HLS4) @@ -957,23 +1389,31 @@ TEST_P(CvtColor, RGB2HLS4) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2HLS4) @@ -981,24 +1421,32 @@ TEST_P(CvtColor, RGBA2HLS4) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HSV2BGR) @@ -1006,16 +1454,24 @@ TEST_P(CvtColor, HSV2BGR) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HSV); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HSV); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HSV2RGB) @@ -1023,16 +1479,24 @@ TEST_P(CvtColor, HSV2RGB) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HSV); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HSV); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HSV42BGR) @@ -1040,21 +1504,29 @@ TEST_P(CvtColor, HSV42BGR) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HSV); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HSV); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HSV42BGRA) @@ -1062,21 +1534,29 @@ TEST_P(CvtColor, HSV42BGRA) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HSV); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HSV); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HLS2BGR) @@ -1084,16 +1564,24 @@ TEST_P(CvtColor, HLS2BGR) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HLS); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HLS); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HLS2RGB) @@ -1101,16 +1589,24 @@ TEST_P(CvtColor, HLS2RGB) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HLS); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HLS); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HLS42RGB) @@ -1118,21 +1614,29 @@ TEST_P(CvtColor, HLS42RGB) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HLS); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HLS); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HLS42RGBA) @@ -1140,22 +1644,30 @@ TEST_P(CvtColor, HLS42RGBA) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HLS); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HLS); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2HSV_FULL) @@ -1163,15 +1675,23 @@ TEST_P(CvtColor, BGR2HSV_FULL) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2HSV_FULL) @@ -1179,15 +1699,23 @@ TEST_P(CvtColor, RGB2HSV_FULL) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2HSV4_FULL) @@ -1195,23 +1723,31 @@ TEST_P(CvtColor, RGB2HSV4_FULL) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2HSV4_FULL) @@ -1219,24 +1755,32 @@ TEST_P(CvtColor, RGBA2HSV4_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2HLS_FULL) @@ -1244,15 +1788,23 @@ TEST_P(CvtColor, BGR2HLS_FULL) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2HLS_FULL) @@ -1260,15 +1812,23 @@ TEST_P(CvtColor, RGB2HLS_FULL) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2HLS4_FULL) @@ -1276,23 +1836,31 @@ TEST_P(CvtColor, RGB2HLS4_FULL) if (depth == CV_16U) return; - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2HLS4_FULL) @@ -1300,24 +1868,32 @@ TEST_P(CvtColor, RGBA2HLS4_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HSV2BGR_FULL) @@ -1325,16 +1901,24 @@ TEST_P(CvtColor, HSV2BGR_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HSV2RGB_FULL) @@ -1342,16 +1926,24 @@ TEST_P(CvtColor, HSV2RGB_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HSV42RGB_FULL) @@ -1359,21 +1951,29 @@ TEST_P(CvtColor, HSV42RGB_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HSV42RGBA_FULL) @@ -1381,21 +1981,29 @@ TEST_P(CvtColor, HSV42RGBA_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HLS2BGR_FULL) @@ -1403,16 +2011,24 @@ TEST_P(CvtColor, HLS2BGR_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HLS2RGB_FULL) @@ -1420,16 +2036,24 @@ TEST_P(CvtColor, HLS2RGB_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HLS42RGB_FULL) @@ -1437,21 +2061,29 @@ TEST_P(CvtColor, HLS42RGB_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, HLS42RGBA_FULL) @@ -1459,312 +2091,374 @@ TEST_P(CvtColor, HLS42RGBA_FULL) if (depth == CV_16U) return; - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4); - EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2YUV) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGB2YUV) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, YUV2BGR) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2YUV); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2YUV); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, YUV42BGR) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2YUV); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2YUV); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, YUV42BGRA) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2YUV); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2YUV); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4); - cv::Mat channels[4]; - cv::split(src, channels); - channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); - cv::merge(channels, 4, src); + cv::Mat channels[4]; + cv::split(src, channels); + channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0)); + cv::merge(channels, 4, src); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, YUV2RGB) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_RGB2YUV); + try + { + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_RGB2YUV); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BGR2YUV4) { - cv::Mat src = img; + try + { + cv::Mat src = img; - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV); - cv::Mat h_dst(dst); + cv::Mat h_dst(dst); - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); - EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, RGBA2YUV4) { - cv::Mat src; - cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4); - - ASSERT_EQ(4, dst.channels()); - - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV); - - cv::Mat h_dst(dst); - - cv::Mat channels[4]; - cv::split(h_dst, channels); - cv::merge(channels, 3, h_dst); - - EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); -} - -TEST_P(CvtColor, BGR2Lab) -{ - if (depth != CV_8U) - return; - try { - cv::Mat src = readImage("stereobm/aloe-L.png"); + cv::Mat src; + cv::cvtColor(img, src, cv::COLOR_BGR2RGBA); - cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4); - cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR); - - EXPECT_MAT_NEAR(src, dst_bgr, 10); - } - catch (const cv::Exception& e) - { - (void)e; -#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000) - ASSERT_EQ(CV_StsBadFlag, e.code); -#else - FAIL(); -#endif - } -} - -TEST_P(CvtColor, RGB2Lab) -{ - if (depth != CV_8U) - return; - - try - { - cv::Mat src = readImage("stereobm/aloe-L.png"); - - cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab); - - cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB); - - EXPECT_MAT_NEAR(src, dst_bgr, 10); - } - catch (const cv::Exception& e) - { - (void)e; -#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000) - ASSERT_EQ(CV_StsBadFlag, e.code); -#else - FAIL(); -#endif - } -} - -TEST_P(CvtColor, BGR2Luv) -{ - if (depth != CV_8U) - return; - - try - { - cv::Mat src = img; - - cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv); - - cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR); - - EXPECT_MAT_NEAR(src, dst_rgb, 10); - } - catch (const cv::Exception& e) - { - (void)e; -#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000) - ASSERT_EQ(CV_StsBadFlag, e.code); -#else - FAIL(); -#endif - } -} - -TEST_P(CvtColor, RGB2Luv) -{ - if (depth != CV_8U) - return; - - try - { - cv::Mat src = img; - - cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv); - - cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB); - - EXPECT_MAT_NEAR(src, dst_rgb, 10); - } - catch (const cv::Exception& e) - { - (void)e; -#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000) - ASSERT_EQ(CV_StsBadFlag, e.code); -#else - FAIL(); -#endif - } -} - -TEST_P(CvtColor, RGBA2mRGBA) -{ - if (depth != CV_8U) - return; - - try - { - cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4)); - - cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi); - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA); + ASSERT_EQ(4, dst.channels()); cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA); + cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV); - EXPECT_MAT_NEAR(dst_gold, dst, 1); + cv::Mat h_dst(dst); + + cv::Mat channels[4]; + cv::split(h_dst, channels); + cv::merge(channels, 3, h_dst); + + EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5); } - catch (const cv::Exception& e) + catch (...) { - (void)e; -#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000) - ASSERT_EQ(CV_StsBadFlag, e.code); -#else - FAIL(); -#endif + cv::gpu::resetDevice(); + throw; } } +#if defined(CUDA_VERSION) && (CUDA_VERSION >= 5000) + TEST_P(CvtColor, BGR2Lab) + { + if (depth != CV_8U) + return; + + try + { + cv::Mat src = readImage("stereobm/aloe-L.png"); + + cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab); + + cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR); + + EXPECT_MAT_NEAR(src, dst_bgr, 10); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } + } + + TEST_P(CvtColor, RGB2Lab) + { + if (depth != CV_8U) + return; + + try + { + cv::Mat src = readImage("stereobm/aloe-L.png"); + + cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab); + + cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB); + + EXPECT_MAT_NEAR(src, dst_bgr, 10); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } + } + + TEST_P(CvtColor, BGR2Luv) + { + if (depth != CV_8U) + return; + + try + { + cv::Mat src = img; + + cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv); + + cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR); + + EXPECT_MAT_NEAR(src, dst_rgb, 10); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } + } + + TEST_P(CvtColor, RGB2Luv) + { + if (depth != CV_8U) + return; + + try + { + cv::Mat src = img; + + cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv); + + cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB); + + EXPECT_MAT_NEAR(src, dst_rgb, 10); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } + } + + TEST_P(CvtColor, RGBA2mRGBA) + { + if (depth != CV_8U) + return; + + try + { + cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4)); + + cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi); + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA); + + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA); + + EXPECT_MAT_NEAR(dst_gold, dst, 1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } + } +#endif + TEST_P(CvtColor, BayerBG2BGR) { if ((depth != CV_8U && depth != CV_16U) || useRoi) return; - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR); - EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BayerBG2BGR4) @@ -1772,22 +2466,30 @@ TEST_P(CvtColor, BayerBG2BGR4) if ((depth != CV_8U && depth != CV_16U) || useRoi) return; - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR); - cv::Mat dst4(dst); - cv::Mat dst3; - cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR); + cv::Mat dst4(dst); + cv::Mat dst3; + cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR); - EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BayerGB2BGR) @@ -1795,15 +2497,23 @@ TEST_P(CvtColor, BayerGB2BGR) if ((depth != CV_8U && depth != CV_16U) || useRoi) return; - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR); - EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BayerGB2BGR4) @@ -1811,21 +2521,29 @@ TEST_P(CvtColor, BayerGB2BGR4) if ((depth != CV_8U && depth != CV_16U) || useRoi) return; - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR); - cv::Mat dst4(dst); - cv::Mat dst3; - cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR); + cv::Mat dst4(dst); + cv::Mat dst3; + cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR); - EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BayerRG2BGR) @@ -1833,15 +2551,23 @@ TEST_P(CvtColor, BayerRG2BGR) if ((depth != CV_8U && depth != CV_16U) || useRoi) return; - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR); - EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BayerRG2BGR4) @@ -1849,21 +2575,29 @@ TEST_P(CvtColor, BayerRG2BGR4) if ((depth != CV_8U && depth != CV_16U) || useRoi) return; - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR); - cv::Mat dst4(dst); - cv::Mat dst3; - cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR); + cv::Mat dst4(dst); + cv::Mat dst3; + cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR); - EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BayerGR2BGR) @@ -1871,15 +2605,23 @@ TEST_P(CvtColor, BayerGR2BGR) if ((depth != CV_8U && depth != CV_16U) || useRoi) return; - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR); - EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CvtColor, BayerGR2BGR4) @@ -1887,21 +2629,29 @@ TEST_P(CvtColor, BayerGR2BGR4) if ((depth != CV_8U && depth != CV_16U) || useRoi) return; - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst; - cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4); + cv::gpu::GpuMat dst; + cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4); - ASSERT_EQ(4, dst.channels()); + ASSERT_EQ(4, dst.channels()); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR); - cv::Mat dst4(dst); - cv::Mat dst3; - cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR); + cv::Mat dst4(dst); + cv::Mat dst3; + cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR); - EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine( @@ -1931,18 +2681,26 @@ PARAM_TEST_CASE(SwapChannels, cv::gpu::DeviceInfo, cv::Size, UseRoi) TEST_P(SwapChannels, Accuracy) { - cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4); - ASSERT_FALSE(src.empty()); + try + { + cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4); + ASSERT_FALSE(src.empty()); - cv::gpu::GpuMat d_src = loadMat(src, useRoi); + cv::gpu::GpuMat d_src = loadMat(src, useRoi); - const int dstOrder[] = {2, 1, 0, 3}; - cv::gpu::swapChannels(d_src, dstOrder); + const int dstOrder[] = {2, 1, 0, 3}; + cv::gpu::swapChannels(d_src, dstOrder); - cv::Mat dst_gold; - cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA); + cv::Mat dst_gold; + cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA); - EXPECT_MAT_NEAR(dst_gold, d_src, 0.0); + EXPECT_MAT_NEAR(dst_gold, d_src, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, SwapChannels, testing::Combine( diff --git a/modules/gpu/test/test_copy_make_border.cpp b/modules/gpu/test/test_copy_make_border.cpp index 0efd9ec68..7c9bb3554 100644 --- a/modules/gpu/test/test_copy_make_border.cpp +++ b/modules/gpu/test/test_copy_make_border.cpp @@ -71,16 +71,24 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border, TEST_P(CopyMakeBorder, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Scalar val = randomScalar(0, 255); + try + { + cv::Mat src = randomMat(size, type); + cv::Scalar val = randomScalar(0, 255); - cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi); - cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val); + cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi); + cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val); - cv::Mat dst_gold; - cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val); + cv::Mat dst_gold; + cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine( diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp index 695ec9758..d943ec7e7 100644 --- a/modules/gpu/test/test_core.cpp +++ b/modules/gpu/test/test_core.cpp @@ -70,36 +70,44 @@ PARAM_TEST_CASE(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi TEST_P(Merge, Accuracy) { - std::vector src; - src.reserve(channels); - for (int i = 0; i < channels; ++i) - src.push_back(cv::Mat(size, depth, cv::Scalar::all(i))); - - std::vector d_src; - for (int i = 0; i < channels; ++i) - d_src.push_back(loadMat(src[i], useRoi)); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + std::vector src; + src.reserve(channels); + for (int i = 0; i < channels; ++i) + src.push_back(cv::Mat(size, depth, cv::Scalar::all(i))); + + std::vector d_src; + for (int i = 0; i < channels; ++i) + d_src.push_back(loadMat(src[i], useRoi)); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + cv::gpu::GpuMat dst; + cv::gpu::merge(d_src, dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { cv::gpu::GpuMat dst; cv::gpu::merge(d_src, dst); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + + cv::Mat dst_gold; + cv::merge(src, dst_gold); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst; - cv::gpu::merge(d_src, dst); - - cv::Mat dst_gold; - cv::merge(src, dst_gold); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -139,34 +147,42 @@ PARAM_TEST_CASE(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi TEST_P(Split, Accuracy) { - cv::Mat src = randomMat(size, type); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, type); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + std::vector dst; + cv::gpu::split(loadMat(src), dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { std::vector dst; - cv::gpu::split(loadMat(src), dst); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::split(loadMat(src, useRoi), dst); + + std::vector dst_gold; + cv::split(src, dst_gold); + + ASSERT_EQ(dst_gold.size(), dst.size()); + + for (size_t i = 0; i < dst_gold.size(); ++i) + { + EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0); + } } } - else + catch (...) { - std::vector dst; - cv::gpu::split(loadMat(src, useRoi), dst); - - std::vector dst_gold; - cv::split(src, dst_gold); - - ASSERT_EQ(dst_gold.size(), dst.size()); - - for (size_t i = 0; i < dst_gold.size(); ++i) - { - EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0); - } + cv::gpu::resetDevice(); + throw; } } @@ -208,31 +224,39 @@ PARAM_TEST_CASE(Add_Array, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); - dst.setTo(cv::Scalar::all(0)); - cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second); - - cv::Mat dst_gold(size, dtype, cv::Scalar::all(0)); - cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -269,32 +293,40 @@ PARAM_TEST_CASE(Add_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); - dst.setTo(cv::Scalar::all(0)); - cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second); - - cv::Mat dst_gold(size, dtype, cv::Scalar::all(0)); - cv::add(mat1, mat2, dst_gold, mask, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -327,62 +359,78 @@ PARAM_TEST_CASE(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); - dst.setTo(cv::Scalar::all(0)); - cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second); - - cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0)); - cv::add(mat, val, dst_gold, cv::noArray(), depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(Add_Scalar, WithMask) { - cv::Mat mat = randomMat(size, depth.first); - cv::Scalar val = randomScalar(0, 255); - cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); - - if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat mat = randomMat(size, depth.first); + cv::Scalar val = randomScalar(0, 255); + cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); + + if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second); + try + { + cv::gpu::GpuMat dst; + cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); + dst.setTo(cv::Scalar::all(0)); + cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second); + + cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0)); + cv::add(mat, val, dst_gold, mask, depth.second); + + EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); - dst.setTo(cv::Scalar::all(0)); - cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second); - - cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0)); - cv::add(mat, val, dst_gold, mask, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -423,31 +471,39 @@ PARAM_TEST_CASE(Subtract_Array, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); - dst.setTo(cv::Scalar::all(0)); - cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second); - - cv::Mat dst_gold(size, dtype, cv::Scalar::all(0)); - cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -484,32 +540,40 @@ PARAM_TEST_CASE(Subtract_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); - dst.setTo(cv::Scalar::all(0)); - cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second); - - cv::Mat dst_gold(size, dtype, cv::Scalar::all(0)); - cv::subtract(mat1, mat2, dst_gold, mask, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -542,62 +606,78 @@ PARAM_TEST_CASE(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); - dst.setTo(cv::Scalar::all(0)); - cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second); - - cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0)); - cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(Subtract_Scalar, WithMask) { - cv::Mat mat = randomMat(size, depth.first); - cv::Scalar val = randomScalar(0, 255); - cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); - - if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat mat = randomMat(size, depth.first); + cv::Scalar val = randomScalar(0, 255); + cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); + + if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second); + try + { + cv::gpu::GpuMat dst; + cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); + dst.setTo(cv::Scalar::all(0)); + cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second); + + cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0)); + cv::subtract(mat, val, dst_gold, mask, depth.second); + + EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); - dst.setTo(cv::Scalar::all(0)); - cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second); - - cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0)); - cv::subtract(mat, val, dst_gold, mask, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -638,60 +718,76 @@ PARAM_TEST_CASE(Multiply_Array, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); - cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second); - - cv::Mat dst_gold; - cv::multiply(mat1, mat2, dst_gold, 1, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(Multiply_Array, WithScale) { - cv::Mat mat1 = randomMat(size, stype); - cv::Mat mat2 = randomMat(size, stype); - double scale = randomDouble(0.0, 255.0); - - if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat mat1 = randomMat(size, stype); + cv::Mat mat2 = randomMat(size, stype); + double scale = randomDouble(0.0, 255.0); + + if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second); + try + { + cv::gpu::GpuMat dst; + cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); + cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second); + + cv::Mat dst_gold; + cv::multiply(mat1, mat2, dst_gold, scale, depth.second); + + EXPECT_MAT_NEAR(dst_gold, dst, 2.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); - cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second); - - cv::Mat dst_gold; - cv::multiply(mat1, mat2, dst_gold, scale, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, 2.0); + cv::gpu::resetDevice(); + throw; } } @@ -723,76 +819,92 @@ PARAM_TEST_CASE(Multiply_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi) TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1) { - cv::Mat mat1 = randomMat(size, CV_8UC4); - cv::Mat mat2 = randomMat(size, CV_32FC1); - - cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi); - cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst); - - cv::Mat h_dst(dst); - - for (int y = 0; y < h_dst.rows; ++y) + try { - const cv::Vec4b* mat1_row = mat1.ptr(y); - const float* mat2_row = mat2.ptr(y); - const cv::Vec4b* dst_row = h_dst.ptr(y); + cv::Mat mat1 = randomMat(size, CV_8UC4); + cv::Mat mat2 = randomMat(size, CV_32FC1); - for (int x = 0; x < h_dst.cols; ++x) + cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi); + cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst); + + cv::Mat h_dst(dst); + + for (int y = 0; y < h_dst.rows; ++y) { - cv::Vec4b val1 = mat1_row[x]; - float val2 = mat2_row[x]; - cv::Vec4b actual = dst_row[x]; + const cv::Vec4b* mat1_row = mat1.ptr(y); + const float* mat2_row = mat2.ptr(y); + const cv::Vec4b* dst_row = h_dst.ptr(y); - cv::Vec4b gold; + for (int x = 0; x < h_dst.cols; ++x) + { + cv::Vec4b val1 = mat1_row[x]; + float val2 = mat2_row[x]; + cv::Vec4b actual = dst_row[x]; - gold[0] = cv::saturate_cast(val1[0] * val2); - gold[1] = cv::saturate_cast(val1[1] * val2); - gold[2] = cv::saturate_cast(val1[2] * val2); - gold[3] = cv::saturate_cast(val1[3] * val2); + cv::Vec4b gold; - ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + gold[0] = cv::saturate_cast(val1[0] * val2); + gold[1] = cv::saturate_cast(val1[1] * val2); + gold[2] = cv::saturate_cast(val1[2] * val2); + gold[3] = cv::saturate_cast(val1[3] * val2); + + ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + } } } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1) { - cv::Mat mat1 = randomMat(size, CV_16SC4); - cv::Mat mat2 = randomMat(size, CV_32FC1); - - cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi); - cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst); - - cv::Mat h_dst(dst); - - for (int y = 0; y < h_dst.rows; ++y) + try { - const cv::Vec4s* mat1_row = mat1.ptr(y); - const float* mat2_row = mat2.ptr(y); - const cv::Vec4s* dst_row = h_dst.ptr(y); + cv::Mat mat1 = randomMat(size, CV_16SC4); + cv::Mat mat2 = randomMat(size, CV_32FC1); - for (int x = 0; x < h_dst.cols; ++x) + cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi); + cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst); + + cv::Mat h_dst(dst); + + for (int y = 0; y < h_dst.rows; ++y) { - cv::Vec4s val1 = mat1_row[x]; - float val2 = mat2_row[x]; - cv::Vec4s actual = dst_row[x]; + const cv::Vec4s* mat1_row = mat1.ptr(y); + const float* mat2_row = mat2.ptr(y); + const cv::Vec4s* dst_row = h_dst.ptr(y); - cv::Vec4s gold; + for (int x = 0; x < h_dst.cols; ++x) + { + cv::Vec4s val1 = mat1_row[x]; + float val2 = mat2_row[x]; + cv::Vec4s actual = dst_row[x]; - gold[0] = cv::saturate_cast(val1[0] * val2); - gold[1] = cv::saturate_cast(val1[1] * val2); - gold[2] = cv::saturate_cast(val1[2] * val2); - gold[3] = cv::saturate_cast(val1[3] * val2); + cv::Vec4s gold; - ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + gold[0] = cv::saturate_cast(val1[0] * val2); + gold[1] = cv::saturate_cast(val1[1] * val2); + gold[2] = cv::saturate_cast(val1[2] * val2); + gold[3] = cv::saturate_cast(val1[3] * val2); + + ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + } } } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Multiply_Array_Special, testing::Combine( @@ -823,61 +935,77 @@ PARAM_TEST_CASE(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); - cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second); - - cv::Mat dst_gold; - cv::divide(mat1, mat2, dst_gold, 1, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(Divide_Array, WithScale) { - cv::Mat mat1 = randomMat(size, stype); - cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0); - double scale = randomDouble(0.0, 255.0); - - if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat mat1 = randomMat(size, stype); + cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0); + double scale = randomDouble(0.0, 255.0); + + if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second); + try + { + cv::gpu::GpuMat dst; + cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); + cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second); + + cv::Mat dst_gold; + cv::divide(mat1, mat2, dst_gold, scale, depth.second); + + EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dtype, useRoi); - cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second); - - cv::Mat dst_gold; - cv::divide(mat1, mat2, dst_gold, scale, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0); + cv::gpu::resetDevice(); + throw; } } @@ -1004,76 +1148,92 @@ PARAM_TEST_CASE(Divide_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi) TEST_P(Divide_Array_Special, Case_8UC4x_32FC1) { - cv::Mat mat1 = randomMat(size, CV_8UC4); - cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0); - - cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi); - cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst); - - cv::Mat h_dst(dst); - - for (int y = 0; y < h_dst.rows; ++y) + try { - const cv::Vec4b* mat1_row = mat1.ptr(y); - const float* mat2_row = mat2.ptr(y); - const cv::Vec4b* dst_row = h_dst.ptr(y); + cv::Mat mat1 = randomMat(size, CV_8UC4); + cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0); - for (int x = 0; x < h_dst.cols; ++x) + cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi); + cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst); + + cv::Mat h_dst(dst); + + for (int y = 0; y < h_dst.rows; ++y) { - cv::Vec4b val1 = mat1_row[x]; - float val2 = mat2_row[x]; - cv::Vec4b actual = dst_row[x]; + const cv::Vec4b* mat1_row = mat1.ptr(y); + const float* mat2_row = mat2.ptr(y); + const cv::Vec4b* dst_row = h_dst.ptr(y); - cv::Vec4b gold; + for (int x = 0; x < h_dst.cols; ++x) + { + cv::Vec4b val1 = mat1_row[x]; + float val2 = mat2_row[x]; + cv::Vec4b actual = dst_row[x]; - gold[0] = cv::saturate_cast(val1[0] / val2); - gold[1] = cv::saturate_cast(val1[1] / val2); - gold[2] = cv::saturate_cast(val1[2] / val2); - gold[3] = cv::saturate_cast(val1[3] / val2); + cv::Vec4b gold; - ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + gold[0] = cv::saturate_cast(val1[0] / val2); + gold[1] = cv::saturate_cast(val1[1] / val2); + gold[2] = cv::saturate_cast(val1[2] / val2); + gold[3] = cv::saturate_cast(val1[3] / val2); + + ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + } } } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Divide_Array_Special, Case_16SC4x_32FC1) { - cv::Mat mat1 = randomMat(size, CV_16SC4); - cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0); - - cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi); - cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst); - - cv::Mat h_dst(dst); - - for (int y = 0; y < h_dst.rows; ++y) + try { - const cv::Vec4s* mat1_row = mat1.ptr(y); - const float* mat2_row = mat2.ptr(y); - const cv::Vec4s* dst_row = h_dst.ptr(y); + cv::Mat mat1 = randomMat(size, CV_16SC4); + cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0); - for (int x = 0; x < h_dst.cols; ++x) + cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi); + cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst); + + cv::Mat h_dst(dst); + + for (int y = 0; y < h_dst.rows; ++y) { - cv::Vec4s val1 = mat1_row[x]; - float val2 = mat2_row[x]; - cv::Vec4s actual = dst_row[x]; + const cv::Vec4s* mat1_row = mat1.ptr(y); + const float* mat2_row = mat2.ptr(y); + const cv::Vec4s* dst_row = h_dst.ptr(y); - cv::Vec4s gold; + for (int x = 0; x < h_dst.cols; ++x) + { + cv::Vec4s val1 = mat1_row[x]; + float val2 = mat2_row[x]; + cv::Vec4s actual = dst_row[x]; - gold[0] = cv::saturate_cast(val1[0] / val2); - gold[1] = cv::saturate_cast(val1[1] / val2); - gold[2] = cv::saturate_cast(val1[2] / val2); - gold[3] = cv::saturate_cast(val1[3] / val2); + cv::Vec4s gold; - ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); - ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + gold[0] = cv::saturate_cast(val1[0] / val2); + gold[1] = cv::saturate_cast(val1[1] / val2); + gold[2] = cv::saturate_cast(val1[2] / val2); + gold[3] = cv::saturate_cast(val1[3] / val2); + + ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0); + } } } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Divide_Array_Special, testing::Combine( @@ -1104,60 +1264,76 @@ PARAM_TEST_CASE(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); - cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second); - - cv::Mat dst_gold; - cv::divide(mat, val, dst_gold, 1, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(Divide_Scalar, WithScale) { - cv::Mat mat = randomMat(size, depth.first); - cv::Scalar val = randomScalar(1.0, 255.0); - double scale = randomDouble(0.0, 255.0); - - if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat mat = randomMat(size, depth.first); + cv::Scalar val = randomScalar(1.0, 255.0); + double scale = randomDouble(0.0, 255.0); + + if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second); + try + { + cv::gpu::GpuMat dst; + cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); + cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second); + + cv::Mat dst_gold; + cv::divide(mat, val, dst_gold, scale, depth.second); + + EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); - cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second); - - cv::Mat dst_gold; - cv::divide(mat, val, dst_gold, scale, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -1190,30 +1366,38 @@ PARAM_TEST_CASE(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, std::pair= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi); - cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second); - - cv::Mat dst_gold; - cv::divide(scale, mat, dst_gold, depth.second); - - EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -1246,59 +1430,75 @@ PARAM_TEST_CASE(AbsDiff, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(AbsDiff, Array) { - cv::Mat src1 = randomMat(size, depth); - cv::Mat src2 = randomMat(size, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src1 = randomMat(size, depth); + cv::Mat src2 = randomMat(size, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst); + + cv::Mat dst_gold; + cv::absdiff(src1, src2, dst_gold); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst); - - cv::Mat dst_gold; - cv::absdiff(src1, src2, dst_gold); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(AbsDiff, Scalar) { - cv::Mat src = randomMat(size, depth); - cv::Scalar val = randomScalar(0.0, 255.0); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + cv::Scalar val = randomScalar(0.0, 255.0); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::absdiff(loadMat(src), val, dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::absdiff(loadMat(src), val, dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::absdiff(loadMat(src, useRoi), val, dst); + + cv::Mat dst_gold; + cv::absdiff(src, val, dst_gold); + + EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::absdiff(loadMat(src, useRoi), val, dst); - - cv::Mat dst_gold; - cv::absdiff(src, val, dst_gold); - - EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5); + cv::gpu::resetDevice(); + throw; } } @@ -1331,14 +1531,22 @@ PARAM_TEST_CASE(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(Abs, Accuracy) { - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::abs(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::abs(loadMat(src, useRoi), dst); - cv::Mat dst_gold = cv::abs(src); + cv::Mat dst_gold = cv::abs(src); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine( @@ -1370,15 +1578,23 @@ PARAM_TEST_CASE(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(Sqr, Accuracy) { - cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255); + try + { + cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255); - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::sqr(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::sqr(loadMat(src, useRoi), dst); - cv::Mat dst_gold; - cv::multiply(src, src, dst_gold); + cv::Mat dst_gold; + cv::multiply(src, src, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine( @@ -1437,15 +1653,23 @@ PARAM_TEST_CASE(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(Sqrt, Accuracy) { - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::sqrt(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::sqrt(loadMat(src, useRoi), dst); - cv::Mat dst_gold; - sqrtGold(src, dst_gold); + cv::Mat dst_gold; + sqrtGold(src, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5); + EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine( @@ -1504,15 +1728,23 @@ PARAM_TEST_CASE(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(Log, Accuracy) { - cv::Mat src = randomMat(size, depth, 1.0, 255.0); + try + { + cv::Mat src = randomMat(size, depth, 1.0, 255.0); - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::log(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::log(loadMat(src, useRoi), dst); - cv::Mat dst_gold; - logGold(src, dst_gold); + cv::Mat dst_gold; + logGold(src, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6); + EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine( @@ -1581,15 +1813,23 @@ PARAM_TEST_CASE(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(Exp, Accuracy) { - cv::Mat src = randomMat(size, depth, 0.0, 10.0); + try + { + cv::Mat src = randomMat(size, depth, 0.0, 10.0); - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::exp(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::exp(loadMat(src, useRoi), dst); - cv::Mat dst_gold; - expGold(src, dst_gold); + cv::Mat dst_gold; + expGold(src, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2); + EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine( @@ -1629,30 +1869,38 @@ PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode, TEST_P(Compare_Array, Accuracy) { - cv::Mat src1 = randomMat(size, depth); - cv::Mat src2 = randomMat(size, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src1 = randomMat(size, depth); + cv::Mat src2 = randomMat(size, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code); + try + { + cv::gpu::GpuMat dst; + cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi); + cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code); + + cv::Mat dst_gold; + cv::compare(src1, src2, dst_gold, cmp_code); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi); - cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code); - - cv::Mat dst_gold; - cv::compare(src1, src2, dst_gold, cmp_code); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -1731,39 +1979,47 @@ PARAM_TEST_CASE(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatType, CmpCode, TEST_P(Compare_Scalar, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Scalar sc = randomScalar(0.0, 255.0); - - if (src.depth() < CV_32F) + try { - sc.val[0] = cvRound(sc.val[0]); - sc.val[1] = cvRound(sc.val[1]); - sc.val[2] = cvRound(sc.val[2]); - sc.val[3] = cvRound(sc.val[3]); - } + cv::Mat src = randomMat(size, type); + cv::Scalar sc = randomScalar(0.0, 255.0); - if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) - { - try + if (src.depth() < CV_32F) { - cv::gpu::GpuMat dst; - cv::gpu::compare(loadMat(src), sc, dst, cmp_code); + sc.val[0] = cvRound(sc.val[0]); + sc.val[1] = cvRound(sc.val[1]); + sc.val[2] = cvRound(sc.val[2]); + sc.val[3] = cvRound(sc.val[3]); } - catch (const cv::Exception& e) + + if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + try + { + cv::gpu::GpuMat dst; + cv::gpu::compare(loadMat(src), sc, dst, cmp_code); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else + { + cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi); + + cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code); + + cv::Mat dst_gold; + compareScalarGold(src, sc, dst_gold, cmp_code); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi); - - cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code); - - cv::Mat dst_gold; - compareScalarGold(src, sc, dst_gold, cmp_code); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -1801,42 +2057,74 @@ PARAM_TEST_CASE(Bitwise_Array, cv::gpu::DeviceInfo, cv::Size, MatType) TEST_P(Bitwise_Array, Not) { - cv::gpu::GpuMat dst; - cv::gpu::bitwise_not(loadMat(src1), dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::bitwise_not(loadMat(src1), dst); - cv::Mat dst_gold = ~src1; + cv::Mat dst_gold = ~src1; - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Bitwise_Array, Or) { - cv::gpu::GpuMat dst; - cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst); - cv::Mat dst_gold = src1 | src2; + cv::Mat dst_gold = src1 | src2; - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Bitwise_Array, And) { - cv::gpu::GpuMat dst; - cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst); - cv::Mat dst_gold = src1 & src2; + cv::Mat dst_gold = src1 & src2; - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Bitwise_Array, Xor) { - cv::gpu::GpuMat dst; - cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst); - cv::Mat dst_gold = src1 ^ src2; + cv::Mat dst_gold = src1 ^ src2; - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Array, testing::Combine( @@ -1874,35 +2162,59 @@ PARAM_TEST_CASE(Bitwise_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channel TEST_P(Bitwise_Scalar, Or) { - cv::gpu::GpuMat dst; - cv::gpu::bitwise_or(loadMat(src), val, dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::bitwise_or(loadMat(src), val, dst); - cv::Mat dst_gold; - cv::bitwise_or(src, val, dst_gold); + cv::Mat dst_gold; + cv::bitwise_or(src, val, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Bitwise_Scalar, And) { - cv::gpu::GpuMat dst; - cv::gpu::bitwise_and(loadMat(src), val, dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::bitwise_and(loadMat(src), val, dst); - cv::Mat dst_gold; - cv::bitwise_and(src, val, dst_gold); + cv::Mat dst_gold; + cv::bitwise_and(src, val, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Bitwise_Scalar, Xor) { - cv::gpu::GpuMat dst; - cv::gpu::bitwise_xor(loadMat(src), val, dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::bitwise_xor(loadMat(src), val, dst); - cv::Mat dst_gold; - cv::bitwise_xor(src, val, dst_gold); + cv::Mat dst_gold; + cv::bitwise_xor(src, val, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine( @@ -1964,17 +2276,25 @@ PARAM_TEST_CASE(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo TEST_P(RShift, Accuracy) { - int type = CV_MAKE_TYPE(depth, channels); - cv::Mat src = randomMat(size, type); - cv::Scalar_ val = randomScalar(0.0, 8.0); + try + { + int type = CV_MAKE_TYPE(depth, channels); + cv::Mat src = randomMat(size, type); + cv::Scalar_ val = randomScalar(0.0, 8.0); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::rshift(loadMat(src, useRoi), val, dst); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::rshift(loadMat(src, useRoi), val, dst); - cv::Mat dst_gold; - rhiftGold(src, val, dst_gold); + cv::Mat dst_gold; + rhiftGold(src, val, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, RShift, testing::Combine( @@ -2041,17 +2361,25 @@ PARAM_TEST_CASE(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo TEST_P(LShift, Accuracy) { - int type = CV_MAKE_TYPE(depth, channels); - cv::Mat src = randomMat(size, type); - cv::Scalar_ val = randomScalar(0.0, 8.0); + try + { + int type = CV_MAKE_TYPE(depth, channels); + cv::Mat src = randomMat(size, type); + cv::Scalar_ val = randomScalar(0.0, 8.0); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::lshift(loadMat(src, useRoi), val, dst); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::lshift(loadMat(src, useRoi), val, dst); - cv::Mat dst_gold; - lhiftGold(src, val, dst_gold); + cv::Mat dst_gold; + lhiftGold(src, val, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, LShift, testing::Combine( @@ -2084,57 +2412,73 @@ PARAM_TEST_CASE(Min, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(Min, Array) { - cv::Mat src1 = randomMat(size, depth); - cv::Mat src2 = randomMat(size, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src1 = randomMat(size, depth); + cv::Mat src2 = randomMat(size, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::min(loadMat(src1), loadMat(src2), dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::min(loadMat(src1), loadMat(src2), dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst); + + cv::Mat dst_gold = cv::min(src1, src2); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst); - - cv::Mat dst_gold = cv::min(src1, src2); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(Min, Scalar) { - cv::Mat src = randomMat(size, depth); - double val = randomDouble(0.0, 255.0); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + double val = randomDouble(0.0, 255.0); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::min(loadMat(src), val, dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::min(loadMat(src), val, dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::min(loadMat(src, useRoi), val, dst); + + cv::Mat dst_gold = cv::min(src, val); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::min(loadMat(src, useRoi), val, dst); - - cv::Mat dst_gold = cv::min(src, val); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -2167,57 +2511,73 @@ PARAM_TEST_CASE(Max, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(Max, Array) { - cv::Mat src1 = randomMat(size, depth); - cv::Mat src2 = randomMat(size, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src1 = randomMat(size, depth); + cv::Mat src2 = randomMat(size, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::max(loadMat(src1), loadMat(src2), dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::max(loadMat(src1), loadMat(src2), dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst); + + cv::Mat dst_gold = cv::max(src1, src2); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst); - - cv::Mat dst_gold = cv::max(src1, src2); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(Max, Scalar) { - cv::Mat src = randomMat(size, depth); - double val = randomDouble(0.0, 255.0); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + double val = randomDouble(0.0, 255.0); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::max(loadMat(src), val, dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::max(loadMat(src), val, dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::max(loadMat(src, useRoi), val, dst); + + cv::Mat dst_gold = cv::max(src, val); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::max(loadMat(src, useRoi), val, dst); - - cv::Mat dst_gold = cv::max(src, val); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -2250,33 +2610,41 @@ PARAM_TEST_CASE(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(Pow, Accuracy) { - cv::Mat src = randomMat(size, depth, 0.0, 10.0); - double power = randomDouble(2.0, 4.0); - - if (src.depth() < CV_32F) - power = static_cast(power); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth, 0.0, 10.0); + double power = randomDouble(2.0, 4.0); + + if (src.depth() < CV_32F) + power = static_cast(power); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::pow(loadMat(src), power, dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::pow(loadMat(src), power, dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, depth, useRoi); + cv::gpu::pow(loadMat(src, useRoi), power, dst); + + cv::Mat dst_gold; + cv::pow(src, power, dst_gold); + + EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, depth, useRoi); - cv::gpu::pow(loadMat(src, useRoi), power, dst); - - cv::Mat dst_gold; - cv::pow(src, power, dst_gold); - - EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1); + cv::gpu::resetDevice(); + throw; } } @@ -2313,33 +2681,41 @@ PARAM_TEST_CASE(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, TEST_P(AddWeighted, Accuracy) { - cv::Mat src1 = randomMat(size, depth1); - cv::Mat src2 = randomMat(size, depth2); - double alpha = randomDouble(-10.0, 10.0); - double beta = randomDouble(-10.0, 10.0); - double gamma = randomDouble(-10.0, 10.0); - - if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src1 = randomMat(size, depth1); + cv::Mat src2 = randomMat(size, depth2); + double alpha = randomDouble(-10.0, 10.0); + double beta = randomDouble(-10.0, 10.0); + double gamma = randomDouble(-10.0, 10.0); + + if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth); + try + { + cv::gpu::GpuMat dst; + cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi); + cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth); + + cv::Mat dst_gold; + cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth); + + EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi); - cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth); - - cv::Mat dst_gold; - cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth); - - EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3); + cv::gpu::resetDevice(); + throw; } } @@ -2354,6 +2730,8 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine( ////////////////////////////////////////////////////////////////////////////// // GEMM +#ifdef HAVE_CUBLAS + CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T); #define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T)) @@ -2379,58 +2757,54 @@ PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi) TEST_P(GEMM, Accuracy) { - cv::Mat src1 = randomMat(size, type, -10.0, 10.0); - cv::Mat src2 = randomMat(size, type, -10.0, 10.0); - cv::Mat src3 = randomMat(size, type, -10.0, 10.0); - double alpha = randomDouble(-10.0, 10.0); - double beta = randomDouble(-10.0, 10.0); - -#ifndef HAVE_CUBLAS try { - cv::gpu::GpuMat dst; - cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); - } -#else - if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) - { - try - { - cv::gpu::GpuMat dst; - cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); - } - } - else if (type == CV_64FC2 && flags != 0) - { - try - { - cv::gpu::GpuMat dst; - cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); - } - } - else - { - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags); + cv::Mat src1 = randomMat(size, type, -10.0, 10.0); + cv::Mat src2 = randomMat(size, type, -10.0, 10.0); + cv::Mat src3 = randomMat(size, type, -10.0, 10.0); + double alpha = randomDouble(-10.0, 10.0); + double beta = randomDouble(-10.0, 10.0); - cv::Mat dst_gold; - cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags); + if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + cv::gpu::GpuMat dst; + cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else if (type == CV_64FC2 && flags != 0) + { + try + { + cv::gpu::GpuMat dst; + cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsNotImplemented, e.code); + } + } + else + { + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags); - EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10); + cv::Mat dst_gold; + cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags); + + EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } -#endif } INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine( @@ -2440,6 +2814,8 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine( ALL_GEMM_FLAGS, WHOLE_SUBMAT)); +#endif // HAVE_CUBLAS + //////////////////////////////////////////////////////////////////////////////// // Transpose @@ -2463,29 +2839,37 @@ PARAM_TEST_CASE(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(Transpose, Accuracy) { - cv::Mat src = randomMat(size, type); - - if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, type); + + if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat dst; - cv::gpu::transpose(loadMat(src), dst); + try + { + cv::gpu::GpuMat dst; + cv::gpu::transpose(loadMat(src), dst); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi); + cv::gpu::transpose(loadMat(src, useRoi), dst); + + cv::Mat dst_gold; + cv::transpose(src, dst_gold); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi); - cv::gpu::transpose(loadMat(src, useRoi), dst); - - cv::Mat dst_gold; - cv::transpose(src, dst_gold); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -2530,15 +2914,23 @@ PARAM_TEST_CASE(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode, UseRoi) TEST_P(Flip, Accuracy) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::flip(loadMat(src, useRoi), dst, flip_code); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::flip(loadMat(src, useRoi), dst, flip_code); - cv::Mat dst_gold; - cv::flip(src, dst_gold, flip_code); + cv::Mat dst_gold; + cv::flip(src, dst_gold, flip_code); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Flip, testing::Combine( @@ -2582,30 +2974,46 @@ PARAM_TEST_CASE(LUT, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(LUT, OneChannel) { - cv::Mat src = randomMat(size, type); - cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1); + try + { + cv::Mat src = randomMat(size, type); + cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1); - cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels())); - cv::gpu::LUT(loadMat(src, useRoi), lut, dst); + cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels())); + cv::gpu::LUT(loadMat(src, useRoi), lut, dst); - cv::Mat dst_gold; - cv::LUT(src, lut, dst_gold); + cv::Mat dst_gold; + cv::LUT(src, lut, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(LUT, MultiChannel) { - cv::Mat src = randomMat(size, type); - cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels())); + try + { + cv::Mat src = randomMat(size, type); + cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels())); - cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi); - cv::gpu::LUT(loadMat(src, useRoi), lut, dst); + cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi); + cv::gpu::LUT(loadMat(src, useRoi), lut, dst); - cv::Mat dst_gold; - cv::LUT(src, lut, dst_gold); + cv::Mat dst_gold; + cv::LUT(src, lut, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, LUT, testing::Combine( @@ -2635,62 +3043,94 @@ PARAM_TEST_CASE(Magnitude, cv::gpu::DeviceInfo, cv::Size, UseRoi) TEST_P(Magnitude, NPP) { - cv::Mat src = randomMat(size, CV_32FC2); + try + { + cv::Mat src = randomMat(size, CV_32FC2); - cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); - cv::gpu::magnitude(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); + cv::gpu::magnitude(loadMat(src, useRoi), dst); - cv::Mat arr[2]; - cv::split(src, arr); - cv::Mat dst_gold; - cv::magnitude(arr[0], arr[1], dst_gold); + cv::Mat arr[2]; + cv::split(src, arr); + cv::Mat dst_gold; + cv::magnitude(arr[0], arr[1], dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-4); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-4); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Magnitude, Sqr_NPP) { - cv::Mat src = randomMat(size, CV_32FC2); + try + { + cv::Mat src = randomMat(size, CV_32FC2); - cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); - cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); + cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst); - cv::Mat arr[2]; - cv::split(src, arr); - cv::Mat dst_gold; - cv::magnitude(arr[0], arr[1], dst_gold); - cv::multiply(dst_gold, dst_gold, dst_gold); + cv::Mat arr[2]; + cv::split(src, arr); + cv::Mat dst_gold; + cv::magnitude(arr[0], arr[1], dst_gold); + cv::multiply(dst_gold, dst_gold, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-1); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Magnitude, Accuracy) { - cv::Mat x = randomMat(size, CV_32FC1); - cv::Mat y = randomMat(size, CV_32FC1); + try + { + cv::Mat x = randomMat(size, CV_32FC1); + cv::Mat y = randomMat(size, CV_32FC1); - cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); - cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); + cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst); - cv::Mat dst_gold; - cv::magnitude(x, y, dst_gold); + cv::Mat dst_gold; + cv::magnitude(x, y, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-4); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-4); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Magnitude, Sqr_Accuracy) { - cv::Mat x = randomMat(size, CV_32FC1); - cv::Mat y = randomMat(size, CV_32FC1); + try + { + cv::Mat x = randomMat(size, CV_32FC1); + cv::Mat y = randomMat(size, CV_32FC1); - cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); - cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst); + cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); + cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst); - cv::Mat dst_gold; - cv::magnitude(x, y, dst_gold); - cv::multiply(dst_gold, dst_gold, dst_gold); + cv::Mat dst_gold; + cv::magnitude(x, y, dst_gold); + cv::multiply(dst_gold, dst_gold, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 1e-1); + EXPECT_MAT_NEAR(dst_gold, dst, 1e-1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Magnitude, testing::Combine( @@ -2723,16 +3163,24 @@ PARAM_TEST_CASE(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi) TEST_P(Phase, Accuracy) { - cv::Mat x = randomMat(size, CV_32FC1); - cv::Mat y = randomMat(size, CV_32FC1); + try + { + cv::Mat x = randomMat(size, CV_32FC1); + cv::Mat y = randomMat(size, CV_32FC1); - cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); - cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees); + cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi); + cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees); - cv::Mat dst_gold; - cv::phase(x, y, dst_gold, angleInDegrees); + cv::Mat dst_gold; + cv::phase(x, y, dst_gold, angleInDegrees); - EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3); + EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Phase, testing::Combine( @@ -2764,19 +3212,27 @@ PARAM_TEST_CASE(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR TEST_P(CartToPolar, Accuracy) { - cv::Mat x = randomMat(size, CV_32FC1); - cv::Mat y = randomMat(size, CV_32FC1); + try + { + cv::Mat x = randomMat(size, CV_32FC1); + cv::Mat y = randomMat(size, CV_32FC1); - cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi); - cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi); - cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees); + cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi); + cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi); + cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees); - cv::Mat mag_gold; - cv::Mat angle_gold; - cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees); + cv::Mat mag_gold; + cv::Mat angle_gold; + cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees); - EXPECT_MAT_NEAR(mag_gold, mag, 1e-4); - EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3); + EXPECT_MAT_NEAR(mag_gold, mag, 1e-4); + EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, CartToPolar, testing::Combine( @@ -2808,19 +3264,27 @@ PARAM_TEST_CASE(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR TEST_P(PolarToCart, Accuracy) { - cv::Mat magnitude = randomMat(size, CV_32FC1); - cv::Mat angle = randomMat(size, CV_32FC1); + try + { + cv::Mat magnitude = randomMat(size, CV_32FC1); + cv::Mat angle = randomMat(size, CV_32FC1); - cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi); - cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi); - cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees); + cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi); + cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi); + cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees); - cv::Mat x_gold; - cv::Mat y_gold; - cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees); + cv::Mat x_gold; + cv::Mat y_gold; + cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees); - EXPECT_MAT_NEAR(x_gold, x, 1e-4); - EXPECT_MAT_NEAR(y_gold, y, 1e-4); + EXPECT_MAT_NEAR(x_gold, x, 1e-4); + EXPECT_MAT_NEAR(y_gold, y, 1e-4); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, PolarToCart, testing::Combine( @@ -2850,33 +3314,41 @@ PARAM_TEST_CASE(MeanStdDev, cv::gpu::DeviceInfo, cv::Size, UseRoi) TEST_P(MeanStdDev, Accuracy) { - cv::Mat src = randomMat(size, CV_8UC1); - - if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13)) + try { - try + cv::Mat src = randomMat(size, CV_8UC1); + + if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13)) + { + try + { + cv::Scalar mean; + cv::Scalar stddev; + cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsNotImplemented, e.code); + } + } + else { cv::Scalar mean; cv::Scalar stddev; cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); + + cv::Scalar mean_gold; + cv::Scalar stddev_gold; + cv::meanStdDev(src, mean_gold, stddev_gold); + + EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5); + EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5); } } - else + catch (...) { - cv::Scalar mean; - cv::Scalar stddev; - cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev); - - cv::Scalar mean_gold; - cv::Scalar stddev_gold; - cv::meanStdDev(src, mean_gold, stddev_gold); - - EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5); - EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5); + cv::gpu::resetDevice(); + throw; } } @@ -2910,13 +3382,21 @@ PARAM_TEST_CASE(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi) TEST_P(Norm, Accuracy) { - cv::Mat src = randomMat(size, depth); + try + { + cv::Mat src = randomMat(size, depth); - double val = cv::gpu::norm(loadMat(src, useRoi), normCode); + double val = cv::gpu::norm(loadMat(src, useRoi), normCode); - double val_gold = cv::norm(src, normCode); + double val_gold = cv::norm(src, normCode); - EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0); + EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Norm, testing::Combine( @@ -2954,14 +3434,22 @@ PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormCode, UseRoi) TEST_P(NormDiff, Accuracy) { - cv::Mat src1 = randomMat(size, CV_8UC1); - cv::Mat src2 = randomMat(size, CV_8UC1); + try + { + cv::Mat src1 = randomMat(size, CV_8UC1); + cv::Mat src2 = randomMat(size, CV_8UC1); - double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode); + double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode); - double val_gold = cv::norm(src1, src2, normCode); + double val_gold = cv::norm(src1, src2, normCode); - EXPECT_NEAR(val_gold, val, 0.0); + EXPECT_NEAR(val_gold, val, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, NormDiff, testing::Combine( @@ -3074,29 +3562,53 @@ PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(Sum, Simple) { - cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi)); + try + { + cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi)); - cv::Scalar val_gold = cv::sum(src); + cv::Scalar val_gold = cv::sum(src); - EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5); + EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Sum, Abs) { - cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi)); + try + { + cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi)); - cv::Scalar val_gold = absSumGold(src); + cv::Scalar val_gold = absSumGold(src); - EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5); + EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Sum, Sqr) { - cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi)); + try + { + cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi)); - cv::Scalar val_gold = sqrSumGold(src); + cv::Scalar val_gold = sqrSumGold(src); - EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5); + EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine( @@ -3128,91 +3640,115 @@ PARAM_TEST_CASE(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(MinMax, WithoutMask) { - cv::Mat src = randomMat(size, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + double minVal, maxVal; + cv::gpu::minMax(loadMat(src), &minVal, &maxVal); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { double minVal, maxVal; - cv::gpu::minMax(loadMat(src), &minVal, &maxVal); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal); + + double minVal_gold, maxVal_gold; + minMaxLocGold(src, &minVal_gold, &maxVal_gold); + + EXPECT_DOUBLE_EQ(minVal_gold, minVal); + EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); } } - else + catch (...) { - double minVal, maxVal; - cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal); - - double minVal_gold, maxVal_gold; - minMaxLocGold(src, &minVal_gold, &maxVal_gold); - - EXPECT_DOUBLE_EQ(minVal_gold, minVal); - EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); + cv::gpu::resetDevice(); + throw; } } TEST_P(MinMax, WithMask) { - cv::Mat src = randomMat(size, depth); - cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + double minVal, maxVal; + cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask)); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { double minVal, maxVal; - cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask)); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi)); + + double minVal_gold, maxVal_gold; + minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask); + + EXPECT_DOUBLE_EQ(minVal_gold, minVal); + EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); } } - else + catch (...) { - double minVal, maxVal; - cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi)); - - double minVal_gold, maxVal_gold; - minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask); - - EXPECT_DOUBLE_EQ(minVal_gold, minVal); - EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); + cv::gpu::resetDevice(); + throw; } } TEST_P(MinMax, NullPtr) { - cv::Mat src = randomMat(size, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + double minVal, maxVal; + cv::gpu::minMax(loadMat(src), &minVal, 0); + cv::gpu::minMax(loadMat(src), 0, &maxVal); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { double minVal, maxVal; - cv::gpu::minMax(loadMat(src), &minVal, 0); - cv::gpu::minMax(loadMat(src), 0, &maxVal); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0); + cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal); + + double minVal_gold, maxVal_gold; + minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0); + + EXPECT_DOUBLE_EQ(minVal_gold, minVal); + EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); } } - else + catch (...) { - double minVal, maxVal; - cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0); - cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal); - - double minVal_gold, maxVal_gold; - minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0); - - EXPECT_DOUBLE_EQ(minVal_gold, minVal); - EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); + cv::gpu::resetDevice(); + throw; } } @@ -3269,82 +3805,114 @@ PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(MinMaxLoc, WithoutMask) { - cv::Mat src = randomMat(size, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + double minVal, maxVal; + cv::Point minLoc, maxLoc; + cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { double minVal, maxVal; cv::Point minLoc, maxLoc; - cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc); + + double minVal_gold, maxVal_gold; + cv::Point minLoc_gold, maxLoc_gold; + minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold); + + EXPECT_DOUBLE_EQ(minVal_gold, minVal); + EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); + + expectEqual(src, minLoc_gold, minLoc); + expectEqual(src, maxLoc_gold, maxLoc); } } - else + catch (...) { - double minVal, maxVal; - cv::Point minLoc, maxLoc; - cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc); - - double minVal_gold, maxVal_gold; - cv::Point minLoc_gold, maxLoc_gold; - minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold); - - EXPECT_DOUBLE_EQ(minVal_gold, minVal); - EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); - - expectEqual(src, minLoc_gold, minLoc); - expectEqual(src, maxLoc_gold, maxLoc); + cv::gpu::resetDevice(); + throw; } } TEST_P(MinMaxLoc, WithMask) { - cv::Mat src = randomMat(size, depth); - cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + double minVal, maxVal; + cv::Point minLoc, maxLoc; + cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask)); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { double minVal, maxVal; cv::Point minLoc, maxLoc; - cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask)); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi)); + + double minVal_gold, maxVal_gold; + cv::Point minLoc_gold, maxLoc_gold; + minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask); + + EXPECT_DOUBLE_EQ(minVal_gold, minVal); + EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); + + expectEqual(src, minLoc_gold, minLoc); + expectEqual(src, maxLoc_gold, maxLoc); } } - else + catch (...) { - double minVal, maxVal; - cv::Point minLoc, maxLoc; - cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi)); - - double minVal_gold, maxVal_gold; - cv::Point minLoc_gold, maxLoc_gold; - minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask); - - EXPECT_DOUBLE_EQ(minVal_gold, minVal); - EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); - - expectEqual(src, minLoc_gold, minLoc); - expectEqual(src, maxLoc_gold, maxLoc); + cv::gpu::resetDevice(); + throw; } } TEST_P(MinMaxLoc, NullPtr) { - cv::Mat src = randomMat(size, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + double minVal, maxVal; + cv::Point minLoc, maxLoc; + cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0); + cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0); + cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0); + cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { double minVal, maxVal; cv::Point minLoc, maxLoc; @@ -3352,30 +3920,22 @@ TEST_P(MinMaxLoc, NullPtr) cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0); cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0); cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + + double minVal_gold, maxVal_gold; + cv::Point minLoc_gold, maxLoc_gold; + minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold); + + EXPECT_DOUBLE_EQ(minVal_gold, minVal); + EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); + + expectEqual(src, minLoc_gold, minLoc); + expectEqual(src, maxLoc_gold, maxLoc); } } - else + catch (...) { - double minVal, maxVal; - cv::Point minLoc, maxLoc; - cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0); - cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0); - cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0); - cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc); - - double minVal_gold, maxVal_gold; - cv::Point minLoc_gold, maxLoc_gold; - minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold); - - EXPECT_DOUBLE_EQ(minVal_gold, minVal); - EXPECT_DOUBLE_EQ(maxVal_gold, maxVal); - - expectEqual(src, minLoc_gold, minLoc); - expectEqual(src, maxLoc_gold, maxLoc); + cv::gpu::resetDevice(); + throw; } } @@ -3409,28 +3969,36 @@ PARAM_TEST_CASE(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi) TEST_P(CountNonZero, Accuracy) { - cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5); - cv::Mat src; - srcBase.convertTo(src, depth); - - if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5); + cv::Mat src; + srcBase.convertTo(src, depth); + + if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::countNonZero(loadMat(src)); + try + { + cv::gpu::countNonZero(loadMat(src)); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + int val = cv::gpu::countNonZero(loadMat(src, useRoi)); + + int val_gold = cv::countNonZero(src); + + ASSERT_EQ(val_gold, val); } } - else + catch (...) { - int val = cv::gpu::countNonZero(loadMat(src, useRoi)); - - int val_gold = cv::countNonZero(src); - - ASSERT_EQ(val_gold, val); + cv::gpu::resetDevice(); + throw; } } @@ -3486,31 +4054,47 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc TEST_P(Reduce, Rows) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi); - cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth); + cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi); + cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth); - cv::Mat dst_gold; - cv::reduce(src, dst_gold, 0, reduceOp, dst_depth); + cv::Mat dst_gold; + cv::reduce(src, dst_gold, 0, reduceOp, dst_depth); - EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02); + EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(Reduce, Cols) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi); - cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth); + cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi); + cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth); - cv::Mat dst_gold; - cv::reduce(src, dst_gold, 1, reduceOp, dst_depth); - dst_gold.cols = dst_gold.rows; - dst_gold.rows = 1; - dst_gold.step = dst_gold.cols * dst_gold.elemSize(); + cv::Mat dst_gold; + cv::reduce(src, dst_gold, 1, reduceOp, dst_depth); + dst_gold.cols = dst_gold.rows; + dst_gold.rows = 1; + dst_gold.step = dst_gold.cols * dst_gold.elemSize(); - EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02); + EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine( diff --git a/modules/gpu/test/test_denoising.cpp b/modules/gpu/test/test_denoising.cpp index 80bf3dbe2..5edf973f4 100644 --- a/modules/gpu/test/test_denoising.cpp +++ b/modules/gpu/test/test_denoising.cpp @@ -71,17 +71,25 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType) TEST_P(BilateralFilter, Accuracy) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - src.convertTo(src, type); - cv::gpu::GpuMat dst; + src.convertTo(src, type); + cv::gpu::GpuMat dst; - cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial); + cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial); - cv::Mat dst_gold; - cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial); + cv::Mat dst_gold; + 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); + 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,35 +115,41 @@ struct BruteForceNonLocalMeans: testing::TestWithParam TEST_P(BruteForceNonLocalMeans, Regression) { - using cv::gpu::GpuMat; + try + { + using cv::gpu::GpuMat; - cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR); - ASSERT_FALSE(bgr.empty()); + cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR); + ASSERT_FALSE(bgr.empty()); - cv::Mat gray; - cv::cvtColor(bgr, gray, CV_BGR2GRAY); + cv::Mat gray; + cv::cvtColor(bgr, gray, CV_BGR2GRAY); - GpuMat dbgr, dgray; - cv::gpu::nonLocalMeans(GpuMat(bgr), dbgr, 20); - cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20); + GpuMat dbgr, dgray; + cv::gpu::nonLocalMeans(GpuMat(bgr), dbgr, 20); + cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20); -#if 0 - dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr)); - dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray)); -#endif + #if 0 + dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr)); + dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray)); + #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); - ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty()); + 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); + ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty()); - EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4); - EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4); + 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,34 +166,41 @@ struct FastNonLocalMeans: testing::TestWithParam TEST_P(FastNonLocalMeans, Regression) { - using cv::gpu::GpuMat; + try + { + using cv::gpu::GpuMat; - cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR); - ASSERT_FALSE(bgr.empty()); + cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR); + ASSERT_FALSE(bgr.empty()); - cv::Mat gray; - cv::cvtColor(bgr, gray, CV_BGR2GRAY); + cv::Mat gray; + cv::cvtColor(bgr, gray, CV_BGR2GRAY); - GpuMat dbgr, dgray; - cv::gpu::FastNonLocalMeansDenoising fnlmd; + GpuMat dbgr, dgray; + cv::gpu::FastNonLocalMeansDenoising fnlmd; - fnlmd.simpleMethod(GpuMat(gray), dgray, 20); - fnlmd.labMethod(GpuMat(bgr), dbgr, 20, 10); + fnlmd.simpleMethod(GpuMat(gray), dgray, 20); + fnlmd.labMethod(GpuMat(bgr), dbgr, 20, 10); -#if 0 - //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr)); - //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray)); -#endif + #if 0 + //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr)); + //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray)); + #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); - ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty()); + 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); + ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty()); - EXPECT_MAT_NEAR(bgr_gold, dbgr, 1); - EXPECT_MAT_NEAR(gray_gold, dgray, 1); + 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 diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp index c76fe9166..a20ae68b4 100644 --- a/modules/gpu/test/test_features2d.cpp +++ b/modules/gpu/test/test_features2d.cpp @@ -180,31 +180,19 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves, TEST_P(SURF, Detector) { - cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(image.empty()); - - cv::gpu::SURF_GPU surf; - surf.hessianThreshold = hessianThreshold; - surf.nOctaves = nOctaves; - surf.nOctaveLayers = nOctaveLayers; - surf.extended = extended; - surf.upright = upright; - surf.keypointsRatio = 0.05f; - - if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS)) - { - try - { - std::vector keypoints; - surf(loadMat(image), cv::gpu::GpuMat(), keypoints); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); - } - } - else + try { + cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(image.empty()); + + cv::gpu::SURF_GPU surf; + surf.hessianThreshold = hessianThreshold; + surf.nOctaves = nOctaves; + surf.nOctaveLayers = nOctaveLayers; + surf.extended = extended; + surf.upright = upright; + surf.keypointsRatio = 0.05f; + std::vector keypoints; surf(loadMat(image), cv::gpu::GpuMat(), keypoints); @@ -224,38 +212,31 @@ TEST_P(SURF, Detector) EXPECT_GT(matchedRatio, 0.95); } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(SURF, Detector_Masked) { - cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(image.empty()); - - cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1)); - mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0)); - - cv::gpu::SURF_GPU surf; - surf.hessianThreshold = hessianThreshold; - surf.nOctaves = nOctaves; - surf.nOctaveLayers = nOctaveLayers; - surf.extended = extended; - surf.upright = upright; - surf.keypointsRatio = 0.05f; - - if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS)) - { - try - { - std::vector keypoints; - surf(loadMat(image), loadMat(mask), keypoints); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); - } - } - else + try { + cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(image.empty()); + + cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1)); + mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0)); + + cv::gpu::SURF_GPU surf; + surf.hessianThreshold = hessianThreshold; + surf.nOctaves = nOctaves; + surf.nOctaveLayers = nOctaveLayers; + surf.extended = extended; + surf.upright = upright; + surf.keypointsRatio = 0.05f; + std::vector keypoints; surf(loadMat(image), loadMat(mask), keypoints); @@ -275,43 +256,35 @@ TEST_P(SURF, Detector_Masked) EXPECT_GT(matchedRatio, 0.95); } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(SURF, Descriptor) { - cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(image.empty()); - - cv::gpu::SURF_GPU surf; - surf.hessianThreshold = hessianThreshold; - surf.nOctaves = nOctaves; - surf.nOctaveLayers = nOctaveLayers; - surf.extended = extended; - surf.upright = upright; - surf.keypointsRatio = 0.05f; - - cv::SURF surf_gold; - surf_gold.hessianThreshold = hessianThreshold; - surf_gold.nOctaves = nOctaves; - surf_gold.nOctaveLayers = nOctaveLayers; - surf_gold.extended = extended; - surf_gold.upright = upright; - - if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS)) - { - try - { - std::vector 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 + try { + cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(image.empty()); + + cv::gpu::SURF_GPU surf; + surf.hessianThreshold = hessianThreshold; + surf.nOctaves = nOctaves; + surf.nOctaveLayers = nOctaveLayers; + surf.extended = extended; + surf.upright = upright; + surf.keypointsRatio = 0.05f; + + cv::SURF surf_gold; + surf_gold.hessianThreshold = hessianThreshold; + surf_gold.nOctaves = nOctaves; + surf_gold.nOctaveLayers = nOctaveLayers; + surf_gold.extended = extended; + surf_gold.upright = upright; + std::vector 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) { - 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 keypoints; - fast(loadMat(image), cv::gpu::GpuMat(), keypoints); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); - } - } - else + try { + cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(image.empty()); + + cv::gpu::FAST_GPU fast(threshold); + fast.nonmaxSupression = nonmaxSupression; + std::vector 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,30 +416,17 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR TEST_P(ORB, Accuracy) { - cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(image.empty()); - - cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1)); - mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0)); - - 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 keypoints; - cv::gpu::GpuMat descriptors; - orb(loadMat(image), loadMat(mask), keypoints, descriptors); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); - } - } - else + try { + cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(image.empty()); + + cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1)); + mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0)); + + cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize); + orb.blurForDescriptor = blurForDescriptor; + std::vector 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,307 +533,109 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize TEST_P(BruteForceMatcher, Match_Single) { - cv::gpu::BFMatcher_GPU matcher(normCode); - - cv::gpu::GpuMat mask; - if (useMask) + try { - mask.create(query.rows, train.rows, CV_8UC1); - mask.setTo(cv::Scalar::all(1)); + cv::gpu::BFMatcher_GPU matcher(normCode); + + cv::gpu::GpuMat mask; + if (useMask) + { + mask.create(query.rows, train.rows, CV_8UC1); + mask.setTo(cv::Scalar::all(1)); + } + + std::vector matches; + matcher.match(loadMat(query), loadMat(train), matches, mask); + + ASSERT_EQ(static_cast(queryDescCount), matches.size()); + + int badCount = 0; + for (size_t i = 0; i < matches.size(); i++) + { + cv::DMatch match = matches[i]; + if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0)) + badCount++; + } + + ASSERT_EQ(0, badCount); } - - std::vector matches; - matcher.match(loadMat(query), loadMat(train), matches, mask); - - ASSERT_EQ(static_cast(queryDescCount), matches.size()); - - int badCount = 0; - for (size_t i = 0; i < matches.size(); i++) + catch (...) { - cv::DMatch match = matches[i]; - if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0)) - badCount++; + cv::gpu::resetDevice(); + throw; } - - ASSERT_EQ(0, badCount); } TEST_P(BruteForceMatcher, Match_Collection) { - cv::gpu::BFMatcher_GPU matcher(normCode); - - cv::gpu::GpuMat d_train(train); - - // make add() twice to test such case - matcher.add(std::vector(1, d_train.rowRange(0, train.rows / 2))); - matcher.add(std::vector(1, d_train.rowRange(train.rows / 2, train.rows))); - - // prepare masks (make first nearest match illegal) - std::vector masks(2); - for (int mi = 0; mi < 2; mi++) + try { - masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1)); - for (int di = 0; di < queryDescCount/2; di++) - masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0)); - } + cv::gpu::BFMatcher_GPU matcher(normCode); - std::vector matches; - if (useMask) - matcher.match(cv::gpu::GpuMat(query), matches, masks); - else - matcher.match(cv::gpu::GpuMat(query), matches); + cv::gpu::GpuMat d_train(train); - ASSERT_EQ(static_cast(queryDescCount), matches.size()); + // make add() twice to test such case + matcher.add(std::vector(1, d_train.rowRange(0, train.rows / 2))); + matcher.add(std::vector(1, d_train.rowRange(train.rows / 2, train.rows))); - int badCount = 0; - int shift = useMask ? 1 : 0; - for (size_t i = 0; i < matches.size(); i++) - { - cv::DMatch match = matches[i]; - - if ((int)i < queryDescCount / 2) + // prepare masks (make first nearest match illegal) + std::vector masks(2); + for (int mi = 0; mi < 2; mi++) { - bool validQueryIdx = (match.queryIdx == (int)i); - bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift); - bool validImgIdx = (match.imgIdx == 0); - if (!validQueryIdx || !validTrainIdx || !validImgIdx) - badCount++; + masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1)); + for (int di = 0; di < queryDescCount/2; di++) + masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0)); } + + std::vector matches; + if (useMask) + matcher.match(cv::gpu::GpuMat(query), matches, masks); else - { - bool validQueryIdx = (match.queryIdx == (int)i); - bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift); - bool validImgIdx = (match.imgIdx == 1); - if (!validQueryIdx || !validTrainIdx || !validImgIdx) - badCount++; - } - } + matcher.match(cv::gpu::GpuMat(query), matches); - ASSERT_EQ(0, badCount); + ASSERT_EQ(static_cast(queryDescCount), matches.size()); + + int badCount = 0; + int shift = useMask ? 1 : 0; + for (size_t i = 0; i < matches.size(); i++) + { + cv::DMatch match = matches[i]; + + if ((int)i < queryDescCount / 2) + { + bool validQueryIdx = (match.queryIdx == (int)i); + bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift); + bool validImgIdx = (match.imgIdx == 0); + if (!validQueryIdx || !validTrainIdx || !validImgIdx) + badCount++; + } + else + { + bool validQueryIdx = (match.queryIdx == (int)i); + bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift); + bool validImgIdx = (match.imgIdx == 1); + if (!validQueryIdx || !validTrainIdx || !validImgIdx) + badCount++; + } + } + + ASSERT_EQ(0, badCount); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(BruteForceMatcher, KnnMatch_2_Single) { - cv::gpu::BFMatcher_GPU matcher(normCode); - - const int knn = 2; - - cv::gpu::GpuMat mask; - if (useMask) + try { - mask.create(query.rows, train.rows, CV_8UC1); - mask.setTo(cv::Scalar::all(1)); - } + cv::gpu::BFMatcher_GPU matcher(normCode); - std::vector< std::vector > matches; - matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask); + const int knn = 2; - ASSERT_EQ(static_cast(queryDescCount), matches.size()); - - int badCount = 0; - for (size_t i = 0; i < matches.size(); i++) - { - if ((int)matches[i].size() != knn) - badCount++; - else - { - int localBadCount = 0; - for (int k = 0; k < knn; k++) - { - cv::DMatch match = matches[i][k]; - if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0)) - localBadCount++; - } - badCount += localBadCount > 0 ? 1 : 0; - } - } - - ASSERT_EQ(0, badCount); -} - -TEST_P(BruteForceMatcher, KnnMatch_3_Single) -{ - cv::gpu::BFMatcher_GPU matcher(normCode); - - const int knn = 3; - - cv::gpu::GpuMat mask; - if (useMask) - { - mask.create(query.rows, train.rows, CV_8UC1); - mask.setTo(cv::Scalar::all(1)); - } - - std::vector< std::vector > matches; - matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask); - - ASSERT_EQ(static_cast(queryDescCount), matches.size()); - - int badCount = 0; - for (size_t i = 0; i < matches.size(); i++) - { - if ((int)matches[i].size() != knn) - badCount++; - else - { - int localBadCount = 0; - for (int k = 0; k < knn; k++) - { - cv::DMatch match = matches[i][k]; - if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0)) - localBadCount++; - } - badCount += localBadCount > 0 ? 1 : 0; - } - } - - ASSERT_EQ(0, badCount); -} - -TEST_P(BruteForceMatcher, KnnMatch_2_Collection) -{ - cv::gpu::BFMatcher_GPU matcher(normCode); - - const int knn = 2; - - cv::gpu::GpuMat d_train(train); - - // make add() twice to test such case - matcher.add(std::vector(1, d_train.rowRange(0, train.rows / 2))); - matcher.add(std::vector(1, d_train.rowRange(train.rows / 2, train.rows))); - - // prepare masks (make first nearest match illegal) - std::vector masks(2); - for (int mi = 0; mi < 2; mi++ ) - { - masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1)); - for (int di = 0; di < queryDescCount / 2; di++) - masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0)); - } - - std::vector< std::vector > matches; - - if (useMask) - matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks); - else - matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn); - - ASSERT_EQ(static_cast(queryDescCount), matches.size()); - - int badCount = 0; - int shift = useMask ? 1 : 0; - for (size_t i = 0; i < matches.size(); i++) - { - if ((int)matches[i].size() != knn) - badCount++; - else - { - int localBadCount = 0; - for (int k = 0; k < knn; k++) - { - cv::DMatch match = matches[i][k]; - { - if ((int)i < queryDescCount / 2) - { - if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) ) - localBadCount++; - } - else - { - if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) ) - localBadCount++; - } - } - } - badCount += localBadCount > 0 ? 1 : 0; - } - } - - ASSERT_EQ(0, badCount); -} - -TEST_P(BruteForceMatcher, KnnMatch_3_Collection) -{ - cv::gpu::BFMatcher_GPU matcher(normCode); - - const int knn = 3; - - cv::gpu::GpuMat d_train(train); - - // make add() twice to test such case - matcher.add(std::vector(1, d_train.rowRange(0, train.rows / 2))); - matcher.add(std::vector(1, d_train.rowRange(train.rows / 2, train.rows))); - - // prepare masks (make first nearest match illegal) - std::vector masks(2); - for (int mi = 0; mi < 2; mi++ ) - { - masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1)); - for (int di = 0; di < queryDescCount / 2; di++) - masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0)); - } - - std::vector< std::vector > matches; - - if (useMask) - matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks); - else - matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn); - - ASSERT_EQ(static_cast(queryDescCount), matches.size()); - - int badCount = 0; - int shift = useMask ? 1 : 0; - for (size_t i = 0; i < matches.size(); i++) - { - if ((int)matches[i].size() != knn) - badCount++; - else - { - int localBadCount = 0; - for (int k = 0; k < knn; k++) - { - cv::DMatch match = matches[i][k]; - { - if ((int)i < queryDescCount / 2) - { - if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) ) - localBadCount++; - } - else - { - if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) ) - localBadCount++; - } - } - } - badCount += localBadCount > 0 ? 1 : 0; - } - } - - ASSERT_EQ(0, badCount); -} - -TEST_P(BruteForceMatcher, RadiusMatch_Single) -{ - cv::gpu::BFMatcher_GPU matcher(normCode); - - const float radius = 1.f / countFactor; - - if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS)) - { - try - { - std::vector< std::vector > matches; - matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); - } - } - else - { cv::gpu::GpuMat mask; if (useMask) { @@ -879,63 +644,305 @@ TEST_P(BruteForceMatcher, RadiusMatch_Single) } std::vector< std::vector > matches; - matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask); + matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask); ASSERT_EQ(static_cast(queryDescCount), matches.size()); int badCount = 0; for (size_t i = 0; i < matches.size(); i++) { - if ((int)matches[i].size() != 1) + if ((int)matches[i].size() != knn) badCount++; else { - cv::DMatch match = matches[i][0]; - if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0)) - badCount++; + int localBadCount = 0; + for (int k = 0; k < knn; k++) + { + cv::DMatch match = matches[i][k]; + if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0)) + localBadCount++; + } + badCount += localBadCount > 0 ? 1 : 0; } } 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; + + cv::gpu::GpuMat mask; + if (useMask) + { + mask.create(query.rows, train.rows, CV_8UC1); + mask.setTo(cv::Scalar::all(1)); + } + + std::vector< std::vector > matches; + matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask); + + ASSERT_EQ(static_cast(queryDescCount), matches.size()); + + int badCount = 0; + for (size_t i = 0; i < matches.size(); i++) + { + if ((int)matches[i].size() != knn) + badCount++; + else + { + int localBadCount = 0; + for (int k = 0; k < knn; k++) + { + cv::DMatch match = matches[i][k]; + if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0)) + localBadCount++; + } + badCount += localBadCount > 0 ? 1 : 0; + } + } + + 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; + + cv::gpu::GpuMat d_train(train); + + // make add() twice to test such case + matcher.add(std::vector(1, d_train.rowRange(0, train.rows / 2))); + matcher.add(std::vector(1, d_train.rowRange(train.rows / 2, train.rows))); + + // prepare masks (make first nearest match illegal) + std::vector masks(2); + for (int mi = 0; mi < 2; mi++ ) + { + masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1)); + for (int di = 0; di < queryDescCount / 2; di++) + masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0)); + } + + std::vector< std::vector > matches; + + if (useMask) + matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks); + else + matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn); + + ASSERT_EQ(static_cast(queryDescCount), matches.size()); + + int badCount = 0; + int shift = useMask ? 1 : 0; + for (size_t i = 0; i < matches.size(); i++) + { + if ((int)matches[i].size() != knn) + badCount++; + else + { + int localBadCount = 0; + for (int k = 0; k < knn; k++) + { + cv::DMatch match = matches[i][k]; + { + if ((int)i < queryDescCount / 2) + { + if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) ) + localBadCount++; + } + else + { + if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) ) + localBadCount++; + } + } + } + badCount += localBadCount > 0 ? 1 : 0; + } + } + + 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; + + cv::gpu::GpuMat d_train(train); + + // make add() twice to test such case + matcher.add(std::vector(1, d_train.rowRange(0, train.rows / 2))); + matcher.add(std::vector(1, d_train.rowRange(train.rows / 2, train.rows))); + + // prepare masks (make first nearest match illegal) + std::vector masks(2); + for (int mi = 0; mi < 2; mi++ ) + { + masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1)); + for (int di = 0; di < queryDescCount / 2; di++) + masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0)); + } + + std::vector< std::vector > matches; + + if (useMask) + matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks); + else + matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn); + + ASSERT_EQ(static_cast(queryDescCount), matches.size()); + + int badCount = 0; + int shift = useMask ? 1 : 0; + for (size_t i = 0; i < matches.size(); i++) + { + if ((int)matches[i].size() != knn) + badCount++; + else + { + int localBadCount = 0; + for (int k = 0; k < knn; k++) + { + cv::DMatch match = matches[i][k]; + { + if ((int)i < queryDescCount / 2) + { + if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) ) + localBadCount++; + } + else + { + if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) ) + localBadCount++; + } + } + } + badCount += localBadCount > 0 ? 1 : 0; + } + } + + 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; + + if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS)) + { + try + { + std::vector< std::vector > matches; + matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsNotImplemented, e.code); + } + } + else + { + cv::gpu::GpuMat mask; + if (useMask) + { + mask.create(query.rows, train.rows, CV_8UC1); + mask.setTo(cv::Scalar::all(1)); + } + + std::vector< std::vector > matches; + matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask); + + ASSERT_EQ(static_cast(queryDescCount), matches.size()); + + int badCount = 0; + for (size_t i = 0; i < matches.size(); i++) + { + if ((int)matches[i].size() != 1) + badCount++; + else + { + cv::DMatch match = matches[i][0]; + if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0)) + badCount++; + } + } + + ASSERT_EQ(0, badCount); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(BruteForceMatcher, RadiusMatch_Collection) { - cv::gpu::BFMatcher_GPU matcher(normCode); - - const int n = 3; - const float radius = 1.f / countFactor * n; - - cv::gpu::GpuMat d_train(train); - - // make add() twice to test such case - matcher.add(std::vector(1, d_train.rowRange(0, train.rows / 2))); - matcher.add(std::vector(1, d_train.rowRange(train.rows / 2, train.rows))); - - // prepare masks (make first nearest match illegal) - std::vector masks(2); - for (int mi = 0; mi < 2; mi++) + try { - masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1)); - for (int di = 0; di < queryDescCount / 2; di++) - masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0)); - } + cv::gpu::BFMatcher_GPU matcher(normCode); - if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS)) - { - try + const int n = 3; + const float radius = 1.f / countFactor * n; + + cv::gpu::GpuMat d_train(train); + + // make add() twice to test such case + matcher.add(std::vector(1, d_train.rowRange(0, train.rows / 2))); + matcher.add(std::vector(1, d_train.rowRange(train.rows / 2, train.rows))); + + // prepare masks (make first nearest match illegal) + std::vector masks(2); + for (int mi = 0; mi < 2; mi++) { - std::vector< std::vector > matches; - matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks); + masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1)); + for (int di = 0; di < queryDescCount / 2; di++) + masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0)); } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsNotImplemented, e.code); - } - } - else - { + std::vector< std::vector > 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( diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp index 92d6fc002..4bdda9124 100644 --- a/modules/gpu/test/test_filters.cpp +++ b/modules/gpu/test/test_filters.cpp @@ -88,15 +88,23 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use TEST_P(Blur, Accuracy) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor); - cv::Mat dst_gold; - cv::blur(src, dst_gold, ksize, anchor); + cv::Mat dst_gold; + cv::blur(src, dst_gold, ksize, anchor); - EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0); + 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,15 +158,23 @@ TEST_P(Sobel, Accuracy) if (dx == 0 && dy == 0) return; - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType); - cv::Mat dst_gold; - cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType); + cv::Mat dst_gold; + 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); + 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,15 +229,23 @@ TEST_P(Scharr, Accuracy) if (dx + dy != 1) return; - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType); - cv::Mat dst_gold; - cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType); + cv::Mat dst_gold; + 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); + 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,31 +294,39 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, TEST_P(GaussianBlur, Accuracy) { - cv::Mat src = randomMat(size, type); - double sigma1 = randomDouble(0.1, 1.0); - double sigma2 = randomDouble(0.1, 1.0); - - if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20)) + try { - try + cv::Mat src = randomMat(size, type); + double sigma1 = randomDouble(0.1, 1.0); + double sigma2 = randomDouble(0.1, 1.0); + + if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20)) { - cv::gpu::GpuMat dst; - cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType); + try + { + cv::gpu::GpuMat dst; + cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsNotImplemented, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsNotImplemented, e.code); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType); + + cv::Mat dst_gold; + cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType); + + EXPECT_MAT_NEAR(dst_gold, dst, 4.0); } } - else + catch (...) { - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType); - - cv::Mat dst_gold; - cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType); - - EXPECT_MAT_NEAR(dst_gold, dst, 4.0); + cv::gpu::resetDevice(); + throw; } } @@ -349,15 +381,23 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi TEST_P(Laplacian, Accuracy) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width); - cv::Mat dst_gold; - cv::Laplacian(src, dst_gold, -1, ksize.width); + cv::Mat dst_gold; + cv::Laplacian(src, dst_gold, -1, ksize.width); - EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3); + 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,18 +436,26 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration TEST_P(Erode, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); + try + { + cv::Mat src = randomMat(size, type); + cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations); - cv::Mat dst_gold; - cv::erode(src, dst_gold, kernel, anchor, iterations); + cv::Mat dst_gold; + cv::erode(src, dst_gold, kernel, anchor, iterations); - cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1)); + 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); + 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,18 +493,26 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio TEST_P(Dilate, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); + try + { + cv::Mat src = randomMat(size, type); + cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations); - cv::Mat dst_gold; - cv::dilate(src, dst_gold, kernel, anchor, iterations); + cv::Mat dst_gold; + cv::dilate(src, dst_gold, kernel, anchor, iterations); - cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1)); + 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); + 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,18 +555,26 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor TEST_P(MorphEx, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); + try + { + cv::Mat src = randomMat(size, type); + cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations); - cv::Mat dst_gold; - cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations); + cv::Mat dst_gold; + cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations); - cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2); + 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); + 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,16 +617,24 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, TEST_P(Filter2D, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0); + try + { + cv::Mat src = randomMat(size, type); + cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType); - cv::Mat dst_gold; - cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType); + cv::Mat dst_gold; + 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); + 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( diff --git a/modules/gpu/test/test_global_motion.cpp b/modules/gpu/test/test_global_motion.cpp index b37d08068..2b5eab894 100644 --- a/modules/gpu/test/test_global_motion.cpp +++ b/modules/gpu/test/test_global_motion.cpp @@ -53,35 +53,43 @@ struct CompactPoints : testing::TestWithParam TEST_P(CompactPoints, CanCompactizeSmallInput) { - Mat src0(1, 3, CV_32FC2); - src0.at(0,0) = Point2f(0,0); - src0.at(0,1) = Point2f(0,1); - src0.at(0,2) = Point2f(0,2); + try + { + Mat src0(1, 3, CV_32FC2); + src0.at(0,0) = Point2f(0,0); + src0.at(0,1) = Point2f(0,1); + src0.at(0,2) = Point2f(0,2); - Mat src1(1, 3, CV_32FC2); - src1.at(0,0) = Point2f(1,0); - src1.at(0,1) = Point2f(1,1); - src1.at(0,2) = Point2f(1,2); + Mat src1(1, 3, CV_32FC2); + src1.at(0,0) = Point2f(1,0); + src1.at(0,1) = Point2f(1,1); + src1.at(0,2) = Point2f(1,2); - Mat mask(1, 3, CV_8U); - mask.at(0,0) = 1; - mask.at(0,1) = 0; - mask.at(0,2) = 1; + Mat mask(1, 3, CV_8U); + mask.at(0,0) = 1; + mask.at(0,1) = 0; + mask.at(0,2) = 1; - gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask); - gpu::compactPoints(dsrc0, dsrc1, dmask); + gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask); + gpu::compactPoints(dsrc0, dsrc1, dmask); - dsrc0.download(src0); - dsrc1.download(src1); + dsrc0.download(src0); + dsrc1.download(src1); - ASSERT_EQ(2, src0.cols); - ASSERT_EQ(2, src1.cols); + ASSERT_EQ(2, src0.cols); + ASSERT_EQ(2, src1.cols); - ASSERT_TRUE(src0.at(0,0) == Point2f(0,0)); - ASSERT_TRUE(src0.at(0,1) == Point2f(0,2)); + ASSERT_TRUE(src0.at(0,0) == Point2f(0,0)); + ASSERT_TRUE(src0.at(0,1) == Point2f(0,2)); - ASSERT_TRUE(src1.at(0,0) == Point2f(1,0)); - ASSERT_TRUE(src1.at(0,1) == Point2f(1,2)); + ASSERT_TRUE(src1.at(0,0) == Point2f(1,0)); + ASSERT_TRUE(src1.at(0,1) == Point2f(1,2)); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_GlobalMotion, CompactPoints, ALL_DEVICES); diff --git a/modules/gpu/test/test_gpumat.cpp b/modules/gpu/test/test_gpumat.cpp index 9d7e545de..fed954053 100644 --- a/modules/gpu/test/test_gpumat.cpp +++ b/modules/gpu/test/test_gpumat.cpp @@ -69,90 +69,122 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(SetTo, Zero) { - cv::Scalar zero = cv::Scalar::all(0); + try + { + cv::Scalar zero = cv::Scalar::all(0); - cv::gpu::GpuMat mat = createMat(size, type, useRoi); - mat.setTo(zero); + cv::gpu::GpuMat mat = createMat(size, type, useRoi); + mat.setTo(zero); - EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0); + EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(SetTo, SameVal) { - cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0)); - - if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - 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)) + { + try + { + cv::gpu::GpuMat mat = createMat(size, type, useRoi); + mat.setTo(val); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { cv::gpu::GpuMat mat = createMat(size, type, useRoi); mat.setTo(val); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + + EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat mat = createMat(size, type, useRoi); - mat.setTo(val); - - EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(SetTo, DifferentVal) { - cv::Scalar val = randomScalar(0.0, 255.0); - - if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Scalar val = randomScalar(0.0, 255.0); + + if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + { + try + { + cv::gpu::GpuMat mat = createMat(size, type, useRoi); + mat.setTo(val); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } + } + else { cv::gpu::GpuMat mat = createMat(size, type, useRoi); mat.setTo(val); - } - catch (const cv::Exception& e) - { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + + EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat mat = createMat(size, type, useRoi); - mat.setTo(val); - - EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(SetTo, Masked) { - 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); - - if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - 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); + + if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat mat = createMat(size, type, useRoi); - mat.setTo(val, loadMat(mask)); + try + { + cv::gpu::GpuMat mat = createMat(size, type, useRoi); + mat.setTo(val, loadMat(mask)); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi); + mat.setTo(val, loadMat(mask, useRoi)); + + mat_gold.setTo(val, mask); + + EXPECT_MAT_NEAR(mat_gold, mat, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi); - mat.setTo(val, loadMat(mask, useRoi)); - - mat_gold.setTo(val, mask); - - EXPECT_MAT_NEAR(mat_gold, mat, 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -186,43 +218,59 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(CopyTo, WithOutMask) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat d_src = loadMat(src, useRoi); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - d_src.copyTo(dst); + cv::gpu::GpuMat d_src = loadMat(src, useRoi); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + d_src.copyTo(dst); - EXPECT_MAT_NEAR(src, dst, 0.0); + EXPECT_MAT_NEAR(src, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(CopyTo, Masked) { - cv::Mat src = randomMat(size, type); - cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); - - if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, type); + cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); + + if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat d_src = loadMat(src); - cv::gpu::GpuMat dst; - d_src.copyTo(dst, loadMat(mask, useRoi)); + try + { + cv::gpu::GpuMat d_src = loadMat(src); + cv::gpu::GpuMat dst; + d_src.copyTo(dst, loadMat(mask, useRoi)); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat d_src = loadMat(src, useRoi); + cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi); + d_src.copyTo(dst, loadMat(mask, useRoi)); + + cv::Mat dst_gold = cv::Mat::zeros(size, type); + src.copyTo(dst_gold, mask); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat d_src = loadMat(src, useRoi); - cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi); - d_src.copyTo(dst, loadMat(mask, useRoi)); - - cv::Mat dst_gold = cv::Mat::zeros(size, type); - src.copyTo(dst_gold, mask); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } @@ -257,63 +305,79 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us TEST_P(ConvertTo, WithOutScaling) { - cv::Mat src = randomMat(size, depth1); - - if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth1); + + if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat d_src = loadMat(src); - cv::gpu::GpuMat dst; - d_src.convertTo(dst, depth2); + try + { + cv::gpu::GpuMat d_src = loadMat(src); + cv::gpu::GpuMat dst; + d_src.convertTo(dst, depth2); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat d_src = loadMat(src, useRoi); + cv::gpu::GpuMat dst = createMat(size, depth2, useRoi); + d_src.convertTo(dst, depth2); + + cv::Mat dst_gold; + src.convertTo(dst_gold, depth2); + + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } } - else + catch (...) { - cv::gpu::GpuMat d_src = loadMat(src, useRoi); - cv::gpu::GpuMat dst = createMat(size, depth2, useRoi); - d_src.convertTo(dst, depth2); - - cv::Mat dst_gold; - src.convertTo(dst_gold, depth2); - - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + cv::gpu::resetDevice(); + throw; } } TEST_P(ConvertTo, WithScaling) { - cv::Mat src = randomMat(size, depth1); - double a = randomDouble(0.0, 1.0); - double b = randomDouble(-10.0, 10.0); - - if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) + try { - try + cv::Mat src = randomMat(size, depth1); + double a = randomDouble(0.0, 1.0); + double b = randomDouble(-10.0, 10.0); + + if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { - cv::gpu::GpuMat d_src = loadMat(src); - cv::gpu::GpuMat dst; - d_src.convertTo(dst, depth2, a, b); + try + { + cv::gpu::GpuMat d_src = loadMat(src); + cv::gpu::GpuMat dst; + d_src.convertTo(dst, depth2, a, b); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsUnsupportedFormat, e.code); + cv::gpu::GpuMat d_src = loadMat(src, useRoi); + cv::gpu::GpuMat dst = createMat(size, depth2, useRoi); + d_src.convertTo(dst, depth2, a, b); + + cv::Mat dst_gold; + src.convertTo(dst_gold, depth2, a, b); + + EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4); } } - else + catch (...) { - cv::gpu::GpuMat d_src = loadMat(src, useRoi); - cv::gpu::GpuMat dst = createMat(size, depth2, useRoi); - d_src.convertTo(dst, depth2, a, b); - - cv::Mat dst_gold; - src.convertTo(dst_gold, depth2, a, b); - - EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4); + cv::gpu::resetDevice(); + throw; } } @@ -338,22 +402,30 @@ struct EnsureSizeIsEnough : testing::TestWithParam TEST_P(EnsureSizeIsEnough, BufferReuse) { - cv::gpu::GpuMat buffer(100, 100, CV_8U); - cv::gpu::GpuMat old = buffer; + try + { + cv::gpu::GpuMat buffer(100, 100, CV_8U); + cv::gpu::GpuMat old = buffer; - // don't reallocate memory - cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer); - EXPECT_EQ(10, buffer.rows); - EXPECT_EQ(20, buffer.cols); - EXPECT_EQ(CV_8UC1, buffer.type()); - EXPECT_EQ(reinterpret_cast(old.data), reinterpret_cast(buffer.data)); + // don't reallocate memory + cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer); + EXPECT_EQ(10, buffer.rows); + EXPECT_EQ(20, buffer.cols); + EXPECT_EQ(CV_8UC1, buffer.type()); + EXPECT_EQ(reinterpret_cast(old.data), reinterpret_cast(buffer.data)); - // don't reallocate memory - cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer); - EXPECT_EQ(20, buffer.rows); - EXPECT_EQ(30, buffer.cols); - EXPECT_EQ(CV_8UC1, buffer.type()); - EXPECT_EQ(reinterpret_cast(old.data), reinterpret_cast(buffer.data)); + // don't reallocate memory + cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer); + EXPECT_EQ(20, buffer.rows); + EXPECT_EQ(30, buffer.cols); + EXPECT_EQ(CV_8UC1, buffer.type()); + EXPECT_EQ(reinterpret_cast(old.data), reinterpret_cast(buffer.data)); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES); diff --git a/modules/gpu/test/test_hough.cpp b/modules/gpu/test/test_hough.cpp index e6cb4fa85..9c4a97470 100644 --- a/modules/gpu/test/test_hough.cpp +++ b/modules/gpu/test/test_hough.cpp @@ -81,28 +81,36 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi) TEST_P(HoughLines, Accuracy) { - const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::gpu::setDevice(devInfo.deviceID()); - const cv::Size size = GET_PARAM(1); - const bool useRoi = GET_PARAM(2); + try + { + const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + const cv::Size size = GET_PARAM(1); + const bool useRoi = GET_PARAM(2); - const float rho = 1.0f; - const float theta = 1.5f * CV_PI / 180.0f; - const int threshold = 100; + const float rho = 1.0f; + const float theta = 1.5f * CV_PI / 180.0f; + const int threshold = 100; - cv::Mat src(size, CV_8UC1); - generateLines(src); + cv::Mat src(size, CV_8UC1); + generateLines(src); - cv::gpu::GpuMat d_lines; - cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold); + cv::gpu::GpuMat d_lines; + cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold); - std::vector lines; - cv::gpu::HoughLinesDownload(d_lines, lines); + std::vector lines; + cv::gpu::HoughLinesDownload(d_lines, lines); - cv::Mat dst(size, CV_8UC1); - drawLines(dst, lines); + cv::Mat dst(size, CV_8UC1); + drawLines(dst, lines); - ASSERT_MAT_NEAR(src, dst, 0.0); + ASSERT_MAT_NEAR(src, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughLines, testing::Combine( @@ -126,53 +134,61 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi) TEST_P(HoughCircles, Accuracy) { - const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::gpu::setDevice(devInfo.deviceID()); - const cv::Size size = GET_PARAM(1); - const bool useRoi = GET_PARAM(2); - - const float dp = 2.0f; - const float minDist = 10.0f; - const int minRadius = 10; - const int maxRadius = 20; - const int cannyThreshold = 100; - const int votesThreshold = 20; - - std::vector circles_gold(4); - circles_gold[0] = cv::Vec3i(20, 20, minRadius); - circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3); - circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8); - circles_gold[3] = cv::Vec3i(80, 10, maxRadius); - - cv::Mat src(size, CV_8UC1); - drawCircles(src, circles_gold, true); - - cv::gpu::GpuMat d_circles; - cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius); - - std::vector circles; - cv::gpu::HoughCirclesDownload(d_circles, circles); - - ASSERT_FALSE(circles.empty()); - - for (size_t i = 0; i < circles.size(); ++i) + try { - cv::Vec3f cur = circles[i]; + const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + const cv::Size size = GET_PARAM(1); + const bool useRoi = GET_PARAM(2); - bool found = false; + const float dp = 2.0f; + const float minDist = 10.0f; + const int minRadius = 10; + const int maxRadius = 20; + const int cannyThreshold = 100; + const int votesThreshold = 20; - for (size_t j = 0; j < circles_gold.size(); ++j) + std::vector circles_gold(4); + circles_gold[0] = cv::Vec3i(20, 20, minRadius); + circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3); + circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8); + circles_gold[3] = cv::Vec3i(80, 10, maxRadius); + + cv::Mat src(size, CV_8UC1); + drawCircles(src, circles_gold, true); + + cv::gpu::GpuMat d_circles; + cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius); + + std::vector circles; + cv::gpu::HoughCirclesDownload(d_circles, circles); + + ASSERT_FALSE(circles.empty()); + + for (size_t i = 0; i < circles.size(); ++i) { - cv::Vec3f gold = circles_gold[j]; + cv::Vec3f cur = circles[i]; - if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist) + bool found = false; + + for (size_t j = 0; j < circles_gold.size(); ++j) { - found = true; - break; - } - } + cv::Vec3f gold = circles_gold[j]; - ASSERT_TRUE(found); + if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist) + { + found = true; + break; + } + } + + ASSERT_TRUE(found); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } @@ -190,60 +206,68 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi) TEST_P(GeneralizedHough, POSITION) { - const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::gpu::setDevice(devInfo.deviceID()); - const bool useRoi = GET_PARAM(1); - - cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(templ.empty()); - - cv::Point templCenter(templ.cols / 2, templ.rows / 2); - - const size_t gold_count = 3; - cv::Point pos_gold[gold_count]; - pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10); - pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10); - pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40); - - cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0)); - for (size_t i = 0; i < gold_count; ++i) + try { - cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows); - cv::Mat imageROI = image(rec); - templ.copyTo(imageROI); - } + const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + const bool useRoi = GET_PARAM(1); - cv::Ptr hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION); - hough->set("votesThreshold", 200); + cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(templ.empty()); - hough->setTemplate(loadMat(templ, useRoi)); + cv::Point templCenter(templ.cols / 2, templ.rows / 2); - cv::gpu::GpuMat d_pos; - hough->detect(loadMat(image, useRoi), d_pos); + const size_t gold_count = 3; + cv::Point pos_gold[gold_count]; + pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10); + pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10); + pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40); - std::vector pos; - hough->download(d_pos, pos); - - ASSERT_EQ(gold_count, pos.size()); - - for (size_t i = 0; i < gold_count; ++i) - { - cv::Point gold = pos_gold[i]; - - bool found = false; - - for (size_t j = 0; j < pos.size(); ++j) + cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0)); + for (size_t i = 0; i < gold_count; ++i) { - cv::Point2f p(pos[j][0], pos[j][1]); - - if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2) - { - found = true; - break; - } + cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows); + cv::Mat imageROI = image(rec); + templ.copyTo(imageROI); } - ASSERT_TRUE(found); + cv::Ptr hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION); + hough->set("votesThreshold", 200); + + hough->setTemplate(loadMat(templ, useRoi)); + + cv::gpu::GpuMat d_pos; + hough->detect(loadMat(image, useRoi), d_pos); + + std::vector pos; + hough->download(d_pos, pos); + + ASSERT_EQ(gold_count, pos.size()); + + for (size_t i = 0; i < gold_count; ++i) + { + cv::Point gold = pos_gold[i]; + + bool found = false; + + for (size_t j = 0; j < pos.size(); ++j) + { + cv::Point2f p(pos[j][0], pos[j][1]); + + if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2) + { + found = true; + break; + } + } + + ASSERT_TRUE(found); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp index 71d4a8e65..9de380810 100644 --- a/modules/gpu/test/test_imgproc.cpp +++ b/modules/gpu/test/test_imgproc.cpp @@ -66,15 +66,23 @@ PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi) TEST_P(Integral, Accuracy) { - cv::Mat src = randomMat(size, CV_8UC1); + try + { + cv::Mat src = randomMat(size, CV_8UC1); - cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi); - cv::gpu::integral(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi); + cv::gpu::integral(loadMat(src, useRoi), dst); - cv::Mat dst_gold; - cv::integral(src, dst_gold, CV_32S); + cv::Mat dst_gold; + cv::integral(src, dst_gold, CV_32S); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine( @@ -99,32 +107,40 @@ struct HistEven : testing::TestWithParam TEST_P(HistEven, Accuracy) { - cv::Mat img = readImage("stereobm/aloe-L.png"); - ASSERT_FALSE(img.empty()); + try + { + cv::Mat img = readImage("stereobm/aloe-L.png"); + ASSERT_FALSE(img.empty()); - cv::Mat hsv; - cv::cvtColor(img, hsv, CV_BGR2HSV); + cv::Mat hsv; + cv::cvtColor(img, hsv, CV_BGR2HSV); - int hbins = 30; - float hranges[] = {0.0f, 180.0f}; + int hbins = 30; + float hranges[] = {0.0f, 180.0f}; - std::vector srcs; - cv::gpu::split(loadMat(hsv), srcs); + std::vector srcs; + cv::gpu::split(loadMat(hsv), srcs); - cv::gpu::GpuMat hist; - cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]); + cv::gpu::GpuMat hist; + cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]); - cv::MatND histnd; - int histSize[] = {hbins}; - const float* ranges[] = {hranges}; - int channels[] = {0}; - cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges); + cv::MatND histnd; + int histSize[] = {hbins}; + const float* ranges[] = {hranges}; + int channels[] = {0}; + cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges); - cv::Mat hist_gold = histnd; - hist_gold = hist_gold.t(); - hist_gold.convertTo(hist_gold, CV_32S); + cv::Mat hist_gold = histnd; + hist_gold = hist_gold.t(); + hist_gold.convertTo(hist_gold, CV_32S); - EXPECT_MAT_NEAR(hist_gold, hist, 0.0); + EXPECT_MAT_NEAR(hist_gold, hist, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES); @@ -164,15 +180,23 @@ PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size) TEST_P(CalcHist, Accuracy) { - cv::Mat src = randomMat(size, CV_8UC1); + try + { + cv::Mat src = randomMat(size, CV_8UC1); - cv::gpu::GpuMat hist; - cv::gpu::calcHist(loadMat(src), hist); + cv::gpu::GpuMat hist; + cv::gpu::calcHist(loadMat(src), hist); - cv::Mat hist_gold; - calcHistGold(src, hist_gold); + cv::Mat hist_gold; + calcHistGold(src, hist_gold); - EXPECT_MAT_NEAR(hist_gold, hist, 0.0); + EXPECT_MAT_NEAR(hist_gold, hist, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine( @@ -198,15 +222,23 @@ PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size) TEST_P(EqualizeHist, Accuracy) { - cv::Mat src = randomMat(size, CV_8UC1); + try + { + cv::Mat src = randomMat(size, CV_8UC1); - cv::gpu::GpuMat dst; - cv::gpu::equalizeHist(loadMat(src), dst); + cv::gpu::GpuMat dst; + cv::gpu::equalizeHist(loadMat(src), dst); - cv::Mat dst_gold; - cv::equalizeHist(src, dst_gold); + cv::Mat dst_gold; + cv::equalizeHist(src, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, 3.0); + EXPECT_MAT_NEAR(dst_gold, dst, 3.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine( @@ -232,28 +264,36 @@ PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size) TEST_P(ColumnSum, Accuracy) { - cv::Mat src = randomMat(size, CV_32FC1); - - cv::gpu::GpuMat d_dst; - cv::gpu::columnSum(loadMat(src), d_dst); - - cv::Mat dst(d_dst); - - for (int j = 0; j < src.cols; ++j) + try { - float gold = src.at(0, j); - float res = dst.at(0, j); - ASSERT_NEAR(res, gold, 1e-5); - } + cv::Mat src = randomMat(size, CV_32FC1); + + cv::gpu::GpuMat d_dst; + cv::gpu::columnSum(loadMat(src), d_dst); + + cv::Mat dst(d_dst); - for (int i = 1; i < src.rows; ++i) - { for (int j = 0; j < src.cols; ++j) { - float gold = src.at(i, j) += src.at(i - 1, j); - float res = dst.at(i, j); + float gold = src.at(0, j); + float res = dst.at(0, j); ASSERT_NEAR(res, gold, 1e-5); } + + for (int i = 1; i < src.rows; ++i) + { + for (int j = 0; j < src.cols; ++j) + { + float gold = src.at(i, j) += src.at(i - 1, j); + float res = dst.at(i, j); + ASSERT_NEAR(res, gold, 1e-5); + } + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } @@ -287,33 +327,41 @@ PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi) TEST_P(Canny, Accuracy) { - cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(img.empty()); - - double low_thresh = 50.0; - double high_thresh = 100.0; - - if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS)) + try { - try + cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(img.empty()); + + double low_thresh = 50.0; + double high_thresh = 100.0; + + if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS)) { - cv::gpu::GpuMat edges; - cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient); + try + { + cv::gpu::GpuMat edges; + cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient); + } + catch (const cv::Exception& e) + { + ASSERT_EQ(CV_StsNotImplemented, e.code); + } } - catch (const cv::Exception& e) + else { - ASSERT_EQ(CV_StsNotImplemented, e.code); + cv::gpu::GpuMat edges; + cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient); + + cv::Mat edges_gold; + cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient); + + EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2); } } - else + catch (...) { - cv::gpu::GpuMat edges; - cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient); - - cv::Mat edges_gold; - cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient); - - EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2); + cv::gpu::resetDevice(); + throw; } } @@ -351,50 +399,66 @@ struct MeanShift : testing::TestWithParam TEST_P(MeanShift, Filtering) { - cv::Mat img_template; - if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20)) - img_template = readImage("meanshift/con_result.png"); - else - img_template = readImage("meanshift/con_result_CC1X.png"); - ASSERT_FALSE(img_template.empty()); + try + { + cv::Mat img_template; + if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20)) + img_template = readImage("meanshift/con_result.png"); + else + img_template = readImage("meanshift/con_result_CC1X.png"); + ASSERT_FALSE(img_template.empty()); - cv::gpu::GpuMat d_dst; - cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad); + cv::gpu::GpuMat d_dst; + cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad); - ASSERT_EQ(CV_8UC4, d_dst.type()); + ASSERT_EQ(CV_8UC4, d_dst.type()); - cv::Mat dst(d_dst); + cv::Mat dst(d_dst); - cv::Mat result; - cv::cvtColor(dst, result, CV_BGRA2BGR); + cv::Mat result; + cv::cvtColor(dst, result, CV_BGRA2BGR); - EXPECT_MAT_NEAR(img_template, result, 0.0); + EXPECT_MAT_NEAR(img_template, result, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(MeanShift, Proc) { - 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); - else - fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); + 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); + else + fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); - cv::Mat spmap_template; - fs["spmap"] >> spmap_template; - ASSERT_FALSE(spmap_template.empty()); + cv::Mat spmap_template; + fs["spmap"] >> spmap_template; + ASSERT_FALSE(spmap_template.empty()); - cv::gpu::GpuMat rmap_filtered; - cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad); + cv::gpu::GpuMat rmap_filtered; + cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad); - cv::gpu::GpuMat rmap; - cv::gpu::GpuMat spmap; - cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad); + cv::gpu::GpuMat rmap; + cv::gpu::GpuMat spmap; + cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad); - ASSERT_EQ(CV_8UC4, rmap.type()); + ASSERT_EQ(CV_8UC4, rmap.type()); - EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0); - EXPECT_MAT_NEAR(spmap_template, spmap, 0.0); + 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,25 +484,33 @@ PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize) TEST_P(MeanShiftSegmentation, Regression) { - cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4); - ASSERT_FALSE(img.empty()); + try + { + cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4); + ASSERT_FALSE(img.empty()); - std::ostringstream path; - path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize; - if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20)) - path << ".png"; - else - path << "_CC1X.png"; - cv::Mat dst_gold = readImage(path.str()); - ASSERT_FALSE(dst_gold.empty()); + std::ostringstream path; + path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize; + if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20)) + path << ".png"; + else + path << "_CC1X.png"; + cv::Mat dst_gold = readImage(path.str()); + ASSERT_FALSE(dst_gold.empty()); - cv::Mat dst; - cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize); + cv::Mat dst; + cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize); - cv::Mat dst_rgb; - cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR); + cv::Mat dst_rgb; + cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR); - EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3); + EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine( @@ -492,23 +564,31 @@ PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(Blend, Accuracy) { - int depth = CV_MAT_DEPTH(type); + try + { + int depth = CV_MAT_DEPTH(type); - cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0); - cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0); - cv::Mat weights1 = randomMat(size, CV_32F, 0, 1); - cv::Mat weights2 = randomMat(size, CV_32F, 0, 1); + cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0); + cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0); + cv::Mat weights1 = randomMat(size, CV_32F, 0, 1); + cv::Mat weights2 = randomMat(size, CV_32F, 0, 1); - cv::gpu::GpuMat result; - cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result); + cv::gpu::GpuMat result; + cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result); - cv::Mat result_gold; - if (depth == CV_8U) - blendLinearGold(img1, img2, weights1, weights2, result_gold); - else - blendLinearGold(img1, img2, weights1, weights2, result_gold); + cv::Mat result_gold; + if (depth == CV_8U) + blendLinearGold(img1, img2, weights1, weights2, result_gold); + else + blendLinearGold(img1, img2, weights1, weights2, result_gold); - EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5); + 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,16 +662,24 @@ PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr) TEST_P(Convolve, Accuracy) { - 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); + 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); - cv::gpu::GpuMat dst; - cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr); + cv::gpu::GpuMat dst; + cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr); - cv::Mat dst_gold; - convolveDFT(src, kernel, dst_gold, ccorr); + cv::Mat dst_gold; + convolveDFT(src, kernel, dst_gold, ccorr); - EXPECT_MAT_NEAR(dst, dst_gold, 1e-1); + EXPECT_MAT_NEAR(dst, dst_gold, 1e-1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine( @@ -630,16 +718,24 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Ch TEST_P(MatchTemplate8U, Accuracy) { - cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn)); - cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn)); + try + { + cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn)); + cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn)); - cv::gpu::GpuMat dst; - cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method); + cv::gpu::GpuMat dst; + cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method); - cv::Mat dst_gold; - cv::matchTemplate(image, templ, dst_gold, method); + cv::Mat dst_gold; + cv::matchTemplate(image, templ, dst_gold, method); - EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1); + 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,16 +772,24 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, C TEST_P(MatchTemplate32F, Regression) { - cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn)); - cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn)); + try + { + cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn)); + cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn)); - cv::gpu::GpuMat dst; - cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method); + cv::gpu::GpuMat dst; + cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method); - cv::Mat dst_gold; - cv::matchTemplate(image, templ, dst_gold, method); + cv::Mat dst_gold; + cv::matchTemplate(image, templ, dst_gold, method); - EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1); + 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,24 +818,32 @@ PARAM_TEST_CASE(MatchTemplateBlackSource, cv::gpu::DeviceInfo, TemplateMethod) TEST_P(MatchTemplateBlackSource, Accuracy) { - cv::Mat image = readImage("matchtemplate/black.png"); - ASSERT_FALSE(image.empty()); + try + { + cv::Mat image = readImage("matchtemplate/black.png"); + ASSERT_FALSE(image.empty()); - cv::Mat pattern = readImage("matchtemplate/cat.png"); - ASSERT_FALSE(pattern.empty()); + cv::Mat pattern = readImage("matchtemplate/cat.png"); + ASSERT_FALSE(pattern.empty()); - cv::gpu::GpuMat d_dst; - cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method); + cv::gpu::GpuMat d_dst; + cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method); - cv::Mat dst(d_dst); + cv::Mat dst(d_dst); - double maxValue; - cv::Point maxLoc; - cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc); + double maxValue; + cv::Point maxLoc; + cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc); - cv::Point maxLocGold = cv::Point(284, 12); + cv::Point maxLocGold = cv::Point(284, 12); - ASSERT_EQ(maxLocGold, maxLoc); + ASSERT_EQ(maxLocGold, maxLoc); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine( @@ -759,32 +871,40 @@ PARAM_TEST_CASE(MatchTemplate_CCOEF_NORMED, cv::gpu::DeviceInfo, std::pair TEST_P(Labeling, ConnectedComponents) { - cv::Mat image; - cvtColor(loat_image(), image, CV_BGR2GRAY); + try + { + cv::Mat image; + cvtColor(loat_image(), image, CV_BGR2GRAY); - cv::threshold(image, image, 150, 255, CV_THRESH_BINARY); + cv::threshold(image, image, 150, 255, CV_THRESH_BINARY); - ASSERT_TRUE(image.type() == CV_8UC1); + ASSERT_TRUE(image.type() == CV_8UC1); - GreedyLabeling host(image); - host(host._labels); + GreedyLabeling host(image); + host(host._labels); - cv::gpu::GpuMat mask; - mask.create(image.rows, image.cols, CV_8UC1); + cv::gpu::GpuMat mask; + mask.create(image.rows, image.cols, CV_8UC1); - cv::gpu::GpuMat components; - components.create(image.rows, image.cols, CV_32SC1); + cv::gpu::GpuMat components; + components.create(image.rows, image.cols, CV_32SC1); - cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2)); + cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2)); - ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components)); + ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components)); - host.checkCorrectness(cv::Mat(components)); + host.checkCorrectness(cv::Mat(components)); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(ConnectedComponents, Labeling, ALL_DEVICES); diff --git a/modules/gpu/test/test_nvidia.cpp b/modules/gpu/test/test_nvidia.cpp index 484f3cfbb..0b844d35d 100644 --- a/modules/gpu/test/test_nvidia.cpp +++ b/modules/gpu/test/test_nvidia.cpp @@ -69,82 +69,169 @@ struct NVidiaTest : TestWithParam 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) { - bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NPPST, RectStdDev) { - bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NPPST, Resize) { - bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NPPST, VectorOperations) { - bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NPPST, Transpose) { - bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NCV, VectorOperations) { - bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NCV, HaarCascadeLoader) { - bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NCV, HaarCascadeApplication) { - bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NCV, HypothesesFiltration) { - bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(NCV, Visualization) { - // this functionality doesn't used in gpu module - bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel); + try + { + bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel); - ASSERT_TRUE(res); + ASSERT_TRUE(res); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_NVidia, NPPST, ALL_DEVICES); diff --git a/modules/gpu/test/test_objdetect.cpp b/modules/gpu/test/test_objdetect.cpp index 4fb295d4c..81c6c40ce 100644 --- a/modules/gpu/test/test_objdetect.cpp +++ b/modules/gpu/test/test_objdetect.cpp @@ -175,114 +175,129 @@ struct HOG : testing::TestWithParam, cv::gpu::HOGDescriptor } }; -// desabled while resize does not fixed -TEST_P(HOG, DISABLED_Detect) +TEST_P(HOG, Detect) { - cv::Mat img_rgb = readImage("hog/road.png"); - ASSERT_FALSE(img_rgb.empty()); + try + { + cv::Mat img_rgb = readImage("hog/road.png"); + ASSERT_FALSE(img_rgb.empty()); -#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 - 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 + #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 + 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 - // Test on color image - cv::Mat img; - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - testDetect(img); + // Test on color image + cv::Mat img; + cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + testDetect(img); - // Test on gray image - cv::cvtColor(img_rgb, img, CV_BGR2GRAY); - testDetect(img); + // Test on gray image + cv::cvtColor(img_rgb, img, CV_BGR2GRAY); + testDetect(img); - f.close(); + f.close(); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(HOG, GetDescriptors) { - // Load image (e.g. train data, composed from windows) - cv::Mat img_rgb = readImage("hog/train_data.png"); - ASSERT_FALSE(img_rgb.empty()); - - // Convert to C4 - cv::Mat img; - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - - cv::gpu::GpuMat d_img(img); - - // Convert train images into feature vectors (train table) - cv::gpu::GpuMat descriptors, descriptors_by_cols; - getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW); - getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL); - - // Check size of the result train table - wins_per_img_x = 3; - wins_per_img_y = 2; - blocks_per_win_x = 7; - blocks_per_win_y = 15; - block_hist_size = 36; - cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size, - wins_per_img_x * wins_per_img_y); - ASSERT_EQ(descr_size_expected, descriptors.size()); - - // Check both formats of output descriptors are handled correctly - cv::Mat dr(descriptors); - cv::Mat dc(descriptors_by_cols); - for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i) + try { - const float* l = dr.rowRange(i, i + 1).ptr(); - const float* r = dc.rowRange(i, i + 1).ptr(); - for (int y = 0; y < blocks_per_win_y; ++y) - for (int x = 0; x < blocks_per_win_x; ++x) - for (int k = 0; k < block_hist_size; ++k) - ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k], - r[(x * blocks_per_win_y + y) * block_hist_size + k]); + // Load image (e.g. train data, composed from windows) + cv::Mat img_rgb = readImage("hog/train_data.png"); + ASSERT_FALSE(img_rgb.empty()); + + // Convert to C4 + cv::Mat img; + cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + + cv::gpu::GpuMat d_img(img); + + // Convert train images into feature vectors (train table) + cv::gpu::GpuMat descriptors, descriptors_by_cols; + getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW); + getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL); + + // Check size of the result train table + wins_per_img_x = 3; + wins_per_img_y = 2; + blocks_per_win_x = 7; + blocks_per_win_y = 15; + block_hist_size = 36; + cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size, + wins_per_img_x * wins_per_img_y); + ASSERT_EQ(descr_size_expected, descriptors.size()); + + // Check both formats of output descriptors are handled correctly + cv::Mat dr(descriptors); + cv::Mat dc(descriptors_by_cols); + for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i) + { + const float* l = dr.rowRange(i, i + 1).ptr(); + const float* r = dc.rowRange(i, i + 1).ptr(); + for (int y = 0; y < blocks_per_win_y; ++y) + for (int x = 0; x < blocks_per_win_x; ++x) + for (int k = 0; k < block_hist_size; ++k) + ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k], + r[(x * blocks_per_win_y + y) * block_hist_size + k]); + } + + /* Now we want to extract the same feature vectors, but from single images. NOTE: results will + be defferent, due to border values interpolation. Using of many small images is slower, however we + wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms + works good, it can be checked in the gpu_hog sample */ + + img_rgb = readImage("hog/positive1.png"); + ASSERT_TRUE(!img_rgb.empty()); + cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + computeBlockHistograms(cv::gpu::GpuMat(img)); + // Everything is fine with interpolation for left top subimage + ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1))); + + img_rgb = readImage("hog/positive2.png"); + ASSERT_TRUE(!img_rgb.empty()); + cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + computeBlockHistograms(cv::gpu::GpuMat(img)); + compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2))); + + img_rgb = readImage("hog/negative1.png"); + ASSERT_TRUE(!img_rgb.empty()); + cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + computeBlockHistograms(cv::gpu::GpuMat(img)); + compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3))); + + img_rgb = readImage("hog/negative2.png"); + ASSERT_TRUE(!img_rgb.empty()); + cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + computeBlockHistograms(cv::gpu::GpuMat(img)); + compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4))); + + img_rgb = readImage("hog/positive3.png"); + ASSERT_TRUE(!img_rgb.empty()); + cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + computeBlockHistograms(cv::gpu::GpuMat(img)); + compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5))); + + img_rgb = readImage("hog/negative3.png"); + ASSERT_TRUE(!img_rgb.empty()); + 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; } - - /* Now we want to extract the same feature vectors, but from single images. NOTE: results will - be defferent, due to border values interpolation. Using of many small images is slower, however we - wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms - works good, it can be checked in the gpu_hog sample */ - - img_rgb = readImage("hog/positive1.png"); - ASSERT_TRUE(!img_rgb.empty()); - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - computeBlockHistograms(cv::gpu::GpuMat(img)); - // Everything is fine with interpolation for left top subimage - ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1))); - - img_rgb = readImage("hog/positive2.png"); - ASSERT_TRUE(!img_rgb.empty()); - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - computeBlockHistograms(cv::gpu::GpuMat(img)); - compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2))); - - img_rgb = readImage("hog/negative1.png"); - ASSERT_TRUE(!img_rgb.empty()); - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - computeBlockHistograms(cv::gpu::GpuMat(img)); - compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3))); - - img_rgb = readImage("hog/negative2.png"); - ASSERT_TRUE(!img_rgb.empty()); - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - computeBlockHistograms(cv::gpu::GpuMat(img)); - compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4))); - - img_rgb = readImage("hog/positive3.png"); - ASSERT_TRUE(!img_rgb.empty()); - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - computeBlockHistograms(cv::gpu::GpuMat(img)); - compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5))); - - img_rgb = readImage("hog/negative3.png"); - ASSERT_TRUE(!img_rgb.empty()); - 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))); } INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES); @@ -305,27 +320,35 @@ struct CalTech : public ::testing::TestWithParam found_locations; - d_hog.detectMultiScale(d_img, found_locations); - -#if defined (LOG_CASCADE_STATISTIC) - for (int i = 0; i < (int)found_locations.size(); i++) + try { - cv::Rect r = found_locations[i]; + cv::gpu::GpuMat d_img(img); + cv::Mat markedImage(img.clone()); - std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl; - cv::rectangle(markedImage, r , CV_RGB(255, 0, 0)); + cv::gpu::HOGDescriptor d_hog; + d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector()); + d_hog.nlevels = d_hog.nlevels + 32; + + std::vector found_locations; + d_hog.detectMultiScale(d_img, found_locations); + + #if defined (LOG_CASCADE_STATISTIC) + for (int i = 0; i < (int)found_locations.size(); i++) + { + cv::Rect r = found_locations[i]; + + std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl; + cv::rectangle(markedImage, r , CV_RGB(255, 0, 0)); + } + + cv::imshow("Res", markedImage); cv::waitKey(); + #endif + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } - - cv::imshow("Res", markedImage); cv::waitKey(); -#endif } 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) { - 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)); + 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,49 +405,57 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int) TEST_P(LBP_classify, Accuracy) { - 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"; - - cv::CascadeClassifier cpuClassifier(classifierXmlPath); - ASSERT_FALSE(cpuClassifier.empty()); - - cv::Mat image = cv::imread(imagePath); - image = image.colRange(0, image.cols/2); - cv::Mat grey; - cvtColor(image, grey, CV_BGR2GRAY); - ASSERT_FALSE(image.empty()); - - std::vector rects; - cpuClassifier.detectMultiScale(grey, rects); - cv::Mat markedImage = image.clone(); - - std::vector::iterator it = rects.begin(); - for (; it != rects.end(); ++it) - cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255)); - - cv::gpu::CascadeClassifier_GPU gpuClassifier; - ASSERT_TRUE(gpuClassifier.load(classifierXmlPath)); - - cv::gpu::GpuMat gpu_rects; - cv::gpu::GpuMat tested(grey); - int count = gpuClassifier.detectMultiScale(tested, gpu_rects); - -#if defined (LOG_CASCADE_STATISTIC) - cv::Mat downloaded(gpu_rects); - const cv::Rect* faces = downloaded.ptr(); - for (int i = 0; i < count; i++) + try { - cv::Rect r = faces[i]; + 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"; - std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl; - cv::rectangle(markedImage, r , CV_RGB(255, 0, 0)); + cv::CascadeClassifier cpuClassifier(classifierXmlPath); + ASSERT_FALSE(cpuClassifier.empty()); + + cv::Mat image = cv::imread(imagePath); + image = image.colRange(0, image.cols/2); + cv::Mat grey; + cvtColor(image, grey, CV_BGR2GRAY); + ASSERT_FALSE(image.empty()); + + std::vector rects; + cpuClassifier.detectMultiScale(grey, rects); + cv::Mat markedImage = image.clone(); + + std::vector::iterator it = rects.begin(); + for (; it != rects.end(); ++it) + cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255)); + + cv::gpu::CascadeClassifier_GPU gpuClassifier; + ASSERT_TRUE(gpuClassifier.load(classifierXmlPath)); + + cv::gpu::GpuMat gpu_rects; + cv::gpu::GpuMat tested(grey); + int count = gpuClassifier.detectMultiScale(tested, gpu_rects); + + #if defined (LOG_CASCADE_STATISTIC) + cv::Mat downloaded(gpu_rects); + const cv::Rect* faces = downloaded.ptr(); + for (int i = 0; i < count; i++) + { + cv::Rect r = faces[i]; + + std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl; + cv::rectangle(markedImage, r , CV_RGB(255, 0, 0)); + } + #endif + + #if defined (LOG_CASCADE_STATISTIC) + cv::imshow("Res", markedImage); cv::waitKey(); + #endif + (void)count; + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } -#endif - -#if defined (LOG_CASCADE_STATISTIC) - cv::imshow("Res", markedImage); cv::waitKey(); -#endif - (void)count; } INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify, diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp index 3bb3e09ea..4be0c153a 100644 --- a/modules/gpu/test/test_opengl.cpp +++ b/modules/gpu/test/test_opengl.cpp @@ -70,258 +70,402 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType) TEST_P(GlBuffer, Constructor1) { - cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true); + 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()); + 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) { - cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + 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()); + 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) { - cv::Mat gold = randomMat(size, type); + try + { + cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::Mat bufData; - buf.copyTo(bufData); + cv::Mat bufData; + buf.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 0); + EXPECT_MAT_NEAR(gold, bufData, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, ConstructorFromGpuMat) { - cv::Mat gold = randomMat(size, type); - cv::gpu::GpuMat d_gold(gold); + try + { + cv::Mat gold = randomMat(size, type); + cv::gpu::GpuMat d_gold(gold); - cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER); + cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER); - cv::Mat bufData; - buf.copyTo(bufData); + cv::Mat bufData; + buf.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 0); + EXPECT_MAT_NEAR(gold, bufData, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, ConstructorFromGlBuffer) { - cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + try + { + cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true); - cv::GlBuffer buf(buf_gold); + cv::GlBuffer buf(buf_gold); - EXPECT_EQ(buf_gold.bufId(), buf.bufId()); - EXPECT_EQ(buf_gold.rows(), buf.rows()); - EXPECT_EQ(buf_gold.cols(), buf.cols()); - EXPECT_EQ(buf_gold.type(), buf.type()); + EXPECT_EQ(buf_gold.bufId(), buf.bufId()); + 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) { - const int depth = CV_MAT_DEPTH(type); - const int cn = CV_MAT_CN(type); + try + { + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); - if (depth != CV_32F || cn == 2) - return; + if (depth != CV_32F || cn == 2) + return; - cv::Mat gold = randomMat(size, type, 0, 1.0); - cv::GlTexture2D tex_gold(gold, true); + cv::Mat gold = randomMat(size, type, 0, 1.0); + cv::GlTexture2D tex_gold(gold, true); - cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true); - cv::Mat bufData; - buf.copyTo(bufData); + cv::Mat bufData; + buf.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 1e-2); + EXPECT_MAT_NEAR(gold, bufData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, Create) { - cv::GlBuffer buf; - buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true); + 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()); + 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) { - cv::Mat gold = randomMat(size, type); + try + { + cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf; - buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf; + buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::Mat bufData; - buf.copyTo(bufData); + cv::Mat bufData; + buf.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 0); + EXPECT_MAT_NEAR(gold, bufData, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, CopyFromGpuMat) { - cv::Mat gold = randomMat(size, type); - cv::gpu::GpuMat d_gold(gold); + try + { + cv::Mat gold = randomMat(size, type); + cv::gpu::GpuMat d_gold(gold); - cv::GlBuffer buf; - buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf; + buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::Mat bufData; - buf.copyTo(bufData); + cv::Mat bufData; + buf.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 0); + EXPECT_MAT_NEAR(gold, bufData, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, CopyFromGlBuffer) { - cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true); + try + { + cv::Mat gold = randomMat(size, type); + cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::GlBuffer buf; - buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf; + buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true); - EXPECT_NE(buf_gold.bufId(), buf.bufId()); + EXPECT_NE(buf_gold.bufId(), buf.bufId()); - cv::Mat bufData; - buf.copyTo(bufData); + cv::Mat bufData; + buf.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 0); + EXPECT_MAT_NEAR(gold, bufData, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, CopyFromGlTexture2D) { - const int depth = CV_MAT_DEPTH(type); - const int cn = CV_MAT_CN(type); + try + { + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); - if (depth != CV_32F || cn == 2) - return; + if (depth != CV_32F || cn == 2) + return; - cv::Mat gold = randomMat(size, type, 0, 1.0); - cv::GlTexture2D tex_gold(gold, true); + cv::Mat gold = randomMat(size, type, 0, 1.0); + cv::GlTexture2D tex_gold(gold, true); - cv::GlBuffer buf; - buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf; + buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::Mat bufData; - buf.copyTo(bufData); + cv::Mat bufData; + buf.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 1e-2); + EXPECT_MAT_NEAR(gold, bufData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, CopyToGpuMat) { - cv::Mat gold = randomMat(size, type); + try + { + cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::gpu::GpuMat dst; - buf.copyTo(dst); + cv::gpu::GpuMat dst; + buf.copyTo(dst); - EXPECT_MAT_NEAR(gold, dst, 0); + EXPECT_MAT_NEAR(gold, dst, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, CopyToGlBuffer) { - cv::Mat gold = randomMat(size, type); + try + { + cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::GlBuffer dst; - buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer dst; + buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true); - EXPECT_NE(buf.bufId(), dst.bufId()); + EXPECT_NE(buf.bufId(), dst.bufId()); - cv::Mat bufData; - dst.copyTo(bufData); + cv::Mat bufData; + dst.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 0); + EXPECT_MAT_NEAR(gold, bufData, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, CopyToGlTexture2D) { - const int depth = CV_MAT_DEPTH(type); - const int cn = CV_MAT_CN(type); + try + { + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); - if (depth != CV_32F || cn == 2) - return; + if (depth != CV_32F || cn == 2) + return; - cv::Mat gold = randomMat(size, type, 0, 1.0); + cv::Mat gold = randomMat(size, type, 0, 1.0); - cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true); - cv::GlTexture2D tex; - buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true); + cv::GlTexture2D tex; + buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true); - cv::Mat texData; - tex.copyTo(texData); + cv::Mat texData; + tex.copyTo(texData); - EXPECT_MAT_NEAR(gold, texData, 1e-2); + EXPECT_MAT_NEAR(gold, texData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, Clone) { - cv::Mat gold = randomMat(size, type); + try + { + cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true); - EXPECT_NE(buf.bufId(), dst.bufId()); + EXPECT_NE(buf.bufId(), dst.bufId()); - cv::Mat bufData; - dst.copyTo(bufData); + cv::Mat bufData; + dst.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 0); + EXPECT_MAT_NEAR(gold, bufData, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, MapHostRead) { - cv::Mat gold = randomMat(size, type); + try + { + cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY); + cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY); - EXPECT_MAT_NEAR(gold, dst, 0); + EXPECT_MAT_NEAR(gold, dst, 0); - buf.unmapHost(); + buf.unmapHost(); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, MapHostWrite) { - cv::Mat gold = randomMat(size, type); + try + { + cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true); - cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY); - gold.copyTo(dst); - buf.unmapHost(); - dst.release(); + cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY); + gold.copyTo(dst); + buf.unmapHost(); + dst.release(); - cv::Mat bufData; - buf.copyTo(bufData); + cv::Mat bufData; + buf.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 0); + EXPECT_MAT_NEAR(gold, bufData, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlBuffer, MapDevice) { - cv::Mat gold = randomMat(size, type); + try + { + cv::Mat gold = randomMat(size, type); - cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); + cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true); - cv::gpu::GpuMat dst = buf.mapDevice(); + cv::gpu::GpuMat dst = buf.mapDevice(); - EXPECT_MAT_NEAR(gold, dst, 0); + EXPECT_MAT_NEAR(gold, dst, 0); - buf.unmapDevice(); + buf.unmapDevice(); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES)); @@ -360,147 +504,243 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType) TEST_P(GlTexture2D, Constructor1) { - cv::GlTexture2D tex(size.height, size.width, format, true); + 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()); + 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) { - cv::GlTexture2D tex(size, format, true); + try + { + cv::GlTexture2D tex(size, format, true); - EXPECT_EQ(size.height, tex.rows()); - EXPECT_EQ(size.width, tex.cols()); - EXPECT_EQ(format, tex.format()); + 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) { - cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + try + { + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlTexture2D tex(gold, true); + cv::GlTexture2D tex(gold, true); - cv::Mat texData; - tex.copyTo(texData, depth); + cv::Mat texData; + tex.copyTo(texData, depth); - EXPECT_MAT_NEAR(gold, texData, 1e-2); + EXPECT_MAT_NEAR(gold, texData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlTexture2D, ConstructorFromGpuMat) { - cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::gpu::GpuMat d_gold(gold); + try + { + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::gpu::GpuMat d_gold(gold); - cv::GlTexture2D tex(d_gold, true); + cv::GlTexture2D tex(d_gold, true); - cv::Mat texData; - tex.copyTo(texData, depth); + cv::Mat texData; + tex.copyTo(texData, depth); - EXPECT_MAT_NEAR(gold, texData, 1e-2); + EXPECT_MAT_NEAR(gold, texData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlTexture2D, ConstructorFromGlBuffer) { - cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); + try + { + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); - cv::GlTexture2D tex(buf_gold, true); + cv::GlTexture2D tex(buf_gold, true); - cv::Mat texData; - tex.copyTo(texData, depth); + cv::Mat texData; + tex.copyTo(texData, depth); - EXPECT_MAT_NEAR(gold, texData, 1e-2); + EXPECT_MAT_NEAR(gold, texData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlTexture2D, ConstructorFromGlTexture2D) { - cv::GlTexture2D tex_gold(size, format, true); - cv::GlTexture2D tex(tex_gold); + try + { + cv::GlTexture2D tex_gold(size, format, true); + cv::GlTexture2D tex(tex_gold); - EXPECT_EQ(tex_gold.texId(), tex.texId()); - EXPECT_EQ(tex_gold.rows(), tex.rows()); - EXPECT_EQ(tex_gold.cols(), tex.cols()); - EXPECT_EQ(tex_gold.format(), tex.format()); + EXPECT_EQ(tex_gold.texId(), tex.texId()); + 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) { - cv::GlTexture2D tex; - tex.create(size.height, size.width, format, true); + 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()); + 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) { - cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + try + { + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlTexture2D tex; - tex.copyFrom(gold, true); + cv::GlTexture2D tex; + tex.copyFrom(gold, true); - cv::Mat texData; - tex.copyTo(texData, depth); + cv::Mat texData; + tex.copyTo(texData, depth); - EXPECT_MAT_NEAR(gold, texData, 1e-2); + EXPECT_MAT_NEAR(gold, texData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlTexture2D, CopyFromGpuMat) { - cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::gpu::GpuMat d_gold(gold); + try + { + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::gpu::GpuMat d_gold(gold); - cv::GlTexture2D tex; - tex.copyFrom(d_gold, true); + cv::GlTexture2D tex; + tex.copyFrom(d_gold, true); - cv::Mat texData; - tex.copyTo(texData, depth); + cv::Mat texData; + tex.copyTo(texData, depth); - EXPECT_MAT_NEAR(gold, texData, 1e-2); + EXPECT_MAT_NEAR(gold, texData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlTexture2D, CopyFromGlBuffer) { - cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); + try + { + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true); - cv::GlTexture2D tex; - tex.copyFrom(buf_gold, true); + cv::GlTexture2D tex; + tex.copyFrom(buf_gold, true); - cv::Mat texData; - tex.copyTo(texData, depth); + cv::Mat texData; + tex.copyTo(texData, depth); - EXPECT_MAT_NEAR(gold, texData, 1e-2); + EXPECT_MAT_NEAR(gold, texData, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlTexture2D, CopyToGpuMat) { - cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + try + { + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlTexture2D tex(gold, true); + cv::GlTexture2D tex(gold, true); - cv::gpu::GpuMat dst; - tex.copyTo(dst, depth); + cv::gpu::GpuMat dst; + tex.copyTo(dst, depth); - EXPECT_MAT_NEAR(gold, dst, 1e-2); + EXPECT_MAT_NEAR(gold, dst, 1e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GlTexture2D, CopyToGlBuffer) { - cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + try + { + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); - cv::GlTexture2D tex(gold, true); + cv::GlTexture2D tex(gold, true); - cv::GlBuffer dst; - tex.copyTo(dst, depth, true); + cv::GlBuffer dst; + tex.copyTo(dst, depth, true); - cv::Mat bufData; - dst.copyTo(bufData); + cv::Mat bufData; + dst.copyTo(bufData); - EXPECT_MAT_NEAR(gold, bufData, 1e-2); + 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))); diff --git a/modules/gpu/test/test_pyramids.cpp b/modules/gpu/test/test_pyramids.cpp index 1abd7841e..ae91b192b 100644 --- a/modules/gpu/test/test_pyramids.cpp +++ b/modules/gpu/test/test_pyramids.cpp @@ -66,15 +66,23 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(PyrDown, Accuracy) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi); - cv::gpu::pyrDown(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi); + cv::gpu::pyrDown(loadMat(src, useRoi), dst); - cv::Mat dst_gold; - cv::pyrDown(src, dst_gold); + cv::Mat dst_gold; + cv::pyrDown(src, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0); + 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,15 +114,23 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(PyrUp, Accuracy) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi); - cv::gpu::pyrUp(loadMat(src, useRoi), dst); + cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi); + cv::gpu::pyrUp(loadMat(src, useRoi), dst); - cv::Mat dst_gold; - cv::pyrUp(src, dst_gold); + cv::Mat dst_gold; + cv::pyrUp(src, dst_gold); - EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0); + 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( diff --git a/modules/gpu/test/test_remap.cpp b/modules/gpu/test/test_remap.cpp index 978e1044a..e8b44b5fe 100644 --- a/modules/gpu/test/test_remap.cpp +++ b/modules/gpu/test/test_remap.cpp @@ -154,16 +154,24 @@ PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Bo TEST_P(Remap, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Scalar val = randomScalar(0.0, 255.0); + try + { + cv::Mat src = randomMat(size, type); + cv::Scalar val = randomScalar(0.0, 255.0); - cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi); - cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val); + cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi); + cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val); - cv::Mat dst_gold; - remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val); + cv::Mat dst_gold; + remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val); - EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0); + 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( diff --git a/modules/gpu/test/test_resize.cpp b/modules/gpu/test/test_resize.cpp index cae2dbf41..b1b30bb26 100644 --- a/modules/gpu/test/test_resize.cpp +++ b/modules/gpu/test/test_resize.cpp @@ -138,15 +138,23 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol TEST_P(Resize, Accuracy) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast(src.cols * coeff), cv::saturate_cast(src.rows * coeff)), type, useRoi); - cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation); + cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast(src.cols * coeff), cv::saturate_cast(src.rows * coeff)), type, useRoi); + cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation); - cv::Mat dst_gold; - resizeGold(src, dst_gold, coeff, coeff, interpolation); + cv::Mat dst_gold; + resizeGold(src, dst_gold, coeff, coeff, interpolation); - EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0); + 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,15 +192,23 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double // downscaling only: used for classifiers TEST_P(ResizeSameAsHost, Accuracy) { - cv::Mat src = randomMat(size, type); + try + { + cv::Mat src = randomMat(size, type); - cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast(src.cols * coeff), cv::saturate_cast(src.rows * coeff)), type, useRoi); - cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation); + cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast(src.cols * coeff), cv::saturate_cast(src.rows * coeff)), type, useRoi); + cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation); - cv::Mat dst_gold; - cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation); + cv::Mat dst_gold; + cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation); - EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0); + 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,16 +242,24 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation) TEST_P(ResizeNPP, Accuracy) { - cv::Mat src = readImageType("stereobp/aloe-L.png", type); - ASSERT_FALSE(src.empty()); + try + { + cv::Mat src = readImageType("stereobp/aloe-L.png", type); + ASSERT_FALSE(src.empty()); - cv::gpu::GpuMat dst; - cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation); + cv::gpu::GpuMat dst; + cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation); - cv::Mat dst_gold; - resizeGold(src, dst_gold, coeff, coeff, interpolation); + cv::Mat dst_gold; + resizeGold(src, dst_gold, coeff, coeff, interpolation); - EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1); + EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeNPP, testing::Combine( diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp index cc397404a..695280de5 100644 --- a/modules/gpu/test/test_softcascade.cpp +++ b/modules/gpu/test/test_softcascade.cpp @@ -40,7 +40,7 @@ // //M*/ -#include +#include "test_precomp.hpp" #include #ifdef HAVE_CUDA @@ -158,62 +158,77 @@ GPU_TEST_P(SCascadeTestRoi, detect, testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")), testing::Range(0, 5))) { - 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()); - - cv::gpu::SCascade cascade; - - cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); - - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - - GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1); - rois.setTo(0); - - int nroi = GET_PARAM(3); - cv::Mat result(coloredCpu); - cv::RNG rng; - for (int i = 0; i < nroi; ++i) + try { - cv::Rect r = getFromTable(rng(10)); - GpuMat sub(rois, r); - sub.setTo(1); - cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1); + 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()); + + cv::gpu::SCascade cascade; + + cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); + + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + + GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1); + rois.setTo(0); + + int nroi = GET_PARAM(3); + cv::Mat result(coloredCpu); + cv::RNG rng; + for (int i = 0; i < nroi; ++i) + { + cv::Rect r = getFromTable(rng(10)); + GpuMat sub(rois, r); + sub.setTo(1); + cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1); + } + objectBoxes.setTo(0); + + cascade.detect(colored, rois, objectBoxes); + + cv::Mat dt(objectBoxes); + typedef cv::gpu::SCascade::Detection Detection; + + Detection* dts = ((Detection*)dt.data) + 1; + int* count = dt.ptr(0); + + printTotal(std::cout, *count); + + for (int i = 0; i < *count; ++i) + { + Detection d = dts[i]; + print(std::cout, d); + cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1); + } + + SHOW(result); } - objectBoxes.setTo(0); - - cascade.detect(colored, rois, objectBoxes); - - cv::Mat dt(objectBoxes); - typedef cv::gpu::SCascade::Detection Detection; - - Detection* dts = ((Detection*)dt.data) + 1; - int* count = dt.ptr(0); - - printTotal(std::cout, *count); - - for (int i = 0; i < *count; ++i) + catch (...) { - Detection d = dts[i]; - print(std::cout, d); - cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1); + cv::gpu::resetDevice(); + throw; } - - SHOW(result); - } TEST(SCascadeTest, readCascade) { - std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml"; - cv::gpu::SCascade cascade; + try + { + std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml"; + cv::gpu::SCascade cascade; - cv::FileStorage fs(xml, cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); + cv::FileStorage fs(xml, cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } typedef ::testing::TestWithParam SCascadeTestAll; @@ -221,105 +236,129 @@ GPU_TEST_P(SCascadeTestAll, detect, ALL_DEVICES ) { - 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; + 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; - cv::FileStorage fs(xml, cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); + cv::FileStorage fs(xml, cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() - + "../cv/cascadeandhog/bahnhof/image_00000000_0.png"); - ASSERT_FALSE(coloredCpu.empty()); + cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + + "../cv/cascadeandhog/bahnhof/image_00000000_0.png"); + ASSERT_FALSE(coloredCpu.empty()); - GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1); - rois.setTo(0); - GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2)); - sub.setTo(cv::Scalar::all(1)); + GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1); + rois.setTo(0); + GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2)); + sub.setTo(cv::Scalar::all(1)); - objectBoxes.setTo(0); - cascade.detect(colored, rois, objectBoxes); + objectBoxes.setTo(0); + cascade.detect(colored, rois, objectBoxes); - typedef cv::gpu::SCascade::Detection Detection; - cv::Mat detections(objectBoxes); - int a = *(detections.ptr(0)); - ASSERT_EQ(a ,2448); + typedef cv::gpu::SCascade::Detection Detection; + cv::Mat detections(objectBoxes); + int a = *(detections.ptr(0)); + ASSERT_EQ(a, 2448); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } GPU_TEST_P(SCascadeTestAll, detectOnIntegral, ALL_DEVICES ) { - 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; - - cv::FileStorage fs(xml, cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); - - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - - std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml"; - cv::FileStorage fsi(intPath, cv::FileStorage::READ); - ASSERT_TRUE(fsi.isOpened()); - - GpuMat hogluv(121 * 10, 161, CV_32SC1); - for (int i = 0; i < 10; ++i) + try { - cv::Mat channel; - fsi[std::string("channel") + itoa(i)] >> channel; - GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121)); - gchannel.upload(channel); + 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; + + cv::FileStorage fs(xml, cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); + + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + + std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml"; + cv::FileStorage fsi(intPath, cv::FileStorage::READ); + ASSERT_TRUE(fsi.isOpened()); + + GpuMat hogluv(121 * 10, 161, CV_32SC1); + for (int i = 0; i < 10; ++i) + { + cv::Mat channel; + fsi[std::string("channel") + itoa(i)] >> channel; + GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121)); + gchannel.upload(channel); + } + + GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1); + rois.setTo(1); + + objectBoxes.setTo(0); + cascade.detect(hogluv, rois, objectBoxes); + + typedef cv::gpu::SCascade::Detection Detection; + cv::Mat detections(objectBoxes); + int a = *(detections.ptr(0)); + + ASSERT_EQ(a, 1024); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } - - GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1); - rois.setTo(1); - - objectBoxes.setTo(0); - cascade.detect(hogluv, rois, objectBoxes); - - typedef cv::gpu::SCascade::Detection Detection; - cv::Mat detections(objectBoxes); - int a = *(detections.ptr(0)); - - ASSERT_EQ( a ,1024); } GPU_TEST_P(SCascadeTestAll, detectStream, ALL_DEVICES ) { - 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; + 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; - cv::FileStorage fs(xml, cv::FileStorage::READ); - ASSERT_TRUE(fs.isOpened()); + cv::FileStorage fs(xml, cv::FileStorage::READ); + ASSERT_TRUE(fs.isOpened()); - ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); + ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode())); - cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() - + "../cv/cascadeandhog/bahnhof/image_00000000_0.png"); - ASSERT_FALSE(coloredCpu.empty()); + cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + + "../cv/cascadeandhog/bahnhof/image_00000000_0.png"); + ASSERT_FALSE(coloredCpu.empty()); - GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1); - rois.setTo(0); - GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2)); - sub.setTo(cv::Scalar::all(1)); + GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1); + rois.setTo(0); + GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2)); + sub.setTo(cv::Scalar::all(1)); - cv::gpu::Stream s; + cv::gpu::Stream s; - objectBoxes.setTo(0); - cascade.detect(colored, rois, objectBoxes, s); - s.waitForCompletion(); + objectBoxes.setTo(0); + cascade.detect(colored, rois, objectBoxes, s); + s.waitForCompletion(); - typedef cv::gpu::SCascade::Detection Detection; - cv::Mat detections(objectBoxes); - int a = *(detections.ptr(0)); - ASSERT_EQ(a ,2448); + typedef cv::gpu::SCascade::Detection Detection; + cv::Mat detections(objectBoxes); + int a = *(detections.ptr(0)); + ASSERT_EQ(a, 2448); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } -#endif \ No newline at end of file +#endif diff --git a/modules/gpu/test/test_threshold.cpp b/modules/gpu/test/test_threshold.cpp index c56921045..38d92a64d 100644 --- a/modules/gpu/test/test_threshold.cpp +++ b/modules/gpu/test/test_threshold.cpp @@ -68,17 +68,25 @@ PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, Use TEST_P(Threshold, Accuracy) { - cv::Mat src = randomMat(size, type); - double maxVal = randomDouble(20.0, 127.0); - double thresh = randomDouble(0.0, maxVal); + try + { + cv::Mat src = randomMat(size, type); + double maxVal = randomDouble(20.0, 127.0); + double thresh = randomDouble(0.0, maxVal); - cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi); - cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp); + cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi); + cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp); - cv::Mat dst_gold; - cv::threshold(src, dst_gold, thresh, maxVal, threshOp); + cv::Mat dst_gold; + cv::threshold(src, dst_gold, thresh, maxVal, threshOp); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine( diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp index 97e792c7f..6162ee2c9 100644 --- a/modules/gpu/test/test_video.cpp +++ b/modules/gpu/test/test_video.cpp @@ -65,67 +65,74 @@ struct BroxOpticalFlow : testing::TestWithParam TEST_P(BroxOpticalFlow, Regression) { - cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1); - ASSERT_FALSE(frame0.empty()); + try + { + cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1); + ASSERT_FALSE(frame0.empty()); - cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1); - ASSERT_FALSE(frame1.empty()); + cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1); + ASSERT_FALSE(frame1.empty()); - cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, - 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); + cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, + 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); - cv::gpu::GpuMat u; - cv::gpu::GpuMat v; - brox(loadMat(frame0), loadMat(frame1), u, v); + cv::gpu::GpuMat u; + cv::gpu::GpuMat v; + brox(loadMat(frame0), loadMat(frame1), u, v); -#ifndef DUMP - std::string fname(cvtest::TS::ptr()->get_data_path()); - if (devInfo.majorVersion() >= 2) - fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20; - else - fname += BROX_OPTICAL_FLOW_DUMP_FILE; + #ifndef DUMP + std::string fname(cvtest::TS::ptr()->get_data_path()); + if (devInfo.majorVersion() >= 2) + fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20; + else + fname += BROX_OPTICAL_FLOW_DUMP_FILE; - std::ifstream f(fname.c_str(), std::ios_base::binary); + std::ifstream f(fname.c_str(), std::ios_base::binary); - int rows, cols; + int rows, cols; - f.read((char*)&rows, sizeof(rows)); - f.read((char*)&cols, sizeof(cols)); + f.read((char*)&rows, sizeof(rows)); + f.read((char*)&cols, sizeof(cols)); - cv::Mat u_gold(rows, cols, CV_32FC1); + cv::Mat u_gold(rows, cols, CV_32FC1); - for (int i = 0; i < u_gold.rows; ++i) - f.read(u_gold.ptr(i), u_gold.cols * sizeof(float)); + for (int i = 0; i < u_gold.rows; ++i) + f.read(u_gold.ptr(i), u_gold.cols * sizeof(float)); - cv::Mat v_gold(rows, cols, CV_32FC1); + cv::Mat v_gold(rows, cols, CV_32FC1); - for (int i = 0; i < v_gold.rows; ++i) - f.read(v_gold.ptr(i), v_gold.cols * sizeof(float)); + for (int i = 0; i < v_gold.rows; ++i) + f.read(v_gold.ptr(i), v_gold.cols * sizeof(float)); - EXPECT_MAT_NEAR(u_gold, u, 0); - EXPECT_MAT_NEAR(v_gold, v, 0); -#else - std::string fname(cvtest::TS::ptr()->get_data_path()); - if (devInfo.majorVersion() >= 2) - fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20; - else - fname += BROX_OPTICAL_FLOW_DUMP_FILE; + EXPECT_MAT_NEAR(u_gold, u, 0); + EXPECT_MAT_NEAR(v_gold, v, 0); + #else + std::string fname(cvtest::TS::ptr()->get_data_path()); + if (devInfo.majorVersion() >= 2) + fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20; + else + fname += BROX_OPTICAL_FLOW_DUMP_FILE; - std::ofstream f(fname.c_str(), std::ios_base::binary); + std::ofstream f(fname.c_str(), std::ios_base::binary); - f.write((char*)&u.rows, sizeof(u.rows)); - f.write((char*)&u.cols, sizeof(u.cols)); + f.write((char*)&u.rows, sizeof(u.rows)); + f.write((char*)&u.cols, sizeof(u.cols)); - cv::Mat h_u(u); - cv::Mat h_v(v); + cv::Mat h_u(u); + cv::Mat h_v(v); - for (int i = 0; i < u.rows; ++i) - f.write(h_u.ptr(i), u.cols * sizeof(float)); + for (int i = 0; i < u.rows; ++i) + f.write(h_u.ptr(i), u.cols * sizeof(float)); - for (int i = 0; i < v.rows; ++i) - f.write(h_v.ptr(i), v.cols * sizeof(float)); - -#endif + for (int i = 0; i < v.rows; ++i) + f.write(h_v.ptr(i), v.cols * sizeof(float)); + #endif + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES); @@ -151,28 +158,16 @@ PARAM_TEST_CASE(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance) TEST_P(GoodFeaturesToTrack, Accuracy) { - cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(image.empty()); - - int maxCorners = 1000; - double qualityLevel = 0.01; - - 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 + try { + cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(image.empty()); + + int maxCorners = 1000; + double qualityLevel = 0.01; + + cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance); + cv::gpu::GpuMat d_pts; detector(loadMat(image), d_pts); @@ -201,21 +196,34 @@ TEST_P(GoodFeaturesToTrack, Accuracy) ASSERT_LE(bad_ratio, 0.01); } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } TEST_P(GoodFeaturesToTrack, EmptyCorners) { - int maxCorners = 1000; - double qualityLevel = 0.01; + try + { + int maxCorners = 1000; + double qualityLevel = 0.01; - cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance); + cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance); - cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0)); - cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2); + cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0)); + cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2); - detector(src, corners); + detector(src, corners); - ASSERT_TRUE( corners.empty() ); + ASSERT_TRUE( corners.empty() ); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine( @@ -243,70 +251,78 @@ PARAM_TEST_CASE(PyrLKOpticalFlow, cv::gpu::DeviceInfo, UseGray) TEST_P(PyrLKOpticalFlow, Sparse) { - cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR); - ASSERT_FALSE(frame0.empty()); - - cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR); - ASSERT_FALSE(frame1.empty()); - - cv::Mat gray_frame; - if (useGray) - gray_frame = frame0; - else - cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY); - - std::vector pts; - cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0); - - cv::gpu::GpuMat d_pts; - cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]); - d_pts.upload(pts_mat); - - cv::gpu::PyrLKOpticalFlow pyrLK; - - cv::gpu::GpuMat d_nextPts; - cv::gpu::GpuMat d_status; - pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status); - - std::vector nextPts(d_nextPts.cols); - cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]); - d_nextPts.download(nextPts_mat); - - std::vector status(d_status.cols); - cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]); - d_status.download(status_mat); - - std::vector nextPts_gold; - std::vector status_gold; - cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray()); - - ASSERT_EQ(nextPts_gold.size(), nextPts.size()); - ASSERT_EQ(status_gold.size(), status.size()); - - size_t mistmatch = 0; - for (size_t i = 0; i < nextPts.size(); ++i) + try { - cv::Point2i a = nextPts[i]; - cv::Point2i b = nextPts_gold[i]; + cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR); + ASSERT_FALSE(frame0.empty()); - if (status[i] != status_gold[i]) + cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR); + ASSERT_FALSE(frame1.empty()); + + cv::Mat gray_frame; + if (useGray) + gray_frame = frame0; + else + cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY); + + std::vector pts; + cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0); + + cv::gpu::GpuMat d_pts; + cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]); + d_pts.upload(pts_mat); + + cv::gpu::PyrLKOpticalFlow pyrLK; + + cv::gpu::GpuMat d_nextPts; + cv::gpu::GpuMat d_status; + pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status); + + std::vector nextPts(d_nextPts.cols); + cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]); + d_nextPts.download(nextPts_mat); + + std::vector status(d_status.cols); + cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]); + d_status.download(status_mat); + + std::vector nextPts_gold; + std::vector status_gold; + cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray()); + + ASSERT_EQ(nextPts_gold.size(), nextPts.size()); + ASSERT_EQ(status_gold.size(), status.size()); + + size_t mistmatch = 0; + for (size_t i = 0; i < nextPts.size(); ++i) { - ++mistmatch; - continue; - } + cv::Point2i a = nextPts[i]; + cv::Point2i b = nextPts_gold[i]; - if (status[i]) - { - bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1; - - if (!eq) + if (status[i] != status_gold[i]) + { ++mistmatch; + continue; + } + + if (status[i]) + { + bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1; + + if (!eq) + ++mistmatch; + } } + + double bad_ratio = static_cast(mistmatch) / nextPts.size(); + + ASSERT_LE(bad_ratio, 0.01); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } - - double bad_ratio = static_cast(mistmatch) / nextPts.size(); - - ASSERT_LE(bad_ratio, 0.01); } INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine( @@ -343,45 +359,53 @@ PARAM_TEST_CASE(FarnebackOpticalFlow, cv::gpu::DeviceInfo, PyrScale, PolyN, Farn TEST_P(FarnebackOpticalFlow, Accuracy) { - cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame0.empty()); - - cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame1.empty()); - - double polySigma = polyN <= 5 ? 1.1 : 1.5; - - cv::gpu::FarnebackOpticalFlow calc; - calc.pyrScale = pyrScale; - calc.polyN = polyN; - calc.polySigma = polySigma; - calc.flags = flags; - - cv::gpu::GpuMat d_flowx, d_flowy; - calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy); - - cv::Mat flow; - if (useInitFlow) + try { - cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)}; - cv::merge(flowxy, 2, flow); - } + cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame0.empty()); - if (useInitFlow) - { - calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW; + cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame1.empty()); + + double polySigma = polyN <= 5 ? 1.1 : 1.5; + + cv::gpu::FarnebackOpticalFlow calc; + calc.pyrScale = pyrScale; + calc.polyN = polyN; + calc.polySigma = polySigma; + calc.flags = flags; + + cv::gpu::GpuMat d_flowx, d_flowy; calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy); + + cv::Mat flow; + if (useInitFlow) + { + cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)}; + cv::merge(flowxy, 2, flow); + } + + if (useInitFlow) + { + calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW; + calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy); + } + + cv::calcOpticalFlowFarneback( + frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize, + calc.numIters, calc.polyN, calc.polySigma, calc.flags); + + std::vector flowxy; + cv::split(flow, flowxy); + + EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1); + EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } - - cv::calcOpticalFlowFarneback( - frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize, - calc.numIters, calc.polyN, calc.polySigma, calc.flags); - - std::vector flowxy; - cv::split(flow, flowxy); - - EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1); - EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1); } INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine( @@ -395,27 +419,35 @@ struct OpticalFlowNan : public BroxOpticalFlow {}; TEST_P(OpticalFlowNan, Regression) { - cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1); - ASSERT_FALSE(frame0.empty()); - cv::Mat r_frame0, r_frame1; - cv::resize(frame0, r_frame0, cv::Size(1380,1000)); + try + { + cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1); + ASSERT_FALSE(frame0.empty()); + cv::Mat r_frame0, r_frame1; + cv::resize(frame0, r_frame0, cv::Size(1380,1000)); - cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1); - ASSERT_FALSE(frame1.empty()); - cv::resize(frame1, r_frame1, cv::Size(1380,1000)); + cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1); + ASSERT_FALSE(frame1.empty()); + cv::resize(frame1, r_frame1, cv::Size(1380,1000)); - cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, - 5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/); + cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, + 5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/); - cv::gpu::GpuMat u; - cv::gpu::GpuMat v; - brox(loadMat(r_frame0), loadMat(r_frame1), u, v); + cv::gpu::GpuMat u; + cv::gpu::GpuMat v; + brox(loadMat(r_frame0), loadMat(r_frame1), u, v); - cv::Mat h_u, h_v; - u.download(h_u); - v.download(h_v); - EXPECT_TRUE(cv::checkRange(h_u)); - EXPECT_TRUE(cv::checkRange(h_v)); + cv::Mat h_u, h_v; + u.download(h_u); + 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,30 +461,38 @@ PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi) TEST_P(OpticalFlowDual_TVL1, Accuracy) { - cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::gpu::setDevice(devInfo.deviceID()); + try + { + cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); - const bool useRoi = GET_PARAM(1); + const bool useRoi = GET_PARAM(1); - cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame0.empty()); + cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame0.empty()); - cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame1.empty()); + cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame1.empty()); - cv::gpu::OpticalFlowDual_TVL1_GPU d_alg; - cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi); - cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi); - d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy); + cv::gpu::OpticalFlowDual_TVL1_GPU d_alg; + cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi); + cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi); + d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy); - cv::OpticalFlowDual_TVL1 alg; - cv::Mat flow; - alg(frame0, frame1, flow); - cv::Mat gold[2]; - cv::split(flow, gold); + cv::OpticalFlowDual_TVL1 alg; + cv::Mat flow; + alg(frame0, frame1, flow); + cv::Mat gold[2]; + cv::split(flow, gold); - EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3); - EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3); + 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,29 +526,37 @@ struct OpticalFlowBM : testing::TestWithParam TEST_P(OpticalFlowBM, Accuracy) { - cv::gpu::DeviceInfo devInfo = GetParam(); - cv::gpu::setDevice(devInfo.deviceID()); + try + { + cv::gpu::DeviceInfo devInfo = GetParam(); + cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame0.empty()); + cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame0.empty()); - cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame1.empty()); + cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame1.empty()); - cv::Size block_size(16, 16); - cv::Size shift_size(1, 1); - cv::Size max_range(16, 16); + cv::Size block_size(16, 16); + cv::Size shift_size(1, 1); + cv::Size max_range(16, 16); - cv::gpu::GpuMat d_velx, d_vely, buf; - cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1), - block_size, shift_size, max_range, false, - d_velx, d_vely, buf); + cv::gpu::GpuMat d_velx, d_vely, buf; + cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1), + block_size, shift_size, max_range, false, + d_velx, d_vely, buf); - cv::Mat velx, vely; - calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely); + cv::Mat velx, vely; + calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely); - EXPECT_MAT_NEAR(velx, d_velx, 0); - EXPECT_MAT_NEAR(vely, d_vely, 0); + 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,44 +634,52 @@ struct FastOpticalFlowBM : testing::TestWithParam TEST_P(FastOpticalFlowBM, Accuracy) { - const double MAX_RMSE = 0.6; + try + { + const double MAX_RMSE = 0.6; - int search_window = 15; - int block_window = 5; + int search_window = 15; + int block_window = 5; - cv::gpu::DeviceInfo devInfo = GetParam(); - cv::gpu::setDevice(devInfo.deviceID()); + cv::gpu::DeviceInfo devInfo = GetParam(); + cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame0.empty()); + cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame0.empty()); - cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame1.empty()); + cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame1.empty()); - cv::Size smallSize(320, 240); - cv::Mat frame0_small; - cv::Mat frame1_small; + cv::Size smallSize(320, 240); + cv::Mat frame0_small; + cv::Mat frame1_small; - cv::resize(frame0, frame0_small, smallSize); - cv::resize(frame1, frame1_small, smallSize); + cv::resize(frame0, frame0_small, smallSize); + cv::resize(frame1, frame1_small, smallSize); - cv::gpu::GpuMat d_flowx; - cv::gpu::GpuMat d_flowy; - cv::gpu::FastOpticalFlowBM fastBM; + cv::gpu::GpuMat d_flowx; + cv::gpu::GpuMat d_flowy; + cv::gpu::FastOpticalFlowBM fastBM; - fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window); + fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window); - cv::Mat_ flowx; - cv::Mat_ flowy; - FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window); + cv::Mat_ flowx; + cv::Mat_ flowy; + FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window); - double err; + double err; - err = calc_rmse(flowx, cv::Mat(d_flowx)); - EXPECT_LE(err, MAX_RMSE); + err = calc_rmse(flowx, cv::Mat(d_flowx)); + EXPECT_LE(err, MAX_RMSE); - err = calc_rmse(flowy, cv::Mat(d_flowy)); - EXPECT_LE(err, MAX_RMSE); + 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,55 +714,63 @@ PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels) TEST_P(FGDStatModel, Update) { - cv::VideoCapture cap(inputFile); - ASSERT_TRUE(cap.isOpened()); - - cv::Mat frame; - cap >> frame; - ASSERT_FALSE(frame.empty()); - - IplImage ipl_frame = frame; - cv::Ptr model(cvCreateFGDStatModel(&ipl_frame)); - - cv::gpu::GpuMat d_frame(frame); - cv::gpu::FGDStatModel d_model(out_cn); - d_model.create(d_frame); - - cv::Mat h_background; - cv::Mat h_foreground; - cv::Mat h_background3; - - cv::Mat backgroundDiff; - cv::Mat foregroundDiff; - - for (int i = 0; i < 5; ++i) + try { + cv::VideoCapture cap(inputFile); + ASSERT_TRUE(cap.isOpened()); + + cv::Mat frame; cap >> frame; ASSERT_FALSE(frame.empty()); - ipl_frame = frame; - int gold_count = cvUpdateBGStatModel(&ipl_frame, model); + IplImage ipl_frame = frame; + cv::Ptr model(cvCreateFGDStatModel(&ipl_frame)); - d_frame.upload(frame); + cv::gpu::GpuMat d_frame(frame); + cv::gpu::FGDStatModel d_model(out_cn); + d_model.create(d_frame); - int count = d_model.update(d_frame); + cv::Mat h_background; + cv::Mat h_foreground; + cv::Mat h_background3; - ASSERT_EQ(gold_count, count); + cv::Mat backgroundDiff; + cv::Mat foregroundDiff; - cv::Mat gold_background(model->background); - cv::Mat gold_foreground(model->foreground); - - if (out_cn == 3) - d_model.background.download(h_background3); - else + for (int i = 0; i < 5; ++i) { - d_model.background.download(h_background); - cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR); - } - d_model.foreground.download(h_foreground); + cap >> frame; + ASSERT_FALSE(frame.empty()); - ASSERT_MAT_NEAR(gold_background, h_background3, 1.0); - ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0); + ipl_frame = frame; + int gold_count = cvUpdateBGStatModel(&ipl_frame, model); + + d_frame.upload(frame); + + int count = d_model.update(d_frame); + + ASSERT_EQ(gold_count, count); + + cv::Mat gold_background(model->background); + cv::Mat gold_foreground(model->foreground); + + if (out_cn == 3) + d_model.background.download(h_background3); + else + { + d_model.background.download(h_background); + cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR); + } + d_model.foreground.download(h_foreground); + + ASSERT_MAT_NEAR(gold_background, h_background3, 1.0); + ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0); + } + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } @@ -745,36 +809,44 @@ PARAM_TEST_CASE(MOG, cv::gpu::DeviceInfo, std::string, UseGray, LearningRate, Us TEST_P(MOG, Update) { - cv::VideoCapture cap(inputFile); - ASSERT_TRUE(cap.isOpened()); - - cv::Mat frame; - cap >> frame; - ASSERT_FALSE(frame.empty()); - - cv::gpu::MOG_GPU mog; - cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi); - - cv::BackgroundSubtractorMOG mog_gold; - cv::Mat foreground_gold; - - for (int i = 0; i < 10; ++i) + try { + cv::VideoCapture cap(inputFile); + ASSERT_TRUE(cap.isOpened()); + + cv::Mat frame; cap >> frame; ASSERT_FALSE(frame.empty()); - if (useGray) + cv::gpu::MOG_GPU mog; + cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi); + + cv::BackgroundSubtractorMOG mog_gold; + cv::Mat foreground_gold; + + for (int i = 0; i < 10; ++i) { - cv::Mat temp; - cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); - cv::swap(temp, frame); + cap >> frame; + ASSERT_FALSE(frame.empty()); + + if (useGray) + { + cv::Mat temp; + cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); + cv::swap(temp, frame); + } + + mog(loadMat(frame, useRoi), foreground, (float)learningRate); + + mog_gold(frame, foreground_gold, learningRate); + + ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0); } - - mog(loadMat(frame, useRoi), foreground, (float)learningRate); - - mog_gold(frame, foreground_gold, learningRate); - - ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } @@ -810,40 +882,48 @@ PARAM_TEST_CASE(MOG2, cv::gpu::DeviceInfo, std::string, UseGray, UseRoi) TEST_P(MOG2, Update) { - cv::VideoCapture cap(inputFile); - ASSERT_TRUE(cap.isOpened()); - - cv::Mat frame; - cap >> frame; - ASSERT_FALSE(frame.empty()); - - cv::gpu::MOG2_GPU mog2; - cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi); - - cv::BackgroundSubtractorMOG2 mog2_gold; - cv::Mat foreground_gold; - - for (int i = 0; i < 10; ++i) + try { + cv::VideoCapture cap(inputFile); + ASSERT_TRUE(cap.isOpened()); + + cv::Mat frame; cap >> frame; ASSERT_FALSE(frame.empty()); - if (useGray) + cv::gpu::MOG2_GPU mog2; + cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi); + + cv::BackgroundSubtractorMOG2 mog2_gold; + cv::Mat foreground_gold; + + for (int i = 0; i < 10; ++i) { - cv::Mat temp; - cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); - cv::swap(temp, frame); + cap >> frame; + ASSERT_FALSE(frame.empty()); + + if (useGray) + { + cv::Mat temp; + cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY); + cv::swap(temp, frame); + } + + mog2(loadMat(frame, useRoi), foreground); + + mog2_gold(frame, foreground_gold); + + double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1); + + norm /= foreground_gold.size().area(); + + ASSERT_LE(norm, 0.09); } - - mog2(loadMat(frame, useRoi), foreground); - - mog2_gold(frame, foreground_gold); - - double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1); - - norm /= foreground_gold.size().area(); - - ASSERT_LE(norm, 0.09); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } } @@ -852,34 +932,42 @@ TEST_P(MOG2, getBackgroundImage) if (useGray) return; - cv::VideoCapture cap(inputFile); - ASSERT_TRUE(cap.isOpened()); - - cv::Mat frame; - - cv::gpu::MOG2_GPU mog2; - cv::gpu::GpuMat foreground; - - cv::BackgroundSubtractorMOG2 mog2_gold; - cv::Mat foreground_gold; - - for (int i = 0; i < 10; ++i) + try { - cap >> frame; - ASSERT_FALSE(frame.empty()); + cv::VideoCapture cap(inputFile); + ASSERT_TRUE(cap.isOpened()); - mog2(loadMat(frame, useRoi), foreground); + cv::Mat frame; - mog2_gold(frame, foreground_gold); + cv::gpu::MOG2_GPU mog2; + cv::gpu::GpuMat foreground; + + cv::BackgroundSubtractorMOG2 mog2_gold; + cv::Mat foreground_gold; + + for (int i = 0; i < 10; ++i) + { + cap >> frame; + ASSERT_FALSE(frame.empty()); + + mog2(loadMat(frame, useRoi), foreground); + + mog2_gold(frame, foreground_gold); + } + + cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi); + mog2.getBackgroundImage(background); + + cv::Mat background_gold; + mog2_gold.getBackgroundImage(background_gold); + + ASSERT_MAT_NEAR(background_gold, background, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } - - cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi); - mog2.getBackgroundImage(background); - - cv::Mat background_gold; - mog2_gold.getBackgroundImage(background_gold); - - ASSERT_MAT_NEAR(background_gold, background, 0); } INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine( @@ -897,30 +985,38 @@ PARAM_TEST_CASE(VIBE, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi) TEST_P(VIBE, Accuracy) { - const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::gpu::setDevice(devInfo.deviceID()); - const cv::Size size = GET_PARAM(1); - const int type = GET_PARAM(2); - const bool useRoi = GET_PARAM(3); + try + { + const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + const cv::Size size = GET_PARAM(1); + const int type = GET_PARAM(2); + const bool useRoi = GET_PARAM(3); - const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255)); + const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255)); - cv::Mat frame = randomMat(size, type, 0.0, 100); - cv::gpu::GpuMat d_frame = loadMat(frame, useRoi); + cv::Mat frame = randomMat(size, type, 0.0, 100); + cv::gpu::GpuMat d_frame = loadMat(frame, useRoi); - cv::gpu::VIBE_GPU vibe; - cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi); - vibe.initialize(d_frame); + cv::gpu::VIBE_GPU vibe; + cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi); + vibe.initialize(d_frame); - for (int i = 0; i < 20; ++i) + for (int i = 0; i < 20; ++i) + vibe(d_frame, d_fgmask); + + frame = randomMat(size, type, 160, 255); + d_frame = loadMat(frame, useRoi); vibe(d_frame, d_fgmask); - frame = randomMat(size, type, 160, 255); - d_frame = loadMat(frame, useRoi); - vibe(d_frame, d_fgmask); - - // now fgmask should be entirely foreground - ASSERT_MAT_NEAR(fullfg, d_fgmask, 0); + // 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,42 +1034,50 @@ PARAM_TEST_CASE(GMG, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi) TEST_P(GMG, Accuracy) { - const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::gpu::setDevice(devInfo.deviceID()); - const cv::Size size = GET_PARAM(1); - const int depth = GET_PARAM(2); - const int channels = GET_PARAM(3); - const bool useRoi = GET_PARAM(4); - - const int type = CV_MAKE_TYPE(depth, channels); - - const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0)); - const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255)); - - cv::Mat frame = randomMat(size, type, 0, 100); - cv::gpu::GpuMat d_frame = loadMat(frame, useRoi); - - cv::gpu::GMG_GPU gmg; - gmg.numInitializationFrames = 5; - gmg.smoothingRadius = 0; - gmg.initialize(d_frame.size(), 0, 255); - - cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi); - - for (int i = 0; i < gmg.numInitializationFrames; ++i) + try { + const cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + const cv::Size size = GET_PARAM(1); + const int depth = GET_PARAM(2); + const int channels = GET_PARAM(3); + const bool useRoi = GET_PARAM(4); + + const int type = CV_MAKE_TYPE(depth, channels); + + const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0)); + const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255)); + + cv::Mat frame = randomMat(size, type, 0, 100); + cv::gpu::GpuMat d_frame = loadMat(frame, useRoi); + + cv::gpu::GMG_GPU gmg; + gmg.numInitializationFrames = 5; + gmg.smoothingRadius = 0; + gmg.initialize(d_frame.size(), 0, 255); + + cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi); + + for (int i = 0; i < gmg.numInitializationFrames; ++i) + { + gmg(d_frame, d_fgmask); + + // fgmask should be entirely background during training + ASSERT_MAT_NEAR(zeros, d_fgmask, 0); + } + + frame = randomMat(size, type, 160, 255); + d_frame = loadMat(frame, useRoi); gmg(d_frame, d_fgmask); - // fgmask should be entirely background during training - ASSERT_MAT_NEAR(zeros, d_fgmask, 0); + // now fgmask should be entirely foreground + ASSERT_MAT_NEAR(fullfg, d_fgmask, 0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; } - - frame = randomMat(size, type, 160, 255); - d_frame = loadMat(frame, useRoi); - gmg(d_frame, d_fgmask); - - // now fgmask should be entirely foreground - ASSERT_MAT_NEAR(fullfg, d_fgmask, 0); } INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine( @@ -1009,39 +1113,47 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string) TEST_P(VideoWriter, Regression) { - const double FPS = 25.0; - - cv::VideoCapture reader(inputFile); - ASSERT_TRUE( reader.isOpened() ); - - cv::gpu::VideoWriter_GPU d_writer; - - cv::Mat frame; - cv::gpu::GpuMat d_frame; - - for (int i = 0; i < 10; ++i) + try { - reader >> frame; - ASSERT_FALSE(frame.empty()); + const double FPS = 25.0; - d_frame.upload(frame); + cv::VideoCapture reader(inputFile); + ASSERT_TRUE( reader.isOpened() ); - if (!d_writer.isOpened()) - d_writer.open(outputFile, frame.size(), FPS); + cv::gpu::VideoWriter_GPU d_writer; - d_writer.write(d_frame); + cv::Mat frame; + cv::gpu::GpuMat d_frame; + + for (int i = 0; i < 10; ++i) + { + reader >> frame; + ASSERT_FALSE(frame.empty()); + + d_frame.upload(frame); + + if (!d_writer.isOpened()) + d_writer.open(outputFile, frame.size(), FPS); + + d_writer.write(d_frame); + } + + reader.release(); + d_writer.close(); + + reader.open(outputFile); + ASSERT_TRUE( reader.isOpened() ); + + for (int i = 0; i < 5; ++i) + { + reader >> frame; + ASSERT_FALSE( frame.empty() ); + } } - - reader.release(); - d_writer.close(); - - reader.open(outputFile); - ASSERT_TRUE( reader.isOpened() ); - - for (int i = 0; i < 5; ++i) + catch (...) { - reader >> frame; - ASSERT_FALSE( frame.empty() ); + cv::gpu::resetDevice(); + throw; } } @@ -1070,19 +1182,27 @@ PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string) TEST_P(VideoReader, Regression) { - cv::gpu::VideoReader_GPU reader(inputFile); - ASSERT_TRUE( reader.isOpened() ); - - cv::gpu::GpuMat frame; - - for (int i = 0; i < 10; ++i) + try { - ASSERT_TRUE( reader.read(frame) ); - ASSERT_FALSE( frame.empty() ); - } + cv::gpu::VideoReader_GPU reader(inputFile); + ASSERT_TRUE( reader.isOpened() ); - reader.close(); - ASSERT_FALSE( reader.isOpened() ); + cv::gpu::GpuMat frame; + + for (int i = 0; i < 10; ++i) + { + ASSERT_TRUE( reader.read(frame) ); + ASSERT_FALSE( frame.empty() ); + } + + reader.close(); + ASSERT_FALSE( reader.isOpened() ); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine( diff --git a/modules/gpu/test/test_warp_affine.cpp b/modules/gpu/test/test_warp_affine.cpp index 065c6755e..256f7504a 100644 --- a/modules/gpu/test/test_warp_affine.cpp +++ b/modules/gpu/test/test_warp_affine.cpp @@ -76,24 +76,32 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse) TEST_P(BuildWarpAffineMaps, Accuracy) { - cv::Mat M = createTransfomMatrix(size, CV_PI / 4); - cv::gpu::GpuMat xmap, ymap; - cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap); + try + { + cv::Mat M = createTransfomMatrix(size, CV_PI / 4); + cv::gpu::GpuMat xmap, ymap; + cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap); - int interpolation = cv::INTER_NEAREST; - int borderMode = cv::BORDER_CONSTANT; + int interpolation = cv::INTER_NEAREST; + int borderMode = cv::BORDER_CONSTANT; - cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1); - cv::Mat dst; - cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode); + cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1); + cv::Mat dst; + cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode); - int flags = interpolation; - if (inverse) - flags |= cv::WARP_INVERSE_MAP; - cv::Mat dst_gold; - cv::warpAffine(src, dst_gold, M, size, flags, borderMode); + int flags = interpolation; + if (inverse) + flags |= cv::WARP_INVERSE_MAP; + cv::Mat dst_gold; + cv::warpAffine(src, dst_gold, M, size, flags, borderMode); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpAffineMaps, testing::Combine( @@ -201,20 +209,28 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int TEST_P(WarpAffine, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Mat M = createTransfomMatrix(size, CV_PI / 3); - int flags = interpolation; - if (inverse) - flags |= cv::WARP_INVERSE_MAP; - cv::Scalar val = randomScalar(0.0, 255.0); + try + { + cv::Mat src = randomMat(size, type); + cv::Mat M = createTransfomMatrix(size, CV_PI / 3); + int flags = interpolation; + if (inverse) + flags |= cv::WARP_INVERSE_MAP; + cv::Scalar val = randomScalar(0.0, 255.0); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val); - cv::Mat dst_gold; - warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val); + cv::Mat dst_gold; + warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val); - EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0); + 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,19 +265,27 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat TEST_P(WarpAffineNPP, Accuracy) { - cv::Mat src = readImageType("stereobp/aloe-L.png", type); - cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4); - int flags = interpolation; - if (inverse) - flags |= cv::WARP_INVERSE_MAP; + try + { + cv::Mat src = readImageType("stereobp/aloe-L.png", type); + cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4); + int flags = interpolation; + if (inverse) + flags |= cv::WARP_INVERSE_MAP; - cv::gpu::GpuMat dst; - cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags); + cv::gpu::GpuMat dst; + cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags); - cv::Mat dst_gold; - warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0)); + cv::Mat dst_gold; + warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0)); - EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2); + EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine( diff --git a/modules/gpu/test/test_warp_perspective.cpp b/modules/gpu/test/test_warp_perspective.cpp index 95c089bb9..77e88d43d 100644 --- a/modules/gpu/test/test_warp_perspective.cpp +++ b/modules/gpu/test/test_warp_perspective.cpp @@ -77,21 +77,29 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse TEST_P(BuildWarpPerspectiveMaps, Accuracy) { - cv::Mat M = createTransfomMatrix(size, CV_PI / 4); - cv::gpu::GpuMat xmap, ymap; - cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap); + try + { + cv::Mat M = createTransfomMatrix(size, CV_PI / 4); + cv::gpu::GpuMat xmap, ymap; + cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap); - cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1); - cv::Mat dst; - cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT); + cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1); + cv::Mat dst; + cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT); - int flags = cv::INTER_NEAREST; - if (inverse) - flags |= cv::WARP_INVERSE_MAP; - cv::Mat dst_gold; - cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT); + int flags = cv::INTER_NEAREST; + if (inverse) + flags |= cv::WARP_INVERSE_MAP; + cv::Mat dst_gold; + cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT); - EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + EXPECT_MAT_NEAR(dst_gold, dst, 0.0); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpPerspectiveMaps, testing::Combine( @@ -201,20 +209,28 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse TEST_P(WarpPerspective, Accuracy) { - cv::Mat src = randomMat(size, type); - cv::Mat M = createTransfomMatrix(size, CV_PI / 3); - int flags = interpolation; - if (inverse) - flags |= cv::WARP_INVERSE_MAP; - cv::Scalar val = randomScalar(0.0, 255.0); + try + { + cv::Mat src = randomMat(size, type); + cv::Mat M = createTransfomMatrix(size, CV_PI / 3); + int flags = interpolation; + if (inverse) + flags |= cv::WARP_INVERSE_MAP; + cv::Scalar val = randomScalar(0.0, 255.0); - cv::gpu::GpuMat dst = createMat(size, type, useRoi); - cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val); + cv::gpu::GpuMat dst = createMat(size, type, useRoi); + cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val); - cv::Mat dst_gold; - warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val); + cv::Mat dst_gold; + warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val); - EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0); + 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,19 +265,27 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter TEST_P(WarpPerspectiveNPP, Accuracy) { - cv::Mat src = readImageType("stereobp/aloe-L.png", type); - cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4); - int flags = interpolation; - if (inverse) - flags |= cv::WARP_INVERSE_MAP; + try + { + cv::Mat src = readImageType("stereobp/aloe-L.png", type); + cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4); + int flags = interpolation; + if (inverse) + flags |= cv::WARP_INVERSE_MAP; - cv::gpu::GpuMat dst; - cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags); + cv::gpu::GpuMat dst; + cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags); - cv::Mat dst_gold; - warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0)); + cv::Mat dst_gold; + warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0)); - EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2); + EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2); + } + catch (...) + { + cv::gpu::resetDevice(); + throw; + } } INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(