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

Merge pull request #13251 from dbudniko:dbudniko/gapi_more_fixes_for_tests

Browse Source 
More fixes for G-API tests (#13251)

* scalar comparator and more fixes for tests

* add weighted aligned

* white space

* more white space

* Add weighted test accuracy check enabled
pull/13292/head
Dmitry Budnikov 6 years ago committed by Alexander Alekhin
parent 8f4e5c2fb8
commit 51cc78b2a2
12 changed files with 134 additions and 138 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      modules/gapi/perf/common/gapi_core_perf_tests.hpp
  2. 72
      modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp
  3. 16
      modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp
  4. 15
      modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp
  5. 14
      modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp
  6. 6
      modules/gapi/test/common/gapi_core_tests.hpp
  7. 57
      modules/gapi/test/common/gapi_core_tests_inl.hpp
  8. 47
      modules/gapi/test/common/gapi_tests_common.hpp
  9. 11
      modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
  10. 3
      modules/gapi/test/cpu/gapi_core_tests_fluid.cpp
  11. 9
      modules/gapi/test/gpu/gapi_core_tests_gpu.cpp
  12. 16
      modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp

6
modules/gapi/perf/common/gapi_core_perf_tests.hpp
Unescape View File

@ -50,9 +50,9 @@ namespace opencv_test
class MaxPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {}; class MaxPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class AbsDiffPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {}; class AbsDiffPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class AbsDiffCPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {}; class AbsDiffCPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class SumPerfTest : public TestPerfParams<tuple<cv::Size, MatType, double, cv::GCompileArgs>> {}; class SumPerfTest : public TestPerfParams<tuple<compare_scalar_f, cv::Size, MatType, cv::GCompileArgs>> {};
class AddWeightedPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, double, cv::GCompileArgs>> {}; class AddWeightedPerfTest : public TestPerfParams<tuple<compare_f, cv::Size, MatType, int, cv::GCompileArgs>> {};
class NormPerfTest : public TestPerfParams<tuple<NormTypes, cv::Size, MatType, double, cv::GCompileArgs>> {}; class NormPerfTest : public TestPerfParams<tuple<compare_scalar_f, NormTypes, cv::Size, MatType, cv::GCompileArgs>> {};
class IntegralPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {}; class IntegralPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class ThresholdPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {}; class ThresholdPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};
class ThresholdOTPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {}; class ThresholdOTPerfTest : public TestPerfParams<tuple<cv::Size, MatType, int, cv::GCompileArgs>> {};

72
modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp
Unescape View File

@ -900,13 +900,13 @@ PERF_TEST_P_(AbsDiffCPerfTest, TestPerformance)
PERF_TEST_P_(SumPerfTest, TestPerformance) PERF_TEST_P_(SumPerfTest, TestPerformance)
{ {
cv::Size sz_in = get<0>(GetParam()); compare_scalar_f cmpF = get<0>(GetParam());
MatType type = get<1>(GetParam()); cv::Size sz_in = get<1>(GetParam());
double tolerance = get<2>(GetParam()); MatType type = get<2>(GetParam());
cv::GCompileArgs compile_args = get<3>(GetParam()); cv::GCompileArgs compile_args = get<3>(GetParam());
initMatrixRandU(type, sz_in, false); initMatrixRandU(type, sz_in, type, false);
cv::Scalar out_sum; cv::Scalar out_sum;
cv::Scalar out_sum_ocv; cv::Scalar out_sum_ocv;
@ -928,8 +928,7 @@ PERF_TEST_P_(SumPerfTest, TestPerformance)
// Comparison //////////////////////////////////////////////////////////// // Comparison ////////////////////////////////////////////////////////////
{ {
EXPECT_LE(std::abs(out_sum[0] - out_sum_ocv[0]) / std::max(1.0, std::abs(out_sum_ocv[0])), tolerance) EXPECT_TRUE(cmpF(out_sum, out_sum_ocv));
<< "OCV=" << out_sum_ocv[0] << " GAPI=" << out_sum[0];
} }
SANITY_CHECK_NOTHING(); SANITY_CHECK_NOTHING();
@ -939,10 +938,10 @@ PERF_TEST_P_(SumPerfTest, TestPerformance)
PERF_TEST_P_(AddWeightedPerfTest, TestPerformance) PERF_TEST_P_(AddWeightedPerfTest, TestPerformance)
{ {
cv::Size sz_in = get<0>(GetParam()); compare_f cmpF = get<0>(GetParam());
MatType type = get<1>(GetParam()); cv::Size sz_in = get<1>(GetParam());
int dtype = get<2>(GetParam()); MatType type = get<2>(GetParam());
double tolerance = get<3>(GetParam()); int dtype = get<3>(GetParam());
cv::GCompileArgs compile_args = get<4>(GetParam()); cv::GCompileArgs compile_args = get<4>(GetParam());
auto& rng = cv::theRNG(); auto& rng = cv::theRNG();
@ -968,45 +967,9 @@ PERF_TEST_P_(AddWeightedPerfTest, TestPerformance)
} }
// Comparison //////////////////////////////////////////////////////////// // Comparison ////////////////////////////////////////////////////////////
// FIXIT unrealiable check EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
if (0) EXPECT_EQ(out_mat_gapi.size(), sz_in);
{
// Note, that we cannot expect bitwise results for add-weighted:
//
// tmp = src1*alpha + src2*beta + gamma;
// dst = saturate<DST>( round(tmp) );
//
// Because tmp is floating-point, dst depends on compiler optimizations
//
// However, we must expect good accuracy of tmp, and rounding correctly
cv::Mat failures;
if (out_mat_ocv.type() == CV_32FC1)
{
// result: float - may vary in 7th decimal digit
failures = abs(out_mat_gapi - out_mat_ocv) > abs(out_mat_ocv) * 1e-6;
}
else
{
// result: integral - rounding may vary if fractional part of tmp
// is nearly 0.5
cv::Mat inexact, incorrect, diff, tmp;
inexact = out_mat_gapi != out_mat_ocv;
// even if rounded differently, check if still rounded correctly
cv::addWeighted(in_mat1, alpha, in_mat2, beta, gamma, tmp, CV_32F);
cv::subtract(out_mat_gapi, tmp, diff, cv::noArray(), CV_32F);
incorrect = abs(diff) >= tolerance;// 0.5000005f; // relative to 6 digits
failures = inexact & incorrect;
}
EXPECT_EQ(0, cv::countNonZero(failures));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
}
SANITY_CHECK_NOTHING(); SANITY_CHECK_NOTHING();
} }
@ -1015,10 +978,10 @@ PERF_TEST_P_(AddWeightedPerfTest, TestPerformance)
PERF_TEST_P_(NormPerfTest, TestPerformance) PERF_TEST_P_(NormPerfTest, TestPerformance)
{ {
NormTypes opType = get<0>(GetParam()); compare_scalar_f cmpF = get<0>(GetParam());
cv::Size sz = get<1>(GetParam()); NormTypes opType = get<1>(GetParam());
MatType type = get<2>(GetParam()); cv::Size sz = get<2>(GetParam());
double tolerance = get<3>(GetParam()); MatType type = get<3>(GetParam());
cv::GCompileArgs compile_args = get<4>(GetParam()); cv::GCompileArgs compile_args = get<4>(GetParam());
@ -1051,8 +1014,7 @@ PERF_TEST_P_(NormPerfTest, TestPerformance)
// Comparison //////////////////////////////////////////////////////////// // Comparison ////////////////////////////////////////////////////////////
{ {
EXPECT_LE(std::abs(out_norm[0] - out_norm_ocv[0]) / std::max(1.0, std::abs(out_norm_ocv[0])), tolerance) EXPECT_TRUE(cmpF(out_norm, out_norm_ocv));
<< "OCV=" << out_norm_ocv[0] << " GAPI=" << out_norm[0];
} }
SANITY_CHECK_NOTHING(); SANITY_CHECK_NOTHING();

16
modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp
Unescape View File

@ -152,24 +152,24 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCPerfTestCPU, AbsDiffCPerfTest,
Values(cv::compile_args(CORE_CPU)))); Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(SumPerfTestCPU, SumPerfTest, INSTANTIATE_TEST_CASE_P(SumPerfTestCPU, SumPerfTest,
Combine(Values(szSmall128, szVGA, sz720p, sz1080p), Combine(Values(AbsToleranceScalar(0.0).to_compare_f()),
Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(0.0), //Values(0.0),
Values(cv::compile_args(CORE_CPU)))); Values(cv::compile_args(CORE_CPU))));
// FIXME: Comparison introduced by YL doesn't work with C3
INSTANTIATE_TEST_CASE_P(AddWeightedPerfTestCPU, AddWeightedPerfTest, INSTANTIATE_TEST_CASE_P(AddWeightedPerfTestCPU, AddWeightedPerfTest,
Combine(Values(szSmall128, szVGA, sz720p, sz1080p), Combine(Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
Values(CV_8UC1, /*CV_8UC3,*/ CV_16UC1, CV_16SC1, CV_32FC1), Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(-1, CV_8U, CV_16U, CV_32F), Values(-1, CV_8U, CV_16U, CV_32F),
Values(0.5000005),
Values(cv::compile_args(CORE_CPU)))); Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(NormPerfTestCPU, NormPerfTest, INSTANTIATE_TEST_CASE_P(NormPerfTestCPU, NormPerfTest,
Combine(Values(NORM_INF, NORM_L1, NORM_L2), Combine(Values(AbsToleranceScalar(0.0).to_compare_f()),
Values(NORM_INF, NORM_L1, NORM_L2),
Values(szSmall128, szVGA, sz720p, sz1080p), Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1), Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(0.0),
Values(cv::compile_args(CORE_CPU)))); Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(IntegralPerfTestCPU, IntegralPerfTest, INSTANTIATE_TEST_CASE_P(IntegralPerfTestCPU, IntegralPerfTest,

15
modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp
Unescape View File

@ -153,24 +153,23 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCPerfTestGPU, AbsDiffCPerfTest,
Values(cv::compile_args(CORE_GPU)))); Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(SumPerfTestGPU, SumPerfTest, INSTANTIATE_TEST_CASE_P(SumPerfTestGPU, SumPerfTest,
Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), Combine(Values(AbsToleranceScalar(1e-5).to_compare_f()),
Values( szSmall128, szVGA, sz720p, sz1080p ),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(4.0), //TODO: too relaxed?
Values(cv::compile_args(CORE_GPU)))); Values(cv::compile_args(CORE_GPU))));
// FIXME: Comparison introduced by YL doesn't work with C3
INSTANTIATE_TEST_CASE_P(AddWeightedPerfTestGPU, AddWeightedPerfTest, INSTANTIATE_TEST_CASE_P(AddWeightedPerfTestGPU, AddWeightedPerfTest,
Combine(Values( szSmall128, szVGA, sz720p, sz1080p ), Combine(Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
Values( CV_8UC1, /*CV_8UC3,*/ CV_16UC1, CV_16SC1, CV_32FC1 ), Values( szSmall128, szVGA, sz720p, sz1080p ),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values( -1, CV_8U, CV_16U, CV_32F ), Values( -1, CV_8U, CV_16U, CV_32F ),
Values(0.50005),
Values(cv::compile_args(CORE_GPU)))); Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(NormPerfTestGPU, NormPerfTest, INSTANTIATE_TEST_CASE_P(NormPerfTestGPU, NormPerfTest,
Combine(Values(NORM_INF, NORM_L1, NORM_L2), Combine(Values(AbsToleranceScalar(1e-5).to_compare_f()),
Values(NORM_INF, NORM_L1, NORM_L2),
Values( szSmall128, szVGA, sz720p, sz1080p ), Values( szSmall128, szVGA, sz720p, sz1080p ),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(4.0), //TODO: too relaxed?
Values(cv::compile_args(CORE_GPU)))); Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(IntegralPerfTestGPU, IntegralPerfTest, INSTANTIATE_TEST_CASE_P(IntegralPerfTestGPU, IntegralPerfTest,

14
modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp
Unescape View File

@ -109,10 +109,20 @@ INSTANTIATE_TEST_CASE_P(Dilate3x3PerfTestGPU, Dilate3x3PerfTest,
INSTANTIATE_TEST_CASE_P(SobelPerfTestGPU, SobelPerfTest, INSTANTIATE_TEST_CASE_P(SobelPerfTestGPU, SobelPerfTest,
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1/*, CV_32FC1*/), //TODO: CV_32FC1 fails accuracy Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(3, 5), Values(3, 5),
Values(szVGA, sz720p, sz1080p), Values(szVGA, sz720p, sz1080p),
Values(-1, CV_32F), Values(-1, CV_16S, CV_32F),
Values(0, 1),
Values(1, 2),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(SobelPerfTestGPU32F, SobelPerfTest,
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_32FC1),
Values(3, 5),
Values(szVGA, sz720p, sz1080p),
Values(CV_32F),
Values(0, 1), Values(0, 1),
Values(1, 2), Values(1, 2),
Values(cv::compile_args(IMGPROC_GPU)))); Values(cv::compile_args(IMGPROC_GPU))));

6
modules/gapi/test/common/gapi_core_tests.hpp
Unescape View File

@ -124,9 +124,9 @@ struct MinTest : public TestParams<std::tuple<int,cv::Size,bool, cv::G
struct MaxTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{}; struct MaxTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{};
struct AbsDiffTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{}; struct AbsDiffTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>>{};
struct AbsDiffCTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {}; struct AbsDiffCTest : public TestParams<std::tuple<int,cv::Size,bool, cv::GCompileArgs>> {};
struct SumTest : public TestParams<std::tuple<int, cv::Size,bool,double,cv::GCompileArgs>> {}; struct SumTest : public TestParams<std::tuple<int, cv::Size,bool, compare_scalar_f, cv::GCompileArgs>> {};
struct AddWeightedTest : public TestParams<std::tuple<int,cv::Size,int,bool,double,cv::GCompileArgs>>{}; struct AddWeightedTest : public TestParams<std::tuple<int,cv::Size,int,bool, compare_f,cv::GCompileArgs>>{};
struct NormTest : public TestParams<std::tuple<NormTypes,int,cv::Size, double, cv::GCompileArgs>>{}; struct NormTest : public TestParams<std::tuple<NormTypes,int,cv::Size, compare_scalar_f, cv::GCompileArgs>>{};
struct IntegralTest : public TestWithParam<std::tuple<int,cv::Size, cv::GCompileArgs>> {}; struct IntegralTest : public TestWithParam<std::tuple<int,cv::Size, cv::GCompileArgs>> {};
struct ThresholdTest : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>> {}; struct ThresholdTest : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>> {};
struct ThresholdOTTest : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>> {}; struct ThresholdOTTest : public TestParams<std::tuple<int,cv::Size,int,bool, cv::GCompileArgs>> {};

57
modules/gapi/test/common/gapi_core_tests_inl.hpp
Unescape View File

@ -681,10 +681,11 @@ TEST_P(AbsDiffCTest, AccuracyTest)
TEST_P(SumTest, AccuracyTest) TEST_P(SumTest, AccuracyTest)
{ {
auto param = GetParam(); auto param = GetParam();
compare_scalar_f cmpF = get<3>(GetParam());
MatType type = std::get<0>(param);
cv::Size sz_in = std::get<1>(param); cv::Size sz_in = std::get<1>(param);
auto tolerance = std::get<3>(param);
auto compile_args = std::get<4>(param); auto compile_args = std::get<4>(param);
initMatrixRandU(std::get<0>(param), sz_in, std::get<2>(param)); initMatrixRandU(type, sz_in, type, std::get<2>(param));
cv::Scalar out_sum; cv::Scalar out_sum;
@ -702,8 +703,7 @@ TEST_P(SumTest, AccuracyTest)
} }
// Comparison ////////////////////////////////////////////////////////////// // Comparison //////////////////////////////////////////////////////////////
{ {
EXPECT_LE(std::abs(out_sum[0] - out_sum_ocv[0]) / std::max(1.0, std::abs(out_sum_ocv[0])), tolerance) EXPECT_TRUE(cmpF(out_sum, out_sum_ocv));
<< "OCV=" << out_sum_ocv[0] << " GAPI=" << out_sum[0];
} }
} }
@ -713,8 +713,8 @@ TEST_P(AddWeightedTest, AccuracyTest)
cv::Size sz_in; cv::Size sz_in;
bool initOut = false; bool initOut = false;
cv::GCompileArgs compile_args; cv::GCompileArgs compile_args;
double tolerance = 0.0; compare_f cmpF;
std::tie(type, sz_in, dtype, initOut, tolerance, compile_args) = GetParam(); std::tie(type, sz_in, dtype, initOut, cmpF, compile_args) = GetParam();
auto& rng = cv::theRNG(); auto& rng = cv::theRNG();
double alpha = rng.uniform(0.0, 1.0); double alpha = rng.uniform(0.0, 1.0);
@ -734,53 +734,19 @@ TEST_P(AddWeightedTest, AccuracyTest)
cv::addWeighted(in_mat1, alpha, in_mat2, beta, gamma, out_mat_ocv, dtype); cv::addWeighted(in_mat1, alpha, in_mat2, beta, gamma, out_mat_ocv, dtype);
} }
// Comparison ////////////////////////////////////////////////////////////// // Comparison //////////////////////////////////////////////////////////////
{ EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
// Note, that we cannot expect bitwise results for add-weighted: EXPECT_EQ(out_mat_gapi.size(), sz_in);
//
// tmp = src1*alpha + src2*beta + gamma;
// dst = saturate<DST>( round(tmp) );
//
// Because tmp is floating-point, dst depends on compiler optimizations
//
// However, we must expect good accuracy of tmp, and rounding correctly
cv::Mat failures;
if (out_mat_ocv.type() == CV_32FC1)
{
// result: float - may vary in 7th decimal digit
failures = abs(out_mat_gapi - out_mat_ocv) > abs(out_mat_ocv) * 1e-6;
}
else
{
// result: integral - rounding may vary if fractional part of tmp
// is nearly 0.5
cv::Mat inexact, incorrect, diff, tmp;
inexact = out_mat_gapi != out_mat_ocv;
// even if rounded differently, check if still rounded correctly
cv::addWeighted(in_mat1, alpha, in_mat2, beta, gamma, tmp, CV_32F);
cv::subtract(out_mat_gapi, tmp, diff, cv::noArray(), CV_32F);
incorrect = abs(diff) >= tolerance;// 0.5000005f; // relative to 6 digits
failures = inexact & incorrect;
}
EXPECT_EQ(0, cv::countNonZero(failures));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
}
} }
TEST_P(NormTest, AccuracyTest) TEST_P(NormTest, AccuracyTest)
{ {
compare_scalar_f cmpF;
NormTypes opType = NORM_INF; NormTypes opType = NORM_INF;
int type = 0; int type = 0;
cv::Size sz; cv::Size sz;
double tolerance = 0.0;
cv::GCompileArgs compile_args; cv::GCompileArgs compile_args;
std::tie(opType, type, sz, tolerance, compile_args) = GetParam(); std::tie(opType, type, sz, cmpF, compile_args) = GetParam();
initMatrixRandU(type, sz, type, false); initMatrixRandU(type, sz, type, false);
cv::Scalar out_norm; cv::Scalar out_norm;
@ -802,8 +768,7 @@ TEST_P(NormTest, AccuracyTest)
// Comparison ////////////////////////////////////////////////////////////// // Comparison //////////////////////////////////////////////////////////////
{ {
EXPECT_LE(std::abs(out_norm[0] - out_norm_ocv[0]) / std::max(1.0, std::abs(out_norm_ocv[0])), tolerance) EXPECT_TRUE(cmpF(out_norm, out_norm_ocv));
<< "OCV=" << out_norm_ocv[0] << " GAPI=" << out_norm[0];
} }
} }

47
modules/gapi/test/common/gapi_tests_common.hpp
Unescape View File

@ -115,6 +115,9 @@ class TestPerfParams: public TestFunctional, public perf::TestBaseWithParam<T>{}
using compare_f = std::function<bool(const cv::Mat &a, const cv::Mat &b)>; using compare_f = std::function<bool(const cv::Mat &a, const cv::Mat &b)>;
using compare_scalar_f = std::function<bool(const cv::Scalar &a, const cv::Scalar &b)>;
template<typename T> template<typename T>
struct Wrappable struct Wrappable
{ {
@ -128,6 +131,20 @@ struct Wrappable
} }
}; };
template<typename T>
struct WrappableScalar
{
compare_scalar_f to_compare_f()
{
T t = *static_cast<T*const>(this);
return [t](const cv::Scalar &a, const cv::Scalar &b)
{
return t(a, b);
};
}
};
class AbsExact : public Wrappable<AbsExact> class AbsExact : public Wrappable<AbsExact>
{ {
public: public:
@ -285,6 +302,28 @@ private:
double _tol; double _tol;
double _inf_tol; double _inf_tol;
}; };
class AbsToleranceScalar : public WrappableScalar<AbsToleranceScalar>
{
public:
AbsToleranceScalar(double tol) : _tol(tol) {}
bool operator() (const cv::Scalar& in1, const cv::Scalar& in2) const
{
double abs_err = std::abs(in1[0] - in2[0]) / std::max(1.0, std::abs(in2[0]));
if (abs_err > _tol)
{
std::cout << "AbsToleranceScalar error: abs_err=" << abs_err << " tolerance=" << _tol << " in1[0]" << in1[0] << " in2[0]" << in2[0] << std::endl;;
return false;
}
else
{
return true;
}
}
private:
double _tol;
};
} // namespace opencv_test } // namespace opencv_test
namespace namespace
@ -294,3 +333,11 @@ namespace
return os << "compare_f"; return os << "compare_f";
} }
} }
namespace
{
inline std::ostream& operator<<(std::ostream& os, const opencv_test::compare_scalar_f&)
{
return os << "compare_scalar_f";
}
}

11
modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
Unescape View File

@ -203,7 +203,8 @@ INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(1e-5), //Values(1e-5),
Values(AbsToleranceScalar(1e-5).to_compare_f()),
Values(cv::compile_args(CORE_CPU)))); Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest, INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
@ -222,15 +223,14 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_CPU)))); Values(cv::compile_args(CORE_CPU))));
// FIXME: Comparison introduced by YL doesn't work with C3
INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest, INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
Combine(Values( CV_8UC1/*, CV_8UC3*/, CV_16UC1, CV_16SC1, CV_32FC1 ), Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values( -1, CV_8U, CV_16U, CV_32F ), Values( -1, CV_8U, CV_16U, CV_32F ),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(0.5000005), Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
Values(cv::compile_args(CORE_CPU)))); Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest, INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
@ -239,7 +239,8 @@ INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(1e-5), //Values(1e-5),
Values(AbsToleranceScalar(1e-5).to_compare_f()),
Values(cv::compile_args(CORE_CPU))), Values(cv::compile_args(CORE_CPU))),
opencv_test::PrintNormCoreParams()); opencv_test::PrintNormCoreParams());

3
modules/gapi/test/cpu/gapi_core_tests_fluid.cpp
Unescape View File

@ -121,7 +121,8 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest,
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F), Values(-1, CV_8U, CV_32F),
testing::Bool(), testing::Bool(),
Values(0.5000005), Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
//Values(0.5000005),
Values(cv::compile_args(CORE_FLUID)))); Values(cv::compile_args(CORE_FLUID))));
INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest, INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest,

9
modules/gapi/test/gpu/gapi_core_tests_gpu.cpp
Unescape View File

@ -190,7 +190,7 @@ INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest,
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(1e-3), //TODO: too relaxed? Values(AbsToleranceScalar(1e-3).to_compare_f()),//TODO: too relaxed?
Values(cv::compile_args(CORE_GPU)))); Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(AbsDiffTestGPU, AbsDiffTest, INSTANTIATE_TEST_CASE_P(AbsDiffTestGPU, AbsDiffTest,
@ -209,15 +209,14 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCTestGPU, AbsDiffCTest,
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_GPU)))); Values(cv::compile_args(CORE_GPU))));
// FIXME: Comparison introduced by YL doesn't work with C3
INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest, INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest,
Combine(Values( CV_8UC1/*, CV_8UC3*/, CV_16UC1, CV_16SC1, CV_32FC1 ), Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values( -1, CV_8U, CV_16U, CV_32F ), Values( -1, CV_8U, CV_16U, CV_32F ),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(0.50005), Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
Values(cv::compile_args(CORE_GPU)))); Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest, INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
@ -226,7 +225,7 @@ INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(1e-3), //TODO: too relaxed? Values(AbsToleranceScalar(1e-3).to_compare_f()), //TODO: too relaxed?
Values(cv::compile_args(CORE_GPU))), Values(cv::compile_args(CORE_GPU))),
opencv_test::PrintNormCoreParams()); opencv_test::PrintNormCoreParams());

16
modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp
Unescape View File

@ -131,11 +131,23 @@ INSTANTIATE_TEST_CASE_P(Dilate3x3TestGPU, Dilate3x3Test,
INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest, INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest,
Combine(Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()), Combine(Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1/*, CV_32FC1*/), //TODO: CV_32FC1 fails accuracy Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(3, 5), Values(3, 5),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480)), cv::Size(640, 480)),
Values(-1, CV_32F), Values(-1, CV_16S, CV_32F),
Values(0, 1),
Values(1, 2),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(SobelTestGPU32F, SobelTest,
Combine(Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()),
Values(CV_32FC1),
Values(3, 5),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(CV_32F),
Values(0, 1), Values(0, 1),
Values(1, 2), Values(1, 2),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),

Write Preview
Loading…
Cancel
Save