Merge pull request #19337 from OrestChura:oc/fLine_fCont_perftests

[G-API]: Performance tests for fitLine and findContours

* Perf.Test for findContours(H)

* Perf.Test for fitLine(2D.3D;Mat,vector<Point2i/2f/2d/3i/3f/3d>)

* Reducing the template specializations number

* Applying comments

modules/gapi/perf/common/gapi_imgproc_perf_tests.hpp

@@ -43,12 +43,44 @@ class CannyPerfTest           : public TestPerfParams<tuple<compare_f, MatType,c
 class GoodFeaturesPerfTest    : public TestPerfParams<tuple<compare_vector_f<cv::Point2f>, std::string,
                                                             int,int,double,double,int,bool,
                                                             cv::GCompileArgs>> {};
+class FindContoursPerfTest    : public TestPerfParams<tuple<CompareMats, MatType,cv::Size,
+                                                            cv::RetrievalModes,
+                                                            cv::ContourApproximationModes,
+                                                            cv::GCompileArgs>> {};
+class FindContoursHPerfTest   : public TestPerfParams<tuple<CompareMats, MatType,cv::Size,
+                                                            cv::RetrievalModes,
+                                                            cv::ContourApproximationModes,
+                                                            cv::GCompileArgs>> {};
 class BoundingRectMatPerfTest       :
     public TestPerfParams<tuple<CompareRects, MatType,cv::Size,bool, cv::GCompileArgs>> {};
 class BoundingRectVector32SPerfTest :
     public TestPerfParams<tuple<CompareRects, cv::Size, cv::GCompileArgs>> {};
 class BoundingRectVector32FPerfTest :
     public TestPerfParams<tuple<CompareRects, cv::Size, cv::GCompileArgs>> {};
+class FitLine2DMatVectorPerfTest : public TestPerfParams<tuple<CompareVecs<float, 4>,
+                                                               MatType,cv::Size,cv::DistanceTypes,
+                                                               cv::GCompileArgs>> {};
+class FitLine2DVector32SPerfTest : public TestPerfParams<tuple<CompareVecs<float, 4>,
+                                                               cv::Size,cv::DistanceTypes,
+                                                               cv::GCompileArgs>> {};
+class FitLine2DVector32FPerfTest : public TestPerfParams<tuple<CompareVecs<float, 4>,
+                                                               cv::Size,cv::DistanceTypes,
+                                                               cv::GCompileArgs>> {};
+class FitLine2DVector64FPerfTest : public TestPerfParams<tuple<CompareVecs<float, 4>,
+                                                               cv::Size,cv::DistanceTypes,
+                                                               cv::GCompileArgs>> {};
+class FitLine3DMatVectorPerfTest : public TestPerfParams<tuple<CompareVecs<float, 6>,
+                                                               MatType,cv::Size,cv::DistanceTypes,
+                                                               cv::GCompileArgs>> {};
+class FitLine3DVector32SPerfTest : public TestPerfParams<tuple<CompareVecs<float, 6>,
+                                                               cv::Size,cv::DistanceTypes,
+                                                               cv::GCompileArgs>> {};
+class FitLine3DVector32FPerfTest : public TestPerfParams<tuple<CompareVecs<float, 6>,
+                                                               cv::Size,cv::DistanceTypes,
+                                                               cv::GCompileArgs>> {};
+class FitLine3DVector64FPerfTest : public TestPerfParams<tuple<CompareVecs<float, 6>,
+                                                               cv::Size,cv::DistanceTypes,
+                                                               cv::GCompileArgs>> {};
 class EqHistPerfTest      : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
 class BGR2RGBPerfTest     : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
 class RGB2GrayPerfTest    : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};

modules/gapi/perf/common/gapi_imgproc_perf_tests_inl.hpp

@@ -795,6 +795,64 @@ PERF_TEST_P_(GoodFeaturesPerfTest, TestPerformance)
 
 //------------------------------------------------------------------------------
 
+PERF_TEST_P_(FindContoursPerfTest, TestPerformance)
+{
+    CompareMats cmpF;
+    MatType type;
+    cv::Size sz;
+    cv::RetrievalModes mode;
+    cv::ContourApproximationModes method;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, type, sz, mode, method, compile_args) = GetParam();
+
+    cv::Mat in;
+    initMatForFindingContours(in, sz, type);
+    cv::Point offset = cv::Point();
+    std::vector<cv::Vec4i> out_hier_gapi = std::vector<cv::Vec4i>();
+
+    std::vector<std::vector<cv::Point>> out_cnts_gapi;
+    cv::GComputation c(findContoursTestGAPI(in, mode, method, std::move(compile_args),
+                                            out_cnts_gapi, out_hier_gapi, offset));
+
+    TEST_CYCLE()
+    {
+        c.apply(gin(in, offset), gout(out_cnts_gapi));
+    }
+
+    findContoursTestOpenCVCompare(in, mode, method, out_cnts_gapi, out_hier_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(FindContoursHPerfTest, TestPerformance)
+{
+    CompareMats cmpF;
+    MatType type;
+    cv::Size sz;
+    cv::RetrievalModes mode;
+    cv::ContourApproximationModes method;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, type, sz, mode, method, compile_args) = GetParam();
+
+    cv::Mat in;
+    initMatForFindingContours(in, sz, type);
+    cv::Point offset = cv::Point();
+
+    std::vector<std::vector<cv::Point>> out_cnts_gapi;
+    std::vector<cv::Vec4i>              out_hier_gapi;
+    cv::GComputation c(findContoursTestGAPI<HIERARCHY>(in, mode, method, std::move(compile_args),
+                                                       out_cnts_gapi, out_hier_gapi, offset));
+
+    TEST_CYCLE()
+    {
+        c.apply(gin(in, offset), gout(out_cnts_gapi, out_hier_gapi));
+    }
+
+    findContoursTestOpenCVCompare<HIERARCHY>(in, mode, method, out_cnts_gapi, out_hier_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+//------------------------------------------------------------------------------
+
 PERF_TEST_P_(BoundingRectMatPerfTest, TestPerformance)
 {
     CompareRects cmpF;
@@ -871,6 +929,198 @@ PERF_TEST_P_(BoundingRectVector32FPerfTest, TestPerformance)
 
 //------------------------------------------------------------------------------
 
+PERF_TEST_P_(FitLine2DMatVectorPerfTest, TestPerformance)
+{
+    CompareVecs<float, 4> cmpF;
+    cv::Size sz;
+    MatType type;
+    cv::DistanceTypes distType;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, type, sz, distType, compile_args) = GetParam();
+
+    initMatByPointsVectorRandU<cv::Point_>(type, sz, -1);
+
+    cv::Vec4f out_vec_gapi;
+    cv::GComputation c(fitLineTestGAPI(in_mat1, distType, std::move(compile_args), out_vec_gapi));
+
+    TEST_CYCLE()
+    {
+        c.apply(cv::gin(in_mat1), cv::gout(out_vec_gapi));
+    }
+
+    fitLineTestOpenCVCompare(in_mat1, distType, out_vec_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(FitLine2DVector32SPerfTest, TestPerformance)
+{
+    CompareVecs<float, 4> cmpF;
+    cv::Size sz;
+    cv::DistanceTypes distType;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, sz, distType, compile_args) = GetParam();
+
+    std::vector<cv::Point2i> in_vector;
+    initPointsVectorRandU(sz.width, in_vector);
+
+    cv::Vec4f out_vec_gapi;
+    cv::GComputation c(fitLineTestGAPI(in_vector, distType, std::move(compile_args),
+                                       out_vec_gapi));
+
+    TEST_CYCLE()
+    {
+        c.apply(cv::gin(in_vector), cv::gout(out_vec_gapi));
+    }
+
+    fitLineTestOpenCVCompare(in_vector, distType, out_vec_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(FitLine2DVector32FPerfTest, TestPerformance)
+{
+    CompareVecs<float, 4> cmpF;
+    cv::Size sz;
+    cv::DistanceTypes distType;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, sz, distType, compile_args) = GetParam();
+
+    std::vector<cv::Point2f> in_vector;
+    initPointsVectorRandU(sz.width, in_vector);
+
+    cv::Vec4f out_vec_gapi;
+    cv::GComputation c(fitLineTestGAPI(in_vector, distType, std::move(compile_args),
+                                       out_vec_gapi));
+
+    TEST_CYCLE()
+    {
+        c.apply(cv::gin(in_vector), cv::gout(out_vec_gapi));
+    }
+
+    fitLineTestOpenCVCompare(in_vector, distType, out_vec_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(FitLine2DVector64FPerfTest, TestPerformance)
+{
+    CompareVecs<float, 4> cmpF;
+    cv::Size sz;
+    cv::DistanceTypes distType;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, sz, distType, compile_args) = GetParam();
+
+    std::vector<cv::Point2d> in_vector;
+    initPointsVectorRandU(sz.width, in_vector);
+
+    cv::Vec4f out_vec_gapi;
+    cv::GComputation c(fitLineTestGAPI(in_vector, distType, std::move(compile_args),
+                                       out_vec_gapi));
+
+    TEST_CYCLE()
+    {
+        c.apply(cv::gin(in_vector), cv::gout(out_vec_gapi));
+    }
+
+    fitLineTestOpenCVCompare(in_vector, distType, out_vec_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(FitLine3DMatVectorPerfTest, TestPerformance)
+{
+    CompareVecs<float, 6> cmpF;
+    cv::Size sz;
+    MatType type;
+    cv::DistanceTypes distType;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, type, sz, distType, compile_args) = GetParam();
+
+    initMatByPointsVectorRandU<cv::Point3_>(type, sz, -1);
+
+    cv::Vec6f out_vec_gapi;
+    cv::GComputation c(fitLineTestGAPI(in_mat1, distType, std::move(compile_args), out_vec_gapi));
+
+    TEST_CYCLE()
+    {
+        c.apply(cv::gin(in_mat1), cv::gout(out_vec_gapi));
+    }
+
+    fitLineTestOpenCVCompare(in_mat1, distType, out_vec_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(FitLine3DVector32SPerfTest, TestPerformance)
+{
+    CompareVecs<float, 6> cmpF;
+    cv::Size sz;
+    cv::DistanceTypes distType;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, sz, distType, compile_args) = GetParam();
+
+    std::vector<cv::Point3i> in_vector;
+    initPointsVectorRandU(sz.width, in_vector);
+
+    cv::Vec6f out_vec_gapi;
+    cv::GComputation c(fitLineTestGAPI(in_vector, distType, std::move(compile_args),
+                                       out_vec_gapi));
+
+    TEST_CYCLE()
+    {
+        c.apply(cv::gin(in_vector), cv::gout(out_vec_gapi));
+    }
+
+    fitLineTestOpenCVCompare(in_vector, distType, out_vec_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(FitLine3DVector32FPerfTest, TestPerformance)
+{
+    CompareVecs<float, 6> cmpF;
+    cv::Size sz;
+    cv::DistanceTypes distType;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, sz, distType, compile_args) = GetParam();
+
+    std::vector<cv::Point3f> in_vector;
+    initPointsVectorRandU(sz.width, in_vector);
+
+    cv::Vec6f out_vec_gapi;
+    cv::GComputation c(fitLineTestGAPI(in_vector, distType, std::move(compile_args),
+                                       out_vec_gapi));
+
+    TEST_CYCLE()
+    {
+        c.apply(cv::gin(in_vector), cv::gout(out_vec_gapi));
+    }
+
+    fitLineTestOpenCVCompare(in_vector, distType, out_vec_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(FitLine3DVector64FPerfTest, TestPerformance)
+{
+    CompareVecs<float, 6> cmpF;
+    cv::Size sz;
+    cv::DistanceTypes distType;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, sz, distType, compile_args) = GetParam();
+
+    std::vector<cv::Point3d> in_vector;
+    initPointsVectorRandU(sz.width, in_vector);
+
+    cv::Vec6f out_vec_gapi;
+    cv::GComputation c(fitLineTestGAPI(in_vector, distType, std::move(compile_args),
+                                       out_vec_gapi));
+
+    TEST_CYCLE()
+    {
+        c.apply(cv::gin(in_vector), cv::gout(out_vec_gapi));
+    }
+
+    fitLineTestOpenCVCompare(in_vector, distType, out_vec_gapi, cmpF);
+    SANITY_CHECK_NOTHING();
+}
+
+//------------------------------------------------------------------------------
+
 PERF_TEST_P_(EqHistPerfTest, TestPerformance)
 {
     compare_f cmpF = get<0>(GetParam());

modules/gapi/perf/cpu/gapi_imgproc_perf_tests_cpu.cpp

@@ -194,6 +194,42 @@ INSTANTIATE_TEST_CASE_P(GoodFeaturesInternalPerfTestCPU, GoodFeaturesPerfTest,
             Values(true),
             Values(cv::compile_args(IMGPROC_CPU))));
 
+INSTANTIATE_TEST_CASE_P(FindContoursPerfTestCPU, FindContoursPerfTest,
+                        Combine(Values(AbsExact().to_compare_obj()),
+                                Values(CV_8UC1),
+                                Values(szVGA, sz720p, sz1080p),
+                                Values(RETR_EXTERNAL, RETR_LIST, RETR_CCOMP, RETR_TREE),
+                                Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
+                                       CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FindContours32SPerfTestCPU, FindContoursPerfTest,
+                        Combine(Values(AbsExact().to_compare_obj()),
+                                Values(CV_32SC1),
+                                Values(szVGA, sz720p, sz1080p),
+                                Values(RETR_CCOMP, RETR_FLOODFILL),
+                                Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
+                                       CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FindContoursHPerfTestCPU, FindContoursHPerfTest,
+                        Combine(Values(AbsExact().to_compare_obj()),
+                                Values(CV_8UC1),
+                                Values(szVGA, sz720p, sz1080p),
+                                Values(RETR_EXTERNAL, RETR_LIST, RETR_CCOMP, RETR_TREE),
+                                Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
+                                       CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FindContoursH32SPerfTestCPU, FindContoursHPerfTest,
+                        Combine(Values(AbsExact().to_compare_obj()),
+                                Values(CV_32SC1),
+                                Values(szVGA, sz720p, sz1080p),
+                                Values(RETR_CCOMP, RETR_FLOODFILL),
+                                Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
+                                       CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
 INSTANTIATE_TEST_CASE_P(BoundingRectMatPerfTestCPU, BoundingRectMatPerfTest,
                         Combine(Values(IoUToleranceRect(0).to_compare_obj()),
                                 Values(CV_8UC1),
@@ -218,6 +254,66 @@ INSTANTIATE_TEST_CASE_P(BoundingRectVector32FPerfTestCPU, BoundingRectVector32FP
                                 Values(szVGA, sz720p, sz1080p),
                                 Values(cv::compile_args(IMGPROC_CPU))));
 
+INSTANTIATE_TEST_CASE_P(FitLine2DMatVectorPerfTestCPU, FitLine2DMatVectorPerfTest,
+                        Combine(Values(RelDiffToleranceVec<float, 4>(0.01).to_compare_obj()),
+                                Values(CV_8U, CV_8S, CV_16U, CV_16S,
+                                       CV_32S, CV_32F, CV_64F),
+                                Values(cv::Size(8, 0), cv::Size(1024, 0)),
+                                Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
+                                       DIST_WELSCH, DIST_HUBER),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FitLine2DVector32SPerfTestCPU, FitLine2DVector32SPerfTest,
+                        Combine(Values(RelDiffToleranceVec<float, 4>(0.01).to_compare_obj()),
+                                Values(cv::Size(8, 0), cv::Size(1024, 0)),
+                                Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
+                                       DIST_WELSCH, DIST_HUBER),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FitLine2DVector32FPerfTestCPU, FitLine2DVector32FPerfTest,
+                        Combine(Values(RelDiffToleranceVec<float, 4>(0.01).to_compare_obj()),
+                                Values(cv::Size(8, 0), cv::Size(1024, 0)),
+                                Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
+                                       DIST_WELSCH, DIST_HUBER),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FitLine2DVector64FPerfTestCPU, FitLine2DVector64FPerfTest,
+                        Combine(Values(RelDiffToleranceVec<float, 4>(0.01).to_compare_obj()),
+                                Values(cv::Size(8, 0), cv::Size(1024, 0)),
+                                Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
+                                       DIST_WELSCH, DIST_HUBER),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FitLine3DMatVectorPerfTestCPU, FitLine3DMatVectorPerfTest,
+                        Combine(Values(RelDiffToleranceVec<float, 6>(0.01).to_compare_obj()),
+                                Values(CV_8U, CV_8S, CV_16U, CV_16S,
+                                       CV_32S, CV_32F, CV_64F),
+                                Values(cv::Size(8, 0), cv::Size(1024, 0)),
+                                Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
+                                       DIST_WELSCH, DIST_HUBER),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FitLine3DVector32SPerfTestCPU, FitLine3DVector32SPerfTest,
+                        Combine(Values(RelDiffToleranceVec<float, 6>(0.01).to_compare_obj()),
+                                Values(cv::Size(8, 0), cv::Size(1024, 0)),
+                                Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
+                                       DIST_WELSCH, DIST_HUBER),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FitLine3DVector32FPerfTestCPU, FitLine3DVector32FPerfTest,
+                        Combine(Values(RelDiffToleranceVec<float, 6>(0.01).to_compare_obj()),
+                                Values(cv::Size(8, 0), cv::Size(1024, 0)),
+                                Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
+                                       DIST_WELSCH, DIST_HUBER),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(FitLine3DVector64FPerfTestCPU, FitLine3DVector64FPerfTest,
+                        Combine(Values(RelDiffToleranceVec<float, 6>(0.01).to_compare_obj()),
+                                Values(cv::Size(8, 0), cv::Size(1024, 0)),
+                                Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
+                                       DIST_WELSCH, DIST_HUBER),
+                                Values(cv::compile_args(IMGPROC_CPU))));
+
 INSTANTIATE_TEST_CASE_P(EqHistPerfTestCPU, EqHistPerfTest,
     Combine(Values(AbsExact().to_compare_f()),
         Values(szVGA, sz720p, sz1080p),

modules/gapi/test/common/gapi_imgproc_tests.hpp

@@ -68,13 +68,13 @@ GAPI_TEST_FIXTURE_SPEC_PARAMS(GoodFeaturesTest,
                               blockSize, useHarrisDetector)
 GAPI_TEST_FIXTURE_SPEC_PARAMS(FindContoursNoOffsetTest,
                               FIXTURE_API(cv::Size,MatType2,cv::RetrievalModes,
-                                          cv::ContourApproximationModes),
+                                          cv::ContourApproximationModes, CompareMats),
-                              4, sz, type, mode, method)
+                              5, sz, type, mode, method, cmpF)
 GAPI_TEST_FIXTURE_SPEC_PARAMS(FindContoursOffsetTest, <>, 0)
 GAPI_TEST_FIXTURE_SPEC_PARAMS(FindContoursHNoOffsetTest,
                               FIXTURE_API(cv::Size,MatType2,cv::RetrievalModes,
-                                          cv::ContourApproximationModes),
+                                          cv::ContourApproximationModes, CompareMats),
-                              4, sz, type, mode, method)
+                              5, sz, type, mode, method, cmpF)
 GAPI_TEST_FIXTURE_SPEC_PARAMS(FindContoursHOffsetTest, <>, 0)
 GAPI_TEST_FIXTURE(BoundingRectMatTest, initNothing, FIXTURE_API(CompareRects,bool),
                   2, cmpF, initByVector)

modules/gapi/test/common/gapi_imgproc_tests_common.hpp

@@ -14,6 +14,105 @@
 
 namespace opencv_test
 {
+// Draw random ellipses on given cv::Mat of given size and type
+static void initMatForFindingContours(cv::Mat& mat, const cv::Size& sz, const int type)
+{
+    cv::RNG& rng = theRNG();
+    mat = cv::Mat(sz, type, cv::Scalar::all(0));
+    const size_t numEllipses = rng.uniform(1, 10);
+
+    for( size_t i = 0; i < numEllipses; i++ )
+    {
+        cv::Point center;
+        cv::Size  axes;
+        center.x    = rng.uniform(0, sz.width);
+        center.y    = rng.uniform(0, sz.height);
+        axes.width  = rng.uniform(2, sz.width);
+        axes.height = rng.uniform(2, sz.height);
+        const int    color = rng.uniform(1, 256);
+        const double angle = rng.uniform(0., 180.);
+        cv::ellipse(mat, center, axes, angle, 0., 360., color, 1, FILLED);
+    }
+}
+
+enum OptionalFindContoursOutput {NONE, HIERARCHY};
+
+template<OptionalFindContoursOutput optional = NONE>
+cv::GComputation findContoursTestGAPI(const cv::Mat& in, const cv::RetrievalModes mode,
+                                      const cv::ContourApproximationModes method,
+                                      cv::GCompileArgs&& args,
+                                      std::vector<std::vector<cv::Point>>& out_cnts_gapi,
+                                      std::vector<cv::Vec4i>& /*out_hier_gapi*/,
+                                      const cv::Point& offset = cv::Point())
+{
+    cv::GMat g_in;
+    cv::GOpaque<cv::Point> gOffset;
+    cv::GArray<cv::GArray<cv::Point>> outCts;
+    outCts = cv::gapi::findContours(g_in, mode, method, gOffset);
+    cv::GComputation c(GIn(g_in, gOffset), GOut(outCts));
+    c.apply(gin(in, offset), gout(out_cnts_gapi), std::move(args));
+    return c;
+}
+
+template<> cv::GComputation findContoursTestGAPI<HIERARCHY> (
+    const cv::Mat& in, const cv::RetrievalModes mode, const cv::ContourApproximationModes method,
+    cv::GCompileArgs&& args, std::vector<std::vector<cv::Point>>& out_cnts_gapi,
+    std::vector<cv::Vec4i>& out_hier_gapi, const cv::Point& offset)
+{
+    cv::GMat g_in;
+    cv::GOpaque<cv::Point> gOffset;
+    cv::GArray<cv::GArray<cv::Point>> outCts;
+    cv::GArray<cv::Vec4i> outHier;
+    std::tie(outCts, outHier) = cv::gapi::findContoursH(g_in, mode, method, gOffset);
+    cv::GComputation c(GIn(g_in, gOffset), GOut(outCts, outHier));
+    c.apply(gin(in, offset), gout(out_cnts_gapi, out_hier_gapi), std::move(args));
+    return c;
+}
+
+template<OptionalFindContoursOutput optional = NONE>
+void findContoursTestOpenCVCompare(const cv::Mat& in, const cv::RetrievalModes mode,
+                                   const cv::ContourApproximationModes method,
+                                   const std::vector<std::vector<cv::Point>>& out_cnts_gapi,
+                                   const std::vector<cv::Vec4i>&              out_hier_gapi,
+                                   const CompareMats& cmpF, const cv::Point& offset = cv::Point())
+{
+    // OpenCV code /////////////////////////////////////////////////////////////
+    std::vector<std::vector<cv::Point>> out_cnts_ocv;
+    std::vector<cv::Vec4i>              out_hier_ocv;
+    cv::findContours(in, out_cnts_ocv, out_hier_ocv, mode, method, offset);
+    // Comparison //////////////////////////////////////////////////////////////
+    EXPECT_TRUE(out_cnts_gapi.size() == out_cnts_ocv.size());
+
+    cv::Mat out_mat_ocv  = cv::Mat(cv::Size{ in.cols, in.rows }, in.type(), cv::Scalar::all(0));
+    cv::Mat out_mat_gapi = cv::Mat(cv::Size{ in.cols, in.rows }, in.type(), cv::Scalar::all(0));
+    cv::fillPoly(out_mat_ocv,  out_cnts_ocv,  cv::Scalar::all(1));
+    cv::fillPoly(out_mat_gapi, out_cnts_gapi, cv::Scalar::all(1));
+    EXPECT_TRUE(cmpF(out_mat_ocv, out_mat_gapi));
+    if (optional == HIERARCHY)
+    {
+        EXPECT_TRUE(out_hier_ocv.size() == out_hier_gapi.size());
+        EXPECT_TRUE(AbsExactVector<cv::Vec4i>().to_compare_f()(out_hier_ocv, out_hier_gapi));
+    }
+}
+
+template<OptionalFindContoursOutput optional = NONE>
+void findContoursTestBody(const cv::Size& sz, const MatType2& type, const cv::RetrievalModes mode,
+                          const cv::ContourApproximationModes method, const CompareMats& cmpF,
+                          cv::GCompileArgs&& args, const cv::Point& offset = cv::Point())
+{
+    cv::Mat in;
+    initMatForFindingContours(in, sz, type);
+
+    std::vector<std::vector<cv::Point>> out_cnts_gapi;
+    std::vector<cv::Vec4i>              out_hier_gapi;
+    findContoursTestGAPI<optional>(in, mode, method, std::move(args), out_cnts_gapi, out_hier_gapi,
+                                   offset);
+    findContoursTestOpenCVCompare<optional>(in, mode, method, out_cnts_gapi, out_hier_gapi, cmpF,
+                                            offset);
+}
+
+//-------------------------------------------------------------------------------------------------
+
 template<typename In>
 static cv::GComputation boundingRectTestGAPI(const In& in, cv::GCompileArgs&& args,
                                              cv::Rect& out_rect_gapi)
@@ -40,10 +139,59 @@ static void boundingRectTestBody(const In& in, const CompareRects& cmpF, cv::GCo
 {
     cv::Rect out_rect_gapi;
     boundingRectTestGAPI(in, std::move(args), out_rect_gapi);
-
     boundingRectTestOpenCVCompare(in, out_rect_gapi, cmpF);
 }
 
+//-------------------------------------------------------------------------------------------------
+
+template<typename In>
+static cv::GComputation fitLineTestGAPI(const In& in, const cv::DistanceTypes distType,
+                                        cv::GCompileArgs&& args, cv::Vec4f& out_vec_gapi)
+{
+    const double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
+
+    cv::detail::g_type_of_t<In> g_in;
+    auto out = cv::gapi::fitLine2D(g_in, distType, paramDefault, repsDefault, aepsDefault);
+    cv::GComputation c(cv::GIn(g_in), cv::GOut(out));
+    c.apply(cv::gin(in), cv::gout(out_vec_gapi), std::move(args));
+    return c;
+}
+
+template<typename In>
+static cv::GComputation fitLineTestGAPI(const In& in, const cv::DistanceTypes distType,
+                                        cv::GCompileArgs&& args, cv::Vec6f& out_vec_gapi)
+{
+    const double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
+
+    cv::detail::g_type_of_t<In> g_in;
+    auto out = cv::gapi::fitLine3D(g_in, distType, paramDefault, repsDefault, aepsDefault);
+    cv::GComputation c(cv::GIn(g_in), cv::GOut(out));
+    c.apply(cv::gin(in), cv::gout(out_vec_gapi), std::move(args));
+    return c;
+}
+
+template<typename In, int dim>
+static void fitLineTestOpenCVCompare(const In& in, const cv::DistanceTypes distType,
+                                     const cv::Vec<float, dim>& out_vec_gapi,
+                                     const CompareVecs<float, dim>& cmpF)
+{
+    const double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
+
+    // OpenCV code /////////////////////////////////////////////////////////////
+    cv::Vec<float, dim> out_vec_ocv;
+    cv::fitLine(in, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
+    // Comparison //////////////////////////////////////////////////////////////
+    EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
+}
+
+template<typename In, int dim>
+static void fitLineTestBody(const In& in, const cv::DistanceTypes distType,
+                            const CompareVecs<float, dim>& cmpF, cv::GCompileArgs&& args)
+{
+    cv::Vec<float, dim> out_vec_gapi;
+    fitLineTestGAPI(in, distType, std::move(args), out_vec_gapi);
+    fitLineTestOpenCVCompare(in, distType, out_vec_gapi, cmpF);
+}
 } // namespace opencv_test
 
 #endif // OPENCV_GAPI_VIDEO_TESTS_COMMON_HPP

modules/gapi/test/common/gapi_imgproc_tests_inl.hpp

@@ -52,27 +52,6 @@ namespace
             rgb2yuyv(in_line_p, out_line_p, in.cols);
         }
     }
-
-    // Draw random ellipses on given mat of given size and type
-    void initMatForFindingContours(cv::Mat& mat, const cv::Size& sz, const int type)
-    {
-        cv::RNG& rng = theRNG();
-        mat = cv::Mat(sz, type, cv::Scalar::all(0));
-        size_t numEllipses = rng.uniform(1, 10);
-
-        for( size_t i = 0; i < numEllipses; i++ )
-        {
-            cv::Point center;
-            cv::Size  axes;
-            center.x     = rng.uniform(0, sz.width);
-            center.y     = rng.uniform(0, sz.height);
-            axes.width   = rng.uniform(2, sz.width);
-            axes.height  = rng.uniform(2, sz.height);
-            int color    = rng.uniform(1, 256);
-            double angle = rng.uniform(0., 180.);
-            cv::ellipse(mat, center, axes, angle, 0., 360., color, 1, FILLED);
-        }
-    }
 }
 
 TEST_P(Filter2DTest, AccuracyTest)
@@ -495,29 +474,7 @@ TEST_P(GoodFeaturesTest, AccuracyTest)
 
 TEST_P(FindContoursNoOffsetTest, AccuracyTest)
 {
-    std::vector<std::vector<cv::Point>> outCtsOCV,  outCtsGAPI;
+    findContoursTestBody(sz, type, mode, method, cmpF, getCompileArgs());
-
-    initMatForFindingContours(in_mat1, sz, type);
-    out_mat_gapi = cv::Mat(sz, type, cv::Scalar::all(0));
-    out_mat_ocv  = cv::Mat(sz, type, cv::Scalar::all(0));
-
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::findContours(in_mat1, outCtsOCV, mode, method);
-    }
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    cv::GArray<cv::GArray<cv::Point>> outCts;
-    outCts = cv::gapi::findContours(in, mode, method);
-    cv::GComputation c(GIn(in), GOut(outCts));
-    c.apply(gin(in_mat1), gout(outCtsGAPI), getCompileArgs());
-
-    // Comparison //////////////////////////////////////////////////////////////
-    EXPECT_TRUE(outCtsGAPI.size() == outCtsOCV.size());
-    cv::fillPoly(out_mat_ocv,  outCtsOCV,  cv::Scalar::all(1));
-    cv::fillPoly(out_mat_gapi, outCtsGAPI, cv::Scalar::all(1));
-    EXPECT_TRUE(AbsExact().to_compare_f()(out_mat_ocv, out_mat_gapi));
 }
 
 TEST_P(FindContoursOffsetTest, AccuracyTest)
@@ -526,63 +483,15 @@ TEST_P(FindContoursOffsetTest, AccuracyTest)
     const MatType2 type = CV_8UC1;
     const cv::RetrievalModes mode = cv::RETR_EXTERNAL;
     const cv::ContourApproximationModes method = cv::CHAIN_APPROX_NONE;
+    const CompareMats cmpF = AbsExact().to_compare_obj();
     const cv::Point offset(15, 15);
-    std::vector<std::vector<cv::Point>> outCtsOCV,  outCtsGAPI;
 
-    initMatForFindingContours(in_mat1, sz, type);
+    findContoursTestBody(sz, type, mode, method, cmpF, getCompileArgs(), offset);
-    out_mat_gapi = cv::Mat(sz, type, cv::Scalar::all(0));
-    out_mat_ocv  = cv::Mat(sz, type, cv::Scalar::all(0));
-
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::findContours(in_mat1, outCtsOCV, mode, method, offset);
-    }
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    GOpaque<Point> gOffset;
-    cv::GArray<cv::GArray<cv::Point>> outCts;
-    outCts = cv::gapi::findContours(in, mode, method, gOffset);
-    cv::GComputation c(GIn(in, gOffset), GOut(outCts));
-    c.apply(gin(in_mat1, offset), gout(outCtsGAPI), getCompileArgs());
-
-    // Comparison //////////////////////////////////////////////////////////////
-    EXPECT_TRUE(outCtsGAPI.size() == outCtsOCV.size());
-    cv::fillPoly(out_mat_ocv,  outCtsOCV,  cv::Scalar::all(1));
-    cv::fillPoly(out_mat_gapi, outCtsGAPI, cv::Scalar::all(1));
-    EXPECT_TRUE(AbsExact().to_compare_f()(out_mat_ocv, out_mat_gapi));
 }
 
 TEST_P(FindContoursHNoOffsetTest, AccuracyTest)
 {
-    std::vector<std::vector<cv::Point>> outCtsOCV,  outCtsGAPI;
+    findContoursTestBody<HIERARCHY>(sz, type, mode, method, cmpF, getCompileArgs());
-    std::vector<cv::Vec4i>              outHierOCV, outHierGAPI;
-
-    initMatForFindingContours(in_mat1, sz, type);
-    out_mat_gapi = cv::Mat(sz, type, cv::Scalar::all(0));
-    out_mat_ocv  = cv::Mat(sz, type, cv::Scalar::all(0));
-
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::findContours(in_mat1, outCtsOCV, outHierOCV, mode, method);
-    }
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    cv::GArray<cv::GArray<cv::Point>> outCts;
-    cv::GArray<cv::Vec4i> outHier;
-    std::tie(outCts, outHier) = cv::gapi::findContoursH(in, mode, method);
-    cv::GComputation c(GIn(in), GOut(outCts, outHier));
-    c.apply(gin(in_mat1), gout(outCtsGAPI, outHierGAPI), getCompileArgs());
-
-    // Comparison //////////////////////////////////////////////////////////////
-    EXPECT_TRUE(outCtsGAPI.size() == outCtsOCV.size());
-    cv::fillPoly(out_mat_ocv,  outCtsOCV,  cv::Scalar::all(1));
-    cv::fillPoly(out_mat_gapi, outCtsGAPI, cv::Scalar::all(1));
-    EXPECT_TRUE(AbsExact().to_compare_f()(out_mat_ocv, out_mat_gapi));
-
-    EXPECT_TRUE(outCtsGAPI.size() == outCtsOCV.size());
-    EXPECT_TRUE(AbsExactVector<cv::Vec4i>().to_compare_f()(outHierOCV, outHierGAPI));
 }
 
 TEST_P(FindContoursHOffsetTest, AccuracyTest)
@@ -591,36 +500,12 @@ TEST_P(FindContoursHOffsetTest, AccuracyTest)
     const MatType2 type = CV_8UC1;
     const cv::RetrievalModes mode = cv::RETR_EXTERNAL;
     const cv::ContourApproximationModes method = cv::CHAIN_APPROX_NONE;
+    const CompareMats cmpF = AbsExact().to_compare_obj();
     const cv::Point offset(15, 15);
     std::vector<std::vector<cv::Point>> outCtsOCV,  outCtsGAPI;
     std::vector<cv::Vec4i>              outHierOCV, outHierGAPI;
 
-    initMatForFindingContours(in_mat1, sz, type);
+    findContoursTestBody<HIERARCHY>(sz, type, mode, method, cmpF, getCompileArgs(), offset);
-    out_mat_gapi = cv::Mat(sz, type, cv::Scalar::all(0));
-    out_mat_ocv  = cv::Mat(sz, type, cv::Scalar::all(0));
-
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::findContours(in_mat1, outCtsOCV, outHierOCV, mode, method, offset);
-    }
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    GOpaque<Point> gOffset;
-    cv::GArray<cv::GArray<cv::Point>> outCts;
-    cv::GArray<cv::Vec4i> outHier;
-    std::tie(outCts, outHier) = cv::gapi::findContoursH(in, mode, method, gOffset);
-    cv::GComputation c(GIn(in, gOffset), GOut(outCts, outHier));
-    c.apply(gin(in_mat1, offset), gout(outCtsGAPI, outHierGAPI), getCompileArgs());
-
-    // Comparison //////////////////////////////////////////////////////////////
-    EXPECT_TRUE(outCtsGAPI.size() == outCtsOCV.size());
-    cv::fillPoly(out_mat_ocv,  outCtsOCV,  cv::Scalar::all(1));
-    cv::fillPoly(out_mat_gapi, outCtsGAPI, cv::Scalar::all(1));
-    EXPECT_TRUE(AbsExact().to_compare_f()(out_mat_ocv, out_mat_gapi));
-
-    EXPECT_TRUE(outCtsGAPI.size() == outCtsOCV.size());
-    EXPECT_TRUE(AbsExactVector<cv::Vec4i>().to_compare_f()(outHierOCV, outHierGAPI));
 }
 
 TEST_P(BoundingRectMatTest, AccuracyTest)
@@ -655,188 +540,60 @@ TEST_P(BoundingRectVector32FTest, AccuracyTest)
 
 TEST_P(FitLine2DMatVectorTest, AccuracyTest)
 {
-    cv::Vec4f out_vec_gapi, out_vec_ocv;
+    fitLineTestBody(in_mat1, distType, cmpF, getCompileArgs());
-    double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    auto out = cv::gapi::fitLine2D(in, distType, paramDefault, repsDefault, aepsDefault);
-
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_mat1), cv::gout(out_vec_gapi), getCompileArgs());
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::fitLine(in_mat1, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
-    }
 }
 
 TEST_P(FitLine2DVector32STest, AccuracyTest)
 {
-    cv::Vec4f out_vec_gapi, out_vec_ocv;
-    double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
-
     std::vector<cv::Point2i> in_vec;
     initPointsVectorRandU(sz.width, in_vec);
 
-    // G-API code //////////////////////////////////////////////////////////////
+    fitLineTestBody(in_vec, distType, cmpF, getCompileArgs());
-    cv::GArray<cv::Point2i> in;
-    auto out = cv::gapi::fitLine2D(in, distType, paramDefault, repsDefault, aepsDefault);
-
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_vec), cv::gout(out_vec_gapi), getCompileArgs());
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::fitLine(in_vec, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
-    }
 }
 
 TEST_P(FitLine2DVector32FTest, AccuracyTest)
 {
-    cv::Vec4f out_vec_gapi, out_vec_ocv;
-    double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
-
     std::vector<cv::Point2f> in_vec;
     initPointsVectorRandU(sz.width, in_vec);
 
-    // G-API code //////////////////////////////////////////////////////////////
+    fitLineTestBody(in_vec, distType, cmpF, getCompileArgs());
-    cv::GArray<cv::Point2f> in;
-    auto out = cv::gapi::fitLine2D(in, distType, paramDefault, repsDefault, aepsDefault);
-
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_vec), cv::gout(out_vec_gapi), getCompileArgs());
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::fitLine(in_vec, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
-    }
 }
 
 TEST_P(FitLine2DVector64FTest, AccuracyTest)
 {
-    cv::Vec4f out_vec_gapi, out_vec_ocv;
-    double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
-
     std::vector<cv::Point2d> in_vec;
     initPointsVectorRandU(sz.width, in_vec);
 
-    // G-API code //////////////////////////////////////////////////////////////
+    fitLineTestBody(in_vec, distType, cmpF, getCompileArgs());
-    cv::GArray<cv::Point2d> in;
-    auto out = cv::gapi::fitLine2D(in, distType, paramDefault, repsDefault, aepsDefault);
-
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_vec), cv::gout(out_vec_gapi), getCompileArgs());
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::fitLine(in_vec, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
-    }
 }
 
 TEST_P(FitLine3DMatVectorTest, AccuracyTest)
 {
-    cv::Vec6f out_vec_gapi, out_vec_ocv;
+    fitLineTestBody(in_mat1, distType, cmpF, getCompileArgs());
-    double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    auto out = cv::gapi::fitLine3D(in, distType, paramDefault, repsDefault, aepsDefault);
-
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_mat1), cv::gout(out_vec_gapi), getCompileArgs());
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::fitLine(in_mat1, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
-    }
 }
 
 TEST_P(FitLine3DVector32STest, AccuracyTest)
 {
-    cv::Vec6f out_vec_gapi, out_vec_ocv;
-    double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
-
     std::vector<cv::Point3i> in_vec;
     initPointsVectorRandU(sz.width, in_vec);
 
-    // G-API code //////////////////////////////////////////////////////////////
+    fitLineTestBody(in_vec, distType, cmpF, getCompileArgs());
-    cv::GArray<cv::Point3i> in;
-    auto out = cv::gapi::fitLine3D(in, distType, paramDefault, repsDefault, aepsDefault);
-
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_vec), cv::gout(out_vec_gapi), getCompileArgs());
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::fitLine(in_vec, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
-    }
 }
 
 TEST_P(FitLine3DVector32FTest, AccuracyTest)
 {
-    cv::Vec6f out_vec_gapi, out_vec_ocv;
-    double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
-
     std::vector<cv::Point3f> in_vec;
     initPointsVectorRandU(sz.width, in_vec);
 
-    // G-API code //////////////////////////////////////////////////////////////
+    fitLineTestBody(in_vec, distType, cmpF, getCompileArgs());
-    cv::GArray<cv::Point3f> in;
-    auto out = cv::gapi::fitLine3D(in, distType, paramDefault, repsDefault, aepsDefault);
-
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_vec), cv::gout(out_vec_gapi), getCompileArgs());
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::fitLine(in_vec, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
-    }
 }
 
 TEST_P(FitLine3DVector64FTest, AccuracyTest)
 {
-    cv::Vec6f out_vec_gapi, out_vec_ocv;
-    double paramDefault = 0., repsDefault = 0., aepsDefault = 0.;
-
     std::vector<cv::Point3d> in_vec;
     initPointsVectorRandU(sz.width, in_vec);
 
-    // G-API code //////////////////////////////////////////////////////////////
+    fitLineTestBody(in_vec, distType, cmpF, getCompileArgs());
-    cv::GArray<cv::Point3d> in;
-    auto out = cv::gapi::fitLine3D(in, distType, paramDefault, repsDefault, aepsDefault);
-
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-    c.apply(cv::gin(in_vec), cv::gout(out_vec_gapi), getCompileArgs());
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::fitLine(in_vec, out_vec_ocv, distType, paramDefault, repsDefault, aepsDefault);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_vec_gapi, out_vec_ocv));
-    }
 }
 
 TEST_P(BGR2RGBTest, AccuracyTest)

modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp

@@ -270,7 +270,8 @@ INSTANTIATE_TEST_CASE_P(FindContoursNoOffsetTestCPU, FindContoursNoOffsetTest,
                                 Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(RETR_EXTERNAL),
-                                Values(CHAIN_APPROX_NONE)));
+                                Values(CHAIN_APPROX_NONE),
+                                Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(FindContoursOffsetTestCPU, FindContoursOffsetTest,
                         Values(IMGPROC_CPU));
@@ -282,7 +283,8 @@ INSTANTIATE_TEST_CASE_P(FindContoursHNoOffsetTestCPU, FindContoursHNoOffsetTest,
                                 Values(CV_8UC1),
                                 Values(RETR_EXTERNAL, RETR_LIST, RETR_CCOMP, RETR_TREE),
                                 Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
-                                       CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS)));
+                                       CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS),
+                                Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(FindContoursHNoOffset32STestCPU, FindContoursHNoOffsetTest,
                         Combine(Values(IMGPROC_CPU),
@@ -291,7 +293,8 @@ INSTANTIATE_TEST_CASE_P(FindContoursHNoOffset32STestCPU, FindContoursHNoOffsetTe
                                 Values(CV_32SC1),
                                 Values(RETR_CCOMP, RETR_FLOODFILL),
                                 Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
-                                       CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS)));
+                                       CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS),
+                                Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(FindContoursHOffsetTestCPU, FindContoursHOffsetTest,
                         Values(IMGPROC_CPU));