Revert "call resetDevice if gpu test fails"

This reverts commit ab25fe9e377fdbd69c916d5124483fa26e4a7835.

modules/gpu/app/nv_perf_test/main.cpp

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

modules/gpu/perf/perf_calib3d.cpp

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

modules/gpu/perf/perf_denoising.cpp

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

modules/gpu/perf/perf_features2d.cpp

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

modules/gpu/perf/perf_filters.cpp

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

modules/gpu/perf/perf_imgproc.cpp

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

modules/gpu/perf/perf_labeling.cpp

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

modules/gpu/perf/perf_matop.cpp

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

modules/gpu/perf/perf_objdetect.cpp

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

modules/gpu/perf/perf_softcascade.cpp

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

modules/gpu/perf/perf_video.cpp

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

modules/gpu/test/nvidia/main_nvidia.cpp

@@ -276,8 +276,6 @@ 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();
@@ -294,6 +292,8 @@ 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;

modules/gpu/test/test_calib3d.cpp

@@ -62,8 +62,6 @@ struct StereoBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoBM, Regression)
 {
-    try
-    {
     cv::Mat left_image  = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
     cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
     cv::Mat disp_gold   = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
@@ -78,12 +76,6 @@ TEST_P(StereoBM, Regression)
     bm(loadMat(left_image), loadMat(right_image), disp);
 
     EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBM, ALL_DEVICES);
@@ -105,8 +97,6 @@ struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoBeliefPropagation, Regression)
 {
-    try
-    {
     cv::Mat left_image  = readImage("stereobp/aloe-L.png");
     cv::Mat right_image = readImage("stereobp/aloe-R.png");
     cv::Mat disp_gold   = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
@@ -124,12 +114,6 @@ TEST_P(StereoBeliefPropagation, Regression)
     h_disp.convertTo(h_disp, disp_gold.depth());
 
     EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBeliefPropagation, ALL_DEVICES);
@@ -151,8 +135,6 @@ struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoConstantSpaceBP, Regression)
 {
-    try
-    {
     cv::Mat left_image  = readImage("csstereobp/aloe-L.png");
     cv::Mat right_image = readImage("csstereobp/aloe-R.png");
 
@@ -176,12 +158,6 @@ TEST_P(StereoConstantSpaceBP, Regression)
     h_disp.convertTo(h_disp, disp_gold.depth());
 
     EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
@@ -203,8 +179,6 @@ struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(TransformPoints, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
     cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
     cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@@ -232,12 +206,6 @@ TEST_P(TransformPoints, Accuracy)
 
         ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, TransformPoints, ALL_DEVICES);
@@ -259,8 +227,6 @@ struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(ProjectPoints, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
     cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
     cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@@ -290,12 +256,6 @@ TEST_P(ProjectPoints, Accuracy)
 
         ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ProjectPoints, ALL_DEVICES);
@@ -317,8 +277,6 @@ struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(SolvePnPRansac, Accuracy)
 {
-    try
-    {
     cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
     cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
     camera_mat.at<float>(0, 1) = 0.f;
@@ -341,12 +299,6 @@ TEST_P(SolvePnPRansac, Accuracy)
 
     ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3);
     ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, SolvePnPRansac, ALL_DEVICES);
@@ -374,8 +326,6 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use
 
 TEST_P(ReprojectImageTo3D, Accuracy)
 {
-    try
-    {
     cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
     cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
 
@@ -386,12 +336,6 @@ TEST_P(ReprojectImageTo3D, Accuracy)
     cv::reprojectImageTo3D(disp, dst_gold, Q, false);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(

modules/gpu/test/test_copy_make_border.cpp

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

modules/gpu/test/test_denoising.cpp

@@ -71,8 +71,6 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType)
 
 TEST_P(BilateralFilter, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     src.convertTo(src, type);
@@ -84,12 +82,6 @@ TEST_P(BilateralFilter, Accuracy)
     cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
 
     EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BilateralFilter, testing::Combine(
@@ -115,8 +107,6 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(BruteForceNonLocalMeans, Regression)
 {
-    try
-    {
     using cv::gpu::GpuMat;
 
     cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
@@ -129,10 +119,10 @@ TEST_P(BruteForceNonLocalMeans, Regression)
     cv::gpu::nonLocalMeans(GpuMat(bgr),  dbgr, 20);
     cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
 
-    #if 0
+#if 0
     dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
     dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
-    #endif
+#endif
 
     cv::Mat bgr_gold  = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
     cv::Mat gray_gold  = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
@@ -140,16 +130,12 @@ TEST_P(BruteForceNonLocalMeans, Regression)
 
     EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
     EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES);
 
+
+
 ////////////////////////////////////////////////////////
 // Fast Force Non local means
 
@@ -166,8 +152,6 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(FastNonLocalMeans, Regression)
 {
-    try
-    {
     using cv::gpu::GpuMat;
 
     cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
@@ -182,10 +166,10 @@ TEST_P(FastNonLocalMeans, Regression)
     fnlmd.simpleMethod(GpuMat(gray),  dgray, 20);
     fnlmd.labMethod(GpuMat(bgr),  dbgr, 20, 10);
 
-    #if 0
+#if 0
     //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
     //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
-    #endif
+#endif
 
     cv::Mat bgr_gold  = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
     cv::Mat gray_gold  = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
@@ -193,14 +177,9 @@ TEST_P(FastNonLocalMeans, Regression)
 
     EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
     EXPECT_MAT_NEAR(gray_gold, dgray, 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES);
 
+
 #endif // HAVE_CUDA

modules/gpu/test/test_features2d.cpp

@@ -180,8 +180,6 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves,
 
 TEST_P(SURF, Detector)
 {
-    try
-    {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
 
@@ -193,6 +191,20 @@ TEST_P(SURF, Detector)
     surf.upright = upright;
     surf.keypointsRatio = 0.05f;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
 
@@ -212,17 +224,10 @@ TEST_P(SURF, Detector)
 
         EXPECT_GT(matchedRatio, 0.95);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SURF, Detector_Masked)
 {
-    try
-    {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
 
@@ -237,6 +242,20 @@ TEST_P(SURF, Detector_Masked)
     surf.upright = upright;
     surf.keypointsRatio = 0.05f;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            surf(loadMat(image), loadMat(mask), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         surf(loadMat(image), loadMat(mask), keypoints);
 
@@ -256,17 +275,10 @@ TEST_P(SURF, Detector_Masked)
 
         EXPECT_GT(matchedRatio, 0.95);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SURF, Descriptor)
 {
-    try
-    {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
 
@@ -285,6 +297,21 @@ TEST_P(SURF, Descriptor)
     surf_gold.extended = extended;
     surf_gold.upright = upright;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            cv::gpu::GpuMat descriptors;
+            surf(loadMat(image), cv::gpu::GpuMat(), keypoints, descriptors);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         surf_gold(image, cv::noArray(), keypoints);
 
@@ -303,11 +330,6 @@ TEST_P(SURF, Descriptor)
 
         EXPECT_GT(matchedRatio, 0.6);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
@@ -342,14 +364,26 @@ PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression
 
 TEST_P(FAST, Accuracy)
 {
-    try
-    {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
 
     cv::gpu::FAST_GPU fast(threshold);
     fast.nonmaxSupression = nonmaxSupression;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
 
@@ -358,11 +392,6 @@ TEST_P(FAST, Accuracy)
 
         ASSERT_KEYPOINTS_EQ(keypoints_gold, keypoints);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
@@ -416,8 +445,6 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR
 
 TEST_P(ORB, Accuracy)
 {
-    try
-    {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
 
@@ -427,6 +454,21 @@ TEST_P(ORB, Accuracy)
     cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
     orb.blurForDescriptor = blurForDescriptor;
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            cv::gpu::GpuMat descriptors;
+            orb(loadMat(image), loadMat(mask), keypoints, descriptors);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector<cv::KeyPoint> keypoints;
         cv::gpu::GpuMat descriptors;
         orb(loadMat(image), loadMat(mask), keypoints, descriptors);
@@ -446,11 +488,6 @@ TEST_P(ORB, Accuracy)
 
         EXPECT_GT(matchedRatio, 0.35);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB,  testing::Combine(
@@ -533,8 +570,6 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize
 
 TEST_P(BruteForceMatcher, Match_Single)
 {
-    try
-    {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
     cv::gpu::GpuMat mask;
@@ -558,18 +593,10 @@ TEST_P(BruteForceMatcher, Match_Single)
     }
 
     ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(BruteForceMatcher, Match_Collection)
 {
-    try
-    {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
     cv::gpu::GpuMat d_train(train);
@@ -620,18 +647,10 @@ TEST_P(BruteForceMatcher, Match_Collection)
     }
 
     ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_2_Single)
 {
-    try
-    {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
     const int knn = 2;
@@ -667,18 +686,10 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Single)
     }
 
     ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_3_Single)
 {
-    try
-    {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
     const int knn = 3;
@@ -714,18 +725,10 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Single)
     }
 
     ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
 {
-    try
-    {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
     const int knn = 2;
@@ -784,18 +787,10 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
     }
 
     ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
 {
-    try
-    {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
     const int knn = 3;
@@ -854,18 +849,10 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
     }
 
     ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(BruteForceMatcher, RadiusMatch_Single)
 {
-    try
-    {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
     const float radius = 1.f / countFactor;
@@ -911,18 +898,10 @@ TEST_P(BruteForceMatcher, RadiusMatch_Single)
 
         ASSERT_EQ(0, badCount);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 {
-    try
-    {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
     const int n = 3;
@@ -943,6 +922,20 @@ TEST_P(BruteForceMatcher, RadiusMatch_Collection)
             masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
     }
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector< std::vector<cv::DMatch> > matches;
+            matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector< std::vector<cv::DMatch> > matches;
 
         if (useMask)
@@ -984,11 +977,6 @@ TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 
         ASSERT_EQ(0, badCount);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(

modules/gpu/test/test_filters.cpp

@@ -88,8 +88,6 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use
 
 TEST_P(Blur, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat dst = createMat(size, type, useRoi);
@@ -99,12 +97,6 @@ TEST_P(Blur, Accuracy)
     cv::blur(src, dst_gold, ksize, anchor);
 
     EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
@@ -158,8 +150,6 @@ TEST_P(Sobel, Accuracy)
     if (dx == 0 && dy == 0)
         return;
 
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat dst = createMat(size, type, useRoi);
@@ -169,12 +159,6 @@ TEST_P(Sobel, Accuracy)
     cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
 
     EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
@@ -229,8 +213,6 @@ TEST_P(Scharr, Accuracy)
     if (dx + dy != 1)
         return;
 
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat dst = createMat(size, type, useRoi);
@@ -240,12 +222,6 @@ TEST_P(Scharr, Accuracy)
     cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
 
     EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
@@ -294,8 +270,6 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels,
 
 TEST_P(GaussianBlur, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
     double sigma1 = randomDouble(0.1, 1.0);
     double sigma2 = randomDouble(0.1, 1.0);
@@ -322,12 +296,6 @@ TEST_P(GaussianBlur, Accuracy)
 
         EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, GaussianBlur, testing::Combine(
@@ -381,8 +349,6 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi
 
 TEST_P(Laplacian, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat dst = createMat(size, type, useRoi);
@@ -392,12 +358,6 @@ TEST_P(Laplacian, Accuracy)
     cv::Laplacian(src, dst_gold, -1, ksize.width);
 
     EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine(
@@ -436,8 +396,6 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration
 
 TEST_P(Erode, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
     cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
@@ -450,12 +408,6 @@ TEST_P(Erode, Accuracy)
     cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
 
     EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Erode, testing::Combine(
@@ -493,8 +445,6 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio
 
 TEST_P(Dilate, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
     cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
@@ -507,12 +457,6 @@ TEST_P(Dilate, Accuracy)
     cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
 
     EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Dilate, testing::Combine(
@@ -555,8 +499,6 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor
 
 TEST_P(MorphEx, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
     cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
@@ -569,12 +511,6 @@ TEST_P(MorphEx, Accuracy)
     cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
 
     EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, MorphEx, testing::Combine(
@@ -617,8 +553,6 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor,
 
 TEST_P(Filter2D, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
     cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
 
@@ -629,12 +563,6 @@ TEST_P(Filter2D, Accuracy)
     cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
 
     EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(

modules/gpu/test/test_global_motion.cpp

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

modules/gpu/test/test_gpumat.cpp

@@ -69,26 +69,16 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(SetTo, Zero)
 {
-    try
-    {
     cv::Scalar zero = cv::Scalar::all(0);
 
     cv::gpu::GpuMat mat = createMat(size, type, useRoi);
     mat.setTo(zero);
 
     EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SetTo, SameVal)
 {
-    try
-    {
     cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
 
     if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
@@ -110,18 +100,10 @@ TEST_P(SetTo, SameVal)
 
         EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SetTo, DifferentVal)
 {
-    try
-    {
     cv::Scalar val = randomScalar(0.0, 255.0);
 
     if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
@@ -143,18 +125,10 @@ TEST_P(SetTo, DifferentVal)
 
         EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SetTo, Masked)
 {
-    try
-    {
     cv::Scalar val = randomScalar(0.0, 255.0);
     cv::Mat mat_gold = randomMat(size, type);
     cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
@@ -180,12 +154,6 @@ TEST_P(SetTo, Masked)
 
         EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GpuMat, SetTo, testing::Combine(
@@ -218,8 +186,6 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(CopyTo, WithOutMask)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat d_src = loadMat(src, useRoi);
@@ -227,18 +193,10 @@ TEST_P(CopyTo, WithOutMask)
     d_src.copyTo(dst);
 
     EXPECT_MAT_NEAR(src, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(CopyTo, Masked)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
     cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
@@ -266,12 +224,6 @@ TEST_P(CopyTo, Masked)
 
         EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GpuMat, CopyTo, testing::Combine(
@@ -305,8 +257,6 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us
 
 TEST_P(ConvertTo, WithOutScaling)
 {
-    try
-    {
     cv::Mat src = randomMat(size, depth1);
 
     if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
@@ -333,18 +283,10 @@ TEST_P(ConvertTo, WithOutScaling)
 
         EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(ConvertTo, WithScaling)
 {
-    try
-    {
     cv::Mat src = randomMat(size, depth1);
     double a = randomDouble(0.0, 1.0);
     double b = randomDouble(-10.0, 10.0);
@@ -373,12 +315,6 @@ TEST_P(ConvertTo, WithScaling)
 
         EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GpuMat, ConvertTo, testing::Combine(
@@ -402,8 +338,6 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(EnsureSizeIsEnough, BufferReuse)
 {
-    try
-    {
     cv::gpu::GpuMat buffer(100, 100, CV_8U);
     cv::gpu::GpuMat old = buffer;
 
@@ -420,12 +354,6 @@ TEST_P(EnsureSizeIsEnough, BufferReuse)
     EXPECT_EQ(30, buffer.cols);
     EXPECT_EQ(CV_8UC1, buffer.type());
     EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);

modules/gpu/test/test_hough.cpp

@@ -81,8 +81,6 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(HoughLines, Accuracy)
 {
-    try
-    {
     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
     const cv::Size size = GET_PARAM(1);
@@ -90,7 +88,7 @@ TEST_P(HoughLines, Accuracy)
 
     const float rho = 1.0f;
     const float theta = (float) (1.5 * CV_PI / 180.0);
-        const int threshold = 100;
+    onst int threshold = 100;
 
     cv::Mat src(size, CV_8UC1);
     generateLines(src);
@@ -105,12 +103,6 @@ TEST_P(HoughLines, Accuracy)
     drawLines(dst, lines);
 
     ASSERT_MAT_NEAR(src, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughLines, testing::Combine(
@@ -134,8 +126,6 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(HoughCircles, Accuracy)
 {
-    try
-    {
     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
     const cv::Size size = GET_PARAM(1);
@@ -184,12 +174,6 @@ TEST_P(HoughCircles, Accuracy)
 
         ASSERT_TRUE(found);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughCircles, testing::Combine(
@@ -206,8 +190,6 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi)
 
 TEST_P(GeneralizedHough, POSITION)
 {
-    try
-    {
     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
     const bool useRoi = GET_PARAM(1);
@@ -263,12 +245,6 @@ TEST_P(GeneralizedHough, POSITION)
 
         ASSERT_TRUE(found);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, GeneralizedHough, testing::Combine(

modules/gpu/test/test_imgproc.cpp

@@ -66,8 +66,6 @@ PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Integral, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, CV_8UC1);
 
     cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
@@ -77,12 +75,6 @@ TEST_P(Integral, Accuracy)
     cv::integral(src, dst_gold, CV_32S);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine(
@@ -107,8 +99,6 @@ struct HistEven : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(HistEven, Accuracy)
 {
-    try
-    {
     cv::Mat img = readImage("stereobm/aloe-L.png");
     ASSERT_FALSE(img.empty());
 
@@ -135,12 +125,6 @@ TEST_P(HistEven, Accuracy)
     hist_gold.convertTo(hist_gold, CV_32S);
 
     EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);
@@ -180,8 +164,6 @@ PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(CalcHist, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, CV_8UC1);
 
     cv::gpu::GpuMat hist;
@@ -191,12 +173,6 @@ TEST_P(CalcHist, Accuracy)
     calcHistGold(src, hist_gold);
 
     EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine(
@@ -222,8 +198,6 @@ PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(EqualizeHist, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, CV_8UC1);
 
     cv::gpu::GpuMat dst;
@@ -233,12 +207,6 @@ TEST_P(EqualizeHist, Accuracy)
     cv::equalizeHist(src, dst_gold);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine(
@@ -264,8 +232,6 @@ PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(ColumnSum, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, CV_32FC1);
 
     cv::gpu::GpuMat d_dst;
@@ -289,12 +255,6 @@ TEST_P(ColumnSum, Accuracy)
             ASSERT_NEAR(res, gold, 1e-5);
         }
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ColumnSum, testing::Combine(
@@ -327,8 +287,6 @@ PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi)
 
 TEST_P(Canny, Accuracy)
 {
-    try
-    {
     cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
@@ -357,12 +315,6 @@ TEST_P(Canny, Accuracy)
 
         EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine(
@@ -399,8 +351,6 @@ struct MeanShift : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(MeanShift, Filtering)
 {
-    try
-    {
     cv::Mat img_template;
     if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
         img_template = readImage("meanshift/con_result.png");
@@ -419,18 +369,10 @@ TEST_P(MeanShift, Filtering)
     cv::cvtColor(dst, result, CV_BGRA2BGR);
 
     EXPECT_MAT_NEAR(img_template, result, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(MeanShift, Proc)
 {
-    try
-    {
     cv::FileStorage fs;
     if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
         fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
@@ -453,12 +395,6 @@ TEST_P(MeanShift, Proc)
 
     EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
     EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShift, ALL_DEVICES);
@@ -484,8 +420,6 @@ PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize)
 
 TEST_P(MeanShiftSegmentation, Regression)
 {
-    try
-    {
     cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
     ASSERT_FALSE(img.empty());
 
@@ -505,12 +439,6 @@ TEST_P(MeanShiftSegmentation, Regression)
     cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
 
     EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(
@@ -564,8 +492,6 @@ PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Blend, Accuracy)
 {
-    try
-    {
     int depth = CV_MAT_DEPTH(type);
 
     cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
@@ -583,12 +509,6 @@ TEST_P(Blend, Accuracy)
         blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
 
     EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(
@@ -662,8 +582,6 @@ PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
 
 TEST_P(Convolve, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
     cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
 
@@ -674,12 +592,6 @@ TEST_P(Convolve, Accuracy)
     convolveDFT(src, kernel, dst_gold, ccorr);
 
     EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
@@ -718,8 +630,6 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Ch
 
 TEST_P(MatchTemplate8U, Accuracy)
 {
-    try
-    {
     cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
     cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
 
@@ -730,12 +640,6 @@ TEST_P(MatchTemplate8U, Accuracy)
     cv::matchTemplate(image, templ, dst_gold, method);
 
     EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, testing::Combine(
@@ -772,8 +676,6 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, C
 
 TEST_P(MatchTemplate32F, Regression)
 {
-    try
-    {
     cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
     cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
 
@@ -784,12 +686,6 @@ TEST_P(MatchTemplate32F, Regression)
     cv::matchTemplate(image, templ, dst_gold, method);
 
     EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate32F, testing::Combine(
@@ -818,8 +714,6 @@ PARAM_TEST_CASE(MatchTemplateBlackSource, cv::gpu::DeviceInfo, TemplateMethod)
 
 TEST_P(MatchTemplateBlackSource, Accuracy)
 {
-    try
-    {
     cv::Mat image = readImage("matchtemplate/black.png");
     ASSERT_FALSE(image.empty());
 
@@ -838,12 +732,6 @@ TEST_P(MatchTemplateBlackSource, Accuracy)
     cv::Point maxLocGold = cv::Point(284, 12);
 
     ASSERT_EQ(maxLocGold, maxLoc);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine(
@@ -871,8 +759,6 @@ PARAM_TEST_CASE(MatchTemplate_CCOEF_NORMED, cv::gpu::DeviceInfo, std::pair<std::
 
 TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
 {
-    try
-    {
     cv::Mat image = readImage(imageName);
     ASSERT_FALSE(image.empty());
 
@@ -899,12 +785,6 @@ TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
     ASSERT_EQ(maxLocGold, maxLoc);
     ASSERT_LE(maxVal, 1.0);
     ASSERT_GE(minVal, -1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CCOEF_NORMED, testing::Combine(
@@ -928,8 +808,6 @@ struct MatchTemplate_CanFindBigTemplate : testing::TestWithParam<cv::gpu::Device
 
 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
 {
-    try
-    {
     cv::Mat scene = readImage("matchtemplate/scene.png");
     ASSERT_FALSE(scene.empty());
 
@@ -949,18 +827,10 @@ TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
     ASSERT_LT(minVal, 1e-3);
     ASSERT_EQ(344, minLoc.x);
     ASSERT_EQ(0, minLoc.y);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
 {
-    try
-    {
     cv::Mat scene = readImage("matchtemplate/scene.png");
     ASSERT_FALSE(scene.empty());
 
@@ -979,12 +849,6 @@ TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
     ASSERT_GE(minVal, 0);
     ASSERT_EQ(344, minLoc.x);
     ASSERT_EQ(0, minLoc.y);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CanFindBigTemplate, ALL_DEVICES);
@@ -1017,8 +881,6 @@ PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
 
 TEST_P(MulSpectrums, Simple)
 {
-    try
-    {
     cv::gpu::GpuMat c;
     cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
 
@@ -1026,18 +888,10 @@ TEST_P(MulSpectrums, Simple)
     cv::mulSpectrums(a, b, c_gold, flag, false);
 
     EXPECT_MAT_NEAR(c_gold, c, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(MulSpectrums, Scaled)
 {
-    try
-    {
     float scale = 1.f / size.area();
 
     cv::gpu::GpuMat c;
@@ -1048,12 +902,6 @@ TEST_P(MulSpectrums, Scaled)
     c_gold.convertTo(c_gold, c_gold.type(), scale);
 
     EXPECT_MAT_NEAR(c_gold, c, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MulSpectrums, testing::Combine(
@@ -1102,8 +950,6 @@ void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplac
 
 TEST_P(Dft, C2C)
 {
-    try
-    {
     int cols = randomInt(2, 100);
     int rows = randomInt(2, 100);
 
@@ -1125,12 +971,6 @@ TEST_P(Dft, C2C)
         testC2C("size 1 2", 1, 2, 0, inplace);
         testC2C("size 2 1", 2, 1, 0, inplace);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
@@ -1171,8 +1011,6 @@ void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
 
 TEST_P(Dft, R2CThenC2R)
 {
-    try
-    {
     int cols = randomInt(2, 100);
     int rows = randomInt(2, 100);
 
@@ -1191,12 +1029,6 @@ TEST_P(Dft, R2CThenC2R)
     testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
     testR2CThenC2R("single row", cols, 1, true);
     testR2CThenC2R("single row 1", cols + 1, 1, true);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Dft, ALL_DEVICES);
@@ -1229,8 +1061,6 @@ PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, BlockSiz
 
 TEST_P(CornerHarris, Accuracy)
 {
-    try
-    {
     cv::Mat src = readImageType("stereobm/aloe-L.png", type);
     ASSERT_FALSE(src.empty());
 
@@ -1243,12 +1073,6 @@ TEST_P(CornerHarris, Accuracy)
     cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(
@@ -1283,8 +1107,6 @@ PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, BorderType, BlockS
 
 TEST_P(CornerMinEigen, Accuracy)
 {
-    try
-    {
     cv::Mat src = readImageType("stereobm/aloe-L.png", type);
     ASSERT_FALSE(src.empty());
 
@@ -1295,12 +1117,6 @@ TEST_P(CornerMinEigen, Accuracy)
     cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(

modules/gpu/test/test_labeling.cpp

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

modules/gpu/test/test_nvidia.cpp

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

modules/gpu/test/test_objdetect.cpp

@@ -175,20 +175,19 @@ struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
     }
 };
 
-TEST_P(HOG, Detect)
+// desabled while resize does not fixed
+TEST_P(HOG, DISABLED_Detect)
 {
-    try
-    {
     cv::Mat img_rgb = readImage("hog/road.png");
     ASSERT_FALSE(img_rgb.empty());
 
-    #ifdef DUMP
+#ifdef DUMP
     f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
     ASSERT_TRUE(f.is_open());
-    #else
+#else
     f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
     ASSERT_TRUE(f.is_open());
-    #endif
+#endif
 
     // Test on color image
     cv::Mat img;
@@ -200,18 +199,10 @@ TEST_P(HOG, Detect)
     testDetect(img);
 
     f.close();
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(HOG, GetDescriptors)
 {
-    try
-    {
     // Load image (e.g. train data, composed from windows)
     cv::Mat img_rgb = readImage("hog/train_data.png");
     ASSERT_FALSE(img_rgb.empty());
@@ -292,12 +283,6 @@ TEST_P(HOG, GetDescriptors)
     cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
     computeBlockHistograms(cv::gpu::GpuMat(img));
     compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
@@ -320,8 +305,6 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::Device
 
 TEST_P(CalTech, HOG)
 {
-    try
-    {
     cv::gpu::GpuMat d_img(img);
     cv::Mat markedImage(img.clone());
 
@@ -332,7 +315,7 @@ TEST_P(CalTech, HOG)
     std::vector<cv::Rect> found_locations;
     d_hog.detectMultiScale(d_img, found_locations);
 
-    #if defined (LOG_CASCADE_STATISTIC)
+#if defined (LOG_CASCADE_STATISTIC)
     for (int i = 0; i < (int)found_locations.size(); i++)
     {
         cv::Rect r = found_locations[i];
@@ -342,13 +325,7 @@ TEST_P(CalTech, HOG)
     }
 
     cv::imshow("Res", markedImage); cv::waitKey();
-    #endif
+#endif
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(detect, CalTech, testing::Combine(ALL_DEVICES,
@@ -375,17 +352,9 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::gpu::DeviceInfo, int)
 
 TEST_P(LBP_Read_classifier, Accuracy)
 {
-    try
-    {
     cv::gpu::CascadeClassifier_GPU classifier;
     std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
     ASSERT_TRUE(classifier.load(classifierXmlPath));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_Read_classifier,
@@ -405,8 +374,6 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int)
 
 TEST_P(LBP_classify, Accuracy)
 {
-    try
-    {
     std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
     std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
 
@@ -434,7 +401,7 @@ TEST_P(LBP_classify, Accuracy)
     cv::gpu::GpuMat tested(grey);
     int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
 
-    #if defined (LOG_CASCADE_STATISTIC)
+#if defined (LOG_CASCADE_STATISTIC)
     cv::Mat downloaded(gpu_rects);
     const cv::Rect* faces = downloaded.ptr<cv::Rect>();
     for (int i = 0; i < count; i++)
@@ -444,18 +411,12 @@ TEST_P(LBP_classify, Accuracy)
         std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
         cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
     }
-    #endif
+#endif
 
-    #if defined (LOG_CASCADE_STATISTIC)
+#if defined (LOG_CASCADE_STATISTIC)
     cv::imshow("Res", markedImage); cv::waitKey();
-    #endif
+#endif
     (void)count;
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,

modules/gpu/test/test_opengl.cpp

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

modules/gpu/test/test_pyramids.cpp

@@ -66,8 +66,6 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(PyrDown, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
@@ -77,12 +75,6 @@ TEST_P(PyrDown, Accuracy)
     cv::pyrDown(src, dst_gold);
 
     EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine(
@@ -114,8 +106,6 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(PyrUp, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
@@ -125,12 +115,6 @@ TEST_P(PyrUp, Accuracy)
     cv::pyrUp(src, dst_gold);
 
     EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine(

modules/gpu/test/test_remap.cpp

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

modules/gpu/test/test_resize.cpp

@@ -138,8 +138,6 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol
 
 TEST_P(Resize, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
@@ -149,12 +147,6 @@ TEST_P(Resize, Accuracy)
     resizeGold(src, dst_gold, coeff, coeff, interpolation);
 
     EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
@@ -192,8 +184,6 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double
 // downscaling only: used for classifiers
 TEST_P(ResizeSameAsHost, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
 
     cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
@@ -203,12 +193,6 @@ TEST_P(ResizeSameAsHost, Accuracy)
     cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
 
     EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
@@ -242,8 +226,6 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation)
 
 TEST_P(ResizeNPP, Accuracy)
 {
-    try
-    {
     cv::Mat src = readImageType("stereobp/aloe-L.png", type);
     ASSERT_FALSE(src.empty());
 
@@ -254,12 +236,6 @@ TEST_P(ResizeNPP, Accuracy)
     resizeGold(src, dst_gold, coeff, coeff, interpolation);
 
     EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeNPP, testing::Combine(

modules/gpu/test/test_softcascade.cpp

@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include <test_precomp.hpp>
 #include <time.h>
 
 #ifdef HAVE_CUDA
@@ -158,8 +158,6 @@ GPU_TEST_P(SCascadeTestRoi, detect,
         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 5)))
 {
-    try
-    {
     cv::gpu::setDevice(GET_PARAM(0).deviceID());
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
     ASSERT_FALSE(coloredCpu.empty());
@@ -204,18 +202,11 @@ GPU_TEST_P(SCascadeTestRoi, detect,
     }
 
     SHOW(result);
-    }
+
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST(SCascadeTest, readCascade)
 {
-    try
-    {
     std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
     cv::gpu::SCascade cascade;
 
@@ -223,12 +214,6 @@ TEST(SCascadeTest, readCascade)
     ASSERT_TRUE(fs.isOpened());
 
     ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
@@ -236,8 +221,6 @@ GPU_TEST_P(SCascadeTestAll, detect,
         ALL_DEVICES
         )
 {
-    try
-    {
     cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SCascade cascade;
@@ -262,21 +245,13 @@ GPU_TEST_P(SCascadeTestAll, detect,
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
     int a = *(detections.ptr<int>(0));
-        ASSERT_EQ(a, 2448);
+    ASSERT_EQ(a ,2448);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
         ALL_DEVICES
         )
 {
-    try
-    {
     cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SCascade cascade;
@@ -309,21 +284,13 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
     cv::Mat detections(objectBoxes);
     int a = *(detections.ptr<int>(0));
 
-        ASSERT_EQ(a, 1024);
+    ASSERT_EQ( a ,1024);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 GPU_TEST_P(SCascadeTestAll, detectStream,
         ALL_DEVICES
         )
 {
-    try
-    {
     cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SCascade cascade;
@@ -351,13 +318,7 @@ GPU_TEST_P(SCascadeTestAll, detectStream,
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
     int a = *(detections.ptr<int>(0));
-        ASSERT_EQ(a, 2448);
+    ASSERT_EQ(a ,2448);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 

modules/gpu/test/test_threshold.cpp

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

modules/gpu/test/test_video.cpp

@@ -65,8 +65,6 @@ struct BroxOpticalFlow : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(BroxOpticalFlow, Regression)
 {
-    try
-    {
     cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
     ASSERT_FALSE(frame0.empty());
 
@@ -80,7 +78,7 @@ TEST_P(BroxOpticalFlow, Regression)
     cv::gpu::GpuMat v;
     brox(loadMat(frame0), loadMat(frame1), u, v);
 
-    #ifndef DUMP
+#ifndef DUMP
     std::string fname(cvtest::TS::ptr()->get_data_path());
     if (devInfo.majorVersion() >= 2)
         fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
@@ -106,7 +104,7 @@ TEST_P(BroxOpticalFlow, Regression)
 
     EXPECT_MAT_NEAR(u_gold, u, 0);
     EXPECT_MAT_NEAR(v_gold, v, 0);
-    #else
+#else
     std::string fname(cvtest::TS::ptr()->get_data_path());
     if (devInfo.majorVersion() >= 2)
         fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
@@ -126,13 +124,8 @@ TEST_P(BroxOpticalFlow, Regression)
 
     for (int i = 0; i < v.rows; ++i)
         f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
-    #endif
+
-    }
+#endif
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
@@ -158,8 +151,6 @@ PARAM_TEST_CASE(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
 
 TEST_P(GoodFeaturesToTrack, Accuracy)
 {
-    try
-    {
     cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
 
@@ -168,6 +159,20 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
 
     cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
 
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            cv::gpu::GpuMat d_pts;
+            detector(loadMat(image), d_pts);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         cv::gpu::GpuMat d_pts;
         detector(loadMat(image), d_pts);
 
@@ -196,17 +201,10 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
 
         ASSERT_LE(bad_ratio, 0.01);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(GoodFeaturesToTrack, EmptyCorners)
 {
-    try
-    {
     int maxCorners = 1000;
     double qualityLevel = 0.01;
 
@@ -218,12 +216,6 @@ TEST_P(GoodFeaturesToTrack, EmptyCorners)
     detector(src, corners);
 
     ASSERT_TRUE( corners.empty() );
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
@@ -251,8 +243,6 @@ PARAM_TEST_CASE(PyrLKOpticalFlow, cv::gpu::DeviceInfo, UseGray)
 
 TEST_P(PyrLKOpticalFlow, Sparse)
 {
-    try
-    {
     cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
     ASSERT_FALSE(frame0.empty());
 
@@ -317,12 +307,6 @@ TEST_P(PyrLKOpticalFlow, Sparse)
     double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
 
     ASSERT_LE(bad_ratio, 0.01);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
@@ -359,8 +343,6 @@ PARAM_TEST_CASE(FarnebackOpticalFlow, cv::gpu::DeviceInfo, PyrScale, PolyN, Farn
 
 TEST_P(FarnebackOpticalFlow, Accuracy)
 {
-    try
-    {
     cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(frame0.empty());
 
@@ -400,12 +382,6 @@ TEST_P(FarnebackOpticalFlow, Accuracy)
 
     EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
     EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
@@ -419,8 +395,6 @@ struct OpticalFlowNan : public BroxOpticalFlow {};
 
 TEST_P(OpticalFlowNan, Regression)
 {
-    try
-    {
     cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
     ASSERT_FALSE(frame0.empty());
     cv::Mat r_frame0, r_frame1;
@@ -442,12 +416,6 @@ TEST_P(OpticalFlowNan, Regression)
     v.download(h_v);
     EXPECT_TRUE(cv::checkRange(h_u));
     EXPECT_TRUE(cv::checkRange(h_v));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 };
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowNan, ALL_DEVICES);
@@ -461,8 +429,6 @@ PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi)
 
 TEST_P(OpticalFlowDual_TVL1, Accuracy)
 {
-    try
-    {
     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
 
@@ -487,12 +453,6 @@ TEST_P(OpticalFlowDual_TVL1, Accuracy)
 
     EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
     EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
@@ -526,8 +486,6 @@ struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(OpticalFlowBM, Accuracy)
 {
-    try
-    {
     cv::gpu::DeviceInfo devInfo = GetParam();
     cv::gpu::setDevice(devInfo.deviceID());
 
@@ -551,12 +509,6 @@ TEST_P(OpticalFlowBM, Accuracy)
 
     EXPECT_MAT_NEAR(velx, d_velx, 0);
     EXPECT_MAT_NEAR(vely, d_vely, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
@@ -634,8 +586,6 @@ struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(FastOpticalFlowBM, Accuracy)
 {
-    try
-    {
     const double MAX_RMSE = 0.6;
 
     int search_window = 15;
@@ -674,12 +624,6 @@ TEST_P(FastOpticalFlowBM, Accuracy)
 
     err = calc_rmse(flowy, cv::Mat(d_flowy));
     EXPECT_LE(err, MAX_RMSE);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
@@ -714,8 +658,6 @@ PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels)
 
 TEST_P(FGDStatModel, Update)
 {
-    try
-    {
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
 
@@ -766,12 +708,6 @@ TEST_P(FGDStatModel, Update)
         ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
         ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FGDStatModel, testing::Combine(
@@ -809,8 +745,6 @@ PARAM_TEST_CASE(MOG, cv::gpu::DeviceInfo, std::string, UseGray, LearningRate, Us
 
 TEST_P(MOG, Update)
 {
-    try
-    {
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
 
@@ -842,12 +776,6 @@ TEST_P(MOG, Update)
 
         ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, MOG, testing::Combine(
@@ -882,8 +810,6 @@ PARAM_TEST_CASE(MOG2, cv::gpu::DeviceInfo, std::string, UseGray, UseRoi)
 
 TEST_P(MOG2, Update)
 {
-    try
-    {
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
 
@@ -919,12 +845,6 @@ TEST_P(MOG2, Update)
 
         ASSERT_LE(norm, 0.09);
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(MOG2, getBackgroundImage)
@@ -932,8 +852,6 @@ TEST_P(MOG2, getBackgroundImage)
     if (useGray)
         return;
 
-    try
-    {
     cv::VideoCapture cap(inputFile);
     ASSERT_TRUE(cap.isOpened());
 
@@ -962,12 +880,6 @@ TEST_P(MOG2, getBackgroundImage)
     mog2_gold.getBackgroundImage(background_gold);
 
     ASSERT_MAT_NEAR(background_gold, background, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
@@ -985,8 +897,6 @@ PARAM_TEST_CASE(VIBE, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(VIBE, Accuracy)
 {
-    try
-    {
     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
     const cv::Size size = GET_PARAM(1);
@@ -1011,12 +921,6 @@ TEST_P(VIBE, Accuracy)
 
     // now fgmask should be entirely foreground
     ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VIBE, testing::Combine(
@@ -1034,8 +938,6 @@ PARAM_TEST_CASE(GMG, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
 
 TEST_P(GMG, Accuracy)
 {
-    try
-    {
     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
     const cv::Size size = GET_PARAM(1);
@@ -1072,12 +974,6 @@ TEST_P(GMG, Accuracy)
 
     // now fgmask should be entirely foreground
     ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
@@ -1113,8 +1009,6 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
 
 TEST_P(VideoWriter, Regression)
 {
-    try
-    {
     const double FPS = 25.0;
 
     cv::VideoCapture reader(inputFile);
@@ -1149,12 +1043,6 @@ TEST_P(VideoWriter, Regression)
         reader >> frame;
         ASSERT_FALSE( frame.empty() );
     }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VideoWriter, testing::Combine(
@@ -1182,8 +1070,6 @@ PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
 
 TEST_P(VideoReader, Regression)
 {
-    try
-    {
     cv::gpu::VideoReader_GPU reader(inputFile);
     ASSERT_TRUE( reader.isOpened() );
 
@@ -1197,12 +1083,6 @@ TEST_P(VideoReader, Regression)
 
     reader.close();
     ASSERT_FALSE( reader.isOpened() );
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(

modules/gpu/test/test_warp_affine.cpp

@@ -76,8 +76,6 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse)
 
 TEST_P(BuildWarpAffineMaps, Accuracy)
 {
-    try
-    {
     cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
     cv::gpu::GpuMat xmap, ymap;
     cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
@@ -96,12 +94,6 @@ TEST_P(BuildWarpAffineMaps, Accuracy)
     cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpAffineMaps, testing::Combine(
@@ -209,8 +201,6 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int
 
 TEST_P(WarpAffine, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
     cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
     int flags = interpolation;
@@ -225,12 +215,6 @@ TEST_P(WarpAffine, Accuracy)
     warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
 
     EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine(
@@ -265,8 +249,6 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat
 
 TEST_P(WarpAffineNPP, Accuracy)
 {
-    try
-    {
     cv::Mat src = readImageType("stereobp/aloe-L.png", type);
     cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
     int flags = interpolation;
@@ -280,12 +262,6 @@ TEST_P(WarpAffineNPP, Accuracy)
     warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
 
     EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine(

modules/gpu/test/test_warp_perspective.cpp

@@ -77,8 +77,6 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse
 
 TEST_P(BuildWarpPerspectiveMaps, Accuracy)
 {
-    try
-    {
     cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
     cv::gpu::GpuMat xmap, ymap;
     cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
@@ -94,12 +92,6 @@ TEST_P(BuildWarpPerspectiveMaps, Accuracy)
     cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpPerspectiveMaps, testing::Combine(
@@ -209,8 +201,6 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse
 
 TEST_P(WarpPerspective, Accuracy)
 {
-    try
-    {
     cv::Mat src = randomMat(size, type);
     cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
     int flags = interpolation;
@@ -225,12 +215,6 @@ TEST_P(WarpPerspective, Accuracy)
     warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
 
     EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine(
@@ -265,8 +249,6 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter
 
 TEST_P(WarpPerspectiveNPP, Accuracy)
 {
-    try
-    {
     cv::Mat src = readImageType("stereobp/aloe-L.png", type);
     cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
     int flags = interpolation;
@@ -280,12 +262,6 @@ TEST_P(WarpPerspectiveNPP, Accuracy)
     warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
 
     EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(