Merge pull request #21475 from alexgiving:atrutnev/fix_tests

GAPI: Replace resize perf test to imgproc

* resize + test configs

* fluid kernel "add"

* Add fluid core

modules/gapi/perf/common/gapi_core_perf_tests.hpp

@@ -78,10 +78,6 @@ namespace opencv_test
     class KMeans2DPerfTest : public TestPerfParams<tuple<int, int, cv::KmeansFlags, cv::GCompileArgs>> {};
     class KMeans3DPerfTest : public TestPerfParams<tuple<int, int, cv::KmeansFlags, cv::GCompileArgs>> {};
     class TransposePerfTest : public TestPerfParams<tuple<compare_f, cv::Size, MatType, cv::GCompileArgs>> {};
-    class ResizePerfTest : public TestPerfParams<tuple<compare_f, MatType, int, cv::Size, cv::Size, cv::GCompileArgs>> {};
-    class BottleneckKernelsConstInputPerfTest : public TestPerfParams<tuple<compare_f, std::string, cv::GCompileArgs>> {};
-    class ResizeFxFyPerfTest : public TestPerfParams<tuple<compare_f, MatType, int, cv::Size, double, double, cv::GCompileArgs>> {};
-    class ResizeInSimpleGraphPerfTest : public TestPerfParams<tuple<compare_f, MatType, cv::Size, double, double,  cv::GCompileArgs>> {};
     class ParseSSDBLPerfTest : public TestPerfParams<tuple<cv::Size, float, int, cv::GCompileArgs>>, public ParserSSDTest {};
     class ParseSSDPerfTest   : public TestPerfParams<tuple<cv::Size, float, bool, bool, cv::GCompileArgs>>, public ParserSSDTest {};
     class ParseYoloPerfTest  : public TestPerfParams<tuple<cv::Size, float, float, int, cv::GCompileArgs>>, public ParserYoloTest {};

modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp

@@ -2282,187 +2282,6 @@ PERF_TEST_P_(TransposePerfTest, TestPerformance)
 
 //------------------------------------------------------------------------------
 
-PERF_TEST_P_(ResizePerfTest, TestPerformance)
-{
-    compare_f cmpF;
-    MatType type = -1;
-    int interp = 1;
-    cv::Size sz;
-    cv::Size sz_out;
-    cv::GCompileArgs compile_args;
-    std::tie(cmpF, type, interp, sz, sz_out, compile_args) = GetParam();
-
-    in_mat1 = cv::Mat(sz, type);
-    cv::Scalar mean = cv::Scalar::all(127);
-    cv::Scalar stddev = cv::Scalar::all(40.f);
-    cv::randn(in_mat1, mean, stddev);
-    out_mat_gapi = cv::Mat(sz_out, type);
-    out_mat_ocv = cv::Mat(sz_out, type);
-
-    // OpenCV code ///////////////////////////////////////////////////////////
-    cv::resize(in_mat1, out_mat_ocv, sz_out, 0.0, 0.0, interp);
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    auto out = cv::gapi::resize(in, sz_out, 0.0, 0.0, interp);
-    cv::GComputation c(in, out);
-
-    // Warm-up graph engine:
-    auto cc = c.compile(descr_of(gin(in_mat1)),
-                        std::move(compile_args));
-    cc(gin(in_mat1), gout(out_mat_gapi));
-
-    TEST_CYCLE()
-    {
-        cc(gin(in_mat1), gout(out_mat_gapi));
-    }
-
-    // Comparison ////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-    }
-
-    SANITY_CHECK_NOTHING();
-}
-
-//------------------------------------------------------------------------------
-
-PERF_TEST_P_(ResizeFxFyPerfTest, TestPerformance)
-{
-    compare_f cmpF;
-    MatType type = -1;
-    int interp = 1;
-    cv::Size sz;
-    double fx = 1.0;
-    double fy = 1.0;
-    cv::GCompileArgs compile_args;
-    std::tie(cmpF, type, interp, sz, fx, fy, compile_args) = GetParam();
-
-    in_mat1 = cv::Mat(sz, type);
-    cv::Scalar mean = cv::Scalar::all(127);
-    cv::Scalar stddev = cv::Scalar::all(40.f);
-    cv::randn(in_mat1, mean, stddev);
-    cv::Size sz_out = cv::Size();
-    out_mat_gapi = cv::Mat(sz_out, type);
-    out_mat_ocv = cv::Mat(sz_out, type);
-
-    // OpenCV code ///////////////////////////////////////////////////////////
-    cv::resize(in_mat1, out_mat_ocv, sz_out, fx, fy, interp);
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    auto out = cv::gapi::resize(in, sz_out, fx, fy, interp);
-    cv::GComputation c(in, out);
-
-    // Warm-up graph engine:
-    auto cc = c.compile(descr_of(gin(in_mat1)),
-                        std::move(compile_args));
-    cc(gin(in_mat1), gout(out_mat_gapi));
-
-    TEST_CYCLE()
-    {
-        cc(gin(in_mat1), gout(out_mat_gapi));
-    }
-    // Comparison ////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-    }
-
-    SANITY_CHECK_NOTHING();
-}
-
-//------------------------------------------------------------------------------
-
-// This test cases were created to control performance result of test scenario mentioned here:
-// https://stackoverflow.com/questions/60629331/opencv-gapi-performance-not-good-as-expected
-
-PERF_TEST_P_(BottleneckKernelsConstInputPerfTest, TestPerformance)
-{
-    compare_f cmpF;
-    std::string fileName = "";
-    cv::GCompileArgs compile_args;
-    double fx = 0.5;
-    double fy = 0.5;
-    std::tie(cmpF, fileName, compile_args) = GetParam();
-
-    in_mat1 = cv::imread(findDataFile(fileName));
-
-    cv::Mat cvvga;
-    cv::Mat cvgray;
-    cv::Mat cvblurred;
-
-    cv::resize(in_mat1, cvvga, cv::Size(), fx, fy);
-    cv::cvtColor(cvvga, cvgray, cv::COLOR_BGR2GRAY);
-    cv::blur(cvgray, cvblurred, cv::Size(3, 3));
-    cv::Canny(cvblurred, out_mat_ocv, 32, 128, 3);
-
-    cv::GMat in;
-    cv::GMat vga = cv::gapi::resize(in, cv::Size(), fx, fy, INTER_LINEAR);
-    cv::GMat gray = cv::gapi::BGR2Gray(vga);
-    cv::GMat blurred = cv::gapi::blur(gray, cv::Size(3, 3));
-    cv::GMat out = cv::gapi::Canny(blurred, 32, 128, 3);
-    cv::GComputation ac(in, out);
-
-    auto cc = ac.compile(descr_of(gin(in_mat1)),
-        std::move(compile_args));
-    cc(gin(in_mat1), gout(out_mat_gapi));
-
-    TEST_CYCLE()
-    {
-        cc(gin(in_mat1), gout(out_mat_gapi));
-    }
-
-    // Comparison ////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-    }
-
-    SANITY_CHECK_NOTHING();
-}
-
-//------------------------------------------------------------------------------
-
-PERF_TEST_P_(ResizeInSimpleGraphPerfTest, TestPerformance)
-{
-    compare_f cmpF;
-    MatType type = -1;
-    cv::Size sz;
-    double fx = 0.5;
-    double fy = 0.5;
-    cv::GCompileArgs compile_args;
-    std::tie(cmpF, type, sz, fx, fy, compile_args) = GetParam();
-
-    initMatsRandU(type, sz, type, false);
-
-    cv::Mat add_res_ocv;
-
-    cv::add(in_mat1, in_mat2, add_res_ocv);
-    cv::resize(add_res_ocv, out_mat_ocv, cv::Size(), fx, fy);
-
-    cv::GMat in1, in2;
-    cv::GMat add_res_gapi = cv::gapi::add(in1, in2);
-    cv::GMat out = cv::gapi::resize(add_res_gapi, cv::Size(), fx, fy, INTER_LINEAR);
-    cv::GComputation ac(GIn(in1, in2), GOut(out));
-
-    auto cc = ac.compile(descr_of(gin(in_mat1, in_mat2)),
-                         std::move(compile_args));
-    cc(gin(in_mat1, in_mat2), gout(out_mat_gapi));
-
-    TEST_CYCLE()
-    {
-        cc(gin(in_mat1, in_mat2), gout(out_mat_gapi));
-    }
-
-    // Comparison ////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-    }
-
-    SANITY_CHECK_NOTHING();
-}
-
-//------------------------------------------------------------------------------
-
 PERF_TEST_P_(ParseSSDBLPerfTest, TestPerformance)
 {
     cv::Size sz;

modules/gapi/perf/common/gapi_imgproc_perf_tests.hpp

@@ -99,6 +99,10 @@ class YUV2BGRPerfTest     : public TestPerfParams<tuple<compare_f, cv::Size, cv:
 class RGB2HSVPerfTest     : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
 class BayerGR2RGBPerfTest : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
 class RGB2YUV422PerfTest  : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
+class ResizePerfTest      : public TestPerfParams<tuple<compare_f, MatType, int, cv::Size, cv::Size, cv::GCompileArgs>> {};
+class ResizeFxFyPerfTest  : public TestPerfParams<tuple<compare_f, MatType, int, cv::Size, double, double, cv::GCompileArgs>> {};
+class ResizeInSimpleGraphPerfTest : public TestPerfParams<tuple<compare_f, MatType, cv::Size, double, double,  cv::GCompileArgs>> {};
+class BottleneckKernelsConstInputPerfTest : public TestPerfParams<tuple<compare_f, std::string, cv::GCompileArgs>> {};
 } // opencv_test
 
 #endif //OPENCV_GAPI_IMGPROC_PERF_TESTS_HPP

modules/gapi/perf/common/gapi_imgproc_perf_tests_inl.hpp

@@ -1761,5 +1761,187 @@ PERF_TEST_P_(RGB2YUV422PerfTest, TestPerformance)
 
 //------------------------------------------------------------------------------
 
+PERF_TEST_P_(ResizePerfTest, TestPerformance)
+{
+    compare_f cmpF;
+    MatType type = -1;
+    int interp = 1;
+    cv::Size sz;
+    cv::Size sz_out;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, type, interp, sz, sz_out, compile_args) = GetParam();
+
+    in_mat1 = cv::Mat(sz, type);
+    cv::Scalar mean = cv::Scalar::all(127);
+    cv::Scalar stddev = cv::Scalar::all(40.f);
+    cv::randn(in_mat1, mean, stddev);
+    out_mat_gapi = cv::Mat(sz_out, type);
+    out_mat_ocv = cv::Mat(sz_out, type);
+
+    // OpenCV code ///////////////////////////////////////////////////////////
+    cv::resize(in_mat1, out_mat_ocv, sz_out, 0.0, 0.0, interp);
+
+    // G-API code //////////////////////////////////////////////////////////////
+    cv::GMat in;
+    auto out = cv::gapi::resize(in, sz_out, 0.0, 0.0, interp);
+    cv::GComputation c(in, out);
+
+    // Warm-up graph engine:
+    auto cc = c.compile(descr_of(gin(in_mat1)),
+                        std::move(compile_args));
+    cc(gin(in_mat1), gout(out_mat_gapi));
+
+    TEST_CYCLE()
+    {
+        cc(gin(in_mat1), gout(out_mat_gapi));
+    }
+
+    // Comparison ////////////////////////////////////////////////////////////
+    {
+        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+//------------------------------------------------------------------------------
+
+PERF_TEST_P_(ResizeFxFyPerfTest, TestPerformance)
+{
+    compare_f cmpF;
+    MatType type = -1;
+    int interp = 1;
+    cv::Size sz;
+    double fx = 1.0;
+    double fy = 1.0;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, type, interp, sz, fx, fy, compile_args) = GetParam();
+
+    in_mat1 = cv::Mat(sz, type);
+    cv::Scalar mean = cv::Scalar::all(127);
+    cv::Scalar stddev = cv::Scalar::all(40.f);
+    cv::randn(in_mat1, mean, stddev);
+    cv::Size sz_out = cv:: Size(saturate_cast<int>(sz.width*fx), saturate_cast<int>(sz.height*fy));
+    out_mat_gapi = cv::Mat(sz_out, type);
+    out_mat_ocv = cv::Mat(sz_out, type);
+
+    // OpenCV code ///////////////////////////////////////////////////////////
+    cv::resize(in_mat1, out_mat_ocv, sz_out, fx, fy, interp);
+
+    // G-API code //////////////////////////////////////////////////////////////
+    cv::GMat in;
+    auto out = cv::gapi::resize(in, sz_out, fx, fy, interp);
+    cv::GComputation c(in, out);
+
+    // Warm-up graph engine:
+    auto cc = c.compile(descr_of(gin(in_mat1)),
+                        std::move(compile_args));
+    cc(gin(in_mat1), gout(out_mat_gapi));
+
+    TEST_CYCLE()
+    {
+        cc(gin(in_mat1), gout(out_mat_gapi));
+    }
+
+    // Comparison ////////////////////////////////////////////////////////////
+    {
+        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+//------------------------------------------------------------------------------
+
+PERF_TEST_P_(ResizeInSimpleGraphPerfTest, TestPerformance)
+{
+    compare_f cmpF;
+    MatType type = -1;
+    cv::Size sz;
+    double fx = 0.5;
+    double fy = 0.5;
+    cv::GCompileArgs compile_args;
+    std::tie(cmpF, type, sz, fx, fy, compile_args) = GetParam();
+
+    initMatsRandU(type, sz, type, false);
+
+    cv::Mat add_res_ocv;
+
+    cv::add(in_mat1, in_mat2, add_res_ocv);
+    cv::resize(add_res_ocv, out_mat_ocv, cv::Size(), fx, fy);
+
+    cv::GMat in1, in2;
+    cv::GMat add_res_gapi = cv::gapi::add(in1, in2);
+    cv::GMat out = cv::gapi::resize(add_res_gapi, cv::Size(), fx, fy, INTER_LINEAR);
+    cv::GComputation ac(GIn(in1, in2), GOut(out));
+
+    auto cc = ac.compile(descr_of(gin(in_mat1, in_mat2)),
+                         std::move(compile_args));
+    cc(gin(in_mat1, in_mat2), gout(out_mat_gapi));
+
+    TEST_CYCLE()
+    {
+        cc(gin(in_mat1, in_mat2), gout(out_mat_gapi));
+    }
+
+    // Comparison ////////////////////////////////////////////////////////////
+    {
+        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+//------------------------------------------------------------------------------
+
+// This test cases were created to control performance result of test scenario mentioned here:
+// https://stackoverflow.com/questions/60629331/opencv-gapi-performance-not-good-as-expected
+
+PERF_TEST_P_(BottleneckKernelsConstInputPerfTest, TestPerformance)
+{
+    compare_f cmpF;
+    std::string fileName = "";
+    cv::GCompileArgs compile_args;
+    double fx = 0.5;
+    double fy = 0.5;
+    std::tie(cmpF, fileName, compile_args) = GetParam();
+
+    in_mat1 = cv::imread(findDataFile(fileName));
+
+    cv::Mat cvvga;
+    cv::Mat cvgray;
+    cv::Mat cvblurred;
+
+    cv::resize(in_mat1, cvvga, cv::Size(), fx, fy);
+    cv::cvtColor(cvvga, cvgray, cv::COLOR_BGR2GRAY);
+    cv::blur(cvgray, cvblurred, cv::Size(3, 3));
+    cv::Canny(cvblurred, out_mat_ocv, 32, 128, 3);
+
+    cv::GMat in;
+    cv::GMat vga = cv::gapi::resize(in, cv::Size(), fx, fy, INTER_LINEAR);
+    cv::GMat gray = cv::gapi::BGR2Gray(vga);
+    cv::GMat blurred = cv::gapi::blur(gray, cv::Size(3, 3));
+    cv::GMat out = cv::gapi::Canny(blurred, 32, 128, 3);
+    cv::GComputation ac(in, out);
+
+    auto cc = ac.compile(descr_of(gin(in_mat1)),
+        std::move(compile_args));
+    cc(gin(in_mat1), gout(out_mat_gapi));
+
+    TEST_CYCLE()
+    {
+        cc(gin(in_mat1), gout(out_mat_gapi));
+    }
+
+    // Comparison ////////////////////////////////////////////////////////////
+    {
+        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+//------------------------------------------------------------------------------
+
 }
 #endif //OPENCV_GAPI_IMGPROC_PERF_TESTS_INL_HPP

modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp

@@ -369,38 +369,6 @@ INSTANTIATE_TEST_CASE_P(TransposePerfTestCPU, TransposePerfTest,
                     CV_8UC3, CV_16UC3, CV_16SC3, CV_32FC3),
             Values(cv::compile_args(CORE_CPU))));
 
-INSTANTIATE_TEST_CASE_P(ResizePerfTestCPU, ResizePerfTest,
-    Combine(Values(AbsExact().to_compare_f()),
-            Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-            Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
-            Values(szSmall128, szVGA, sz720p, sz1080p),
-            Values( cv::Size(64, 64),
-                    cv::Size(32, 32)),
-            Values(cv::compile_args(CORE_CPU))));
-
-INSTANTIATE_TEST_CASE_P(BottleneckKernelsPerfTestCPU, BottleneckKernelsConstInputPerfTest,
-    Combine(Values(AbsExact().to_compare_f()),
-            Values( "cv/optflow/frames/1080p_00.png", "cv/optflow/frames/720p_00.png",
-                    "cv/optflow/frames/VGA_00.png", "cv/dnn_face/recognition/Aaron_Tippin_0001.jpg"),
-            Values(cv::compile_args(CORE_CPU))));
-
-INSTANTIATE_TEST_CASE_P(ResizeInSimpleGraphPerfTestCPU, ResizeInSimpleGraphPerfTest,
-    Combine(Values(AbsExact().to_compare_f()),
-            Values(CV_8UC3),
-            Values(szSmall128, szVGA, sz720p, sz1080p),
-            Values(0.5),
-            Values(0.5),
-            Values(cv::compile_args(CORE_CPU))));
-
-INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestCPU, ResizeFxFyPerfTest,
-    Combine(Values(AbsExact().to_compare_f()),
-            Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-            Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
-            Values(szSmall128, szVGA, sz720p, sz1080p),
-            Values(0.5, 0.1),
-            Values(0.5, 0.1),
-            Values(cv::compile_args(CORE_CPU))));
-
 INSTANTIATE_TEST_CASE_P(ParseSSDBLPerfTestCPU, ParseSSDBLPerfTest,
     Combine(Values(sz720p, sz1080p),
             Values(0.3f, 0.7f),

modules/gapi/perf/cpu/gapi_core_perf_tests_fluid.cpp

@@ -49,8 +49,8 @@ INSTANTIATE_TEST_CASE_P(SubPerfTestFluid, SubPerfTest,
 INSTANTIATE_TEST_CASE_P(SubCPerfTestFluid, SubCPerfTest,
     Combine(Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
             Values(szSmall128, szVGA, sz720p, sz1080p),
-            Values(CV_8UC1, CV_8UC3, CV_16SC1, CV_32FC1),
-            Values(-1, CV_8U, CV_32F),
+            Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
+            Values(-1, CV_8U, CV_16U, CV_16S, CV_32F),
             Values(cv::compile_args(CORE_FLUID))));
 
 INSTANTIATE_TEST_CASE_P(SubRCPerfTestFluid, SubRCPerfTest,
@@ -78,8 +78,8 @@ INSTANTIATE_TEST_CASE_P(MulDoublePerfTestFluid, MulDoublePerfTest,
 INSTANTIATE_TEST_CASE_P(MulCPerfTestFluid, MulCPerfTest,
     Combine(Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
             Values(szSmall128, szVGA, sz720p, sz1080p),
-            Values(CV_8UC1, CV_8UC3, CV_16SC1, CV_32FC1),
-            Values(-1, CV_8U, CV_32F),
+            Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
+            Values(-1, CV_8U, CV_16U, CV_16S, CV_32F),
             Values(cv::compile_args(CORE_FLUID))));
 
 INSTANTIATE_TEST_CASE_P(DivPerfTestFluid, DivPerfTest,
@@ -328,36 +328,4 @@ INSTANTIATE_TEST_CASE_P(ConvertToPerfTestFluid, ConvertToPerfTest,
             Values(0.0),
             Values(cv::compile_args(CORE_FLUID))));
 
-INSTANTIATE_TEST_CASE_P(ResizePerfTestFluid, ResizePerfTest,
-    Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_f()),
-            Values(CV_8UC3),
-            Values(cv::INTER_LINEAR),
-            Values(szSmall128, szVGA, sz720p, sz1080p),
-            Values(cv::Size(64, 64),
-                   cv::Size(30, 30)),
-            Values(cv::compile_args(CORE_FLUID))));
-
-#define IMGPROC_FLUID cv::gapi::imgproc::fluid::kernels()
-INSTANTIATE_TEST_CASE_P(BottleneckKernelsPerfTestFluid, BottleneckKernelsConstInputPerfTest,
-    Combine(Values(AbsSimilarPoints(0, 1).to_compare_f()),
-            Values("cv/optflow/frames/1080p_00.png", "cv/optflow/frames/720p_00.png",
-                   "cv/optflow/frames/VGA_00.png", "cv/dnn_face/recognition/Aaron_Tippin_0001.jpg"),
-            Values(cv::compile_args(CORE_FLUID, IMGPROC_FLUID))));
-
-INSTANTIATE_TEST_CASE_P(ResizeInSimpleGraphPerfTestFluid, ResizeInSimpleGraphPerfTest,
-    Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_f()),
-            Values(CV_8UC3),
-            Values(szSmall128, szVGA, sz720p, sz1080p),
-            Values(0.5),
-            Values(0.5),
-            Values(cv::compile_args(CORE_FLUID, IMGPROC_FLUID))));
-
-INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestFluid, ResizeFxFyPerfTest,
-    Combine(Values(AbsExact().to_compare_f()),
-            Values(CV_8UC3),
-            Values(cv::INTER_LINEAR),
-            Values(szSmall128, szVGA, sz720p, sz1080p),
-            Values(0.5, 0.1),
-            Values(0.5, 0.1),
-            Values(cv::compile_args(CORE_FLUID))));
 } // opencv_test

modules/gapi/perf/cpu/gapi_imgproc_perf_tests_cpu.cpp

@@ -403,4 +403,36 @@ INSTANTIATE_TEST_CASE_P(RGB2YUV422PerfTestCPU, RGB2YUV422PerfTest,
         Combine(Values(ToleranceColor(1e-3).to_compare_f()),
             Values(szVGA, sz720p, sz1080p),
             Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(ResizePerfTestCPU, ResizePerfTest,
+    Combine(Values(AbsExact().to_compare_f()),
+            Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
+            Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
+            Values(szSmall128, szVGA, sz720p, sz1080p),
+            Values( cv::Size(64, 64),
+                    cv::Size(32, 32)),
+            Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(BottleneckKernelsPerfTestCPU, BottleneckKernelsConstInputPerfTest,
+    Combine(Values(AbsExact().to_compare_f()),
+            Values( "cv/optflow/frames/1080p_00.png", "cv/optflow/frames/720p_00.png",
+                    "cv/optflow/frames/VGA_00.png", "cv/dnn_face/recognition/Aaron_Tippin_0001.jpg"),
+            Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(ResizeInSimpleGraphPerfTestCPU, ResizeInSimpleGraphPerfTest,
+    Combine(Values(AbsExact().to_compare_f()),
+            Values(CV_8UC3),
+            Values(szSmall128, szVGA, sz720p, sz1080p),
+            Values(0.5),
+            Values(0.5),
+            Values(cv::compile_args(IMGPROC_CPU))));
+
+INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestCPU, ResizeFxFyPerfTest,
+    Combine(Values(AbsExact().to_compare_f()),
+            Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
+            Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
+            Values(szSmall128, szVGA, sz720p, sz1080p),
+            Values(0.5, 0.1),
+            Values(0.5, 0.1),
+            Values(cv::compile_args(IMGPROC_CPU))));
 } // opencv_test

modules/gapi/perf/cpu/gapi_imgproc_perf_tests_fluid.cpp

@@ -9,6 +9,7 @@
 #include "../common/gapi_imgproc_perf_tests.hpp"
 
 #define IMGPROC_FLUID cv::gapi::imgproc::fluid::kernels()
+#define CORE_FLUID cv::gapi::core::fluid::kernels()
 
 namespace opencv_test
 {
@@ -198,4 +199,36 @@ INSTANTIATE_TEST_CASE_P(RGB2LabPerfTestFluid, RGB2LabPerfTest,
             Values(szVGA, sz720p, sz1080p),
             Values(cv::compile_args(IMGPROC_FLUID))));
 
+INSTANTIATE_TEST_CASE_P(ResizePerfTestFluid, ResizePerfTest,
+    Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_f()),
+            Values(CV_8UC3),
+            Values(cv::INTER_LINEAR),
+            Values(szSmall128, szVGA, sz720p, sz1080p),
+            Values(cv::Size(64, 64),
+                   cv::Size(30, 30)),
+            Values(cv::compile_args(IMGPROC_FLUID))));
+
+#define IMGPROC_FLUID cv::gapi::imgproc::fluid::kernels()
+INSTANTIATE_TEST_CASE_P(BottleneckKernelsPerfTestFluid, BottleneckKernelsConstInputPerfTest,
+    Combine(Values(AbsSimilarPoints(0, 1).to_compare_f()),
+            Values("cv/optflow/frames/1080p_00.png", "cv/optflow/frames/720p_00.png",
+                   "cv/optflow/frames/VGA_00.png", "cv/dnn_face/recognition/Aaron_Tippin_0001.jpg"),
+            Values(cv::compile_args(IMGPROC_FLUID))));
+
+INSTANTIATE_TEST_CASE_P(ResizeInSimpleGraphPerfTestFluid, ResizeInSimpleGraphPerfTest,
+    Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_f()),
+            Values(CV_8UC3),
+            Values(szSmall128, szVGA, sz720p, sz1080p),
+            Values(0.5),
+            Values(0.5),
+            Values(cv::compile_args(cv::gapi::combine(IMGPROC_FLUID, CORE_FLUID)))));
+
+INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestFluid, ResizeFxFyPerfTest,
+    Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_f()),
+            Values(CV_8UC3),
+            Values(cv::INTER_LINEAR),
+            Values(szSmall128, szVGA, sz720p, sz1080p),
+            Values(0.5, 0.25, 2),
+            Values(0.5, 0.25, 2),
+            Values(cv::compile_args(IMGPROC_FLUID))));
 }

modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp

@@ -323,22 +323,4 @@ INSTANTIATE_TEST_CASE_P(TransposePerfTestGPU, TransposePerfTest,
                    CV_8UC2, CV_16UC2, CV_16SC2, CV_32FC2,
                    CV_8UC3, CV_16UC3, CV_16SC3, CV_32FC3),
             Values(cv::compile_args(CORE_GPU))));
-
-INSTANTIATE_TEST_CASE_P(ResizePerfTestGPU, ResizePerfTest,
-    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 ),
-            Values(cv::Size(64,64),
-                   cv::Size(30,30)),
-            Values(cv::compile_args(CORE_GPU))));
-
-INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestGPU, ResizeFxFyPerfTest,
-    Combine(Values(AbsExact().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),
-            Values(0.5, 0.1),
-            Values(0.5, 0.1),
-            Values(cv::compile_args(CORE_GPU))));
 } // opencv_test

modules/gapi/perf/gpu/gapi_imgproc_perf_tests_gpu.cpp

@@ -204,4 +204,21 @@ INSTANTIATE_TEST_CASE_P(YUV2BGRPerfTestGPU, YUV2BGRPerfTest,
                         Values(szVGA, sz720p, sz1080p),
                         Values(cv::compile_args(IMGPROC_GPU))));
 
+INSTANTIATE_TEST_CASE_P(ResizePerfTestGPU, ResizePerfTest,
+                        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 ),
+                        Values(cv::Size(64,64),
+                               cv::Size(30,30)),
+                        Values(cv::compile_args(IMGPROC_GPU))));
+
+INSTANTIATE_TEST_CASE_P(ResizeFxFyPerfTestGPU, ResizeFxFyPerfTest,
+                        Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 1).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),
+                        Values(0.5, 0.1),
+                        Values(0.5, 0.1),
+                        Values(cv::compile_args(IMGPROC_GPU))));
 }

modules/gapi/src/backends/fluid/gfluidimgproc.cpp

@@ -2078,8 +2078,8 @@ GAPI_FLUID_KERNEL(GFluidResize, cv::gapi::imgproc::GResize, true)
        int outSz_h;
        if (outSz.width == 0 || outSz.height == 0)
        {
-           outSz_w = static_cast<int>(round(in.size.width * fx));
-           outSz_h = static_cast<int>(round(in.size.height * fy));
+           outSz_w = saturate_cast<int>(in.size.width * fx);
+           outSz_h = saturate_cast<int>(in.size.height * fy);
        }
        else
        {