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

removed ASSERT_NO_THROW

Browse Source
This commit is contained in:
Vladislav Vinogradov 2012-02-06 11:31:52 +00:00
parent 23af203e00
commit 75ac4362ca
9 changed files with 765 additions and 1252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

274
modules/gpu/test/test_arithm.cpp
View File

@ -88,13 +88,11 @@ TEST_P(Add, Array)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -106,13 +104,11 @@ TEST_P(Add, Scalar)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::add(loadMat(mat1, useRoi), val, gpuRes);
cv::gpu::add(loadMat(mat1, useRoi), val, gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
@ -134,13 +130,11 @@ TEST_P(Subtract, Array)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -152,13 +146,11 @@ TEST_P(Subtract, Scalar)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::subtract(loadMat(mat1, useRoi), val, gpuRes);
cv::gpu::subtract(loadMat(mat1, useRoi), val, gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
@ -180,13 +172,11 @@ TEST_P(Multiply, Array)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -198,13 +188,11 @@ TEST_P(Multiply, Scalar)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::multiply(loadMat(mat1, useRoi), val, gpuRes);
cv::gpu::multiply(loadMat(mat1, useRoi), val, gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
@ -226,13 +214,11 @@ TEST_P(Divide, Array)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
}
@ -244,13 +230,11 @@ TEST_P(Divide, Scalar)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::divide(loadMat(mat1, useRoi), val, gpuRes);
cv::gpu::divide(loadMat(mat1, useRoi), val, gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
@ -272,13 +256,11 @@ TEST_P(Transpose, Accuracy)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::transpose(loadMat(mat1, useRoi), gpuRes);
cv::gpu::transpose(loadMat(mat1, useRoi), gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -300,13 +282,11 @@ TEST_P(Absdiff, Array)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::absdiff(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
cv::gpu::absdiff(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -318,13 +298,11 @@ TEST_P(Absdiff, Scalar)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::absdiff(loadMat(mat1, useRoi), val, gpuRes);
cv::gpu::absdiff(loadMat(mat1, useRoi), val, gpuRes);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
@ -373,13 +351,11 @@ TEST_P(Compare, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuRes;
cv::gpu::GpuMat gpuRes;
cv::gpu::compare(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes, cmp_code);
cv::gpu::compare(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuRes, cmp_code);
gpuRes.download(dst);
);
gpuRes.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -426,9 +402,7 @@ TEST_P(MeanStdDev, Accuracy)
cv::Scalar mean;
cv::Scalar stddev;
ASSERT_NO_THROW(
cv::gpu::meanStdDev(loadMat(mat, useRoi), mean, stddev);
);
cv::gpu::meanStdDev(loadMat(mat, useRoi), mean, stddev);
EXPECT_NEAR(mean_gold[0], mean[0], 1e-5);
EXPECT_NEAR(mean_gold[1], mean[1], 1e-5);
@ -480,11 +454,7 @@ PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, NormCode, UseRoi)
TEST_P(NormDiff, Accuracy)
{
double norm;
ASSERT_NO_THROW(
norm = cv::gpu::norm(loadMat(mat1, useRoi), loadMat(mat2, useRoi), normCode);
);
double norm = cv::gpu::norm(loadMat(mat1, useRoi), loadMat(mat2, useRoi), normCode);
EXPECT_NEAR(norm_gold, norm, 1e-6);
}
@ -532,13 +502,11 @@ TEST_P(Flip, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpu_res;
cv::gpu::GpuMat gpu_res;
cv::gpu::flip(loadMat(mat, useRoi), gpu_res, flip_code);
cv::gpu::flip(loadMat(mat, useRoi), gpu_res, flip_code);
gpu_res.download(dst);
);
gpu_res.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -587,13 +555,11 @@ TEST_P(LUT, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpu_res;
cv::gpu::GpuMat gpu_res;
cv::gpu::LUT(loadMat(mat, useRoi), lut, gpu_res);
cv::gpu::LUT(loadMat(mat, useRoi), lut, gpu_res);
gpu_res.download(dst);
);
gpu_res.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -637,13 +603,11 @@ TEST_P(Exp, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpu_res;
cv::gpu::GpuMat gpu_res;
cv::gpu::exp(loadMat(mat, useRoi), gpu_res);
cv::gpu::exp(loadMat(mat, useRoi), gpu_res);
gpu_res.download(dst);
);
gpu_res.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
@ -697,13 +661,11 @@ TEST_P(Pow, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpu_res;
cv::gpu::GpuMat gpu_res;
cv::gpu::pow(loadMat(mat, useRoi), power, gpu_res);
cv::gpu::pow(loadMat(mat, useRoi), power, gpu_res);
gpu_res.download(dst);
);
gpu_res.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 2);
}
@ -747,13 +709,11 @@ TEST_P(Log, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpu_res;
cv::gpu::GpuMat gpu_res;
cv::gpu::log(loadMat(mat, useRoi), gpu_res);
cv::gpu::log(loadMat(mat, useRoi), gpu_res);
gpu_res.download(dst);
);
gpu_res.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
@ -797,13 +757,11 @@ TEST_P(Magnitude, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpu_res;
cv::gpu::GpuMat gpu_res;
cv::gpu::magnitude(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpu_res);
cv::gpu::magnitude(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpu_res);
gpu_res.download(dst);
);
gpu_res.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
}
@ -847,13 +805,11 @@ TEST_P(Phase, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpu_res;
cv::gpu::GpuMat gpu_res;
cv::gpu::phase(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpu_res);
cv::gpu::phase(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpu_res);
gpu_res.download(dst);
);
gpu_res.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-3);
}
@ -898,15 +854,13 @@ TEST_P(CartToPolar, Accuracy)
{
cv::Mat mag, angle;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuMag;
cv::gpu::GpuMat gpuAngle;
cv::gpu::GpuMat gpuMag;
cv::gpu::GpuMat gpuAngle;
cv::gpu::cartToPolar(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuMag, gpuAngle);
cv::gpu::cartToPolar(loadMat(mat1, useRoi), loadMat(mat2, useRoi), gpuMag, gpuAngle);
gpuMag.download(mag);
gpuAngle.download(angle);
);
gpuMag.download(mag);
gpuAngle.download(angle);
EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
EXPECT_MAT_NEAR(angle_gold, angle, 1e-3);
@ -953,15 +907,13 @@ TEST_P(PolarToCart, Accuracy)
{
cv::Mat x, y;
ASSERT_NO_THROW(
cv::gpu::GpuMat gpuX;
cv::gpu::GpuMat gpuY;
cv::gpu::GpuMat gpuX;
cv::gpu::GpuMat gpuY;
cv::gpu::polarToCart(loadMat(mag, useRoi), loadMat(angle, useRoi), gpuX, gpuY);
cv::gpu::polarToCart(loadMat(mag, useRoi), loadMat(angle, useRoi), gpuX, gpuY);
gpuX.download(x);
gpuY.download(y);
);
gpuX.download(x);
gpuY.download(y);
EXPECT_MAT_NEAR(x_gold, x, 1e-4);
EXPECT_MAT_NEAR(y_gold, y, 1e-4);
@ -1036,9 +988,7 @@ TEST_P(MinMax, Accuracy)
double minVal, maxVal;
ASSERT_NO_THROW(
cv::gpu::minMax(loadMat(mat, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
);
cv::gpu::minMax(loadMat(mat, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
EXPECT_DOUBLE_EQ(minVal_gold, minVal);
EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
@ -1117,9 +1067,7 @@ TEST_P(MinMaxLoc, Accuracy)
double minVal, maxVal;
cv::Point minLoc, maxLoc;
ASSERT_NO_THROW(
cv::gpu::minMaxLoc(loadMat(mat, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
);
cv::gpu::minMaxLoc(loadMat(mat, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
EXPECT_DOUBLE_EQ(minVal_gold, minVal);
EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
@ -1178,11 +1126,7 @@ TEST_P(CountNonZero, Accuracy)
if (type == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
return;
int n;
ASSERT_NO_THROW(
n = cv::gpu::countNonZero(loadMat(mat, useRoi));
);
int n = cv::gpu::countNonZero(loadMat(mat, useRoi));
ASSERT_EQ(n_gold, n);
}
@ -1227,11 +1171,7 @@ TEST_P(Sum, Simple)
cv::Scalar sum_gold = cv::sum(mat);
cv::Scalar sum;
ASSERT_NO_THROW(
sum = cv::gpu::sum(loadMat(mat, useRoi));
);
cv::Scalar sum = cv::gpu::sum(loadMat(mat, useRoi));
EXPECT_NEAR(sum[0], sum_gold[0], mat.size().area() * 1e-5);
EXPECT_NEAR(sum[1], sum_gold[1], mat.size().area() * 1e-5);
@ -1246,11 +1186,7 @@ TEST_P(Sum, Abs)
cv::Scalar sum_gold = cv::norm(mat, cv::NORM_L1);
cv::Scalar sum;
ASSERT_NO_THROW(
sum = cv::gpu::absSum(loadMat(mat, useRoi));
);
cv::Scalar sum = cv::gpu::absSum(loadMat(mat, useRoi));
EXPECT_NEAR(sum[0], sum_gold[0], mat.size().area() * 1e-5);
EXPECT_NEAR(sum[1], sum_gold[1], mat.size().area() * 1e-5);
@ -1267,11 +1203,7 @@ TEST_P(Sum, Sqr)
multiply(mat, mat, sqrmat);
cv::Scalar sum_gold = sum(sqrmat);
cv::Scalar sum;
ASSERT_NO_THROW(
sum = cv::gpu::sqrSum(loadMat(mat, useRoi));
);
cv::Scalar sum = cv::gpu::sqrSum(loadMat(mat, useRoi));
EXPECT_NEAR(sum[0], sum_gold[0], mat.size().area() * 1e-5);
EXPECT_NEAR(sum[1], sum_gold[1], mat.size().area() * 1e-5);
@ -1330,13 +1262,11 @@ TEST_P(Bitwise, Not)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_dst;
cv::gpu::bitwise_not(loadMat(mat1), dev_dst);
cv::gpu::bitwise_not(loadMat(mat1), dev_dst);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -1350,13 +1280,11 @@ TEST_P(Bitwise, Or)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_dst;
cv::gpu::bitwise_or(loadMat(mat1), loadMat(mat2), dev_dst);
cv::gpu::bitwise_or(loadMat(mat1), loadMat(mat2), dev_dst);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -1370,13 +1298,11 @@ TEST_P(Bitwise, And)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_dst;
cv::gpu::bitwise_and(loadMat(mat1), loadMat(mat2), dev_dst);
cv::gpu::bitwise_and(loadMat(mat1), loadMat(mat2), dev_dst);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -1390,13 +1316,11 @@ TEST_P(Bitwise, Xor)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_dst;
cv::gpu::bitwise_xor(loadMat(mat1), loadMat(mat2), dev_dst);
cv::gpu::bitwise_xor(loadMat(mat1), loadMat(mat2), dev_dst);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -1457,13 +1381,11 @@ TEST_P(AddWeighted, Accuracy)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_dst;
cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dev_dst, dtype);
cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dev_dst, dtype);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, dtype < CV_32F ? 1.0 : 1e-12);
}
@ -1522,13 +1444,11 @@ TEST_P(Reduce, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_dst;
cv::gpu::reduce(loadMat(src, useRoi), dev_dst, dim, reduceOp, reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG ? CV_32F : CV_MAT_DEPTH(type));
cv::gpu::reduce(loadMat(src, useRoi), dev_dst, dim, reduceOp, reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG ? CV_32F : CV_MAT_DEPTH(type));
dev_dst.download(dst);
);
dev_dst.download(dst);
double norm = reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG ? 1e-1 : 0.0;
EXPECT_MAT_NEAR(dst_gold, dst, norm);
@ -1587,13 +1507,11 @@ TEST_P(GEMM, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_dst;
cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dev_dst, flags);
cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dev_dst, flags);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
}

52
modules/gpu/test/test_calib3d.cpp
View File

@ -77,14 +77,12 @@ TEST_P(StereoBlockMatching, Regression)
{
cv::Mat disp;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_disp;
cv::gpu::StereoBM_GPU bm(0, 128, 19);
cv::gpu::GpuMat dev_disp;
cv::gpu::StereoBM_GPU bm(0, 128, 19);
bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
dev_disp.download(disp);
);
dev_disp.download(disp);
disp.convertTo(disp, img_template.type());
@ -124,14 +122,12 @@ TEST_P(StereoBeliefPropagation, Regression)
{
cv::Mat disp;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_disp;
cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
cv::gpu::GpuMat dev_disp;
cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
dev_disp.download(disp);
);
dev_disp.download(disp);
disp.convertTo(disp, img_template.type());
@ -175,14 +171,12 @@ TEST_P(StereoConstantSpaceBP, Regression)
{
cv::Mat disp;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_disp;
cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4);
cv::gpu::GpuMat dev_disp;
cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4);
bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
dev_disp.download(disp);
);
dev_disp.download(disp);
disp.convertTo(disp, img_template.type());
@ -230,13 +224,11 @@ TEST_P(ProjectPoints, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat d_dst;
cv::gpu::GpuMat d_dst;
cv::gpu::projectPoints(cv::gpu::GpuMat(src), rvec, tvec, camera_mat, cv::Mat(), d_dst);
cv::gpu::projectPoints(cv::gpu::GpuMat(src), rvec, tvec, camera_mat, cv::Mat(), d_dst);
d_dst.download(dst);
);
d_dst.download(dst);
ASSERT_EQ(dst_gold.size(), dst.cols);
ASSERT_EQ(1, dst.rows);
@ -286,13 +278,11 @@ TEST_P(TransformPoints, Accuracy)
{
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat d_dst;
cv::gpu::GpuMat d_dst;
cv::gpu::transformPoints(cv::gpu::GpuMat(src), rvec, tvec, d_dst);
cv::gpu::transformPoints(cv::gpu::GpuMat(src), rvec, tvec, d_dst);
d_dst.download(dst);
);
d_dst.download(dst);
ASSERT_EQ(src.size(), dst.size());
ASSERT_EQ(src.type(), dst.type());
@ -356,10 +346,8 @@ TEST_P(SolvePnPRansac, Accuracy)
cv::Mat rvec, tvec;
std::vector<int> inliers;
ASSERT_NO_THROW(
cv::gpu::solvePnPRansac(object, cv::Mat(1, image_vec.size(), CV_32FC2, &image_vec[0]), camera_mat,
cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec, false, 200, 2.f, 100, &inliers);
);
cv::gpu::solvePnPRansac(object, cv::Mat(1, 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-3f);
ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3f);

182
modules/gpu/test/test_features2d.cpp
View File

@ -117,9 +117,7 @@ TEST_P(SURF, EmptyDataTest)
std::vector<cv::KeyPoint> keypoints;
std::vector<float> descriptors;
ASSERT_NO_THROW(
fdetector(image, cv::gpu::GpuMat(), keypoints, descriptors);
);
fdetector(image, cv::gpu::GpuMat(), keypoints, descriptors);
EXPECT_TRUE(keypoints.empty());
EXPECT_TRUE(descriptors.empty());
@ -130,14 +128,12 @@ TEST_P(SURF, Accuracy)
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_descriptors;
cv::gpu::SURF_GPU fdetector; fdetector.extended = false;
cv::gpu::GpuMat dev_descriptors;
cv::gpu::SURF_GPU fdetector; fdetector.extended = false;
fdetector(loadMat(image), loadMat(mask), keypoints, dev_descriptors);
fdetector(loadMat(image), loadMat(mask), keypoints, dev_descriptors);
dev_descriptors.download(descriptors);
);
dev_descriptors.download(descriptors);
cv::BruteForceMatcher< cv::L2<float> > matcher;
std::vector<cv::DMatch> matches;
@ -218,11 +214,9 @@ TEST_P(BruteForceMatcher, Match)
{
std::vector<cv::DMatch> matches;
ASSERT_NO_THROW(
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
matcher.match(loadMat(query), loadMat(train), matches);
);
matcher.match(loadMat(query), loadMat(train), matches);
ASSERT_EQ(queryDescCount, matches.size());
@ -244,28 +238,26 @@ TEST_P(BruteForceMatcher, MatchAdd)
bool isMaskSupported;
ASSERT_NO_THROW(
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
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));
}
matcher.match(cv::gpu::GpuMat(query), matches, masks);
matcher.match(cv::gpu::GpuMat(query), matches, masks);
isMaskSupported = matcher.isMaskSupported();
);
isMaskSupported = matcher.isMaskSupported();
ASSERT_EQ(queryDescCount, matches.size());
@ -297,10 +289,8 @@ TEST_P(BruteForceMatcher, KnnMatch2)
std::vector< std::vector<cv::DMatch> > matches;
ASSERT_NO_THROW(
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
matcher.knnMatch(loadMat(query), loadMat(train), matches, knn);
);
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
matcher.knnMatch(loadMat(query), loadMat(train), matches, knn);
ASSERT_EQ(queryDescCount, matches.size());
@ -331,10 +321,8 @@ TEST_P(BruteForceMatcher, KnnMatch3)
std::vector< std::vector<cv::DMatch> > matches;
ASSERT_NO_THROW(
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
matcher.knnMatch(loadMat(query), loadMat(train), matches, knn);
);
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
matcher.knnMatch(loadMat(query), loadMat(train), matches, knn);
ASSERT_EQ(queryDescCount, matches.size());
@ -366,28 +354,26 @@ TEST_P(BruteForceMatcher, KnnMatchAdd2)
bool isMaskSupported;
ASSERT_NO_THROW(
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
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));
}
matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
isMaskSupported = matcher.isMaskSupported();
);
isMaskSupported = matcher.isMaskSupported();
ASSERT_EQ(queryDescCount, matches.size());
@ -430,28 +416,26 @@ TEST_P(BruteForceMatcher, KnnMatchAdd3)
bool isMaskSupported;
ASSERT_NO_THROW(
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
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));
}
matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
isMaskSupported = matcher.isMaskSupported();
);
isMaskSupported = matcher.isMaskSupported();
ASSERT_EQ(queryDescCount, matches.size());
@ -497,11 +481,9 @@ TEST_P(BruteForceMatcher, RadiusMatch)
std::vector< std::vector<cv::DMatch> > matches;
ASSERT_NO_THROW(
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
);
matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
ASSERT_EQ(queryDescCount, matches.size());
@ -533,28 +515,26 @@ TEST_P(BruteForceMatcher, RadiusMatchAdd)
bool isMaskSupported;
ASSERT_NO_THROW(
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
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));
}
matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks);
matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks);
isMaskSupported = matcher.isMaskSupported();
);
isMaskSupported = matcher.isMaskSupported();
ASSERT_EQ(queryDescCount, matches.size());
@ -647,11 +627,9 @@ TEST_P(FAST, Accuracy)
{
std::vector<cv::KeyPoint> keypoints;
ASSERT_NO_THROW(
cv::gpu::FAST_GPU fastGPU(threshold);
cv::gpu::FAST_GPU fastGPU(threshold);
fastGPU(cv::gpu::GpuMat(image), cv::gpu::GpuMat(), keypoints);
);
fastGPU(cv::gpu::GpuMat(image), cv::gpu::GpuMat(), keypoints);
ASSERT_EQ(keypoints.size(), keypoints_gold.size());
@ -711,14 +689,12 @@ TEST_P(ORB, Accuracy)
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
ASSERT_NO_THROW(
cv::gpu::ORB_GPU orbGPU(npoints);
cv::gpu::GpuMat d_descriptors;
cv::gpu::ORB_GPU orbGPU(npoints);
cv::gpu::GpuMat d_descriptors;
orbGPU(cv::gpu::GpuMat(image), cv::gpu::GpuMat(mask), keypoints, d_descriptors);
orbGPU(cv::gpu::GpuMat(image), cv::gpu::GpuMat(mask), keypoints, d_descriptors);
d_descriptors.download(descriptors);
);
d_descriptors.download(descriptors);
cv::BruteForceMatcher<cv::Hamming> matcher;
std::vector<cv::DMatch> matches;

128
modules/gpu/test/test_filters.cpp
View File

@ -107,13 +107,11 @@ TEST_P(Blur, Rgba)
{
cv::Mat dst_rgba;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::blur(loadMat(img_rgba, useRoi), dev_dst_rgba, ksize);
cv::gpu::blur(loadMat(img_rgba, useRoi), dev_dst_rgba, ksize);
dev_dst_rgba.download(dst_rgba);
);
dev_dst_rgba.download(dst_rgba);
EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 1.0);
}
@ -122,13 +120,11 @@ TEST_P(Blur, Gray)
{
cv::Mat dst_gray;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::blur(loadMat(img_gray, useRoi), dev_dst_gray, ksize);
cv::gpu::blur(loadMat(img_gray, useRoi), dev_dst_gray, ksize);
dev_dst_gray.download(dst_gray);
);
dev_dst_gray.download(dst_gray);
EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 1.0);
}
@ -186,13 +182,11 @@ TEST_P(Sobel, Rgba)
cv::Mat dst_rgba;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::Sobel(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, dx, dy, ksize);
cv::gpu::Sobel(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, dx, dy, ksize);
dev_dst_rgba.download(dst_rgba);
);
dev_dst_rgba.download(dst_rgba);
EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 0.0);
}
@ -204,13 +198,11 @@ TEST_P(Sobel, Gray)
cv::Mat dst_gray;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::Sobel(loadMat(img_gray, useRoi), dev_dst_gray, -1, dx, dy, ksize);
cv::gpu::Sobel(loadMat(img_gray, useRoi), dev_dst_gray, -1, dx, dy, ksize);
dev_dst_gray.download(dst_gray);
);
dev_dst_gray.download(dst_gray);
EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 0.0);
}
@ -268,13 +260,11 @@ TEST_P(Scharr, Rgba)
cv::Mat dst_rgba;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::Scharr(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, dx, dy);
cv::gpu::Scharr(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, dx, dy);
dev_dst_rgba.download(dst_rgba);
);
dev_dst_rgba.download(dst_rgba);
EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
}
@ -286,13 +276,11 @@ TEST_P(Scharr, Gray)
cv::Mat dst_gray;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::Scharr(loadMat(img_gray, useRoi), dev_dst_gray, -1, dx, dy);
cv::gpu::Scharr(loadMat(img_gray, useRoi), dev_dst_gray, -1, dx, dy);
dev_dst_gray.download(dst_gray);
);
dev_dst_gray.download(dst_gray);
EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
}
@ -348,13 +336,11 @@ TEST_P(GaussianBlur, Rgba)
{
cv::Mat dst_rgba;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GaussianBlur(loadMat(img_rgba, useRoi), dev_dst_rgba, ksize, sigma1, sigma2);
cv::gpu::GaussianBlur(loadMat(img_rgba, useRoi), dev_dst_rgba, ksize, sigma1, sigma2);
dev_dst_rgba.download(dst_rgba);
);
dev_dst_rgba.download(dst_rgba);
EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 3.0);
}
@ -363,13 +349,11 @@ TEST_P(GaussianBlur, Gray)
{
cv::Mat dst_gray;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GaussianBlur(loadMat(img_gray, useRoi), dev_dst_gray, ksize, sigma1, sigma2);
cv::gpu::GaussianBlur(loadMat(img_gray, useRoi), dev_dst_gray, ksize, sigma1, sigma2);
dev_dst_gray.download(dst_gray);
);
dev_dst_gray.download(dst_gray);
EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 3.0);
}
@ -417,13 +401,11 @@ TEST_P(Laplacian, Rgba)
{
cv::Mat dst_rgba;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::Laplacian(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, ksize);
cv::gpu::Laplacian(loadMat(img_rgba, useRoi), dev_dst_rgba, -1, ksize);
dev_dst_rgba.download(dst_rgba);
);
dev_dst_rgba.download(dst_rgba);
EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
}
@ -432,13 +414,11 @@ TEST_P(Laplacian, Gray)
{
cv::Mat dst_gray;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::Laplacian(loadMat(img_gray, useRoi), dev_dst_gray, -1, ksize);
cv::gpu::Laplacian(loadMat(img_gray, useRoi), dev_dst_gray, -1, ksize);
dev_dst_gray.download(dst_gray);
);
dev_dst_gray.download(dst_gray);
EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
}
@ -488,13 +468,11 @@ TEST_P(Erode, Rgba)
{
cv::Mat dst_rgba;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::erode(loadMat(img_rgba, useRoi), dev_dst_rgba, kernel);
cv::gpu::erode(loadMat(img_rgba, useRoi), dev_dst_rgba, kernel);
dev_dst_rgba.download(dst_rgba);
);
dev_dst_rgba.download(dst_rgba);
EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
}
@ -503,13 +481,11 @@ TEST_P(Erode, Gray)
{
cv::Mat dst_gray;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::erode(loadMat(img_gray, useRoi), dev_dst_gray, kernel);
cv::gpu::erode(loadMat(img_gray, useRoi), dev_dst_gray, kernel);
dev_dst_gray.download(dst_gray);
);
dev_dst_gray.download(dst_gray);
EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
}
@ -558,13 +534,11 @@ TEST_P(Dilate, Rgba)
{
cv::Mat dst_rgba;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::dilate(loadMat(img_rgba, useRoi), dev_dst_rgba, kernel);
cv::gpu::dilate(loadMat(img_rgba, useRoi), dev_dst_rgba, kernel);
dev_dst_rgba.download(dst_rgba);
);
dev_dst_rgba.download(dst_rgba);
EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
}
@ -573,13 +547,11 @@ TEST_P(Dilate, Gray)
{
cv::Mat dst_gray;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::dilate(loadMat(img_gray, useRoi), dev_dst_gray, kernel);
cv::gpu::dilate(loadMat(img_gray, useRoi), dev_dst_gray, kernel);
dev_dst_gray.download(dst_gray);
);
dev_dst_gray.download(dst_gray);
EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
}
@ -630,13 +602,11 @@ TEST_P(MorphEx, Rgba)
{
cv::Mat dst_rgba;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::GpuMat dev_dst_rgba;
cv::gpu::morphologyEx(loadMat(img_rgba, useRoi), dev_dst_rgba, morphOp, kernel);
cv::gpu::morphologyEx(loadMat(img_rgba, useRoi), dev_dst_rgba, morphOp, kernel);
dev_dst_rgba.download(dst_rgba);
);
dev_dst_rgba.download(dst_rgba);
EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 4, 0.0);
}
@ -645,13 +615,11 @@ TEST_P(MorphEx, Gray)
{
cv::Mat dst_gray;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::GpuMat dev_dst_gray;
cv::gpu::morphologyEx(loadMat(img_gray, useRoi), dev_dst_gray, morphOp, kernel);
cv::gpu::morphologyEx(loadMat(img_gray, useRoi), dev_dst_gray, morphOp, kernel);
dev_dst_gray.download(dst_gray);
);
dev_dst_gray.download(dst_gray);
EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 4, 0.0);
}

12
modules/gpu/test/test_hog.cpp
View File

@ -186,10 +186,8 @@ struct Detect : TestWithParam<cv::gpu::DeviceInfo>
TEST_P(Detect, Accuracy)
{
ASSERT_NO_THROW(
CV_GpuHogDetectTestRunner runner;
runner.run();
);
CV_GpuHogDetectTestRunner runner;
runner.run();
}
INSTANTIATE_TEST_CASE_P(HOG, Detect, ALL_DEVICES);
@ -316,10 +314,8 @@ struct GetDescriptors : TestWithParam<cv::gpu::DeviceInfo>
TEST_P(GetDescriptors, Accuracy)
{
ASSERT_NO_THROW(
CV_GpuHogGetDescriptorsTestRunner runner;
runner.run();
);
CV_GpuHogGetDescriptorsTestRunner runner;
runner.run();
}
INSTANTIATE_TEST_CASE_P(HOG, GetDescriptors, ALL_DEVICES);

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

File diff suppressed because it is too large Load Diff

152
modules/gpu/test/test_matop.cpp
View File

@ -90,17 +90,15 @@ TEST_P(Merge, Accuracy)
cv::Mat dst;
ASSERT_NO_THROW(
std::vector<cv::gpu::GpuMat> dev_src;
cv::gpu::GpuMat dev_dst;
std::vector<cv::gpu::GpuMat> dev_src;
cv::gpu::GpuMat dev_dst;
for (size_t i = 0; i < src.size(); ++i)
dev_src.push_back(loadMat(src[i], useRoi));
for (size_t i = 0; i < src.size(); ++i)
dev_src.push_back(loadMat(src[i], useRoi));
cv::gpu::merge(dev_src, dev_dst);
cv::gpu::merge(dev_src, dev_dst);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -149,16 +147,14 @@ TEST_P(Split, Accuracy)
std::vector<cv::Mat> dst;
ASSERT_NO_THROW(
std::vector<cv::gpu::GpuMat> dev_dst;
std::vector<cv::gpu::GpuMat> dev_dst;
cv::gpu::split(loadMat(src, useRoi), dev_dst);
cv::gpu::split(loadMat(src, useRoi), dev_dst);
dst.resize(dev_dst.size());
dst.resize(dev_dst.size());
for (size_t i = 0; i < dev_dst.size(); ++i)
dev_dst[i].download(dst[i]);
);
for (size_t i = 0; i < dev_dst.size(); ++i)
dev_dst[i].download(dst[i]);
ASSERT_EQ(dst_gold.size(), dst.size());
@ -207,15 +203,13 @@ TEST_P(SplitMerge, Consistency)
cv::Mat final;
ASSERT_NO_THROW(
std::vector<cv::gpu::GpuMat> dev_vec;
cv::gpu::GpuMat dev_final;
std::vector<cv::gpu::GpuMat> dev_vec;
cv::gpu::GpuMat dev_final;
cv::gpu::split(loadMat(orig), dev_vec);
cv::gpu::merge(dev_vec, dev_final);
cv::gpu::split(loadMat(orig), dev_vec);
cv::gpu::merge(dev_vec, dev_final);
dev_final.download(final);
);
dev_final.download(final);
EXPECT_MAT_NEAR(orig, final, 0.0);
}
@ -261,14 +255,12 @@ TEST_P(SetTo, Zero)
cv::Mat mat;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
mat_gold.setTo(zero);
dev_mat.setTo(zero);
mat_gold.setTo(zero);
dev_mat.setTo(zero);
dev_mat.download(mat);
);
dev_mat.download(mat);
EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
}
@ -282,14 +274,12 @@ TEST_P(SetTo, SameVal)
cv::Mat mat;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_mat(mat_gold);
cv::gpu::GpuMat dev_mat(mat_gold);
mat_gold.setTo(s);
dev_mat.setTo(s);
mat_gold.setTo(s);
dev_mat.setTo(s);
dev_mat.download(mat);
);
dev_mat.download(mat);
EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
}
@ -303,14 +293,12 @@ TEST_P(SetTo, DifferentVal)
cv::Mat mat;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
mat_gold.setTo(s);
dev_mat.setTo(s);
mat_gold.setTo(s);
dev_mat.setTo(s);
dev_mat.download(mat);
);
dev_mat.download(mat);
EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
}
@ -327,14 +315,12 @@ TEST_P(SetTo, Masked)
cv::Mat mat;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
cv::gpu::GpuMat dev_mat = loadMat(mat_gold, useRoi);
mat_gold.setTo(s, mask);
dev_mat.setTo(s, loadMat(mask, useRoi));
mat_gold.setTo(s, mask);
dev_mat.setTo(s, loadMat(mask, useRoi));
dev_mat.download(mat);
);
dev_mat.download(mat);
EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
}
@ -382,14 +368,12 @@ TEST_P(CopyTo, WithoutMask)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
cv::gpu::GpuMat dev_dst = loadMat(src, useRoi);
cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
cv::gpu::GpuMat dev_dst = loadMat(src, useRoi);
dev_src.copyTo(dev_dst);
dev_src.copyTo(dev_dst);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -410,14 +394,12 @@ TEST_P(CopyTo, Masked)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
cv::gpu::GpuMat dev_dst = loadMat(zeroMat, useRoi);
cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
cv::gpu::GpuMat dev_dst = loadMat(zeroMat, useRoi);
dev_src.copyTo(dev_dst, loadMat(mask, useRoi));
dev_src.copyTo(dev_dst, loadMat(mask, useRoi));
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -467,14 +449,12 @@ TEST_P(ConvertTo, WithoutScaling)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
cv::gpu::GpuMat dev_dst;
dev_src.convertTo(dev_dst, depth2);
dev_src.convertTo(dev_dst, depth2);
dev_dst.download(dst);
);
dev_dst.download(dst);
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
}
@ -494,15 +474,13 @@ TEST_P(ConvertTo, WithScaling)
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
cv::gpu::GpuMat dev_src = loadMat(src, useRoi);
cv::gpu::GpuMat dev_dst;
cv::gpu::GpuMat dev_dst;
dev_src.convertTo(dev_dst, depth2, a, b);
dev_src.convertTo(dev_dst, depth2, a, b);
dev_dst.download(dst);
);
dev_dst.download(dst);
const double eps = depth2 < CV_32F ? 1 : 1e-4;
@ -549,30 +527,28 @@ TEST_P(Async, Accuracy)
{
cv::Mat dst0, dst1;
ASSERT_NO_THROW(
cv::gpu::CudaMem cpudst0;
cv::gpu::CudaMem cpudst1;
cv::gpu::CudaMem cpudst0;
cv::gpu::CudaMem cpudst1;
cv::gpu::GpuMat gpusrc;
cv::gpu::GpuMat gpudst0;
cv::gpu::GpuMat gpudst1(src.rows, src.cols, CV_8UC1);
cv::gpu::GpuMat gpusrc;
cv::gpu::GpuMat gpudst0;
cv::gpu::GpuMat gpudst1(src.rows, src.cols, CV_8UC1);
cv::gpu::Stream stream0;
cv::gpu::Stream stream1;
cv::gpu::Stream stream0;
cv::gpu::Stream stream1;
stream0.enqueueUpload(src, gpusrc);
cv::gpu::bitwise_not(gpusrc, gpudst0, cv::gpu::GpuMat(), stream0);
stream0.enqueueDownload(gpudst0, cpudst0);
stream0.enqueueUpload(src, gpusrc);
cv::gpu::bitwise_not(gpusrc, gpudst0, cv::gpu::GpuMat(), stream0);
stream0.enqueueDownload(gpudst0, cpudst0);
stream1.enqueueMemSet(gpudst1, cv::Scalar::all(128));
stream1.enqueueDownload(gpudst1, cpudst1);
stream1.enqueueMemSet(gpudst1, cv::Scalar::all(128));
stream1.enqueueDownload(gpudst1, cpudst1);
stream0.waitForCompletion();
stream1.waitForCompletion();
stream0.waitForCompletion();
stream1.waitForCompletion();
dst0 = cpudst0.createMatHeader();
dst1 = cpudst1.createMatHeader();
);
dst0 = cpudst0.createMatHeader();
dst1 = cpudst1.createMatHeader();
EXPECT_MAT_NEAR(dst_gold0, dst0, 0.0);
EXPECT_MAT_NEAR(dst_gold1, dst1, 0.0);

66
modules/gpu/test/test_nvidia.cpp
View File

@ -88,121 +88,77 @@ OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
TEST_P(NPPST, Integral)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NPPST, SquaredIntegral)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NPPST_Squared_Integral_Image(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NPPST_Squared_Integral_Image(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NPPST, RectStdDev)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NPPST_RectStdDev(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NPPST_RectStdDev(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NPPST, Resize)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NPPST_Resize(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NPPST_Resize(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NPPST, VectorOperations)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NPPST_Vector_Operations(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NPPST_Vector_Operations(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NPPST, Transpose)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NPPST_Transpose(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NPPST_Transpose(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NCV, VectorOperations)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NCV_Vector_Operations(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NCV_Vector_Operations(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NCV, HaarCascadeLoader)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NCV_Haar_Cascade_Loader(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NCV_Haar_Cascade_Loader(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NCV, HaarCascadeApplication)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NCV_Haar_Cascade_Application(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NCV_Haar_Cascade_Application(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NCV, HypothesesFiltration)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NCV_Hypotheses_Filtration(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NCV_Hypotheses_Filtration(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}
TEST_P(NCV, Visualization)
{
bool res;
ASSERT_NO_THROW(
res = nvidia_NCV_Visualization(path, nvidiaTestOutputLevel);
);
bool res = nvidia_NCV_Visualization(path, nvidiaTestOutputLevel);
ASSERT_TRUE(res);
}

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

@ -117,14 +117,13 @@ TEST_P(BroxOpticalFlow, Regression)
cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
ASSERT_NO_THROW(
cv::gpu::GpuMat d_u;
cv::gpu::GpuMat d_v;
d_flow(cv::gpu::GpuMat(frame0), cv::gpu::GpuMat(frame1), d_u, d_v);
d_u.download(u);
d_v.download(v);
d_flow.buf.release();
);
cv::gpu::GpuMat d_u;
cv::gpu::GpuMat d_v;
d_flow(cv::gpu::GpuMat(frame0), cv::gpu::GpuMat(frame1), d_u, d_v);
d_u.download(u);
d_v.download(v);
#ifndef DUMP
@ -212,21 +211,23 @@ TEST_P(InterpolateFrames, Regression)
cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
ASSERT_NO_THROW(
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
cv::gpu::GpuMat d_fu;
cv::gpu::GpuMat d_fv;
cv::gpu::GpuMat d_bu;
cv::gpu::GpuMat d_bv;
cv::gpu::GpuMat d_newFrame;
cv::gpu::GpuMat d_buf;
d_flow(d_frame0, d_frame1, d_fu, d_fv);
d_flow(d_frame1, d_frame0, d_bu, d_bv);
cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
d_newFrame.download(newFrame);
d_flow.buf.release();
);
cv::gpu::GpuMat d_frame0(frame0);
cv::gpu::GpuMat d_frame1(frame1);
cv::gpu::GpuMat d_fu;
cv::gpu::GpuMat d_fv;
cv::gpu::GpuMat d_bu;
cv::gpu::GpuMat 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::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
d_newFrame.download(newFrame);
#ifndef DUMP