Skip to content

O
opencv
Commit ca9aa180 authored by Alexander Alekhin's avatar Alexander Alekhin
Browse files
Options

Merge pull request #13096 from alalek:gapi_tests_checks

parents ce46cc98 6189b476
Show whitespace changes
Inline Side-by-side
Showing with 183 additions and 262 deletions
modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp
View file @ ca9aa180
......@@ -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();
......@@ -921,7 +928,8 @@ PERF_TEST_P_(SumPerfTest, TestPerformance)
// Comparison ////////////////////////////////////////////////////////////
{
EXPECT_LE(abs(out_sum[0] - out_sum_ocv[0]), tolerance);
EXPECT_LE(std::abs(out_sum[0] - out_sum_ocv[0]) / std::max(1.0, std::abs(out_sum_ocv[0])), tolerance)
<< "OCV=" << out_sum_ocv[0] << " GAPI=" << out_sum[0];
}
SANITY_CHECK_NOTHING();
......@@ -960,6 +968,8 @@ PERF_TEST_P_(AddWeightedPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
// FIXIT unrealiable check
if (0)
{
// Note, that we cannot expect bitwise results for add-weighted:
//
......@@ -1041,7 +1051,8 @@ PERF_TEST_P_(NormPerfTest, TestPerformance)
// Comparison ////////////////////////////////////////////////////////////
{
EXPECT_LE(abs(out_norm[0] - out_norm_ocv[0]), tolerance);
EXPECT_LE(std::abs(out_norm[0] - out_norm_ocv[0]) / std::max(1.0, std::abs(out_norm_ocv[0])), tolerance)
<< "OCV=" << out_norm_ocv[0] << " GAPI=" << out_norm[0];
}
SANITY_CHECK_NOTHING();
......@@ -1086,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();
}
......@@ -1124,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();
......@@ -1162,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]);
......@@ -1199,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();
......@@ -1237,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();
}
......@@ -1277,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();
}
......@@ -1316,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();
}
......@@ -1354,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();
}
......@@ -1390,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();
......@@ -1424,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();
......@@ -1459,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();
......@@ -1507,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();
}
......@@ -1560,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();
}
......@@ -1607,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();
}
......@@ -1660,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();
}
......@@ -1697,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();
......@@ -1732,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();
......
modules/gapi/perf/cpu/gapi_imgproc_perf_tests_fluid.cpp
View file @ ca9aa180
......@@ -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),
......
modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp
View file @ ca9aa180
......@@ -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 ),
......
modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp
View file @ ca9aa180
......@@ -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))));
......
modules/gapi/test/common/gapi_core_tests_inl.hpp
View file @ ca9aa180
......@@ -703,7 +703,8 @@ TEST_P(SumTest, AccuracyTest)
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_LE(abs(out_sum[0] - out_sum_ocv[0]), tolerance);
EXPECT_LE(std::abs(out_sum[0] - out_sum_ocv[0]) / std::max(1.0, std::abs(out_sum_ocv[0])), tolerance)
<< "OCV=" << out_sum_ocv[0] << " GAPI=" << out_sum[0];
}
}
......@@ -802,7 +803,8 @@ TEST_P(NormTest, AccuracyTest)
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_LE(abs(out_norm[0] - out_norm_ocv[0]), tolerance);
EXPECT_LE(std::abs(out_norm[0] - out_norm_ocv[0]) / std::max(1.0, std::abs(out_norm_ocv[0])), tolerance)
<< "OCV=" << out_norm_ocv[0] << " GAPI=" << out_norm[0];
}
}
......@@ -869,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));
}
}
......
modules/gapi/test/common/gapi_tests_common.hpp
View file @ ca9aa180
......@@ -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()))
{
return true;
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)
{
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;
std::cout << "ToleranceFilter error: err=" << err << " tolerance=" << tolerance
<< " depth=" << cv::depthToString(depth)
<< 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;
}
}
}
}
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
double err_Inf = cv::norm(in1, in2, NORM_INF);
if (err_Inf > _inf_tol)
{
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;
std::cout << "ToleranceColor error: err_Inf=" << err_Inf << " tolerance=" << _inf_tol << 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
double err = cv::norm(in1, in2, NORM_L1 | NORM_RELATIVE);
if (err > _tol)
{
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;
std::cout << "ToleranceColor error: err=" << err << " tolerance=" << _tol << std::endl;;
return false;
}
else
{
return true;
}
return true;
}
private:
double _tol;
double _inf_tol;
};
} // namespace opencv_test
......
modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
View file @ ca9aa180
......@@ -188,7 +188,7 @@ INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
cv::Size(640, 480),
cv::Size(128, 128)),
/*init output matrices or not*/ testing::Bool(),
Values(0.0),
Values(1e-5),
Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
......@@ -224,7 +224,7 @@ INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(0.0),
Values(1e-5),
Values(cv::compile_args(CORE_CPU))),
opencv_test::PrintNormCoreParams());
......@@ -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),
......
modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp
View file @ ca9aa180
......@@ -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)),
......
modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp
View file @ ca9aa180
......@@ -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),
......
modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
View file @ ca9aa180
......@@ -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),
......
modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
View file @ ca9aa180
......@@ -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),
......
modules/gapi/test/gpu/gapi_core_tests_gpu.cpp
View file @ ca9aa180
......@@ -190,7 +190,7 @@ INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest,
cv::Size(640, 480),
cv::Size(128, 128)),
/*init output matrices or not*/ testing::Bool(),
Values(0.5), //Values(0.04), //TODO: too relaxed?
Values(1e-3), //TODO: too relaxed?
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(AbsDiffTestGPU, AbsDiffTest,
......@@ -226,7 +226,7 @@ INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(0.04), //TODO: too relaxed?
Values(1e-3), //TODO: too relaxed?
Values(cv::compile_args(CORE_GPU))),
opencv_test::PrintNormCoreParams());
......@@ -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),
......
modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp
View file @ ca9aa180
......@@ -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(),
......
modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp
View file @ ca9aa180
......@@ -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),
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment