Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

gapi(test): more reliable checks

Browse Source 
avoid `countNonZero()`, use `norm()`
pull/13096/head
Alexander Alekhin 6 years ago
parent dd6f5949c2
commit 6189b47648
14 changed files with 178 additions and 261 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. 93
      modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp
  2. 2
      modules/gapi/perf/cpu/gapi_imgproc_perf_tests_fluid.cpp
  3. 12
      modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp
  4. 36
      modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp
  5. 4
      modules/gapi/test/common/gapi_core_tests_inl.hpp
  6. 210
      modules/gapi/test/common/gapi_tests_common.hpp
  7. 4
      modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
  8. 2
      modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp
  9. 24
      modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp
  10. 2
      modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
  11. 2
      modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
  12. 4
      modules/gapi/test/gpu/gapi_core_tests_gpu.cpp
  13. 38
      modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp
  14. 6
      modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp

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

@ -44,7 +44,7 @@ PERF_TEST_P_(AddPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -79,7 +79,7 @@ PERF_TEST_P_(AddCPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -113,7 +113,7 @@ PERF_TEST_P_(SubPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -148,7 +148,7 @@ PERF_TEST_P_(SubCPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -183,7 +183,7 @@ PERF_TEST_P_(SubRCPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -217,7 +217,7 @@ PERF_TEST_P_(MulPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -253,7 +253,7 @@ PERF_TEST_P_(MulDoublePerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -288,7 +288,7 @@ PERF_TEST_P_(MulCPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -304,6 +304,7 @@ PERF_TEST_P_(DivPerfTest, TestPerformance)
int dtype = get<3>(GetParam());
cv::GCompileArgs compile_args = get<4>(GetParam());
// FIXIT Unstable input data for divide
initMatsRandU(type, sz, dtype, false);
// OpenCV code ///////////////////////////////////////////////////////////
@ -323,7 +324,7 @@ PERF_TEST_P_(DivPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
// FIXIT unrealiable check: EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -338,6 +339,7 @@ PERF_TEST_P_(DivCPerfTest, TestPerformance)
int dtype = get<2>(GetParam());
cv::GCompileArgs compile_args = get<3>(GetParam());
// FIXIT Unstable input data for divide
initMatsRandU(type, sz, dtype, false);
// OpenCV code ///////////////////////////////////////////////////////////
@ -358,7 +360,7 @@ PERF_TEST_P_(DivCPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -374,8 +376,13 @@ PERF_TEST_P_(DivRCPerfTest, TestPerformance)
int dtype = get<3>(GetParam());
cv::GCompileArgs compile_args = get<4>(GetParam());
// FIXIT Unstable input data for divide
initMatsRandU(type, sz, dtype, false);
// FIXIT Unstable input data for divide, don't process zeros
sc += Scalar::all(1);
in_mat1 += 1;
// OpenCV code ///////////////////////////////////////////////////////////
cv::divide(sc, in_mat1, out_mat_ocv, 1.0, dtype);
@ -431,7 +438,7 @@ PERF_TEST_P_(MaskPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -465,7 +472,7 @@ PERF_TEST_P_(MeanPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(out_norm[0], out_norm_ocv[0]);
// FIXIT unrealiable check: EXPECT_EQ(out_norm[0], out_norm_ocv[0]);
SANITY_CHECK_NOTHING();
}
@ -677,7 +684,7 @@ PERF_TEST_P_(BitwisePerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -710,7 +717,7 @@ PERF_TEST_P_(BitwiseNotPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -746,7 +753,7 @@ PERF_TEST_P_(SelectPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -780,7 +787,7 @@ PERF_TEST_P_(MinPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -814,7 +821,7 @@ PERF_TEST_P_(MaxPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -848,7 +855,7 @@ PERF_TEST_P_(AbsDiffPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -883,7 +890,7 @@ PERF_TEST_P_(AbsDiffCPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -961,6 +968,8 @@ PERF_TEST_P_(AddWeightedPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
// FIXIT unrealiable check
if (0)
{
// Note, that we cannot expect bitwise results for add-weighted:
//
@ -1088,8 +1097,8 @@ PERF_TEST_P_(IntegralPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv1 != out_mat1));
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv2 != out_mat2));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_ocv1 != out_mat1));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_ocv2 != out_mat2));
SANITY_CHECK_NOTHING();
}
@ -1126,7 +1135,7 @@ PERF_TEST_P_(ThresholdPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -1164,7 +1173,7 @@ PERF_TEST_P_(ThresholdOTPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
EXPECT_EQ(ocv_res, out_gapi_scalar.val[0]);
@ -1201,7 +1210,7 @@ PERF_TEST_P_(InRangePerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -1239,9 +1248,9 @@ PERF_TEST_P_(Split3PerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv2 != out_mat2));
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv3 != out_mat3));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(0, cv::norm(out_mat_ocv2, out_mat2, NORM_INF));
EXPECT_EQ(0, cv::norm(out_mat_ocv3, out_mat3, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -1279,10 +1288,10 @@ PERF_TEST_P_(Split4PerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv2 != out_mat2));
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv3 != out_mat3));
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv4 != out_mat4));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(0, cv::norm(out_mat_ocv2, out_mat2, NORM_INF));
EXPECT_EQ(0, cv::norm(out_mat_ocv3, out_mat3, NORM_INF));
EXPECT_EQ(0, cv::norm(out_mat_ocv4, out_mat4, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -1318,7 +1327,7 @@ PERF_TEST_P_(Merge3PerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -1356,7 +1365,7 @@ PERF_TEST_P_(Merge4PerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -1392,7 +1401,7 @@ PERF_TEST_P_(RemapPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -1426,7 +1435,7 @@ PERF_TEST_P_(FlipPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -1461,7 +1470,7 @@ PERF_TEST_P_(CropPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_out);
SANITY_CHECK_NOTHING();
@ -1509,7 +1518,7 @@ PERF_TEST_P_(ConcatHorPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -1562,7 +1571,7 @@ PERF_TEST_P_(ConcatHorVecPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -1609,7 +1618,7 @@ PERF_TEST_P_(ConcatVertPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -1662,7 +1671,7 @@ PERF_TEST_P_(ConcatVertVecPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
SANITY_CHECK_NOTHING();
}
@ -1699,7 +1708,7 @@ PERF_TEST_P_(LUTPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();
@ -1734,7 +1743,7 @@ PERF_TEST_P_(ConvertToPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
// FIXIT unrealiable check: EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
SANITY_CHECK_NOTHING();

2
modules/gapi/perf/cpu/gapi_imgproc_perf_tests_fluid.cpp
Unescape View File

@ -26,7 +26,7 @@ namespace opencv_test
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(SobelPerfTestFluid32F, SobelPerfTest,
Combine(Values(AbsToleranceSobel(1e-3).to_compare_f()),
Combine(Values(ToleranceFilter(1e-3f, 0.0).to_compare_f()),
Values(CV_32FC1),
Values(3), // add 5x5 once supported
Values(szVGA, sz720p, sz1080p),

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

@ -63,7 +63,7 @@ INSTANTIATE_TEST_CASE_P(MulCPerfTestGPU, MulCPerfTest,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(DivPerfTestGPU, DivPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-2).to_compare_f()),
Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
Values( szSmall128, szVGA, sz720p, sz1080p ),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values( -1, CV_8U, CV_16U, CV_32F ),
@ -76,7 +76,7 @@ INSTANTIATE_TEST_CASE_P(DivCPerfTestGPU, DivCPerfTest,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(DivRCPerfTestGPU, DivRCPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-2).to_compare_f()),
Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
Values( szSmall128, szVGA, sz720p, sz1080p ),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values( -1, CV_8U, CV_16U, CV_32F ),
@ -95,12 +95,12 @@ INSTANTIATE_TEST_CASE_P(MeanPerfTestGPU, MeanPerfTest,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(Polar2CartPerfTestGPU, Polar2CartPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-2).to_compare_f()),
Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
Values( szSmall128, szVGA, sz720p, sz1080p ),
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(Cart2PolarPerfTestGPU, Cart2PolarPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-2, 1e-2).to_compare_f()),
Combine(Values(Tolerance_FloatRel_IntAbs(1e-2, 2).to_compare_f()),
Values( szSmall128, szVGA, sz720p, sz1080p ),
Values(cv::compile_args(CORE_GPU))));
@ -272,7 +272,7 @@ INSTANTIATE_TEST_CASE_P(ConvertToPerfTestGPU, ConvertToPerfTest,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(ResizePerfTestGPU, ResizePerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-3, 1e-0).to_compare_f()), //TODO: too relaxed?
Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
Values( szSmall128, szVGA, sz720p, sz1080p ),
@ -281,7 +281,7 @@ INSTANTIATE_TEST_CASE_P(ResizePerfTestGPU, ResizePerfTest,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestGPU, ResizeFxFyPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-1, 1e-0).to_compare_f()), //TODO: too relaxed?
Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
Values( szSmall128, szVGA, sz720p, sz1080p ),

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

@ -16,7 +16,7 @@ namespace opencv_test
INSTANTIATE_TEST_CASE_P(SepFilterPerfTestGPU_8U, SepFilterPerfTest,
Combine(Values(AbsToleranceSepFilter(1e-4f).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_8UC3),
Values(3),
Values(szVGA, sz720p, sz1080p),
@ -24,7 +24,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterPerfTestGPU_8U, SepFilterPerfTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(SepFilterPerfTestGPU_other, SepFilterPerfTest,
Combine(Values(AbsToleranceSepFilter(1e-4f).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_16UC1, CV_16SC1, CV_32FC1),
Values(3),
Values(szVGA, sz720p, sz1080p),
@ -34,7 +34,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterPerfTestGPU_other, SepFilterPerfTest,
INSTANTIATE_TEST_CASE_P(Filter2DPerfTestGPU, Filter2DPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(3, 4, 5, 7),
Values(szVGA, sz720p, sz1080p),
@ -43,7 +43,7 @@ INSTANTIATE_TEST_CASE_P(Filter2DPerfTestGPU, Filter2DPerfTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BoxFilterPerfTestGPU, BoxFilterPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(/*CV_8UC1,*/ CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(3,5),
Values(szVGA, sz720p, sz1080p),
@ -52,7 +52,7 @@ INSTANTIATE_TEST_CASE_P(BoxFilterPerfTestGPU, BoxFilterPerfTest,
Values(cv::compile_args(IMGPROC_GPU)))); //TODO: 8UC1 doesn't work
INSTANTIATE_TEST_CASE_P(BlurPerfTestGPU, BlurPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(3, 5),
Values(szVGA, sz720p, sz1080p),
@ -60,7 +60,7 @@ INSTANTIATE_TEST_CASE_P(BlurPerfTestGPU, BlurPerfTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(GaussianBlurPerfTestGPU, GaussianBlurPerfTest,
Combine(Values(AbsToleranceGaussianBlur_Float_Int(1e-5, 0.05).to_compare_f()), //TODO: too relaxed?
Combine(Values(AbsSimilarPoints(1, 0.05).to_compare_f()), //TODO: too relaxed?
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(3, 5),
Values(szVGA, sz720p, sz1080p),
@ -108,7 +108,7 @@ INSTANTIATE_TEST_CASE_P(Dilate3x3PerfTestGPU, Dilate3x3PerfTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(SobelPerfTestGPU, SobelPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-4).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(3, 5),
Values(szVGA, sz720p, sz1080p),
@ -118,7 +118,7 @@ INSTANTIATE_TEST_CASE_P(SobelPerfTestGPU, SobelPerfTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(CannyPerfTestGPU, CannyPerfTest,
Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()),
Combine(Values(AbsSimilarPoints(1, 0.05).to_compare_f()),
Values(CV_8UC1, CV_8UC3),
Values(szVGA, sz720p, sz1080p),
Values(3.0, 120.0),
@ -128,52 +128,52 @@ INSTANTIATE_TEST_CASE_P(CannyPerfTestGPU, CannyPerfTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(EqHistPerfTestGPU, EqHistPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(AbsExact().to_compare_f()), // FIXIT unrealiable check
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(RGB2GrayPerfTestGPU, RGB2GrayPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BGR2GrayPerfTestGPU, BGR2GrayPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(RGB2YUVPerfTestGPU, RGB2YUVPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(YUV2RGBPerfTestGPU, YUV2RGBPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(RGB2LabPerfTestGPU, RGB2LabPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(AbsSimilarPoints(1, 0.05).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BGR2LUVPerfTestGPU, BGR2LUVPerfTest,
Combine(Values(ToleranceTriple(0.25 * 3, 0.01 * 3, 0.0001 * 3).to_compare_f()),
Combine(Values(AbsSimilarPoints(1, 0.05).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(LUV2BGRPerfTestGPU, LUV2BGRPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BGR2YUVPerfTestGPU, BGR2YUVPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(YUV2BGRPerfTestGPU, YUV2BGRPerfTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(szVGA, sz720p, sz1080p),
Values(cv::compile_args(IMGPROC_GPU))));

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

@ -871,8 +871,8 @@ TEST_P(ThresholdTest, AccuracyTestBinary)
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(out_mat_gapi.size(), sz_in);
ASSERT_EQ(out_mat_gapi.size(), sz_in);
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_L1));
}
}

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

@ -134,7 +134,7 @@ public:
AbsExact() {}
bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
{
if (cv::countNonZero(in1 != in2) != 0)
if (cv::norm(in1, in2, NORM_INF) != 0)
{
std::cout << "AbsExact error: G-API output and reference output matrixes are not bitexact equal." << std::endl;
return false;
@ -153,8 +153,7 @@ public:
AbsTolerance(double tol) : _tol(tol) {}
bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
{
cv::Mat absDiff; cv::absdiff(in1, in2, absDiff);
if(cv::countNonZero(absDiff > _tol))
if (cv::norm(in1, in2, NORM_INF) > _tol)
{
std::cout << "AbsTolerance error: Number of different pixels in " << std::endl;
std::cout << "G-API output and reference output matrixes exceeds " << _tol << " pixels threshold." << std::endl;
@ -169,19 +168,22 @@ private:
double _tol;
};
class AbsTolerance_Float_Int : public Wrappable<AbsTolerance_Float_Int>
class Tolerance_FloatRel_IntAbs : public Wrappable<Tolerance_FloatRel_IntAbs>
{
public:
AbsTolerance_Float_Int(double tol, double tol8u) : _tol(tol), _tol8u(tol8u) {}
Tolerance_FloatRel_IntAbs(double tol, double tol8u) : _tol(tol), _tol8u(tol8u) {}
bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
{
if (CV_MAT_DEPTH(in1.type()) == CV_32F)
int depth = CV_MAT_DEPTH(in1.type());
{
if (cv::countNonZero(cv::abs(in1 - in2) > (_tol)*cv::abs(in2)))
double err = depth >= CV_32F ? cv::norm(in1, in2, NORM_L1 | NORM_RELATIVE)
: cv::norm(in1, in2, NORM_INF);
double tolerance = depth >= CV_32F ? _tol : _tol8u;
if (err > tolerance)
{
std::cout << "AbsTolerance_Float_Int error (Float): One or more of pixels in" << std::endl;
std::cout << "G-API output exceeds relative threshold value defined by reference_pixel_value * tolerance" << std::endl;
std::cout << "for tolerance " << _tol << std::endl;
std::cout << "Tolerance_FloatRel_IntAbs error: err=" << err
<< " tolerance=" << tolerance
<< " depth=" << cv::typeToString(depth) << std::endl;
return false;
}
else
@ -189,193 +191,99 @@ public:
return true;
}
}
else
{
if (cv::countNonZero(in1 != in2) <= (_tol8u)* in2.total())
{
return true;
}
else
{
std::cout << "AbsTolerance_Float_Int error (Integer): Number of different pixels in" << std::endl;
std::cout << "G-API output and reference output matrixes exceeds relative threshold value" << std::endl;
std::cout << "defined by reference_total_pixels_number * tolerance" << std::endl;
std::cout << "for tolerance " << _tol8u << std::endl;
return false;
}
}
}
private:
double _tol;
double _tol8u;
};
class AbsToleranceSepFilter : public Wrappable<AbsToleranceSepFilter>
class AbsSimilarPoints : public Wrappable<AbsSimilarPoints>
{
public:
AbsToleranceSepFilter(double tol) : _tol(tol) {}
AbsSimilarPoints(double tol, double percent) : _tol(tol), _percent(percent) {}
bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
{
if ((cv::countNonZero(cv::abs(in1 - in2) > (_tol)* cv::abs(in2)) <= 0.01 * in2.total()))
Mat diff;
cv::absdiff(in1, in2, diff);
Mat err_mask = diff > _tol;
int err_points = cv::countNonZero(err_mask.reshape(1));
double max_err_points = _percent * std::max((size_t)1000, in1.total());
if (err_points > max_err_points)
{
return true;
std::cout << "AbsSimilarPoints error: err_points=" << err_points
<< " max_err_points=" << max_err_points << " (total=" << in1.total() << ")"
<< " diff_tolerance=" << _tol << std::endl;
return false;
}
else
{
std::cout << "AbsToleranceSepFilter error: Number of different pixels in" << std::endl;
std::cout << "G-API output and reference output matrixes which exceeds relative threshold value" << std::endl;
std::cout << "defined by reference_pixel_value * tolerance" << std::endl;
std::cout << "for tolerance " << _tol << " is more then 1% of total number of pixels in the reference matrix." << std::endl;
return false;
return true;
}
}
private:
double _tol;
double _percent;
};
class AbsToleranceGaussianBlur_Float_Int : public Wrappable<AbsToleranceGaussianBlur_Float_Int>
class ToleranceFilter : public Wrappable<ToleranceFilter>
{
public:
AbsToleranceGaussianBlur_Float_Int(double tol, double tol8u) : _tol(tol), _tol8u(tol8u) {}
ToleranceFilter(double tol, double tol8u, double inf_tol = 2.0) : _tol(tol), _tol8u(tol8u), _inf_tol(inf_tol) {}
bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
{
if (CV_MAT_DEPTH(in1.type()) == CV_32F || CV_MAT_DEPTH(in1.type()) == CV_64F)
int depth = CV_MAT_DEPTH(in1.type());
{
if (cv::countNonZero(cv::abs(in1 - in2) > (_tol)*cv::abs(in2)))
double err_Inf = cv::norm(in1, in2, NORM_INF);
if (err_Inf > _inf_tol)
{
std::cout << "AbsToleranceGaussianBlur_Float_Int error (Float): Number of different pixels in" << std::endl;
std::cout << "G-API output and reference output matrixes which exceeds relative threshold value" << std::endl;
std::cout << "defined by reference_pixel_value * tolerance" << std::endl;
std::cout << "for tolerance " << _tol << " is more then 0." << std::endl;
std::cout << "ToleranceFilter error: err_Inf=" << err_Inf << " tolerance=" << _inf_tol << std::endl;
return false;
}
else
double err = cv::norm(in1, in2, NORM_L2 | NORM_RELATIVE);
double tolerance = depth >= CV_32F ? _tol : _tol8u;
if (err > tolerance)
{
return true;
}
}
else
{
if (CV_MAT_DEPTH(in1.type()) == CV_8U)
{
bool a = (cv::countNonZero(cv::abs(in1 - in2) > 1) <= _tol8u * in2.total());
if (((a == 1 ? 0 : 1) && ((cv::countNonZero(cv::abs(in1 - in2) > 2) <= 0) == 1 ? 0 : 1)) == 1)
{
std::cout << "AbsToleranceGaussianBlur_Float_Int error (8U): Number of pixels in" << std::endl;
std::cout << "G-API output and reference output matrixes with absolute difference which is more than 1 but less than 3" << std::endl;
std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance" << std::endl;
std::cout << "for tolerance " << _tol8u << std::endl;
return false;
}
else
{
return true;
}
}
else
{
if (cv::countNonZero(in1 != in2) != 0)
{
std::cout << "AbsToleranceGaussianBlur_Float_Int error: G-API output and reference output matrixes are not bitexact equal." << std::endl;
return false;
}
else
{
return true;
}
std::cout << "ToleranceFilter error: err=" << err << " tolerance=" << tolerance
<< " depth=" << cv::depthToString(depth)
<< std::endl;
return false;
}
}
return true;
}
private:
double _tol;
double _tol8u;
double _inf_tol;
};
class ToleranceRGBBGR : public Wrappable<ToleranceRGBBGR>
class ToleranceColor : public Wrappable<ToleranceColor>
{
public:
ToleranceRGBBGR(double tol) : _tol(tol) {}
ToleranceColor(double tol, double inf_tol = 2.0) : _tol(tol), _inf_tol(inf_tol) {}
bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
{
bool a = (cv::countNonZero((in1 - in2) > 0) <= _tol * in2.total());
if (((a == 1 ? 0 : 1) && ((cv::countNonZero((in1 - in2) > 1) <= 0) == 1 ? 0 : 1)) == 1)
{
std::cout << "ToleranceRGBBGR error: Number of pixels in" << std::endl;
std::cout << "G-API output and reference output matrixes with difference which is more than 0 but no more than 1" << std::endl;
std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance" << std::endl;
std::cout << "for tolerance " << _tol << std::endl;
return false;
}
else
{
return true;
}
}
private:
double _tol;
};
class ToleranceTriple: public Wrappable<ToleranceTriple>
{
public:
ToleranceTriple(double tol1, double tol2, double tol3) : _tol1(tol1), _tol2(tol2), _tol3(tol3) {}
bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
{
bool a = (cv::countNonZero((in1 - in2) > 0) <= _tol1 * in2.total());
if ((((a == 1 ? 0 : 1) &&
((cv::countNonZero((in1 - in2) > 1) <= _tol2 * in2.total()) == 1 ? 0 : 1) &&
((cv::countNonZero((in1 - in2) > 2) <= _tol3 * in2.total()) == 1 ? 0 : 1))) == 1)
{
std::cout << "ToleranceTriple error: Number of pixels in" << std::endl;
std::cout << "G-API output and reference output matrixes with difference which is more than 0 but no more than 1" << std::endl;
std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance1" << std::endl;
std::cout << "for tolerance1 " << _tol1 << std::endl;
std::cout << "AND with difference which is more than 1 but no more than 2" << std::endl;
std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance2" << std::endl;
std::cout << "for tolerance2 " << _tol2 << std::endl;
std::cout << "AND with difference which is more than 2" << std::endl;
std::cout << "exceeds relative threshold value defined by reference_total_pixels_number * tolerance3" << std::endl;
std::cout << "for tolerance3 " << _tol3 << std::endl;
return false;
}
else
{
return true;
}
}
private:
double _tol1, _tol2, _tol3;
};
class AbsToleranceSobel : public Wrappable<AbsToleranceSobel>
{
public:
AbsToleranceSobel(double tol) : _tol(tol) {}
bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
{
cv::Mat diff, a1, a2, b, base;
cv::absdiff(in1, in2, diff);
a1 = cv::abs(in1);
a2 = cv::abs(in2);
cv::max(a1, a2, b);
cv::max(1, b, base); // base = max{1, |in1|, |in2|}
if(cv::countNonZero(diff > _tol*base) != 0)
{
std::cout << "AbsToleranceSobel error: Number of pixels in" << std::endl;
std::cout << "G-API output and reference output matrixes with absolute difference which is more than relative threshold defined by tolerance * max{1, |in1|, |in2|}" << std::endl;
std::cout << "relative threshold defined by tolerance * max{1, |in1|, |in2|} exceeds 0"<< std::endl;
std::cout << "for tolerance " << _tol << std::endl;
return false;
}
else
{
return true;
double err_Inf = cv::norm(in1, in2, NORM_INF);
if (err_Inf > _inf_tol)
{
std::cout << "ToleranceColor error: err_Inf=" << err_Inf << " tolerance=" << _inf_tol << std::endl;;
return false;
}
double err = cv::norm(in1, in2, NORM_L1 | NORM_RELATIVE);
if (err > _tol)
{
std::cout << "ToleranceColor error: err=" << err << " tolerance=" << _tol << std::endl;;
return false;
}
}
return true;
}
private:
double _tol;
double _inf_tol;
};
} // namespace opencv_test

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

@ -275,7 +275,7 @@ INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
Values(cv::Size(1280, 720),
@ -286,7 +286,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
Values(cv::Size(1280, 720),

2
modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp
Unescape View File

@ -161,7 +161,7 @@ INSTANTIATE_TEST_CASE_P(EqHistTestCPU, EqHistTest,
Values(cv::compile_args(IMGPROC_CPU))));
INSTANTIATE_TEST_CASE_P(CannyTestCPU, CannyTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(AbsSimilarPoints(0, 0.05).to_compare_f()),
Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),

24
modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp
Unescape View File

@ -15,35 +15,35 @@ namespace opencv_test
{
INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest,
Combine(Values(ToleranceRGBBGR(0.001).to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(true, false),
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest,
Combine(Values(ToleranceRGBBGR(0.001).to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(true, false),
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest,
Combine(Values(ToleranceRGBBGR(0.15*3).to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(true, false),
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest,
Combine(Values(ToleranceTriple(0.25 * 3, 0.01 * 3, 1e-5 * 3).to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(true, false),
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
Combine(Values(ToleranceTriple(0.25 * 3, 0.0, 1e-5 * 3).to_compare_f()),
Combine(Values(AbsSimilarPoints(1, 0.05).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(true, false),
@ -51,14 +51,14 @@ INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
// FIXME: Not supported by Fluid yet (no kernel implemented)
INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest,
Combine(Values(ToleranceTriple(0.25 * 3, 0.01 * 3, 0.0001 * 3).to_compare_f()),
Combine(Values(ToleranceColor(5e-3, 6).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(true, false),
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
Combine(Values(AbsTolerance(0.0).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(3), // add kernel size=5 when implementation is ready
Values(cv::Size(1280, 720),
@ -68,7 +68,7 @@ INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
Combine(Values(AbsToleranceGaussianBlur_Float_Int(1e-6, 1e-6).to_compare_f()),
Combine(Values(ToleranceFilter(1e-3f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(3), // add kernel size=5 when implementation is ready
Values(cv::Size(1280, 720),
@ -122,7 +122,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
Combine(Values(AbsToleranceSobel(1e-3).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_32FC1),
Values(3), // add kernel size=5 when implementation is ready
Values(cv::Size(1280, 720),
@ -134,7 +134,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
Combine(Values(AbsTolerance_Float_Int(1e-6, 1e-4).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(3), // add kernel size=5 when implementation is ready
Values(cv::Size(1280, 720),
@ -145,7 +145,7 @@ INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
Combine(Values(AbsToleranceSepFilter(1e-5f).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_32FC1),
Values(3), // add kernel size=5 when implementation is ready
Values(cv::Size(1280, 720),
@ -155,7 +155,7 @@ INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
Values(cv::compile_args(IMGPROC_FLUID))));
INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest,
Combine(Values(AbsTolerance_Float_Int(1e-6, 1e-4).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(3), // add kernel size=4,5,7 when implementation ready
Values(cv::Size(1280, 720),

2
modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
Unescape View File

@ -30,7 +30,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest,
INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
Combine(Values(AbsExact().to_compare_f()),
Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR,
Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, // FIXIT avoid division by values near zero: opDiv, opDivR,
opGT, opLT, opGE, opLE, opEQ, opNE,
opGTR, opLTR, opGER, opLER, opEQR, opNER),
Values(CV_8UC1, CV_16SC1, CV_32FC1),

2
modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
Unescape View File

@ -29,7 +29,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,
//FIXME: Some Mat/Scalar Fluid kernels are not there yet!
INSTANTIATE_TEST_CASE_P(DISABLED_MathOperatorTestFluid, MathOperatorMatScalarTest,
Combine(Values(AbsExact().to_compare_f()),
Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR,
Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, // FIXIT avoid division by values near zero: opDiv, opDivR,
opGT, opLT, opGE, opLE, opEQ, opNE,
opGTR, opLTR, opGER, opLER, opEQR, opNER),
Values(CV_8UC1, CV_16SC1, CV_32FC1),

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

@ -277,7 +277,7 @@ INSTANTIATE_TEST_CASE_P(Split4TestGPU, Split4Test,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest,
Combine(Values(AbsTolerance_Float_Int(1e-3, 1e-0).to_compare_f()), //TODO: too relaxed?
Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
Values(cv::Size(1280, 720),
@ -288,7 +288,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy,
Combine(Values(AbsTolerance_Float_Int(1e-1, 1e-0).to_compare_f()), //TODO: too relaxed?
Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
Values(cv::Size(1280, 720),

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

@ -17,7 +17,7 @@ namespace opencv_test
INSTANTIATE_TEST_CASE_P(Filter2DTestGPU, Filter2DTest,
Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()),
Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(3, 4, 5, 7),
Values(cv::Size(1280, 720),
@ -29,7 +29,7 @@ INSTANTIATE_TEST_CASE_P(Filter2DTestGPU, Filter2DTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BoxFilterTestGPU, BoxFilterTest,
Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()),
Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
Values(/*CV_8UC1,*/ CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(3,5),
Values(cv::Size(1280, 720),
@ -40,7 +40,7 @@ INSTANTIATE_TEST_CASE_P(BoxFilterTestGPU, BoxFilterTest,
Values(cv::compile_args(IMGPROC_GPU)))); //TODO: 8UC1 doesn't work
INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_8U, SepFilterTest,
Combine(Values(AbsToleranceSepFilter(1e-4f).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_8UC3),
Values(3),
Values(cv::Size(1280, 720),
@ -50,7 +50,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_8U, SepFilterTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest,
Combine(Values(AbsToleranceSepFilter(1e-4f).to_compare_f()),
Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
Values(CV_16UC1, CV_16SC1, CV_32FC1),
Values(3),
Values(cv::Size(1280, 720),
@ -60,7 +60,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BlurTestGPU, BlurTest,
Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-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),
Values(3,5),
Values(cv::Size(1280, 720),
@ -70,9 +70,9 @@ INSTANTIATE_TEST_CASE_P(BlurTestGPU, BlurTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(gaussBlurTestGPU, GaussianBlurTest,
Combine(Values(AbsToleranceGaussianBlur_Float_Int(1e-5, 0.05).to_compare_f()), //TODO: too relaxed?
Combine(Values(ToleranceFilter(1e-5f, 0.01).to_compare_f()),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(3, 5),
Values(3), // FIXIT 5
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
@ -130,7 +130,7 @@ INSTANTIATE_TEST_CASE_P(Dilate3x3TestGPU, Dilate3x3Test,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest,
Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-4).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(3, 5),
Values(cv::Size(1280, 720),
@ -142,14 +142,14 @@ INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(EqHistTestGPU, EqHistTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(AbsExact().to_compare_f()), // FIXIT Non reliable check
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(CannyTestGPU, CannyTest,
Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()),
Combine(Values(AbsSimilarPoints(0, 0.05).to_compare_f()),
Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
@ -161,63 +161,63 @@ INSTANTIATE_TEST_CASE_P(CannyTestGPU, CannyTest,
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(RGB2GrayTestGPU, RGB2GrayTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BGR2GrayTestGPU, BGR2GrayTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(RGB2YUVTestGPU, RGB2YUVTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(YUV2RGBTestGPU, YUV2RGBTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(RGB2LabTestGPU, RGB2LabTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(AbsSimilarPoints(1, 0.05).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BGR2LUVTestGPU, BGR2LUVTest,
Combine(Values(ToleranceTriple(0.25 * 3, 0.01 * 3, 0.0001 * 3).to_compare_f()),
Combine(Values(ToleranceColor(5e-3, 6).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(LUV2BGRTestGPU, LUV2BGRTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(BGR2YUVTestGPU, BGR2YUVTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(IMGPROC_GPU))));
INSTANTIATE_TEST_CASE_P(YUV2BGRTestGPU, YUV2BGRTest,
Combine(Values(AbsExact().to_compare_f()),
Combine(Values(ToleranceColor(1e-3).to_compare_f()),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
/*init output matrices or not*/ testing::Bool(),

6
modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp
Unescape View File

@ -16,7 +16,7 @@ namespace opencv_test
INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest,
Combine(Values(AbsTolerance_Float_Int(1e-5, 1e-3).to_compare_f()),
Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq),
Values(CV_8UC1, CV_16SC1, CV_32FC1),
@ -28,8 +28,8 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest,
Combine(Values(AbsTolerance_Float_Int(1e-4, 1e-2).to_compare_f()),
Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR,
Combine(Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()),
Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, // FIXIT avoid division by values near zero: opDiv, opDivR,
opGT, opLT, opGE, opLE, opEQ, opNE,
opGTR, opLTR, opGER, opLER, opEQR, opNER),
Values(CV_8UC1, CV_16SC1, CV_32FC1),

Write Preview
Loading…
Cancel
Save