if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_image(image);
- cv::gpu::GpuMat d_lines;
- cv::gpu::HoughLinesBuf d_buf;
+ cv::gpu::GpuMat d_image(image);
+ cv::gpu::GpuMat d_lines;
+ cv::gpu::HoughLinesBuf d_buf;
- cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+ cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
- TEST_CYCLE()
- {
- cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
- }
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
+ cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_mask(mask);
- cv::gpu::GpuMat d_pts;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_mask(mask);
+ cv::gpu::GpuMat d_pts;
- d_detector(d_src, d_pts, d_mask);
+ d_detector(d_src, d_pts, d_mask);
- TEST_CYCLE()
- {
- d_detector(d_src, d_pts, d_mask);
- }
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_detector(d_src, d_pts, d_mask);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
- cv::gpu::GpuMat d_nextPts;
- cv::gpu::GpuMat d_status;
-
- cv::gpu::PyrLKOpticalFlow d_pyrLK;
- d_pyrLK.winSize = winSize;
- d_pyrLK.maxLevel = maxLevel;
- d_pyrLK.iters = criteria.maxCount;
- d_pyrLK.useInitialFlow = false;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
+ cv::gpu::GpuMat d_nextPts;
+ cv::gpu::GpuMat d_status;
- d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+ cv::gpu::PyrLKOpticalFlow d_pyrLK;
+ d_pyrLK.winSize = winSize;
+ d_pyrLK.maxLevel = maxLevel;
+ d_pyrLK.iters = criteria.maxCount;
+ d_pyrLK.useInitialFlow = false;
- TEST_CYCLE()
- {
- d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
- }
- }
- catch (...)
+ d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
- cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
-
- cv::gpu::FarnebackOpticalFlow d_farneback;
- d_farneback.pyrScale = pyrScale;
- d_farneback.numLevels = numLevels;
- d_farneback.winSize = winSize;
- d_farneback.numIters = numIters;
- d_farneback.polyN = polyN;
- d_farneback.polySigma = polySigma;
- d_farneback.flags = flags;
-
- d_farneback(d_src1, d_src2, d_u, d_v);
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
+ cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
+
+ cv::gpu::FarnebackOpticalFlow d_farneback;
+ d_farneback.pyrScale = pyrScale;
+ d_farneback.numLevels = numLevels;
+ d_farneback.winSize = winSize;
+ d_farneback.numIters = numIters;
+ d_farneback.polyN = polyN;
+ d_farneback.polySigma = polySigma;
+ d_farneback.flags = flags;
+
+ d_farneback(d_src1, d_src2, d_u, d_v);
- TEST_CYCLE_N(10)
- {
- d_farneback(d_src1, d_src2, d_u, d_v);
- }
- }
- catch (...)
+ TEST_CYCLE_N(10)
{
- cv::gpu::resetDevice();
- throw;
+ d_farneback(d_src1, d_src2, d_u, d_v);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_velx, d_vely, buf;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_velx, d_vely, buf;
- cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+ cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
- TEST_CYCLE_N(10)
- {
- cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
- }
- }
- catch (...)
+ TEST_CYCLE_N(10)
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_velx, d_vely;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_velx, d_vely;
- cv::gpu::FastOpticalFlowBM fastBM;
+ cv::gpu::FastOpticalFlowBM fastBM;
- fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
+ fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
- TEST_CYCLE_N(10)
- {
- fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
- }
- }
- catch (...)
+ TEST_CYCLE_N(10)
{
- cv::gpu::resetDevice();
- throw;
+ fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
-
- cv::gpu::GpuMat d_imgLeft(imgLeft);
- cv::gpu::GpuMat d_imgRight(imgRight);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
- d_bm(d_imgLeft, d_imgRight, d_dst);
+ cv::gpu::GpuMat d_imgLeft(imgLeft);
+ cv::gpu::GpuMat d_imgRight(imgRight);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- d_bm(d_imgLeft, d_imgRight, d_dst);
- }
+ d_bm(d_imgLeft, d_imgRight, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_bm(d_imgLeft, d_imgRight, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::StereoBeliefPropagation d_bp(ndisp);
+ cv::gpu::StereoBeliefPropagation d_bp(ndisp);
- cv::gpu::GpuMat d_imgLeft(imgLeft);
- cv::gpu::GpuMat d_imgRight(imgRight);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_imgLeft(imgLeft);
+ cv::gpu::GpuMat d_imgRight(imgRight);
+ cv::gpu::GpuMat d_dst;
- d_bp(d_imgLeft, d_imgRight, d_dst);
-
- TEST_CYCLE()
- {
- d_bp(d_imgLeft, d_imgRight, d_dst);
- }
+ d_bp(d_imgLeft, d_imgRight, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_bp(d_imgLeft, d_imgRight, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
+ cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
- cv::gpu::GpuMat d_imgLeft(imgLeft);
- cv::gpu::GpuMat d_imgRight(imgRight);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_imgLeft(imgLeft);
+ cv::gpu::GpuMat d_imgRight(imgRight);
+ cv::gpu::GpuMat d_dst;
- d_csbp(d_imgLeft, d_imgRight, d_dst);
+ d_csbp(d_imgLeft, d_imgRight, d_dst);
- TEST_CYCLE()
- {
- d_csbp(d_imgLeft, d_imgRight, d_dst);
- }
-
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_csbp(d_imgLeft, d_imgRight, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::DisparityBilateralFilter d_filter(ndisp);
+ cv::gpu::DisparityBilateralFilter d_filter(ndisp);
- cv::gpu::GpuMat d_img(img);
- cv::gpu::GpuMat d_disp(disp);
- cv::gpu::GpuMat d_dst;
-
- d_filter(d_disp, d_img, d_dst);
+ cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_disp(disp);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- d_filter(d_disp, d_img, d_dst);
- }
+ d_filter(d_disp, d_img, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_filter(d_disp, d_img, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
- }
+ cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
- }
+ cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+ cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
- TEST_CYCLE()
- {
- cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
- }
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
- }
+ cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::drawColorDisp(d_src, d_dst, 255);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::drawColorDisp(d_src, d_dst, 255);
- }
+ cv::gpu::drawColorDisp(d_src, d_dst, 255);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::drawColorDisp(d_src, d_dst, 255);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- std::vector<cv::gpu::GpuMat> d_src(channels);
- for (int i = 0; i < channels; ++i)
- d_src[i].upload(src[i]);
+ std::vector<cv::gpu::GpuMat> d_src(channels);
+ for (int i = 0; i < channels; ++i)
+ d_src[i].upload(src[i]);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
+ TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-12);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-12);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_src(src);
- std::vector<cv::gpu::GpuMat> d_dst;
+ std::vector<cv::gpu::GpuMat> d_dst;
- TEST_CYCLE() cv::gpu::split(d_src, d_dst);
+ TEST_CYCLE() cv::gpu::split(d_src, d_dst);
- cv::gpu::GpuMat first = d_dst[0];
- GPU_SANITY_CHECK(first, 1e-12);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ cv::gpu::GpuMat first = d_dst[0];
+ GPU_SANITY_CHECK(first, 1e-12);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
+ TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
+ TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
+ TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
+ TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
+ TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::multiply(d_src, s, d_dst);
+ cv::gpu::multiply(d_src, s, d_dst);
- TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
+ TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
+ TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
+ TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
+ TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
+ TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
+ TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
+ TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else FAIL_NO_CPU();
}
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
+ TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else FAIL_NO_CPU();
}
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
+ TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::log(d_src, d_dst);
+ TEST_CYCLE() cv::gpu::log(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
+ TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
+ TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
+ TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
+ TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
+ TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
+ TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
+ TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
+ TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
+ TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
+ TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
+ TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
+ TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
+ TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
+ TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
+ TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
+ TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
+ TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
+ TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
//////////////////////////////////////////////////////////////////////
// GEMM
-#ifdef HAVE_CUBLAS
-
CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T)
#define ALL_GEMM_FLAGS Values(0, CV_GEMM_A_T, CV_GEMM_B_T, CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T, CV_GEMM_A_T | CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T)
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_src3(src3);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_src3(src3);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
+ TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
}
}
-#endif // HAVE_CUBLAS
-
//////////////////////////////////////////////////////////////////////
// Transpose
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
+ TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
+ TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
+ TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
+ TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
+ TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
+ TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
+ TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
TEST_CYCLE() cv::magnitude(src1, src2, dst);
CPU_SANITY_CHECK(dst, 1e-8);
+
}
}
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
+ TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
+ TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
- GPU_SANITY_CHECK(d_dst, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_magnitude;
- cv::gpu::GpuMat d_angle;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_magnitude;
+ cv::gpu::GpuMat d_angle;
- TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
+ TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
+
+ GPU_SANITY_CHECK(d_magnitude, 1e-8);
+ GPU_SANITY_CHECK(d_angle, 1e-8);
- GPU_SANITY_CHECK(d_magnitude, 1e-8);
- GPU_SANITY_CHECK(d_angle, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_magnitude(magnitude);
- cv::gpu::GpuMat d_angle(angle);
- cv::gpu::GpuMat d_x;
- cv::gpu::GpuMat d_y;
+ cv::gpu::GpuMat d_magnitude(magnitude);
+ cv::gpu::GpuMat d_angle(angle);
+ cv::gpu::GpuMat d_x;
+ cv::gpu::GpuMat d_y;
- TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
+ TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
- GPU_SANITY_CHECK(d_x, 1e-8);
- GPU_SANITY_CHECK(d_y, 1e-8);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_x, 1e-8);
+ GPU_SANITY_CHECK(d_y, 1e-8);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+
+ TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
- TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
+ TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
- SANITY_CHECK(dst, 1e-6);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ SANITY_CHECK(dst, 1e-6);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
+ TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
- SANITY_CHECK(dst, 1e-6);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ SANITY_CHECK(dst, 1e-6);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
+ TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
- SANITY_CHECK(minVal);
- SANITY_CHECK(maxVal);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ SANITY_CHECK(minVal);
+ SANITY_CHECK(maxVal);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_valbuf, d_locbuf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_valbuf, d_locbuf;
- TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
+ TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
- GPU_SANITY_CHECK(d_dst, 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ GPU_SANITY_CHECK(d_dst, 1);
}
else
{
cv::Mat src(size, type);
fillRandom(src);
- if (PERF_RUN_GPU())
+ if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
- }
+ cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
- }
+ cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::FastNonLocalMeansDenoising fnlmd;
-
- fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::FastNonLocalMeansDenoising fnlmd;
- TEST_CYCLE()
- {
- fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
- }
+ fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::FastNonLocalMeansDenoising fnlmd;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::FastNonLocalMeansDenoising fnlmd;
- fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
-
- TEST_CYCLE()
- {
- fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
- }
+ fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
CPU_SANITY_CHECK(dst);
}
-}
+}
\ No newline at end of file
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::SURF_GPU d_surf;
-
- cv::gpu::GpuMat d_img(img);
- cv::gpu::GpuMat d_keypoints, d_descriptors;
+ cv::gpu::SURF_GPU d_surf;
- d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+ cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_keypoints, d_descriptors;
- TEST_CYCLE()
- {
- d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
- }
+ d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
- GPU_SANITY_CHECK(d_descriptors, 1e-4);
- GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
}
+
+ GPU_SANITY_CHECK(d_descriptors, 1e-4);
+ GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::FAST_GPU d_fast(20);
+ cv::gpu::FAST_GPU d_fast(20);
- cv::gpu::GpuMat d_img(img);
- cv::gpu::GpuMat d_keypoints;
+ cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_keypoints;
- d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+ d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
- TEST_CYCLE()
- {
- d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
- }
-
- GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
}
+
+ GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::ORB_GPU d_orb(4000);
-
- cv::gpu::GpuMat d_img(img);
- cv::gpu::GpuMat d_keypoints, d_descriptors;
+ cv::gpu::ORB_GPU d_orb(4000);
- d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+ cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_keypoints, d_descriptors;
- TEST_CYCLE()
- {
- d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
- }
+ d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
- GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
- GPU_SANITY_CHECK(d_descriptors);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
}
+
+ GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
+ GPU_SANITY_CHECK(d_descriptors);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::BFMatcher_GPU d_matcher(normType);
-
- cv::gpu::GpuMat d_query(query);
- cv::gpu::GpuMat d_train(train);
- cv::gpu::GpuMat d_trainIdx, d_distance;
+ cv::gpu::BFMatcher_GPU d_matcher(normType);
- d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+ cv::gpu::GpuMat d_query(query);
+ cv::gpu::GpuMat d_train(train);
+ cv::gpu::GpuMat d_trainIdx, d_distance;
- TEST_CYCLE()
- {
- d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
- }
+ d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
- GPU_SANITY_CHECK(d_trainIdx);
- GPU_SANITY_CHECK(d_distance);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
}
+
+ GPU_SANITY_CHECK(d_trainIdx);
+ GPU_SANITY_CHECK(d_distance);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::BFMatcher_GPU d_matcher(normType);
+ cv::gpu::BFMatcher_GPU d_matcher(normType);
- cv::gpu::GpuMat d_query(query);
- cv::gpu::GpuMat d_train(train);
- cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
+ cv::gpu::GpuMat d_query(query);
+ cv::gpu::GpuMat d_train(train);
+ cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
- d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+ d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
- TEST_CYCLE()
- {
- d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
- }
-
- GPU_SANITY_CHECK(d_trainIdx);
- GPU_SANITY_CHECK(d_distance);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
}
+
+ GPU_SANITY_CHECK(d_trainIdx);
+ GPU_SANITY_CHECK(d_distance);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::BFMatcher_GPU d_matcher(normType);
-
- cv::gpu::GpuMat d_query(query);
- cv::gpu::GpuMat d_train(train);
- cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
+ cv::gpu::BFMatcher_GPU d_matcher(normType);
- d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+ cv::gpu::GpuMat d_query(query);
+ cv::gpu::GpuMat d_train(train);
+ cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
- TEST_CYCLE()
- {
- d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
- }
+ d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
- GPU_SANITY_CHECK(d_trainIdx);
- GPU_SANITY_CHECK(d_distance);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
}
+
+ GPU_SANITY_CHECK(d_trainIdx);
+ GPU_SANITY_CHECK(d_distance);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
- }
+ cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_buf;
- cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
-
- TEST_CYCLE()
- {
- cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
- }
+ cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_buf;
-
- cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE()
- {
- cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
- }
+ cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_buf;
-
- cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE()
- {
- cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
- }
+ cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
- }
+ cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_buf;
- cv::gpu::erode(d_src, d_dst, ker, d_buf);
-
- TEST_CYCLE()
- {
- cv::gpu::erode(d_src, d_dst, ker, d_buf);
- }
+ cv::gpu::erode(d_src, d_dst, ker, d_buf);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::erode(d_src, d_dst, ker, d_buf);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_buf;
-
- cv::gpu::dilate(d_src, d_dst, ker, d_buf);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_buf;
- TEST_CYCLE()
- {
- cv::gpu::dilate(d_src, d_dst, ker, d_buf);
- }
+ cv::gpu::dilate(d_src, d_dst, ker, d_buf);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::dilate(d_src, d_dst, ker, d_buf);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_buf1;
- cv::gpu::GpuMat d_buf2;
-
- cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_buf1;
+ cv::gpu::GpuMat d_buf2;
- TEST_CYCLE()
- {
- cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
- }
+ cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::filter2D(d_src, d_dst, -1, kernel);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::filter2D(d_src, d_dst, -1, kernel);
- }
+ cv::gpu::filter2D(d_src, d_dst, -1, kernel);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::filter2D(d_src, d_dst, -1, kernel);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_xmap(xmap);
- cv::gpu::GpuMat d_ymap(ymap);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_xmap(xmap);
+ cv::gpu::GpuMat d_ymap(ymap);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
- }
+ cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
- }
+ cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-
- TEST_CYCLE()
- {
- cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
- }
+ cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
-
- TEST_CYCLE()
- {
- cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
- }
+ cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
-
- TEST_CYCLE()
- {
- cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
- }
+ cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
- }
+ cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
-
- TEST_CYCLE()
- {
- cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
- }
+ cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_buf;
- cv::gpu::integralBuffered(d_src, d_dst, d_buf);
-
- TEST_CYCLE()
- {
- cv::gpu::integralBuffered(d_src, d_dst, d_buf);
- }
+ cv::gpu::integralBuffered(d_src, d_dst, d_buf);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::integralBuffered(d_src, d_dst, d_buf);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::sqrIntegral(d_src, d_dst);
-
- TEST_CYCLE()
- {
- cv::gpu::sqrIntegral(d_src, d_dst);
- }
+ cv::gpu::sqrIntegral(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::sqrIntegral(d_src, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_hist;
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_hist;
+ cv::gpu::GpuMat d_buf;
- cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
-
- TEST_CYCLE()
- {
- cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
- }
+ cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
- GPU_SANITY_CHECK(d_hist);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
}
+
+ GPU_SANITY_CHECK(d_hist);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_hist[4];
- cv::gpu::GpuMat d_buf, d_hist0;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_hist[4];
+ cv::gpu::GpuMat d_buf, d_hist0;
- cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
-
- TEST_CYCLE()
- {
- cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
- }
+ cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
- GPU_SANITY_CHECK(d_hist0);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
}
+
+ GPU_SANITY_CHECK(d_hist0);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_hist;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_hist;
- cv::gpu::calcHist(d_src, d_hist);
-
- TEST_CYCLE()
- {
- cv::gpu::calcHist(d_src, d_hist);
- }
+ cv::gpu::calcHist(d_src, d_hist);
- GPU_SANITY_CHECK(d_hist);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::calcHist(d_src, d_hist);
}
+
+ GPU_SANITY_CHECK(d_hist);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_hist;
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_hist;
+ cv::gpu::GpuMat d_buf;
- cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
-
- TEST_CYCLE()
- {
- cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
- }
+ cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
- GPU_SANITY_CHECK(d_hist);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
}
+
+ GPU_SANITY_CHECK(d_hist);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::columnSum(d_src, d_dst);
-
- TEST_CYCLE()
- {
- cv::gpu::columnSum(d_src, d_dst);
- }
+ cv::gpu::columnSum(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::columnSum(d_src, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_image(image);
- cv::gpu::GpuMat d_dst;
- cv::gpu::CannyBuf d_buf;
+ cv::gpu::GpuMat d_image(image);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::CannyBuf d_buf;
- cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
+ cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
- TEST_CYCLE()
- {
- cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
- }
-
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(rgba);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(rgba);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
-
- TEST_CYCLE()
- {
- cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
- }
+ cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(rgba);
- cv::gpu::GpuMat d_dstr;
- cv::gpu::GpuMat d_dstsp;
+ cv::gpu::GpuMat d_src(rgba);
+ cv::gpu::GpuMat d_dstr;
+ cv::gpu::GpuMat d_dstsp;
- cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
-
- TEST_CYCLE()
- {
- cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
- }
+ cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
- GPU_SANITY_CHECK(d_dstr);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
}
+
+ GPU_SANITY_CHECK(d_dstr);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(rgba);
+ cv::gpu::GpuMat d_src(rgba);
- cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
-
- TEST_CYCLE()
- {
- cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
- }
+ cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
- GPU_SANITY_CHECK(dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
}
+
+ GPU_SANITY_CHECK(dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_img1(img1);
- cv::gpu::GpuMat d_img2(img2);
- cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
- cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_img1(img1);
+ cv::gpu::GpuMat d_img2(img2);
+ cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
+ cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));
+ cv::gpu::GpuMat d_dst;
- cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
-
- TEST_CYCLE()
- {
- cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
- }
+ cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
- d_image.upload(image);
+ cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
+ d_image.upload(image);
- cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
- d_templ.upload(templ);
+ cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
+ d_templ.upload(templ);
- cv::gpu::GpuMat d_dst;
- cv::gpu::ConvolveBuf d_buf;
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::ConvolveBuf d_buf;
- cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
-
- TEST_CYCLE()
- {
- cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
- }
+ cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_image(image);
- cv::gpu::GpuMat d_templ(templ);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_image(image);
+ cv::gpu::GpuMat d_templ(templ);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-
- TEST_CYCLE()
- {
- cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
- }
+ cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_image(image);
- cv::gpu::GpuMat d_templ(templ);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_image(image);
+ cv::gpu::GpuMat d_templ(templ);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
+ cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
- TEST_CYCLE()
- {
- cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
- }
-
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_a(a);
- cv::gpu::GpuMat d_b(b);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_a(a);
+ cv::gpu::GpuMat d_b(b);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
-
- TEST_CYCLE()
- {
- cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
- }
+ cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src1(src1);
- cv::gpu::GpuMat d_src2(src2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src1(src1);
+ cv::gpu::GpuMat d_src2(src2);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
-
- TEST_CYCLE()
- {
- cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
- }
+ cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::dft(d_src, d_dst, size, flag);
-
- TEST_CYCLE()
- {
- cv::gpu::dft(d_src, d_dst, size, flag);
- }
+ cv::gpu::dft(d_src, d_dst, size, flag);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::dft(d_src, d_dst, size, flag);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_img(img);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_Dx;
- cv::gpu::GpuMat d_Dy;
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_Dx;
+ cv::gpu::GpuMat d_Dy;
+ cv::gpu::GpuMat d_buf;
- cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
-
- TEST_CYCLE()
- {
- cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
- }
+ cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_img(img);
- cv::gpu::GpuMat d_dst;
- cv::gpu::GpuMat d_Dx;
- cv::gpu::GpuMat d_Dy;
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_Dx;
+ cv::gpu::GpuMat d_Dy;
+ cv::gpu::GpuMat d_buf;
- cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
-
- TEST_CYCLE()
- {
- cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
- }
+ cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_map_x;
- cv::gpu::GpuMat d_map_y;
+ cv::gpu::GpuMat d_map_x;
+ cv::gpu::GpuMat d_map_y;
- cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
-
- TEST_CYCLE()
- {
- cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
- }
+ cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
- GPU_SANITY_CHECK(d_map_x);
- GPU_SANITY_CHECK(d_map_y);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
}
+
+ GPU_SANITY_CHECK(d_map_x);
+ GPU_SANITY_CHECK(d_map_y);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_map_x;
- cv::gpu::GpuMat d_map_y;
+ cv::gpu::GpuMat d_map_x;
+ cv::gpu::GpuMat d_map_y;
- cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-
- TEST_CYCLE()
- {
- cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
- }
+ cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
- GPU_SANITY_CHECK(d_map_x);
- GPU_SANITY_CHECK(d_map_y);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
}
+
+ GPU_SANITY_CHECK(d_map_x);
+ GPU_SANITY_CHECK(d_map_y);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_map_x;
- cv::gpu::GpuMat d_map_y;
-
- cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
+ cv::gpu::GpuMat d_map_x;
+ cv::gpu::GpuMat d_map_y;
- TEST_CYCLE()
- {
- cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
- }
+ cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
- GPU_SANITY_CHECK(d_map_x);
- GPU_SANITY_CHECK(d_map_y);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
}
+
+ GPU_SANITY_CHECK(d_map_x);
+ GPU_SANITY_CHECK(d_map_y);
+
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
+ cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
- TEST_CYCLE()
- {
- cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
- }
-
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::pyrDown(d_src, d_dst);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::pyrDown(d_src, d_dst);
- }
+ cv::gpu::pyrDown(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::pyrDown(d_src, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::pyrUp(d_src, d_dst);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::pyrUp(d_src, d_dst);
- }
+ cv::gpu::pyrUp(d_src, d_dst);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::pyrUp(d_src, d_dst);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
- }
+ cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_src(src);
- cv::gpu::swapChannels(d_src, dstOrder);
+ cv::gpu::swapChannels(d_src, dstOrder);
- TEST_CYCLE()
- {
- cv::gpu::swapChannels(d_src, dstOrder);
- }
-
- GPU_SANITY_CHECK(d_src);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::swapChannels(d_src, dstOrder);
}
+
+ GPU_SANITY_CHECK(d_src);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_img1(img1);
- cv::gpu::GpuMat d_img2(img2);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_img1(img1);
+ cv::gpu::GpuMat d_img2(img2);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
+ cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
- TEST_CYCLE()
- {
- cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
- }
-
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_src(src);
- cv::gpu::ImagePyramid d_pyr;
+ cv::gpu::ImagePyramid d_pyr;
- d_pyr.build(d_src, 5);
+ d_pyr.build(d_src, 5);
- TEST_CYCLE()
- {
- d_pyr.build(d_src, 5);
- }
-
- GPU_SANITY_CHECK(d_src);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_pyr.build(d_src, 5);
}
+
+ GPU_SANITY_CHECK(d_src);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- cv::gpu::ImagePyramid d_pyr(d_src, 3);
+ cv::gpu::ImagePyramid d_pyr(d_src, 3);
- d_pyr.getLayer(d_dst, dstSize);
+ d_pyr.getLayer(d_dst, dstSize);
- TEST_CYCLE()
- {
- d_pyr.getLayer(d_dst, dstSize);
- }
-
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_pyr.getLayer(d_dst, dstSize);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_lines;
- cv::gpu::HoughLinesBuf d_buf;
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_lines;
+ cv::gpu::HoughLinesBuf d_buf;
- cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
+ cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
- TEST_CYCLE()
- {
- cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
- }
-
- cv::Mat h_lines(d_lines);
- cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
- cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
- std::sort(begin, end, Vec2fComparator());
- SANITY_CHECK(h_lines);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
}
+
+ cv::Mat h_lines(d_lines);
+ cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
+ cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
+ std::sort(begin, end, Vec2fComparator());
+ SANITY_CHECK(h_lines);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_mask(mask);
- cv::gpu::GpuMat d_lines;
- cv::gpu::HoughLinesBuf d_buf;
-
- cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+ cv::gpu::GpuMat d_mask(mask);
+ cv::gpu::GpuMat d_lines;
+ cv::gpu::HoughLinesBuf d_buf;
- TEST_CYCLE()
- {
- cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
- }
+ cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
- cv::Mat h_lines(d_lines);
- cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
- cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
- std::sort(begin, end, Vec4iComparator());
- SANITY_CHECK(h_lines);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
}
+
+ cv::Mat h_lines(d_lines);
+ cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
+ cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
+ std::sort(begin, end, Vec4iComparator());
+ SANITY_CHECK(h_lines);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_circles;
- cv::gpu::HoughCirclesBuf d_buf;
-
- cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_circles;
+ cv::gpu::HoughCirclesBuf d_buf;
- TEST_CYCLE()
- {
- cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
- }
+ cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
- cv::Mat h_circles(d_circles);
- cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
- cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
- std::sort(begin, end, Vec3fComparator());
- SANITY_CHECK(h_circles);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
}
+
+ cv::Mat h_circles(d_circles);
+ cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
+ cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
+ std::sort(begin, end, Vec3fComparator());
+ SANITY_CHECK(h_circles);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_edges(edges);
- cv::gpu::GpuMat d_dx(dx);
- cv::gpu::GpuMat d_dy(dy);
- cv::gpu::GpuMat d_position;
+ cv::gpu::GpuMat d_edges(edges);
+ cv::gpu::GpuMat d_dx(dx);
+ cv::gpu::GpuMat d_dy(dy);
+ cv::gpu::GpuMat d_position;
- cv::Ptr<cv::gpu::GeneralizedHough_GPU> d_hough = cv::gpu::GeneralizedHough_GPU::create(method);
- if (method & cv::GHT_ROTATION)
- {
- d_hough->set("maxAngle", 90.0);
- d_hough->set("angleStep", 2.0);
- }
-
- d_hough->setTemplate(cv::gpu::GpuMat(templ));
+ cv::Ptr<cv::gpu::GeneralizedHough_GPU> d_hough = cv::gpu::GeneralizedHough_GPU::create(method);
+ if (method & cv::GHT_ROTATION)
+ {
+ d_hough->set("maxAngle", 90.0);
+ d_hough->set("angleStep", 2.0);
+ }
- d_hough->detect(d_edges, d_dx, d_dy, d_position);
+ d_hough->setTemplate(cv::gpu::GpuMat(templ));
- TEST_CYCLE()
- {
- d_hough->detect(d_edges, d_dx, d_dy, d_position);
- }
+ d_hough->detect(d_edges, d_dx, d_dy, d_position);
- GPU_SANITY_CHECK(d_position);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_hough->detect(d_edges, d_dx, d_dy, d_position);
}
+
+ GPU_SANITY_CHECK(d_position);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat mask;
- mask.create(image.rows, image.cols, CV_8UC1);
-
- cv::gpu::GpuMat components;
- components.create(image.rows, image.cols, CV_32SC1);
+ cv::gpu::GpuMat mask;
+ mask.create(image.rows, image.cols, CV_8UC1);
- cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+ cv::gpu::GpuMat components;
+ components.create(image.rows, image.cols, CV_32SC1);
- ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+ cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
- TEST_CYCLE()
- {
- cv::gpu::labelComponents(mask, components);
- }
+ ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
- GPU_SANITY_CHECK(components);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::labelComponents(mask, components);
}
+
+ GPU_SANITY_CHECK(components);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(size, type);
-
- d_src.setTo(val);
+ cv::gpu::GpuMat d_src(size, type);
- TEST_CYCLE()
- {
- d_src.setTo(val);
- }
+ d_src.setTo(val);
- GPU_SANITY_CHECK(d_src);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_src.setTo(val);
}
+
+ GPU_SANITY_CHECK(d_src);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_mask(mask);
-
- d_src.setTo(val, d_mask);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_mask(mask);
- TEST_CYCLE()
- {
- d_src.setTo(val, d_mask);
- }
+ d_src.setTo(val, d_mask);
- GPU_SANITY_CHECK(d_src);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_src.setTo(val, d_mask);
}
+
+ GPU_SANITY_CHECK(d_src);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_mask(mask);
- cv::gpu::GpuMat d_dst;
-
- d_src.copyTo(d_dst, d_mask);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_mask(mask);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- d_src.copyTo(d_dst, d_mask);
- }
+ d_src.copyTo(d_dst, d_mask);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_src.copyTo(d_dst, d_mask);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_src(src);
- cv::gpu::GpuMat d_dst;
-
- d_src.convertTo(d_dst, depth2, 0.5, 1.0);
+ cv::gpu::GpuMat d_src(src);
+ cv::gpu::GpuMat d_dst;
- TEST_CYCLE()
- {
- d_src.convertTo(d_dst, depth2, 0.5, 1.0);
- }
+ d_src.convertTo(d_dst, depth2, 0.5, 1.0);
- GPU_SANITY_CHECK(d_dst);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_src.convertTo(d_dst, depth2, 0.5, 1.0);
}
+
+ GPU_SANITY_CHECK(d_dst);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_img(img);
- cv::gpu::HOGDescriptor d_hog;
- d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+ cv::gpu::HOGDescriptor d_hog;
+ d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
- d_hog.detectMultiScale(d_img, found_locations);
+ d_hog.detectMultiScale(d_img, found_locations);
- TEST_CYCLE()
- {
- d_hog.detectMultiScale(d_img, found_locations);
- }
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_hog.detectMultiScale(d_img, found_locations);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_img(img);
- cv::gpu::HOGDescriptor d_hog;
- d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+ cv::gpu::HOGDescriptor d_hog;
+ d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
- d_hog.detectMultiScale(d_img, found_locations);
+ d_hog.detectMultiScale(d_img, found_locations);
- TEST_CYCLE()
- {
- d_hog.detectMultiScale(d_img, found_locations);
- }
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_hog.detectMultiScale(d_img, found_locations);
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::CascadeClassifier_GPU d_cascade;
- ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
-
- cv::gpu::GpuMat d_img(img);
- cv::gpu::GpuMat d_objects_buffer;
+ cv::gpu::CascadeClassifier_GPU d_cascade;
+ ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
- d_cascade.detectMultiScale(d_img, d_objects_buffer);
+ cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_objects_buffer;
- TEST_CYCLE()
- {
- d_cascade.detectMultiScale(d_img, d_objects_buffer);
- }
+ d_cascade.detectMultiScale(d_img, d_objects_buffer);
- GPU_SANITY_CHECK(d_objects_buffer);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_cascade.detectMultiScale(d_img, d_objects_buffer);
}
+
+ GPU_SANITY_CHECK(d_objects_buffer);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::CascadeClassifier_GPU d_cascade;
- ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
+ cv::gpu::CascadeClassifier_GPU d_cascade;
+ ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
- cv::gpu::GpuMat d_img(img);
- cv::gpu::GpuMat d_gpu_rects;
+ cv::gpu::GpuMat d_img(img);
+ cv::gpu::GpuMat d_gpu_rects;
- d_cascade.detectMultiScale(d_img, d_gpu_rects);
-
- TEST_CYCLE()
- {
- d_cascade.detectMultiScale(d_img, d_gpu_rects);
- }
+ d_cascade.detectMultiScale(d_img, d_gpu_rects);
- GPU_SANITY_CHECK(d_gpu_rects);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_cascade.detectMultiScale(d_img, d_gpu_rects);
}
+
+ GPU_SANITY_CHECK(d_gpu_rects);
}
else
{
}
}
-} // namespace
+} // namespace
\ No newline at end of file
RUN_GPU(SCascadeTest, detect)
{
- try
- {
- cv::Mat cpu = readImage (GET_PARAM(1));
- ASSERT_FALSE(cpu.empty());
- cv::gpu::GpuMat colored(cpu);
+ cv::Mat cpu = readImage (GET_PARAM(1));
+ ASSERT_FALSE(cpu.empty());
+ cv::gpu::GpuMat colored(cpu);
- cv::gpu::SCascade cascade;
+ cv::gpu::SCascade cascade;
- cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
- rois.setTo(1);
+ cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+ rois.setTo(1);
- cascade.detect(colored, rois, objectBoxes);
+ cascade.detect(colored, rois, objectBoxes);
- TEST_CYCLE()
- {
- cascade.detect(colored, rois, objectBoxes);
- }
-
- SANITY_CHECK(sortDetections(objectBoxes));
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cascade.detect(colored, rois, objectBoxes);
}
+
+ SANITY_CHECK(sortDetections(objectBoxes));
}
NO_CPU(SCascadeTest, detect)
RUN_GPU(SCascadeTestRoi, detectInRoi)
{
- try
- {
- cv::Mat cpu = readImage (GET_PARAM(1));
- ASSERT_FALSE(cpu.empty());
- cv::gpu::GpuMat colored(cpu);
+ cv::Mat cpu = readImage (GET_PARAM(1));
+ ASSERT_FALSE(cpu.empty());
+ cv::gpu::GpuMat colored(cpu);
- cv::gpu::SCascade cascade;
+ cv::gpu::SCascade cascade;
- cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
- rois.setTo(0);
+ cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
+ rois.setTo(0);
- int nroi = GET_PARAM(2);
- cv::RNG rng;
- for (int i = 0; i < nroi; ++i)
- {
- cv::Rect r = getFromTable(rng(10));
- cv::gpu::GpuMat sub(rois, r);
- sub.setTo(1);
- }
-
- cascade.detect(colored, rois, objectBoxes);
+ int nroi = GET_PARAM(2);
+ cv::RNG rng;
+ for (int i = 0; i < nroi; ++i)
+ {
+ cv::Rect r = getFromTable(rng(10));
+ cv::gpu::GpuMat sub(rois, r);
+ sub.setTo(1);
+ }
- TEST_CYCLE()
- {
- cascade.detect(colored, rois, objectBoxes);
- }
+ cascade.detect(colored, rois, objectBoxes);
- SANITY_CHECK(sortDetections(objectBoxes));
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cascade.detect(colored, rois, objectBoxes);
}
+
+ SANITY_CHECK(sortDetections(objectBoxes));
}
NO_CPU(SCascadeTestRoi, detectInRoi)
RUN_GPU(SCascadeTestRoi, detectEachRoi)
{
- try
- {
- cv::Mat cpu = readImage (GET_PARAM(1));
- ASSERT_FALSE(cpu.empty());
- cv::gpu::GpuMat colored(cpu);
-
- cv::gpu::SCascade cascade;
+ cv::Mat cpu = readImage (GET_PARAM(1));
+ ASSERT_FALSE(cpu.empty());
+ cv::gpu::GpuMat colored(cpu);
- cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::gpu::SCascade cascade;
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
- rois.setTo(0);
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- int idx = GET_PARAM(2);
- cv::Rect r = getFromTable(idx);
- cv::gpu::GpuMat sub(rois, r);
- sub.setTo(1);
+ cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
+ rois.setTo(0);
- cascade.detect(colored, rois, objectBoxes);
+ int idx = GET_PARAM(2);
+ cv::Rect r = getFromTable(idx);
+ cv::gpu::GpuMat sub(rois, r);
+ sub.setTo(1);
- TEST_CYCLE()
- {
- cascade.detect(colored, rois, objectBoxes);
- }
+ cascade.detect(colored, rois, objectBoxes);
- SANITY_CHECK(sortDetections(objectBoxes));
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cascade.detect(colored, rois, objectBoxes);
}
+
+ SANITY_CHECK(sortDetections(objectBoxes));
}
NO_CPU(SCascadeTestRoi, detectEachRoi)
RUN_GPU(SCascadeTest, detectOnIntegral)
{
- try
- {
- cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
- ASSERT_TRUE(fsi.isOpened());
-
- cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
- for (int i = 0; i < 10; ++i)
- {
- cv::Mat channel;
- fsi[std::string("channel") + itoa(i)] >> channel;
- cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
- gchannel.upload(channel);
- }
+ cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+ ASSERT_TRUE(fsi.isOpened());
- cv::gpu::SCascade cascade;
+ cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
+ for (int i = 0; i < 10; ++i)
+ {
+ cv::Mat channel;
+ fsi[std::string("channel") + itoa(i)] >> channel;
+ cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+ gchannel.upload(channel);
+ }
- cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::gpu::SCascade cascade;
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
- rois.setTo(1);
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- cascade.detect(hogluv, rois, objectBoxes);
+ cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
+ rois.setTo(1);
- TEST_CYCLE()
- {
- cascade.detect(hogluv, rois, objectBoxes);
- }
+ cascade.detect(hogluv, rois, objectBoxes);
- SANITY_CHECK(sortDetections(objectBoxes));
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cascade.detect(hogluv, rois, objectBoxes);
}
+
+ SANITY_CHECK(sortDetections(objectBoxes));
}
NO_CPU(SCascadeTest, detectOnIntegral)
RUN_GPU(SCascadeTest, detectStream)
{
- try
- {
- cv::Mat cpu = readImage (GET_PARAM(1));
- ASSERT_FALSE(cpu.empty());
- cv::gpu::GpuMat colored(cpu);
+ cv::Mat cpu = readImage (GET_PARAM(1));
+ ASSERT_FALSE(cpu.empty());
+ cv::gpu::GpuMat colored(cpu);
- cv::gpu::SCascade cascade;
+ cv::gpu::SCascade cascade;
- cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
- rois.setTo(1);
+ cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+ rois.setTo(1);
- cv::gpu::Stream s;
+ cv::gpu::Stream s;
- cascade.detect(colored, rois, objectBoxes, s);
+ cascade.detect(colored, rois, objectBoxes, s);
- TEST_CYCLE()
- {
- cascade.detect(colored, rois, objectBoxes, s);
- }
-
- #ifdef HAVE_CUDA
- cudaDeviceSynchronize();
- #endif
-
- SANITY_CHECK(sortDetections(objectBoxes));
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cascade.detect(colored, rois, objectBoxes, s);
}
+
+#ifdef HAVE_CUDA
+ cudaDeviceSynchronize();
+#endif
+
+ SANITY_CHECK(sortDetections(objectBoxes));
}
NO_CPU(SCascadeTest, detectStream)
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_u;
- cv::gpu::GpuMat d_v;
-
- cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
- 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_u;
+ cv::gpu::GpuMat d_v;
- d_flow(d_frame0, d_frame1, d_u, d_v);
+ cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+ 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
- TEST_CYCLE()
- {
- d_flow(d_frame0, d_frame1, d_u, d_v);
- }
+ d_flow(d_frame0, d_frame1, d_u, d_v);
- GPU_SANITY_CHECK(d_u);
- GPU_SANITY_CHECK(d_v);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_flow(d_frame0, d_frame1, d_u, d_v);
}
+
+ GPU_SANITY_CHECK(d_u);
+ GPU_SANITY_CHECK(d_v);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_fu, d_fv;
- cv::gpu::GpuMat d_bu, d_bv;
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_fu, d_fv;
+ cv::gpu::GpuMat d_bu, d_bv;
- cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
- 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+ cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+ 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
- d_flow(d_frame0, d_frame1, d_fu, d_fv);
- d_flow(d_frame1, d_frame0, d_bu, d_bv);
+ d_flow(d_frame0, d_frame1, d_fu, d_fv);
+ d_flow(d_frame1, d_frame0, d_bu, d_bv);
- cv::gpu::GpuMat d_newFrame;
- cv::gpu::GpuMat d_buf;
+ cv::gpu::GpuMat d_newFrame;
+ cv::gpu::GpuMat d_buf;
- cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
+ cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
- TEST_CYCLE()
- {
- cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
- }
-
- GPU_SANITY_CHECK(d_fu);
- GPU_SANITY_CHECK(d_fv);
- GPU_SANITY_CHECK(d_bu);
- GPU_SANITY_CHECK(d_bv);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
}
+
+ GPU_SANITY_CHECK(d_fu);
+ GPU_SANITY_CHECK(d_fv);
+ GPU_SANITY_CHECK(d_bu);
+ GPU_SANITY_CHECK(d_bv);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_u;
- cv::gpu::GpuMat d_v;
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_u;
+ cv::gpu::GpuMat d_v;
- cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
- 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+ cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+ 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
- d_flow(d_frame0, d_frame1, d_u, d_v);
+ d_flow(d_frame0, d_frame1, d_u, d_v);
- cv::gpu::GpuMat d_vertex, d_colors;
+ cv::gpu::GpuMat d_vertex, d_colors;
- cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
+ cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
- TEST_CYCLE()
- {
- cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
- }
-
- GPU_SANITY_CHECK(d_vertex);
- GPU_SANITY_CHECK(d_colors);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
}
+
+ GPU_SANITY_CHECK(d_vertex);
+ GPU_SANITY_CHECK(d_colors);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
-
- cv::gpu::GpuMat d_image(image);
- cv::gpu::GpuMat d_pts;
+ cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
- d_detector(d_image, d_pts);
+ cv::gpu::GpuMat d_image(image);
+ cv::gpu::GpuMat d_pts;
- TEST_CYCLE()
- {
- d_detector(d_image, d_pts);
- }
+ d_detector(d_image, d_pts);
- GPU_SANITY_CHECK(d_pts);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_detector(d_image, d_pts);
}
+
+ GPU_SANITY_CHECK(d_pts);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
+ cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
- cv::gpu::PyrLKOpticalFlow d_pyrLK;
- d_pyrLK.winSize = cv::Size(winSize, winSize);
- d_pyrLK.maxLevel = levels - 1;
- d_pyrLK.iters = iters;
+ cv::gpu::PyrLKOpticalFlow d_pyrLK;
+ d_pyrLK.winSize = cv::Size(winSize, winSize);
+ d_pyrLK.maxLevel = levels - 1;
+ d_pyrLK.iters = iters;
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_nextPts;
- cv::gpu::GpuMat d_status;
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_nextPts;
+ cv::gpu::GpuMat d_status;
- d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
-
- TEST_CYCLE()
- {
- d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
- }
+ d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
- GPU_SANITY_CHECK(d_status);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
}
+
+ GPU_SANITY_CHECK(d_status);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_u;
- cv::gpu::GpuMat d_v;
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_u;
+ cv::gpu::GpuMat d_v;
- cv::gpu::PyrLKOpticalFlow d_pyrLK;
- d_pyrLK.winSize = cv::Size(winSize, winSize);
- d_pyrLK.maxLevel = levels - 1;
- d_pyrLK.iters = iters;
-
- d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
+ cv::gpu::PyrLKOpticalFlow d_pyrLK;
+ d_pyrLK.winSize = cv::Size(winSize, winSize);
+ d_pyrLK.maxLevel = levels - 1;
+ d_pyrLK.iters = iters;
- TEST_CYCLE()
- {
- d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
- }
+ d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
- GPU_SANITY_CHECK(d_u);
- GPU_SANITY_CHECK(d_v);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
}
+
+ GPU_SANITY_CHECK(d_u);
+ GPU_SANITY_CHECK(d_v);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_u;
- cv::gpu::GpuMat d_v;
-
- cv::gpu::FarnebackOpticalFlow d_farneback;
- d_farneback.numLevels = numLevels;
- d_farneback.pyrScale = pyrScale;
- d_farneback.winSize = winSize;
- d_farneback.numIters = numIters;
- d_farneback.polyN = polyN;
- d_farneback.polySigma = polySigma;
- d_farneback.flags = flags;
-
- d_farneback(d_frame0, d_frame1, d_u, d_v);
-
- TEST_CYCLE()
- {
- d_farneback(d_frame0, d_frame1, d_u, d_v);
- }
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_u;
+ cv::gpu::GpuMat d_v;
+
+ cv::gpu::FarnebackOpticalFlow d_farneback;
+ d_farneback.numLevels = numLevels;
+ d_farneback.pyrScale = pyrScale;
+ d_farneback.winSize = winSize;
+ d_farneback.numIters = numIters;
+ d_farneback.polyN = polyN;
+ d_farneback.polySigma = polySigma;
+ d_farneback.flags = flags;
+
+ d_farneback(d_frame0, d_frame1, d_u, d_v);
- GPU_SANITY_CHECK(d_u);
- GPU_SANITY_CHECK(d_v);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_farneback(d_frame0, d_frame1, d_u, d_v);
}
+
+ GPU_SANITY_CHECK(d_u);
+ GPU_SANITY_CHECK(d_v);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_flowx;
- cv::gpu::GpuMat d_flowy;
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_flowx;
+ cv::gpu::GpuMat d_flowy;
- cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+ cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
- d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
+ d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
- TEST_CYCLE()
- {
- d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
- }
-
- GPU_SANITY_CHECK(d_flowx);
- GPU_SANITY_CHECK(d_flowy);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
}
+
+ GPU_SANITY_CHECK(d_flowx);
+ GPU_SANITY_CHECK(d_flowy);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_velx, d_vely, buf;
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_velx, d_vely, buf;
- cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-
- TEST_CYCLE()
- {
- cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
- }
+ cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
- GPU_SANITY_CHECK(d_velx);
- GPU_SANITY_CHECK(d_vely);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
}
+
+ GPU_SANITY_CHECK(d_velx);
+ GPU_SANITY_CHECK(d_vely);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame0(frame0);
- cv::gpu::GpuMat d_frame1(frame1);
- cv::gpu::GpuMat d_velx, d_vely;
+ cv::gpu::GpuMat d_frame0(frame0);
+ cv::gpu::GpuMat d_frame1(frame1);
+ cv::gpu::GpuMat d_velx, d_vely;
- cv::gpu::FastOpticalFlowBM fastBM;
+ cv::gpu::FastOpticalFlowBM fastBM;
- fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
+ fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
- TEST_CYCLE()
- {
- fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
- }
-
- GPU_SANITY_CHECK(d_velx);
- GPU_SANITY_CHECK(d_vely);
- }
- catch (...)
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
}
+
+ GPU_SANITY_CHECK(d_velx);
+ GPU_SANITY_CHECK(d_vely);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame(frame);
+ cv::gpu::GpuMat d_frame(frame);
- cv::gpu::FGDStatModel d_model(4);
- d_model.create(d_frame);
+ cv::gpu::FGDStatModel d_model(4);
+ d_model.create(d_frame);
- for (int i = 0; i < 10; ++i)
- {
- cap >> frame;
- ASSERT_FALSE(frame.empty());
+ for (int i = 0; i < 10; ++i)
+ {
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- d_frame.upload(frame);
+ d_frame.upload(frame);
- startTimer(); next();
- d_model.update(d_frame);
- stopTimer();
- }
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ startTimer(); next();
+ d_model.update(d_frame);
+ stopTimer();
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame(frame);
- cv::gpu::MOG_GPU d_mog;
- cv::gpu::GpuMat d_foreground;
+ cv::gpu::GpuMat d_frame(frame);
+ cv::gpu::MOG_GPU d_mog;
+ cv::gpu::GpuMat d_foreground;
- d_mog(d_frame, d_foreground, learningRate);
+ d_mog(d_frame, d_foreground, learningRate);
+
+ for (int i = 0; i < 10; ++i)
+ {
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- for (int i = 0; i < 10; ++i)
+ if (cn != 3)
{
- cap >> frame;
- ASSERT_FALSE(frame.empty());
-
- if (cn != 3)
- {
- cv::Mat temp;
- if (cn == 1)
- cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
- else
- cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
- cv::swap(temp, frame);
- }
-
- d_frame.upload(frame);
-
- startTimer(); next();
- d_mog(d_frame, d_foreground, learningRate);
- stopTimer();
+ cv::Mat temp;
+ if (cn == 1)
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+ else
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+ cv::swap(temp, frame);
}
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+
+ d_frame.upload(frame);
+
+ startTimer(); next();
+ d_mog(d_frame, d_foreground, learningRate);
+ stopTimer();
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame(frame);
- cv::gpu::MOG2_GPU d_mog2;
- cv::gpu::GpuMat d_foreground;
+ cv::gpu::GpuMat d_frame(frame);
+ cv::gpu::MOG2_GPU d_mog2;
+ cv::gpu::GpuMat d_foreground;
- d_mog2(d_frame, d_foreground);
+ d_mog2(d_frame, d_foreground);
- for (int i = 0; i < 10; ++i)
+ for (int i = 0; i < 10; ++i)
+ {
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
+
+ if (cn != 3)
{
- cap >> frame;
- ASSERT_FALSE(frame.empty());
-
- if (cn != 3)
- {
- cv::Mat temp;
- if (cn == 1)
- cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
- else
- cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
- cv::swap(temp, frame);
- }
-
- d_frame.upload(frame);
-
- startTimer(); next();
- d_mog2(d_frame, d_foreground);
- stopTimer();
+ cv::Mat temp;
+ if (cn == 1)
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+ else
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+ cv::swap(temp, frame);
}
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+
+ d_frame.upload(frame);
+
+ startTimer(); next();
+ d_mog2(d_frame, d_foreground);
+ stopTimer();
}
}
else
if (PERF_RUN_GPU())
{
- try
+ cv::gpu::GpuMat d_frame;
+ cv::gpu::MOG2_GPU d_mog2;
+ cv::gpu::GpuMat d_foreground;
+
+ for (int i = 0; i < 10; ++i)
{
- cv::gpu::GpuMat d_frame;
- cv::gpu::MOG2_GPU d_mog2;
- cv::gpu::GpuMat d_foreground;
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- for (int i = 0; i < 10; ++i)
+ if (cn != 3)
{
- cap >> frame;
- ASSERT_FALSE(frame.empty());
-
- if (cn != 3)
- {
- cv::Mat temp;
- if (cn == 1)
- cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
- else
- cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
- cv::swap(temp, frame);
- }
-
- d_frame.upload(frame);
-
- d_mog2(d_frame, d_foreground);
+ cv::Mat temp;
+ if (cn == 1)
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+ else
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+ cv::swap(temp, frame);
}
- cv::gpu::GpuMat d_background;
- d_mog2.getBackgroundImage(d_background);
-
- TEST_CYCLE()
- {
- d_mog2.getBackgroundImage(d_background);
- }
+ d_frame.upload(frame);
- GPU_SANITY_CHECK(d_background);
+ d_mog2(d_frame, d_foreground);
}
- catch (...)
+
+ cv::gpu::GpuMat d_background;
+ d_mog2.getBackgroundImage(d_background);
+
+ TEST_CYCLE()
{
- cv::gpu::resetDevice();
- throw;
+ d_mog2.getBackgroundImage(d_background);
}
+
+ GPU_SANITY_CHECK(d_background);
}
else
{
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame(frame);
- cv::gpu::VIBE_GPU d_vibe;
- cv::gpu::GpuMat d_foreground;
+ cv::gpu::GpuMat d_frame(frame);
+ cv::gpu::VIBE_GPU d_vibe;
+ cv::gpu::GpuMat d_foreground;
- d_vibe(d_frame, d_foreground);
+ d_vibe(d_frame, d_foreground);
+
+ for (int i = 0; i < 10; ++i)
+ {
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- for (int i = 0; i < 10; ++i)
+ if (cn != 3)
{
- cap >> frame;
- ASSERT_FALSE(frame.empty());
-
- if (cn != 3)
- {
- cv::Mat temp;
- if (cn == 1)
- cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
- else
- cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
- cv::swap(temp, frame);
- }
-
- d_frame.upload(frame);
-
- startTimer(); next();
- d_vibe(d_frame, d_foreground);
- stopTimer();
+ cv::Mat temp;
+ if (cn == 1)
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+ else
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+ cv::swap(temp, frame);
}
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+
+ d_frame.upload(frame);
+
+ startTimer(); next();
+ d_vibe(d_frame, d_foreground);
+ stopTimer();
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::GpuMat d_frame(frame);
- cv::gpu::GpuMat d_fgmask;
+ cv::gpu::GpuMat d_frame(frame);
+ cv::gpu::GpuMat d_fgmask;
- cv::gpu::GMG_GPU d_gmg;
- d_gmg.maxFeatures = maxFeatures;
+ cv::gpu::GMG_GPU d_gmg;
+ d_gmg.maxFeatures = maxFeatures;
- d_gmg(d_frame, d_fgmask);
+ d_gmg(d_frame, d_fgmask);
- for (int i = 0; i < 150; ++i)
+ for (int i = 0; i < 150; ++i)
+ {
+ cap >> frame;
+ if (frame.empty())
{
+ cap.release();
+ cap.open(inputFile);
cap >> frame;
- if (frame.empty())
- {
- cap.release();
- cap.open(inputFile);
- cap >> frame;
- }
-
- if (cn != 3)
- {
- cv::Mat temp;
- if (cn == 1)
- cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
- else
- cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
- cv::swap(temp, frame);
- }
-
- d_frame.upload(frame);
-
- startTimer(); next();
- d_gmg(d_frame, d_fgmask);
- stopTimer();
}
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+
+ if (cn != 3)
+ {
+ cv::Mat temp;
+ if (cn == 1)
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+ else
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+ cv::swap(temp, frame);
+ }
+
+ d_frame.upload(frame);
+
+ startTimer(); next();
+ d_gmg(d_frame, d_fgmask);
+ stopTimer();
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::VideoWriter_GPU d_writer;
+ cv::gpu::VideoWriter_GPU d_writer;
- cv::gpu::GpuMat d_frame;
+ cv::gpu::GpuMat d_frame;
- for (int i = 0; i < 10; ++i)
- {
- reader >> frame;
- ASSERT_FALSE(frame.empty());
+ for (int i = 0; i < 10; ++i)
+ {
+ reader >> frame;
+ ASSERT_FALSE(frame.empty());
- d_frame.upload(frame);
+ d_frame.upload(frame);
- if (!d_writer.isOpened())
- d_writer.open(outputFile, frame.size(), FPS);
+ if (!d_writer.isOpened())
+ d_writer.open(outputFile, frame.size(), FPS);
- startTimer(); next();
- d_writer.write(d_frame);
- stopTimer();
- }
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ startTimer(); next();
+ d_writer.write(d_frame);
+ stopTimer();
}
}
else
if (PERF_RUN_GPU())
{
- try
- {
- cv::gpu::VideoReader_GPU d_reader(inputFile);
- ASSERT_TRUE( d_reader.isOpened() );
+ cv::gpu::VideoReader_GPU d_reader(inputFile);
+ ASSERT_TRUE( d_reader.isOpened() );
- cv::gpu::GpuMat d_frame;
+ cv::gpu::GpuMat d_frame;
- d_reader.read(d_frame);
+ d_reader.read(d_frame);
- TEST_CYCLE_N(10)
- {
- d_reader.read(d_frame);
- }
-
- GPU_SANITY_CHECK(d_frame);
- }
- catch (...)
+ TEST_CYCLE_N(10)
{
- cv::gpu::resetDevice();
- throw;
+ d_reader.read(d_frame);
}
+
+ GPU_SANITY_CHECK(d_frame);
}
else
{
(void)msg;
}
-}
-
bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
{
path = test_data_path.c_str();
return testListerII.invoke();
}
+}
+
bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
{
path = test_data_path;
return testListerVisualize.invoke();
}
-#endif /* CUDA_DISABLER */
+#endif /* CUDA_DISABLER */
\ No newline at end of file
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);
+ cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+ cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
+ cv::Mat disp_gold = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(left_image.empty());
- ASSERT_FALSE(right_image.empty());
- ASSERT_FALSE(disp_gold.empty());
+ ASSERT_FALSE(left_image.empty());
+ ASSERT_FALSE(right_image.empty());
+ ASSERT_FALSE(disp_gold.empty());
- cv::gpu::StereoBM_GPU bm(0, 128, 19);
- cv::gpu::GpuMat disp;
+ cv::gpu::StereoBM_GPU bm(0, 128, 19);
+ cv::gpu::GpuMat disp;
- bm(loadMat(left_image), loadMat(right_image), disp);
+ bm(loadMat(left_image), loadMat(right_image), disp);
- EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBM, ALL_DEVICES);
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);
+ cv::Mat left_image = readImage("stereobp/aloe-L.png");
+ cv::Mat right_image = readImage("stereobp/aloe-R.png");
+ cv::Mat disp_gold = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(left_image.empty());
- ASSERT_FALSE(right_image.empty());
- ASSERT_FALSE(disp_gold.empty());
+ ASSERT_FALSE(left_image.empty());
+ ASSERT_FALSE(right_image.empty());
+ ASSERT_FALSE(disp_gold.empty());
- cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
- cv::gpu::GpuMat disp;
+ cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
+ cv::gpu::GpuMat disp;
- bp(loadMat(left_image), loadMat(right_image), disp);
+ bp(loadMat(left_image), loadMat(right_image), disp);
- cv::Mat h_disp(disp);
- h_disp.convertTo(h_disp, disp_gold.depth());
+ cv::Mat h_disp(disp);
+ h_disp.convertTo(h_disp, disp_gold.depth());
- EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBeliefPropagation, ALL_DEVICES);
TEST_P(StereoConstantSpaceBP, Regression)
{
- try
- {
- cv::Mat left_image = readImage("csstereobp/aloe-L.png");
- cv::Mat right_image = readImage("csstereobp/aloe-R.png");
+ cv::Mat left_image = readImage("csstereobp/aloe-L.png");
+ cv::Mat right_image = readImage("csstereobp/aloe-R.png");
- cv::Mat disp_gold;
+ cv::Mat disp_gold;
- if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
- disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
- else
- disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
+ if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+ disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+ else
+ disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(left_image.empty());
- ASSERT_FALSE(right_image.empty());
- ASSERT_FALSE(disp_gold.empty());
+ ASSERT_FALSE(left_image.empty());
+ ASSERT_FALSE(right_image.empty());
+ ASSERT_FALSE(disp_gold.empty());
- cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4);
- cv::gpu::GpuMat disp;
+ cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4);
+ cv::gpu::GpuMat disp;
- csbp(loadMat(left_image), loadMat(right_image), disp);
+ csbp(loadMat(left_image), loadMat(right_image), disp);
- cv::Mat h_disp(disp);
- h_disp.convertTo(h_disp, disp_gold.depth());
+ cv::Mat h_disp(disp);
+ h_disp.convertTo(h_disp, disp_gold.depth());
- EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
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);
+ cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
+ cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+ cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
- cv::gpu::GpuMat dst;
- cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst);
- ASSERT_EQ(src.size(), dst.size());
- ASSERT_EQ(src.type(), dst.type());
+ ASSERT_EQ(src.size(), dst.size());
+ ASSERT_EQ(src.type(), dst.type());
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat rot;
- cv::Rodrigues(rvec, rot);
+ cv::Mat rot;
+ cv::Rodrigues(rvec, rot);
- for (int i = 0; i < h_dst.cols; ++i)
- {
- cv::Point3f res = h_dst.at<cv::Point3f>(0, i);
+ for (int i = 0; i < h_dst.cols; ++i)
+ {
+ cv::Point3f res = h_dst.at<cv::Point3f>(0, i);
- cv::Point3f p = src.at<cv::Point3f>(0, i);
- cv::Point3f res_gold(
- rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
- rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
- rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
+ cv::Point3f p = src.at<cv::Point3f>(0, i);
+ cv::Point3f res_gold(
+ rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
+ rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
+ rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
- ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
- }
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
}
}
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);
- cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
- camera_mat.at<float>(0, 1) = 0.f;
- camera_mat.at<float>(1, 0) = 0.f;
- camera_mat.at<float>(2, 0) = 0.f;
- camera_mat.at<float>(2, 1) = 0.f;
-
- cv::gpu::GpuMat dst;
- cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst);
+ cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
+ cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+ cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+ cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
+ camera_mat.at<float>(0, 1) = 0.f;
+ camera_mat.at<float>(1, 0) = 0.f;
+ camera_mat.at<float>(2, 0) = 0.f;
+ camera_mat.at<float>(2, 1) = 0.f;
- ASSERT_EQ(1, dst.rows);
- ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type()));
+ cv::gpu::GpuMat dst;
+ cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst);
- std::vector<cv::Point2f> dst_gold;
- cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
+ ASSERT_EQ(1, dst.rows);
+ ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type()));
- ASSERT_EQ(dst_gold.size(), static_cast<size_t>(dst.cols));
+ std::vector<cv::Point2f> dst_gold;
+ cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
- cv::Mat h_dst(dst);
+ ASSERT_EQ(dst_gold.size(), static_cast<size_t>(dst.cols));
- for (size_t i = 0; i < dst_gold.size(); ++i)
- {
- cv::Point2f res = h_dst.at<cv::Point2f>(0, (int)i);
- cv::Point2f res_gold = dst_gold[i];
+ cv::Mat h_dst(dst);
- ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
- }
- }
- catch (...)
+ for (size_t i = 0; i < dst_gold.size(); ++i)
{
- cv::gpu::resetDevice();
- throw;
+ cv::Point2f res = h_dst.at<cv::Point2f>(0, (int)i);
+ cv::Point2f res_gold = dst_gold[i];
+
+ ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
}
}
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;
- camera_mat.at<float>(1, 0) = 0.f;
- camera_mat.at<float>(2, 0) = 0.f;
- camera_mat.at<float>(2, 1) = 0.f;
-
- std::vector<cv::Point2f> image_vec;
- cv::Mat rvec_gold;
- cv::Mat tvec_gold;
- rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
- tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
- cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
-
- cv::Mat rvec, tvec;
- std::vector<int> inliers;
- cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)image_vec.size(), CV_32FC2, &image_vec[0]),
- camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)),
- rvec, tvec, false, 200, 2.f, 100, &inliers);
-
- ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3);
- ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ 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;
+ camera_mat.at<float>(1, 0) = 0.f;
+ camera_mat.at<float>(2, 0) = 0.f;
+ camera_mat.at<float>(2, 1) = 0.f;
+
+ std::vector<cv::Point2f> image_vec;
+ cv::Mat rvec_gold;
+ cv::Mat tvec_gold;
+ rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+ tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+ cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
+
+ cv::Mat rvec, tvec;
+ std::vector<int> inliers;
+ cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)image_vec.size(), CV_32FC2, &image_vec[0]),
+ camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)),
+ rvec, tvec, false, 200, 2.f, 100, &inliers);
+
+ ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3);
+ ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, SolvePnPRansac, ALL_DEVICES);
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);
+ cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
+ cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
- cv::gpu::GpuMat dst;
- cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
+ cv::gpu::GpuMat dst;
+ cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
- cv::Mat dst_gold;
- cv::reprojectImageTo3D(disp, dst_gold, Q, false);
+ cv::Mat dst_gold;
+ cv::reprojectImageTo3D(disp, dst_gold, Q, false);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(
TEST_P(CvtColor, BGR2RGB)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR2RGBA)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR2BGRA)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGRA2RGB)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGRA2BGR)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGRA2RGBA)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR2GRAY)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, RGB2GRAY)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, GRAY2BGR)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, GRAY2BGRA)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGRA2GRAY)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, RGBA2GRAY)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, BGR2BGR565)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, RGB2BGR565)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5652BGR)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5652RGB)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGRA2BGR565)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, RGBA2BGR565)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5652BGRA)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5652RGBA)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, GRAY2BGR565)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5652GRAY)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR2BGR555)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, RGB2BGR555)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5552BGR)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5552RGB)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGRA2BGR555)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, RGBA2BGR555)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5552BGRA)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5552RGBA)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, GRAY2BGR555)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR5552GRAY)
if (depth != CV_8U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(CvtColor, BGR2XYZ)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, RGB2XYZ)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, BGR2XYZ4)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
}
TEST_P(CvtColor, BGRA2XYZ4)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
}
TEST_P(CvtColor, XYZ2BGR)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, XYZ2RGB)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, XYZ42BGR)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, XYZ42BGRA)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, BGR2YCrCb)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, RGB2YCrCb)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, BGR2YCrCb4)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
}
TEST_P(CvtColor, RGBA2YCrCb4)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
}
TEST_P(CvtColor, YCrCb2BGR)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, YCrCb2RGB)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, YCrCb42RGB)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, YCrCb42RGBA)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, BGR2HSV)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGB2HSV)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGB2HSV4)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGBA2HSV4)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, BGR2HLS)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGB2HLS)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGB2HLS4)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGBA2HLS4)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HSV2BGR)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HSV2RGB)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HSV42BGR)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HSV42BGRA)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HLS2BGR)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HLS2RGB)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HLS42RGB)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HLS42RGBA)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, BGR2HSV_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGB2HSV_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGB2HSV4_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGBA2HSV4_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, BGR2HLS_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGB2HLS_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGB2HLS4_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, RGBA2HLS4_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HSV2BGR_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HSV2RGB_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HSV42RGB_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HSV42RGBA_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HLS2BGR_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HLS2RGB_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HLS42RGB_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, HLS42RGBA_FULL)
if (depth == CV_16U)
return;
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
}
TEST_P(CvtColor, BGR2YUV)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, RGB2YUV)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, YUV2BGR)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, YUV42BGR)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, YUV42BGRA)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
- cv::Mat channels[4];
- cv::split(src, channels);
- channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
- cv::merge(channels, 4, src);
+ cv::Mat channels[4];
+ cv::split(src, channels);
+ channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+ cv::merge(channels, 4, src);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, YUV2RGB)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
TEST_P(CvtColor, BGR2YUV4)
{
- try
- {
- cv::Mat src = img;
+ cv::Mat src = img;
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
- EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
}
TEST_P(CvtColor, RGBA2YUV4)
{
- try
- {
- cv::Mat src;
- cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+ cv::Mat src;
+ cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+
+ cv::Mat h_dst(dst);
+
+ cv::Mat channels[4];
+ cv::split(h_dst, channels);
+ cv::merge(channels, 3, h_dst);
+
+ EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2Lab)
+{
+ if (depth != CV_8U)
+ return;
+
+ try
+ {
+ cv::Mat src = readImage("stereobm/aloe-L.png");
- cv::Mat h_dst(dst);
+ cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
- cv::Mat channels[4];
- cv::split(h_dst, channels);
- cv::merge(channels, 3, h_dst);
+ cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
- EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+ EXPECT_MAT_NEAR(src, dst_bgr, 10);
}
- catch (...)
+ catch (const cv::Exception& e)
{
- cv::gpu::resetDevice();
- throw;
+ (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+ ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+ FAIL();
+#endif
}
}
-#if defined(CUDA_VERSION) && (CUDA_VERSION >= 5000)
- TEST_P(CvtColor, BGR2Lab)
+TEST_P(CvtColor, RGB2Lab)
+{
+ if (depth != CV_8U)
+ return;
+
+ try
{
- if (depth != CV_8U)
- return;
-
- try
- {
- cv::Mat src = readImage("stereobm/aloe-L.png");
-
- cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
-
- cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
-
- EXPECT_MAT_NEAR(src, dst_bgr, 10);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
- }
+ cv::Mat src = readImage("stereobm/aloe-L.png");
+
+ cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
- TEST_P(CvtColor, RGB2Lab)
+ cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
+
+ EXPECT_MAT_NEAR(src, dst_bgr, 10);
+ }
+ catch (const cv::Exception& e)
{
- if (depth != CV_8U)
- return;
-
- try
- {
- cv::Mat src = readImage("stereobm/aloe-L.png");
-
- cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
-
- cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
-
- EXPECT_MAT_NEAR(src, dst_bgr, 10);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+ ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+ FAIL();
+#endif
}
+}
+
+TEST_P(CvtColor, BGR2Luv)
+{
+ if (depth != CV_8U)
+ return;
- TEST_P(CvtColor, BGR2Luv)
+ try
{
- if (depth != CV_8U)
- return;
-
- try
- {
- cv::Mat src = img;
-
- cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
-
- cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
-
- EXPECT_MAT_NEAR(src, dst_rgb, 10);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
- }
+ cv::Mat src = img;
+
+ cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
- TEST_P(CvtColor, RGB2Luv)
+ cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
+
+ EXPECT_MAT_NEAR(src, dst_rgb, 10);
+ }
+ catch (const cv::Exception& e)
{
- if (depth != CV_8U)
- return;
-
- try
- {
- cv::Mat src = img;
-
- cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
-
- cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
-
- EXPECT_MAT_NEAR(src, dst_rgb, 10);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+ ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+ FAIL();
+#endif
}
+}
+
+TEST_P(CvtColor, RGB2Luv)
+{
+ if (depth != CV_8U)
+ return;
- TEST_P(CvtColor, RGBA2mRGBA)
+ try
{
- if (depth != CV_8U)
- return;
-
- try
- {
- cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
-
- cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
-
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ cv::Mat src = img;
+
+ cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
+
+ cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
+
+ EXPECT_MAT_NEAR(src, dst_rgb, 10);
}
+ catch (const cv::Exception& e)
+ {
+ (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+ ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+ FAIL();
#endif
+ }
+}
-TEST_P(CvtColor, BayerBG2BGR)
+TEST_P(CvtColor, RGBA2mRGBA)
{
- if ((depth != CV_8U && depth != CV_16U) || useRoi)
+ if (depth != CV_8U)
return;
try
{
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
+ cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+ cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
- EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+ EXPECT_MAT_NEAR(dst_gold, dst, 1);
}
- catch (...)
+ catch (const cv::Exception& e)
{
- cv::gpu::resetDevice();
- throw;
+ (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+ ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+ FAIL();
+#endif
}
}
+TEST_P(CvtColor, BayerBG2BGR)
+{
+ if ((depth != CV_8U && depth != CV_16U) || useRoi)
+ return;
+
+ cv::Mat src = randomMat(size, depth);
+
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
+
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+
+ EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+}
+
TEST_P(CvtColor, BayerBG2BGR4)
{
if ((depth != CV_8U && depth != CV_16U) || useRoi)
return;
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
- cv::Mat dst4(dst);
- cv::Mat dst3;
- cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+ cv::Mat dst4(dst);
+ cv::Mat dst3;
+ cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
- EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
}
TEST_P(CvtColor, BayerGB2BGR)
if ((depth != CV_8U && depth != CV_16U) || useRoi)
return;
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
- EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
}
TEST_P(CvtColor, BayerGB2BGR4)
if ((depth != CV_8U && depth != CV_16U) || useRoi)
return;
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
- cv::Mat dst4(dst);
- cv::Mat dst3;
- cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+ cv::Mat dst4(dst);
+ cv::Mat dst3;
+ cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
- EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
}
TEST_P(CvtColor, BayerRG2BGR)
if ((depth != CV_8U && depth != CV_16U) || useRoi)
return;
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
- EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
}
TEST_P(CvtColor, BayerRG2BGR4)
if ((depth != CV_8U && depth != CV_16U) || useRoi)
return;
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
- cv::Mat dst4(dst);
- cv::Mat dst3;
- cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+ cv::Mat dst4(dst);
+ cv::Mat dst3;
+ cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
- EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
}
TEST_P(CvtColor, BayerGR2BGR)
if ((depth != CV_8U && depth != CV_16U) || useRoi)
return;
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
- EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
}
TEST_P(CvtColor, BayerGR2BGR4)
if ((depth != CV_8U && depth != CV_16U) || useRoi)
return;
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst;
- cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
- ASSERT_EQ(4, dst.channels());
+ ASSERT_EQ(4, dst.channels());
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
- cv::Mat dst4(dst);
- cv::Mat dst3;
- cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+ cv::Mat dst4(dst);
+ cv::Mat dst3;
+ cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
- EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine(
TEST_P(SwapChannels, Accuracy)
{
- try
- {
- cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
- ASSERT_FALSE(src.empty());
+ cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
+ ASSERT_FALSE(src.empty());
- cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+ cv::gpu::GpuMat d_src = loadMat(src, useRoi);
- const int dstOrder[] = {2, 1, 0, 3};
- cv::gpu::swapChannels(d_src, dstOrder);
+ const int dstOrder[] = {2, 1, 0, 3};
+ cv::gpu::swapChannels(d_src, dstOrder);
- cv::Mat dst_gold;
- cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+ cv::Mat dst_gold;
+ cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
- EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, SwapChannels, testing::Combine(
TEST_P(CopyMakeBorder, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Scalar val = randomScalar(0, 255);
+ cv::Mat src = randomMat(size, type);
+ cv::Scalar val = randomScalar(0, 255);
- cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi);
- cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val);
+ cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi);
+ cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val);
- cv::Mat dst_gold;
- cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
+ cv::Mat dst_gold;
+ cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
TEST_P(Merge, Accuracy)
{
- try
- {
- std::vector<cv::Mat> src;
- src.reserve(channels);
- for (int i = 0; i < channels; ++i)
- src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
+ std::vector<cv::Mat> src;
+ src.reserve(channels);
+ for (int i = 0; i < channels; ++i)
+ src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
- std::vector<cv::gpu::GpuMat> d_src;
- for (int i = 0; i < channels; ++i)
- d_src.push_back(loadMat(src[i], useRoi));
+ std::vector<cv::gpu::GpuMat> d_src;
+ for (int i = 0; i < channels; ++i)
+ d_src.push_back(loadMat(src[i], useRoi));
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::merge(d_src, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
- }
- else
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
cv::gpu::GpuMat dst;
cv::gpu::merge(d_src, dst);
-
- cv::Mat dst_gold;
- cv::merge(src, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst;
+ cv::gpu::merge(d_src, dst);
+
+ cv::Mat dst_gold;
+ cv::merge(src, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(Split, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- std::vector<cv::gpu::GpuMat> dst;
- cv::gpu::split(loadMat(src), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ std::vector<cv::gpu::GpuMat> dst;
+ cv::gpu::split(loadMat(src), dst);
}
- else
+ catch (const cv::Exception& e)
{
- std::vector<cv::gpu::GpuMat> dst;
- cv::gpu::split(loadMat(src, useRoi), dst);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+ }
+ }
+ else
+ {
+ std::vector<cv::gpu::GpuMat> dst;
+ cv::gpu::split(loadMat(src, useRoi), dst);
- std::vector<cv::Mat> dst_gold;
- cv::split(src, dst_gold);
+ std::vector<cv::Mat> dst_gold;
+ cv::split(src, dst_gold);
- ASSERT_EQ(dst_gold.size(), dst.size());
+ ASSERT_EQ(dst_gold.size(), dst.size());
- for (size_t i = 0; i < dst_gold.size(); ++i)
- {
- EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
- }
+ for (size_t i = 0; i < dst_gold.size(); ++i)
+ {
+ EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
}
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Split, testing::Combine(
TEST_P(Add_Array, Accuracy)
{
- try
- {
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
- cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
- cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+ cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+ cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Add_Array_Mask, Accuracy)
{
- try
- {
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
- cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
- cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
- cv::add(mat1, mat2, dst_gold, mask, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+ cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+ cv::add(mat1, mat2, dst_gold, mask, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Add_Scalar, WithOutMask)
{
- try
- {
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
- cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
- cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+ cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+ cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Add_Scalar, WithMask)
{
- try
- {
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
- cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
- cv::add(mat, val, dst_gold, mask, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+ cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+ cv::add(mat, val, dst_gold, mask, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Subtract_Array, Accuracy)
{
- try
- {
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
- cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
- cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+ cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+ cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Subtract_Array_Mask, Accuracy)
{
- try
- {
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
- cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
- cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+ cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+ cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Subtract_Scalar, WithOutMask)
{
- try
- {
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
- cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
- cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+ cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+ cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Subtract_Scalar, WithMask)
{
- try
- {
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- dst.setTo(cv::Scalar::all(0));
- cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
- cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
- cv::subtract(mat, val, dst_gold, mask, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ dst.setTo(cv::Scalar::all(0));
+ cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+ cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+ cv::subtract(mat, val, dst_gold, mask, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Multiply_Array, WithOutScale)
{
- try
- {
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
- cv::Mat dst_gold;
- cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+ cv::Mat dst_gold;
+ cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
}
}
TEST_P(Multiply_Array, WithScale)
{
- try
- {
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype);
- double scale = randomDouble(0.0, 255.0);
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype);
+ double scale = randomDouble(0.0, 255.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
- cv::Mat dst_gold;
- cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+ cv::Mat dst_gold;
+ cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
}
}
TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
{
- try
- {
- cv::Mat mat1 = randomMat(size, CV_8UC4);
- cv::Mat mat2 = randomMat(size, CV_32FC1);
+ cv::Mat mat1 = randomMat(size, CV_8UC4);
+ cv::Mat mat2 = randomMat(size, CV_32FC1);
- cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
- cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+ cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- for (int y = 0; y < h_dst.rows; ++y)
- {
- const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
- const float* mat2_row = mat2.ptr<float>(y);
- const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+ for (int y = 0; y < h_dst.rows; ++y)
+ {
+ const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+ const float* mat2_row = mat2.ptr<float>(y);
+ const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
- for (int x = 0; x < h_dst.cols; ++x)
- {
- cv::Vec4b val1 = mat1_row[x];
- float val2 = mat2_row[x];
- cv::Vec4b actual = dst_row[x];
+ for (int x = 0; x < h_dst.cols; ++x)
+ {
+ cv::Vec4b val1 = mat1_row[x];
+ float val2 = mat2_row[x];
+ cv::Vec4b actual = dst_row[x];
- cv::Vec4b gold;
+ cv::Vec4b gold;
- gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
- gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
- gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
- gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
+ gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
+ gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
+ gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
+ gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
- ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- }
+ ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
}
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
{
- try
- {
- cv::Mat mat1 = randomMat(size, CV_16SC4);
- cv::Mat mat2 = randomMat(size, CV_32FC1);
+ cv::Mat mat1 = randomMat(size, CV_16SC4);
+ cv::Mat mat2 = randomMat(size, CV_32FC1);
- cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
- cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+ cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- for (int y = 0; y < h_dst.rows; ++y)
- {
- const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
- const float* mat2_row = mat2.ptr<float>(y);
- const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+ for (int y = 0; y < h_dst.rows; ++y)
+ {
+ const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+ const float* mat2_row = mat2.ptr<float>(y);
+ const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
- for (int x = 0; x < h_dst.cols; ++x)
- {
- cv::Vec4s val1 = mat1_row[x];
- float val2 = mat2_row[x];
- cv::Vec4s actual = dst_row[x];
+ for (int x = 0; x < h_dst.cols; ++x)
+ {
+ cv::Vec4s val1 = mat1_row[x];
+ float val2 = mat2_row[x];
+ cv::Vec4s actual = dst_row[x];
- cv::Vec4s gold;
+ cv::Vec4s gold;
- gold[0] = cv::saturate_cast<short>(val1[0] * val2);
- gold[1] = cv::saturate_cast<short>(val1[1] * val2);
- gold[2] = cv::saturate_cast<short>(val1[2] * val2);
- gold[3] = cv::saturate_cast<short>(val1[3] * val2);
+ gold[0] = cv::saturate_cast<short>(val1[0] * val2);
+ gold[1] = cv::saturate_cast<short>(val1[1] * val2);
+ gold[2] = cv::saturate_cast<short>(val1[2] * val2);
+ gold[3] = cv::saturate_cast<short>(val1[3] * val2);
- ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- }
+ ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
}
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Multiply_Array_Special, testing::Combine(
TEST_P(Multiply_Scalar, WithOutScale)
{
- try
- {
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
- cv::Mat dst_gold;
- cv::multiply(mat, val, dst_gold, 1, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+ cv::Mat dst_gold;
+ cv::multiply(mat, val, dst_gold, 1, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
}
}
TEST_P(Multiply_Scalar, WithScale)
{
- try
- {
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(0, 255);
- double scale = randomDouble(0.0, 255.0);
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(0, 255);
+ double scale = randomDouble(0.0, 255.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
- cv::Mat dst_gold;
- cv::multiply(mat, val, dst_gold, scale, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+ cv::Mat dst_gold;
+ cv::multiply(mat, val, dst_gold, scale, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
}
}
TEST_P(Divide_Array, WithOutScale)
{
- try
- {
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(mat1, mat2, dst_gold, 1, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(mat1, mat2, dst_gold, 1, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
}
}
TEST_P(Divide_Array, WithScale)
{
- try
- {
- cv::Mat mat1 = randomMat(size, stype);
- cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
- double scale = randomDouble(0.0, 255.0);
+ cv::Mat mat1 = randomMat(size, stype);
+ cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+ double scale = randomDouble(0.0, 255.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
- cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(mat1, mat2, dst_gold, scale, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+ cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(mat1, mat2, dst_gold, scale, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
}
}
TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
{
- try
- {
- cv::Mat mat1 = randomMat(size, CV_8UC4);
- cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+ cv::Mat mat1 = randomMat(size, CV_8UC4);
+ cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
- cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
- cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+ cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- for (int y = 0; y < h_dst.rows; ++y)
- {
- const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
- const float* mat2_row = mat2.ptr<float>(y);
- const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+ for (int y = 0; y < h_dst.rows; ++y)
+ {
+ const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+ const float* mat2_row = mat2.ptr<float>(y);
+ const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
- for (int x = 0; x < h_dst.cols; ++x)
- {
- cv::Vec4b val1 = mat1_row[x];
- float val2 = mat2_row[x];
- cv::Vec4b actual = dst_row[x];
+ for (int x = 0; x < h_dst.cols; ++x)
+ {
+ cv::Vec4b val1 = mat1_row[x];
+ float val2 = mat2_row[x];
+ cv::Vec4b actual = dst_row[x];
- cv::Vec4b gold;
+ cv::Vec4b gold;
- gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
- gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
- gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
- gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
+ gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
+ gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
+ gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
+ gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
- ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- }
+ ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
}
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
{
- try
- {
- cv::Mat mat1 = randomMat(size, CV_16SC4);
- cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+ cv::Mat mat1 = randomMat(size, CV_16SC4);
+ cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
- cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
- cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+ cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
- cv::Mat h_dst(dst);
+ cv::Mat h_dst(dst);
- for (int y = 0; y < h_dst.rows; ++y)
- {
- const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
- const float* mat2_row = mat2.ptr<float>(y);
- const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+ for (int y = 0; y < h_dst.rows; ++y)
+ {
+ const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+ const float* mat2_row = mat2.ptr<float>(y);
+ const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
- for (int x = 0; x < h_dst.cols; ++x)
- {
- cv::Vec4s val1 = mat1_row[x];
- float val2 = mat2_row[x];
- cv::Vec4s actual = dst_row[x];
+ for (int x = 0; x < h_dst.cols; ++x)
+ {
+ cv::Vec4s val1 = mat1_row[x];
+ float val2 = mat2_row[x];
+ cv::Vec4s actual = dst_row[x];
- cv::Vec4s gold;
+ cv::Vec4s gold;
- gold[0] = cv::saturate_cast<short>(val1[0] / val2);
- gold[1] = cv::saturate_cast<short>(val1[1] / val2);
- gold[2] = cv::saturate_cast<short>(val1[2] / val2);
- gold[3] = cv::saturate_cast<short>(val1[3] / val2);
+ gold[0] = cv::saturate_cast<short>(val1[0] / val2);
+ gold[1] = cv::saturate_cast<short>(val1[1] / val2);
+ gold[2] = cv::saturate_cast<short>(val1[2] / val2);
+ gold[3] = cv::saturate_cast<short>(val1[3] / val2);
- ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
- }
+ ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+ ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
}
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Divide_Array_Special, testing::Combine(
TEST_P(Divide_Scalar, WithOutScale)
{
- try
- {
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(1.0, 255.0);
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(1.0, 255.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(mat, val, dst_gold, 1, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(mat, val, dst_gold, 1, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(Divide_Scalar, WithScale)
{
- try
- {
- cv::Mat mat = randomMat(size, depth.first);
- cv::Scalar val = randomScalar(1.0, 255.0);
- double scale = randomDouble(0.0, 255.0);
+ cv::Mat mat = randomMat(size, depth.first);
+ cv::Scalar val = randomScalar(1.0, 255.0);
+ double scale = randomDouble(0.0, 255.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(mat, val, dst_gold, scale, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(mat, val, dst_gold, scale, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
}
}
TEST_P(Divide_Scalar_Inv, Accuracy)
{
- try
- {
- double scale = randomDouble(0.0, 255.0);
- cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
+ double scale = randomDouble(0.0, 255.0);
+ cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
- if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
- cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
-
- cv::Mat dst_gold;
- cv::divide(scale, mat, dst_gold, depth.second);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+ cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
+
+ cv::Mat dst_gold;
+ cv::divide(scale, mat, dst_gold, depth.second);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
}
}
TEST_P(AbsDiff, Array)
{
- try
- {
- cv::Mat src1 = randomMat(size, depth);
- cv::Mat src2 = randomMat(size, depth);
+ cv::Mat src1 = randomMat(size, depth);
+ cv::Mat src2 = randomMat(size, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
- cv::Mat dst_gold;
- cv::absdiff(src1, src2, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+ cv::Mat dst_gold;
+ cv::absdiff(src1, src2, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(AbsDiff, Scalar)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
- cv::Scalar val = randomScalar(0.0, 255.0);
+ cv::Mat src = randomMat(size, depth);
+ cv::Scalar val = randomScalar(0.0, 255.0);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::absdiff(loadMat(src), val, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::absdiff(loadMat(src), val, dst);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
-
- cv::Mat dst_gold;
- cv::absdiff(src, val, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
+
+ cv::Mat dst_gold;
+ cv::absdiff(src, val, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
}
}
TEST_P(Abs, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::abs(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::abs(loadMat(src, useRoi), dst);
- cv::Mat dst_gold = cv::abs(src);
+ cv::Mat dst_gold = cv::abs(src);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine(
TEST_P(Sqr, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
+ cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::sqr(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::sqr(loadMat(src, useRoi), dst);
- cv::Mat dst_gold;
- cv::multiply(src, src, dst_gold);
+ cv::Mat dst_gold;
+ cv::multiply(src, src, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine(
TEST_P(Sqrt, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::sqrt(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::sqrt(loadMat(src, useRoi), dst);
- cv::Mat dst_gold;
- sqrtGold(src, dst_gold);
+ cv::Mat dst_gold;
+ sqrtGold(src, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine(
TEST_P(Log, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, depth, 1.0, 255.0);
+ cv::Mat src = randomMat(size, depth, 1.0, 255.0);
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::log(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::log(loadMat(src, useRoi), dst);
- cv::Mat dst_gold;
- logGold(src, dst_gold);
+ cv::Mat dst_gold;
+ logGold(src, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine(
TEST_P(Exp, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+ cv::Mat src = randomMat(size, depth, 0.0, 10.0);
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::exp(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::exp(loadMat(src, useRoi), dst);
- cv::Mat dst_gold;
- expGold(src, dst_gold);
+ cv::Mat dst_gold;
+ expGold(src, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine(
TEST_P(Compare_Array, Accuracy)
{
- try
- {
- cv::Mat src1 = randomMat(size, depth);
- cv::Mat src2 = randomMat(size, depth);
+ cv::Mat src1 = randomMat(size, depth);
+ cv::Mat src2 = randomMat(size, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
- cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
-
- cv::Mat dst_gold;
- cv::compare(src1, src2, dst_gold, cmp_code);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
+ cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
+
+ cv::Mat dst_gold;
+ cv::compare(src1, src2, dst_gold, cmp_code);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(Compare_Scalar, Accuracy)
{
- try
+ cv::Mat src = randomMat(size, type);
+ cv::Scalar sc = randomScalar(0.0, 255.0);
+
+ if (src.depth() < CV_32F)
{
- cv::Mat src = randomMat(size, type);
- cv::Scalar sc = randomScalar(0.0, 255.0);
+ sc.val[0] = cvRound(sc.val[0]);
+ sc.val[1] = cvRound(sc.val[1]);
+ sc.val[2] = cvRound(sc.val[2]);
+ sc.val[3] = cvRound(sc.val[3]);
+ }
- if (src.depth() < CV_32F)
+ if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- sc.val[0] = cvRound(sc.val[0]);
- sc.val[1] = cvRound(sc.val[1]);
- sc.val[2] = cvRound(sc.val[2]);
- sc.val[3] = cvRound(sc.val[3]);
+ cv::gpu::GpuMat dst;
+ cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
}
-
- if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ catch (const cv::Exception& e)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
- else
- {
- cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
+ }
+ else
+ {
+ cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
- cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
+ cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
- cv::Mat dst_gold;
- compareScalarGold(src, sc, dst_gold, cmp_code);
+ cv::Mat dst_gold;
+ compareScalarGold(src, sc, dst_gold, cmp_code);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(Bitwise_Array, Not)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_not(loadMat(src1), dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_not(loadMat(src1), dst);
- cv::Mat dst_gold = ~src1;
+ cv::Mat dst_gold = ~src1;
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(Bitwise_Array, Or)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
- cv::Mat dst_gold = src1 | src2;
+ cv::Mat dst_gold = src1 | src2;
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(Bitwise_Array, And)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
- cv::Mat dst_gold = src1 & src2;
+ cv::Mat dst_gold = src1 & src2;
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(Bitwise_Array, Xor)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
- cv::Mat dst_gold = src1 ^ src2;
+ cv::Mat dst_gold = src1 ^ src2;
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Array, testing::Combine(
TEST_P(Bitwise_Scalar, Or)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_or(loadMat(src), val, dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_or(loadMat(src), val, dst);
- cv::Mat dst_gold;
- cv::bitwise_or(src, val, dst_gold);
+ cv::Mat dst_gold;
+ cv::bitwise_or(src, val, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(Bitwise_Scalar, And)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_and(loadMat(src), val, dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_and(loadMat(src), val, dst);
- cv::Mat dst_gold;
- cv::bitwise_and(src, val, dst_gold);
+ cv::Mat dst_gold;
+ cv::bitwise_and(src, val, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(Bitwise_Scalar, Xor)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::bitwise_xor(loadMat(src), val, dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::bitwise_xor(loadMat(src), val, dst);
- cv::Mat dst_gold;
- cv::bitwise_xor(src, val, dst_gold);
+ cv::Mat dst_gold;
+ cv::bitwise_xor(src, val, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine(
TEST_P(RShift, Accuracy)
{
- try
- {
- int type = CV_MAKE_TYPE(depth, channels);
- cv::Mat src = randomMat(size, type);
- cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+ int type = CV_MAKE_TYPE(depth, channels);
+ cv::Mat src = randomMat(size, type);
+ cv::Scalar_<int> val = randomScalar(0.0, 8.0);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::rshift(loadMat(src, useRoi), val, dst);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::rshift(loadMat(src, useRoi), val, dst);
- cv::Mat dst_gold;
- rhiftGold(src, val, dst_gold);
+ cv::Mat dst_gold;
+ rhiftGold(src, val, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, RShift, testing::Combine(
TEST_P(LShift, Accuracy)
{
- try
- {
- int type = CV_MAKE_TYPE(depth, channels);
- cv::Mat src = randomMat(size, type);
- cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+ int type = CV_MAKE_TYPE(depth, channels);
+ cv::Mat src = randomMat(size, type);
+ cv::Scalar_<int> val = randomScalar(0.0, 8.0);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::lshift(loadMat(src, useRoi), val, dst);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::lshift(loadMat(src, useRoi), val, dst);
- cv::Mat dst_gold;
- lhiftGold(src, val, dst_gold);
+ cv::Mat dst_gold;
+ lhiftGold(src, val, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, LShift, testing::Combine(
TEST_P(Min, Array)
{
- try
- {
- cv::Mat src1 = randomMat(size, depth);
- cv::Mat src2 = randomMat(size, depth);
+ cv::Mat src1 = randomMat(size, depth);
+ cv::Mat src2 = randomMat(size, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::min(loadMat(src1), loadMat(src2), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::min(loadMat(src1), loadMat(src2), dst);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
- cv::Mat dst_gold = cv::min(src1, src2);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+ cv::Mat dst_gold = cv::min(src1, src2);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(Min, Scalar)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
- double val = randomDouble(0.0, 255.0);
+ cv::Mat src = randomMat(size, depth);
+ double val = randomDouble(0.0, 255.0);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::min(loadMat(src), val, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::min(loadMat(src), val, dst);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::min(loadMat(src, useRoi), val, dst);
-
- cv::Mat dst_gold = cv::min(src, val);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::min(loadMat(src, useRoi), val, dst);
+
+ cv::Mat dst_gold = cv::min(src, val);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(Max, Array)
{
- try
- {
- cv::Mat src1 = randomMat(size, depth);
- cv::Mat src2 = randomMat(size, depth);
+ cv::Mat src1 = randomMat(size, depth);
+ cv::Mat src2 = randomMat(size, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::max(loadMat(src1), loadMat(src2), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::max(loadMat(src1), loadMat(src2), dst);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
- cv::Mat dst_gold = cv::max(src1, src2);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+ cv::Mat dst_gold = cv::max(src1, src2);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(Max, Scalar)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
- double val = randomDouble(0.0, 255.0);
+ cv::Mat src = randomMat(size, depth);
+ double val = randomDouble(0.0, 255.0);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::max(loadMat(src), val, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::max(loadMat(src), val, dst);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::max(loadMat(src, useRoi), val, dst);
-
- cv::Mat dst_gold = cv::max(src, val);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::max(loadMat(src, useRoi), val, dst);
+
+ cv::Mat dst_gold = cv::max(src, val);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(Pow, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, depth, 0.0, 10.0);
- double power = randomDouble(2.0, 4.0);
+ cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+ double power = randomDouble(2.0, 4.0);
- if (src.depth() < CV_32F)
- power = static_cast<int>(power);
+ if (src.depth() < CV_32F)
+ power = static_cast<int>(power);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::pow(loadMat(src), power, dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::pow(loadMat(src), power, dst);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
- cv::gpu::pow(loadMat(src, useRoi), power, dst);
-
- cv::Mat dst_gold;
- cv::pow(src, power, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+ cv::gpu::pow(loadMat(src, useRoi), power, dst);
+
+ cv::Mat dst_gold;
+ cv::pow(src, power, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
}
}
TEST_P(AddWeighted, Accuracy)
{
- try
- {
- cv::Mat src1 = randomMat(size, depth1);
- cv::Mat src2 = randomMat(size, depth2);
- double alpha = randomDouble(-10.0, 10.0);
- double beta = randomDouble(-10.0, 10.0);
- double gamma = randomDouble(-10.0, 10.0);
+ cv::Mat src1 = randomMat(size, depth1);
+ cv::Mat src2 = randomMat(size, depth2);
+ double alpha = randomDouble(-10.0, 10.0);
+ double beta = randomDouble(-10.0, 10.0);
+ double gamma = randomDouble(-10.0, 10.0);
- if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
- cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
-
- cv::Mat dst_gold;
- cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
-
- EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
+ cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
+
+ cv::Mat dst_gold;
+ cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
}
}
//////////////////////////////////////////////////////////////////////////////
// GEMM
-#ifdef HAVE_CUBLAS
-
CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T);
#define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
TEST_P(GEMM, Accuracy)
{
+ cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
+ cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
+ cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
+ double alpha = randomDouble(-10.0, 10.0);
+ double beta = randomDouble(-10.0, 10.0);
+
+#ifndef HAVE_CUBLAS
try
{
- cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
- cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
- cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
- double alpha = randomDouble(-10.0, 10.0);
- double beta = randomDouble(-10.0, 10.0);
-
- if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ cv::gpu::GpuMat dst;
+ cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsNotImplemented, e.code);
+ }
+#else
+ if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
}
- else if (type == CV_64FC2 && flags != 0)
+ catch (const cv::Exception& e)
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsNotImplemented, e.code);
- }
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
- else
+ }
+ else if (type == CV_64FC2 && flags != 0)
+ {
+ try
{
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
-
- cv::Mat dst_gold;
- cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
-
- EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
+ cv::gpu::GpuMat dst;
+ cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
+
+ cv::Mat dst_gold;
+ cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
}
+#endif
}
INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
ALL_GEMM_FLAGS,
WHOLE_SUBMAT));
-#endif // HAVE_CUBLAS
-
////////////////////////////////////////////////////////////////////////////////
// Transpose
TEST_P(Transpose, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::transpose(loadMat(src), dst);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::transpose(loadMat(src), dst);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
- cv::gpu::transpose(loadMat(src, useRoi), dst);
-
- cv::Mat dst_gold;
- cv::transpose(src, dst_gold);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
+ cv::gpu::transpose(loadMat(src, useRoi), dst);
+
+ cv::Mat dst_gold;
+ cv::transpose(src, dst_gold);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(Flip, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
- cv::Mat dst_gold;
- cv::flip(src, dst_gold, flip_code);
+ cv::Mat dst_gold;
+ cv::flip(src, dst_gold, flip_code);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Flip, testing::Combine(
TEST_P(LUT, OneChannel)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
- cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
- cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
+ cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
- cv::Mat dst_gold;
- cv::LUT(src, lut, dst_gold);
+ cv::Mat dst_gold;
+ cv::LUT(src, lut, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
TEST_P(LUT, MultiChannel)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
+ cv::Mat src = randomMat(size, type);
+ cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
- cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
- cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
+ cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
- cv::Mat dst_gold;
- cv::LUT(src, lut, dst_gold);
+ cv::Mat dst_gold;
+ cv::LUT(src, lut, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, LUT, testing::Combine(
TEST_P(Magnitude, NPP)
{
- try
- {
- cv::Mat src = randomMat(size, CV_32FC2);
+ cv::Mat src = randomMat(size, CV_32FC2);
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::magnitude(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::magnitude(loadMat(src, useRoi), dst);
- cv::Mat arr[2];
- cv::split(src, arr);
- cv::Mat dst_gold;
- cv::magnitude(arr[0], arr[1], dst_gold);
+ cv::Mat arr[2];
+ cv::split(src, arr);
+ cv::Mat dst_gold;
+ cv::magnitude(arr[0], arr[1], dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
}
TEST_P(Magnitude, Sqr_NPP)
{
- try
- {
- cv::Mat src = randomMat(size, CV_32FC2);
+ cv::Mat src = randomMat(size, CV_32FC2);
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
- cv::Mat arr[2];
- cv::split(src, arr);
- cv::Mat dst_gold;
- cv::magnitude(arr[0], arr[1], dst_gold);
- cv::multiply(dst_gold, dst_gold, dst_gold);
+ cv::Mat arr[2];
+ cv::split(src, arr);
+ cv::Mat dst_gold;
+ cv::magnitude(arr[0], arr[1], dst_gold);
+ cv::multiply(dst_gold, dst_gold, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
}
TEST_P(Magnitude, Accuracy)
{
- try
- {
- cv::Mat x = randomMat(size, CV_32FC1);
- cv::Mat y = randomMat(size, CV_32FC1);
+ cv::Mat x = randomMat(size, CV_32FC1);
+ cv::Mat y = randomMat(size, CV_32FC1);
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
- cv::Mat dst_gold;
- cv::magnitude(x, y, dst_gold);
+ cv::Mat dst_gold;
+ cv::magnitude(x, y, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
}
TEST_P(Magnitude, Sqr_Accuracy)
{
- try
- {
- cv::Mat x = randomMat(size, CV_32FC1);
- cv::Mat y = randomMat(size, CV_32FC1);
+ cv::Mat x = randomMat(size, CV_32FC1);
+ cv::Mat y = randomMat(size, CV_32FC1);
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
- cv::Mat dst_gold;
- cv::magnitude(x, y, dst_gold);
- cv::multiply(dst_gold, dst_gold, dst_gold);
+ cv::Mat dst_gold;
+ cv::magnitude(x, y, dst_gold);
+ cv::multiply(dst_gold, dst_gold, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Magnitude, testing::Combine(
TEST_P(Phase, Accuracy)
{
- try
- {
- cv::Mat x = randomMat(size, CV_32FC1);
- cv::Mat y = randomMat(size, CV_32FC1);
+ cv::Mat x = randomMat(size, CV_32FC1);
+ cv::Mat y = randomMat(size, CV_32FC1);
- cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
- cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
+ cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
- cv::Mat dst_gold;
- cv::phase(x, y, dst_gold, angleInDegrees);
+ cv::Mat dst_gold;
+ cv::phase(x, y, dst_gold, angleInDegrees);
- EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Phase, testing::Combine(
TEST_P(CartToPolar, Accuracy)
{
- try
- {
- cv::Mat x = randomMat(size, CV_32FC1);
- cv::Mat y = randomMat(size, CV_32FC1);
+ cv::Mat x = randomMat(size, CV_32FC1);
+ cv::Mat y = randomMat(size, CV_32FC1);
- cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
- cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
- cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
+ cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
- cv::Mat mag_gold;
- cv::Mat angle_gold;
- cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
+ cv::Mat mag_gold;
+ cv::Mat angle_gold;
+ cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
- EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
- EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
+ EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, CartToPolar, testing::Combine(
TEST_P(PolarToCart, Accuracy)
{
- try
- {
- cv::Mat magnitude = randomMat(size, CV_32FC1);
- cv::Mat angle = randomMat(size, CV_32FC1);
+ cv::Mat magnitude = randomMat(size, CV_32FC1);
+ cv::Mat angle = randomMat(size, CV_32FC1);
- cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
- cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
- cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
+ cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
+ cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
- cv::Mat x_gold;
- cv::Mat y_gold;
- cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
+ cv::Mat x_gold;
+ cv::Mat y_gold;
+ cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
- EXPECT_MAT_NEAR(x_gold, x, 1e-4);
- EXPECT_MAT_NEAR(y_gold, y, 1e-4);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(x_gold, x, 1e-4);
+ EXPECT_MAT_NEAR(y_gold, y, 1e-4);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, PolarToCart, testing::Combine(
TEST_P(MeanStdDev, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, CV_8UC1);
+ cv::Mat src = randomMat(size, CV_8UC1);
- if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
- {
- try
- {
- cv::Scalar mean;
- cv::Scalar stddev;
- cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsNotImplemented, e.code);
- }
- }
- else
+ if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
+ {
+ try
{
cv::Scalar mean;
cv::Scalar stddev;
cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
-
- cv::Scalar mean_gold;
- cv::Scalar stddev_gold;
- cv::meanStdDev(src, mean_gold, stddev_gold);
-
- EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
- EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::Scalar mean;
+ cv::Scalar stddev;
+ cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
+
+ cv::Scalar mean_gold;
+ cv::Scalar stddev_gold;
+ cv::meanStdDev(src, mean_gold, stddev_gold);
+
+ EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
+ EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
}
}
TEST_P(Norm, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- double val = cv::gpu::norm(loadMat(src, useRoi), normCode);
+ double val = cv::gpu::norm(loadMat(src, useRoi), normCode);
- double val_gold = cv::norm(src, normCode);
+ double val_gold = cv::norm(src, normCode);
- EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Norm, testing::Combine(
TEST_P(NormDiff, Accuracy)
{
- try
- {
- cv::Mat src1 = randomMat(size, CV_8UC1);
- cv::Mat src2 = randomMat(size, CV_8UC1);
+ cv::Mat src1 = randomMat(size, CV_8UC1);
+ cv::Mat src2 = randomMat(size, CV_8UC1);
- double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
+ double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
- double val_gold = cv::norm(src1, src2, normCode);
+ double val_gold = cv::norm(src1, src2, normCode);
- EXPECT_NEAR(val_gold, val, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_NEAR(val_gold, val, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, NormDiff, testing::Combine(
TEST_P(Sum, Simple)
{
- try
- {
- cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
+ cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
- cv::Scalar val_gold = cv::sum(src);
+ cv::Scalar val_gold = cv::sum(src);
- EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
}
TEST_P(Sum, Abs)
{
- try
- {
- cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
+ cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
- cv::Scalar val_gold = absSumGold(src);
+ cv::Scalar val_gold = absSumGold(src);
- EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
}
TEST_P(Sum, Sqr)
{
- try
- {
- cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
+ cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
- cv::Scalar val_gold = sqrSumGold(src);
+ cv::Scalar val_gold = sqrSumGold(src);
- EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine(
TEST_P(MinMax, WithoutMask)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
}
- else
+ catch (const cv::Exception& e)
{
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
-
- double minVal_gold, maxVal_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
+
+ double minVal_gold, maxVal_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
}
}
TEST_P(MinMax, WithMask)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+ cv::Mat src = randomMat(size, depth);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
}
- else
+ catch (const cv::Exception& e)
{
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
-
- double minVal_gold, maxVal_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
+
+ double minVal_gold, maxVal_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
}
}
TEST_P(MinMax, NullPtr)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src), &minVal, 0);
- cv::gpu::minMax(loadMat(src), 0, &maxVal);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src), &minVal, 0);
+ cv::gpu::minMax(loadMat(src), 0, &maxVal);
}
- else
+ catch (const cv::Exception& e)
{
- double minVal, maxVal;
- cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
- cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
-
- double minVal_gold, maxVal_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ double minVal, maxVal;
+ cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
+ cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
+
+ double minVal_gold, maxVal_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
}
}
TEST_P(MinMaxLoc, WithoutMask)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
- }
- else
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
double minVal, maxVal;
cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
-
- double minVal_gold, maxVal_gold;
- cv::Point minLoc_gold, maxLoc_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
- expectEqual(src, minLoc_gold, minLoc);
- expectEqual(src, maxLoc_gold, maxLoc);
+ cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
+
+ double minVal_gold, maxVal_gold;
+ cv::Point minLoc_gold, maxLoc_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+ expectEqual(src, minLoc_gold, minLoc);
+ expectEqual(src, maxLoc_gold, maxLoc);
}
}
TEST_P(MinMaxLoc, WithMask)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+ cv::Mat src = randomMat(size, depth);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
- }
- else
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
double minVal, maxVal;
cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
-
- double minVal_gold, maxVal_gold;
- cv::Point minLoc_gold, maxLoc_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
- expectEqual(src, minLoc_gold, minLoc);
- expectEqual(src, maxLoc_gold, maxLoc);
+ cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
+
+ double minVal_gold, maxVal_gold;
+ cv::Point minLoc_gold, maxLoc_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+ expectEqual(src, minLoc_gold, minLoc);
+ expectEqual(src, maxLoc_gold, maxLoc);
}
}
TEST_P(MinMaxLoc, NullPtr)
{
- try
- {
- cv::Mat src = randomMat(size, depth);
+ cv::Mat src = randomMat(size, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- double minVal, maxVal;
- cv::Point minLoc, maxLoc;
- cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
- cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
- }
- else
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
double minVal, maxVal;
cv::Point minLoc, maxLoc;
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
-
- double minVal_gold, maxVal_gold;
- cv::Point minLoc_gold, maxLoc_gold;
- minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
- EXPECT_DOUBLE_EQ(minVal_gold, minVal);
- EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
- expectEqual(src, minLoc_gold, minLoc);
- expectEqual(src, maxLoc_gold, maxLoc);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ double minVal, maxVal;
+ cv::Point minLoc, maxLoc;
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
+ cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
+
+ double minVal_gold, maxVal_gold;
+ cv::Point minLoc_gold, maxLoc_gold;
+ minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+ EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+ EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+ expectEqual(src, minLoc_gold, minLoc);
+ expectEqual(src, maxLoc_gold, maxLoc);
}
}
TEST_P(CountNonZero, Accuracy)
{
- try
- {
- cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
- cv::Mat src;
- srcBase.convertTo(src, depth);
+ cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
+ cv::Mat src;
+ srcBase.convertTo(src, depth);
- if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::countNonZero(loadMat(src));
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::countNonZero(loadMat(src));
}
- else
+ catch (const cv::Exception& e)
{
- int val = cv::gpu::countNonZero(loadMat(src, useRoi));
-
- int val_gold = cv::countNonZero(src);
-
- ASSERT_EQ(val_gold, val);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ int val = cv::gpu::countNonZero(loadMat(src, useRoi));
+
+ int val_gold = cv::countNonZero(src);
+
+ ASSERT_EQ(val_gold, val);
}
}
TEST_P(Reduce, Rows)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
- cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
+ cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
+ cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
- cv::Mat dst_gold;
- cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
+ cv::Mat dst_gold;
+ cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
- EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
}
TEST_P(Reduce, Cols)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
- cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
+ cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
+ cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
- cv::Mat dst_gold;
- cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
- dst_gold.cols = dst_gold.rows;
- dst_gold.rows = 1;
- dst_gold.step = dst_gold.cols * dst_gold.elemSize();
+ cv::Mat dst_gold;
+ cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
+ dst_gold.cols = dst_gold.rows;
+ dst_gold.rows = 1;
+ dst_gold.step = dst_gold.cols * dst_gold.elemSize();
- EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
}
INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine(
TEST_P(BilateralFilter, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- src.convertTo(src, type);
- cv::gpu::GpuMat dst;
+ src.convertTo(src, type);
+ cv::gpu::GpuMat dst;
- cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial);
+ cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial);
- cv::Mat dst_gold;
- cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
+ cv::Mat dst_gold;
+ cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Denoising, BilateralFilter, testing::Combine(
TEST_P(BruteForceNonLocalMeans, Regression)
{
- try
- {
- using cv::gpu::GpuMat;
+ using cv::gpu::GpuMat;
- cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
- ASSERT_FALSE(bgr.empty());
+ cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
+ ASSERT_FALSE(bgr.empty());
- cv::Mat gray;
- cv::cvtColor(bgr, gray, CV_BGR2GRAY);
+ cv::Mat gray;
+ cv::cvtColor(bgr, gray, CV_BGR2GRAY);
- GpuMat dbgr, dgray;
- cv::gpu::nonLocalMeans(GpuMat(bgr), dbgr, 20);
- cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
+ GpuMat dbgr, dgray;
+ cv::gpu::nonLocalMeans(GpuMat(bgr), dbgr, 20);
+ cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
- #if 0
- dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
- dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
- #endif
+#if 0
+ dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+ dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
+#endif
- cv::Mat bgr_gold = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
- cv::Mat gray_gold = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
+ cv::Mat bgr_gold = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
+ cv::Mat gray_gold = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
- EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
- EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
+ EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
}
INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES);
+
+
////////////////////////////////////////////////////////
// Fast Force Non local means
TEST_P(FastNonLocalMeans, Regression)
{
- try
- {
- using cv::gpu::GpuMat;
+ using cv::gpu::GpuMat;
- cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
- ASSERT_FALSE(bgr.empty());
+ cv::Mat bgr = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
+ ASSERT_FALSE(bgr.empty());
- cv::Mat gray;
- cv::cvtColor(bgr, gray, CV_BGR2GRAY);
+ cv::Mat gray;
+ cv::cvtColor(bgr, gray, CV_BGR2GRAY);
- GpuMat dbgr, dgray;
- cv::gpu::FastNonLocalMeansDenoising fnlmd;
+ GpuMat dbgr, dgray;
+ cv::gpu::FastNonLocalMeansDenoising fnlmd;
- fnlmd.simpleMethod(GpuMat(gray), dgray, 20);
- fnlmd.labMethod(GpuMat(bgr), dbgr, 20, 10);
+ fnlmd.simpleMethod(GpuMat(gray), dgray, 20);
+ fnlmd.labMethod(GpuMat(bgr), dbgr, 20, 10);
- #if 0
- //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
- //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
- #endif
+#if 0
+ //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+ //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
+#endif
- cv::Mat bgr_gold = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
- cv::Mat gray_gold = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
+ cv::Mat bgr_gold = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
+ cv::Mat gray_gold = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
- EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
- EXPECT_MAT_NEAR(gray_gold, dgray, 1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
+ EXPECT_MAT_NEAR(gray_gold, dgray, 1);
}
INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES);
+
#endif // HAVE_CUDA
TEST_P(SURF, Detector)
{
- try
- {
- cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(image.empty());
+ cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(image.empty());
- cv::gpu::SURF_GPU surf;
- surf.hessianThreshold = hessianThreshold;
- surf.nOctaves = nOctaves;
- surf.nOctaveLayers = nOctaveLayers;
- surf.extended = extended;
- surf.upright = upright;
- surf.keypointsRatio = 0.05f;
+ cv::gpu::SURF_GPU surf;
+ surf.hessianThreshold = hessianThreshold;
+ surf.nOctaves = nOctaves;
+ surf.nOctaveLayers = nOctaveLayers;
+ surf.extended = extended;
+ surf.upright = upright;
+ surf.keypointsRatio = 0.05f;
+ if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+ {
+ try
+ {
+ std::vector<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);
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());
+ cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(image.empty());
- cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
- mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+ cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+ mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
- cv::gpu::SURF_GPU surf;
- surf.hessianThreshold = hessianThreshold;
- surf.nOctaves = nOctaves;
- surf.nOctaveLayers = nOctaveLayers;
- surf.extended = extended;
- surf.upright = upright;
- surf.keypointsRatio = 0.05f;
+ cv::gpu::SURF_GPU surf;
+ surf.hessianThreshold = hessianThreshold;
+ surf.nOctaves = nOctaves;
+ surf.nOctaveLayers = nOctaveLayers;
+ surf.extended = extended;
+ surf.upright = upright;
+ surf.keypointsRatio = 0.05f;
+ if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+ {
+ try
+ {
+ std::vector<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);
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());
+
+ cv::gpu::SURF_GPU surf;
+ surf.hessianThreshold = hessianThreshold;
+ surf.nOctaves = nOctaves;
+ surf.nOctaveLayers = nOctaveLayers;
+ surf.extended = extended;
+ surf.upright = upright;
+ surf.keypointsRatio = 0.05f;
+
+ cv::SURF surf_gold;
+ surf_gold.hessianThreshold = hessianThreshold;
+ surf_gold.nOctaves = nOctaves;
+ surf_gold.nOctaveLayers = nOctaveLayers;
+ surf_gold.extended = extended;
+ surf_gold.upright = upright;
+
+ if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+ {
+ try
+ {
+ std::vector<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
{
- cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(image.empty());
-
- cv::gpu::SURF_GPU surf;
- surf.hessianThreshold = hessianThreshold;
- surf.nOctaves = nOctaves;
- surf.nOctaveLayers = nOctaveLayers;
- surf.extended = extended;
- surf.upright = upright;
- surf.keypointsRatio = 0.05f;
-
- cv::SURF surf_gold;
- surf_gold.hessianThreshold = hessianThreshold;
- surf_gold.nOctaves = nOctaves;
- surf_gold.nOctaveLayers = nOctaveLayers;
- surf_gold.extended = extended;
- surf_gold.upright = upright;
-
std::vector<cv::KeyPoint> keypoints;
surf_gold(image, cv::noArray(), keypoints);
EXPECT_GT(matchedRatio, 0.6);
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
TEST_P(FAST, Accuracy)
{
- try
- {
- cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(image.empty());
+ cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(image.empty());
- cv::gpu::FAST_GPU fast(threshold);
- fast.nonmaxSupression = nonmaxSupression;
+ 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);
ASSERT_KEYPOINTS_EQ(keypoints_gold, keypoints);
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
TEST_P(ORB, Accuracy)
{
- try
- {
- cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(image.empty());
+ cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(image.empty());
- cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
- mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+ cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+ mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
- cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
- orb.blurForDescriptor = blurForDescriptor;
+ 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);
EXPECT_GT(matchedRatio, 0.35);
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB, testing::Combine(
TEST_P(BruteForceMatcher, Match_Single)
{
- try
- {
- cv::gpu::BFMatcher_GPU matcher(normCode);
+ cv::gpu::BFMatcher_GPU matcher(normCode);
- cv::gpu::GpuMat mask;
- if (useMask)
- {
- mask.create(query.rows, train.rows, CV_8UC1);
- mask.setTo(cv::Scalar::all(1));
- }
-
- std::vector<cv::DMatch> matches;
- matcher.match(loadMat(query), loadMat(train), matches, mask);
+ cv::gpu::GpuMat mask;
+ if (useMask)
+ {
+ mask.create(query.rows, train.rows, CV_8UC1);
+ mask.setTo(cv::Scalar::all(1));
+ }
- ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+ std::vector<cv::DMatch> matches;
+ matcher.match(loadMat(query), loadMat(train), matches, mask);
- int badCount = 0;
- for (size_t i = 0; i < matches.size(); i++)
- {
- cv::DMatch match = matches[i];
- if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
- badCount++;
- }
+ ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
- ASSERT_EQ(0, badCount);
- }
- catch (...)
+ int badCount = 0;
+ for (size_t i = 0; i < matches.size(); i++)
{
- cv::gpu::resetDevice();
- throw;
+ cv::DMatch match = matches[i];
+ if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
+ badCount++;
}
+
+ ASSERT_EQ(0, badCount);
}
TEST_P(BruteForceMatcher, Match_Collection)
{
- try
+ cv::gpu::BFMatcher_GPU matcher(normCode);
+
+ cv::gpu::GpuMat d_train(train);
+
+ // make add() twice to test such case
+ matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+ matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+ // prepare masks (make first nearest match illegal)
+ std::vector<cv::gpu::GpuMat> masks(2);
+ for (int mi = 0; mi < 2; mi++)
{
- cv::gpu::BFMatcher_GPU matcher(normCode);
+ masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
+ for (int di = 0; di < queryDescCount/2; di++)
+ masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+ }
+
+ std::vector<cv::DMatch> matches;
+ if (useMask)
+ matcher.match(cv::gpu::GpuMat(query), matches, masks);
+ else
+ matcher.match(cv::gpu::GpuMat(query), matches);
- cv::gpu::GpuMat d_train(train);
+ ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
- // make add() twice to test such case
- matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
- matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+ int badCount = 0;
+ int shift = useMask ? 1 : 0;
+ for (size_t i = 0; i < matches.size(); i++)
+ {
+ cv::DMatch match = matches[i];
- // prepare masks (make first nearest match illegal)
- std::vector<cv::gpu::GpuMat> masks(2);
- for (int mi = 0; mi < 2; mi++)
+ if ((int)i < queryDescCount / 2)
{
- masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
- for (int di = 0; di < queryDescCount/2; di++)
- masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+ bool validQueryIdx = (match.queryIdx == (int)i);
+ bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift);
+ bool validImgIdx = (match.imgIdx == 0);
+ if (!validQueryIdx || !validTrainIdx || !validImgIdx)
+ badCount++;
}
-
- std::vector<cv::DMatch> matches;
- if (useMask)
- matcher.match(cv::gpu::GpuMat(query), matches, masks);
else
- matcher.match(cv::gpu::GpuMat(query), matches);
-
- ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
- int badCount = 0;
- int shift = useMask ? 1 : 0;
- for (size_t i = 0; i < matches.size(); i++)
{
- cv::DMatch match = matches[i];
-
- if ((int)i < queryDescCount / 2)
- {
- bool validQueryIdx = (match.queryIdx == (int)i);
- bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift);
- bool validImgIdx = (match.imgIdx == 0);
- if (!validQueryIdx || !validTrainIdx || !validImgIdx)
- badCount++;
- }
- else
- {
- bool validQueryIdx = (match.queryIdx == (int)i);
- bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift);
- bool validImgIdx = (match.imgIdx == 1);
- if (!validQueryIdx || !validTrainIdx || !validImgIdx)
- badCount++;
- }
+ bool validQueryIdx = (match.queryIdx == (int)i);
+ bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift);
+ bool validImgIdx = (match.imgIdx == 1);
+ if (!validQueryIdx || !validTrainIdx || !validImgIdx)
+ badCount++;
}
-
- ASSERT_EQ(0, badCount);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
}
+
+ ASSERT_EQ(0, badCount);
}
TEST_P(BruteForceMatcher, KnnMatch_2_Single)
{
- try
- {
- cv::gpu::BFMatcher_GPU matcher(normCode);
+ cv::gpu::BFMatcher_GPU matcher(normCode);
- const int knn = 2;
+ const int knn = 2;
- cv::gpu::GpuMat mask;
- if (useMask)
- {
- mask.create(query.rows, train.rows, CV_8UC1);
- mask.setTo(cv::Scalar::all(1));
- }
+ cv::gpu::GpuMat mask;
+ if (useMask)
+ {
+ mask.create(query.rows, train.rows, CV_8UC1);
+ mask.setTo(cv::Scalar::all(1));
+ }
- std::vector< std::vector<cv::DMatch> > matches;
- matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
+ std::vector< std::vector<cv::DMatch> > matches;
+ matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
- ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+ ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
- int badCount = 0;
- for (size_t i = 0; i < matches.size(); i++)
+ int badCount = 0;
+ for (size_t i = 0; i < matches.size(); i++)
+ {
+ if ((int)matches[i].size() != knn)
+ badCount++;
+ else
{
- if ((int)matches[i].size() != knn)
- badCount++;
- else
+ int localBadCount = 0;
+ for (int k = 0; k < knn; k++)
{
- int localBadCount = 0;
- for (int k = 0; k < knn; k++)
- {
- cv::DMatch match = matches[i][k];
- if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
- localBadCount++;
- }
- badCount += localBadCount > 0 ? 1 : 0;
+ cv::DMatch match = matches[i][k];
+ if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+ localBadCount++;
}
+ badCount += localBadCount > 0 ? 1 : 0;
}
-
- ASSERT_EQ(0, badCount);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
}
+
+ ASSERT_EQ(0, badCount);
}
TEST_P(BruteForceMatcher, KnnMatch_3_Single)
{
- try
- {
- cv::gpu::BFMatcher_GPU matcher(normCode);
+ cv::gpu::BFMatcher_GPU matcher(normCode);
- const int knn = 3;
+ const int knn = 3;
- cv::gpu::GpuMat mask;
- if (useMask)
- {
- mask.create(query.rows, train.rows, CV_8UC1);
- mask.setTo(cv::Scalar::all(1));
- }
+ cv::gpu::GpuMat mask;
+ if (useMask)
+ {
+ mask.create(query.rows, train.rows, CV_8UC1);
+ mask.setTo(cv::Scalar::all(1));
+ }
- std::vector< std::vector<cv::DMatch> > matches;
- matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
+ std::vector< std::vector<cv::DMatch> > matches;
+ matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
- ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+ ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
- int badCount = 0;
- for (size_t i = 0; i < matches.size(); i++)
+ int badCount = 0;
+ for (size_t i = 0; i < matches.size(); i++)
+ {
+ if ((int)matches[i].size() != knn)
+ badCount++;
+ else
{
- if ((int)matches[i].size() != knn)
- badCount++;
- else
+ int localBadCount = 0;
+ for (int k = 0; k < knn; k++)
{
- int localBadCount = 0;
- for (int k = 0; k < knn; k++)
- {
- cv::DMatch match = matches[i][k];
- if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
- localBadCount++;
- }
- badCount += localBadCount > 0 ? 1 : 0;
+ cv::DMatch match = matches[i][k];
+ if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+ localBadCount++;
}
+ badCount += localBadCount > 0 ? 1 : 0;
}
-
- ASSERT_EQ(0, badCount);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
}
+
+ ASSERT_EQ(0, badCount);
}
TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
{
- try
- {
- cv::gpu::BFMatcher_GPU matcher(normCode);
+ cv::gpu::BFMatcher_GPU matcher(normCode);
- const int knn = 2;
+ const int knn = 2;
- cv::gpu::GpuMat d_train(train);
+ cv::gpu::GpuMat d_train(train);
- // make add() twice to test such case
- matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
- matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+ // make add() twice to test such case
+ matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+ matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
- // prepare masks (make first nearest match illegal)
- std::vector<cv::gpu::GpuMat> masks(2);
- for (int mi = 0; mi < 2; mi++ )
- {
- masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
- for (int di = 0; di < queryDescCount / 2; di++)
- masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
- }
+ // prepare masks (make first nearest match illegal)
+ std::vector<cv::gpu::GpuMat> masks(2);
+ for (int mi = 0; mi < 2; mi++ )
+ {
+ masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+ for (int di = 0; di < queryDescCount / 2; di++)
+ masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+ }
- std::vector< std::vector<cv::DMatch> > matches;
+ std::vector< std::vector<cv::DMatch> > matches;
- if (useMask)
- matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
- else
- matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
+ if (useMask)
+ matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+ else
+ matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
- ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+ ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
- int badCount = 0;
- int shift = useMask ? 1 : 0;
- for (size_t i = 0; i < matches.size(); i++)
+ int badCount = 0;
+ int shift = useMask ? 1 : 0;
+ for (size_t i = 0; i < matches.size(); i++)
+ {
+ if ((int)matches[i].size() != knn)
+ badCount++;
+ else
{
- if ((int)matches[i].size() != knn)
- badCount++;
- else
+ int localBadCount = 0;
+ for (int k = 0; k < knn; k++)
{
- int localBadCount = 0;
- for (int k = 0; k < knn; k++)
+ cv::DMatch match = matches[i][k];
{
- cv::DMatch match = matches[i][k];
+ if ((int)i < queryDescCount / 2)
{
- if ((int)i < queryDescCount / 2)
- {
- if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
- localBadCount++;
- }
- else
- {
- if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
- localBadCount++;
- }
+ if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+ localBadCount++;
+ }
+ else
+ {
+ if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+ localBadCount++;
}
}
- badCount += localBadCount > 0 ? 1 : 0;
}
+ badCount += localBadCount > 0 ? 1 : 0;
}
-
- ASSERT_EQ(0, badCount);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
}
+
+ ASSERT_EQ(0, badCount);
}
TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
{
- try
- {
- cv::gpu::BFMatcher_GPU matcher(normCode);
+ cv::gpu::BFMatcher_GPU matcher(normCode);
- const int knn = 3;
+ const int knn = 3;
- cv::gpu::GpuMat d_train(train);
+ cv::gpu::GpuMat d_train(train);
- // make add() twice to test such case
- matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
- matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+ // make add() twice to test such case
+ matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+ matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
- // prepare masks (make first nearest match illegal)
- std::vector<cv::gpu::GpuMat> masks(2);
- for (int mi = 0; mi < 2; mi++ )
- {
- masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
- for (int di = 0; di < queryDescCount / 2; di++)
- masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
- }
+ // prepare masks (make first nearest match illegal)
+ std::vector<cv::gpu::GpuMat> masks(2);
+ for (int mi = 0; mi < 2; mi++ )
+ {
+ masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+ for (int di = 0; di < queryDescCount / 2; di++)
+ masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+ }
- std::vector< std::vector<cv::DMatch> > matches;
+ std::vector< std::vector<cv::DMatch> > matches;
- if (useMask)
- matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
- else
- matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
+ if (useMask)
+ matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+ else
+ matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
- ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+ ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
- int badCount = 0;
- int shift = useMask ? 1 : 0;
- for (size_t i = 0; i < matches.size(); i++)
+ int badCount = 0;
+ int shift = useMask ? 1 : 0;
+ for (size_t i = 0; i < matches.size(); i++)
+ {
+ if ((int)matches[i].size() != knn)
+ badCount++;
+ else
{
- if ((int)matches[i].size() != knn)
- badCount++;
- else
+ int localBadCount = 0;
+ for (int k = 0; k < knn; k++)
{
- int localBadCount = 0;
- for (int k = 0; k < knn; k++)
+ cv::DMatch match = matches[i][k];
{
- cv::DMatch match = matches[i][k];
+ if ((int)i < queryDescCount / 2)
{
- if ((int)i < queryDescCount / 2)
- {
- if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
- localBadCount++;
- }
- else
- {
- if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
- localBadCount++;
- }
+ if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+ localBadCount++;
+ }
+ else
+ {
+ if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+ localBadCount++;
}
}
- badCount += localBadCount > 0 ? 1 : 0;
}
+ badCount += localBadCount > 0 ? 1 : 0;
}
-
- ASSERT_EQ(0, badCount);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
}
+
+ ASSERT_EQ(0, badCount);
}
TEST_P(BruteForceMatcher, RadiusMatch_Single)
{
- try
- {
- cv::gpu::BFMatcher_GPU matcher(normCode);
+ cv::gpu::BFMatcher_GPU matcher(normCode);
- const float radius = 1.f / countFactor;
+ const float radius = 1.f / countFactor;
- if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+ if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+ {
+ try
{
- try
- {
- std::vector< std::vector<cv::DMatch> > matches;
- matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsNotImplemented, e.code);
- }
+ std::vector< std::vector<cv::DMatch> > matches;
+ matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat mask;
- if (useMask)
- {
- mask.create(query.rows, train.rows, CV_8UC1);
- mask.setTo(cv::Scalar::all(1));
- }
+ ASSERT_EQ(CV_StsNotImplemented, e.code);
+ }
+ }
+ else
+ {
+ cv::gpu::GpuMat mask;
+ if (useMask)
+ {
+ mask.create(query.rows, train.rows, CV_8UC1);
+ mask.setTo(cv::Scalar::all(1));
+ }
- std::vector< std::vector<cv::DMatch> > matches;
- matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask);
+ std::vector< std::vector<cv::DMatch> > matches;
+ matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask);
- ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+ ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
- int badCount = 0;
- for (size_t i = 0; i < matches.size(); i++)
+ int badCount = 0;
+ for (size_t i = 0; i < matches.size(); i++)
+ {
+ if ((int)matches[i].size() != 1)
+ badCount++;
+ else
{
- if ((int)matches[i].size() != 1)
+ cv::DMatch match = matches[i][0];
+ if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
badCount++;
- else
- {
- cv::DMatch match = matches[i][0];
- if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
- badCount++;
- }
}
-
- ASSERT_EQ(0, badCount);
}
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+
+ ASSERT_EQ(0, badCount);
}
}
TEST_P(BruteForceMatcher, RadiusMatch_Collection)
{
- try
- {
- cv::gpu::BFMatcher_GPU matcher(normCode);
+ cv::gpu::BFMatcher_GPU matcher(normCode);
- const int n = 3;
- const float radius = 1.f / countFactor * n;
+ const int n = 3;
+ const float radius = 1.f / countFactor * n;
- cv::gpu::GpuMat d_train(train);
+ cv::gpu::GpuMat d_train(train);
- // make add() twice to test such case
- matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
- matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+ // make add() twice to test such case
+ matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+ matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
- // prepare masks (make first nearest match illegal)
- std::vector<cv::gpu::GpuMat> masks(2);
- for (int mi = 0; mi < 2; mi++)
+ // prepare masks (make first nearest match illegal)
+ std::vector<cv::gpu::GpuMat> masks(2);
+ for (int mi = 0; mi < 2; mi++)
+ {
+ masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+ for (int di = 0; di < queryDescCount / 2; di++)
+ masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+ }
+
+ if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+ {
+ try
{
- masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
- for (int di = 0; di < queryDescCount / 2; di++)
- masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+ 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)
ASSERT_EQ(0, badCount);
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
TEST_P(Blur, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor);
- cv::Mat dst_gold;
- cv::blur(src, dst_gold, ksize, anchor);
+ cv::Mat dst_gold;
+ cv::blur(src, dst_gold, ksize, anchor);
- EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
if (dx == 0 && dy == 0)
return;
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType);
- cv::Mat dst_gold;
- cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
+ cv::Mat dst_gold;
+ cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
- EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
if (dx + dy != 1)
return;
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType);
- cv::Mat dst_gold;
- cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
+ cv::Mat dst_gold;
+ cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
- EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
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);
+ cv::Mat src = randomMat(size, type);
+ double sigma1 = randomDouble(0.1, 1.0);
+ double sigma2 = randomDouble(0.1, 1.0);
- if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+ if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat dst;
- cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsNotImplemented, e.code);
- }
+ cv::gpu::GpuMat dst;
+ cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType);
-
- cv::Mat dst_gold;
- cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
+ ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType);
+
+ cv::Mat dst_gold;
+ cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
}
}
TEST_P(Laplacian, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width);
- cv::Mat dst_gold;
- cv::Laplacian(src, dst_gold, -1, ksize.width);
+ cv::Mat dst_gold;
+ cv::Laplacian(src, dst_gold, -1, ksize.width);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine(
TEST_P(Erode, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations);
- cv::Mat dst_gold;
- cv::erode(src, dst_gold, kernel, anchor, iterations);
+ cv::Mat dst_gold;
+ cv::erode(src, dst_gold, kernel, anchor, iterations);
- cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
+ cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
- EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Erode, testing::Combine(
TEST_P(Dilate, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations);
- cv::Mat dst_gold;
- cv::dilate(src, dst_gold, kernel, anchor, iterations);
+ cv::Mat dst_gold;
+ cv::dilate(src, dst_gold, kernel, anchor, iterations);
- cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
+ cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
- EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Dilate, testing::Combine(
TEST_P(MorphEx, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations);
- cv::Mat dst_gold;
- cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations);
+ cv::Mat dst_gold;
+ cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations);
- cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
+ cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
- EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, MorphEx, testing::Combine(
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);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType);
- cv::Mat dst_gold;
- cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
+ cv::Mat dst_gold;
+ cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
- EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
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);
- src0.at<Point2f>(0,2) = Point2f(0,2);
+ Mat src0(1, 3, CV_32FC2);
+ src0.at<Point2f>(0,0) = Point2f(0,0);
+ src0.at<Point2f>(0,1) = Point2f(0,1);
+ src0.at<Point2f>(0,2) = Point2f(0,2);
- Mat src1(1, 3, CV_32FC2);
-
src1.at<Point2f>(0,0) = Point2f(1,0);
-
src1.at<Point2f>(0,1) = Point2f(1,1);
-
src1.at<Point2f>(0,2) = Point2f(1,2);
+ Mat src1(1, 3, CV_32FC2);
+ src1.at<Point2f>(0,0) = Point2f(1,0);
+ src1.at<Point2f>(0,1) = Point2f(1,1);
+ src1.at<Point2f>(0,2) = Point2f(1,2);
- Mat mask(1, 3, CV_8U);
- mask.at<uchar>(0,0) = 1;
- mask.at<uchar>(0,1) = 0;
- mask.at<uchar>(0,2) = 1;
+ Mat mask(1, 3, CV_8U);
+ mask.at<uchar>(0,0) = 1;
+ mask.at<uchar>(0,1) = 0;
+ mask.at<uchar>(0,2) = 1;
- gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask);
- gpu::compactPoints(dsrc0, dsrc1, dmask);
+ gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask);
+ gpu::compactPoints(dsrc0, dsrc1, dmask);
- dsrc0.download(src0);
- dsrc1.download(src1);
+ dsrc0.download(src0);
+ dsrc1.download(src1);
- ASSERT_EQ(2, src0.cols);
- ASSERT_EQ(2, src1.cols);
+ ASSERT_EQ(2, src0.cols);
+ ASSERT_EQ(2, src1.cols);
-
ASSERT_TRUE(src0.at<Point2f>(0,0) == Point2f(0,0));
-
ASSERT_TRUE(src0.at<Point2f>(0,1) == Point2f(0,2));
+ ASSERT_TRUE(src0.at<Point2f>(0,0) == Point2f(0,0));
+ ASSERT_TRUE(src0.at<Point2f>(0,1) == Point2f(0,2));
- 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;
- }
+ ASSERT_TRUE(src1.at<Point2f>(0,0) == Point2f(1,0));
+ ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
}
INSTANTIATE_TEST_CASE_P(GPU_GlobalMotion, CompactPoints, ALL_DEVICES);
TEST_P(SetTo, Zero)
{
- try
- {
- cv::Scalar zero = cv::Scalar::all(0);
+ cv::Scalar zero = cv::Scalar::all(0);
- cv::gpu::GpuMat mat = createMat(size, type, useRoi);
- mat.setTo(zero);
+ cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+ mat.setTo(zero);
- EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
}
TEST_P(SetTo, SameVal)
{
- try
- {
- cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
+ cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
- if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat mat = createMat(size, type, useRoi);
- mat.setTo(val);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
- }
- else
+ if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
cv::gpu::GpuMat mat = createMat(size, type, useRoi);
mat.setTo(val);
-
- EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+ mat.setTo(val);
+
+ EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
}
}
TEST_P(SetTo, DifferentVal)
{
- try
- {
- cv::Scalar val = randomScalar(0.0, 255.0);
+ cv::Scalar val = randomScalar(0.0, 255.0);
- if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
- {
- try
- {
- cv::gpu::GpuMat mat = createMat(size, type, useRoi);
- mat.setTo(val);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
- }
- else
+ if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
cv::gpu::GpuMat mat = createMat(size, type, useRoi);
mat.setTo(val);
-
- EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+ }
+ catch (const cv::Exception& e)
+ {
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+ mat.setTo(val);
+
+ EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
}
}
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);
+ cv::Scalar val = randomScalar(0.0, 255.0);
+ cv::Mat mat_gold = randomMat(size, type);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
- if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat mat = createMat(size, type, useRoi);
- mat.setTo(val, loadMat(mask));
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+ mat.setTo(val, loadMat(mask));
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
- mat.setTo(val, loadMat(mask, useRoi));
-
- mat_gold.setTo(val, mask);
-
- EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
+ mat.setTo(val, loadMat(mask, useRoi));
+
+ mat_gold.setTo(val, mask);
+
+ EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
}
}
TEST_P(CopyTo, WithOutMask)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat d_src = loadMat(src, useRoi);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- d_src.copyTo(dst);
+ cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ d_src.copyTo(dst);
- EXPECT_MAT_NEAR(src, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(src, dst, 0.0);
}
TEST_P(CopyTo, Masked)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
- if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat d_src = loadMat(src);
- cv::gpu::GpuMat dst;
- d_src.copyTo(dst, loadMat(mask, useRoi));
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat d_src = loadMat(src);
+ cv::gpu::GpuMat dst;
+ d_src.copyTo(dst, loadMat(mask, useRoi));
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat d_src = loadMat(src, useRoi);
- cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
- d_src.copyTo(dst, loadMat(mask, useRoi));
-
- cv::Mat dst_gold = cv::Mat::zeros(size, type);
- src.copyTo(dst_gold, mask);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+ cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
+ d_src.copyTo(dst, loadMat(mask, useRoi));
+
+ cv::Mat dst_gold = cv::Mat::zeros(size, type);
+ src.copyTo(dst_gold, mask);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
TEST_P(ConvertTo, WithOutScaling)
{
- try
- {
- cv::Mat src = randomMat(size, depth1);
+ cv::Mat src = randomMat(size, depth1);
- if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat d_src = loadMat(src);
- cv::gpu::GpuMat dst;
- d_src.convertTo(dst, depth2);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat d_src = loadMat(src);
+ cv::gpu::GpuMat dst;
+ d_src.convertTo(dst, depth2);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat d_src = loadMat(src, useRoi);
- cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
- d_src.convertTo(dst, depth2);
-
- cv::Mat dst_gold;
- src.convertTo(dst_gold, depth2);
-
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+ cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+ d_src.convertTo(dst, depth2);
+
+ cv::Mat dst_gold;
+ src.convertTo(dst_gold, depth2);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
}
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);
+ cv::Mat src = randomMat(size, depth1);
+ double a = randomDouble(0.0, 1.0);
+ double b = randomDouble(-10.0, 10.0);
- if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat d_src = loadMat(src);
- cv::gpu::GpuMat dst;
- d_src.convertTo(dst, depth2, a, b);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
- }
+ cv::gpu::GpuMat d_src = loadMat(src);
+ cv::gpu::GpuMat dst;
+ d_src.convertTo(dst, depth2, a, b);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat d_src = loadMat(src, useRoi);
- cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
- d_src.convertTo(dst, depth2, a, b);
-
- cv::Mat dst_gold;
- src.convertTo(dst_gold, depth2, a, b);
-
- EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
+ ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+ cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+ d_src.convertTo(dst, depth2, a, b);
+
+ cv::Mat dst_gold;
+ src.convertTo(dst_gold, depth2, a, b);
+
+ EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
}
}
TEST_P(EnsureSizeIsEnough, BufferReuse)
{
- try
- {
- cv::gpu::GpuMat buffer(100, 100, CV_8U);
- cv::gpu::GpuMat old = buffer;
-
- // don't reallocate memory
- cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
- EXPECT_EQ(10, buffer.rows);
- EXPECT_EQ(20, buffer.cols);
- EXPECT_EQ(CV_8UC1, buffer.type());
- EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
-
- // don't reallocate memory
- cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
- EXPECT_EQ(20, buffer.rows);
- EXPECT_EQ(30, buffer.cols);
- EXPECT_EQ(CV_8UC1, buffer.type());
- EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ cv::gpu::GpuMat buffer(100, 100, CV_8U);
+ cv::gpu::GpuMat old = buffer;
+
+ // don't reallocate memory
+ cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
+ EXPECT_EQ(10, buffer.rows);
+ EXPECT_EQ(20, buffer.cols);
+ EXPECT_EQ(CV_8UC1, buffer.type());
+ EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
+
+ // don't reallocate memory
+ cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
+ EXPECT_EQ(20, buffer.rows);
+ EXPECT_EQ(30, buffer.cols);
+ EXPECT_EQ(CV_8UC1, buffer.type());
+ EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
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);
- const bool useRoi = GET_PARAM(2);
+ const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+ cv::gpu::setDevice(devInfo.deviceID());
+ const cv::Size size = GET_PARAM(1);
+ const bool useRoi = GET_PARAM(2);
- const float rho = 1.0f;
- const float theta = (float) (1.5 * CV_PI / 180.0);
- const int threshold = 100;
+ const float rho = 1.0f;
+ const float theta = (float) (1.5 * CV_PI / 180.0);
+ onst int threshold = 100;
- cv::Mat src(size, CV_8UC1);
- generateLines(src);
+ cv::Mat src(size, CV_8UC1);
+ generateLines(src);
- cv::gpu::GpuMat d_lines;
- cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold);
+ cv::gpu::GpuMat d_lines;
+ cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold);
- std::vector<cv::Vec2f> lines;
- cv::gpu::HoughLinesDownload(d_lines, lines);
+ std::vector<cv::Vec2f> lines;
+ cv::gpu::HoughLinesDownload(d_lines, lines);
- cv::Mat dst(size, CV_8UC1);
- drawLines(dst, lines);
+ cv::Mat dst(size, CV_8UC1);
+ drawLines(dst, lines);
- ASSERT_MAT_NEAR(src, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_MAT_NEAR(src, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughLines, testing::Combine(
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);
- const bool useRoi = GET_PARAM(2);
+ const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+ cv::gpu::setDevice(devInfo.deviceID());
+ const cv::Size size = GET_PARAM(1);
+ const bool useRoi = GET_PARAM(2);
- const float dp = 2.0f;
- const float minDist = 10.0f;
- const int minRadius = 10;
- const int maxRadius = 20;
- const int cannyThreshold = 100;
- const int votesThreshold = 20;
+ const float dp = 2.0f;
+ const float minDist = 10.0f;
+ const int minRadius = 10;
+ const int maxRadius = 20;
+ const int cannyThreshold = 100;
+ const int votesThreshold = 20;
- std::vector<cv::Vec3f> circles_gold(4);
- circles_gold[0] = cv::Vec3i(20, 20, minRadius);
- circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3);
- circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8);
- circles_gold[3] = cv::Vec3i(80, 10, maxRadius);
+ std::vector<cv::Vec3f> circles_gold(4);
+ circles_gold[0] = cv::Vec3i(20, 20, minRadius);
+ circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3);
+ circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8);
+ circles_gold[3] = cv::Vec3i(80, 10, maxRadius);
- cv::Mat src(size, CV_8UC1);
- drawCircles(src, circles_gold, true);
+ cv::Mat src(size, CV_8UC1);
+ drawCircles(src, circles_gold, true);
- cv::gpu::GpuMat d_circles;
- cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+ cv::gpu::GpuMat d_circles;
+ cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
- std::vector<cv::Vec3f> circles;
- cv::gpu::HoughCirclesDownload(d_circles, circles);
+ std::vector<cv::Vec3f> circles;
+ cv::gpu::HoughCirclesDownload(d_circles, circles);
- ASSERT_FALSE(circles.empty());
+ ASSERT_FALSE(circles.empty());
- for (size_t i = 0; i < circles.size(); ++i)
- {
- cv::Vec3f cur = circles[i];
+ for (size_t i = 0; i < circles.size(); ++i)
+ {
+ cv::Vec3f cur = circles[i];
- bool found = false;
+ bool found = false;
- for (size_t j = 0; j < circles_gold.size(); ++j)
- {
- cv::Vec3f gold = circles_gold[j];
+ for (size_t j = 0; j < circles_gold.size(); ++j)
+ {
+ cv::Vec3f gold = circles_gold[j];
- if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist)
- {
- found = true;
- break;
- }
+ if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist)
+ {
+ found = true;
+ break;
}
-
- ASSERT_TRUE(found);
}
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+
+ ASSERT_TRUE(found);
}
}
TEST_P(GeneralizedHough, POSITION)
{
- try
- {
- const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
- cv::gpu::setDevice(devInfo.deviceID());
- const bool useRoi = GET_PARAM(1);
+ const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+ cv::gpu::setDevice(devInfo.deviceID());
+ const bool useRoi = GET_PARAM(1);
- cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(templ.empty());
+ cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(templ.empty());
- cv::Point templCenter(templ.cols / 2, templ.rows / 2);
+ cv::Point templCenter(templ.cols / 2, templ.rows / 2);
- const size_t gold_count = 3;
- cv::Point pos_gold[gold_count];
- pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10);
- pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10);
- pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40);
+ const size_t gold_count = 3;
+ cv::Point pos_gold[gold_count];
+ pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10);
+ pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10);
+ pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40);
- cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0));
- for (size_t i = 0; i < gold_count; ++i)
- {
- cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows);
- cv::Mat imageROI = image(rec);
- templ.copyTo(imageROI);
- }
+ cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0));
+ for (size_t i = 0; i < gold_count; ++i)
+ {
+ cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows);
+ cv::Mat imageROI = image(rec);
+ templ.copyTo(imageROI);
+ }
- cv::Ptr<cv::gpu::GeneralizedHough_GPU> hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION);
- hough->set("votesThreshold", 200);
+ cv::Ptr<cv::gpu::GeneralizedHough_GPU> hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION);
+ hough->set("votesThreshold", 200);
- hough->setTemplate(loadMat(templ, useRoi));
+ hough->setTemplate(loadMat(templ, useRoi));
- cv::gpu::GpuMat d_pos;
- hough->detect(loadMat(image, useRoi), d_pos);
+ cv::gpu::GpuMat d_pos;
+ hough->detect(loadMat(image, useRoi), d_pos);
- std::vector<cv::Vec4f> pos;
- hough->download(d_pos, pos);
+ std::vector<cv::Vec4f> pos;
+ hough->download(d_pos, pos);
- ASSERT_EQ(gold_count, pos.size());
+ ASSERT_EQ(gold_count, pos.size());
- for (size_t i = 0; i < gold_count; ++i)
- {
- cv::Point gold = pos_gold[i];
+ for (size_t i = 0; i < gold_count; ++i)
+ {
+ cv::Point gold = pos_gold[i];
- bool found = false;
+ bool found = false;
- for (size_t j = 0; j < pos.size(); ++j)
- {
- cv::Point2f p(pos[j][0], pos[j][1]);
+ for (size_t j = 0; j < pos.size(); ++j)
+ {
+ cv::Point2f p(pos[j][0], pos[j][1]);
- if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2)
- {
- found = true;
- break;
- }
+ if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2)
+ {
+ found = true;
+ break;
}
-
- ASSERT_TRUE(found);
}
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+
+ ASSERT_TRUE(found);
}
}
TEST_P(Integral, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, CV_8UC1);
+ cv::Mat src = randomMat(size, CV_8UC1);
- cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
- cv::gpu::integral(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
+ cv::gpu::integral(loadMat(src, useRoi), dst);
- cv::Mat dst_gold;
- cv::integral(src, dst_gold, CV_32S);
+ cv::Mat dst_gold;
+ cv::integral(src, dst_gold, CV_32S);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine(
TEST_P(HistEven, Accuracy)
{
- try
- {
- cv::Mat img = readImage("stereobm/aloe-L.png");
- ASSERT_FALSE(img.empty());
+ cv::Mat img = readImage("stereobm/aloe-L.png");
+ ASSERT_FALSE(img.empty());
- cv::Mat hsv;
- cv::cvtColor(img, hsv, CV_BGR2HSV);
+ cv::Mat hsv;
+ cv::cvtColor(img, hsv, CV_BGR2HSV);
- int hbins = 30;
- float hranges[] = {0.0f, 180.0f};
+ int hbins = 30;
+ float hranges[] = {0.0f, 180.0f};
- std::vector<cv::gpu::GpuMat> srcs;
- cv::gpu::split(loadMat(hsv), srcs);
+ std::vector<cv::gpu::GpuMat> srcs;
+ cv::gpu::split(loadMat(hsv), srcs);
- cv::gpu::GpuMat hist;
- cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);
+ cv::gpu::GpuMat hist;
+ cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);
- cv::MatND histnd;
- int histSize[] = {hbins};
- const float* ranges[] = {hranges};
- int channels[] = {0};
- cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
+ cv::MatND histnd;
+ int histSize[] = {hbins};
+ const float* ranges[] = {hranges};
+ int channels[] = {0};
+ cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
- cv::Mat hist_gold = histnd;
- hist_gold = hist_gold.t();
- hist_gold.convertTo(hist_gold, CV_32S);
+ cv::Mat hist_gold = histnd;
+ hist_gold = hist_gold.t();
+ hist_gold.convertTo(hist_gold, CV_32S);
- EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);
TEST_P(CalcHist, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, CV_8UC1);
+ cv::Mat src = randomMat(size, CV_8UC1);
- cv::gpu::GpuMat hist;
- cv::gpu::calcHist(loadMat(src), hist);
+ cv::gpu::GpuMat hist;
+ cv::gpu::calcHist(loadMat(src), hist);
- cv::Mat hist_gold;
- calcHistGold(src, hist_gold);
+ cv::Mat hist_gold;
+ calcHistGold(src, hist_gold);
- EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine(
TEST_P(EqualizeHist, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, CV_8UC1);
+ cv::Mat src = randomMat(size, CV_8UC1);
- cv::gpu::GpuMat dst;
- cv::gpu::equalizeHist(loadMat(src), dst);
+ cv::gpu::GpuMat dst;
+ cv::gpu::equalizeHist(loadMat(src), dst);
- cv::Mat dst_gold;
- cv::equalizeHist(src, dst_gold);
+ cv::Mat dst_gold;
+ cv::equalizeHist(src, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine(
TEST_P(ColumnSum, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, CV_32FC1);
+ cv::Mat src = randomMat(size, CV_32FC1);
- cv::gpu::GpuMat d_dst;
- cv::gpu::columnSum(loadMat(src), d_dst);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::columnSum(loadMat(src), d_dst);
- cv::Mat dst(d_dst);
+ cv::Mat dst(d_dst);
+
+ for (int j = 0; j < src.cols; ++j)
+ {
+ float gold = src.at<float>(0, j);
+ float res = dst.at<float>(0, j);
+ ASSERT_NEAR(res, gold, 1e-5);
+ }
+ for (int i = 1; i < src.rows; ++i)
+ {
for (int j = 0; j < src.cols; ++j)
{
- float gold = src.at<float>(0, j);
- float res = dst.at<float>(0, j);
+ float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
+ float res = dst.at<float>(i, j);
ASSERT_NEAR(res, gold, 1e-5);
}
-
- for (int i = 1; i < src.rows; ++i)
- {
- for (int j = 0; j < src.cols; ++j)
- {
- float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
- float res = dst.at<float>(i, j);
- ASSERT_NEAR(res, gold, 1e-5);
- }
- }
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
}
}
TEST_P(Canny, Accuracy)
{
- try
- {
- cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(img.empty());
+ cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(img.empty());
- double low_thresh = 50.0;
- double high_thresh = 100.0;
+ double low_thresh = 50.0;
+ double high_thresh = 100.0;
- if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))
+ if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))
+ {
+ try
{
- try
- {
- cv::gpu::GpuMat edges;
- cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
- }
- catch (const cv::Exception& e)
- {
- ASSERT_EQ(CV_StsNotImplemented, e.code);
- }
+ cv::gpu::GpuMat edges;
+ cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
}
- else
+ catch (const cv::Exception& e)
{
- cv::gpu::GpuMat edges;
- cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
-
- cv::Mat edges_gold;
- cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
-
- EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
+ ASSERT_EQ(CV_StsNotImplemented, e.code);
}
}
- catch (...)
+ else
{
- cv::gpu::resetDevice();
- throw;
+ cv::gpu::GpuMat edges;
+ cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
+
+ cv::Mat edges_gold;
+ cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
+
+ EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
}
}
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");
- else
- img_template = readImage("meanshift/con_result_CC1X.png");
- ASSERT_FALSE(img_template.empty());
+ cv::Mat img_template;
+ if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+ img_template = readImage("meanshift/con_result.png");
+ else
+ img_template = readImage("meanshift/con_result_CC1X.png");
+ ASSERT_FALSE(img_template.empty());
- cv::gpu::GpuMat d_dst;
- cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);
- ASSERT_EQ(CV_8UC4, d_dst.type());
+ ASSERT_EQ(CV_8UC4, d_dst.type());
- cv::Mat dst(d_dst);
+ cv::Mat dst(d_dst);
- cv::Mat result;
- cv::cvtColor(dst, result, CV_BGRA2BGR);
+ cv::Mat result;
+ cv::cvtColor(dst, result, CV_BGRA2BGR);
- EXPECT_MAT_NEAR(img_template, result, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(img_template, result, 0.0);
}
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);
- else
- fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::FileStorage fs;
+ if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+ fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
+ else
+ fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- cv::Mat spmap_template;
- fs["spmap"] >> spmap_template;
- ASSERT_FALSE(spmap_template.empty());
+ cv::Mat spmap_template;
+ fs["spmap"] >> spmap_template;
+ ASSERT_FALSE(spmap_template.empty());
- cv::gpu::GpuMat rmap_filtered;
- cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);
+ cv::gpu::GpuMat rmap_filtered;
+ cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);
- cv::gpu::GpuMat rmap;
- cv::gpu::GpuMat spmap;
- cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);
+ cv::gpu::GpuMat rmap;
+ cv::gpu::GpuMat spmap;
+ cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);
- ASSERT_EQ(CV_8UC4, rmap.type());
+ ASSERT_EQ(CV_8UC4, rmap.type());
- EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
- EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
+ EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShift, ALL_DEVICES);
TEST_P(MeanShiftSegmentation, Regression)
{
- try
- {
- cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
- ASSERT_FALSE(img.empty());
+ cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
+ ASSERT_FALSE(img.empty());
- std::ostringstream path;
- path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
- if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
- path << ".png";
- else
- path << "_CC1X.png";
- cv::Mat dst_gold = readImage(path.str());
- ASSERT_FALSE(dst_gold.empty());
+ std::ostringstream path;
+ path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
+ if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+ path << ".png";
+ else
+ path << "_CC1X.png";
+ cv::Mat dst_gold = readImage(path.str());
+ ASSERT_FALSE(dst_gold.empty());
- cv::Mat dst;
- cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
+ cv::Mat dst;
+ cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
- cv::Mat dst_rgb;
- cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
+ cv::Mat dst_rgb;
+ cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
- EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(
TEST_P(Blend, Accuracy)
{
- try
- {
- int depth = CV_MAT_DEPTH(type);
+ int depth = CV_MAT_DEPTH(type);
- cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
- cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
- cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
- cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
+ cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
+ cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
+ cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
+ cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
- cv::gpu::GpuMat result;
- cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);
+ cv::gpu::GpuMat result;
+ cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);
- cv::Mat result_gold;
- if (depth == CV_8U)
- blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
- else
- blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
+ cv::Mat result_gold;
+ if (depth == CV_8U)
+ blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
+ else
+ 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;
- }
+ EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(
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);
+ cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
+ cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
- cv::gpu::GpuMat dst;
- cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
+ cv::gpu::GpuMat dst;
+ cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
- cv::Mat dst_gold;
- convolveDFT(src, kernel, dst_gold, ccorr);
+ cv::Mat dst_gold;
+ convolveDFT(src, kernel, dst_gold, ccorr);
- EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
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));
+ cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
+ cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
- cv::gpu::GpuMat dst;
- cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
+ cv::gpu::GpuMat dst;
+ cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
- cv::Mat dst_gold;
- cv::matchTemplate(image, templ, dst_gold, method);
+ cv::Mat dst_gold;
+ cv::matchTemplate(image, templ, dst_gold, method);
- EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, testing::Combine(
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));
+ cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
+ cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
- cv::gpu::GpuMat dst;
- cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
+ cv::gpu::GpuMat dst;
+ cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
- cv::Mat dst_gold;
- cv::matchTemplate(image, templ, dst_gold, method);
+ cv::Mat dst_gold;
+ cv::matchTemplate(image, templ, dst_gold, method);
- EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate32F, testing::Combine(
TEST_P(MatchTemplateBlackSource, Accuracy)
{
- try
- {
- cv::Mat image = readImage("matchtemplate/black.png");
- ASSERT_FALSE(image.empty());
+ cv::Mat image = readImage("matchtemplate/black.png");
+ ASSERT_FALSE(image.empty());
- cv::Mat pattern = readImage("matchtemplate/cat.png");
- ASSERT_FALSE(pattern.empty());
+ cv::Mat pattern = readImage("matchtemplate/cat.png");
+ ASSERT_FALSE(pattern.empty());
- cv::gpu::GpuMat d_dst;
- cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);
- cv::Mat dst(d_dst);
+ cv::Mat dst(d_dst);
- double maxValue;
- cv::Point maxLoc;
- cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
+ double maxValue;
+ cv::Point maxLoc;
+ cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
- cv::Point maxLocGold = cv::Point(284, 12);
+ cv::Point maxLocGold = cv::Point(284, 12);
- ASSERT_EQ(maxLocGold, maxLoc);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_EQ(maxLocGold, maxLoc);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine(
TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
{
- try
- {
- cv::Mat image = readImage(imageName);
- ASSERT_FALSE(image.empty());
+ cv::Mat image = readImage(imageName);
+ ASSERT_FALSE(image.empty());
- cv::Mat pattern = readImage(patternName);
- ASSERT_FALSE(pattern.empty());
+ cv::Mat pattern = readImage(patternName);
+ ASSERT_FALSE(pattern.empty());
- cv::gpu::GpuMat d_dst;
- cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
+ cv::gpu::GpuMat d_dst;
+ cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
- cv::Mat dst(d_dst);
+ cv::Mat dst(d_dst);
- cv::Point minLoc, maxLoc;
- double minVal, maxVal;
- cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
+ cv::Point minLoc, maxLoc;
+ double minVal, maxVal;
+ cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
- cv::Mat dstGold;
- cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
+ cv::Mat dstGold;
+ cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
- double minValGold, maxValGold;
- cv::Point minLocGold, maxLocGold;
- cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);
+ double minValGold, maxValGold;
+ cv::Point minLocGold, maxLocGold;
+ cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);
- ASSERT_EQ(minLocGold, minLoc);
- ASSERT_EQ(maxLocGold, maxLoc);
- ASSERT_LE(maxVal, 1.0);
- ASSERT_GE(minVal, -1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_EQ(minLocGold, minLoc);
+ ASSERT_EQ(maxLocGold, maxLoc);
+ ASSERT_LE(maxVal, 1.0);
+ ASSERT_GE(minVal, -1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CCOEF_NORMED, testing::Combine(
TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
{
- try
- {
- cv::Mat scene = readImage("matchtemplate/scene.png");
- ASSERT_FALSE(scene.empty());
+ cv::Mat scene = readImage("matchtemplate/scene.png");
+ ASSERT_FALSE(scene.empty());
- cv::Mat templ = readImage("matchtemplate/template.png");
- ASSERT_FALSE(templ.empty());
+ cv::Mat templ = readImage("matchtemplate/template.png");
+ ASSERT_FALSE(templ.empty());
- cv::gpu::GpuMat d_result;
- cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
+ cv::gpu::GpuMat d_result;
+ cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
- cv::Mat result(d_result);
+ cv::Mat result(d_result);
- double minVal;
- cv::Point minLoc;
- cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
+ double minVal;
+ cv::Point minLoc;
+ cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
- ASSERT_GE(minVal, 0);
- ASSERT_LT(minVal, 1e-3);
- ASSERT_EQ(344, minLoc.x);
- ASSERT_EQ(0, minLoc.y);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_GE(minVal, 0);
+ ASSERT_LT(minVal, 1e-3);
+ ASSERT_EQ(344, minLoc.x);
+ ASSERT_EQ(0, minLoc.y);
}
TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
{
- try
- {
- cv::Mat scene = readImage("matchtemplate/scene.png");
- ASSERT_FALSE(scene.empty());
+ cv::Mat scene = readImage("matchtemplate/scene.png");
+ ASSERT_FALSE(scene.empty());
- cv::Mat templ = readImage("matchtemplate/template.png");
- ASSERT_FALSE(templ.empty());
+ cv::Mat templ = readImage("matchtemplate/template.png");
+ ASSERT_FALSE(templ.empty());
- cv::gpu::GpuMat d_result;
- cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
+ cv::gpu::GpuMat d_result;
+ cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
- cv::Mat result(d_result);
+ cv::Mat result(d_result);
- double minVal;
- cv::Point minLoc;
- cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
+ double minVal;
+ cv::Point minLoc;
+ cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
- ASSERT_GE(minVal, 0);
- ASSERT_EQ(344, minLoc.x);
- ASSERT_EQ(0, minLoc.y);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_GE(minVal, 0);
+ ASSERT_EQ(344, minLoc.x);
+ ASSERT_EQ(0, minLoc.y);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CanFindBigTemplate, ALL_DEVICES);
TEST_P(MulSpectrums, Simple)
{
- try
- {
- cv::gpu::GpuMat c;
- cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
+ cv::gpu::GpuMat c;
+ cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
- cv::Mat c_gold;
- cv::mulSpectrums(a, b, c_gold, flag, false);
+ cv::Mat c_gold;
+ cv::mulSpectrums(a, b, c_gold, flag, false);
- EXPECT_MAT_NEAR(c_gold, c, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(c_gold, c, 1e-2);
}
TEST_P(MulSpectrums, Scaled)
{
- try
- {
- float scale = 1.f / size.area();
+ float scale = 1.f / size.area();
- cv::gpu::GpuMat c;
- cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
+ cv::gpu::GpuMat c;
+ cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
- cv::Mat c_gold;
- cv::mulSpectrums(a, b, c_gold, flag, false);
- c_gold.convertTo(c_gold, c_gold.type(), scale);
+ cv::Mat c_gold;
+ cv::mulSpectrums(a, b, c_gold, flag, false);
+ c_gold.convertTo(c_gold, c_gold.type(), scale);
- EXPECT_MAT_NEAR(c_gold, c, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(c_gold, c, 1e-2);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MulSpectrums, testing::Combine(
TEST_P(Dft, C2C)
{
- try
- {
- int cols = randomInt(2, 100);
- int rows = randomInt(2, 100);
-
- for (int i = 0; i < 2; ++i)
- {
- bool inplace = i != 0;
-
- testC2C("no flags", cols, rows, 0, inplace);
- testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
- testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
- testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
- testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
- testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
- testC2C("single col", 1, rows, 0, inplace);
- testC2C("single row", cols, 1, 0, inplace);
- testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
- testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
- testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
- testC2C("size 1 2", 1, 2, 0, inplace);
- testC2C("size 2 1", 2, 1, 0, inplace);
- }
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ int cols = randomInt(2, 100);
+ int rows = randomInt(2, 100);
+
+ for (int i = 0; i < 2; ++i)
+ {
+ bool inplace = i != 0;
+
+ testC2C("no flags", cols, rows, 0, inplace);
+ testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
+ testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
+ testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
+ testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
+ testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
+ testC2C("single col", 1, rows, 0, inplace);
+ testC2C("single row", cols, 1, 0, inplace);
+ testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
+ testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
+ testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
+ testC2C("size 1 2", 1, 2, 0, inplace);
+ testC2C("size 2 1", 2, 1, 0, inplace);
}
}
TEST_P(Dft, R2CThenC2R)
{
- try
- {
- int cols = randomInt(2, 100);
- int rows = randomInt(2, 100);
-
- testR2CThenC2R("sanity", cols, rows, false);
- testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
- testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
- testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
- testR2CThenC2R("single col", 1, rows, false);
- testR2CThenC2R("single col 1", 1, rows + 1, false);
- testR2CThenC2R("single row", cols, 1, false);
- testR2CThenC2R("single row 1", cols + 1, 1, false);
-
- testR2CThenC2R("sanity", cols, rows, true);
- testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
- testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
- 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;
- }
+ int cols = randomInt(2, 100);
+ int rows = randomInt(2, 100);
+
+ testR2CThenC2R("sanity", cols, rows, false);
+ testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
+ testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
+ testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
+ testR2CThenC2R("single col", 1, rows, false);
+ testR2CThenC2R("single col 1", 1, rows + 1, false);
+ testR2CThenC2R("single row", cols, 1, false);
+ testR2CThenC2R("single row 1", cols + 1, 1, false);
+
+ testR2CThenC2R("sanity", cols, rows, true);
+ testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
+ testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
+ testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
+ testR2CThenC2R("single row", cols, 1, true);
+ testR2CThenC2R("single row 1", cols + 1, 1, true);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Dft, ALL_DEVICES);
TEST_P(CornerHarris, Accuracy)
{
- try
- {
- cv::Mat src = readImageType("stereobm/aloe-L.png", type);
- ASSERT_FALSE(src.empty());
+ cv::Mat src = readImageType("stereobm/aloe-L.png", type);
+ ASSERT_FALSE(src.empty());
- double k = randomDouble(0.1, 0.9);
+ double k = randomDouble(0.1, 0.9);
- cv::gpu::GpuMat dst;
- cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);
- cv::Mat dst_gold;
- cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
+ cv::Mat dst_gold;
+ cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(
TEST_P(CornerMinEigen, Accuracy)
{
- try
- {
- cv::Mat src = readImageType("stereobm/aloe-L.png", type);
- ASSERT_FALSE(src.empty());
+ cv::Mat src = readImageType("stereobm/aloe-L.png", type);
+ ASSERT_FALSE(src.empty());
- cv::gpu::GpuMat dst;
- cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);
+ cv::gpu::GpuMat dst;
+ cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);
- cv::Mat dst_gold;
- cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
+ cv::Mat dst_gold;
+ cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(
TEST_P(Labeling, ConnectedComponents)
{
- try
- {
- cv::Mat image;
- cvtColor(loat_image(), image, CV_BGR2GRAY);
+ cv::Mat image;
+ cvtColor(loat_image(), image, CV_BGR2GRAY);
- cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
+ cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
- ASSERT_TRUE(image.type() == CV_8UC1);
+ ASSERT_TRUE(image.type() == CV_8UC1);
- GreedyLabeling host(image);
- host(host._labels);
+ GreedyLabeling host(image);
+ host(host._labels);
- cv::gpu::GpuMat mask;
- mask.create(image.rows, image.cols, CV_8UC1);
+ cv::gpu::GpuMat mask;
+ mask.create(image.rows, image.cols, CV_8UC1);
- cv::gpu::GpuMat components;
- components.create(image.rows, image.cols, CV_32SC1);
+ cv::gpu::GpuMat components;
+ components.create(image.rows, image.cols, CV_32SC1);
- cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+ cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
- ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+ ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
- host.checkCorrectness(cv::Mat(components));
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ host.checkCorrectness(cv::Mat(components));
}
INSTANTIATE_TEST_CASE_P(ConnectedComponents, Labeling, ALL_DEVICES);
struct NPPST : NVidiaTest {};
struct NCV : NVidiaTest {};
-TEST_P(NPPST, Integral)
-{
- try
- {
- bool res = nvidia_NPPST_Integral_Image(_path, nvidiaTestOutputLevel);
+//TEST_P(NPPST, Integral)
+//{
+// bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
-}
+// ASSERT_TRUE(res);
+//}
TEST_P(NPPST, SquaredIntegral)
{
- try
- {
- bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NPPST, RectStdDev)
{
- try
- {
- bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NPPST, Resize)
{
- try
- {
- bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NPPST, VectorOperations)
{
- try
- {
- bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NPPST, Transpose)
{
- try
- {
- bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NCV, VectorOperations)
{
- try
- {
- bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NCV, HaarCascadeLoader)
{
- try
- {
- bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NCV, HaarCascadeApplication)
{
- try
- {
- bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NCV, HypothesesFiltration)
{
- try
- {
- bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
+ bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
TEST_P(NCV, Visualization)
{
- try
- {
- bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
+ // this functionality doesn't used in gpu module
+ bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
- ASSERT_TRUE(res);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(res);
}
INSTANTIATE_TEST_CASE_P(GPU_NVidia, NPPST, ALL_DEVICES);
}
};
-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
- f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
- ASSERT_TRUE(f.is_open());
- #else
- f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
- ASSERT_TRUE(f.is_open());
- #endif
-
- // Test on color image
- cv::Mat img;
- cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
- testDetect(img);
-
- // Test on gray image
- cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
- testDetect(img);
-
- f.close();
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ cv::Mat img_rgb = readImage("hog/road.png");
+ ASSERT_FALSE(img_rgb.empty());
+
+#ifdef DUMP
+ f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+ ASSERT_TRUE(f.is_open());
+#else
+ f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+ ASSERT_TRUE(f.is_open());
+#endif
+
+ // Test on color image
+ cv::Mat img;
+ cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+ testDetect(img);
+
+ // Test on gray image
+ cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
+ testDetect(img);
+
+ f.close();
}
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());
-
- // Convert to C4
- cv::Mat img;
- cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-
- cv::gpu::GpuMat d_img(img);
-
- // Convert train images into feature vectors (train table)
- cv::gpu::GpuMat descriptors, descriptors_by_cols;
- getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW);
- getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL);
-
- // Check size of the result train table
- wins_per_img_x = 3;
- wins_per_img_y = 2;
- blocks_per_win_x = 7;
- blocks_per_win_y = 15;
- block_hist_size = 36;
- cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
- wins_per_img_x * wins_per_img_y);
- ASSERT_EQ(descr_size_expected, descriptors.size());
-
- // Check both formats of output descriptors are handled correctly
- cv::Mat dr(descriptors);
- cv::Mat dc(descriptors_by_cols);
- for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i)
- {
- const float* l = dr.rowRange(i, i + 1).ptr<float>();
- const float* r = dc.rowRange(i, i + 1).ptr<float>();
- for (int y = 0; y < blocks_per_win_y; ++y)
- for (int x = 0; x < blocks_per_win_x; ++x)
- for (int k = 0; k < block_hist_size; ++k)
- ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
- r[(x * blocks_per_win_y + y) * block_hist_size + k]);
- }
+ // Load image (e.g. train data, composed from windows)
+ cv::Mat img_rgb = readImage("hog/train_data.png");
+ ASSERT_FALSE(img_rgb.empty());
- /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
- be defferent, due to border values interpolation. Using of many small images is slower, however we
- wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
- works good, it can be checked in the gpu_hog sample */
-
- img_rgb = readImage("hog/positive1.png");
- ASSERT_TRUE(!img_rgb.empty());
- cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
- computeBlockHistograms(cv::gpu::GpuMat(img));
- // Everything is fine with interpolation for left top subimage
- ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
-
- img_rgb = readImage("hog/positive2.png");
- ASSERT_TRUE(!img_rgb.empty());
- cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
- computeBlockHistograms(cv::gpu::GpuMat(img));
- compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
-
- img_rgb = readImage("hog/negative1.png");
- ASSERT_TRUE(!img_rgb.empty());
- cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
- computeBlockHistograms(cv::gpu::GpuMat(img));
- compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
-
- img_rgb = readImage("hog/negative2.png");
- ASSERT_TRUE(!img_rgb.empty());
- cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
- computeBlockHistograms(cv::gpu::GpuMat(img));
- compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
-
- img_rgb = readImage("hog/positive3.png");
- ASSERT_TRUE(!img_rgb.empty());
- cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
- computeBlockHistograms(cv::gpu::GpuMat(img));
- compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
-
- img_rgb = readImage("hog/negative3.png");
- ASSERT_TRUE(!img_rgb.empty());
- cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
- computeBlockHistograms(cv::gpu::GpuMat(img));
- compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
- }
- catch (...)
+ // Convert to C4
+ cv::Mat img;
+ cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+
+ cv::gpu::GpuMat d_img(img);
+
+ // Convert train images into feature vectors (train table)
+ cv::gpu::GpuMat descriptors, descriptors_by_cols;
+ getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW);
+ getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL);
+
+ // Check size of the result train table
+ wins_per_img_x = 3;
+ wins_per_img_y = 2;
+ blocks_per_win_x = 7;
+ blocks_per_win_y = 15;
+ block_hist_size = 36;
+ cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
+ wins_per_img_x * wins_per_img_y);
+ ASSERT_EQ(descr_size_expected, descriptors.size());
+
+ // Check both formats of output descriptors are handled correctly
+ cv::Mat dr(descriptors);
+ cv::Mat dc(descriptors_by_cols);
+ for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i)
{
- cv::gpu::resetDevice();
- throw;
+ const float* l = dr.rowRange(i, i + 1).ptr<float>();
+ const float* r = dc.rowRange(i, i + 1).ptr<float>();
+ for (int y = 0; y < blocks_per_win_y; ++y)
+ for (int x = 0; x < blocks_per_win_x; ++x)
+ for (int k = 0; k < block_hist_size; ++k)
+ ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
+ r[(x * blocks_per_win_y + y) * block_hist_size + k]);
}
+
+ /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
+ be defferent, due to border values interpolation. Using of many small images is slower, however we
+ wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
+ works good, it can be checked in the gpu_hog sample */
+
+ img_rgb = readImage("hog/positive1.png");
+ ASSERT_TRUE(!img_rgb.empty());
+ cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+ computeBlockHistograms(cv::gpu::GpuMat(img));
+ // Everything is fine with interpolation for left top subimage
+ ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
+
+ img_rgb = readImage("hog/positive2.png");
+ ASSERT_TRUE(!img_rgb.empty());
+ cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+ computeBlockHistograms(cv::gpu::GpuMat(img));
+ compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
+
+ img_rgb = readImage("hog/negative1.png");
+ ASSERT_TRUE(!img_rgb.empty());
+ cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+ computeBlockHistograms(cv::gpu::GpuMat(img));
+ compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
+
+ img_rgb = readImage("hog/negative2.png");
+ ASSERT_TRUE(!img_rgb.empty());
+ cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+ computeBlockHistograms(cv::gpu::GpuMat(img));
+ compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
+
+ img_rgb = readImage("hog/positive3.png");
+ ASSERT_TRUE(!img_rgb.empty());
+ cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+ computeBlockHistograms(cv::gpu::GpuMat(img));
+ compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
+
+ img_rgb = readImage("hog/negative3.png");
+ ASSERT_TRUE(!img_rgb.empty());
+ cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+ computeBlockHistograms(cv::gpu::GpuMat(img));
+ compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
TEST_P(CalTech, HOG)
{
- try
- {
- cv::gpu::GpuMat d_img(img);
- cv::Mat markedImage(img.clone());
-
- cv::gpu::HOGDescriptor d_hog;
- d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
- d_hog.nlevels = d_hog.nlevels + 32;
+ cv::gpu::GpuMat d_img(img);
+ cv::Mat markedImage(img.clone());
- std::vector<cv::Rect> found_locations;
- d_hog.detectMultiScale(d_img, found_locations);
+ cv::gpu::HOGDescriptor d_hog;
+ d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+ d_hog.nlevels = d_hog.nlevels + 32;
- #if defined (LOG_CASCADE_STATISTIC)
- for (int i = 0; i < (int)found_locations.size(); i++)
- {
- cv::Rect r = found_locations[i];
-
- std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl;
- cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
- }
+ std::vector<cv::Rect> found_locations;
+ d_hog.detectMultiScale(d_img, found_locations);
- cv::imshow("Res", markedImage); cv::waitKey();
- #endif
- }
- catch (...)
+#if defined (LOG_CASCADE_STATISTIC)
+ for (int i = 0; i < (int)found_locations.size(); i++)
{
- cv::gpu::resetDevice();
- throw;
+ cv::Rect r = found_locations[i];
+
+ std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl;
+ cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
}
+
+ cv::imshow("Res", markedImage); cv::waitKey();
+#endif
}
INSTANTIATE_TEST_CASE_P(detect, CalTech, testing::Combine(ALL_DEVICES,
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;
- }
+ 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));
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_Read_classifier,
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";
-
- cv::CascadeClassifier cpuClassifier(classifierXmlPath);
- ASSERT_FALSE(cpuClassifier.empty());
+ std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
+ std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
- cv::Mat image = cv::imread(imagePath);
- image = image.colRange(0, image.cols/2);
- cv::Mat grey;
- cvtColor(image, grey, CV_BGR2GRAY);
- ASSERT_FALSE(image.empty());
+ cv::CascadeClassifier cpuClassifier(classifierXmlPath);
+ ASSERT_FALSE(cpuClassifier.empty());
- std::vector<cv::Rect> rects;
- cpuClassifier.detectMultiScale(grey, rects);
- cv::Mat markedImage = image.clone();
+ cv::Mat image = cv::imread(imagePath);
+ image = image.colRange(0, image.cols/2);
+ cv::Mat grey;
+ cvtColor(image, grey, CV_BGR2GRAY);
+ ASSERT_FALSE(image.empty());
- std::vector<cv::Rect>::iterator it = rects.begin();
- for (; it != rects.end(); ++it)
- cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
+ std::vector<cv::Rect> rects;
+ cpuClassifier.detectMultiScale(grey, rects);
+ cv::Mat markedImage = image.clone();
- cv::gpu::CascadeClassifier_GPU gpuClassifier;
- ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
+ std::vector<cv::Rect>::iterator it = rects.begin();
+ for (; it != rects.end(); ++it)
+ cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
- cv::gpu::GpuMat gpu_rects;
- cv::gpu::GpuMat tested(grey);
- int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
+ cv::gpu::CascadeClassifier_GPU gpuClassifier;
+ ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
- #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++)
- {
- cv::Rect r = faces[i];
-
- std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl;
- cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
- }
- #endif
+ cv::gpu::GpuMat gpu_rects;
+ cv::gpu::GpuMat tested(grey);
+ int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
- #if defined (LOG_CASCADE_STATISTIC)
- cv::imshow("Res", markedImage); cv::waitKey();
- #endif
- (void)count;
- }
- catch (...)
+#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++)
{
- cv::gpu::resetDevice();
- throw;
+ cv::Rect r = faces[i];
+
+ std::cout << r.x << " " << r.y << " " << r.width << " " << r.height << std::endl;
+ cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
}
+#endif
+
+#if defined (LOG_CASCADE_STATISTIC)
+ cv::imshow("Res", markedImage); cv::waitKey();
+#endif
+ (void)count;
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
TEST_P(GlBuffer, Constructor1)
{
- try
- {
- cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
+ 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;
- }
+ EXPECT_EQ(size.height, buf.rows());
+ EXPECT_EQ(size.width, buf.cols());
+ EXPECT_EQ(type, buf.type());
}
TEST_P(GlBuffer, Constructor2)
{
- try
- {
- cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+ 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;
- }
+ EXPECT_EQ(size.height, buf.rows());
+ EXPECT_EQ(size.width, buf.cols());
+ EXPECT_EQ(type, buf.type());
}
TEST_P(GlBuffer, ConstructorFromMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
+ cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::Mat bufData;
- buf.copyTo(bufData);
+ cv::Mat bufData;
+ buf.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 0);
}
TEST_P(GlBuffer, ConstructorFromGpuMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
- cv::gpu::GpuMat d_gold(gold);
+ cv::Mat gold = randomMat(size, type);
+ cv::gpu::GpuMat d_gold(gold);
- cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
+ cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
- cv::Mat bufData;
- buf.copyTo(bufData);
+ cv::Mat bufData;
+ buf.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 0);
}
TEST_P(GlBuffer, ConstructorFromGlBuffer)
{
- try
- {
- cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::GlBuffer buf(buf_gold);
+ cv::GlBuffer buf(buf_gold);
- EXPECT_EQ(buf_gold.bufId(), buf.bufId());
- EXPECT_EQ(buf_gold.rows(), buf.rows());
- EXPECT_EQ(buf_gold.cols(), buf.cols());
- EXPECT_EQ(buf_gold.type(), buf.type());
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_EQ(buf_gold.bufId(), buf.bufId());
+ EXPECT_EQ(buf_gold.rows(), buf.rows());
+ EXPECT_EQ(buf_gold.cols(), buf.cols());
+ EXPECT_EQ(buf_gold.type(), buf.type());
}
TEST_P(GlBuffer, ConstructorFromGlTexture2D)
{
- try
- {
- const int depth = CV_MAT_DEPTH(type);
- const int cn = CV_MAT_CN(type);
+ const int depth = CV_MAT_DEPTH(type);
+ const int cn = CV_MAT_CN(type);
- if (depth != CV_32F || cn == 2)
- return;
+ if (depth != CV_32F || cn == 2)
+ return;
- cv::Mat gold = randomMat(size, type, 0, 1.0);
- cv::GlTexture2D tex_gold(gold, true);
+ cv::Mat gold = randomMat(size, type, 0, 1.0);
+ cv::GlTexture2D tex_gold(gold, true);
- cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+ cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
- cv::Mat bufData;
- buf.copyTo(bufData);
+ cv::Mat bufData;
+ buf.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 1e-2);
}
TEST_P(GlBuffer, Create)
{
- try
- {
- cv::GlBuffer buf;
- buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
+ 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;
- }
+ EXPECT_EQ(size.height, buf.rows());
+ EXPECT_EQ(size.width, buf.cols());
+ EXPECT_EQ(type, buf.type());
}
TEST_P(GlBuffer, CopyFromMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
+ cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf;
- buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf;
+ buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::Mat bufData;
- buf.copyTo(bufData);
+ cv::Mat bufData;
+ buf.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 0);
}
TEST_P(GlBuffer, CopyFromGpuMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
- cv::gpu::GpuMat d_gold(gold);
+ cv::Mat gold = randomMat(size, type);
+ cv::gpu::GpuMat d_gold(gold);
- cv::GlBuffer buf;
- buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf;
+ buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::Mat bufData;
- buf.copyTo(bufData);
+ cv::Mat bufData;
+ buf.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 0);
}
TEST_P(GlBuffer, CopyFromGlBuffer)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::Mat gold = randomMat(size, type);
+ cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::GlBuffer buf;
- buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf;
+ buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
- EXPECT_NE(buf_gold.bufId(), buf.bufId());
+ EXPECT_NE(buf_gold.bufId(), buf.bufId());
- cv::Mat bufData;
- buf.copyTo(bufData);
+ cv::Mat bufData;
+ buf.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 0);
}
TEST_P(GlBuffer, CopyFromGlTexture2D)
{
- try
- {
- const int depth = CV_MAT_DEPTH(type);
- const int cn = CV_MAT_CN(type);
+ const int depth = CV_MAT_DEPTH(type);
+ const int cn = CV_MAT_CN(type);
- if (depth != CV_32F || cn == 2)
- return;
+ if (depth != CV_32F || cn == 2)
+ return;
- cv::Mat gold = randomMat(size, type, 0, 1.0);
- cv::GlTexture2D tex_gold(gold, true);
+ cv::Mat gold = randomMat(size, type, 0, 1.0);
+ cv::GlTexture2D tex_gold(gold, true);
- cv::GlBuffer buf;
- buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf;
+ buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::Mat bufData;
- buf.copyTo(bufData);
+ cv::Mat bufData;
+ buf.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 1e-2);
}
TEST_P(GlBuffer, CopyToGpuMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
+ cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::gpu::GpuMat dst;
- buf.copyTo(dst);
+ cv::gpu::GpuMat dst;
+ buf.copyTo(dst);
- EXPECT_MAT_NEAR(gold, dst, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, dst, 0);
}
TEST_P(GlBuffer, CopyToGlBuffer)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
+ cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::GlBuffer dst;
- buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer dst;
+ buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
- EXPECT_NE(buf.bufId(), dst.bufId());
+ EXPECT_NE(buf.bufId(), dst.bufId());
- cv::Mat bufData;
- dst.copyTo(bufData);
+ cv::Mat bufData;
+ dst.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 0);
}
TEST_P(GlBuffer, CopyToGlTexture2D)
{
- try
- {
- const int depth = CV_MAT_DEPTH(type);
- const int cn = CV_MAT_CN(type);
+ const int depth = CV_MAT_DEPTH(type);
+ const int cn = CV_MAT_CN(type);
- if (depth != CV_32F || cn == 2)
- return;
+ if (depth != CV_32F || cn == 2)
+ return;
- cv::Mat gold = randomMat(size, type, 0, 1.0);
+ cv::Mat gold = randomMat(size, type, 0, 1.0);
- cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+ cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
- cv::GlTexture2D tex;
- buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+ cv::GlTexture2D tex;
+ buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
- cv::Mat texData;
- tex.copyTo(texData);
+ cv::Mat texData;
+ tex.copyTo(texData);
- EXPECT_MAT_NEAR(gold, texData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
TEST_P(GlBuffer, Clone)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
+ cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
- EXPECT_NE(buf.bufId(), dst.bufId());
+ EXPECT_NE(buf.bufId(), dst.bufId());
- cv::Mat bufData;
- dst.copyTo(bufData);
+ cv::Mat bufData;
+ dst.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 0);
}
TEST_P(GlBuffer, MapHostRead)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
+ cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
+ cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
- EXPECT_MAT_NEAR(gold, dst, 0);
+ EXPECT_MAT_NEAR(gold, dst, 0);
- buf.unmapHost();
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ buf.unmapHost();
}
TEST_P(GlBuffer, MapHostWrite)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
+ cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
- gold.copyTo(dst);
- buf.unmapHost();
- dst.release();
+ cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
+ gold.copyTo(dst);
+ buf.unmapHost();
+ dst.release();
- cv::Mat bufData;
- buf.copyTo(bufData);
+ cv::Mat bufData;
+ buf.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 0);
}
TEST_P(GlBuffer, MapDevice)
{
- try
- {
- cv::Mat gold = randomMat(size, type);
+ cv::Mat gold = randomMat(size, type);
- cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+ cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
- cv::gpu::GpuMat dst = buf.mapDevice();
+ cv::gpu::GpuMat dst = buf.mapDevice();
- EXPECT_MAT_NEAR(gold, dst, 0);
+ EXPECT_MAT_NEAR(gold, dst, 0);
- buf.unmapDevice();
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ buf.unmapDevice();
}
INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES));
TEST_P(GlTexture2D, Constructor1)
{
- try
- {
- cv::GlTexture2D tex(size.height, size.width, format, true);
+ 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;
- }
+ EXPECT_EQ(size.height, tex.rows());
+ EXPECT_EQ(size.width, tex.cols());
+ EXPECT_EQ(format, tex.format());
}
TEST_P(GlTexture2D, Constructor2)
{
- try
- {
- cv::GlTexture2D tex(size, format, true);
+ 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;
- }
+ EXPECT_EQ(size.height, tex.rows());
+ EXPECT_EQ(size.width, tex.cols());
+ EXPECT_EQ(format, tex.format());
}
TEST_P(GlTexture2D, ConstructorFromMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+ cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
- cv::GlTexture2D tex(gold, true);
+ cv::GlTexture2D tex(gold, true);
- cv::Mat texData;
- tex.copyTo(texData, depth);
+ cv::Mat texData;
+ tex.copyTo(texData, depth);
- EXPECT_MAT_NEAR(gold, texData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
TEST_P(GlTexture2D, ConstructorFromGpuMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
- cv::gpu::GpuMat d_gold(gold);
+ cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+ cv::gpu::GpuMat d_gold(gold);
- cv::GlTexture2D tex(d_gold, true);
+ cv::GlTexture2D tex(d_gold, true);
- cv::Mat texData;
- tex.copyTo(texData, depth);
+ cv::Mat texData;
+ tex.copyTo(texData, depth);
- EXPECT_MAT_NEAR(gold, texData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
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);
+ cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+ cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
- cv::GlTexture2D tex(buf_gold, true);
+ cv::GlTexture2D tex(buf_gold, true);
- cv::Mat texData;
- tex.copyTo(texData, depth);
+ cv::Mat texData;
+ tex.copyTo(texData, depth);
- EXPECT_MAT_NEAR(gold, texData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
{
- try
- {
- cv::GlTexture2D tex_gold(size, format, true);
- cv::GlTexture2D tex(tex_gold);
+ cv::GlTexture2D tex_gold(size, format, true);
+ cv::GlTexture2D tex(tex_gold);
- EXPECT_EQ(tex_gold.texId(), tex.texId());
- EXPECT_EQ(tex_gold.rows(), tex.rows());
- EXPECT_EQ(tex_gold.cols(), tex.cols());
- EXPECT_EQ(tex_gold.format(), tex.format());
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_EQ(tex_gold.texId(), tex.texId());
+ EXPECT_EQ(tex_gold.rows(), tex.rows());
+ EXPECT_EQ(tex_gold.cols(), tex.cols());
+ EXPECT_EQ(tex_gold.format(), tex.format());
}
TEST_P(GlTexture2D, Create)
{
- try
- {
- cv::GlTexture2D tex;
- tex.create(size.height, size.width, format, true);
+ 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;
- }
+ EXPECT_EQ(size.height, tex.rows());
+ EXPECT_EQ(size.width, tex.cols());
+ EXPECT_EQ(format, tex.format());
}
TEST_P(GlTexture2D, CopyFromMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+ cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
- cv::GlTexture2D tex;
- tex.copyFrom(gold, true);
+ cv::GlTexture2D tex;
+ tex.copyFrom(gold, true);
- cv::Mat texData;
- tex.copyTo(texData, depth);
+ cv::Mat texData;
+ tex.copyTo(texData, depth);
- EXPECT_MAT_NEAR(gold, texData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
TEST_P(GlTexture2D, CopyFromGpuMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
- cv::gpu::GpuMat d_gold(gold);
+ cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+ cv::gpu::GpuMat d_gold(gold);
- cv::GlTexture2D tex;
- tex.copyFrom(d_gold, true);
+ cv::GlTexture2D tex;
+ tex.copyFrom(d_gold, true);
- cv::Mat texData;
- tex.copyTo(texData, depth);
+ cv::Mat texData;
+ tex.copyTo(texData, depth);
- EXPECT_MAT_NEAR(gold, texData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
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);
+ cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+ cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
- cv::GlTexture2D tex;
- tex.copyFrom(buf_gold, true);
+ cv::GlTexture2D tex;
+ tex.copyFrom(buf_gold, true);
- cv::Mat texData;
- tex.copyTo(texData, depth);
+ cv::Mat texData;
+ tex.copyTo(texData, depth);
- EXPECT_MAT_NEAR(gold, texData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
TEST_P(GlTexture2D, CopyToGpuMat)
{
- try
- {
- cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+ cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
- cv::GlTexture2D tex(gold, true);
+ cv::GlTexture2D tex(gold, true);
- cv::gpu::GpuMat dst;
- tex.copyTo(dst, depth);
+ cv::gpu::GpuMat dst;
+ tex.copyTo(dst, depth);
- EXPECT_MAT_NEAR(gold, dst, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, dst, 1e-2);
}
TEST_P(GlTexture2D, CopyToGlBuffer)
{
- try
- {
- cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+ cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
- cv::GlTexture2D tex(gold, true);
+ cv::GlTexture2D tex(gold, true);
- cv::GlBuffer dst;
- tex.copyTo(dst, depth, true);
+ cv::GlBuffer dst;
+ tex.copyTo(dst, depth, true);
- cv::Mat bufData;
- dst.copyTo(bufData);
+ cv::Mat bufData;
+ dst.copyTo(bufData);
- EXPECT_MAT_NEAR(gold, bufData, 1e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(gold, bufData, 1e-2);
}
INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
TEST_P(PyrDown, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
- cv::gpu::pyrDown(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
+ cv::gpu::pyrDown(loadMat(src, useRoi), dst);
- cv::Mat dst_gold;
- cv::pyrDown(src, dst_gold);
+ cv::Mat dst_gold;
+ cv::pyrDown(src, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine(
TEST_P(PyrUp, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ cv::Mat src = randomMat(size, type);
- cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
- cv::gpu::pyrUp(loadMat(src, useRoi), dst);
+ cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
+ cv::gpu::pyrUp(loadMat(src, useRoi), dst);
- cv::Mat dst_gold;
- cv::pyrUp(src, dst_gold);
+ cv::Mat dst_gold;
+ cv::pyrUp(src, dst_gold);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine(
TEST_P(Remap, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Scalar val = randomScalar(0.0, 255.0);
+ cv::Mat src = randomMat(size, type);
+ cv::Scalar val = randomScalar(0.0, 255.0);
- cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi);
- cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val);
+ cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi);
+ cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val);
- cv::Mat dst_gold;
- remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
+ cv::Mat dst_gold;
+ remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine(
TEST_P(Resize, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ 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);
- cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
+ cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
+ cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
- cv::Mat dst_gold;
- resizeGold(src, dst_gold, coeff, coeff, interpolation);
+ cv::Mat dst_gold;
+ resizeGold(src, dst_gold, coeff, coeff, interpolation);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
// downscaling only: used for classifiers
TEST_P(ResizeSameAsHost, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
+ 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);
- cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
+ cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
+ cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
- cv::Mat dst_gold;
- cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
+ cv::Mat dst_gold;
+ cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
TEST_P(ResizeNPP, Accuracy)
{
- try
- {
- cv::Mat src = readImageType("stereobp/aloe-L.png", type);
- ASSERT_FALSE(src.empty());
+ cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+ ASSERT_FALSE(src.empty());
- cv::gpu::GpuMat dst;
- cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
+ cv::gpu::GpuMat dst;
+ cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
- cv::Mat dst_gold;
- resizeGold(src, dst_gold, coeff, coeff, interpolation);
+ cv::Mat dst_gold;
+ resizeGold(src, dst_gold, coeff, coeff, interpolation);
- EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeNPP, testing::Combine(
//
//M*/
-#include "test_precomp.hpp"
+#include <test_precomp.hpp>
#include <time.h>
#ifdef HAVE_CUDA
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());
-
- cv::gpu::SCascade cascade;
+ cv::gpu::setDevice(GET_PARAM(0).deviceID());
+ cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
+ ASSERT_FALSE(coloredCpu.empty());
- cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::gpu::SCascade cascade;
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
- rois.setTo(0);
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- int nroi = GET_PARAM(3);
- cv::Mat result(coloredCpu);
- cv::RNG rng;
- for (int i = 0; i < nroi; ++i)
- {
- cv::Rect r = getFromTable(rng(10));
- GpuMat sub(rois, r);
- sub.setTo(1);
- cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
- }
- objectBoxes.setTo(0);
+ GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
+ rois.setTo(0);
- cascade.detect(colored, rois, objectBoxes);
+ int nroi = GET_PARAM(3);
+ cv::Mat result(coloredCpu);
+ cv::RNG rng;
+ for (int i = 0; i < nroi; ++i)
+ {
+ cv::Rect r = getFromTable(rng(10));
+ GpuMat sub(rois, r);
+ sub.setTo(1);
+ cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
+ }
+ objectBoxes.setTo(0);
- cv::Mat dt(objectBoxes);
- typedef cv::gpu::SCascade::Detection Detection;
+ cascade.detect(colored, rois, objectBoxes);
- Detection* dts = ((Detection*)dt.data) + 1;
- int* count = dt.ptr<int>(0);
+ cv::Mat dt(objectBoxes);
+ typedef cv::gpu::SCascade::Detection Detection;
- printTotal(std::cout, *count);
+ Detection* dts = ((Detection*)dt.data) + 1;
+ int* count = dt.ptr<int>(0);
- for (int i = 0; i < *count; ++i)
- {
- Detection d = dts[i];
- print(std::cout, d);
- cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
- }
+ printTotal(std::cout, *count);
- SHOW(result);
- }
- catch (...)
+ for (int i = 0; i < *count; ++i)
{
- cv::gpu::resetDevice();
- throw;
+ Detection d = dts[i];
+ print(std::cout, d);
+ cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
}
+
+ SHOW(result);
+
}
TEST(SCascadeTest, readCascade)
{
- try
- {
- std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
- cv::gpu::SCascade cascade;
+ std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
+ cv::gpu::SCascade cascade;
- cv::FileStorage fs(xml, cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::FileStorage fs(xml, cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
}
typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
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;
+ cv::gpu::setDevice(GetParam().deviceID());
+ std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+ cv::gpu::SCascade cascade;
- cv::FileStorage fs(xml, cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::FileStorage fs(xml, cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
- + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
- ASSERT_FALSE(coloredCpu.empty());
+ cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+ + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+ ASSERT_FALSE(coloredCpu.empty());
- GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
- rois.setTo(0);
- GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
- sub.setTo(cv::Scalar::all(1));
+ GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
+ rois.setTo(0);
+ GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+ sub.setTo(cv::Scalar::all(1));
- objectBoxes.setTo(0);
- cascade.detect(colored, rois, objectBoxes);
+ objectBoxes.setTo(0);
+ cascade.detect(colored, rois, objectBoxes);
- typedef cv::gpu::SCascade::Detection Detection;
- cv::Mat detections(objectBoxes);
- int a = *(detections.ptr<int>(0));
- ASSERT_EQ(a, 2448);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ typedef cv::gpu::SCascade::Detection Detection;
+ cv::Mat detections(objectBoxes);
+ int a = *(detections.ptr<int>(0));
+ ASSERT_EQ(a ,2448);
}
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;
+ cv::gpu::setDevice(GetParam().deviceID());
+ std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+ cv::gpu::SCascade cascade;
- cv::FileStorage fs(xml, cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::FileStorage fs(xml, cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
- cv::FileStorage fsi(intPath, cv::FileStorage::READ);
- ASSERT_TRUE(fsi.isOpened());
+ std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
+ cv::FileStorage fsi(intPath, cv::FileStorage::READ);
+ ASSERT_TRUE(fsi.isOpened());
- GpuMat hogluv(121 * 10, 161, CV_32SC1);
- for (int i = 0; i < 10; ++i)
- {
- cv::Mat channel;
- fsi[std::string("channel") + itoa(i)] >> channel;
- GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
- gchannel.upload(channel);
- }
+ GpuMat hogluv(121 * 10, 161, CV_32SC1);
+ for (int i = 0; i < 10; ++i)
+ {
+ cv::Mat channel;
+ fsi[std::string("channel") + itoa(i)] >> channel;
+ GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+ gchannel.upload(channel);
+ }
- GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
- rois.setTo(1);
+ GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
+ rois.setTo(1);
- objectBoxes.setTo(0);
- cascade.detect(hogluv, rois, objectBoxes);
+ objectBoxes.setTo(0);
+ cascade.detect(hogluv, rois, objectBoxes);
- typedef cv::gpu::SCascade::Detection Detection;
- cv::Mat detections(objectBoxes);
- int a = *(detections.ptr<int>(0));
+ typedef cv::gpu::SCascade::Detection Detection;
+ cv::Mat detections(objectBoxes);
+ int a = *(detections.ptr<int>(0));
- ASSERT_EQ(a, 1024);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_EQ( a ,1024);
}
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;
+ cv::gpu::setDevice(GetParam().deviceID());
+ std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+ cv::gpu::SCascade cascade;
- cv::FileStorage fs(xml, cv::FileStorage::READ);
- ASSERT_TRUE(fs.isOpened());
+ cv::FileStorage fs(xml, cv::FileStorage::READ);
+ ASSERT_TRUE(fs.isOpened());
- ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+ ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
- cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
- + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
- ASSERT_FALSE(coloredCpu.empty());
+ cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+ + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+ ASSERT_FALSE(coloredCpu.empty());
- GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
- rois.setTo(0);
- GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
- sub.setTo(cv::Scalar::all(1));
+ GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
+ rois.setTo(0);
+ GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+ sub.setTo(cv::Scalar::all(1));
- cv::gpu::Stream s;
+ cv::gpu::Stream s;
- objectBoxes.setTo(0);
- cascade.detect(colored, rois, objectBoxes, s);
- s.waitForCompletion();
+ objectBoxes.setTo(0);
+ cascade.detect(colored, rois, objectBoxes, s);
+ s.waitForCompletion();
- typedef cv::gpu::SCascade::Detection Detection;
- cv::Mat detections(objectBoxes);
- int a = *(detections.ptr<int>(0));
- ASSERT_EQ(a, 2448);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ typedef cv::gpu::SCascade::Detection Detection;
+ cv::Mat detections(objectBoxes);
+ int a = *(detections.ptr<int>(0));
+ ASSERT_EQ(a ,2448);
}
-#endif
+#endif
\ No newline at end of file
TEST_P(Threshold, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- double maxVal = randomDouble(20.0, 127.0);
- double thresh = randomDouble(0.0, maxVal);
+ cv::Mat src = randomMat(size, type);
+ double maxVal = randomDouble(20.0, 127.0);
+ double thresh = randomDouble(0.0, maxVal);
- cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
- cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
+ cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+ cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
- cv::Mat dst_gold;
- cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
+ cv::Mat dst_gold;
+ cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(
TEST_P(BroxOpticalFlow, Regression)
{
- try
- {
- cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
- ASSERT_FALSE(frame0.empty());
+ cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+ ASSERT_FALSE(frame0.empty());
- cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
- ASSERT_FALSE(frame1.empty());
+ cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+ ASSERT_FALSE(frame1.empty());
- cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
- 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+ cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+ 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
- cv::gpu::GpuMat u;
- cv::gpu::GpuMat v;
- brox(loadMat(frame0), loadMat(frame1), u, v);
+ cv::gpu::GpuMat u;
+ cv::gpu::GpuMat v;
+ brox(loadMat(frame0), loadMat(frame1), u, v);
- #ifndef DUMP
- std::string fname(cvtest::TS::ptr()->get_data_path());
- if (devInfo.majorVersion() >= 2)
- fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
- else
- fname += BROX_OPTICAL_FLOW_DUMP_FILE;
+#ifndef DUMP
+ std::string fname(cvtest::TS::ptr()->get_data_path());
+ if (devInfo.majorVersion() >= 2)
+ fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
+ else
+ fname += BROX_OPTICAL_FLOW_DUMP_FILE;
- std::ifstream f(fname.c_str(), std::ios_base::binary);
+ std::ifstream f(fname.c_str(), std::ios_base::binary);
- int rows, cols;
+ int rows, cols;
- f.read((char*)&rows, sizeof(rows));
- f.read((char*)&cols, sizeof(cols));
+ f.read((char*)&rows, sizeof(rows));
+ f.read((char*)&cols, sizeof(cols));
- cv::Mat u_gold(rows, cols, CV_32FC1);
+ cv::Mat u_gold(rows, cols, CV_32FC1);
- for (int i = 0; i < u_gold.rows; ++i)
- f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
+ for (int i = 0; i < u_gold.rows; ++i)
+ f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
- cv::Mat v_gold(rows, cols, CV_32FC1);
+ cv::Mat v_gold(rows, cols, CV_32FC1);
- for (int i = 0; i < v_gold.rows; ++i)
- f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
+ for (int i = 0; i < v_gold.rows; ++i)
+ f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
- EXPECT_MAT_NEAR(u_gold, u, 0);
- EXPECT_MAT_NEAR(v_gold, v, 0);
- #else
- std::string fname(cvtest::TS::ptr()->get_data_path());
- if (devInfo.majorVersion() >= 2)
- fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
- else
- fname += BROX_OPTICAL_FLOW_DUMP_FILE;
+ EXPECT_MAT_NEAR(u_gold, u, 0);
+ EXPECT_MAT_NEAR(v_gold, v, 0);
+#else
+ std::string fname(cvtest::TS::ptr()->get_data_path());
+ if (devInfo.majorVersion() >= 2)
+ fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
+ else
+ fname += BROX_OPTICAL_FLOW_DUMP_FILE;
- std::ofstream f(fname.c_str(), std::ios_base::binary);
+ std::ofstream f(fname.c_str(), std::ios_base::binary);
- f.write((char*)&u.rows, sizeof(u.rows));
- f.write((char*)&u.cols, sizeof(u.cols));
+ f.write((char*)&u.rows, sizeof(u.rows));
+ f.write((char*)&u.cols, sizeof(u.cols));
- cv::Mat h_u(u);
- cv::Mat h_v(v);
+ cv::Mat h_u(u);
+ cv::Mat h_v(v);
- for (int i = 0; i < u.rows; ++i)
- f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
+ for (int i = 0; i < u.rows; ++i)
+ f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
- for (int i = 0; i < v.rows; ++i)
- f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
- #endif
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ for (int i = 0; i < v.rows; ++i)
+ f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
+
+#endif
}
INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
TEST_P(GoodFeaturesToTrack, Accuracy)
{
- try
- {
- cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(image.empty());
+ cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(image.empty());
- int maxCorners = 1000;
- double qualityLevel = 0.01;
+ int maxCorners = 1000;
+ double qualityLevel = 0.01;
- cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+ 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);
ASSERT_LE(bad_ratio, 0.01);
}
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
}
TEST_P(GoodFeaturesToTrack, EmptyCorners)
{
- try
- {
- int maxCorners = 1000;
- double qualityLevel = 0.01;
+ int maxCorners = 1000;
+ double qualityLevel = 0.01;
- cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+ cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
- cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
- cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
+ cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
+ cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
- detector(src, corners);
+ detector(src, corners);
- ASSERT_TRUE( corners.empty() );
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_TRUE( corners.empty() );
}
INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
TEST_P(PyrLKOpticalFlow, Sparse)
{
- try
- {
- cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
- ASSERT_FALSE(frame0.empty());
+ cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+ ASSERT_FALSE(frame0.empty());
- cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
- ASSERT_FALSE(frame1.empty());
+ cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+ ASSERT_FALSE(frame1.empty());
- cv::Mat gray_frame;
- if (useGray)
- gray_frame = frame0;
- else
- cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
+ cv::Mat gray_frame;
+ if (useGray)
+ gray_frame = frame0;
+ else
+ cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
- std::vector<cv::Point2f> pts;
- cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
+ std::vector<cv::Point2f> pts;
+ cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
- cv::gpu::GpuMat d_pts;
- cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
- d_pts.upload(pts_mat);
+ cv::gpu::GpuMat d_pts;
+ cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
+ d_pts.upload(pts_mat);
- cv::gpu::PyrLKOpticalFlow pyrLK;
+ cv::gpu::PyrLKOpticalFlow pyrLK;
- cv::gpu::GpuMat d_nextPts;
- cv::gpu::GpuMat d_status;
- pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
+ cv::gpu::GpuMat d_nextPts;
+ cv::gpu::GpuMat d_status;
+ pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
- std::vector<cv::Point2f> nextPts(d_nextPts.cols);
- cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
- d_nextPts.download(nextPts_mat);
+ std::vector<cv::Point2f> nextPts(d_nextPts.cols);
+ cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
+ d_nextPts.download(nextPts_mat);
- std::vector<unsigned char> status(d_status.cols);
- cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
- d_status.download(status_mat);
+ std::vector<unsigned char> status(d_status.cols);
+ cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
+ d_status.download(status_mat);
- std::vector<cv::Point2f> nextPts_gold;
- std::vector<unsigned char> status_gold;
- cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
+ std::vector<cv::Point2f> nextPts_gold;
+ std::vector<unsigned char> status_gold;
+ cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
- ASSERT_EQ(nextPts_gold.size(), nextPts.size());
- ASSERT_EQ(status_gold.size(), status.size());
+ ASSERT_EQ(nextPts_gold.size(), nextPts.size());
+ ASSERT_EQ(status_gold.size(), status.size());
- size_t mistmatch = 0;
- for (size_t i = 0; i < nextPts.size(); ++i)
- {
- cv::Point2i a = nextPts[i];
- cv::Point2i b = nextPts_gold[i];
+ size_t mistmatch = 0;
+ for (size_t i = 0; i < nextPts.size(); ++i)
+ {
+ cv::Point2i a = nextPts[i];
+ cv::Point2i b = nextPts_gold[i];
- if (status[i] != status_gold[i])
- {
- ++mistmatch;
- continue;
- }
+ if (status[i] != status_gold[i])
+ {
+ ++mistmatch;
+ continue;
+ }
- if (status[i])
- {
- bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
+ if (status[i])
+ {
+ bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
- if (!eq)
- ++mistmatch;
- }
+ if (!eq)
+ ++mistmatch;
}
+ }
- double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
+ double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
- ASSERT_LE(bad_ratio, 0.01);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_LE(bad_ratio, 0.01);
}
INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
TEST_P(FarnebackOpticalFlow, Accuracy)
{
- try
- {
- cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(frame0.empty());
+ cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(frame0.empty());
- cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(frame1.empty());
+ cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(frame1.empty());
- double polySigma = polyN <= 5 ? 1.1 : 1.5;
+ double polySigma = polyN <= 5 ? 1.1 : 1.5;
- cv::gpu::FarnebackOpticalFlow calc;
- calc.pyrScale = pyrScale;
- calc.polyN = polyN;
- calc.polySigma = polySigma;
- calc.flags = flags;
+ cv::gpu::FarnebackOpticalFlow calc;
+ calc.pyrScale = pyrScale;
+ calc.polyN = polyN;
+ calc.polySigma = polySigma;
+ calc.flags = flags;
- cv::gpu::GpuMat d_flowx, d_flowy;
- calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+ cv::gpu::GpuMat d_flowx, d_flowy;
+ calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
- cv::Mat flow;
- if (useInitFlow)
- {
- cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
- cv::merge(flowxy, 2, flow);
- }
+ cv::Mat flow;
+ if (useInitFlow)
+ {
+ cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
+ cv::merge(flowxy, 2, flow);
+ }
- if (useInitFlow)
- {
- calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
- calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
- }
+ if (useInitFlow)
+ {
+ calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
+ calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+ }
- cv::calcOpticalFlowFarneback(
- frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
- calc.numIters, calc.polyN, calc.polySigma, calc.flags);
+ cv::calcOpticalFlowFarneback(
+ frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
+ calc.numIters, calc.polyN, calc.polySigma, calc.flags);
- std::vector<cv::Mat> flowxy;
- cv::split(flow, flowxy);
+ std::vector<cv::Mat> flowxy;
+ cv::split(flow, flowxy);
- EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
- EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
+ EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
}
INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
TEST_P(OpticalFlowNan, Regression)
{
- try
- {
- cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
- ASSERT_FALSE(frame0.empty());
- cv::Mat r_frame0, r_frame1;
- cv::resize(frame0, r_frame0, cv::Size(1380,1000));
-
- cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
- ASSERT_FALSE(frame1.empty());
- cv::resize(frame1, r_frame1, cv::Size(1380,1000));
-
- cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
- 5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
-
- cv::gpu::GpuMat u;
- cv::gpu::GpuMat v;
- brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
-
- cv::Mat h_u, h_v;
- u.download(h_u);
- v.download(h_v);
- EXPECT_TRUE(cv::checkRange(h_u));
- EXPECT_TRUE(cv::checkRange(h_v));
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+ ASSERT_FALSE(frame0.empty());
+ cv::Mat r_frame0, r_frame1;
+ cv::resize(frame0, r_frame0, cv::Size(1380,1000));
+
+ cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+ ASSERT_FALSE(frame1.empty());
+ cv::resize(frame1, r_frame1, cv::Size(1380,1000));
+
+ cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+ 5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+ cv::gpu::GpuMat u;
+ cv::gpu::GpuMat v;
+ brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
+
+ cv::Mat h_u, h_v;
+ u.download(h_u);
+ v.download(h_v);
+ EXPECT_TRUE(cv::checkRange(h_u));
+ EXPECT_TRUE(cv::checkRange(h_v));
};
INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowNan, ALL_DEVICES);
TEST_P(OpticalFlowDual_TVL1, Accuracy)
{
- try
- {
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
- cv::gpu::setDevice(devInfo.deviceID());
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+ cv::gpu::setDevice(devInfo.deviceID());
- const bool useRoi = GET_PARAM(1);
+ const bool useRoi = GET_PARAM(1);
- cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(frame0.empty());
+ cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(frame0.empty());
- cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(frame1.empty());
+ cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(frame1.empty());
- cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
- cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
- cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
- d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
+ cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+ cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
+ cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
+ d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
- cv::OpticalFlowDual_TVL1 alg;
- cv::Mat flow;
- alg(frame0, frame1, flow);
- cv::Mat gold[2];
- cv::split(flow, gold);
+ cv::OpticalFlowDual_TVL1 alg;
+ cv::Mat flow;
+ alg(frame0, frame1, flow);
+ cv::Mat gold[2];
+ cv::split(flow, gold);
- EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
- EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
+ EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
}
INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
TEST_P(OpticalFlowBM, Accuracy)
{
- try
- {
- cv::gpu::DeviceInfo devInfo = GetParam();
- cv::gpu::setDevice(devInfo.deviceID());
+ cv::gpu::DeviceInfo devInfo = GetParam();
+ cv::gpu::setDevice(devInfo.deviceID());
- cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(frame0.empty());
+ cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(frame0.empty());
- cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(frame1.empty());
+ cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(frame1.empty());
- cv::Size block_size(16, 16);
- cv::Size shift_size(1, 1);
- cv::Size max_range(16, 16);
+ cv::Size block_size(16, 16);
+ cv::Size shift_size(1, 1);
+ cv::Size max_range(16, 16);
- cv::gpu::GpuMat d_velx, d_vely, buf;
- cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
- block_size, shift_size, max_range, false,
- d_velx, d_vely, buf);
+ cv::gpu::GpuMat d_velx, d_vely, buf;
+ cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
+ block_size, shift_size, max_range, false,
+ d_velx, d_vely, buf);
- cv::Mat velx, vely;
- calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+ cv::Mat velx, vely;
+ calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
- EXPECT_MAT_NEAR(velx, d_velx, 0);
- EXPECT_MAT_NEAR(vely, d_vely, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(velx, d_velx, 0);
+ EXPECT_MAT_NEAR(vely, d_vely, 0);
}
INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
TEST_P(FastOpticalFlowBM, Accuracy)
{
- try
- {
- const double MAX_RMSE = 0.6;
+ const double MAX_RMSE = 0.6;
- int search_window = 15;
- int block_window = 5;
+ int search_window = 15;
+ int block_window = 5;
- cv::gpu::DeviceInfo devInfo = GetParam();
- cv::gpu::setDevice(devInfo.deviceID());
+ cv::gpu::DeviceInfo devInfo = GetParam();
+ cv::gpu::setDevice(devInfo.deviceID());
- cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(frame0.empty());
+ cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(frame0.empty());
- cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
- ASSERT_FALSE(frame1.empty());
+ cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+ ASSERT_FALSE(frame1.empty());
- cv::Size smallSize(320, 240);
- cv::Mat frame0_small;
- cv::Mat frame1_small;
+ cv::Size smallSize(320, 240);
+ cv::Mat frame0_small;
+ cv::Mat frame1_small;
- cv::resize(frame0, frame0_small, smallSize);
- cv::resize(frame1, frame1_small, smallSize);
+ cv::resize(frame0, frame0_small, smallSize);
+ cv::resize(frame1, frame1_small, smallSize);
- cv::gpu::GpuMat d_flowx;
- cv::gpu::GpuMat d_flowy;
- cv::gpu::FastOpticalFlowBM fastBM;
+ cv::gpu::GpuMat d_flowx;
+ cv::gpu::GpuMat d_flowy;
+ cv::gpu::FastOpticalFlowBM fastBM;
- fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
+ fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
- cv::Mat_<float> flowx;
- cv::Mat_<float> flowy;
- FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
+ cv::Mat_<float> flowx;
+ cv::Mat_<float> flowy;
+ FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
- double err;
+ double err;
- err = calc_rmse(flowx, cv::Mat(d_flowx));
- EXPECT_LE(err, MAX_RMSE);
+ err = calc_rmse(flowx, cv::Mat(d_flowx));
+ EXPECT_LE(err, MAX_RMSE);
- err = calc_rmse(flowy, cv::Mat(d_flowy));
- EXPECT_LE(err, MAX_RMSE);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ err = calc_rmse(flowy, cv::Mat(d_flowy));
+ EXPECT_LE(err, MAX_RMSE);
}
INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
TEST_P(FGDStatModel, Update)
{
- try
- {
- cv::VideoCapture cap(inputFile);
- ASSERT_TRUE(cap.isOpened());
+ cv::VideoCapture cap(inputFile);
+ ASSERT_TRUE(cap.isOpened());
- cv::Mat frame;
- cap >> frame;
- ASSERT_FALSE(frame.empty());
+ cv::Mat frame;
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- IplImage ipl_frame = frame;
- cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
+ IplImage ipl_frame = frame;
+ cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
- cv::gpu::GpuMat d_frame(frame);
- cv::gpu::FGDStatModel d_model(out_cn);
- d_model.create(d_frame);
+ cv::gpu::GpuMat d_frame(frame);
+ cv::gpu::FGDStatModel d_model(out_cn);
+ d_model.create(d_frame);
- cv::Mat h_background;
- cv::Mat h_foreground;
- cv::Mat h_background3;
+ cv::Mat h_background;
+ cv::Mat h_foreground;
+ cv::Mat h_background3;
- cv::Mat backgroundDiff;
- cv::Mat foregroundDiff;
+ cv::Mat backgroundDiff;
+ cv::Mat foregroundDiff;
- for (int i = 0; i < 5; ++i)
- {
- cap >> frame;
- ASSERT_FALSE(frame.empty());
-
- ipl_frame = frame;
- int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
+ for (int i = 0; i < 5; ++i)
+ {
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- d_frame.upload(frame);
+ ipl_frame = frame;
+ int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
- int count = d_model.update(d_frame);
+ d_frame.upload(frame);
- ASSERT_EQ(gold_count, count);
+ int count = d_model.update(d_frame);
- cv::Mat gold_background(model->background);
- cv::Mat gold_foreground(model->foreground);
+ ASSERT_EQ(gold_count, count);
- if (out_cn == 3)
- d_model.background.download(h_background3);
- else
- {
- d_model.background.download(h_background);
- cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
- }
- d_model.foreground.download(h_foreground);
+ cv::Mat gold_background(model->background);
+ cv::Mat gold_foreground(model->foreground);
- ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
- ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
+ if (out_cn == 3)
+ d_model.background.download(h_background3);
+ else
+ {
+ d_model.background.download(h_background);
+ cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
}
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ d_model.foreground.download(h_foreground);
+
+ ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
+ ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
}
}
TEST_P(MOG, Update)
{
- try
- {
- cv::VideoCapture cap(inputFile);
- ASSERT_TRUE(cap.isOpened());
+ cv::VideoCapture cap(inputFile);
+ ASSERT_TRUE(cap.isOpened());
- cv::Mat frame;
- cap >> frame;
- ASSERT_FALSE(frame.empty());
+ cv::Mat frame;
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- cv::gpu::MOG_GPU mog;
- cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+ cv::gpu::MOG_GPU mog;
+ cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
- cv::BackgroundSubtractorMOG mog_gold;
- cv::Mat foreground_gold;
+ cv::BackgroundSubtractorMOG mog_gold;
+ cv::Mat foreground_gold;
- for (int i = 0; i < 10; ++i)
- {
- cap >> frame;
- ASSERT_FALSE(frame.empty());
+ for (int i = 0; i < 10; ++i)
+ {
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- if (useGray)
- {
- cv::Mat temp;
- cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
- cv::swap(temp, frame);
- }
+ if (useGray)
+ {
+ cv::Mat temp;
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+ cv::swap(temp, frame);
+ }
- mog(loadMat(frame, useRoi), foreground, (float)learningRate);
+ mog(loadMat(frame, useRoi), foreground, (float)learningRate);
- mog_gold(frame, foreground_gold, learningRate);
+ mog_gold(frame, foreground_gold, learningRate);
- ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
- }
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
}
}
TEST_P(MOG2, Update)
{
- try
- {
- cv::VideoCapture cap(inputFile);
- ASSERT_TRUE(cap.isOpened());
+ cv::VideoCapture cap(inputFile);
+ ASSERT_TRUE(cap.isOpened());
- cv::Mat frame;
- cap >> frame;
- ASSERT_FALSE(frame.empty());
+ cv::Mat frame;
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- cv::gpu::MOG2_GPU mog2;
- cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+ cv::gpu::MOG2_GPU mog2;
+ cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
- cv::BackgroundSubtractorMOG2 mog2_gold;
- cv::Mat foreground_gold;
+ cv::BackgroundSubtractorMOG2 mog2_gold;
+ cv::Mat foreground_gold;
- for (int i = 0; i < 10; ++i)
- {
- cap >> frame;
- ASSERT_FALSE(frame.empty());
+ for (int i = 0; i < 10; ++i)
+ {
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- if (useGray)
- {
- cv::Mat temp;
- cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
- cv::swap(temp, frame);
- }
+ if (useGray)
+ {
+ cv::Mat temp;
+ cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+ cv::swap(temp, frame);
+ }
- mog2(loadMat(frame, useRoi), foreground);
+ mog2(loadMat(frame, useRoi), foreground);
- mog2_gold(frame, foreground_gold);
+ mog2_gold(frame, foreground_gold);
- double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
+ double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
- norm /= foreground_gold.size().area();
+ norm /= foreground_gold.size().area();
- ASSERT_LE(norm, 0.09);
- }
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ ASSERT_LE(norm, 0.09);
}
}
if (useGray)
return;
- try
- {
- cv::VideoCapture cap(inputFile);
- ASSERT_TRUE(cap.isOpened());
+ cv::VideoCapture cap(inputFile);
+ ASSERT_TRUE(cap.isOpened());
- cv::Mat frame;
+ cv::Mat frame;
- cv::gpu::MOG2_GPU mog2;
- cv::gpu::GpuMat foreground;
+ cv::gpu::MOG2_GPU mog2;
+ cv::gpu::GpuMat foreground;
- cv::BackgroundSubtractorMOG2 mog2_gold;
- cv::Mat foreground_gold;
+ cv::BackgroundSubtractorMOG2 mog2_gold;
+ cv::Mat foreground_gold;
- for (int i = 0; i < 10; ++i)
- {
- cap >> frame;
- ASSERT_FALSE(frame.empty());
+ for (int i = 0; i < 10; ++i)
+ {
+ cap >> frame;
+ ASSERT_FALSE(frame.empty());
- mog2(loadMat(frame, useRoi), foreground);
+ mog2(loadMat(frame, useRoi), foreground);
- mog2_gold(frame, foreground_gold);
- }
+ mog2_gold(frame, foreground_gold);
+ }
- cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
- mog2.getBackgroundImage(background);
+ cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
+ mog2.getBackgroundImage(background);
- cv::Mat background_gold;
- mog2_gold.getBackgroundImage(background_gold);
+ cv::Mat background_gold;
+ mog2_gold.getBackgroundImage(background_gold);
- ASSERT_MAT_NEAR(background_gold, background, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ ASSERT_MAT_NEAR(background_gold, background, 0);
}
INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
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);
- const int type = GET_PARAM(2);
- const bool useRoi = GET_PARAM(3);
-
- const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+ const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+ cv::gpu::setDevice(devInfo.deviceID());
+ const cv::Size size = GET_PARAM(1);
+ const int type = GET_PARAM(2);
+ const bool useRoi = GET_PARAM(3);
- cv::Mat frame = randomMat(size, type, 0.0, 100);
- cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+ const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
- cv::gpu::VIBE_GPU vibe;
- cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
- vibe.initialize(d_frame);
+ cv::Mat frame = randomMat(size, type, 0.0, 100);
+ cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
- for (int i = 0; i < 20; ++i)
- vibe(d_frame, d_fgmask);
+ cv::gpu::VIBE_GPU vibe;
+ cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+ vibe.initialize(d_frame);
- frame = randomMat(size, type, 160, 255);
- d_frame = loadMat(frame, useRoi);
+ for (int i = 0; i < 20; ++i)
vibe(d_frame, d_fgmask);
- // now fgmask should be entirely foreground
- ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ frame = randomMat(size, type, 160, 255);
+ d_frame = loadMat(frame, useRoi);
+ vibe(d_frame, d_fgmask);
+
+ // now fgmask should be entirely foreground
+ ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
}
INSTANTIATE_TEST_CASE_P(GPU_Video, VIBE, testing::Combine(
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);
- const int depth = GET_PARAM(2);
- const int channels = GET_PARAM(3);
- const bool useRoi = GET_PARAM(4);
-
- const int type = CV_MAKE_TYPE(depth, channels);
+ const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+ cv::gpu::setDevice(devInfo.deviceID());
+ const cv::Size size = GET_PARAM(1);
+ const int depth = GET_PARAM(2);
+ const int channels = GET_PARAM(3);
+ const bool useRoi = GET_PARAM(4);
- const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
- const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+ const int type = CV_MAKE_TYPE(depth, channels);
- cv::Mat frame = randomMat(size, type, 0, 100);
- cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+ const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
+ const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
- cv::gpu::GMG_GPU gmg;
- gmg.numInitializationFrames = 5;
- gmg.smoothingRadius = 0;
- gmg.initialize(d_frame.size(), 0, 255);
+ cv::Mat frame = randomMat(size, type, 0, 100);
+ cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
- cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+ cv::gpu::GMG_GPU gmg;
+ gmg.numInitializationFrames = 5;
+ gmg.smoothingRadius = 0;
+ gmg.initialize(d_frame.size(), 0, 255);
- for (int i = 0; i < gmg.numInitializationFrames; ++i)
- {
- gmg(d_frame, d_fgmask);
-
- // fgmask should be entirely background during training
- ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
- }
+ cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
- frame = randomMat(size, type, 160, 255);
- d_frame = loadMat(frame, useRoi);
+ for (int i = 0; i < gmg.numInitializationFrames; ++i)
+ {
gmg(d_frame, d_fgmask);
- // now fgmask should be entirely foreground
- ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
+ // fgmask should be entirely background during training
+ ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
}
+
+ frame = randomMat(size, type, 160, 255);
+ d_frame = loadMat(frame, useRoi);
+ gmg(d_frame, d_fgmask);
+
+ // now fgmask should be entirely foreground
+ ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
}
INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
TEST_P(VideoWriter, Regression)
{
- try
- {
- const double FPS = 25.0;
+ const double FPS = 25.0;
- cv::VideoCapture reader(inputFile);
- ASSERT_TRUE( reader.isOpened() );
+ cv::VideoCapture reader(inputFile);
+ ASSERT_TRUE( reader.isOpened() );
- cv::gpu::VideoWriter_GPU d_writer;
+ cv::gpu::VideoWriter_GPU d_writer;
- cv::Mat frame;
- cv::gpu::GpuMat d_frame;
+ cv::Mat frame;
+ cv::gpu::GpuMat d_frame;
- for (int i = 0; i < 10; ++i)
- {
- reader >> frame;
- ASSERT_FALSE(frame.empty());
+ for (int i = 0; i < 10; ++i)
+ {
+ reader >> frame;
+ ASSERT_FALSE(frame.empty());
- d_frame.upload(frame);
+ d_frame.upload(frame);
- if (!d_writer.isOpened())
- d_writer.open(outputFile, frame.size(), FPS);
+ if (!d_writer.isOpened())
+ d_writer.open(outputFile, frame.size(), FPS);
- d_writer.write(d_frame);
- }
+ d_writer.write(d_frame);
+ }
- reader.release();
- d_writer.close();
+ reader.release();
+ d_writer.close();
- reader.open(outputFile);
- ASSERT_TRUE( reader.isOpened() );
+ reader.open(outputFile);
+ ASSERT_TRUE( reader.isOpened() );
- for (int i = 0; i < 5; ++i)
- {
- reader >> frame;
- ASSERT_FALSE( frame.empty() );
- }
- }
- catch (...)
+ for (int i = 0; i < 5; ++i)
{
- cv::gpu::resetDevice();
- throw;
+ reader >> frame;
+ ASSERT_FALSE( frame.empty() );
}
}
TEST_P(VideoReader, Regression)
{
- try
- {
- cv::gpu::VideoReader_GPU reader(inputFile);
- ASSERT_TRUE( reader.isOpened() );
+ cv::gpu::VideoReader_GPU reader(inputFile);
+ ASSERT_TRUE( reader.isOpened() );
- cv::gpu::GpuMat frame;
+ cv::gpu::GpuMat frame;
- for (int i = 0; i < 10; ++i)
- {
- ASSERT_TRUE( reader.read(frame) );
- ASSERT_FALSE( frame.empty() );
- }
-
- reader.close();
- ASSERT_FALSE( reader.isOpened() );
- }
- catch (...)
+ for (int i = 0; i < 10; ++i)
{
- cv::gpu::resetDevice();
- throw;
+ ASSERT_TRUE( reader.read(frame) );
+ ASSERT_FALSE( frame.empty() );
}
+
+ reader.close();
+ ASSERT_FALSE( reader.isOpened() );
}
INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
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);
+ cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+ cv::gpu::GpuMat xmap, ymap;
+ cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
- int interpolation = cv::INTER_NEAREST;
- int borderMode = cv::BORDER_CONSTANT;
+ int interpolation = cv::INTER_NEAREST;
+ int borderMode = cv::BORDER_CONSTANT;
- cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
- cv::Mat dst;
- cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
+ cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+ cv::Mat dst;
+ cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
- int flags = interpolation;
- if (inverse)
- flags |= cv::WARP_INVERSE_MAP;
- cv::Mat dst_gold;
- cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
+ int flags = interpolation;
+ if (inverse)
+ flags |= cv::WARP_INVERSE_MAP;
+ cv::Mat dst_gold;
+ cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpAffineMaps, testing::Combine(
TEST_P(WarpAffine, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
- int flags = interpolation;
- if (inverse)
- flags |= cv::WARP_INVERSE_MAP;
- cv::Scalar val = randomScalar(0.0, 255.0);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
+ int flags = interpolation;
+ if (inverse)
+ flags |= cv::WARP_INVERSE_MAP;
+ cv::Scalar val = randomScalar(0.0, 255.0);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
- cv::Mat dst_gold;
- warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
+ cv::Mat dst_gold;
+ warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine(
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;
- if (inverse)
- flags |= cv::WARP_INVERSE_MAP;
+ cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+ cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
+ int flags = interpolation;
+ if (inverse)
+ flags |= cv::WARP_INVERSE_MAP;
- cv::gpu::GpuMat dst;
- cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags);
+ cv::gpu::GpuMat dst;
+ cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags);
- cv::Mat dst_gold;
- warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
+ cv::Mat dst_gold;
+ warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
- EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine(
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);
+ cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+ cv::gpu::GpuMat xmap, ymap;
+ cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
- cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
- cv::Mat dst;
- cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
+ cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+ cv::Mat dst;
+ cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
- int flags = cv::INTER_NEAREST;
- if (inverse)
- flags |= cv::WARP_INVERSE_MAP;
- cv::Mat dst_gold;
- cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
+ int flags = cv::INTER_NEAREST;
+ if (inverse)
+ flags |= cv::WARP_INVERSE_MAP;
+ cv::Mat dst_gold;
+ cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
- EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpPerspectiveMaps, testing::Combine(
TEST_P(WarpPerspective, Accuracy)
{
- try
- {
- cv::Mat src = randomMat(size, type);
- cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
- int flags = interpolation;
- if (inverse)
- flags |= cv::WARP_INVERSE_MAP;
- cv::Scalar val = randomScalar(0.0, 255.0);
+ cv::Mat src = randomMat(size, type);
+ cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
+ int flags = interpolation;
+ if (inverse)
+ flags |= cv::WARP_INVERSE_MAP;
+ cv::Scalar val = randomScalar(0.0, 255.0);
- cv::gpu::GpuMat dst = createMat(size, type, useRoi);
- cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
+ cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+ cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
- cv::Mat dst_gold;
- warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
+ cv::Mat dst_gold;
+ warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
- EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine(
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;
- if (inverse)
- flags |= cv::WARP_INVERSE_MAP;
+ cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+ cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
+ int flags = interpolation;
+ if (inverse)
+ flags |= cv::WARP_INVERSE_MAP;
- cv::gpu::GpuMat dst;
- cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags);
+ cv::gpu::GpuMat dst;
+ cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags);
- cv::Mat dst_gold;
- warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
+ cv::Mat dst_gold;
+ warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
- EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
- }
- catch (...)
- {
- cv::gpu::resetDevice();
- throw;
- }
+ EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
}
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(
projects / profile / ivi / opencv.git / commitdiff