Merge pull request opencv#16118 from smirnov-alexey:as/gopaque

G-API: GOpaque implementation

* Stub initial copypasted solution

* Fix mov test and add a couple of others

* Fix warnings

* More code coverage and tests

* fix macos warning

* address review comments

* Address review comments and fix indentation

* Fix build on armv7

Author: smirnov-alexey

modules/gapi/CMakeLists.txt

@@ -44,6 +44,7 @@ set(gapi_srcs
     src/api/gorigin.cpp
     src/api/gmat.cpp
     src/api/garray.cpp
+    src/api/gopaque.cpp
     src/api/gscalar.cpp
     src/api/gkernel.cpp
     src/api/gbackend.cpp

modules/gapi/include/opencv2/gapi/cpu/gcpukernel.hpp

@@ -94,9 +94,14 @@ class GAPI_EXPORTS GCPUContext
     {
         return outVecRef(output).wref<T>();
     }
+    template<typename T> T& outOpaqueR(int output) // FIXME: the same issue
+    {
+        return outOpaqueRef(output).wref<T>();
+    }
 
 protected:
     detail::VectorRef& outVecRef(int output);
+    detail::OpaqueRef& outOpaqueRef(int output);
 
     std::vector<GArg> m_args;
 
@@ -145,12 +150,31 @@ template<typename U> struct get_in<cv::GArray<U> >
 {
     static const std::vector<U>& get(GCPUContext &ctx, int idx) { return ctx.inArg<VectorRef>(idx).rref<U>(); }
 };
+template<typename U> struct get_in<cv::GOpaque<U> >
+{
+    static const U& get(GCPUContext &ctx, int idx) { return ctx.inArg<OpaqueRef>(idx).rref<U>(); }
+};
 
 //FIXME(dm): GArray<Mat>/GArray<GMat> conversion should be done more gracefully in the system
 template<> struct get_in<cv::GArray<cv::GMat> >: public get_in<cv::GArray<cv::Mat> >
 {
 };
 
+//FIXME(dm): GArray<Scalar>/GArray<GScalar> conversion should be done more gracefully in the system
+template<> struct get_in<cv::GArray<cv::GScalar> >: public get_in<cv::GArray<cv::Scalar> >
+{
+};
+
+//FIXME(dm): GOpaque<Mat>/GOpaque<GMat> conversion should be done more gracefully in the system
+template<> struct get_in<cv::GOpaque<cv::GMat> >: public get_in<cv::GOpaque<cv::Mat> >
+{
+};
+
+//FIXME(dm): GOpaque<Scalar>/GOpaque<GScalar> conversion should be done more gracefully in the system
+template<> struct get_in<cv::GOpaque<cv::GScalar> >: public get_in<cv::GOpaque<cv::Mat> >
+{
+};
+
 template<class T> struct get_in
 {
     static T get(GCPUContext &ctx, int idx) { return ctx.inArg<T>(idx); }
@@ -229,6 +253,13 @@ template<typename U> struct get_out<cv::GArray<U>>
         return ctx.outVecR<U>(idx);
     }
 };
+template<typename U> struct get_out<cv::GOpaque<U>>
+{
+    static U& get(GCPUContext &ctx, int idx)
+    {
+        return ctx.outOpaqueR<U>(idx);
+    }
+};
 
 template<typename, typename, typename>
 struct OCVCallHelper;

modules/gapi/include/opencv2/gapi/fluid/gfluidkernel.hpp

@@ -200,6 +200,14 @@ template<typename U> struct fluid_get_in<cv::GArray<U>>
     }
 };
 
+template<typename U> struct fluid_get_in<cv::GOpaque<U>>
+{
+    static const U& get(const cv::GArgs &in_args, int idx)
+    {
+        return in_args.at(idx).unsafe_get<cv::detail::OpaqueRef>().rref<U>();
+    }
+};
+
 template<class T> struct fluid_get_in
 {
     static const T& get(const cv::GArgs &in_args, int idx)

modules/gapi/include/opencv2/gapi/garg.hpp

@@ -20,6 +20,7 @@
 #include <opencv2/gapi/gmat.hpp>
 #include <opencv2/gapi/gscalar.hpp>
 #include <opencv2/gapi/garray.hpp>
+#include <opencv2/gapi/gopaque.hpp>
 #include <opencv2/gapi/gtype_traits.hpp>
 #include <opencv2/gapi/gmetaarg.hpp>
 #include <opencv2/gapi/own/scalar.hpp>
@@ -96,7 +97,8 @@ using GRunArg  = util::variant<
     cv::gapi::wip::IStreamSource::Ptr,
     cv::gapi::own::Mat,
     cv::gapi::own::Scalar,
-    cv::detail::VectorRef
+    cv::detail::VectorRef,
+    cv::detail::OpaqueRef
     >;
 using GRunArgs = std::vector<GRunArg>;
 
@@ -128,7 +130,8 @@ using GRunArgP = util::variant<
 #endif // !defined(GAPI_STANDALONE)
     cv::gapi::own::Mat*,
     cv::gapi::own::Scalar*,
-    cv::detail::VectorRef
+    cv::detail::VectorRef,
+    cv::detail::OpaqueRef
     >;
 using GRunArgsP = std::vector<GRunArgP>;
 

modules/gapi/include/opencv2/gapi/gcall.hpp

@@ -12,6 +12,7 @@
 #include <opencv2/gapi/gmat.hpp>      // GMat
 #include <opencv2/gapi/gscalar.hpp>   // GScalar
 #include <opencv2/gapi/garray.hpp>    // GArray<T>
+#include <opencv2/gapi/gopaque.hpp>   // GOpaque<T>
 
 namespace cv {
 
@@ -46,6 +47,11 @@ class GAPI_EXPORTS GCall final
         return GArray<T>(yieldArray(output));
     }
 
+    template<class T> GOpaque<T> yieldOpaque(int output = 0)
+    {
+        return GOpaque<T>(yieldOpaque(output));
+    }
+
     // Internal use only
     Priv& priv();
     const Priv& priv() const;
@@ -55,8 +61,9 @@ class GAPI_EXPORTS GCall final
 
     void setArgs(std::vector<GArg> &&args);
 
-    // Public version returns a typed array, this one is implementation detail
+    // Public versions return a typed array or opaque, those are implementation details
     detail::GArrayU yieldArray(int output = 0);
+    detail::GOpaqueU yieldOpaque(int output = 0);
 };
 
 } // namespace cv

modules/gapi/include/opencv2/gapi/gcommon.hpp

@@ -44,6 +44,7 @@ enum class GShape: int
     GMAT,
     GSCALAR,
     GARRAY,
+    GOPAQUE,
 };
 
 struct GCompileArg;

modules/gapi/include/opencv2/gapi/gcompoundkernel.hpp

@@ -65,6 +65,16 @@ template<typename U> struct get_compound_in<cv::GArray<U>>
     }
 };
 
+template<typename U> struct get_compound_in<cv::GOpaque<U>>
+{
+    static cv::GOpaque<U> get(GCompoundContext &ctx, int idx)
+    {
+        auto opaq = cv::GOpaque<U>();
+        ctx.m_args[idx] = GArg(opaq);
+        return opaq;
+    }
+};
+
 template<typename, typename, typename>
 struct GCompoundCallHelper;
 

modules/gapi/include/opencv2/gapi/gkernel.hpp

@@ -74,6 +74,10 @@ namespace detail
         {
             static inline cv::GArray<U> yield(cv::GCall &call, int i) { return call.yieldArray<U>(i); }
         };
+        template<typename U> struct Yield<cv::GOpaque<U> >
+        {
+            static inline cv::GOpaque<U> yield(cv::GCall &call, int i) { return call.yieldOpaque<U>(i); }
+        };
     } // anonymous namespace
 
     ////////////////////////////////////////////////////////////////////////////
@@ -87,7 +91,8 @@ namespace detail
     template<> struct MetaType<cv::GMat>    { using type = GMatDesc; };
     template<> struct MetaType<cv::GMatP>   { using type = GMatDesc; };
     template<> struct MetaType<cv::GScalar> { using type = GScalarDesc; };
-    template<typename U> struct MetaType<cv::GArray<U> > { using type = GArrayDesc; };
+    template<typename U> struct MetaType<cv::GArray<U> >  { using type = GArrayDesc; };
+    template<typename U> struct MetaType<cv::GOpaque<U> > { using type = GOpaqueDesc; };
     template<typename T> struct MetaType    { using type = T; }; // opaque args passed as-is
 
     // 2. Hacky test based on MetaType to check if we operate on G-* type or not

modules/gapi/include/opencv2/gapi/gmat.hpp

@@ -46,6 +46,7 @@ struct GOrigin;
  *    cv::GMat           | cv::Mat
  *    cv::GScalar        | cv::Scalar
  *    `cv::GArray<T>`    | std::vector<T>
+ *    `cv::GOpaque<T>`   | T
  */
 class GAPI_EXPORTS GMat
 {

modules/gapi/include/opencv2/gapi/gmetaarg.hpp

@@ -17,6 +17,7 @@
 #include <opencv2/gapi/gmat.hpp>
 #include <opencv2/gapi/gscalar.hpp>
 #include <opencv2/gapi/garray.hpp>
+#include <opencv2/gapi/gopaque.hpp>
 
 namespace cv
 {
@@ -36,6 +37,7 @@ using GMetaArg = util::variant
     , GMatDesc
     , GScalarDesc
     , GArrayDesc
+    , GOpaqueDesc
     >;
 GAPI_EXPORTS std::ostream& operator<<(std::ostream& os, const GMetaArg &);
 
@@ -52,6 +54,7 @@ namespace detail
     template<> struct is_meta_descr<GMatDesc>    : std::true_type {};
     template<> struct is_meta_descr<GScalarDesc> : std::true_type {};
     template<> struct is_meta_descr<GArrayDesc>  : std::true_type {};
+    template<> struct is_meta_descr<GOpaqueDesc> : std::true_type {};
 
     template<typename... Ts>
     using are_meta_descrs = all_satisfy<is_meta_descr, Ts...>;