Merge branch 4.x

2026-07-30 07:43:03 +04:00 · 2021-12-30 16:23:27 +00:00
parent 80c5d18f9c 5f249a3e67
commit a0d5277e0d
951 changed files with 158314 additions and 152668 deletions
@@ -107,12 +107,6 @@ GAPI_TEST_FIXTURE(ThresholdOTTest, initMatrixRandU, FIXTURE_API(int), 1, tt)
 GAPI_TEST_FIXTURE(InRangeTest, initMatrixRandU, <>, 0)
 GAPI_TEST_FIXTURE(Split3Test, initMatrixRandU, <>, 0)
 GAPI_TEST_FIXTURE(Split4Test, initMatrixRandU, <>, 0)
-GAPI_TEST_FIXTURE(ResizeTest, initNothing, FIXTURE_API(CompareMats,int,cv::Size), 3,
-    cmpF, interp, sz_out)
-GAPI_TEST_FIXTURE(ResizePTest, initNothing, FIXTURE_API(CompareMats,int,cv::Size), 3,
-    cmpF, interp, sz_out)
-GAPI_TEST_FIXTURE(ResizeTestFxFy, initNothing, FIXTURE_API(CompareMats,int,double,double), 4,
-    cmpF, interp, fx, fy)
 GAPI_TEST_FIXTURE(Merge3Test, initMatsRandU, <>, 0)
 GAPI_TEST_FIXTURE(Merge4Test, initMatsRandU, <>, 0)
 GAPI_TEST_FIXTURE(RemapTest, initMatrixRandU, <>, 0)
@@ -138,7 +138,7 @@ TEST_P(MathOpTest, MatricesAccuracyTest)
    #else
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    #endif
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -173,7 +173,7 @@ TEST_P(MulDoubleTest, AccuracyTest)
 #else
    EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
 #endif
-    EXPECT_EQ(out_mat_gapi.size(), sz);
+    EXPECT_EQ(sz, out_mat_gapi.size());
 }

 TEST_P(DivTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pull/12826
@@ -195,7 +195,7 @@ TEST_P(DivTest, DISABLED_DivByZeroTest)  // https://github.com/opencv/opencv/pul
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -304,7 +304,7 @@ TEST_P(Polar2CartTest, AccuracyTest)
        //
        // TODO: Make threshold a configurable parameter of this test (ADE-221)

-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());

        cv::Mat &outx = out_mat_gapi,
                &outy = out_mat2;
@@ -347,7 +347,7 @@ TEST_P(Cart2PolarTest, AccuracyTest)
        //
        // TODO: Make threshold a configurable parameter of this test (ADE-221)

-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());

        cv::Mat &outm = out_mat_gapi,
                &outa = out_mat2;
@@ -406,7 +406,7 @@ TEST_P(CmpTest, AccuracyTest)

    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
    }
 }
@@ -464,7 +464,7 @@ TEST_P(BitwiseTest, AccuracyTest)

    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
 }
@@ -484,7 +484,7 @@ TEST_P(NotTest, AccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
 }
@@ -508,7 +508,7 @@ TEST_P(SelectTest, AccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
 }
@@ -528,7 +528,7 @@ TEST_P(MinTest, AccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
 }
@@ -548,7 +548,7 @@ TEST_P(MaxTest, AccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
 }
@@ -568,7 +568,7 @@ TEST_P(AbsDiffTest, AccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
 }
@@ -589,7 +589,7 @@ TEST_P(AbsDiffCTest, AccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
    }
 }
@@ -659,7 +659,7 @@ TEST_P(AddWeightedTest, AccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-    EXPECT_EQ(out_mat_gapi.size(), sz);
+    EXPECT_EQ(sz, out_mat_gapi.size());
 }

 TEST_P(NormTest, AccuracyTest)
@@ -738,7 +738,7 @@ TEST_P(ThresholdTest, AccuracyTestBinary)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_L1));
    }
 }
@@ -764,7 +764,7 @@ TEST_P(ThresholdOTTest, AccuracyTestOtsu)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(ocv_res, out_gapi_scalar.val[0]);
    }
 }
@@ -788,7 +788,7 @@ TEST_P(InRangeTest, AccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
 }
@@ -847,78 +847,6 @@ TEST_P(Split4Test, AccuracyTest)
    }
 }

-static void ResizeAccuracyTest(const CompareMats& cmpF, int type, int interp, cv::Size sz_in,
-    cv::Size sz_out, double fx, double fy, cv::GCompileArgs&& compile_args)
-{
-    cv::Mat in_mat1 (sz_in, type );
-    cv::Scalar mean = cv::Scalar::all(127);
-    cv::Scalar stddev = cv::Scalar::all(40.f);
-
-    cv::randn(in_mat1, mean, stddev);
-
-    auto out_mat_sz = sz_out.area() == 0 ? cv::Size(saturate_cast<int>(sz_in.width *fx),
-                                                    saturate_cast<int>(sz_in.height*fy))
-                                         : sz_out;
-    cv::Mat out_mat(out_mat_sz, type);
-    cv::Mat out_mat_ocv(out_mat_sz, type);
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    auto out = cv::gapi::resize(in, sz_out, fx, fy, interp);
-
-    cv::GComputation c(in, out);
-    c.apply(in_mat1, out_mat, std::move(compile_args));
-    // OpenCV code /////////////////////////////////////////////////////////////
-    {
-        cv::resize(in_mat1, out_mat_ocv, sz_out, fx, fy, interp);
-    }
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_mat, out_mat_ocv));
-    }
-}
-
-TEST_P(ResizeTest, AccuracyTest)
-{
-    ResizeAccuracyTest(cmpF, type, interp, sz, sz_out, 0.0, 0.0, getCompileArgs());
-}
-
-TEST_P(ResizeTestFxFy, AccuracyTest)
-{
-    ResizeAccuracyTest(cmpF, type, interp, sz, cv::Size{0, 0}, fx, fy, getCompileArgs());
-}
-
-TEST_P(ResizePTest, AccuracyTest)
-{
-    constexpr int planeNum = 3;
-    cv::Size sz_in_p {sz.width,  sz.height*planeNum};
-    cv::Size sz_out_p{sz_out.width, sz_out.height*planeNum};
-
-    cv::Mat in_mat(sz_in_p, CV_8UC1);
-    cv::randn(in_mat, cv::Scalar::all(127.0f), cv::Scalar::all(40.f));
-
-    cv::Mat out_mat    (sz_out_p, CV_8UC1);
-    cv::Mat out_mat_ocv_p(sz_out_p, CV_8UC1);
-
-    cv::GMatP in;
-    auto out = cv::gapi::resizeP(in, sz_out, interp);
-    cv::GComputation c(cv::GIn(in), cv::GOut(out));
-
-    c.compile(cv::descr_of(in_mat).asPlanar(planeNum), getCompileArgs())
-             (cv::gin(in_mat), cv::gout(out_mat));
-
-    for (int i = 0; i < planeNum; i++) {
-        const cv::Mat in_mat_roi = in_mat(cv::Rect(0, i*sz.height,  sz.width,  sz.height));
-        cv::Mat out_mat_roi = out_mat_ocv_p(cv::Rect(0, i*sz_out.height, sz_out.width, sz_out.height));
-        cv::resize(in_mat_roi, out_mat_roi, sz_out, 0, 0, interp);
-    }
-
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_mat, out_mat_ocv_p));
-    }
-}
-
 TEST_P(Merge3Test, AccuracyTest)
 {
    cv::Mat in_mat3(sz, type);
@@ -992,7 +920,7 @@ TEST_P(RemapTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1011,7 +939,7 @@ TEST_P(FlipTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1037,7 +965,7 @@ TEST_P(CropTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
-        EXPECT_EQ(out_mat_gapi.size(), sz_out);
+        EXPECT_EQ(sz_out, out_mat_gapi.size());
    }
 }

@@ -1063,7 +991,7 @@ TEST_P(CopyTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
-        EXPECT_EQ(out_mat_gapi.size(), sz_out);
+        EXPECT_EQ(sz_out, out_mat_gapi.size());
    }
 }

@@ -1245,7 +1173,7 @@ TEST_P(LUTTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1269,7 +1197,7 @@ TEST_P(ConvertToTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1378,7 +1306,7 @@ TEST_P(NormalizeTest, Test)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1654,7 +1582,7 @@ TEST_P(ReInitOutTest, TestWithAdd)

        // Comparison //////////////////////////////////////////////////////////////
        EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    };

    // run for uninitialized output
@@ -1738,7 +1666,7 @@ TEST_P(SizeTest, ParseTest)
    cv::GComputation c(cv::GIn(in), cv::GOut(out));
    c.apply(cv::gin(in_mat1), cv::gout(out_sz), getCompileArgs());

-    EXPECT_EQ(out_sz, sz);
+    EXPECT_EQ(sz, out_sz);
 }

 TEST_P(SizeRTest, ParseTest)
@@ -1751,7 +1679,7 @@ TEST_P(SizeRTest, ParseTest)
    cv::GComputation c(cv::GIn(op_rect), cv::GOut(out));
    c.apply(cv::gin(rect), cv::gout(out_sz), getCompileArgs());

-    EXPECT_EQ(out_sz, sz);
+    EXPECT_EQ(sz, out_sz);
 }

 namespace {
@@ -1784,7 +1712,7 @@ TEST_P(SizeMFTest, ParseTest)
    cv::GComputation c(cv::GIn(in), cv::GOut(out));
    c.apply(cv::gin(frame), cv::gout(out_sz), getCompileArgs());

-    EXPECT_EQ(out_sz, sz);
+    EXPECT_EQ(sz, out_sz);
 }

 } // opencv_test
@@ -119,6 +119,12 @@ GAPI_TEST_FIXTURE(YUV2BGRTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmp
 GAPI_TEST_FIXTURE(RGB2HSVTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF)
 GAPI_TEST_FIXTURE(BayerGR2RGBTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF)
 GAPI_TEST_FIXTURE(RGB2YUV422Test, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF)
+GAPI_TEST_FIXTURE(ResizeTest, initNothing, FIXTURE_API(CompareMats,int,cv::Size), 3,
+    cmpF, interp, sz_out)
+GAPI_TEST_FIXTURE(ResizePTest, initNothing, FIXTURE_API(CompareMats,int,cv::Size), 3,
+    cmpF, interp, sz_out)
+GAPI_TEST_FIXTURE(ResizeTestFxFy, initNothing, FIXTURE_API(CompareMats,int,double,double), 4,
+    cmpF, interp, fx, fy)
 } // opencv_test

 #endif //OPENCV_GAPI_IMGPROC_TESTS_HPP
@@ -92,7 +92,7 @@ TEST_P(Filter2DTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -116,7 +116,7 @@ TEST_P(BoxFilterTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -142,7 +142,7 @@ TEST_P(SepFilterTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -163,7 +163,7 @@ TEST_P(BlurTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -185,7 +185,7 @@ TEST_P(GaussianBlurTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -204,7 +204,7 @@ TEST_P(MedianBlurTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -225,7 +225,7 @@ TEST_P(ErodeTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -246,7 +246,7 @@ TEST_P(Erode3x3Test, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -267,7 +267,7 @@ TEST_P(DilateTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -288,7 +288,7 @@ TEST_P(Dilate3x3Test, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -311,7 +311,7 @@ TEST_P(MorphologyExTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -330,7 +330,7 @@ TEST_P(SobelTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -362,8 +362,8 @@ TEST_P(SobelXYTest, AccuracyTest)
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
        EXPECT_TRUE(cmpF(out_mat_gapi2, out_mat_ocv2));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
-        EXPECT_EQ(out_mat_gapi2.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
+        EXPECT_EQ(sz, out_mat_gapi2.size());
    }
 }

@@ -383,7 +383,7 @@ TEST_P(LaplacianTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -402,7 +402,7 @@ TEST_P(BilateralFilterTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -421,7 +421,7 @@ TEST_P(EqHistTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -440,7 +440,7 @@ TEST_P(CannyTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -611,7 +611,7 @@ TEST_P(BGR2RGBTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -630,7 +630,7 @@ TEST_P(RGB2GrayTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -649,7 +649,7 @@ TEST_P(BGR2GrayTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -668,7 +668,7 @@ TEST_P(RGB2YUVTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -687,7 +687,7 @@ TEST_P(YUV2RGBTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -706,7 +706,7 @@ TEST_P(BGR2I420Test, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), Size(sz.width, sz.height * 3 / 2));
+        EXPECT_EQ(Size(sz.width, sz.height * 3 / 2), out_mat_gapi.size());
    }
 }

@@ -725,7 +725,7 @@ TEST_P(RGB2I420Test, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), Size(sz.width, sz.height * 3 / 2));
+        EXPECT_EQ(Size(sz.width, sz.height * 3 / 2), out_mat_gapi.size());
    }
 }

@@ -744,7 +744,7 @@ TEST_P(I4202BGRTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), Size(sz.width, sz.height * 2 / 3));
+        EXPECT_EQ(Size(sz.width, sz.height * 2 / 3), out_mat_gapi.size());
    }
 }

@@ -763,7 +763,7 @@ TEST_P(I4202RGBTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), Size(sz.width, sz.height * 2 / 3));
+        EXPECT_EQ(Size(sz.width, sz.height * 2 / 3), out_mat_gapi.size());
    }
 }

@@ -787,7 +787,7 @@ TEST_P(NV12toRGBTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -811,7 +811,7 @@ TEST_P(NV12toBGRTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -839,7 +839,7 @@ TEST_P(NV12toGrayTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -882,7 +882,7 @@ TEST_P(NV12toRGBpTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi_planar, out_mat_ocv_planar));
-        EXPECT_EQ(out_mat_gapi_planar.size(), sz_p);
+        EXPECT_EQ(sz_p, out_mat_gapi_planar.size());
    }
 }

@@ -912,7 +912,7 @@ TEST_P(NV12toBGRpTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi_planar, out_mat_ocv_planar));
-        EXPECT_EQ(out_mat_gapi_planar.size(), sz_p);
+        EXPECT_EQ(sz_p, out_mat_gapi_planar.size());
    }
 }

@@ -931,7 +931,7 @@ TEST_P(RGB2LabTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -950,7 +950,7 @@ TEST_P(BGR2LUVTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -969,7 +969,7 @@ TEST_P(LUV2BGRTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -988,7 +988,7 @@ TEST_P(BGR2YUVTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1007,7 +1007,7 @@ TEST_P(YUV2BGRTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1026,7 +1026,7 @@ TEST_P(RGB2HSVTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1045,7 +1045,7 @@ TEST_P(BayerGR2RGBTest, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }

@@ -1064,9 +1064,82 @@ TEST_P(RGB2YUV422Test, AccuracyTest)
    // Comparison //////////////////////////////////////////////////////////////
    {
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-        EXPECT_EQ(out_mat_gapi.size(), sz);
+        EXPECT_EQ(sz, out_mat_gapi.size());
    }
 }
+
+static void ResizeAccuracyTest(const CompareMats& cmpF, int type, int interp, cv::Size sz_in,
+    cv::Size sz_out, double fx, double fy, cv::GCompileArgs&& compile_args)
+{
+    cv::Mat in_mat1 (sz_in, type );
+    cv::Scalar mean = cv::Scalar::all(127);
+    cv::Scalar stddev = cv::Scalar::all(40.f);
+
+    cv::randn(in_mat1, mean, stddev);
+
+    auto out_mat_sz = sz_out.area() == 0 ? cv::Size(saturate_cast<int>(sz_in.width *fx),
+                                                    saturate_cast<int>(sz_in.height*fy))
+                                         : sz_out;
+    cv::Mat out_mat(out_mat_sz, type);
+    cv::Mat out_mat_ocv(out_mat_sz, type);
+
+    // G-API code //////////////////////////////////////////////////////////////
+    cv::GMat in;
+    auto out = cv::gapi::resize(in, sz_out, fx, fy, interp);
+
+    cv::GComputation c(in, out);
+    c.apply(in_mat1, out_mat, std::move(compile_args));
+    // OpenCV code /////////////////////////////////////////////////////////////
+    {
+        cv::resize(in_mat1, out_mat_ocv, sz_out, fx, fy, interp);
+    }
+    // Comparison //////////////////////////////////////////////////////////////
+    {
+        EXPECT_TRUE(cmpF(out_mat, out_mat_ocv));
+    }
+}
+
+TEST_P(ResizeTest, AccuracyTest)
+{
+    ResizeAccuracyTest(cmpF, type, interp, sz, sz_out, 0.0, 0.0, getCompileArgs());
+}
+
+TEST_P(ResizeTestFxFy, AccuracyTest)
+{
+    ResizeAccuracyTest(cmpF, type, interp, sz, cv::Size{0, 0}, fx, fy, getCompileArgs());
+}
+
+TEST_P(ResizePTest, AccuracyTest)
+{
+    constexpr int planeNum = 3;
+    cv::Size sz_in_p {sz.width,  sz.height*planeNum};
+    cv::Size sz_out_p{sz_out.width, sz_out.height*planeNum};
+
+    cv::Mat in_mat(sz_in_p, CV_8UC1);
+    cv::randn(in_mat, cv::Scalar::all(127.0f), cv::Scalar::all(40.f));
+
+    cv::Mat out_mat    (sz_out_p, CV_8UC1);
+    cv::Mat out_mat_ocv_p(sz_out_p, CV_8UC1);
+
+    cv::GMatP in;
+    auto out = cv::gapi::resizeP(in, sz_out, interp);
+    cv::GComputation c(cv::GIn(in), cv::GOut(out));
+
+    c.compile(cv::descr_of(in_mat).asPlanar(planeNum), getCompileArgs())
+             (cv::gin(in_mat), cv::gout(out_mat));
+
+    for (int i = 0; i < planeNum; i++) {
+        const cv::Mat in_mat_roi = in_mat(cv::Rect(0, i*sz.height,  sz.width,  sz.height));
+        cv::Mat out_mat_roi = out_mat_ocv_p(cv::Rect(0, i*sz_out.height, sz_out.width, sz_out.height));
+        cv::resize(in_mat_roi, out_mat_roi, sz_out, 0, 0, interp);
+    }
+
+    // Comparison //////////////////////////////////////////////////////////////
+    {
+        EXPECT_TRUE(cmpF(out_mat, out_mat_ocv_p));
+    }
+}
+
 } // opencv_test

 #endif //OPENCV_GAPI_IMGPROC_TESTS_INL_HPP
@@ -36,7 +36,7 @@ TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest )

    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
    }
 }
@@ -63,7 +63,7 @@ TEST_P(MathOperatorMatMatTest, OperatorAccuracyTest )

    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
    }
 }
@@ -83,7 +83,7 @@ TEST_P(NotOperatorTest, OperatorAccuracyTest)
    }
    // Comparison //////////////////////////////////////////////////////////////
    {
-        ASSERT_EQ(out_mat_gapi.size(), sz);
+        ASSERT_EQ(sz, out_mat_gapi.size());
        EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
    }
 }
@@ -0,0 +1,86 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_STREAMING_TESTS_COMMON_HPP
+#define OPENCV_GAPI_STREAMING_TESTS_COMMON_HPP
+
+#include "gapi_tests_common.hpp"
+#include <opencv2/gapi/streaming/onevpl/source.hpp>
+#include <opencv2/gapi/streaming/onevpl/data_provider_interface.hpp>
+#include "streaming/onevpl/data_provider_defines.hpp"
+
+#ifdef HAVE_ONEVPL
+#include "streaming/onevpl/onevpl_export.hpp"
+
+namespace opencv_test {
+namespace streaming {
+namespace onevpl {
+
+struct StreamDataProvider : public cv::gapi::wip::onevpl::IDataProvider {
+
+    StreamDataProvider(std::istream& in) : data_stream (in) {
+        EXPECT_TRUE(in);
+    }
+
+mfx_codec_id_type get_mfx_codec_id() const override {
+        return MFX_CODEC_HEVC;
+    }
+
+    bool fetch_bitstream_data(std::shared_ptr<mfx_bitstream> &out_bitstream) override {
+        if (empty()) {
+            return false;
+        }
+
+        if (!out_bitstream) {
+            out_bitstream = std::make_shared<mfx_bitstream>();
+            out_bitstream->MaxLength = 2000000;
+            out_bitstream->Data = (mfxU8 *)calloc(out_bitstream->MaxLength, sizeof(mfxU8));
+            if(!out_bitstream->Data) {
+                throw std::runtime_error("Cannot allocate bitstream.Data bytes: " +
+                                         std::to_string(out_bitstream->MaxLength * sizeof(mfxU8)));
+            }
+            out_bitstream->CodecId = get_mfx_codec_id();
+        }
+
+        mfxU8 *p0 = out_bitstream->Data;
+        mfxU8 *p1 = out_bitstream->Data + out_bitstream->DataOffset;
+        EXPECT_FALSE(out_bitstream->DataOffset > out_bitstream->MaxLength - 1);
+        EXPECT_FALSE(out_bitstream->DataLength + out_bitstream->DataOffset > out_bitstream->MaxLength);
+
+        std::copy_n(p1, out_bitstream->DataLength, p0);
+
+        out_bitstream->DataOffset = 0;
+        out_bitstream->DataLength += static_cast<mfxU32>(fetch_data(out_bitstream->MaxLength - out_bitstream->DataLength,
+                                                         out_bitstream->Data + out_bitstream->DataLength));
+        return out_bitstream->DataLength != 0;
+    }
+
+    size_t fetch_data(size_t out_data_size, void* out_data_buf) {
+        data_stream.read(reinterpret_cast<char*>(out_data_buf), out_data_size);
+        return data_stream.gcount();
+    }
+    bool empty() const override {
+        return data_stream.eof() || data_stream.bad();
+    }
+private:
+    std::istream& data_stream;
+};
+
+static const unsigned char hevc_header[] = {
+ 0x00, 0x00, 0x00, 0x01, 0x40, 0x01, 0x0C, 0x06, 0xFF, 0xFF, 0x01, 0x40, 0x00,
+ 0x00, 0x03, 0x00, 0x80, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x78, 0x00,
+ 0x00, 0x04, 0x02, 0x10, 0x30, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x03,
+ 0x01, 0xE5, 0x00, 0x00, 0x00, 0x01, 0x42, 0x01, 0x06, 0x01, 0x40, 0x00, 0x00,
+ 0x03, 0x00, 0x80, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x78, 0x00, 0x00,
+ 0xA0, 0x10, 0x20, 0x61, 0x63, 0x41, 0x00, 0x86, 0x49, 0x1B, 0x2B, 0x20, 0x00,
+ 0x00, 0x00, 0x01, 0x44, 0x01, 0xC0, 0x71, 0xC0, 0xD9, 0x20, 0x00, 0x00, 0x00,
+ 0x01, 0x26, 0x01, 0xAF, 0x0C
+};
+} // namespace onevpl
+} // namespace streaming
+} // namespace opencv_test
+#endif // HAVE_ONEVPL
+#endif // OPENCV_GAPI_STREAMING_TESTS_HPP
@@ -58,40 +58,6 @@ namespace
        return o;
    }

-    inline bool initTestDataPathSilent()
-    {
-#ifndef WINRT
-        static bool initialized = false;
-        if (!initialized)
-        {
-            // Since G-API has no own test data (yet), it is taken from the common space
-            const char* testDataPath = getenv("OPENCV_TEST_DATA_PATH");
-            if (testDataPath != nullptr) {
-                cvtest::addDataSearchPath(testDataPath);
-                initialized = true;
-            }
-        }
-
-        return initialized;
-#endif // WINRT
-    }
-
-    inline void initTestDataPath()
-    {
-        bool initialized = initTestDataPathSilent();
-        GAPI_Assert(initialized &&
-            "OPENCV_TEST_DATA_PATH environment variable is either not set or set incorrectly.");
-    }
-
-    inline void initTestDataPathOrSkip()
-    {
-        bool initialized = initTestDataPathSilent();
-        if (!initialized)
-        {
-            throw cvtest::SkipTestException("Can't find test data");
-        }
-    }
-
    template <typename T> inline void initPointRandU(cv::RNG &rng, cv::Point_<T>& pt)
    {
        GAPI_Assert(std::is_integral<T>::value);
@@ -299,7 +265,6 @@ public:

    void initMatFromImage(int type, const std::string& fileName)
    {
-        initTestDataPath();

        int channels = (type >> CV_CN_SHIFT) + 1;
        GAPI_Assert(channels == 1 || channels == 3 || channels == 4);
@@ -323,7 +288,6 @@ public:

    void initMatsFromImages(int channels, const std::string& pattern, int imgNum)
    {
-        initTestDataPath();
        GAPI_Assert(channels == 1 || channels == 3 || channels == 4);
        const int flags = (channels == 1) ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR;

@@ -78,7 +78,7 @@ TEST_P(BuildPyr_CalcOptFlow_PipelineTest, AccuracyTest)

    auto customKernel  = gapi::kernels<GCPUMinScalar>();
    auto kernels       = gapi::combine(customKernel,
-                                       params.compileArgs[0].get<gapi::GKernelPackage>());
+                                       params.compileArgs[0].get<GKernelPackage>());
    params.compileArgs = compile_args(kernels);

    OptFlowLKTestOutput outOCV  { outPtsOCV,  outStatusOCV,  outErrOCV };
@@ -92,8 +92,6 @@ TEST_P(BuildPyr_CalcOptFlow_PipelineTest, AccuracyTest)
 #ifdef HAVE_OPENCV_VIDEO
 TEST_P(BackgroundSubtractorTest, AccuracyTest)
 {
-    initTestDataPath();
-
    cv::gapi::video::BackgroundSubtractorType opType;
    double thr = -1;
    std::tie(opType, thr) = typeAndThreshold;