Merge pull request #19112 from rgarnov:rg/generic_copy_kernel

Ruslan Garnov · web-flow · commit f7cab121fe29 · 2020-12-16T11:18:08.000Z
Generic copy kernel

* Moved RMat wrapping of cv::Mats to StreamingInput

* Generalized GCopy kernel

* Generic GCopy kernel: applied review comments
diff --git a/modules/gapi/include/opencv2/gapi/core.hpp b/modules/gapi/include/opencv2/gapi/core.hpp
@@ -451,12 +451,6 @@ namespace core {
         }
     };
 
-    G_TYPED_KERNEL(GCopy, <GMat(GMat)>, "org.opencv.core.transform.copy") {
-        static GMatDesc outMeta(GMatDesc in) {
-            return in;
-        }
-    };
-
     G_TYPED_KERNEL(GConcatHor, <GMat(GMat, GMat)>, "org.opencv.imgproc.transform.concatHor") {
         static GMatDesc outMeta(GMatDesc l, GMatDesc r) {
             return l.withSizeDelta(+r.size.width, 0);
@@ -1667,19 +1661,6 @@ Output matrix must be of the same depth as input one, size is specified by given
 */
 GAPI_EXPORTS GMat crop(const GMat& src, const Rect& rect);
 
-/** @brief Copies a matrix.
-
-Copies an input array. Works as a regular Mat::clone but happens in-graph.
-Mainly is used to workaround some existing limitations (e.g. to forward an input frame to outputs
-in the streaming mode). Will be deprecated and removed in the future.
-
-@note Function textual ID is "org.opencv.core.transform.copy"
-
-@param src input matrix.
-@sa crop
-*/
-GAPI_EXPORTS GMat copy(const GMat& src);
-
 /** @brief Applies horizontal concatenation to given matrices.
 
 The function horizontally concatenates two GMat matrices (with the same number of rows).
diff --git a/modules/gapi/include/opencv2/gapi/streaming/format.hpp b/modules/gapi/include/opencv2/gapi/streaming/format.hpp
@@ -15,36 +15,44 @@ namespace streaming {
 
 GAPI_EXPORTS cv::gapi::GKernelPackage kernels();
 
-// FIXME: Make a generic kernel
-G_API_OP(GCopy, <GFrame(GFrame)>, "org.opencv.streaming.copy")
-{
-    static GFrameDesc outMeta(const GFrameDesc& in) { return in; }
-};
-
 G_API_OP(GBGR, <GMat(GFrame)>, "org.opencv.streaming.BGR")
 {
     static GMatDesc outMeta(const GFrameDesc& in) { return GMatDesc{CV_8U, 3, in.size}; }
 };
 
-/** @brief Gets copy from the input frame
+/** @brief Gets bgr plane from input frame
 
-@note Function textual ID is "org.opencv.streaming.copy"
+@note Function textual ID is "org.opencv.streaming.BGR"
 
 @param in Input frame
-@return Copy of the input frame
+@return Image in BGR format
 */
-GAPI_EXPORTS cv::GFrame copy(const cv::GFrame& in);
+GAPI_EXPORTS cv::GMat BGR(const cv::GFrame& in);
 
-/** @brief Gets bgr plane from input frame
+} // namespace streaming
 
-@note Function textual ID is "org.opencv.streaming.BGR"
+/** @brief Makes a copy of the input image. Note that this copy may be not real
+(no actual data copied). Use this function to maintain graph contracts,
+e.g when graph's input needs to be passed directly to output, like in Streaming mode.
+
+@note Function textual ID is "org.opencv.streaming.copy"
+
+@param in Input image
+@return Copy of the input
+*/
+GAPI_EXPORTS cv::GMat copy(const cv::GMat& in);
+
+/** @brief Makes a copy of the input frame. Note that this copy may be not real
+(no actual data copied). Use this function to maintain graph contracts,
+e.g when graph's input needs to be passed directly to output, like in Streaming mode.
+
+@note Function textual ID is "org.opencv.streaming.copy"
 
 @param in Input frame
-@return Image in BGR format
+@return Copy of the input
 */
-GAPI_EXPORTS cv::GMat BGR (const cv::GFrame& in);
+GAPI_EXPORTS cv::GFrame copy(const cv::GFrame& in);
 
-} // namespace streaming
 } // namespace gapi
 } // namespace cv
 
diff --git a/modules/gapi/perf/cpu/gapi_core_perf_tests_fluid.cpp b/modules/gapi/perf/cpu/gapi_core_perf_tests_fluid.cpp
@@ -233,11 +233,6 @@ INSTANTIATE_TEST_CASE_P(Split3PerfTestFluid, Split3PerfTest,
 //         Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)),
 //         Values(cv::compile_args(CORE_FLUID))));
 
-// INSTANTIATE_TEST_CASE_P(CopyPerfTestFluid, CopyPerfTest,
-//     Combine(Values(szSmall128, szVGA, sz720p, sz1080p),
-//         Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-//         Values(cv::compile_args(CORE_FLUID))));
-
 // INSTANTIATE_TEST_CASE_P(ConcatHorPerfTestFluid, ConcatHorPerfTest,
 //     Combine(Values(szSmall128, szVGA, sz720p, sz1080p),
 //         Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
diff --git a/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp b/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp
@@ -232,11 +232,6 @@ INSTANTIATE_TEST_CASE_P(CropPerfTestGPU, CropPerfTest,
                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)),
                                 Values(cv::compile_args(CORE_GPU))));
 
-INSTANTIATE_TEST_CASE_P(CopyPerfTestGPU, CopyPerfTest,
-                        Combine(Values( szSmall128, szVGA, sz720p, sz1080p ),
-                                Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::compile_args(CORE_GPU))));
-
 INSTANTIATE_TEST_CASE_P(ConcatHorPerfTestGPU, ConcatHorPerfTest,
                         Combine(Values( szSmall128, szVGA, sz720p, sz1080p ),
                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
diff --git a/modules/gapi/src/api/kernels_core.cpp b/modules/gapi/src/api/kernels_core.cpp
@@ -328,11 +328,6 @@ GMat crop(const GMat& src, const Rect& rect)
     return core::GCrop::on(src, rect);
 }
 
-GMat copy(const GMat& src)
-{
-    return core::GCopy::on(src);
-}
-
 GMat concatHor(const GMat& src1, const GMat& src2)
 {
     return core::GConcatHor::on(src1, src2);
diff --git a/modules/gapi/src/api/kernels_streaming.cpp b/modules/gapi/src/api/kernels_streaming.cpp
@@ -75,10 +75,6 @@ cv::GMat cv::gapi::streaming::desync(const cv::GMat &g) {
     // object will feed both branches of the streaming executable.
 }
 
-cv::GFrame cv::gapi::streaming::copy(const cv::GFrame& in) {
-    return cv::gapi::streaming::GCopy::on(in);
-}
-
 cv::GMat cv::gapi::streaming::BGR(const cv::GFrame& in) {
     return cv::gapi::streaming::GBGR::on(in);
 }
diff --git a/modules/gapi/src/backends/cpu/gcpucore.cpp b/modules/gapi/src/backends/cpu/gcpucore.cpp
@@ -510,14 +510,6 @@ GAPI_OCV_KERNEL(GCPUCrop, cv::gapi::core::GCrop)
     }
 };
 
-GAPI_OCV_KERNEL(GCPUCopy, cv::gapi::core::GCopy)
-{
-    static void run(const cv::Mat& in, cv::Mat& out)
-    {
-        in.copyTo(out);
-    }
-};
-
 GAPI_OCV_KERNEL(GCPUConcatHor, cv::gapi::core::GConcatHor)
 {
     static void run(const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out)
@@ -762,7 +754,6 @@ cv::gapi::GKernelPackage cv::gapi::core::cpu::kernels()
          , GCPURemap
          , GCPUFlip
          , GCPUCrop
-         , GCPUCopy
          , GCPUConcatHor
          , GCPUConcatVert
          , GCPULUT
diff --git a/modules/gapi/src/backends/fluid/gfluidcore.cpp b/modules/gapi/src/backends/fluid/gfluidcore.cpp
@@ -2675,40 +2675,6 @@ GAPI_FLUID_KERNEL(GFluidSqrt, cv::gapi::core::GSqrt, false)
     }
 };
 
-GAPI_FLUID_KERNEL(GFluidCopy, cv::gapi::core::GCopy, false)
-{
-    static const int Window = 1;
-
-    static void run(const View &src, Buffer &dst)
-    {
-        const auto *in  = src.InLine<uchar>(0);
-              auto *out = dst.OutLine<uchar>();
-
-        GAPI_DbgAssert(dst.length() == src.length());
-        GAPI_DbgAssert(dst.meta().chan == src.meta().chan);
-        GAPI_DbgAssert(dst.meta().depth == src.meta().depth);
-
-        int width = src.length();
-        int elem_size = CV_ELEM_SIZE(CV_MAKETYPE(src.meta().depth, src.meta().chan));
-
-        int w = 0; // cycle counter
-
-    #if CV_SIMD128
-        for (; w <= width*elem_size-16; w+=16)
-        {
-            v_uint8x16 a;
-            a = v_load(&in[w]);
-            v_store(&out[w], a);
-        }
-    #endif
-
-        for (; w < width*elem_size; w++)
-        {
-            out[w] = in[w];
-        }
-    }
-};
-
 } // namespace fliud
 } // namespace gapi
 } // namespace cv
@@ -2768,7 +2734,6 @@ cv::gapi::GKernelPackage cv::gapi::core::fluid::kernels()
             ,GFluidInRange
             ,GFluidResize
             ,GFluidSqrt
-            ,GFluidCopy
         #if 0
             ,GFluidMean        -- not fluid
             ,GFluidSum         -- not fluid
diff --git a/modules/gapi/src/backends/ocl/goclcore.cpp b/modules/gapi/src/backends/ocl/goclcore.cpp
@@ -490,14 +490,6 @@ GAPI_OCL_KERNEL(GOCLCrop, cv::gapi::core::GCrop)
     }
 };
 
-GAPI_OCL_KERNEL(GOCLCopy, cv::gapi::core::GCopy)
-{
-    static void run(const cv::UMat& in, cv::UMat& out)
-    {
-        in.copyTo(out);
-    }
-};
-
 GAPI_OCL_KERNEL(GOCLConcatHor, cv::gapi::core::GConcatHor)
 {
     static void run(const cv::UMat& in1, const cv::UMat& in2, cv::UMat& out)
@@ -590,7 +582,6 @@ cv::gapi::GKernelPackage cv::gapi::core::ocl::kernels()
          , GOCLRemap
          , GOCLFlip
          , GOCLCrop
-         , GOCLCopy
          , GOCLConcatHor
          , GOCLConcatVert
          , GOCLLUT
diff --git a/modules/gapi/src/backends/streaming/gstreamingbackend.cpp b/modules/gapi/src/backends/streaming/gstreamingbackend.cpp
@@ -137,7 +137,12 @@ cv::gapi::GBackend cv::gapi::streaming::backend()
 
 cv::gapi::GKernelPackage cv::gapi::streaming::kernels()
 {
-    return cv::gapi::kernels<cv::gimpl::Copy, cv::gimpl::BGR>();
+    return cv::gapi::kernels<cv::gimpl::BGR>();
+}
+
+cv::gapi::GKernelPackage cv::gimpl::streaming::kernels()
+{
+    return cv::gapi::kernels<cv::gimpl::Copy>();
 }
 
 void cv::gimpl::Copy::Actor::run(cv::gimpl::GIslandExecutable::IInput  &in,
@@ -153,8 +158,21 @@ void cv::gimpl::Copy::Actor::run(cv::gimpl::GIslandExecutable::IInput  &in,
     const cv::GRunArgs &in_args = cv::util::get<cv::GRunArgs>(in_msg);
     GAPI_Assert(in_args.size() == 1u);
 
-    cv::GRunArgP out_arg = out.get(0);
-    *cv::util::get<cv::MediaFrame*>(out_arg) = cv::util::get<cv::MediaFrame>(in_args[0]);
+    const auto& in_arg = in_args[0];
+    auto out_arg = out.get(0);
+    using cv::util::get;
+    switch (in_arg.index()) {
+    case cv::GRunArg::index_of<cv::RMat>():
+        *get<cv::RMat*>(out_arg) = get<cv::RMat>(in_arg);
+        break;
+    case cv::GRunArg::index_of<cv::MediaFrame>():
+        *get<cv::MediaFrame*>(out_arg) = get<cv::MediaFrame>(in_arg);
+        break;
+    // FIXME: Add support for remaining types
+    default:
+        GAPI_Assert(false && "Copy: unsupported data type");
+    }
+    out.meta(out_arg, in_arg.meta);
     out.post(std::move(out_arg));
 }
 
@@ -197,3 +215,11 @@ void cv::gimpl::BGR::Actor::run(cv::gimpl::GIslandExecutable::IInput  &in,
     }
     out.post(std::move(out_arg));
 }
+
+cv::GMat cv::gapi::copy(const cv::GMat& in) {
+    return cv::gimpl::streaming::GCopy::on<cv::GMat>(in);
+}
+
+cv::GFrame cv::gapi::copy(const cv::GFrame& in) {
+    return cv::gimpl::streaming::GCopy::on<cv::GFrame>(in);
+}
diff --git a/modules/gapi/src/backends/streaming/gstreamingbackend.hpp b/modules/gapi/src/backends/streaming/gstreamingbackend.hpp
@@ -12,11 +12,37 @@
 #include "gstreamingkernel.hpp"
 
 namespace cv {
+namespace gapi {
+namespace streaming {
+
+cv::gapi::GBackend backend();
+
+}} // namespace gapi::streaming
+
 namespace gimpl {
+namespace streaming {
+
+cv::gapi::GKernelPackage kernels();
+
+struct GCopy final : public cv::detail::NoTag
+{
+    static constexpr const char* id() { return "org.opencv.streaming.copy"; }
+
+    static GMetaArgs getOutMeta(const GMetaArgs &in_meta, const GArgs&) {
+        GAPI_Assert(in_meta.size() == 1u);
+        return in_meta;
+    }
+
+    template<typename T> static T on(const T& arg) {
+        return cv::GKernelType<GCopy, std::function<T(T)>>::on(arg);
+    }
+};
+
+} // namespace streaming
 
 struct Copy: public cv::detail::KernelTag
 {
-    using API = cv::gapi::streaming::GCopy;
+    using API = streaming::GCopy;
 
     static gapi::GBackend backend() { return cv::gapi::streaming::backend(); }
 
diff --git a/modules/gapi/src/compiler/gcompiler.cpp b/modules/gapi/src/compiler/gcompiler.cpp
@@ -36,6 +36,7 @@
 #include "executor/gstreamingexecutor.hpp"
 #include "backends/common/gbackend.hpp"
 #include "backends/common/gmetabackend.hpp"
+#include "backends/streaming/gstreamingbackend.hpp"
 
 // <FIXME:>
 #if !defined(GAPI_STANDALONE)
@@ -60,8 +61,11 @@ namespace
             for (const auto &b : pkg.backends()) {
                 aux_pkg = combine(aux_pkg, b.priv().auxiliaryKernels());
             }
-            // Always include built-in meta<> implementation
-            return combine(pkg, aux_pkg, cv::gimpl::meta::kernels());
+            // Always include built-in meta<> and copy implementation
+            return combine(pkg,
+                           aux_pkg,
+                           cv::gimpl::meta::kernels(),
+                           cv::gimpl::streaming::kernels());
         };
 
         auto has_use_only = cv::gapi::getCompileArg<cv::gapi::use_only>(args);
diff --git a/modules/gapi/src/compiler/gislandmodel.cpp b/modules/gapi/src/compiler/gislandmodel.cpp
@@ -18,7 +18,6 @@
 #include "compiler/gmodel.hpp"
 #include "compiler/gislandmodel.hpp"
 #include "compiler/gmodel.hpp"
-#include "backends/common/gbackend.hpp" // RMatAdapter
 
 #include "logger.hpp"    // GAPI_LOG
 
@@ -357,22 +356,7 @@ void GIslandExecutable::run(GIslandExecutable::IInput &in, GIslandExecutable::IO
     for (auto &&it: ade::util::zip(ade::util::toRange(in_desc),
                                    ade::util::toRange(in_vector)))
     {
-        const cv::GRunArg& in_data_orig = std::get<1>(it);
-        cv::GRunArg in_data;
-        switch (in_data_orig.index())
-        {
-        case cv::GRunArg::index_of<cv::Mat>():
-            // FIXME: This whole construct is ugly, from
-            // its writing to a need in this in general
-            in_data = cv::GRunArg{ cv::make_rmat<cv::gimpl::RMatAdapter>(cv::util::get<cv::Mat>(in_data_orig))
-                                 , in_data_orig.meta
-                                 };
-            break;
-        default:
-            in_data = in_data_orig;
-            break;
-        }
-        in_objs.emplace_back(std::get<0>(it), std::move(in_data));
+        in_objs.emplace_back(std::get<0>(it), std::get<1>(it));
     }
     for (auto &&it: ade::util::indexed(ade::util::toRange(out_desc)))
     {
diff --git a/modules/gapi/src/executor/gexecutor.cpp b/modules/gapi/src/executor/gexecutor.cpp
diff --git a/modules/gapi/src/executor/gstreamingexecutor.cpp b/modules/gapi/src/executor/gstreamingexecutor.cpp
diff --git a/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp
diff --git a/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp
diff --git a/modules/gapi/test/internal/gapi_int_island_fusion_tests.cpp b/modules/gapi/test/internal/gapi_int_island_fusion_tests.cpp
diff --git a/modules/gapi/test/streaming/gapi_streaming_tests.cpp b/modules/gapi/test/streaming/gapi_streaming_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -328,11 +328,6 @@ GMat crop(const GMat& src, const Rect& rect)`
`328`	`328`	`return core::GCrop::on(src, rect);`
`329`	`329`	`}`
`330`	`330`
`331`		`-GMat copy(const GMat& src)`
`332`		`-{`
`333`		`- return core::GCopy::on(src);`
`334`		`-}`
`335`		`-`
`336`	`331`	`GMat concatHor(const GMat& src1, const GMat& src2)`
`337`	`332`	`{`
`338`	`333`	`return core::GConcatHor::on(src1, src2);`
Original file line number	Diff line number	Diff line change
`@@ -75,10 +75,6 @@ cv::GMat cv::gapi::streaming::desync(const cv::GMat &g) {`
`75`	`75`	`// object will feed both branches of the streaming executable.`
`76`	`76`	`}`
`77`	`77`
`78`		`-cv::GFrame cv::gapi::streaming::copy(const cv::GFrame& in) {`
`79`		`- return cv::gapi::streaming::GCopy::on(in);`
`80`		`-}`
`81`		`-`
`82`	`78`	`cv::GMat cv::gapi::streaming::BGR(const cv::GFrame& in) {`
`83`	`79`	`return cv::gapi::streaming::GBGR::on(in);`
`84`	`80`	`}`