Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

ts: refactor OpenCV tests

Browse Source 
- removed tr1 usage (dropped in C++17)
- moved includes of vector/map/iostream/limits into ts.hpp
- require opencv_test + anonymous namespace (added compile check)
- fixed norm() usage (must be from cvtest::norm for checks) and other conflict functions
- added missing license headers
pull/9770/head
Alexander Alekhin 7 years ago
parent f1e50ecab3
commit 4a297a2443
435 changed files with 2010 additions and 2379 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      modules/calib3d/perf/opencl/perf_stereobm.cpp
  2. 9
      modules/calib3d/perf/perf_affine2d.cpp
  3. 10
      modules/calib3d/perf/perf_cicrlesGrid.cpp
  4. 35
      modules/calib3d/perf/perf_pnp.cpp
  5. 17
      modules/calib3d/perf/perf_precomp.hpp
  6. 2
      modules/calib3d/perf/perf_stereosgbm.cpp
  7. 2
      modules/calib3d/test/opencl/test_stereobm.cpp
  8. 9
      modules/calib3d/test/test_affine2d_estimator.cpp
  9. 6
      modules/calib3d/test/test_affine3.cpp
  10. 21
      modules/calib3d/test/test_affine3d_estimator.cpp
  11. 9
      modules/calib3d/test/test_affine_partial2d_estimator.cpp
  12. 24
      modules/calib3d/test/test_cameracalibration.cpp
  13. 29
      modules/calib3d/test/test_cameracalibration_artificial.cpp
  14. 11
      modules/calib3d/test/test_cameracalibration_badarg.cpp
  15. 33
      modules/calib3d/test/test_cameracalibration_tilt.cpp
  16. 26
      modules/calib3d/test/test_chessboardgenerator.cpp
  17. 7
      modules/calib3d/test/test_chessboardgenerator.hpp
  18. 19
      modules/calib3d/test/test_chesscorners.cpp
  19. 6
      modules/calib3d/test/test_chesscorners_badarg.cpp
  20. 3
      modules/calib3d/test/test_chesscorners_timing.cpp
  21. 21
      modules/calib3d/test/test_compose_rt.cpp
  22. 7
      modules/calib3d/test/test_cornerssubpix.cpp
  23. 12
      modules/calib3d/test/test_decompose_projection.cpp
  24. 6
      modules/calib3d/test/test_fisheye.cpp
  25. 28
      modules/calib3d/test/test_fundam.cpp
  26. 9
      modules/calib3d/test/test_homography.cpp
  27. 13
      modules/calib3d/test/test_homography_decomp.cpp
  28. 3
      modules/calib3d/test/test_main.cpp
  29. 4
      modules/calib3d/test/test_posit.cpp
  30. 21
      modules/calib3d/test/test_precomp.hpp
  31. 9
      modules/calib3d/test/test_reproject_image_to_3d.cpp
  32. 43
      modules/calib3d/test/test_solvepnp_ransac.cpp
  33. 16
      modules/calib3d/test/test_stereomatching.cpp
  34. 7
      modules/calib3d/test/test_undistort.cpp
  35. 3
      modules/calib3d/test/test_undistort_badarg.cpp
  36. 11
      modules/calib3d/test/test_undistort_points.cpp
  37. 8
      modules/core/include/opencv2/core/cuda/detail/color_detail.hpp
  38. 3
      modules/core/perf/cuda/perf_gpumat.cpp
  39. 10
      modules/core/perf/opencl/perf_arithm.cpp
  40. 4
      modules/core/perf/opencl/perf_bufferpool.cpp
  41. 6
      modules/core/perf/opencl/perf_channels.cpp
  42. 4
      modules/core/perf/opencl/perf_dxt.cpp
  43. 4
      modules/core/perf/opencl/perf_gemm.cpp
  44. 4
      modules/core/perf/opencl/perf_matop.cpp
  45. 6
      modules/core/perf/opencl/perf_usage_flags.cpp
  46. 8
      modules/core/perf/perf_abs.cpp
  47. 8
      modules/core/perf/perf_addWeighted.cpp
  48. 38
      modules/core/perf/perf_arithm.cpp
  49. 8
      modules/core/perf/perf_bitwise.cpp
  50. 10
      modules/core/perf/perf_compare.cpp
  51. 10
      modules/core/perf/perf_convertTo.cpp
  52. 8
      modules/core/perf/perf_cvround.cpp
  53. 14
      modules/core/perf/perf_dft.cpp
  54. 10
      modules/core/perf/perf_dot.cpp
  55. 8
      modules/core/perf/perf_inRange.cpp
  56. 10
      modules/core/perf/perf_io_base64.cpp
  57. 5
      modules/core/perf/perf_lut.cpp
  58. 8
      modules/core/perf/perf_mat.cpp
  59. 6
      modules/core/perf/perf_math.cpp
  60. 10
      modules/core/perf/perf_merge.cpp
  61. 8
      modules/core/perf/perf_minmaxloc.cpp
  62. 32
      modules/core/perf/perf_norm.cpp
  63. 15
      modules/core/perf/perf_precomp.hpp
  64. 10
      modules/core/perf/perf_reduce.cpp
  65. 10
      modules/core/perf/perf_sort.cpp
  66. 10
      modules/core/perf/perf_split.cpp
  67. 8
      modules/core/perf/perf_stat.cpp
  68. 11
      modules/core/perf/perf_umat.cpp
  69. 10
      modules/core/test/ocl/test_arithm.cpp
  70. 4
      modules/core/test/ocl/test_channels.cpp
  71. 4
      modules/core/test/ocl/test_dft.cpp
  72. 4
      modules/core/test/ocl/test_gemm.cpp
  73. 4
      modules/core/test/ocl/test_image2d.cpp
  74. 4
      modules/core/test/ocl/test_matrix_expr.cpp
  75. 4
      modules/core/test/ocl/test_matrix_operation.cpp
  76. 1
      modules/core/test/ocl/test_opencl.cpp
  77. 236
      modules/core/test/test_arithm.cpp
  78. 5
      modules/core/test/test_concatenation.cpp
  79. 5
      modules/core/test/test_conjugate_gradient.cpp
  80. 14
      modules/core/test/test_countnonzero.cpp
  81. 7
      modules/core/test/test_downhill_simplex.cpp
  82. 8
      modules/core/test/test_ds.cpp
  83. 40
      modules/core/test/test_dxt.cpp
  84. 9
      modules/core/test/test_eigen.cpp
  85. 11
      modules/core/test/test_hal_core.cpp
  86. 6
      modules/core/test/test_intrin.cpp
  87. 5
      modules/core/test/test_intrin.fp16.cpp
  88. 5
      modules/core/test/test_intrin_utils.hpp
  89. 20
      modules/core/test/test_io.cpp
  90. 7
      modules/core/test/test_ippasync.cpp
  91. 5
      modules/core/test/test_lpsolver.cpp
  92. 10
      modules/core/test/test_main.cpp
  93. 47
      modules/core/test/test_mat.cpp
  94. 18
      modules/core/test/test_math.cpp
  95. 8
      modules/core/test/test_misc.cpp
  96. 42
      modules/core/test/test_operations.cpp
  97. 12
      modules/core/test/test_precomp.hpp
  98. 8
      modules/core/test/test_ptr.cpp
  99. 9
      modules/core/test/test_rand.cpp
  100. 13
      modules/core/test/test_rotatedrect.cpp
  101. Some files were not shown because too many files have changed in this diff Show More

4
modules/calib3d/perf/opencl/perf_stereobm.cpp
Unescape View File

@ -45,10 +45,10 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
typedef std::tr1::tuple<int, int> StereoBMFixture_t;
typedef tuple<int, int> StereoBMFixture_t;
typedef TestBaseWithParam<StereoBMFixture_t> StereoBMFixture;
OCL_PERF_TEST_P(StereoBMFixture, StereoBM, ::testing::Combine(OCL_PERF_ENUM(32, 64, 128), OCL_PERF_ENUM(11,21) ) )

9
modules/calib3d/perf/perf_affine2d.cpp
Unescape View File

@ -43,14 +43,9 @@
#include <algorithm>
#include <functional>
namespace cvtest
namespace opencv_test
{
using std::tr1::tuple;
using std::tr1::get;
using namespace perf;
using namespace testing;
using namespace cv;
CV_ENUM(Method, RANSAC, LMEDS)
typedef tuple<int, double, Method, size_t> AffineParams;
@ -167,4 +162,4 @@ PERF_TEST_P( EstimateAffine, EstimateAffinePartial2D, ESTIMATE_PARAMS )
SANITY_CHECK_NOTHING();
}
} // namespace cvtest
} // namespace opencv_test

10
modules/calib3d/perf/perf_cicrlesGrid.cpp
Unescape View File

@ -1,12 +1,10 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
typedef std::tr1::tuple<std::string, cv::Size> String_Size_t;
typedef tuple<std::string, cv::Size> String_Size_t;
typedef perf::TestBaseWithParam<String_Size_t> String_Size;
PERF_TEST_P(String_Size, asymm_circles_grid, testing::Values(
@ -40,3 +38,5 @@ PERF_TEST_P(String_Size, asymm_circles_grid, testing::Values(
SANITY_CHECK(ptvec, 2);
}
} // namespace

35
modules/calib3d/perf/perf_pnp.cpp
Unescape View File

@ -1,18 +1,12 @@
#include "perf_precomp.hpp"
#ifdef HAVE_TBB
#include "tbb/task_scheduler_init.h"
#endif
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
CV_ENUM(pnpAlgo, SOLVEPNP_ITERATIVE, SOLVEPNP_EPNP, SOLVEPNP_P3P, SOLVEPNP_DLS, SOLVEPNP_UPNP)
typedef std::tr1::tuple<int, pnpAlgo> PointsNum_Algo_t;
typedef tuple<int, pnpAlgo> PointsNum_Algo_t;
typedef perf::TestBaseWithParam<PointsNum_Algo_t> PointsNum_Algo;
typedef perf::TestBaseWithParam<int> PointsNum;
@ -48,14 +42,14 @@ PERF_TEST_P(PointsNum_Algo, solvePnP,
//add noise
Mat noise(1, (int)points2d.size(), CV_32FC2);
randu(noise, 0, 0.01);
add(points2d, noise, points2d);
cv::add(points2d, noise, points2d);
declare.in(points3d, points2d);
declare.time(100);
TEST_CYCLE_N(1000)
{
solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, algo);
cv::solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, algo);
}
SANITY_CHECK(rvec, 1e-6);
@ -92,22 +86,22 @@ PERF_TEST_P(PointsNum_Algo, solvePnPSmallPoints,
// normalize Rodrigues vector
Mat rvec_tmp = Mat::eye(3, 3, CV_32F);
Rodrigues(rvec, rvec_tmp);
Rodrigues(rvec_tmp, rvec);
cv::Rodrigues(rvec, rvec_tmp);
cv::Rodrigues(rvec_tmp, rvec);
projectPoints(points3d, rvec, tvec, intrinsics, distortion, points2d);
cv::projectPoints(points3d, rvec, tvec, intrinsics, distortion, points2d);
//add noise
Mat noise(1, (int)points2d.size(), CV_32FC2);
randu(noise, -0.001, 0.001);
add(points2d, noise, points2d);
cv::add(points2d, noise, points2d);
declare.in(points3d, points2d);
declare.time(100);
TEST_CYCLE_N(1000)
{
solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, algo);
cv::solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, algo);
}
SANITY_CHECK(rvec, 1e-1);
@ -144,16 +138,13 @@ PERF_TEST_P(PointsNum, DISABLED_SolvePnPRansac, testing::Values(5, 3*9, 7*13))
Mat rvec;
Mat tvec;
#ifdef HAVE_TBB
// limit concurrency to get deterministic result
tbb::task_scheduler_init one_thread(1);
#endif
TEST_CYCLE()
{
solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
}
SANITY_CHECK(rvec, 1e-6);
SANITY_CHECK(tvec, 1e-6);
}
} // namespace

17
modules/calib3d/perf/perf_precomp.hpp
Unescape View File

@ -1,21 +1,10 @@
#ifdef __GNUC__
# pragma GCC diagnostic ignored "-Wmissing-declarations"
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic ignored "-Wmissing-prototypes"
# pragma GCC diagnostic ignored "-Wextra"
# endif
#endif
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
#ifndef __OPENCV_PERF_PRECOMP_HPP__
#define __OPENCV_PERF_PRECOMP_HPP__
#include "opencv2/ts.hpp"
#include "opencv2/calib3d.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
#ifdef GTEST_CREATE_SHARED_LIBRARY
#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
#endif
#endif

2
modules/calib3d/perf/perf_stereosgbm.cpp
Unescape View File

@ -36,7 +36,7 @@
#include "perf_precomp.hpp"
namespace cvtest
namespace opencv_test
{
using namespace perf;
using namespace testing;

2
modules/calib3d/test/opencl/test_stereobm.cpp
Unescape View File

@ -46,7 +46,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
PARAM_TEST_CASE(StereoBMFixture, int, int)

9
modules/calib3d/test/test_affine2d_estimator.cpp
Unescape View File

@ -41,12 +41,7 @@
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
using namespace testing;
#include <vector>
#include <numeric>
namespace opencv_test { namespace {
CV_ENUM(Method, RANSAC, LMEDS)
typedef TestWithParam<Method> EstimateAffine2D;
@ -156,3 +151,5 @@ TEST_P(EstimateAffine2D, testConversion)
}
INSTANTIATE_TEST_CASE_P(Calib3d, EstimateAffine2D, Method::all());
}} // namespace

6
modules/calib3d/test/test_affine3.cpp
Unescape View File

@ -42,8 +42,8 @@
#include "test_precomp.hpp"
#include "opencv2/core/affine.hpp"
#include "opencv2/calib3d.hpp"
#include <iostream>
namespace opencv_test { namespace {
TEST(Calib3d_Affine3f, accuracy)
{
@ -106,3 +106,5 @@ TEST(Calib3d_Affine3f, accuracy_rvec)
ASSERT_LT(cvtest::norm(va, vo, cv::NORM_L2), 1e-9);
}
}
}} // namespace

21
modules/calib3d/test/test_affine3d_estimator.cpp
Unescape View File

@ -42,16 +42,7 @@
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
#include <string>
#include <iostream>
#include <fstream>
#include <functional>
#include <iterator>
#include <limits>
#include <numeric>
namespace opencv_test { namespace {
class CV_Affine3D_EstTest : public cvtest::BaseTest
{
@ -101,7 +92,7 @@ bool CV_Affine3D_EstTest::test4Points()
fpts.ptr<Point3f>()[2] = Point3f( rngIn(1,2), rngIn(3,4), rngIn(5, 6) );
fpts.ptr<Point3f>()[3] = Point3f( rngIn(3,4), rngIn(1,2), rngIn(5, 6) );
transform(fpts.ptr<Point3f>(), fpts.ptr<Point3f>() + 4, tpts.ptr<Point3f>(), WrapAff(aff));
std::transform(fpts.ptr<Point3f>(), fpts.ptr<Point3f>() + 4, tpts.ptr<Point3f>(), WrapAff(aff));
Mat aff_est;
vector<uchar> outliers;
@ -144,11 +135,11 @@ bool CV_Affine3D_EstTest::testNPoints()
Mat tpts(1, n, CV_32FC3);
randu(fpts, Scalar::all(0), Scalar::all(100));
transform(fpts.ptr<Point3f>(), fpts.ptr<Point3f>() + n, tpts.ptr<Point3f>(), WrapAff(aff));
std::transform(fpts.ptr<Point3f>(), fpts.ptr<Point3f>() + n, tpts.ptr<Point3f>(), WrapAff(aff));
/* adding noise*/
transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m, bind2nd(plus<Point3f>(), shift_outl));
transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m, Noise(noise_level));
std::transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m, std::bind2nd(std::plus<Point3f>(), shift_outl));
std::transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m, Noise(noise_level));
Mat aff_est;
vector<uchar> outl;
@ -195,3 +186,5 @@ void CV_Affine3D_EstTest::run( int /* start_from */)
}
TEST(Calib3d_EstimateAffine3D, accuracy) { CV_Affine3D_EstTest test; test.safe_run(); }
}} // namespace

9
modules/calib3d/test/test_affine_partial2d_estimator.cpp
Unescape View File

@ -41,12 +41,7 @@
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
using namespace testing;
#include <vector>
#include <numeric>
namespace opencv_test { namespace {
CV_ENUM(Method, RANSAC, LMEDS)
typedef TestWithParam<Method> EstimateAffinePartial2D;
@ -165,3 +160,5 @@ TEST_P(EstimateAffinePartial2D, testConversion)
}
INSTANTIATE_TEST_CASE_P(Calib3d, EstimateAffinePartial2D, Method::all());
}} // namespace

24
modules/calib3d/test/test_cameracalibration.cpp
Unescape View File

@ -42,10 +42,7 @@
#include "test_precomp.hpp"
#include "opencv2/calib3d/calib3d_c.h"
#include <limits>
using namespace std;
using namespace cv;
namespace opencv_test { namespace {
#if 0
class CV_ProjectPointsTest : public cvtest::ArrayTest
@ -861,7 +858,7 @@ void CV_CameraCalibrationTest_CPP::calibrate(int imageCount, int* pointCounts,
for( int i = 0; i < imageCount; ++rvecsIt, ++tvecsIt, i++, rm+=9, tm+=3 )
{
Mat r9( 3, 3, CV_64FC1 );
Rodrigues( *rvecsIt, r9 );
cvtest::Rodrigues( *rvecsIt, r9 );
memcpy( rm, r9.ptr(), 9*sizeof(double) );
memcpy( tm, tvecsIt->ptr(), 3*sizeof(double) );
}
@ -878,7 +875,7 @@ void CV_CameraCalibrationTest_CPP::project( int pointCount, CvPoint3D64f* _objec
Mat cameraMatrix( 3, 3, CV_64FC1, _cameraMatrix );
Mat distCoeffs( 1, 4, CV_64FC1, distortion );
vector<Point2f> imagePoints;
Rodrigues( rmat, rvec );
cvtest::Rodrigues( rmat, rvec );
objectPoints.convertTo( objectPoints, CV_32FC1 );
projectPoints( objectPoints, rvec, tvec,
@ -982,7 +979,7 @@ void CV_CalibrationMatrixValuesTest::run(int)
code = cvtest::TS::FAIL_BAD_ACCURACY;
goto _exit_;
}
if( norm( principalPoint - goodPrincipalPoint ) > FLT_EPSILON )
if( cv::norm(principalPoint - goodPrincipalPoint) > FLT_EPSILON ) // Point2d
{
ts->printf( cvtest::TS::LOG, "bad principalPoint\n" );
code = cvtest::TS::FAIL_BAD_ACCURACY;
@ -1117,7 +1114,8 @@ void CV_ProjectPointsTest::run(int)
rvec(0,0) = rng.uniform( rMinVal, rMaxVal );
rvec(0,1) = rng.uniform( rMinVal, rMaxVal );
rvec(0,2) = rng.uniform( rMinVal, rMaxVal );
Rodrigues( rvec, rmat );
rmat = cv::Mat_<float>::zeros(3, 3);
cvtest::Rodrigues( rvec, rmat );
tvec(0,0) = rng.uniform( tMinVal, tMaxVal );
tvec(0,1) = rng.uniform( tMinVal, tMaxVal );
@ -2135,7 +2133,7 @@ TEST(Calib3d_Triangulate, accuracy)
Mat res_, res;
triangulatePoints(P1, P2, x1, x2, res_);
transpose(res_, res_);
cv::transpose(res_, res_); // TODO cvtest (transpose doesn't support inplace)
convertPointsFromHomogeneous(res_, res);
res = res.reshape(1, 1);
@ -2143,7 +2141,7 @@ TEST(Calib3d_Triangulate, accuracy)
cout << "\tres0: " << res0 << endl;
cout << "\tres: " << res << endl;
ASSERT_LE(norm(res, res0, NORM_INF), 1e-1);
ASSERT_LE(cvtest::norm(res, res0, NORM_INF), 1e-1);
}
// another testcase http://code.opencv.org/issues/3461
@ -2175,7 +2173,7 @@ TEST(Calib3d_Triangulate, accuracy)
Mat res_, res;
triangulatePoints(P1, P2, x1, x2, res_);
transpose(res_, res_);
cv::transpose(res_, res_); // TODO cvtest (transpose doesn't support inplace)
convertPointsFromHomogeneous(res_, res);
res = res.reshape(1, 1);
@ -2183,6 +2181,8 @@ TEST(Calib3d_Triangulate, accuracy)
cout << "\tres0: " << res0 << endl;
cout << "\tres: " << res << endl;
ASSERT_LE(norm(res, res0, NORM_INF), 2);
ASSERT_LE(cvtest::norm(res, res0, NORM_INF), 2);
}
}
}} // namespace

29
modules/calib3d/test/test_cameracalibration_artificial.cpp
Unescape View File

@ -41,18 +41,9 @@
//M*/
#include "test_precomp.hpp"
#include <string>
#include <limits>
#include <vector>
#include <iostream>
#include <sstream>
#include <iomanip>
#include "test_chessboardgenerator.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
//template<class T> ostream& operator<<(ostream& out, const Mat_<T>& mat)
//{
@ -75,10 +66,10 @@ Mat calcRvec(const vector<Point3f>& points, const Size& cornerSize)
Mat rot(3, 3, CV_64F);
*rot.ptr<Vec3d>(0) = ex;
*rot.ptr<Vec3d>(1) = ey;
*rot.ptr<Vec3d>(2) = ez * (1.0/norm(ez));
*rot.ptr<Vec3d>(2) = ez * (1.0/cv::norm(ez)); // TODO cvtest
Mat res;
Rodrigues(rot.t(), res);
cvtest::Rodrigues(rot.t(), res);
return res.reshape(1, 1);
}
@ -174,7 +165,9 @@ protected:
const Point3d& tvec = *tvecs[i].ptr<Point3d>();
const Point3d& tvec_est = *tvecs_est[i].ptr<Point3d>();
if (norm(tvec_est - tvec) > eps* (norm(tvec) + dlt))
double n1 = cv::norm(tvec_est - tvec); // TODO cvtest
double n2 = cv::norm(tvec); // TODO cvtest
if (n1 > eps* (n2 + dlt))
{
if (err_count++ < errMsgNum)
{
@ -183,7 +176,7 @@ protected:
else
{
ts->printf( cvtest::TS::LOG, "%d) Bad accuracy in returned tvecs. Index = %d\n", r, i);
ts->printf( cvtest::TS::LOG, "%d) norm(tvec_est - tvec) = %f, norm(tvec_exp) = %f \n", r, norm(tvec_est - tvec), norm(tvec));
ts->printf( cvtest::TS::LOG, "%d) norm(tvec_est - tvec) = %f, norm(tvec_exp) = %f \n", r, n1, n2);
}
}
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
@ -201,8 +194,8 @@ protected:
const int errMsgNum = 4;
for(size_t i = 0; i < rvecs.size(); ++i)
{
Rodrigues(rvecs[i], rmat);
Rodrigues(rvecs_est[i], rmat_est);
cvtest::Rodrigues(rvecs[i], rmat);
cvtest::Rodrigues(rvecs_est[i], rmat_est);
if (cvtest::norm(rmat_est, rmat, NORM_L2) > eps* (cvtest::norm(rmat, NORM_L2) + dlt))
{
@ -237,7 +230,7 @@ protected:
projectPoints(_chessboard3D, _rvecs_exp[i], _tvecs_exp[i], eye33, zero15, uv_exp);
projectPoints(_chessboard3D, rvecs_est[i], tvecs_est[i], eye33, zero15, uv_est);
for(size_t j = 0; j < cb3d.size(); ++j)
res += norm(uv_exp[i] - uv_est[i]);
res += cv::norm(uv_exp[i] - uv_est[i]); // TODO cvtest
}
return res;
}
@ -429,3 +422,5 @@ protected:
};
TEST(Calib3d_CalibrateCamera_CPP, DISABLED_accuracy_on_artificial_data) { CV_CalibrateCameraArtificialTest test; test.safe_run(); }
}} // namespace

11
modules/calib3d/test/test_cameracalibration_badarg.cpp
Unescape View File

@ -43,10 +43,7 @@
#include "test_chessboardgenerator.hpp"
#include "opencv2/calib3d/calib3d_c.h"
#include <iostream>
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class CV_CameraCalibrationBadArgTest : public cvtest::BadArgTest
{
@ -507,8 +504,8 @@ protected:
objectPoints_c = objectPoints_cpp;
Mat t_vec_cpp(Mat::zeros(1, 3, CV_32F)); t_vec_c = t_vec_cpp;
Mat r_vec_cpp;
Rodrigues(Mat::eye(3, 3, CV_32F), r_vec_cpp); r_vec_c = r_vec_cpp;
Mat r_vec_cpp(3, 1, CV_32F);
cvtest::Rodrigues(Mat::eye(3, 3, CV_32F), r_vec_cpp); r_vec_c = r_vec_cpp;
Mat A_cpp = camMat.clone(); A_c = A_cpp;
Mat distCoeffs_cpp = distCoeffs.clone(); distCoeffs_c = distCoeffs_cpp;
@ -735,3 +732,5 @@ protected:
TEST(Calib3d_CalibrateCamera_C, badarg) { CV_CameraCalibrationBadArgTest test; test.safe_run(); }
TEST(Calib3d_Rodrigues_C, badarg) { CV_Rodrigues2BadArgTest test; test.safe_run(); }
TEST(Calib3d_ProjectPoints_C, badarg) { CV_ProjectPoints2BadArgTest test; test.safe_run(); }
}} // namespace

33
modules/calib3d/test/test_cameracalibration_tilt.cpp
Unescape View File

@ -41,8 +41,9 @@
//M*/
#include "test_precomp.hpp"
#include <opencv2/ts/cuda_test.hpp>
#include "opencv2/calib3d.hpp"
#include "opencv2/ts/cuda_test.hpp" // EXPECT_MAT_NEAR
namespace opencv_test { namespace {
#define NUM_DIST_COEFF_TILT 14
@ -664,24 +665,14 @@ TEST_F(cameraCalibrationTiltTest, calibrateCamera)
// back projection error
for (size_t i = 0; i < viewsNoisyImagePoints.size(); ++i)
{
double dRvec = norm(
m_pointTargetRvec[i] -
cv::Vec3d(
outRvecs[i].at<double>(0),
outRvecs[i].at<double>(1),
outRvecs[i].at<double>(2)));
// std::cout << dRvec << " " << tolRvec << "\n";
EXPECT_LE(dRvec,
tolRvec);
double dTvec = norm(
m_pointTargetTvec[i] -
cv::Vec3d(
outTvecs[i].at<double>(0),
outTvecs[i].at<double>(1),
outTvecs[i].at<double>(2)));
// std::cout << dTvec << " " << tolTvec << "\n";
EXPECT_LE(dTvec,
tolTvec);
double dRvec = cv::norm(m_pointTargetRvec[i],
cv::Vec3d(outRvecs[i].at<double>(0), outRvecs[i].at<double>(1), outRvecs[i].at<double>(2))
);
EXPECT_LE(dRvec, tolRvec);
double dTvec = cv::norm(m_pointTargetTvec[i],
cv::Vec3d(outTvecs[i].at<double>(0), outTvecs[i].at<double>(1), outTvecs[i].at<double>(2))
);
EXPECT_LE(dTvec, tolTvec);
std::vector<cv::Point2f> backProjection;
cv::projectPoints(
@ -698,3 +689,5 @@ TEST_F(cameraCalibrationTiltTest, calibrateCamera)
pixelNoiseHalfWidth *= .25;
}
}
}} // namespace

26
modules/calib3d/test/test_chessboardgenerator.cpp
Unescape View File

@ -43,28 +43,24 @@
#include "test_precomp.hpp"
#include "test_chessboardgenerator.hpp"
#include <vector>
#include <iterator>
#include <algorithm>
using namespace cv;
using namespace std;
namespace cv {
ChessBoardGenerator::ChessBoardGenerator(const Size& _patternSize) : sensorWidth(32), sensorHeight(24),
squareEdgePointsNum(200), min_cos(std::sqrt(3.f)*0.5f), cov(0.5),
patternSize(_patternSize), rendererResolutionMultiplier(4), tvec(Mat::zeros(1, 3, CV_32F))
{
Rodrigues(Mat::eye(3, 3, CV_32F), rvec);
rvec.create(3, 1, CV_32F);
cvtest::Rodrigues(Mat::eye(3, 3, CV_32F), rvec);
}
void cv::ChessBoardGenerator::generateEdge(const Point3f& p1, const Point3f& p2, vector<Point3f>& out) const
void ChessBoardGenerator::generateEdge(const Point3f& p1, const Point3f& p2, vector<Point3f>& out) const
{
Point3f step = (p2 - p1) * (1.f/squareEdgePointsNum);
for(size_t n = 0; n < squareEdgePointsNum; ++n)
out.push_back( p1 + step * (float)n);
}
Size cv::ChessBoardGenerator::cornersSize() const
Size ChessBoardGenerator::cornersSize() const
{
return Size(patternSize.width-1, patternSize.height-1);
}
@ -76,7 +72,7 @@ struct Mult
Point2f operator()(const Point2f& p)const { return p * m; }
};
void cv::ChessBoardGenerator::generateBasis(Point3f& pb1, Point3f& pb2) const
void ChessBoardGenerator::generateBasis(Point3f& pb1, Point3f& pb2) const
{
RNG& rng = theRNG();
@ -108,7 +104,7 @@ void cv::ChessBoardGenerator::generateBasis(Point3f& pb1, Point3f& pb2) const
}
Mat cv::ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat, const Mat& distCoeffs,
Mat ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat, const Mat& distCoeffs,
const Point3f& zero, const Point3f& pb1, const Point3f& pb2,
float sqWidth, float sqHeight, const vector<Point3f>& whole,
vector<Point2f>& corners) const
@ -178,7 +174,7 @@ Mat cv::ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat
return result;
}
Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, vector<Point2f>& corners) const
Mat ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, vector<Point2f>& corners) const
{
cov = std::min(cov, 0.8);
double fovx, fovy, focalLen;
@ -242,7 +238,7 @@ Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const
}
Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs,
Mat ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs,
const Size2f& squareSize, vector<Point2f>& corners) const
{
cov = std::min(cov, 0.8);
@ -301,7 +297,7 @@ Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const
squareSize.width, squareSize.height, pts3d, corners);
}
Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs,
Mat ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs,
const Size2f& squareSize, const Point3f& pos, vector<Point2f>& corners) const
{
cov = std::min(cov, 0.8);
@ -331,3 +327,5 @@ Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const
return generateChessBoard(bg, camMat, distCoeffs, zero, pb1, pb2,
squareSize.width, squareSize.height, pts3d, corners);
}
} // namespace

7
modules/calib3d/test/test_chessboardgenerator.hpp
Unescape View File

@ -1,11 +1,14 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#ifndef CV_CHESSBOARDGENERATOR_H143KJTVYM389YTNHKFDHJ89NYVMO3VLMEJNTBGUEIYVCM203P
#define CV_CHESSBOARDGENERATOR_H143KJTVYM389YTNHKFDHJ89NYVMO3VLMEJNTBGUEIYVCM203P
#include "opencv2/calib3d.hpp"
namespace cv
{
using std::vector;
class ChessBoardGenerator
{
public:

19
modules/calib3d/test/test_chesscorners.cpp
Unescape View File

@ -43,18 +43,14 @@
#include "test_chessboardgenerator.hpp"
#include <functional>
#include <limits>
#include <numeric>
using namespace std;
using namespace cv;
namespace opencv_test { namespace {
#define _L2_ERR
//#define DEBUG_CHESSBOARD
#ifdef DEBUG_CHESSBOARD
#include "opencv2/highgui.hpp"
void show_points( const Mat& gray, const Mat& expected, const vector<Point2f>& actual, bool was_found )
{
Mat rgb( gray.size(), CV_8U);
@ -103,7 +99,7 @@ double calcError(const vector<Point2f>& v, const Mat& u)
int count_exp = u.cols * u.rows;
const Point2f* u_data = u.ptr<Point2f>();
double err = numeric_limits<double>::max();
double err = std::numeric_limits<double>::max();
for( int k = 0; k < 2; ++k )
{
double err1 = 0;
@ -336,19 +332,19 @@ bool validateData(const ChessBoardGenerator& cbg, const Size& imgSz,
{
const Point2f& cur = mat(i, j);
tmp = norm( cur - mat(i + 1, j + 1) );
tmp = cv::norm(cur - mat(i + 1, j + 1)); // TODO cvtest
if (tmp < minNeibDist)
tmp = minNeibDist;
tmp = norm( cur - mat(i - 1, j + 1 ) );
tmp = cv::norm(cur - mat(i - 1, j + 1)); // TODO cvtest
if (tmp < minNeibDist)
tmp = minNeibDist;
tmp = norm( cur - mat(i + 1, j - 1) );
tmp = cv::norm(cur - mat(i + 1, j - 1)); // TODO cvtest
if (tmp < minNeibDist)
tmp = minNeibDist;
tmp = norm( cur - mat(i - 1, j - 1) );
tmp = cv::norm(cur - mat(i - 1, j - 1)); // TODO cvtest
if (tmp < minNeibDist)
tmp = minNeibDist;
}
@ -438,7 +434,7 @@ bool CV_ChessboardDetectorTest::checkByGenerator()
if (found)
res = false;
Point2f c = std::accumulate(cg.begin(), cg.end(), Point2f(), plus<Point2f>()) * (1.f/cg.size());
Point2f c = std::accumulate(cg.begin(), cg.end(), Point2f(), std::plus<Point2f>()) * (1.f/cg.size());
Mat_<double> aff(2, 3);
aff << 1.0, 0.0, -(double)c.x, 0.0, 1.0, 0.0;
@ -472,4 +468,5 @@ TEST(Calib3d_AsymmetricCirclesPatternDetector, accuracy) { CV_ChessboardDetector
TEST(Calib3d_AsymmetricCirclesPatternDetectorWithClustering, accuracy) { CV_ChessboardDetectorTest test( ASYMMETRIC_CIRCLES_GRID, CALIB_CB_CLUSTERING ); test.safe_run(); }
#endif
}} // namespace
/* End of file. */

6
modules/calib3d/test/test_chesscorners_badarg.cpp
Unescape View File

@ -43,10 +43,7 @@
#include "test_chessboardgenerator.hpp"
#include "opencv2/calib3d/calib3d_c.h"
#include <limits>
using namespace std;
using namespace cv;
namespace opencv_test { namespace {
class CV_ChessboardDetectorBadArgTest : public cvtest::BadArgTest
{
@ -151,4 +148,5 @@ void CV_ChessboardDetectorBadArgTest::run( int /*start_from */)
TEST(Calib3d_ChessboardDetector, badarg) { CV_ChessboardDetectorBadArgTest test; test.safe_run(); }
}} // namespace
/* End of file. */

3
modules/calib3d/test/test_chesscorners_timing.cpp
Unescape View File

@ -43,6 +43,8 @@
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/calib3d/calib3d_c.h"
namespace opencv_test { namespace {
class CV_ChessboardDetectorTimingTest : public cvtest::BaseTest
{
public:
@ -182,4 +184,5 @@ _exit_:
TEST(Calib3d_ChessboardDetector, timing) { CV_ChessboardDetectorTimingTest test; test.safe_run(); }
}} // namespace
/* End of file. */

21
modules/calib3d/test/test_compose_rt.cpp
Unescape View File

@ -42,8 +42,7 @@
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class Differential
{
@ -155,14 +154,14 @@ protected:
Mat rvec3_exp, tvec3_exp;
Mat rmat1, rmat2;
Rodrigues(rvec1, rmat1);
Rodrigues(rvec2, rmat2);
Rodrigues(rmat2 * rmat1, rvec3_exp);
cv::Rodrigues(rvec1, rmat1); // TODO cvtest
cv::Rodrigues(rvec2, rmat2); // TODO cvtest
cv::Rodrigues(rmat2 * rmat1, rvec3_exp); // TODO cvtest
tvec3_exp = rmat2 * tvec1 + tvec2;
const double thres = 1e-5;
if (norm(rvec3_exp, rvec3) > thres || norm(tvec3_exp, tvec3) > thres)
if (cv::norm(rvec3_exp, rvec3) > thres || cv::norm(tvec3_exp, tvec3) > thres)
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
const double eps = 1e-3;
@ -176,7 +175,7 @@ protected:
Mat_<double> dr3_dr1, dt3_dr1;
diff.dRv1(dr3_dr1, dt3_dr1);
if (norm(dr3_dr1, dr3dr1) > thres || norm(dt3_dr1, dt3dr1) > thres)
if (cv::norm(dr3_dr1, dr3dr1) > thres || cv::norm(dt3_dr1, dt3dr1) > thres)
{
ts->printf( cvtest::TS::LOG, "Invalid derivates by r1\n" );
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
@ -185,7 +184,7 @@ protected:
Mat_<double> dr3_dr2, dt3_dr2;
diff.dRv2(dr3_dr2, dt3_dr2);
if (norm(dr3_dr2, dr3dr2) > thres || norm(dt3_dr2, dt3dr2) > thres)
if (cv::norm(dr3_dr2, dr3dr2) > thres || cv::norm(dt3_dr2, dt3dr2) > thres)
{
ts->printf( cvtest::TS::LOG, "Invalid derivates by r2\n" );
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
@ -194,7 +193,7 @@ protected:
Mat_<double> dr3_dt1, dt3_dt1;
diff.dTv1(dr3_dt1, dt3_dt1);
if (norm(dr3_dt1, dr3dt1) > thres || norm(dt3_dt1, dt3dt1) > thres)
if (cv::norm(dr3_dt1, dr3dt1) > thres || cv::norm(dt3_dt1, dt3dt1) > thres)
{
ts->printf( cvtest::TS::LOG, "Invalid derivates by t1\n" );
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
@ -203,7 +202,7 @@ protected:
Mat_<double> dr3_dt2, dt3_dt2;
diff.dTv2(dr3_dt2, dt3_dt2);
if (norm(dr3_dt2, dr3dt2) > thres || norm(dt3_dt2, dt3dt2) > thres)
if (cv::norm(dr3_dt2, dr3dt2) > thres || cv::norm(dt3_dt2, dt3dt2) > thres)
{
ts->printf( cvtest::TS::LOG, "Invalid derivates by t2\n" );
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
@ -212,3 +211,5 @@ protected:
};
TEST(Calib3d_ComposeRT, accuracy) { CV_composeRT_Test test; test.safe_run(); }
}} // namespace

7
modules/calib3d/test/test_cornerssubpix.cpp
Unescape View File

@ -41,11 +41,9 @@
#include "test_precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include <limits>
#include "test_chessboardgenerator.hpp"
using namespace std;
using namespace cv;
namespace opencv_test { namespace {
class CV_ChessboardSubpixelTest : public cvtest::BaseTest
{
@ -78,7 +76,7 @@ int calcDistance(const vector<Point2f>& set1, const vector<Point2f>& set2, doubl
for(int j = 0; j < (int)set2.size(); j++)
{
double dist = norm(set1[i] - set2[j]);
double dist = cv::norm(set1[i] - set2[j]); // TODO cvtest
if(dist < min_dist)
{
min_idx = j;
@ -256,4 +254,5 @@ TEST(Calib3d_CornerSubPix, regression_7204)
cv::TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
}
}} // namespace
/* End of file. */

12
modules/calib3d/test/test_decompose_projection.cpp
Unescape View File

@ -42,6 +42,8 @@
#include "test_precomp.hpp"
namespace opencv_test { namespace {
class CV_DecomposeProjectionMatrixTest : public cvtest::BaseTest
{
public:
@ -86,7 +88,7 @@ void CV_DecomposeProjectionMatrixTest::run(int start_from)
rng.fill(rVec, cv::RNG::UNIFORM, -CV_PI, CV_PI);
cv::Matx33d origR;
Rodrigues(rVec, origR);
cv::Rodrigues(rVec, origR); // TODO cvtest
cv::Vec3d origT;
rng.fill(origT, cv::RNG::NORMAL, 0, 1);
@ -111,19 +113,19 @@ void CV_DecomposeProjectionMatrixTest::run(int start_from)
const double thresh = 1e-6;
if ( norm(origK, K, cv::NORM_INF) > thresh )
if (cv::norm(origK, K, cv::NORM_INF) > thresh)
{
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
break;
}
if ( norm(origR, R, cv::NORM_INF) > thresh )
if (cv::norm(origR, R, cv::NORM_INF) > thresh)
{
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
break;
}
if ( norm(origT, t, cv::NORM_INF) > thresh )
if (cv::norm(origT, t, cv::NORM_INF) > thresh)
{
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
break;
@ -138,3 +140,5 @@ TEST(Calib3d_DecomposeProjectionMatrix, accuracy)
CV_DecomposeProjectionMatrixTest test;
test.safe_run();
}
}} // namespace

6
modules/calib3d/test/test_fisheye.cpp
Unescape View File

@ -41,10 +41,12 @@
//M*/
#include "test_precomp.hpp"
#include <opencv2/ts/cuda_test.hpp>
#include <opencv2/ts/cuda_test.hpp> // EXPECT_MAT_NEAR
#include "../src/fisheye.hpp"
#include "opencv2/videoio.hpp"
namespace opencv_test { namespace {
class fisheyeTest : public ::testing::Test {
protected:
@ -701,3 +703,5 @@ void fisheyeTest::merge4(const cv::Mat& tl, const cv::Mat& tr, const cv::Mat& bl
bl.copyTo(merged(cv::Rect(0, sz.height, sz.width, sz.height)));
br.copyTo(merged(cv::Rect(sz.width, sz.height, sz.width, sz.height)));
}
}} // namespace

28
modules/calib3d/test/test_fundam.cpp
Unescape View File

@ -42,10 +42,9 @@
#include "test_precomp.hpp"
#include "opencv2/calib3d/calib3d_c.h"
using namespace cv;
using namespace std;
namespace cvtest {
int cvTsRodrigues( const CvMat* src, CvMat* dst, CvMat* jacobian )
static int cvTsRodrigues( const CvMat* src, CvMat* dst, CvMat* jacobian )
{
int depth;
int i;
@ -348,14 +347,18 @@ int cvTsRodrigues( const CvMat* src, CvMat* dst, CvMat* jacobian )
}
void cvtest::Rodrigues(const Mat& src, Mat& dst, Mat* jac)
/*extern*/ void Rodrigues(const Mat& src, Mat& dst, Mat* jac)
{
CV_Assert(src.data != dst.data && "Inplace is not supported");
CV_Assert(!dst.empty() && "'dst' must be allocated");
CvMat _src = src, _dst = dst, _jac;
if( jac )
_jac = *jac;
cvTsRodrigues(&_src, &_dst, jac ? &_jac : 0);
}
} // namespace
namespace opencv_test {
static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
{
@ -463,6 +466,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
dst.convertTo(_dst, _dst.depth());
}
namespace {
void
test_projectPoints( const Mat& _3d, const Mat& Rt, const Mat& A, Mat& _2d, RNG* rng, double sigma )
@ -728,7 +732,7 @@ void CV_RodriguesTest::prepare_to_validation( int /*test_case_idx*/ )
cvtest::Rodrigues( m, vec2, m2v_jac );
cvtest::copy( vec, vec2 );
theta0 = norm( vec2, CV_L2 );
theta0 = cvtest::norm( vec2, CV_L2 );
theta1 = fmod( theta0, CV_PI*2 );
if( theta1 > CV_PI )
@ -1067,7 +1071,9 @@ protected:
void run_func();
void prepare_to_validation( int );
#if 0
double sampson_error(const double* f, double x1, double y1, double x2, double y2);
#endif
int method;
int img_size;
@ -1299,6 +1305,7 @@ void CV_EssentialMatTest::run_func()
mask2.copyTo(test_mat[TEMP][4]);
}
#if 0
double CV_EssentialMatTest::sampson_error(const double * f, double x1, double y1, double x2, double y2)
{
double Fx1[3] = {
@ -1316,8 +1323,8 @@ double CV_EssentialMatTest::sampson_error(const double * f, double x1, double y1
double error = x2tFx1 * x2tFx1 / (Fx1[0] * Fx1[0] + Fx1[1] * Fx1[1] + Ftx2[0] * Ftx2[0] + Ftx2[1] * Ftx2[1]);
error = sqrt(error);
return error;
}
#endif
void CV_EssentialMatTest::prepare_to_validation( int test_case_idx )
{
@ -1395,10 +1402,10 @@ void CV_EssentialMatTest::prepare_to_validation( int test_case_idx )
double* pose_prop1 = test_mat[REF_OUTPUT][2].ptr<double>();
double* pose_prop2 = test_mat[OUTPUT][2].ptr<double>();
double terr1 = cvtest::norm(Rt0.col(3) / norm(Rt0.col(3)) + test_mat[TEMP][3], NORM_L2);
double terr2 = cvtest::norm(Rt0.col(3) / norm(Rt0.col(3)) - test_mat[TEMP][3], NORM_L2);
Mat rvec;
Rodrigues(Rt0.colRange(0, 3), rvec);
double terr1 = cvtest::norm(Rt0.col(3) / cvtest::norm(Rt0.col(3), NORM_L2) + test_mat[TEMP][3], NORM_L2);
double terr2 = cvtest::norm(Rt0.col(3) / cvtest::norm(Rt0.col(3), NORM_L2) - test_mat[TEMP][3], NORM_L2);
Mat rvec(3, 1, CV_32F);
cvtest::Rodrigues(Rt0.colRange(0, 3), rvec);
pose_prop1[0] = 0;
// No check for CV_LMeDS on translation. Since it
// involves with some degraded problem, when data is exact inliers.
@ -1726,4 +1733,5 @@ TEST(Calib3d_FindFundamentalMat, correctMatches)
cout << np2 << endl;
}
}} // namespace
/* End of file. */

9
modules/calib3d/test/test_homography.cpp
Unescape View File

@ -42,7 +42,8 @@
//M*/
#include "test_precomp.hpp"
#include <time.h>
namespace opencv_test { namespace {
#define CALIB3D_HOMOGRAPHY_ERROR_MATRIX_SIZE 1
#define CALIB3D_HOMOGRAPHY_ERROR_MATRIX_DIFF 2
@ -622,7 +623,7 @@ TEST(Calib3d_Homography, EKcase)
Mat h = findHomography(p1, p2, RANSAC, 0.01, mask);
ASSERT_TRUE(!h.empty());
transpose(mask, mask);
cv::transpose(mask, mask);
Mat p3, mask2;
int ninliers = countNonZero(mask);
Mat nmask[] = { mask, mask };
@ -631,7 +632,7 @@ TEST(Calib3d_Homography, EKcase)
mask2 = mask2.reshape(1);
p2 = p2.reshape(1);
p3 = p3.reshape(1);
double err = norm(p2, p3, NORM_INF, mask2);
double err = cvtest::norm(p2, p3, NORM_INF, mask2);
printf("ninliers: %d, inliers err: %.2g\n", ninliers, err);
ASSERT_GE(ninliers, 10);
@ -709,3 +710,5 @@ TEST(Calib3d_Homography, fromImages)
ASSERT_TRUE(!H1.empty());
ASSERT_GE(ninliers1, 80);
}
}} // namespace

13
modules/calib3d/test/test_homography_decomp.cpp
Unescape View File

@ -44,11 +44,8 @@
//M*/
#include "test_precomp.hpp"
#include "opencv2/calib3d.hpp"
#include <vector>
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class CV_HomographyDecompTest: public cvtest::BaseTest {
@ -118,9 +115,9 @@ private:
riter != rotations.end() && titer != translations.end() && niter != normals.end();
++riter, ++titer, ++niter) {
double rdist = norm(*riter, _R, NORM_INF);
double tdist = norm(*titer, _t, NORM_INF);
double ndist = norm(*niter, _n, NORM_INF);
double rdist = cvtest::norm(*riter, _R, NORM_INF);
double tdist = cvtest::norm(*titer, _t, NORM_INF);
double ndist = cvtest::norm(*niter, _n, NORM_INF);
if ( rdist < max_error
&& tdist < max_error
@ -136,3 +133,5 @@ private:
};
TEST(Calib3d_DecomposeHomography, regression) { CV_HomographyDecompTest test; test.safe_run(); }
}} // namespace

3
modules/calib3d/test/test_main.cpp
Unescape View File

@ -1,3 +1,6 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
CV_TEST_MAIN("")

4
modules/calib3d/test/test_posit.cpp
Unescape View File

@ -42,8 +42,7 @@
#include "test_precomp.hpp"
#include "opencv2/calib3d/calib3d_c.h"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class CV_POSITTest : public cvtest::BaseTest
{
@ -219,4 +218,5 @@ void CV_POSITTest::run( int start_from )
TEST(Calib3d_POSIT, accuracy) { CV_POSITTest test; test.safe_run(); }
}} // namespace
/* End of file. */

21
modules/calib3d/test/test_precomp.hpp
Unescape View File

@ -1,23 +1,22 @@
#ifdef __GNUC__
# pragma GCC diagnostic ignored "-Wmissing-declarations"
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic ignored "-Wmissing-prototypes"
# pragma GCC diagnostic ignored "-Wextra"
# endif
#endif
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#ifndef __OPENCV_TEST_PRECOMP_HPP__
#define __OPENCV_TEST_PRECOMP_HPP__
#include <iostream>
#include <functional>
#include <numeric>
#include "opencv2/ts.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/calib3d.hpp"
#include "opencv2/imgcodecs.hpp"
namespace cvtest
{
void Rodrigues(const Mat& src, Mat& dst, Mat* jac=0);
}
namespace opencv_test {
CVTEST_GUARD_SYMBOL(Rodrigues)
} // namespace
#endif

9
modules/calib3d/test/test_reproject_image_to_3d.cpp
Unescape View File

@ -42,11 +42,8 @@
#include "test_precomp.hpp"
#include "opencv2/calib3d/calib3d_c.h"
#include <string>
#include <limits>
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
template<class T> double thres() { return 1.0; }
template<> double thres<float>() { return 1e-5; }
@ -130,7 +127,7 @@ protected:
CvMat cvdisp = disp; CvMat cv_3dImg = _3dImg; CvMat cvQ = Q;
cvReprojectImageTo3D( &cvdisp, &cv_3dImg, &cvQ, handleMissingValues );
if (numeric_limits<OutT>::max() == numeric_limits<float>::max())
if (std::numeric_limits<OutT>::max() == std::numeric_limits<float>::max())
reprojectImageTo3D(disp, _3dImg, Q, handleMissingValues);
for(int y = 0; y < disp.rows; ++y)
@ -178,3 +175,5 @@ protected:
};
TEST(Calib3d_ReprojectImageTo3D, accuracy) { CV_ReprojectImageTo3DTest test; test.safe_run(); }
}} // namespace

43
modules/calib3d/test/test_solvepnp_ransac.cpp
Unescape View File

@ -42,12 +42,7 @@
#include "test_precomp.hpp"
#ifdef HAVE_TBB
#include "tbb/task_scheduler_init.h"
#endif
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class CV_solvePnPRansac_Test : public cvtest::BaseTest
{
@ -69,7 +64,7 @@ protected:
Point3f pmin = Point3f(-1, -1, 5),
Point3f pmax = Point3f(1, 1, 10))
{
RNG rng = ::theRNG(); // fix the seed to use "fixed" input 3D points
RNG rng = cv::theRNG(); // fix the seed to use "fixed" input 3D points
for (size_t i = 0; i < points.size(); i++)
{
@ -142,7 +137,7 @@ protected:
bool isTestSuccess = inliers.size() >= points.size()*0.95;
double rvecDiff = norm(rvec-trueRvec), tvecDiff = norm(tvec-trueTvec);
double rvecDiff = cvtest::norm(rvec, trueRvec, NORM_L2), tvecDiff = cvtest::norm(tvec, trueTvec, NORM_L2);
isTestSuccess = isTestSuccess && rvecDiff < epsilon[method] && tvecDiff < epsilon[method];
double error = rvecDiff > tvecDiff ? rvecDiff : tvecDiff;
//cout << error << " " << inliers.size() << " " << eps[method] << endl;
@ -254,7 +249,7 @@ protected:
return isEstimateSuccess;
}
double rvecDiff = norm(rvec-trueRvec), tvecDiff = norm(tvec-trueTvec);
double rvecDiff = cvtest::norm(rvec, trueRvec, NORM_L2), tvecDiff = cvtest::norm(tvec, trueTvec, NORM_L2);
bool isTestSuccess = rvecDiff < epsilon[method] && tvecDiff < epsilon[method];
double error = rvecDiff > tvecDiff ? rvecDiff : tvecDiff;
@ -305,8 +300,8 @@ class CV_solveP3P_Test : public CV_solvePnPRansac_Test
bool isTestSuccess = false;
double error = DBL_MAX;
for (unsigned int i = 0; i < rvecs.size() && !isTestSuccess; ++i) {
double rvecDiff = norm(rvecs[i]-trueRvec);
double tvecDiff = norm(tvecs[i]-trueTvec);
double rvecDiff = cvtest::norm(rvecs[i], trueRvec, NORM_L2);
double tvecDiff = cvtest::norm(tvecs[i], trueTvec, NORM_L2);
isTestSuccess = rvecDiff < epsilon[method] && tvecDiff < epsilon[method];
error = std::min(error, std::max(rvecDiff, tvecDiff));
}
@ -450,12 +445,12 @@ TEST(Calib3d_SolvePnPRansac, input_type)
points2dMat = points2dMat.reshape(1, numPoints);
EXPECT_TRUE(solvePnPRansac(points3dMat, points2dMat, intrinsics, cv::Mat(), R4, t4));
EXPECT_LE(norm(R1, R2, NORM_INF), 1e-6);
EXPECT_LE(norm(t1, t2, NORM_INF), 1e-6);
EXPECT_LE(norm(R1, R3, NORM_INF), 1e-6);
EXPECT_LE(norm(t1, t3, NORM_INF), 1e-6);
EXPECT_LE(norm(R1, R4, NORM_INF), 1e-6);
EXPECT_LE(norm(t1, t4, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(R1, R2, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(t1, t2, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(R1, R3, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(t1, t3, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(R1, R4, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(t1, t4, NORM_INF), 1e-6);
}
TEST(Calib3d_SolvePnP, double_support)
@ -483,8 +478,8 @@ TEST(Calib3d_SolvePnP, double_support)
solvePnPRansac(points3dF, points2dF, intrinsics, cv::Mat(), RF, tF, true, 100, 8.f, 0.999, inliers, cv::SOLVEPNP_P3P);
solvePnPRansac(points3d, points2d, intrinsics, cv::Mat(), R, t, true, 100, 8.f, 0.999, inliers, cv::SOLVEPNP_P3P);
EXPECT_LE(norm(R, Mat_<double>(RF), NORM_INF), 1e-3);
EXPECT_LE(norm(t, Mat_<double>(tF), NORM_INF), 1e-3);
EXPECT_LE(cvtest::norm(R, Mat_<double>(RF), NORM_INF), 1e-3);
EXPECT_LE(cvtest::norm(t, Mat_<double>(tF), NORM_INF), 1e-3);
}
TEST(Calib3d_SolvePnP, translation)
@ -556,8 +551,8 @@ TEST(Calib3d_SolvePnP, iterativeInitialGuess3pts)
std::cout << "tvec_ground_truth: " << tvec_ground_truth.t() << std::endl;
std::cout << "tvec_est: " << tvec_est.t() << std::endl;
EXPECT_LE(norm(rvec_ground_truth, rvec_est, NORM_INF), 1e-6);
EXPECT_LE(norm(tvec_ground_truth, tvec_est, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(rvec_ground_truth, rvec_est, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(tvec_ground_truth, tvec_est, NORM_INF), 1e-6);
}
{
@ -587,7 +582,9 @@ TEST(Calib3d_SolvePnP, iterativeInitialGuess3pts)
std::cout << "tvec_ground_truth: " << tvec_ground_truth.t() << std::endl;
std::cout << "tvec_est: " << tvec_est.t() << std::endl;
EXPECT_LE(norm(rvec_ground_truth, rvec_est, NORM_INF), 1e-6);
EXPECT_LE(norm(tvec_ground_truth, tvec_est, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(rvec_ground_truth, rvec_est, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(tvec_ground_truth, tvec_est, NORM_INF), 1e-6);
}
}
}} // namespace

16
modules/calib3d/test/test_stereomatching.cpp
Unescape View File

@ -46,12 +46,8 @@
*/
#include "test_precomp.hpp"
#include <limits>
#include <cstdio>
#include <map>
using namespace std;
using namespace cv;
namespace opencv_test { namespace {
const float EVAL_BAD_THRESH = 1.f;
const int EVAL_TEXTURELESS_WIDTH = 3;
@ -238,10 +234,10 @@ void computeDepthDiscontMask( const Mat& disp, Mat& depthDiscontMask, const Mat&
Mat curDisp; disp.copyTo( curDisp );
if( !unknDispMask.empty() )
curDisp.setTo( Scalar(numeric_limits<float>::min()), unknDispMask );
curDisp.setTo( Scalar(std::numeric_limits<float>::min()), unknDispMask );
Mat maxNeighbDisp; dilate( curDisp, maxNeighbDisp, Mat(3, 3, CV_8UC1, Scalar(1)) );
if( !unknDispMask.empty() )
curDisp.setTo( Scalar(numeric_limits<float>::max()), unknDispMask );
curDisp.setTo( Scalar(std::numeric_limits<float>::max()), unknDispMask );
Mat minNeighbDisp; erode( curDisp, minNeighbDisp, Mat(3, 3, CV_8UC1, Scalar(1)) );
depthDiscontMask = max( (Mat)(maxNeighbDisp-disp), (Mat)(disp-minNeighbDisp) ) > dispGap;
if( !unknDispMask.empty() )
@ -566,12 +562,12 @@ int CV_StereoMatchingTest::processStereoMatchingResults( FileStorage& fs, int ca
Mat leftUnknMask, rightUnknMask;
DatasetParams params = datasetsParams[caseDatasets[caseIdx]];
absdiff( trueLeftDisp, Scalar(params.dispUnknVal), leftUnknMask );
leftUnknMask = leftUnknMask < numeric_limits<float>::epsilon();
leftUnknMask = leftUnknMask < std::numeric_limits<float>::epsilon();
assert(leftUnknMask.type() == CV_8UC1);
if( !trueRightDisp.empty() )
{
absdiff( trueRightDisp, Scalar(params.dispUnknVal), rightUnknMask );
rightUnknMask = rightUnknMask < numeric_limits<float>::epsilon();
rightUnknMask = rightUnknMask < std::numeric_limits<float>::epsilon();
assert(rightUnknMask.type() == CV_8UC1);
}
@ -892,3 +888,5 @@ TEST(Calib3d_StereoSGBM_HH4, regression)
absdiff(toCheck, testData,diff);
CV_Assert( countNonZero(diff)==0);
}
}} // namespace

7
modules/calib3d/test/test_undistort.cpp
Unescape View File

@ -43,8 +43,7 @@
#include "test_precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class CV_DefaultNewCameraMatrixTest : public cvtest::ArrayTest
{
@ -67,7 +66,7 @@ private:
static const int MAX_X = 2048;
static const int MAX_Y = 2048;
static const int MAX_VAL = 10000;
//static const int MAX_VAL = 10000;
};
CV_DefaultNewCameraMatrixTest::CV_DefaultNewCameraMatrixTest()
@ -938,3 +937,5 @@ double CV_InitUndistortRectifyMapTest::get_success_error_level( int /*test_case_
TEST(Calib3d_DefaultNewCameraMatrix, accuracy) { CV_DefaultNewCameraMatrixTest test; test.safe_run(); }
TEST(Calib3d_UndistortPoints, accuracy) { CV_UndistortPointsTest test; test.safe_run(); }
TEST(Calib3d_InitUndistortRectifyMap, accuracy) { CV_InitUndistortRectifyMapTest test; test.safe_run(); }
}} // namespace

3
modules/calib3d/test/test_undistort_badarg.cpp
Unescape View File

@ -42,6 +42,8 @@
#include "test_precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
namespace opencv_test { namespace {
class CV_UndistortPointsBadArgTest : public cvtest::BadArgTest
{
public:
@ -525,4 +527,5 @@ TEST(Calib3d_UndistortPoints, badarg) { CV_UndistortPointsBadArgTest test; test.
TEST(Calib3d_InitUndistortRectifyMap, badarg) { CV_InitUndistortRectifyMapBadArgTest test; test.safe_run(); }
TEST(Calib3d_Undistort, badarg) { CV_UndistortBadArgTest test; test.safe_run(); }
}} // namespace
/* End of file. */

11
modules/calib3d/test/test_undistort_points.cpp
Unescape View File

@ -1,8 +1,9 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
#include <string>
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class CV_UndistortTest : public cvtest::BaseTest
{
@ -29,7 +30,7 @@ CV_UndistortTest::~CV_UndistortTest() {}
void CV_UndistortTest::generate3DPointCloud(vector<Point3f>& points, Point3f pmin, Point3f pmax)
{
RNG rng_Point = ::theRNG(); // fix the seed to use "fixed" input 3D points
RNG rng_Point = cv::theRNG(); // fix the seed to use "fixed" input 3D points
for (size_t i = 0; i < points.size(); i++)
{
float _x = rng_Point.uniform(pmin.x, pmax.x);
@ -117,3 +118,5 @@ TEST(Calib3d_Undistort, stop_criteria)
ASSERT_LE(obtainedError, maxError);
}
}} // namespace

8
modules/core/include/opencv2/core/cuda/detail/color_detail.hpp
Unescape View File

@ -1027,8 +1027,8 @@ namespace cv { namespace cuda { namespace device
vmin = fmin(vmin, b);
diff = v - vmin;
s = diff / (float)(::fabs(v) + numeric_limits<float>::epsilon());
diff = (float)(60. / (diff + numeric_limits<float>::epsilon()));
s = diff / (float)(::fabs(v) + std::numeric_limits<float>::epsilon());
diff = (float)(60. / (diff + std::numeric_limits<float>::epsilon()));
h = (v == r) * (g - b) * diff;
h += (v != r && v == g) * ((b - r) * diff + 120.f);
@ -1261,7 +1261,7 @@ namespace cv { namespace cuda { namespace device
diff = vmax - vmin;
l = (vmax + vmin) * 0.5f;
if (diff > numeric_limits<float>::epsilon())
if (diff > std::numeric_limits<float>::epsilon())
{
s = (l < 0.5f) * diff / (vmax + vmin);
s += (l >= 0.5f) * diff / (2.0f - vmax - vmin);
@ -1802,7 +1802,7 @@ namespace cv { namespace cuda { namespace device
float L = splineInterpolate(Y * (LAB_CBRT_TAB_SIZE / 1.5f), c_LabCbrtTab, LAB_CBRT_TAB_SIZE);
L = 116.f * L - 16.f;
const float d = (4 * 13) / ::fmaxf(X + 15 * Y + 3 * Z, numeric_limits<float>::epsilon());
const float d = (4 * 13) / ::fmaxf(X + 15 * Y + 3 * Z, std::numeric_limits<float>::epsilon());
float u = L * (X * d - _un);
float v = L * ((9 * 0.25f) * Y * d - _vn);

3
modules/core/perf/cuda/perf_gpumat.cpp
Unescape View File

@ -47,7 +47,7 @@
#include "opencv2/core/cuda.hpp"
#include "opencv2/ts/cuda_perf.hpp"
using namespace std;
namespace opencv_test { namespace {
using namespace testing;
using namespace perf;
@ -193,4 +193,5 @@ PERF_TEST_P(Sz_2Depth, CUDA_GpuMat_ConvertTo,
SANITY_CHECK_NOTHING();
}
}} // namespace
#endif

10
modules/core/perf/opencl/perf_arithm.cpp
Unescape View File

@ -44,7 +44,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
///////////// Lut ////////////////////////
@ -352,7 +352,7 @@ enum
CV_ENUM(FlipType, FLIP_BOTH, FLIP_ROWS, FLIP_COLS)
typedef std::tr1::tuple<Size, MatType, FlipType> FlipParams;
typedef tuple<Size, MatType, FlipType> FlipParams;
typedef TestBaseWithParam<FlipParams> FlipFixture;
OCL_PERF_TEST_P(FlipFixture, Flip,
@ -570,7 +570,7 @@ OCL_PERF_TEST_P(BitwiseNotFixture, Bitwise_not,
CV_ENUM(CmpCode, CMP_LT, CMP_LE, CMP_EQ, CMP_NE, CMP_GE, CMP_GT)
typedef std::tr1::tuple<Size, MatType, CmpCode> CompareParams;
typedef tuple<Size, MatType, CmpCode> CompareParams;
typedef TestBaseWithParam<CompareParams> CompareFixture;
OCL_PERF_TEST_P(CompareFixture, Compare,
@ -773,7 +773,7 @@ OCL_PERF_TEST_P(MeanStdDevFixture, MeanStdDevWithMask,
CV_ENUM(NormType, NORM_INF, NORM_L1, NORM_L2)
typedef std::tr1::tuple<Size, MatType, NormType> NormParams;
typedef tuple<Size, MatType, NormType> NormParams;
typedef TestBaseWithParam<NormParams> NormFixture;
OCL_PERF_TEST_P(NormFixture, Norm1Arg,
@ -1176,6 +1176,6 @@ OCL_PERF_TEST_P(ReduceAccFixture, Reduce,
SANITY_CHECK(dst, eps);
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/perf/opencl/perf_bufferpool.cpp
Unescape View File

@ -9,7 +9,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
struct BufferPoolState
@ -127,6 +127,6 @@ OCL_PERF_TEST_P(BufferPoolFixture, BufferPool_UMatIntegral10, Bool())
SANITY_CHECK_NOTHING();
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

6
modules/core/perf/opencl/perf_channels.cpp
Unescape View File

@ -49,7 +49,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
///////////// Merge////////////////////////
@ -156,7 +156,7 @@ OCL_PERF_TEST_P(MixChannelsFixture, MixChannels,
///////////// InsertChannel ////////////////////////
typedef std::tr1::tuple<cv::Size, MatDepth> Size_MatDepth_t;
typedef tuple<cv::Size, MatDepth> Size_MatDepth_t;
typedef TestBaseWithParam<Size_MatDepth_t> Size_MatDepth;
typedef Size_MatDepth InsertChannelFixture;
@ -201,6 +201,6 @@ OCL_PERF_TEST_P(ExtractChannelFixture, ExtractChannel,
SANITY_CHECK(dst);
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/perf/opencl/perf_dxt.cpp
Unescape View File

@ -49,7 +49,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
///////////// dft ////////////////////////
@ -113,6 +113,6 @@ OCL_PERF_TEST_P(MulSpectrumsFixture, MulSpectrums,
SANITY_CHECK(dst, 1e-3);
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/perf/opencl/perf_gemm.cpp
Unescape View File

@ -49,7 +49,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
///////////// gemm ////////////////////////
@ -79,6 +79,6 @@ OCL_PERF_TEST_P(GemmFixture, Gemm, ::testing::Combine(
SANITY_CHECK(dst, 0.01);
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/perf/opencl/perf_matop.cpp
Unescape View File

@ -10,7 +10,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
///////////// SetTo ////////////////////////
@ -146,6 +146,6 @@ OCL_PERF_TEST_P(CopyToFixture, CopyToWithMaskUninit,
SANITY_CHECK(dst);
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

6
modules/core/perf/opencl/perf_usage_flags.cpp
Unescape View File

@ -9,10 +9,10 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
typedef TestBaseWithParam<std::tr1::tuple<cv::Size, bool> > UsageFlagsBoolFixture;
typedef TestBaseWithParam<tuple<cv::Size, bool> > UsageFlagsBoolFixture;
OCL_PERF_TEST_P(UsageFlagsBoolFixture, UsageFlags_AllocHostMem, ::testing::Combine(OCL_TEST_SIZES, Bool()))
{
@ -37,6 +37,6 @@ OCL_PERF_TEST_P(UsageFlagsBoolFixture, UsageFlags_AllocHostMem, ::testing::Combi
SANITY_CHECK_NOTHING();
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

8
modules/core/perf/perf_abs.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
#define TYPICAL_MAT_SIZES_ABS TYPICAL_MAT_SIZES
#define TYPICAL_MAT_TYPES_ABS CV_8SC1, CV_8SC4, CV_32SC1, CV_32FC1
@ -24,3 +22,5 @@ PERF_TEST_P(Size_MatType, abs, TYPICAL_MATS_ABS)
SANITY_CHECK(c);
}
} // namespace

8
modules/core/perf/perf_addWeighted.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
#define TYPICAL_MAT_TYPES_ADWEIGHTED CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1
#define TYPICAL_MATS_ADWEIGHTED testing::Combine(testing::Values(szVGA, sz720p, sz1080p), testing::Values(TYPICAL_MAT_TYPES_ADWEIGHTED))
@ -34,3 +32,5 @@ PERF_TEST_P(Size_MatType, addWeighted, TYPICAL_MATS_ADWEIGHTED)
SANITY_CHECK(dst, 1);
}
} // namespace

38
modules/core/perf/perf_arithm.cpp
Unescape View File

@ -1,12 +1,10 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
#define TYPICAL_MAT_SIZES_CORE_ARITHM ::szVGA, ::sz720p, ::sz1080p
#define TYPICAL_MAT_SIZES_CORE_ARITHM szVGA, sz720p, sz1080p
#define TYPICAL_MAT_TYPES_CORE_ARITHM CV_8UC1, CV_8SC1, CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4, CV_8UC4, CV_32SC1, CV_32FC1
#define TYPICAL_MATS_CORE_ARITHM testing::Combine( testing::Values( TYPICAL_MAT_SIZES_CORE_ARITHM ), testing::Values( TYPICAL_MAT_TYPES_CORE_ARITHM ) )
@ -20,7 +18,7 @@ PERF_TEST_P(Size_MatType, min, TYPICAL_MATS_CORE_ARITHM)
declare.in(a, b, WARMUP_RNG).out(c);
TEST_CYCLE() min(a, b, c);
TEST_CYCLE() cv::min(a, b, c);
SANITY_CHECK(c);
}
@ -35,7 +33,7 @@ PERF_TEST_P(Size_MatType, minScalar, TYPICAL_MATS_CORE_ARITHM)
declare.in(a, b, WARMUP_RNG).out(c);
TEST_CYCLE() min(a, b, c);
TEST_CYCLE() cv::min(a, b, c);
SANITY_CHECK(c);
}
@ -50,7 +48,7 @@ PERF_TEST_P(Size_MatType, max, TYPICAL_MATS_CORE_ARITHM)
declare.in(a, b, WARMUP_RNG).out(c);
TEST_CYCLE() max(a, b, c);
TEST_CYCLE() cv::max(a, b, c);
SANITY_CHECK(c);
}
@ -65,7 +63,7 @@ PERF_TEST_P(Size_MatType, maxScalar, TYPICAL_MATS_CORE_ARITHM)
declare.in(a, b, WARMUP_RNG).out(c);
TEST_CYCLE() max(a, b, c);
TEST_CYCLE() cv::max(a, b, c);
SANITY_CHECK(c);
}
@ -89,7 +87,7 @@ PERF_TEST_P(Size_MatType, absdiff, TYPICAL_MATS_CORE_ARITHM)
eps = 1;
}
TEST_CYCLE() absdiff(a, b, c);
TEST_CYCLE() cv::absdiff(a, b, c);
SANITY_CHECK(c, eps);
}
@ -113,7 +111,7 @@ PERF_TEST_P(Size_MatType, absdiffScalar, TYPICAL_MATS_CORE_ARITHM)
eps = 1;
}
TEST_CYCLE() absdiff(a, b, c);
TEST_CYCLE() cv::absdiff(a, b, c);
SANITY_CHECK(c, eps);
}
@ -138,7 +136,7 @@ PERF_TEST_P(Size_MatType, add, TYPICAL_MATS_CORE_ARITHM)
eps = 1;
}
TEST_CYCLE() add(a, b, c);
TEST_CYCLE() cv::add(a, b, c);
SANITY_CHECK(c, eps);
}
@ -162,7 +160,7 @@ PERF_TEST_P(Size_MatType, addScalar, TYPICAL_MATS_CORE_ARITHM)
eps = 1;
}
TEST_CYCLE() add(a, b, c);
TEST_CYCLE() cv::add(a, b, c);
SANITY_CHECK(c, eps);
}
@ -186,7 +184,7 @@ PERF_TEST_P(Size_MatType, subtract, TYPICAL_MATS_CORE_ARITHM)
eps = 1;
}
TEST_CYCLE() subtract(a, b, c);
TEST_CYCLE() cv::subtract(a, b, c);
SANITY_CHECK(c, eps);
}
@ -210,7 +208,7 @@ PERF_TEST_P(Size_MatType, subtractScalar, TYPICAL_MATS_CORE_ARITHM)
eps = 1;
}
TEST_CYCLE() subtract(a, b, c);
TEST_CYCLE() cv::subtract(a, b, c);
SANITY_CHECK(c, eps);
}
@ -229,7 +227,7 @@ PERF_TEST_P(Size_MatType, multiply, TYPICAL_MATS_CORE_ARITHM)
b /= (2 << 16);
}
TEST_CYCLE() multiply(a, b, c);
TEST_CYCLE() cv::multiply(a, b, c);
SANITY_CHECK(c, 1e-8);
}
@ -250,7 +248,7 @@ PERF_TEST_P(Size_MatType, multiplyScale, TYPICAL_MATS_CORE_ARITHM)
b /= (2 << 16);
}
TEST_CYCLE() multiply(a, b, c, scale);
TEST_CYCLE() cv::multiply(a, b, c, scale);
SANITY_CHECK(c, 1e-8);
}
@ -264,7 +262,7 @@ PERF_TEST_P(Size_MatType, divide, TYPICAL_MATS_CORE_ARITHM)
declare.in(a, b, WARMUP_RNG).out(c);
TEST_CYCLE() divide(a, b, c, scale);
TEST_CYCLE() cv::divide(a, b, c, scale);
SANITY_CHECK_NOTHING();
}
@ -278,7 +276,9 @@ PERF_TEST_P(Size_MatType, reciprocal, TYPICAL_MATS_CORE_ARITHM)
declare.in(b, WARMUP_RNG).out(c);
TEST_CYCLE() divide(scale, b, c);
TEST_CYCLE() cv::divide(scale, b, c);
SANITY_CHECK_NOTHING();
}
} // namespace

8
modules/core/perf/perf_bitwise.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
#define TYPICAL_MAT_SIZES_BITW_ARITHM TYPICAL_MAT_SIZES
#define TYPICAL_MAT_TYPES_BITW_ARITHM CV_8UC1, CV_8SC1, CV_8UC4, CV_32SC1, CV_32SC4
@ -73,3 +71,5 @@ PERF_TEST_P(Size_MatType, bitwise_xor, TYPICAL_MATS_BITW_ARITHM)
SANITY_CHECK(c);
}
} // namespace

10
modules/core/perf/perf_compare.cpp
Unescape View File

@ -1,14 +1,12 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
CV_ENUM(CmpType, CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE)
typedef std::tr1::tuple<Size, MatType, CmpType> Size_MatType_CmpType_t;
typedef tuple<Size, MatType, CmpType> Size_MatType_CmpType_t;
typedef perf::TestBaseWithParam<Size_MatType_CmpType_t> Size_MatType_CmpType;
PERF_TEST_P( Size_MatType_CmpType, compare,
@ -57,3 +55,5 @@ PERF_TEST_P( Size_MatType_CmpType, compareScalar,
SANITY_CHECK(dst);
}
} // namespace

10
modules/core/perf/perf_convertTo.cpp
Unescape View File

@ -1,12 +1,10 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
typedef std::tr1::tuple<Size, MatType, MatType, int, double> Size_DepthSrc_DepthDst_Channels_alpha_t;
typedef tuple<Size, MatType, MatType, int, double> Size_DepthSrc_DepthDst_Channels_alpha_t;
typedef perf::TestBaseWithParam<Size_DepthSrc_DepthDst_Channels_alpha_t> Size_DepthSrc_DepthDst_Channels_alpha;
PERF_TEST_P( Size_DepthSrc_DepthDst_Channels_alpha, convertTo,
@ -39,3 +37,5 @@ PERF_TEST_P( Size_DepthSrc_DepthDst_Channels_alpha, convertTo,
eps = eps * std::max(1.0, fabs(alpha));
SANITY_CHECK(dst, eps);
}
} // namespace

8
modules/core/perf/perf_cvround.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
template <typename T>
static void CvRoundMat(const cv::Mat & src, cv::Mat & dst)
@ -43,3 +41,5 @@ PERF_TEST_P(Size_MatType, CvRound_Float,
SANITY_CHECK_NOTHING();
}
} // namespace

14
modules/core/perf/perf_dft.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
///////////////////////////////////////////////////////dft//////////////////////////////////////////////////////////////
@ -13,7 +11,7 @@ using std::tr1::get;
CV_ENUM(FlagsType, 0, DFT_INVERSE, DFT_SCALE, DFT_COMPLEX_OUTPUT, DFT_ROWS, DFT_INVERSE|DFT_COMPLEX_OUTPUT)
#define TEST_MATS_DFT testing::Combine(testing::Values(MAT_SIZES_DFT), testing::Values(MAT_TYPES_DFT), FlagsType::all(), testing::Values(true, false))
typedef std::tr1::tuple<Size, MatType, FlagsType, bool> Size_MatType_FlagsType_NzeroRows_t;
typedef tuple<Size, MatType, FlagsType, bool> Size_MatType_FlagsType_NzeroRows_t;
typedef perf::TestBaseWithParam<Size_MatType_FlagsType_NzeroRows_t> Size_MatType_FlagsType_NzeroRows;
PERF_TEST_P(Size_MatType_FlagsType_NzeroRows, dft, TEST_MATS_DFT)
@ -42,7 +40,7 @@ PERF_TEST_P(Size_MatType_FlagsType_NzeroRows, dft, TEST_MATS_DFT)
CV_ENUM(DCT_FlagsType, 0, DCT_INVERSE , DCT_ROWS, DCT_INVERSE|DCT_ROWS)
typedef std::tr1::tuple<Size, MatType, DCT_FlagsType> Size_MatType_Flag_t;
typedef tuple<Size, MatType, DCT_FlagsType> Size_MatType_Flag_t;
typedef perf::TestBaseWithParam<Size_MatType_Flag_t> Size_MatType_Flag;
PERF_TEST_P(Size_MatType_Flag, dct, testing::Combine(
@ -66,4 +64,6 @@ PERF_TEST_P(Size_MatType_Flag, dct, testing::Combine(
TEST_CYCLE() dct(src, dst, flags);
SANITY_CHECK(dst, 1e-5, ERROR_RELATIVE);
}
}
} // namespace

10
modules/core/perf/perf_dot.cpp
Unescape View File

@ -1,12 +1,10 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
typedef tr1::tuple<MatType, int> MatType_Length_t;
typedef tuple<MatType, int> MatType_Length_t;
typedef TestBaseWithParam<MatType_Length_t> MatType_Length;
PERF_TEST_P( MatType_Length, dot,
@ -29,3 +27,5 @@ PERF_TEST_P( MatType_Length, dot,
SANITY_CHECK(product, 1e-6, ERROR_RELATIVE);
}
} // namespace

8
modules/core/perf/perf_inRange.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
#define TYPICAL_MAT_TYPES_INRANGE CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_32FC4
#define TYPICAL_MATS_INRANGE testing::Combine(testing::Values(szVGA, sz720p, sz1080p), testing::Values(TYPICAL_MAT_TYPES_INRANGE))
@ -24,3 +22,5 @@ PERF_TEST_P(Size_MatType, inRange, TYPICAL_MATS_INRANGE)
SANITY_CHECK(dst);
}
} // namespace

10
modules/core/perf/perf_io_base64.cpp
Unescape View File

@ -1,12 +1,10 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
typedef std::tr1::tuple<cv::Size, MatType, String> Size_MatType_Str_t;
typedef tuple<cv::Size, MatType, String> Size_MatType_Str_t;
typedef TestBaseWithParam<Size_MatType_Str_t> Size_Mat_StrType;
#define MAT_SIZES ::perf::sz1080p/*, ::perf::sz4320p*/
@ -84,3 +82,5 @@ PERF_TEST_P(Size_Mat_StrType, fs_base64,
remove(file_name.c_str());
SANITY_CHECK_NOTHING();
}
} // namespace

5
modules/core/perf/perf_lut.cpp
Unescape View File

@ -1,7 +1,6 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test { namespace {
using namespace perf;
typedef perf::TestBaseWithParam<Size> SizePrm;
@ -24,3 +23,5 @@ PERF_TEST_P( SizePrm, LUT,
SANITY_CHECK(dst, 0.1);
}
}} // namespace

8
modules/core/perf/perf_mat.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
PERF_TEST_P(Size_MatType, Mat_Eye,
testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
@ -124,3 +122,5 @@ PERF_TEST_P(Size_MatType, Mat_Transform,
SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
}
} // namespace

6
modules/core/perf/perf_math.cpp
Unescape View File

@ -1,7 +1,7 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
namespace {
@ -158,3 +158,5 @@ INSTANTIATE_TEST_CASE_P(/*nothing*/ , KMeans,
);
}
} // namespace

10
modules/core/perf/perf_merge.cpp
Unescape View File

@ -1,12 +1,10 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
typedef std::tr1::tuple<Size, MatType, int> Size_SrcDepth_DstChannels_t;
typedef tuple<Size, MatType, int> Size_SrcDepth_DstChannels_t;
typedef perf::TestBaseWithParam<Size_SrcDepth_DstChannels_t> Size_SrcDepth_DstChannels;
PERF_TEST_P( Size_SrcDepth_DstChannels, merge,
@ -38,3 +36,5 @@ PERF_TEST_P( Size_SrcDepth_DstChannels, merge,
double eps = srcDepth <= CV_32S ? 1e-12 : (FLT_EPSILON * maxValue);
SANITY_CHECK(dst, eps);
}
} // namespace

8
modules/core/perf/perf_minmaxloc.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
PERF_TEST_P(Size_MatType, minMaxLoc, testing::Combine(
testing::Values(TYPICAL_MAT_SIZES),
@ -33,3 +31,5 @@ PERF_TEST_P(Size_MatType, minMaxLoc, testing::Combine(
SANITY_CHECK(minVal, 1e-12);
SANITY_CHECK(maxVal, 1e-12);
}
} // namespace

32
modules/core/perf/perf_norm.cpp
Unescape View File

@ -1,16 +1,14 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
#define HAMMING_NORM_SIZES cv::Size(640, 480), cv::Size(1920, 1080)
#define HAMMING_NORM_TYPES CV_8UC1
CV_FLAGS(NormType, NORM_HAMMING2, NORM_HAMMING, NORM_INF, NORM_L1, NORM_L2, NORM_TYPE_MASK, NORM_RELATIVE, NORM_MINMAX)
typedef std::tr1::tuple<Size, MatType, NormType> Size_MatType_NormType_t;
typedef tuple<Size, MatType, NormType> Size_MatType_NormType_t;
typedef perf::TestBaseWithParam<Size_MatType_NormType_t> Size_MatType_NormType;
PERF_TEST_P(Size_MatType_NormType, norm,
@ -30,7 +28,7 @@ PERF_TEST_P(Size_MatType_NormType, norm,
declare.in(src, WARMUP_RNG);
TEST_CYCLE() n = norm(src, normType);
TEST_CYCLE() n = cv::norm(src, normType);
SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
}
@ -53,7 +51,7 @@ PERF_TEST_P(Size_MatType_NormType, norm_mask,
declare.in(src, WARMUP_RNG).in(mask);
TEST_CYCLE() n = norm(src, normType, mask);
TEST_CYCLE() n = cv::norm(src, normType, mask);
SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
}
@ -76,7 +74,7 @@ PERF_TEST_P(Size_MatType_NormType, norm2,
declare.in(src1, src2, WARMUP_RNG);
TEST_CYCLE() n = norm(src1, src2, normType);
TEST_CYCLE() n = cv::norm(src1, src2, normType);
SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
}
@ -100,13 +98,13 @@ PERF_TEST_P(Size_MatType_NormType, norm2_mask,
declare.in(src1, src2, WARMUP_RNG).in(mask);
TEST_CYCLE() n = norm(src1, src2, normType, mask);
TEST_CYCLE() n = cv::norm(src1, src2, normType, mask);
SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
}
namespace {
typedef std::tr1::tuple<NormType, MatType, Size> PerfHamming_t;
typedef tuple<NormType, MatType, Size> PerfHamming_t;
typedef perf::TestBaseWithParam<PerfHamming_t> PerfHamming;
PERF_TEST_P(PerfHamming, norm,
@ -126,7 +124,7 @@ PERF_TEST_P(PerfHamming, norm,
declare.in(src, WARMUP_RNG);
TEST_CYCLE() n = norm(src, normType);
TEST_CYCLE() n = cv::norm(src, normType);
(void)n;
SANITY_CHECK_NOTHING();
@ -150,7 +148,7 @@ PERF_TEST_P(PerfHamming, norm2,
declare.in(src1, src2, WARMUP_RNG);
TEST_CYCLE() n = norm(src1, src2, normType);
TEST_CYCLE() n = cv::norm(src1, src2, normType);
(void)n;
SANITY_CHECK_NOTHING();
@ -180,7 +178,7 @@ PERF_TEST_P(Size_MatType_NormType, normalize,
declare.in(src, WARMUP_RNG).out(dst);
TEST_CYCLE() normalize(src, dst, alpha, 0., normType);
TEST_CYCLE() cv::normalize(src, dst, alpha, 0., normType);
SANITY_CHECK(dst, 1e-6);
}
@ -208,7 +206,7 @@ PERF_TEST_P(Size_MatType_NormType, normalize_mask,
declare.in(src, WARMUP_RNG).in(mask).out(dst);
declare.time(100);
TEST_CYCLE() normalize(src, dst, alpha, 0., normType, -1, mask);
TEST_CYCLE() cv::normalize(src, dst, alpha, 0., normType, -1, mask);
SANITY_CHECK(dst, 1e-6);
}
@ -234,7 +232,7 @@ PERF_TEST_P(Size_MatType_NormType, normalize_32f,
declare.in(src, WARMUP_RNG).out(dst);
TEST_CYCLE() normalize(src, dst, alpha, 0., normType, CV_32F);
TEST_CYCLE() cv::normalize(src, dst, alpha, 0., normType, CV_32F);
SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
}
@ -250,7 +248,9 @@ PERF_TEST_P( Size_MatType, normalize_minmax, TYPICAL_MATS )
declare.in(src, WARMUP_RNG).out(dst);
declare.time(30);
TEST_CYCLE() normalize(src, dst, 20., 100., NORM_MINMAX);
TEST_CYCLE() cv::normalize(src, dst, 20., 100., NORM_MINMAX);
SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
}
} // namespace

15
modules/core/perf/perf_precomp.hpp
Unescape View File

@ -1,18 +1,9 @@
#ifdef __GNUC__
# pragma GCC diagnostic ignored "-Wmissing-declarations"
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic ignored "-Wmissing-prototypes"
# pragma GCC diagnostic ignored "-Wextra"
# endif
#endif
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
#ifndef __OPENCV_PERF_PRECOMP_HPP__
#define __OPENCV_PERF_PRECOMP_HPP__
#include "opencv2/ts.hpp"
#ifdef GTEST_CREATE_SHARED_LIBRARY
#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
#endif
#endif

10
modules/core/perf/perf_reduce.cpp
Unescape View File

@ -1,14 +1,12 @@
#include "perf_precomp.hpp"
#include "opencv2/core/core_c.h"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
CV_ENUM(ROp, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
typedef std::tr1::tuple<Size, MatType, ROp> Size_MatType_ROp_t;
typedef tuple<Size, MatType, ROp> Size_MatType_ROp_t;
typedef perf::TestBaseWithParam<Size_MatType_ROp_t> Size_MatType_ROp;
@ -66,3 +64,5 @@ PERF_TEST_P(Size_MatType_ROp, reduceC,
SANITY_CHECK(vec, 1);
}
} // namespace

10
modules/core/perf/perf_sort.cpp
Unescape View File

@ -1,13 +1,9 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::tuple;
using std::tr1::make_tuple;
using std::tr1::get;
#define TYPICAL_MAT_SIZES_SORT TYPICAL_MAT_SIZES
#define TYPICAL_MAT_TYPES_SORT CV_8UC1, CV_16UC1, CV_32FC1
#define SORT_TYPES SORT_EVERY_ROW | SORT_ASCENDING, SORT_EVERY_ROW | SORT_DESCENDING
@ -50,3 +46,5 @@ PERF_TEST_P(sortIdxFixture, sorIdx, TYPICAL_MATS_SORT)
SANITY_CHECK_NOTHING();
}
} // namespace

10
modules/core/perf/perf_split.cpp
Unescape View File

@ -1,12 +1,10 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
typedef std::tr1::tuple<Size, MatType, int> Size_Depth_Channels_t;
typedef tuple<Size, MatType, int> Size_Depth_Channels_t;
typedef perf::TestBaseWithParam<Size_Depth_Channels_t> Size_Depth_Channels;
PERF_TEST_P( Size_Depth_Channels, split,
@ -35,3 +33,5 @@ PERF_TEST_P( Size_Depth_Channels, split,
SANITY_CHECK(mv, 1e-12);
#endif
}
} // namespace

8
modules/core/perf/perf_stat.cpp
Unescape View File

@ -1,10 +1,8 @@
#include "perf_precomp.hpp"
using namespace std;
using namespace cv;
namespace opencv_test
{
using namespace perf;
using std::tr1::make_tuple;
using std::tr1::get;
PERF_TEST_P(Size_MatType, sum, TYPICAL_MATS)
{
@ -102,3 +100,5 @@ PERF_TEST_P(Size_MatType, countNonZero, testing::Combine( testing::Values( TYPIC
SANITY_CHECK(cnt);
}
} // namespace

11
modules/core/perf/perf_umat.cpp
Unescape View File

@ -5,13 +5,10 @@
#include "perf_precomp.hpp"
#include "opencv2/ts/ocl_perf.hpp"
using namespace std;
using namespace cv;
using namespace ::perf;
namespace opencv_test
{
using namespace perf;
using namespace ::cvtest::ocl;
using namespace ::testing;
using std::tr1::tuple;
using std::tr1::get;
struct OpenCLState
@ -63,3 +60,5 @@ OCL_PERF_TEST_P(UMatTest, CustomPtr, Combine(Values(sz1080p, sz2160p), Bool(), :
SANITY_CHECK_NOTHING();
}
} // namespace

10
modules/core/test/ocl/test_arithm.cpp
Unescape View File

@ -42,11 +42,9 @@
#include "../test_precomp.hpp"
#include "opencv2/ts/ocl_test.hpp"
#include <cmath>
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
//////////////////////////////// LUT /////////////////////////////////////////////////
@ -138,8 +136,8 @@ PARAM_TEST_CASE(ArithmTestBase, MatDepth, Channels, bool)
{
const int type = CV_MAKE_TYPE(depth, cn);
double minV = getMinVal(type);
double maxV = getMaxVal(type);
double minV = cvtest::getMinVal(type);
double maxV = cvtest::getMaxVal(type);
Size roiSize = randomSize(1, MAX_VALUE);
Border src1Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
@ -1964,6 +1962,6 @@ OCL_TEST(Normalize, DISABLED_regression_5876_inplace_change_type)
EXPECT_EQ(0, cvtest::norm(um, uresult, NORM_INF));
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/test/ocl/test_channels.cpp
Unescape View File

@ -49,7 +49,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
//////////////////////////////////////// Merge ///////////////////////////////////////////////
@ -464,6 +464,6 @@ OCL_INSTANTIATE_TEST_CASE_P(Channels, MixChannels, Combine(OCL_ALL_DEPTHS, Bool(
OCL_INSTANTIATE_TEST_CASE_P(Channels, InsertChannel, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
OCL_INSTANTIATE_TEST_CASE_P(Channels, ExtractChannel, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool()));
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/test/ocl/test_dft.cpp
Unescape View File

@ -56,7 +56,7 @@ enum OCL_FFT_TYPE
C2C = 3
};
namespace cvtest {
namespace opencv_test {
namespace ocl {
////////////////////////////////////////////////////////////////////////////
@ -185,6 +185,6 @@ OCL_INSTANTIATE_TEST_CASE_P(Core, Dft, Combine(Values(cv::Size(45, 72), cv::Size
)
);
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/test/ocl/test_gemm.cpp
Unescape View File

@ -47,7 +47,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
////////////////////////////////////////////////////////////////////////////
@ -145,6 +145,6 @@ OCL_INSTANTIATE_TEST_CASE_P(Core, Gemm, ::testing::Combine(
testing::Values(CV_32FC1, CV_32FC2, CV_64FC1, CV_64FC2),
Bool(), Bool(), Bool(), Bool()));
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/test/ocl/test_image2d.cpp
Unescape View File

@ -10,7 +10,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
TEST(Image2D, createAliasEmptyUMat)
@ -91,6 +91,6 @@ TEST(Image2D, turnOffOpenCL)
std::cout << "OpenCL runtime not found. Test skipped." << std::endl;
}
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL

4
modules/core/test/ocl/test_matrix_expr.cpp
Unescape View File

@ -10,7 +10,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
//////////////////////////////// UMat Expressions /////////////////////////////////////////////////
@ -80,6 +80,6 @@ OCL_TEST_P(UMatExpr, Ones)
OCL_INSTANTIATE_TEST_CASE_P(MatrixOperation, UMatExpr, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS));
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif

4
modules/core/test/ocl/test_matrix_operation.cpp
Unescape View File

@ -49,7 +49,7 @@
#ifdef HAVE_OPENCL
namespace cvtest {
namespace opencv_test {
namespace ocl {
////////////////////////////////converto/////////////////////////////////////////////////
@ -219,6 +219,6 @@ OCL_INSTANTIATE_TEST_CASE_P(MatrixOperation, CopyTo, Combine(
OCL_INSTANTIATE_TEST_CASE_P(MatrixOperation, SetTo, Combine(
OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool(), Bool()));
} } // namespace cvtest::ocl
} } // namespace opencv_test::ocl
#endif

1
modules/core/test/ocl/test_opencl.cpp
Unescape View File

@ -4,7 +4,6 @@
#include "../test_precomp.hpp"
#include <opencv2/core/ocl.hpp>
#include <fstream>
namespace opencv_test { namespace {

236
modules/core/test/test_arithm.cpp
Unescape View File

@ -1,11 +1,9 @@
#include "test_precomp.hpp"
#include <cmath>
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace cvtest
{
namespace opencv_test { namespace {
const int ARITHM_NTESTS = 1000;
const int ARITHM_RNG_SEED = -1;
@ -31,7 +29,7 @@ struct BaseElemWiseOp
virtual void getRandomSize(RNG& rng, vector<int>& size)
{
cvtest::randomSize(rng, 2, ARITHM_MAX_NDIMS, cvtest::ARITHM_MAX_SIZE_LOG, size);
cvtest::randomSize(rng, 2, ARITHM_MAX_NDIMS, ARITHM_MAX_SIZE_LOG, size);
}
virtual int getRandomType(RNG& rng)
@ -119,9 +117,9 @@ struct AddOp : public BaseAddOp
void op(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
if( mask.empty() )
add(src[0], src[1], dst);
cv::add(src[0], src[1], dst);
else
add(src[0], src[1], dst, mask);
cv::add(src[0], src[1], dst, mask);
}
};
@ -132,9 +130,9 @@ struct SubOp : public BaseAddOp
void op(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
if( mask.empty() )
subtract(src[0], src[1], dst);
cv::subtract(src[0], src[1], dst);
else
subtract(src[0], src[1], dst, mask);
cv::subtract(src[0], src[1], dst, mask);
}
};
@ -145,9 +143,9 @@ struct AddSOp : public BaseAddOp
void op(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
if( mask.empty() )
add(src[0], gamma, dst);
cv::add(src[0], gamma, dst);
else
add(src[0], gamma, dst, mask);
cv::add(src[0], gamma, dst, mask);
}
};
@ -158,9 +156,9 @@ struct SubRSOp : public BaseAddOp
void op(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
if( mask.empty() )
subtract(gamma, src[0], dst);
cv::subtract(gamma, src[0], dst);
else
subtract(gamma, src[0], dst, mask);
cv::subtract(gamma, src[0], dst, mask);
}
};
@ -170,7 +168,7 @@ struct ScaleAddOp : public BaseAddOp
ScaleAddOp() : BaseAddOp(2, FIX_BETA+FIX_GAMMA, 1, 1, Scalar::all(0)) {}
void op(const vector<Mat>& src, Mat& dst, const Mat&)
{
scaleAdd(src[0], alpha, src[1], dst);
cv::scaleAdd(src[0], alpha, src[1], dst);
}
double getMaxErr(int depth)
{
@ -184,7 +182,7 @@ struct AddWeightedOp : public BaseAddOp
AddWeightedOp() : BaseAddOp(2, REAL_GAMMA, 1, 1, Scalar::all(0)) {}
void op(const vector<Mat>& src, Mat& dst, const Mat&)
{
addWeighted(src[0], alpha, src[1], beta, gamma[0], dst);
cv::addWeighted(src[0], alpha, src[1], beta, gamma[0], dst);
}
double getMaxErr(int depth)
{
@ -282,11 +280,11 @@ struct LogicOp : public BaseElemWiseOp
void op(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
if( opcode == '&' )
bitwise_and(src[0], src[1], dst, mask);
cv::bitwise_and(src[0], src[1], dst, mask);
else if( opcode == '|' )
bitwise_or(src[0], src[1], dst, mask);
cv::bitwise_or(src[0], src[1], dst, mask);
else
bitwise_xor(src[0], src[1], dst, mask);
cv::bitwise_xor(src[0], src[1], dst, mask);
}
void refop(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
@ -313,13 +311,13 @@ struct LogicSOp : public BaseElemWiseOp
void op(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
if( opcode == '&' )
bitwise_and(src[0], gamma, dst, mask);
cv::bitwise_and(src[0], gamma, dst, mask);
else if( opcode == '|' )
bitwise_or(src[0], gamma, dst, mask);
cv::bitwise_or(src[0], gamma, dst, mask);
else if( opcode == '^' )
bitwise_xor(src[0], gamma, dst, mask);
cv::bitwise_xor(src[0], gamma, dst, mask);
else
bitwise_not(src[0], dst);
cv::bitwise_not(src[0], dst);
}
void refop(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
@ -547,6 +545,7 @@ template<typename _Tp> static void inRange_(const _Tp* src, const _Tp* a, const
}
}
namespace reference {
static void inRange(const Mat& src, const Mat& lb, const Mat& rb, Mat& dst)
{
@ -597,7 +596,6 @@ static void inRange(const Mat& src, const Mat& lb, const Mat& rb, Mat& dst)
}
}
static void inRangeS(const Mat& src, const Scalar& lb, const Scalar& rb, Mat& dst)
{
dst.create( src.dims, &src.size[0], CV_8U );
@ -647,6 +645,8 @@ static void inRangeS(const Mat& src, const Scalar& lb, const Scalar& rb, Mat& ds
}
}
} // namespace
CVTEST_GUARD_SYMBOL(inRange);
struct InRangeSOp : public BaseElemWiseOp
{
@ -657,7 +657,7 @@ struct InRangeSOp : public BaseElemWiseOp
}
void refop(const vector<Mat>& src, Mat& dst, const Mat&)
{
cvtest::inRangeS(src[0], gamma, gamma1, dst);
reference::inRangeS(src[0], gamma, gamma1, dst);
}
double getMaxErr(int)
{
@ -695,7 +695,7 @@ struct InRangeOp : public BaseElemWiseOp
cvtest::min(src[1], src[2], lb);
cvtest::max(src[1], src[2], rb);
cvtest::inRange(src[0], lb, rb, dst);
reference::inRange(src[0], lb, rb, dst);
}
double getMaxErr(int)
{
@ -827,6 +827,7 @@ struct ConvertScaleAbsOp : public BaseElemWiseOp
}
};
namespace reference {
static void flip(const Mat& src, Mat& dst, int flipcode)
{
@ -867,13 +868,14 @@ static void setIdentity(Mat& dst, const Scalar& s)
}
}
} // namespace
struct FlipOp : public BaseElemWiseOp
{
FlipOp() : BaseElemWiseOp(1, FIX_ALPHA+FIX_BETA+FIX_GAMMA, 1, 1, Scalar::all(0)) { flipcode = 0; }
void getRandomSize(RNG& rng, vector<int>& size)
{
cvtest::randomSize(rng, 2, 2, cvtest::ARITHM_MAX_SIZE_LOG, size);
cvtest::randomSize(rng, 2, 2, ARITHM_MAX_SIZE_LOG, size);
}
void op(const vector<Mat>& src, Mat& dst, const Mat&)
{
@ -881,7 +883,7 @@ struct FlipOp : public BaseElemWiseOp
}
void refop(const vector<Mat>& src, Mat& dst, const Mat&)
{
cvtest::flip(src[0], dst, flipcode);
reference::flip(src[0], dst, flipcode);
}
void generateScalars(int, RNG& rng)
{
@ -899,7 +901,7 @@ struct TransposeOp : public BaseElemWiseOp
TransposeOp() : BaseElemWiseOp(1, FIX_ALPHA+FIX_BETA+FIX_GAMMA, 1, 1, Scalar::all(0)) {}
void getRandomSize(RNG& rng, vector<int>& size)
{
cvtest::randomSize(rng, 2, 2, cvtest::ARITHM_MAX_SIZE_LOG, size);
cvtest::randomSize(rng, 2, 2, ARITHM_MAX_SIZE_LOG, size);
}
void op(const vector<Mat>& src, Mat& dst, const Mat&)
{
@ -920,7 +922,7 @@ struct SetIdentityOp : public BaseElemWiseOp
SetIdentityOp() : BaseElemWiseOp(0, FIX_ALPHA+FIX_BETA, 1, 1, Scalar::all(0)) {}
void getRandomSize(RNG& rng, vector<int>& size)
{
cvtest::randomSize(rng, 2, 2, cvtest::ARITHM_MAX_SIZE_LOG, size);
cvtest::randomSize(rng, 2, 2, ARITHM_MAX_SIZE_LOG, size);
}
void op(const vector<Mat>&, Mat& dst, const Mat&)
{
@ -928,7 +930,7 @@ struct SetIdentityOp : public BaseElemWiseOp
}
void refop(const vector<Mat>&, Mat& dst, const Mat&)
{
cvtest::setIdentity(dst, gamma);
reference::setIdentity(dst, gamma);
}
double getMaxErr(int)
{
@ -953,7 +955,7 @@ struct SetZeroOp : public BaseElemWiseOp
}
};
namespace reference {
static void exp(const Mat& src, Mat& dst)
{
dst.create( src.dims, &src.size[0], src.type() );
@ -1012,6 +1014,8 @@ static void log(const Mat& src, Mat& dst)
}
}
} // namespace
struct ExpOp : public BaseElemWiseOp
{
ExpOp() : BaseElemWiseOp(1, FIX_ALPHA+FIX_BETA+FIX_GAMMA, 1, 1, Scalar::all(0)) {}
@ -1030,7 +1034,7 @@ struct ExpOp : public BaseElemWiseOp
}
void refop(const vector<Mat>& src, Mat& dst, const Mat&)
{
cvtest::exp(src[0], dst);
reference::exp(src[0], dst);
}
double getMaxErr(int depth)
{
@ -1054,14 +1058,14 @@ struct LogOp : public BaseElemWiseOp
void op(const vector<Mat>& src, Mat& dst, const Mat&)
{
Mat temp;
cvtest::exp(src[0], temp);
reference::exp(src[0], temp);
cv::log(temp, dst);
}
void refop(const vector<Mat>& src, Mat& dst, const Mat&)
{
Mat temp;
cvtest::exp(src[0], temp);
cvtest::log(temp, dst);
reference::exp(src[0], temp);
reference::log(temp, dst);
}
double getMaxErr(int depth)
{
@ -1070,6 +1074,7 @@ struct LogOp : public BaseElemWiseOp
};
namespace reference {
static void cartToPolar(const Mat& mx, const Mat& my, Mat& mmag, Mat& mangle, bool angleInDegrees)
{
CV_Assert( (mx.type() == CV_32F || mx.type() == CV_64F) &&
@ -1120,6 +1125,7 @@ static void cartToPolar(const Mat& mx, const Mat& my, Mat& mmag, Mat& mangle, bo
}
}
} // namespace
struct CartToPolarToCartOp : public BaseElemWiseOp
{
@ -1147,7 +1153,7 @@ struct CartToPolarToCartOp : public BaseElemWiseOp
void refop(const vector<Mat>& src, Mat& dst, const Mat&)
{
Mat mag, angle;
cvtest::cartToPolar(src[0], src[1], mag, angle, angleInDegrees);
reference::cartToPolar(src[0], src[1], mag, angle, angleInDegrees);
Mat msrc[] = {mag, angle, src[0], src[1]};
int pairs[] = {0, 0, 1, 1, 2, 2, 3, 3};
dst.create(src[0].dims, src[0].size, CV_MAKETYPE(src[0].depth(), 4));
@ -1382,9 +1388,7 @@ struct MinMaxLocOp : public BaseElemWiseOp
};
}
typedef Ptr<cvtest::BaseElemWiseOp> ElemWiseOpPtr;
typedef Ptr<BaseElemWiseOp> ElemWiseOpPtr;
class ElemWiseTest : public ::testing::TestWithParam<ElemWiseOpPtr> {};
TEST_P(ElemWiseTest, accuracy)
@ -1392,15 +1396,15 @@ TEST_P(ElemWiseTest, accuracy)
ElemWiseOpPtr op = GetParam();
int testIdx = 0;
RNG rng((uint64)cvtest::ARITHM_RNG_SEED);
for( testIdx = 0; testIdx < cvtest::ARITHM_NTESTS; testIdx++ )
RNG rng((uint64)ARITHM_RNG_SEED);
for( testIdx = 0; testIdx < ARITHM_NTESTS; testIdx++ )
{
vector<int> size;
op->getRandomSize(rng, size);
int type = op->getRandomType(rng);
int depth = CV_MAT_DEPTH(type);
bool haveMask = ((op->flags & cvtest::BaseElemWiseOp::SUPPORT_MASK) != 0
|| (op->flags & cvtest::BaseElemWiseOp::SUPPORT_MULTICHANNELMASK) != 0) && rng.uniform(0, 4) == 0;
bool haveMask = ((op->flags & BaseElemWiseOp::SUPPORT_MASK) != 0
|| (op->flags & BaseElemWiseOp::SUPPORT_MULTICHANNELMASK) != 0) && rng.uniform(0, 4) == 0;
double minval=0, maxval=0;
op->getValueRange(depth, minval, maxval);
@ -1410,13 +1414,13 @@ TEST_P(ElemWiseTest, accuracy)
src[i] = cvtest::randomMat(rng, size, type, minval, maxval, true);
Mat dst0, dst, mask;
if( haveMask ) {
bool multiChannelMask = (op->flags & cvtest::BaseElemWiseOp::SUPPORT_MULTICHANNELMASK) != 0
bool multiChannelMask = (op->flags & BaseElemWiseOp::SUPPORT_MULTICHANNELMASK) != 0
&& rng.uniform(0, 2) == 0;
int masktype = CV_8UC(multiChannelMask ? CV_MAT_CN(type) : 1);
mask = cvtest::randomMat(rng, size, masktype, 0, 2, true);
}
if( (haveMask || ninputs == 0) && !(op->flags & cvtest::BaseElemWiseOp::SCALAR_OUTPUT))
if( (haveMask || ninputs == 0) && !(op->flags & BaseElemWiseOp::SCALAR_OUTPUT))
{
dst0 = cvtest::randomMat(rng, size, type, minval, maxval, false);
dst = cvtest::randomMat(rng, size, type, minval, maxval, true);
@ -1434,61 +1438,61 @@ TEST_P(ElemWiseTest, accuracy)
}
INSTANTIATE_TEST_CASE_P(Core_Copy, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::CopyOp)));
INSTANTIATE_TEST_CASE_P(Core_Set, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::SetOp)));
INSTANTIATE_TEST_CASE_P(Core_SetZero, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::SetZeroOp)));
INSTANTIATE_TEST_CASE_P(Core_ConvertScale, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::ConvertScaleOp)));
INSTANTIATE_TEST_CASE_P(Core_ConvertScaleFp16, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::ConvertScaleFp16Op)));
INSTANTIATE_TEST_CASE_P(Core_ConvertScaleAbs, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::ConvertScaleAbsOp)));
INSTANTIATE_TEST_CASE_P(Core_Copy, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new CopyOp)));
INSTANTIATE_TEST_CASE_P(Core_Set, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new SetOp)));
INSTANTIATE_TEST_CASE_P(Core_SetZero, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new SetZeroOp)));
INSTANTIATE_TEST_CASE_P(Core_ConvertScale, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new ConvertScaleOp)));
INSTANTIATE_TEST_CASE_P(Core_ConvertScaleFp16, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new ConvertScaleFp16Op)));
INSTANTIATE_TEST_CASE_P(Core_ConvertScaleAbs, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new ConvertScaleAbsOp)));
INSTANTIATE_TEST_CASE_P(Core_Add, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::AddOp)));
INSTANTIATE_TEST_CASE_P(Core_Sub, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::SubOp)));
INSTANTIATE_TEST_CASE_P(Core_AddS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::AddSOp)));
INSTANTIATE_TEST_CASE_P(Core_SubRS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::SubRSOp)));
INSTANTIATE_TEST_CASE_P(Core_ScaleAdd, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::ScaleAddOp)));
INSTANTIATE_TEST_CASE_P(Core_AddWeighted, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::AddWeightedOp)));
INSTANTIATE_TEST_CASE_P(Core_AbsDiff, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::AbsDiffOp)));
INSTANTIATE_TEST_CASE_P(Core_Add, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new AddOp)));
INSTANTIATE_TEST_CASE_P(Core_Sub, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new SubOp)));
INSTANTIATE_TEST_CASE_P(Core_AddS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new AddSOp)));
INSTANTIATE_TEST_CASE_P(Core_SubRS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new SubRSOp)));
INSTANTIATE_TEST_CASE_P(Core_ScaleAdd, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new ScaleAddOp)));
INSTANTIATE_TEST_CASE_P(Core_AddWeighted, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new AddWeightedOp)));
INSTANTIATE_TEST_CASE_P(Core_AbsDiff, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new AbsDiffOp)));
INSTANTIATE_TEST_CASE_P(Core_AbsDiffS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::AbsDiffSOp)));
INSTANTIATE_TEST_CASE_P(Core_AbsDiffS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new AbsDiffSOp)));
INSTANTIATE_TEST_CASE_P(Core_And, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::LogicOp('&'))));
INSTANTIATE_TEST_CASE_P(Core_AndS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::LogicSOp('&'))));
INSTANTIATE_TEST_CASE_P(Core_Or, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::LogicOp('|'))));
INSTANTIATE_TEST_CASE_P(Core_OrS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::LogicSOp('|'))));
INSTANTIATE_TEST_CASE_P(Core_Xor, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::LogicOp('^'))));
INSTANTIATE_TEST_CASE_P(Core_XorS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::LogicSOp('^'))));
INSTANTIATE_TEST_CASE_P(Core_Not, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::LogicSOp('~'))));
INSTANTIATE_TEST_CASE_P(Core_And, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new LogicOp('&'))));
INSTANTIATE_TEST_CASE_P(Core_AndS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new LogicSOp('&'))));
INSTANTIATE_TEST_CASE_P(Core_Or, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new LogicOp('|'))));
INSTANTIATE_TEST_CASE_P(Core_OrS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new LogicSOp('|'))));
INSTANTIATE_TEST_CASE_P(Core_Xor, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new LogicOp('^'))));
INSTANTIATE_TEST_CASE_P(Core_XorS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new LogicSOp('^'))));
INSTANTIATE_TEST_CASE_P(Core_Not, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new LogicSOp('~'))));
INSTANTIATE_TEST_CASE_P(Core_Max, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::MaxOp)));
INSTANTIATE_TEST_CASE_P(Core_MaxS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::MaxSOp)));
INSTANTIATE_TEST_CASE_P(Core_Min, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::MinOp)));
INSTANTIATE_TEST_CASE_P(Core_MinS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::MinSOp)));
INSTANTIATE_TEST_CASE_P(Core_Max, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new MaxOp)));
INSTANTIATE_TEST_CASE_P(Core_MaxS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new MaxSOp)));
INSTANTIATE_TEST_CASE_P(Core_Min, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new MinOp)));
INSTANTIATE_TEST_CASE_P(Core_MinS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new MinSOp)));
INSTANTIATE_TEST_CASE_P(Core_Mul, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::MulOp)));
INSTANTIATE_TEST_CASE_P(Core_Div, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::DivOp)));
INSTANTIATE_TEST_CASE_P(Core_Recip, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::RecipOp)));
INSTANTIATE_TEST_CASE_P(Core_Mul, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new MulOp)));
INSTANTIATE_TEST_CASE_P(Core_Div, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new DivOp)));
INSTANTIATE_TEST_CASE_P(Core_Recip, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new RecipOp)));
INSTANTIATE_TEST_CASE_P(Core_Cmp, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::CmpOp)));
INSTANTIATE_TEST_CASE_P(Core_CmpS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::CmpSOp)));
INSTANTIATE_TEST_CASE_P(Core_Cmp, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new CmpOp)));
INSTANTIATE_TEST_CASE_P(Core_CmpS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new CmpSOp)));
INSTANTIATE_TEST_CASE_P(Core_InRangeS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::InRangeSOp)));
INSTANTIATE_TEST_CASE_P(Core_InRange, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::InRangeOp)));
INSTANTIATE_TEST_CASE_P(Core_InRangeS, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new InRangeSOp)));
INSTANTIATE_TEST_CASE_P(Core_InRange, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new InRangeOp)));
INSTANTIATE_TEST_CASE_P(Core_Flip, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::FlipOp)));
INSTANTIATE_TEST_CASE_P(Core_Transpose, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::TransposeOp)));
INSTANTIATE_TEST_CASE_P(Core_SetIdentity, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::SetIdentityOp)));
INSTANTIATE_TEST_CASE_P(Core_Flip, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new FlipOp)));
INSTANTIATE_TEST_CASE_P(Core_Transpose, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new TransposeOp)));
INSTANTIATE_TEST_CASE_P(Core_SetIdentity, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new SetIdentityOp)));
INSTANTIATE_TEST_CASE_P(Core_Exp, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::ExpOp)));
INSTANTIATE_TEST_CASE_P(Core_Log, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::LogOp)));
INSTANTIATE_TEST_CASE_P(Core_Exp, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new ExpOp)));
INSTANTIATE_TEST_CASE_P(Core_Log, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new LogOp)));
INSTANTIATE_TEST_CASE_P(Core_CountNonZero, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::CountNonZeroOp)));
INSTANTIATE_TEST_CASE_P(Core_Mean, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::MeanOp)));
INSTANTIATE_TEST_CASE_P(Core_MeanStdDev, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::MeanStdDevOp)));
INSTANTIATE_TEST_CASE_P(Core_Sum, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::SumOp)));
INSTANTIATE_TEST_CASE_P(Core_Norm, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::NormOp)));
INSTANTIATE_TEST_CASE_P(Core_MinMaxLoc, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::MinMaxLocOp)));
INSTANTIATE_TEST_CASE_P(Core_CartToPolarToCart, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new cvtest::CartToPolarToCartOp)));
INSTANTIATE_TEST_CASE_P(Core_CountNonZero, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new CountNonZeroOp)));
INSTANTIATE_TEST_CASE_P(Core_Mean, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new MeanOp)));
INSTANTIATE_TEST_CASE_P(Core_MeanStdDev, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new MeanStdDevOp)));
INSTANTIATE_TEST_CASE_P(Core_Sum, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new SumOp)));
INSTANTIATE_TEST_CASE_P(Core_Norm, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new NormOp)));
INSTANTIATE_TEST_CASE_P(Core_MinMaxLoc, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new MinMaxLocOp)));
INSTANTIATE_TEST_CASE_P(Core_CartToPolarToCart, ElemWiseTest, ::testing::Values(ElemWiseOpPtr(new CartToPolarToCartOp)));
TEST(Core_ArithmMask, uninitialized)
@ -1528,34 +1532,34 @@ TEST(Core_ArithmMask, uninitialized)
a.convertTo(a1, depth1);
b.convertTo(b1, depth1);
// invert the mask
compare(mask, 0, mask1, CMP_EQ);
cv::compare(mask, 0, mask1, CMP_EQ);
a1.setTo(0, mask1);
b1.setTo(0, mask1);
if( op == 0 )
{
add(a, b, c, mask);
add(a1, b1, d);
cv::add(a, b, c, mask);
cv::add(a1, b1, d);
}
else if( op == 1 )
{
subtract(a, b, c, mask);
subtract(a1, b1, d);
cv::subtract(a, b, c, mask);
cv::subtract(a1, b1, d);
}
else if( op == 2 )
{
bitwise_and(a, b, c, mask);
bitwise_and(a1, b1, d);
cv::bitwise_and(a, b, c, mask);
cv::bitwise_and(a1, b1, d);
}
else if( op == 3 )
{
bitwise_or(a, b, c, mask);
bitwise_or(a1, b1, d);
cv::bitwise_or(a, b, c, mask);
cv::bitwise_or(a1, b1, d);
}
else if( op == 4 )
{
bitwise_xor(a, b, c, mask);
bitwise_xor(a1, b1, d);
cv::bitwise_xor(a, b, c, mask);
cv::bitwise_xor(a1, b1, d);
}
Mat d1;
d.convertTo(d1, depth);
@ -1630,7 +1634,7 @@ TEST_P(Mul1, One)
INSTANTIATE_TEST_CASE_P(Arithm, Mul1, testing::Values(Size(2, 2), Size(1, 1)));
class SubtractOutputMatNotEmpty : public testing::TestWithParam< std::tr1::tuple<cv::Size, perf::MatType, perf::MatDepth, bool> >
class SubtractOutputMatNotEmpty : public testing::TestWithParam< tuple<cv::Size, perf::MatType, perf::MatDepth, bool> >
{
public:
cv::Size size;
@ -1640,10 +1644,10 @@ public:
void SetUp()
{
size = std::tr1::get<0>(GetParam());
src_type = std::tr1::get<1>(GetParam());
dst_depth = std::tr1::get<2>(GetParam());
fixed = std::tr1::get<3>(GetParam());
size = get<0>(GetParam());
src_type = get<1>(GetParam());
dst_depth = get<2>(GetParam());
fixed = get<3>(GetParam());
}
};
@ -1864,13 +1868,13 @@ TEST(Core_BoolVector, support)
nz += (int)test[i];
}
ASSERT_EQ( nz, countNonZero(test) );
ASSERT_FLOAT_EQ((float)nz/n, (float)(mean(test)[0]));
ASSERT_FLOAT_EQ((float)nz/n, (float)(cv::mean(test)[0]));
}
TEST(MinMaxLoc, Mat_UcharMax_Without_Loc)
{
Mat_<uchar> mat(50, 50);
uchar iMaxVal = numeric_limits<uchar>::max();
uchar iMaxVal = std::numeric_limits<uchar>::max();
mat.setTo(iMaxVal);
double min, max;
@ -1888,7 +1892,7 @@ TEST(MinMaxLoc, Mat_UcharMax_Without_Loc)
TEST(MinMaxLoc, Mat_IntMax_Without_Mask)
{
Mat_<int> mat(50, 50);
int iMaxVal = numeric_limits<int>::max();
int iMaxVal = std::numeric_limits<int>::max();
mat.setTo(iMaxVal);
double min, max;
@ -1957,8 +1961,8 @@ TEST(Compare, regression_8999)
Mat_<double> B(1,1); B << 2;
Mat C;
ASSERT_ANY_THROW({
compare(A, B, C, CMP_LT);
});
cv::compare(A, B, C, CMP_LT);
});
}
@ -1982,7 +1986,7 @@ TEST(Core_minMaxIdx, regression_9207_1)
Mat src(Size(cols, rows), CV_8UC1, src_);
double minVal = -0.0, maxVal = -0.0;
int minIdx[2] = { -2, -2 }, maxIdx[2] = { -2, -2 };
minMaxIdx(src, &minVal, &maxVal, minIdx, maxIdx, mask);
cv::minMaxIdx(src, &minVal, &maxVal, minIdx, maxIdx, mask);
EXPECT_EQ(0, minIdx[0]);
EXPECT_EQ(0, minIdx[1]);
EXPECT_EQ(0, maxIdx[0]);
@ -2028,9 +2032,11 @@ TEST(Core_minMaxIdx, regression_9207_2)
Mat src(Size(cols, rows), CV_8UC1, src_);
double minVal = -0.0, maxVal = -0.0;
int minIdx[2] = { -2, -2 }, maxIdx[2] = { -2, -2 };
minMaxIdx(src, &minVal, &maxVal, minIdx, maxIdx, mask);
cv::minMaxIdx(src, &minVal, &maxVal, minIdx, maxIdx, mask);
EXPECT_EQ(0, minIdx[0]);
EXPECT_EQ(14, minIdx[1]);
EXPECT_EQ(0, maxIdx[0]);
EXPECT_EQ(14, maxIdx[1]);
}
}} // namespace

5
modules/core/test/test_concatenation.cpp
Unescape View File

@ -41,8 +41,7 @@
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class Core_ConcatenationTest : public cvtest::BaseTest
{
@ -145,3 +144,5 @@ TEST(Core_Concatenation, hconcat_empty_empty) { Core_ConcatenationTest test(true
TEST(Core_Concatenation, vconcat_empty_nonempty) { Core_ConcatenationTest test(false, true, false); test.safe_run(); }
TEST(Core_Concatenation, vconcat_nonempty_empty) { Core_ConcatenationTest test(false, false, true); test.safe_run(); }
TEST(Core_Concatenation, vconcat_empty_empty) { Core_ConcatenationTest test(false, true, true); test.safe_run(); }
}} // namespace

5
modules/core/test/test_conjugate_gradient.cpp
Unescape View File

@ -39,7 +39,8 @@
//
//M*/
#include "test_precomp.hpp"
#include <cstdlib>
namespace opencv_test { namespace {
static void mytest(cv::Ptr<cv::ConjGradSolver> solver,cv::Ptr<cv::MinProblemSolver::Function> ptr_F,cv::Mat& x,
cv::Mat& etalon_x,double etalon_res){
@ -103,3 +104,5 @@ TEST(Core_ConjGradSolver, regression_basic){
}
#endif
}
}} // namespace

14
modules/core/test/test_countnonzero.cpp
Unescape View File

@ -41,10 +41,8 @@
//M*/
#include "test_precomp.hpp"
#include <time.h>
#include <limits>
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
#define CORE_COUNTNONZERO_ERROR_COUNT 1
@ -252,12 +250,12 @@ void CV_CountNonZeroTest::run(int)
TEST (Core_CountNonZero, accuracy) { CV_CountNonZeroTest test; test.safe_run(); }
typedef testing::TestWithParam<std::tr1::tuple<int, int> > CountNonZeroND;
typedef testing::TestWithParam<tuple<int, int> > CountNonZeroND;
TEST_P (CountNonZeroND, ndim)
{
const int dims = std::tr1::get<0>(GetParam());
const int type = std::tr1::get<1>(GetParam());
const int dims = get<0>(GetParam());
const int type = get<1>(GetParam());
const int ONE_SIZE = 5;
vector<int> sizes(dims);
@ -277,3 +275,5 @@ INSTANTIATE_TEST_CASE_P(Core, CountNonZeroND,
testing::Values(CV_8U, CV_8S, CV_32F)
)
);
}} // namespace

7
modules/core/test/test_downhill_simplex.cpp
Unescape View File

@ -39,9 +39,8 @@
//
//M*/
#include "test_precomp.hpp"
#include <cstdlib>
#include <cmath>
#include <algorithm>
namespace opencv_test { namespace {
static void mytest(cv::Ptr<cv::DownhillSolver> solver,cv::Ptr<cv::MinProblemSolver::Function> ptr_F,cv::Mat& x,cv::Mat& step,
cv::Mat& etalon_x,double etalon_res){
@ -103,3 +102,5 @@ TEST(Core_DownhillSolver, regression_basic){
}
#endif
}
}} // namespace

8
modules/core/test/test_ds.cpp
Unescape View File

@ -1,7 +1,9 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
typedef struct CvTsSimpleSeq
{
@ -2130,3 +2132,5 @@ TEST(Core_DS_Seq, sort_invert) { Core_SeqSortInvTest test; test.safe_run(); }
TEST(Core_DS_Set, basic_operations) { Core_SetTest test; test.safe_run(); }
TEST(Core_DS_Graph, basic_operations) { Core_GraphTest test; test.safe_run(); }
TEST(Core_DS_Graph, scan) { Core_GraphScanTest test; test.safe_run(); }
}} // namespace

40
modules/core/test/test_dxt.cpp
Unescape View File

@ -1,10 +1,9 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace cvtest
{
namespace opencv_test { namespace {
static Mat initDFTWave( int n, bool inv )
{
@ -497,9 +496,6 @@ static void mulComplex( const Mat& src1, const Mat& src2, Mat& dst, int flags )
}
}
}
class CxCore_DXTBaseTest : public cvtest::ArrayTest
{
public:
@ -661,7 +657,7 @@ int CxCore_DXTBaseTest::prepare_test_case( int test_case_idx )
int out_type = test_mat[OUTPUT][0].type();
if( CV_MAT_CN(in_type) == 2 && CV_MAT_CN(out_type) == 1 )
cvtest::fixCCS( test_mat[INPUT][0], test_mat[OUTPUT][0].cols, flags );
fixCCS( test_mat[INPUT][0], test_mat[OUTPUT][0].cols, flags );
if( inplace )
cvtest::copy( test_mat[INPUT][test_case_idx & (int)spectrum_mode],
@ -718,22 +714,22 @@ void CxCore_DFTTest::prepare_to_validation( int /*test_case_idx*/ )
if( !(flags & CV_DXT_INVERSE ) )
{
Mat& cvdft_dst = test_mat[TEMP][1];
cvtest::convertFromCCS( cvdft_dst, cvdft_dst,
test_mat[OUTPUT][0], flags );
convertFromCCS( cvdft_dst, cvdft_dst,
test_mat[OUTPUT][0], flags );
*tmp_src = Scalar::all(0);
cvtest::insert( src, *tmp_src, 0 );
}
else
{
cvtest::convertFromCCS( src, src, *tmp_src, flags );
convertFromCCS( src, src, *tmp_src, flags );
tmp_dst = &test_mat[TEMP][1];
}
}
if( src.rows == 1 || (src.cols == 1 && !(flags & CV_DXT_ROWS)) )
cvtest::DFT_1D( *tmp_src, *tmp_dst, flags );
DFT_1D( *tmp_src, *tmp_dst, flags );
else
cvtest::DFT_2D( *tmp_src, *tmp_dst, flags );
DFT_2D( *tmp_src, *tmp_dst, flags );
if( tmp_dst != &dst )
cvtest::extract( *tmp_dst, dst, 0 );
@ -773,9 +769,9 @@ void CxCore_DCTTest::prepare_to_validation( int /*test_case_idx*/ )
Mat& dst = test_mat[REF_OUTPUT][0];
if( src.rows == 1 || (src.cols == 1 && !(flags & CV_DXT_ROWS)) )
cvtest::DCT_1D( src, dst, flags );
DCT_1D( src, dst, flags );
else
cvtest::DCT_2D( src, dst, flags );
DCT_2D( src, dst, flags );
}
@ -837,17 +833,17 @@ void CxCore_MulSpectrumsTest::prepare_to_validation( int /*test_case_idx*/ )
if( cn == 1 )
{
cvtest::convertFromCCS( *src1, *src1, dst, flags );
cvtest::convertFromCCS( *src2, *src2, dst0, flags );
convertFromCCS( *src1, *src1, dst, flags );
convertFromCCS( *src2, *src2, dst0, flags );
src1 = &dst;
src2 = &dst0;
}
cvtest::mulComplex( *src1, *src2, dst0, flags );
mulComplex( *src1, *src2, dst0, flags );
if( cn == 1 )
{
Mat& temp = test_mat[TEMP][0];
cvtest::convertFromCCS( temp, temp, dst, flags );
convertFromCCS( temp, temp, dst, flags );
}
}
@ -900,7 +896,7 @@ TEST(Core_DFT, complex_output2)
Mat x(m, n, type), out;
randu(x, -1., 1.);
dft(x, out, DFT_ROWS | DFT_COMPLEX_OUTPUT);
double nrm = norm(out, NORM_INF);
double nrm = cvtest::norm(out, NORM_INF);
double thresh = n*m*2;
if( nrm > thresh )
{
@ -986,3 +982,5 @@ protected:
TEST(Core_DFT, reverse) { Core_DXTReverseTest test(Core_DXTReverseTest::ModeDFT); test.safe_run(); }
TEST(Core_DCT, reverse) { Core_DXTReverseTest test(Core_DXTReverseTest::ModeDCT); test.safe_run(); }
}} // namespace

9
modules/core/test/test_eigen.cpp
Unescape View File

@ -39,12 +39,9 @@
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "test_precomp.hpp"
#include <time.h>
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
#define sign(a) a > 0 ? 1 : a == 0 ? 0 : -1
@ -374,7 +371,7 @@ bool Core_EigenTest::check_full(int type)
{
const int MAX_DEGREE = 7;
RNG rng = ::theRNG(); // fix the seed
RNG rng = cv::theRNG(); // fix the seed
for (int i = 0; i < ntests; ++i)
{
@ -518,3 +515,5 @@ static void testEigen3x3()
}
TEST(Core_EigenNonSymmetric, float3x3) { testEigen3x3<float>(); }
TEST(Core_EigenNonSymmetric, double3x3) { testEigen3x3<double>(); }
}} // namespace

11
modules/core/test/test_hal_core.cpp
Unescape View File

@ -38,10 +38,9 @@
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "test_precomp.hpp"
using namespace cv;
namespace opencv_test { namespace {
enum
{
@ -111,7 +110,7 @@ TEST(Core_HAL, mathfuncs)
t = (double)getTickCount() - t;
min_ocv_t = std::min(min_ocv_t, t);
}
EXPECT_LE(norm(dst, dst0, NORM_INF | NORM_RELATIVE), eps);
EXPECT_LE(cvtest::norm(dst, dst0, NORM_INF | NORM_RELATIVE), eps);
double freq = getTickFrequency();
printf("%s (N=%d, %s): hal time=%.2fusec, ocv time=%.2fusec\n",
@ -120,8 +119,6 @@ TEST(Core_HAL, mathfuncs)
}
}
namespace {
enum
{
HAL_LU = 0,
@ -188,7 +185,7 @@ TEST_P(HAL, mat_decomp)
//std::cout << "x: " << Mat(x.t()) << std::endl;
//std::cout << "x0: " << Mat(x0.t()) << std::endl;
EXPECT_LE(norm(x, x0, NORM_INF | NORM_RELATIVE), eps)
EXPECT_LE(cvtest::norm(x, x0, NORM_INF | NORM_RELATIVE), eps)
<< "x: " << Mat(x.t())
<< "\nx0: " << Mat(x0.t())
<< "\na0: " << a0
@ -205,4 +202,4 @@ TEST_P(HAL, mat_decomp)
INSTANTIATE_TEST_CASE_P(Core, HAL, testing::Range(0, 16));
} // namespace
}} // namespace

6
modules/core/test/test_intrin.cpp
Unescape View File

@ -1,5 +1,7 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
#include <climits>
#include "test_intrin_utils.hpp"
@ -10,7 +12,7 @@
using namespace cv;
namespace cvtest { namespace hal {
namespace opencv_test { namespace hal {
using namespace CV_CPU_OPTIMIZATION_NAMESPACE;
//============= 8-bit integer =====================================================================

5
modules/core/test/test_intrin.fp16.cpp
Unescape View File

@ -1,7 +1,10 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
#include "test_intrin_utils.hpp"
namespace cvtest { namespace hal {
namespace opencv_test { namespace hal {
CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
void test_hal_intrin_float16x4()

5
modules/core/test/test_intrin_utils.hpp
Unescape View File

@ -1,6 +1,9 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "opencv2/core/hal/intrin.hpp"
namespace cvtest { namespace hal {
namespace opencv_test { namespace hal {
CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
void test_hal_intrin_float16x4();

20
modules/core/test/test_io.cpp
Unescape View File

@ -1,7 +1,9 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
static SparseMat cvTsGetRandomSparseMat(int dims, const int* sz, int type,
int nzcount, double a, double b, RNG& rng)
@ -122,7 +124,7 @@ protected:
exp(test_mat, test_mat);
Mat test_mat_scale(test_mat.size(), test_mat.type());
rng0.fill(test_mat_scale, CV_RAND_UNI, Scalar::all(-1), Scalar::all(1));
multiply(test_mat, test_mat_scale, test_mat);
cv::multiply(test_mat, test_mat_scale, test_mat);
}
CvSeq* seq = cvCreateSeq(test_mat.type(), (int)sizeof(CvSeq),
@ -158,7 +160,7 @@ protected:
exp(test_mat_nd, test_mat_nd);
MatND test_mat_scale(test_mat_nd.dims, test_mat_nd.size, test_mat_nd.type());
rng0.fill(test_mat_scale, CV_RAND_UNI, Scalar::all(-1), Scalar::all(1));
multiply(test_mat_nd, test_mat_scale, test_mat_nd);
cv::multiply(test_mat_nd, test_mat_scale, test_mat_nd);
}
int ssz[] = {
@ -387,8 +389,6 @@ protected:
TEST(Core_InputOutput, write_read_consistency) { Core_IOTest test; test.safe_run(); }
extern void testFormatter();
struct UserDefinedType
{
@ -1058,7 +1058,7 @@ TEST(Core_InputOutput, filestorage_vec_vec_io)
for(size_t k = 0; k < testMats[j].size(); k++)
{
ASSERT_TRUE(norm(outputMats[j][k] - testMats[j][k], NORM_INF) == 0);
ASSERT_TRUE(cvtest::norm(outputMats[j][k] - testMats[j][k], NORM_INF) == 0);
}
}
@ -1597,7 +1597,7 @@ TEST(Core_InputOutput, FileStorage_free_file_after_exception)
const std::string fileName = "FileStorage_free_file_after_exception_test.yml";
const std::string content = "%YAML:1.0\n cameraMatrix;:: !<tag:yaml.org,2002:opencv-matrix>\n";
fstream testFile;
std::fstream testFile;
testFile.open(fileName.c_str(), std::fstream::out);
if(!testFile.is_open()) FAIL();
testFile << content;
@ -1611,5 +1611,7 @@ TEST(Core_InputOutput, FileStorage_free_file_after_exception)
catch (const std::exception&)
{
}
ASSERT_EQ(std::remove(fileName.c_str()), 0);
ASSERT_EQ(0, std::remove(fileName.c_str()));
}
}} // namespace

7
modules/core/test/test_ippasync.cpp
Unescape View File

@ -1,3 +1,6 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
#include "opencv2/ts/ocl_test.hpp"
@ -6,9 +9,9 @@
using namespace cv;
using namespace std;
using namespace cvtest;
using namespace opencv_test;
namespace cvtest {
namespace opencv_test {
namespace ocl {
PARAM_TEST_CASE(IPPAsync, MatDepth, Channels, hppAccelType)

5
modules/core/test/test_lpsolver.cpp
Unescape View File

@ -39,7 +39,8 @@
//
//M*/
#include "test_precomp.hpp"
#include <iostream>
namespace opencv_test { namespace {
TEST(Core_LPSolver, regression_basic){
cv::Mat A,B,z,etalon_z;
@ -139,3 +140,5 @@ TEST(Core_LPSolver, regression_cycling){
//ASSERT_EQ(res,1);
#endif
}
}} // namespace

10
modules/core/test/test_main.cpp
Unescape View File

@ -1,10 +1,6 @@
#ifdef _MSC_VER
# if _MSC_VER >= 1700
# pragma warning(disable:4447) // Disable warning 'main' signature found without threading model
# endif
#endif
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
CV_TEST_MAIN("cv")

47
modules/core/test/test_mat.cpp
Unescape View File

@ -1,10 +1,9 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
#include <map>
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class Core_ReduceTest : public cvtest::BaseTest
{
@ -770,8 +769,8 @@ void Core_ArrayOpTest::run( int /* start_from */)
SparseMat M( dims, size, depth );
map<string, double> M0;
int nz0 = (unsigned)rng % max(p/5,10);
nz0 = min(max(nz0, 1), p);
int nz0 = (unsigned)rng % std::max(p/5,10);
nz0 = std::min(std::max(nz0, 1), p);
all_vals.resize(nz0);
all_vals2.resize(nz0);
Mat_<double> _all_vals(all_vals), _all_vals2(all_vals2);
@ -791,9 +790,9 @@ void Core_ArrayOpTest::run( int /* start_from */)
}
minMaxLoc(_all_vals, &min_val, &max_val);
double _norm0 = cvtest::norm(_all_vals, CV_C);
double _norm1 = cvtest::norm(_all_vals, CV_L1);
double _norm2 = cvtest::norm(_all_vals, CV_L2);
double _norm0 = cv/*test*/::norm(_all_vals, CV_C);
double _norm1 = cv/*test*/::norm(_all_vals, CV_L1);
double _norm2 = cv/*test*/::norm(_all_vals, CV_L2);
for( i = 0; i < nz0; i++ )
{
@ -828,9 +827,9 @@ void Core_ArrayOpTest::run( int /* start_from */)
SparseMat M3; SparseMat(Md).convertTo(M3, Md.type(), 2);
int nz1 = (int)M.nzcount(), nz2 = (int)M3.nzcount();
double norm0 = norm(M, CV_C);
double norm1 = norm(M, CV_L1);
double norm2 = norm(M, CV_L2);
double norm0 = cv/*test*/::norm(M, CV_C);
double norm1 = cv/*test*/::norm(M, CV_L1);
double norm2 = cv/*test*/::norm(M, CV_L2);
double eps = depth == CV_32F ? FLT_EPSILON*100 : DBL_EPSILON*1000;
if( nz1 != nz0 || nz2 != nz0)
@ -851,8 +850,8 @@ void Core_ArrayOpTest::run( int /* start_from */)
break;
}
int n = (unsigned)rng % max(p/5,10);
n = min(max(n, 1), p) + nz0;
int n = (unsigned)rng % std::max(p/5,10);
n = std::min(std::max(n, 1), p) + nz0;
for( i = 0; i < n; i++ )
{
@ -919,7 +918,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
int idx1[MAX_DIM], idx2[MAX_DIM];
double val1 = 0, val2 = 0;
M3 = SparseMat(Md);
minMaxLoc(M3, &val1, &val2, idx1, idx2);
cv::minMaxLoc(M3, &val1, &val2, idx1, idx2);
string s1 = idx2string(idx1, dims), s2 = idx2string(idx2, dims);
if( val1 != min_val || val2 != max_val || s1 != min_sidx || s2 != max_sidx )
{
@ -930,7 +929,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
break;
}
minMaxIdx(Md, &val1, &val2, idx1, idx2);
cv::minMaxIdx(Md, &val1, &val2, idx1, idx2);
s1 = idx2string(idx1, dims), s2 = idx2string(idx2, dims);
if( (min_val < 0 && (val1 != min_val || s1 != min_sidx)) ||
(max_val > 0 && (val2 != max_val || s2 != max_sidx)) )
@ -1066,7 +1065,7 @@ protected:
merge(src, dst);
// check result
stringstream commonLog;
std::stringstream commonLog;
commonLog << "Depth " << depth << " :";
if(dst.depth() != depth)
{
@ -1115,7 +1114,7 @@ protected:
split(src, dst);
// check result
stringstream commonLog;
std::stringstream commonLog;
commonLog << "Depth " << depth << " :";
if(dst.size() != channels)
{
@ -1391,7 +1390,7 @@ TEST(Core_SVD, orthogonality)
Mat mat_U, mat_W;
SVD::compute(mat_D, mat_W, mat_U, noArray(), SVD::FULL_UV);
mat_U *= mat_U.t();
ASSERT_LT(norm(mat_U, Mat::eye(2, 2, type), NORM_INF), 1e-5);
ASSERT_LT(cvtest::norm(mat_U, Mat::eye(2, 2, type), NORM_INF), 1e-5);
}
}
@ -1713,7 +1712,7 @@ TEST(Mat_, range_based_for)
Mat_<uchar> ref(3, 3);
ref.setTo(Scalar(1));
ASSERT_DOUBLE_EQ(norm(img, ref), 0.);
ASSERT_DOUBLE_EQ(cvtest::norm(img, ref, NORM_INF), 0.);
}
TEST(Mat, from_initializer_list)
@ -1722,7 +1721,7 @@ TEST(Mat, from_initializer_list)
Mat_<float> B(3, 1); B << 1, 2, 3;
ASSERT_EQ(A.type(), CV_32F);
ASSERT_DOUBLE_EQ(norm(A, B, NORM_INF), 0.);
ASSERT_DOUBLE_EQ(cvtest::norm(A, B, NORM_INF), 0.);
}
TEST(Mat_, from_initializer_list)
@ -1730,7 +1729,7 @@ TEST(Mat_, from_initializer_list)
Mat_<float> A = {1, 2, 3};
Mat_<float> B(3, 1); B << 1, 2, 3;
ASSERT_DOUBLE_EQ(norm(A, B, NORM_INF), 0.);
ASSERT_DOUBLE_EQ(cvtest::norm(A, B, NORM_INF), 0.);
}
@ -1754,3 +1753,5 @@ TEST(Mat_, template_based_ptr)
}
#endif
}} // namespace

18
modules/core/test/test_math.cpp
Unescape View File

@ -1,3 +1,7 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
//////////////////////////////////////////////////////////////////////////////////////////
/////////////////// tests for matrix operations and math functions ///////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
@ -7,8 +11,7 @@
#include <math.h>
#include "opencv2/core/softfloat.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
/// !!! NOTE !!! These tests happily avoid overflow cases & out-of-range arguments
/// so that output arrays contain neigher Inf's nor Nan's.
@ -3079,7 +3082,7 @@ TEST(Core_Cholesky, accuracy64f)
for (int i = 0; i < A.rows; i++)
for (int j = i + 1; j < A.cols; j++)
A.at<double>(i, j) = 0.0;
EXPECT_LE(norm(refA, A*A.t(), CV_RELATIVE_L2), FLT_EPSILON);
EXPECT_LE(cvtest::norm(refA, A*A.t(), CV_RELATIVE_L2), FLT_EPSILON);
}
TEST(Core_QR_Solver, accuracy64f)
@ -3099,7 +3102,7 @@ TEST(Core_QR_Solver, accuracy64f)
//solve system with square matrix
solve(A, B, solutionQR, DECOMP_QR);
EXPECT_LE(norm(A*solutionQR, B, CV_RELATIVE_L2), FLT_EPSILON);
EXPECT_LE(cvtest::norm(A*solutionQR, B, CV_RELATIVE_L2), FLT_EPSILON);
A = Mat(m, n, CV_64F);
B = Mat(m, n, CV_64F);
@ -3108,13 +3111,13 @@ TEST(Core_QR_Solver, accuracy64f)
//solve normal system
solve(A, B, solutionQR, DECOMP_QR | DECOMP_NORMAL);
EXPECT_LE(norm(A.t()*(A*solutionQR), A.t()*B, CV_RELATIVE_L2), FLT_EPSILON);
EXPECT_LE(cvtest::norm(A.t()*(A*solutionQR), A.t()*B, CV_RELATIVE_L2), FLT_EPSILON);
//solve overdeterminated system as a least squares problem
Mat solutionSVD;
solve(A, B, solutionQR, DECOMP_QR);
solve(A, B, solutionSVD, DECOMP_SVD);
EXPECT_LE(norm(solutionQR, solutionSVD, CV_RELATIVE_L2), FLT_EPSILON);
EXPECT_LE(cvtest::norm(solutionQR, solutionSVD, CV_RELATIVE_L2), FLT_EPSILON);
//solve system with singular matrix
A = Mat(10, 10, CV_64F);
@ -3718,7 +3721,7 @@ TEST(Core_SoftFloat, sincos64)
softdouble x = inputs[i];
int xexp = x.getExp();
softdouble randEps = eps.setExp(max(xexp-52, -46));
softdouble randEps = eps.setExp(std::max(xexp-52, -46));
softdouble sx = sin(x);
softdouble cx = cos(x);
ASSERT_FALSE(sx.isInf()); ASSERT_FALSE(cx.isInf());
@ -3862,4 +3865,5 @@ TEST(Core_SoftFloat, CvRound)
}
}
}} // namespace
/* End of file. */

8
modules/core/test/test_misc.cpp
Unescape View File

@ -1,7 +1,9 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
TEST(Core_OutputArrayCreate, _1997)
{
@ -154,3 +156,5 @@ TEST(Core_Copy, repeat_regression_8972)
repeat(src, 5, 1, src);
});
}
}} // namespace

42
modules/core/test/test_operations.cpp
Unescape View File

@ -43,7 +43,7 @@
#include "test_precomp.hpp"
#include "opencv2/ts/ocl_test.hpp" // T-API like tests
namespace cvtest {
namespace opencv_test {
namespace {
class CV_OperationsTest : public cvtest::BaseTest
@ -134,16 +134,16 @@ bool CV_OperationsTest::TestMat()
res = Mat(Mat(2 * rot_2x3) * res - shi_2x1) + shift;
Mat tmp, res2;
add(one_3x1, shi_3x1, tmp);
add(tmp, shi_3x1, tmp);
add(tmp, shi_3x1, tmp);
gemm(rot_2x3, tmp, 2, shi_2x1, -1, res2, 0);
add(res2, Mat(2, 1, CV_32F, shift), res2);
cv::add(one_3x1, shi_3x1, tmp);
cv::add(tmp, shi_3x1, tmp);
cv::add(tmp, shi_3x1, tmp);
cv::gemm(rot_2x3, tmp, 2, shi_2x1, -1, res2, 0);
cv::add(res2, Mat(2, 1, CV_32F, shift), res2);
CHECK_DIFF(res, res2);
Mat mat4x4(4, 4, CV_32F);
randu(mat4x4, Scalar(0), Scalar(10));
cv::randu(mat4x4, Scalar(0), Scalar(10));
Mat roi1 = mat4x4(Rect(Point(1, 1), Size(2, 2)));
Mat roi2 = mat4x4(Range(1, 3), Range(1, 3));
@ -508,19 +508,19 @@ bool CV_OperationsTest::TestTemplateMat()
Mat_<float> resS = rot_2x3 * one_3x1;
Mat_<float> tmp, res2, resS2;
add(one_3x1, shi_3x1, tmp);
add(tmp, shi_3x1, tmp);
add(tmp, shi_3x1, tmp);
gemm(rot_2x3, tmp, 2, shi_2x1, -1, res2, 0);
add(res2, Mat(2, 1, CV_32F, shift), res2);
cv::add(one_3x1, shi_3x1, tmp);
cv::add(tmp, shi_3x1, tmp);
cv::add(tmp, shi_3x1, tmp);
cv::gemm(rot_2x3, tmp, 2, shi_2x1, -1, res2, 0);
cv::add(res2, Mat(2, 1, CV_32F, shift), res2);
gemm(rot_2x3, one_3x1, 1, shi_2x1, 0, resS2, 0);
cv::gemm(rot_2x3, one_3x1, 1, shi_2x1, 0, resS2, 0);
CHECK_DIFF(res, res2);
CHECK_DIFF(resS, resS2);
Mat_<float> mat4x4(4, 4);
randu(mat4x4, Scalar(0), Scalar(10));
cv::randu(mat4x4, Scalar(0), Scalar(10));
Mat_<float> roi1 = mat4x4(Rect(Point(1, 1), Size(2, 2)));
Mat_<float> roi2 = mat4x4(Range(1, 3), Range(1, 3));
@ -988,17 +988,17 @@ bool CV_OperationsTest::operations1()
Mat A(1, 32, CV_32F), B;
for( int i = 0; i < A.cols; i++ )
A.at<float>(i) = (float)(i <= 12 ? i : 24 - i);
transpose(A, B);
cv::transpose(A, B);
int minidx[2] = {0, 0}, maxidx[2] = {0, 0};
double minval = 0, maxval = 0;
minMaxIdx(A, &minval, &maxval, minidx, maxidx);
cv::minMaxIdx(A, &minval, &maxval, minidx, maxidx);
if( !(minidx[0] == 0 && minidx[1] == 31 && maxidx[0] == 0 && maxidx[1] == 12 &&
minval == -7 && maxval == 12))
throw test_excep();
minMaxIdx(B, &minval, &maxval, minidx, maxidx);
cv::minMaxIdx(B, &minval, &maxval, minidx, maxidx);
if( !(minidx[0] == 31 && minidx[1] == 0 && maxidx[0] == 12 && maxidx[1] == 0 &&
minval == -7 && maxval == 12))
@ -1006,13 +1006,13 @@ bool CV_OperationsTest::operations1()
Matx33f b(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f);
Mat c;
add(Mat::zeros(3, 3, CV_32F), b, c);
cv::add(Mat::zeros(3, 3, CV_32F), b, c);
CV_Assert( cvtest::norm(b, c, CV_C) == 0 );
add(Mat::zeros(3, 3, CV_64F), b, c, noArray(), c.type());
cv::add(Mat::zeros(3, 3, CV_64F), b, c, noArray(), c.type());
CV_Assert( cvtest::norm(b, c, CV_C) == 0 );
add(Mat::zeros(6, 1, CV_64F), 1, c, noArray(), c.type());
cv::add(Mat::zeros(6, 1, CV_64F), 1, c, noArray(), c.type());
CV_Assert( cvtest::norm(Matx61f(1.f, 1.f, 1.f, 1.f, 1.f, 1.f), c, CV_C) == 0 );
vector<Point2f> pt2d(3);
@ -1025,7 +1025,7 @@ bool CV_OperationsTest::operations1()
0.9058f, 0.0975f, 0.9649f, 0.4854f,
0.1270f, 0.2785f, 0.1576f, 0.8003f,
0.9134f, 0.5469f, 0.9706f, 0.1419f);
double d = determinant(m44);
double d = cv::determinant(m44);
CV_Assert( fabs(d - (-0.0262)) <= 0.001 );
Cv32suf z;

12
modules/core/test/test_precomp.hpp
Unescape View File

@ -1,15 +1,9 @@
#ifdef __GNUC__
# pragma GCC diagnostic ignored "-Wmissing-declarations"
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic ignored "-Wmissing-prototypes"
# pragma GCC diagnostic ignored "-Wextra"
# endif
#endif
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#ifndef __OPENCV_TEST_PRECOMP_HPP__
#define __OPENCV_TEST_PRECOMP_HPP__
#include <iostream>
#include "opencv2/ts.hpp"
#include "opencv2/ts/ocl_test.hpp"
#include "opencv2/core/core_c.h"

8
modules/core/test/test_ptr.cpp
Unescape View File

@ -41,6 +41,8 @@
#include "test_precomp.hpp"
namespace opencv_test { namespace {
#ifdef GTEST_CAN_COMPARE_NULL
# define EXPECT_NULL(ptr) EXPECT_EQ(NULL, ptr)
#else
@ -366,6 +368,8 @@ TEST(Core_Ptr, make)
EXPECT_TRUE(deleted);
}
}} // namespace
namespace {
struct SpeciallyDeletable
@ -385,6 +389,8 @@ void DefaultDeleter<SpeciallyDeletable>::operator()(SpeciallyDeletable * obj) co
}
namespace opencv_test { namespace {
TEST(Core_Ptr, specialized_deleter)
{
SpeciallyDeletable sd;
@ -393,3 +399,5 @@ TEST(Core_Ptr, specialized_deleter)
ASSERT_TRUE(sd.deleted);
}
}} // namespace

9
modules/core/test/test_rand.cpp
Unescape View File

@ -1,7 +1,9 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class Core_RandTest : public cvtest::BaseTest
{
@ -383,7 +385,6 @@ TEST(Core_Rand, Regression_Stack_Corruption)
ASSERT_EQ(param2, 2);
}
namespace {
class RandRowFillParallelLoopBody : public cv::ParallelLoopBody
{
@ -417,4 +418,4 @@ TEST(Core_Rand, parallel_for_stable_results)
ASSERT_EQ(0, countNonZero(dst1 != dst2));
}
} // namespace
}} // namespace

13
modules/core/test/test_rotatedrect.cpp
Unescape View File

@ -41,8 +41,7 @@
#include "test_precomp.hpp"
using namespace cv;
using namespace std;
namespace opencv_test { namespace {
class Core_RotatedRectConstructorTest : public cvtest::BaseTest
{
@ -72,7 +71,7 @@ int Core_RotatedRectConstructorTest::prepare_test_case( int test_case_idx )
{
b = Point2f( rng.uniform(-MAX_COORD_VAL, MAX_COORD_VAL), rng.uniform(-MAX_COORD_VAL, MAX_COORD_VAL) );
}
while( norm(a - b) <= FLT_EPSILON );
while( cv::norm(a - b) <= FLT_EPSILON );
Vec2f along(a - b);
Vec2f perp = Vec2f(-along[1], along[0]);
double d = (double) rng.uniform(1.0f, 5.0f);
@ -93,9 +92,9 @@ int Core_RotatedRectConstructorTest::validate_test_results( int )
int count_match = 0;
for( int i = 0; i < 4; i++ )
{
if( norm(vertices[i] - a) <= 0.001 ) count_match++;
else if( norm(vertices[i] - b) <= 0.001 ) count_match++;
else if( norm(vertices[i] - c) <= 0.001 ) count_match++;
if( cv::norm(vertices[i] - a) <= 0.001 ) count_match++;
else if( cv::norm(vertices[i] - b) <= 0.001 ) count_match++;
else if( cv::norm(vertices[i] - c) <= 0.001 ) count_match++;
}
if( count_match == 3 )
return cvtest::TS::OK;
@ -105,3 +104,5 @@ int Core_RotatedRectConstructorTest::validate_test_results( int )
}
TEST(Core_RotatedRect, three_point_constructor) { Core_RotatedRectConstructorTest test; test.safe_run(); }
}} // namespace

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save