Merge pull request opencv#17502 from dmatveev:dm/infer2

* G-API: Introduce a new gapi::infer2 overload + gaze estimation sample

* G-API/infer2: Introduced static type checking for infer2

- Also added extra tests on the type check routine

* G-API/infer2: Addressed self-review comments in the sample app

- Also fix build on Linux;

* G-API/infer2: Remove incorrect SetLayout(HWC) + dead code

- Also fixed comments in the backend

* G-API/infer2: Continue with self-review

- Fix warnings/compile errors in gaze estimation
- Dropped the use of RTTI (VectorRef::holds()) from the giebackend
- Replaced it with a trait-based enums for GArray<T> and std::vector<T>
- The enums and traits are temporary and need to be unified with
  the S11N when it comes

* G-API/infer2: Final self-review items

- Refactored ROIList test to cover 70% for infer<> and infer2<>;
- Fixed the model data discovery routine to be compatible with new
  OpenVINO;
- Hopefully fixed the final issues (warnings) with the sample.

* G-API/infer2: address review problems

- Fixed typo in comments;
- Fixed public (Doxygen) comment on GArray<GMat> input case for infer2;
- Made model lookup more flexible to allow new & old OMZ dir layouts.

* G-API/infer2: Change the model paths again

* G-API/infer2: Change the lookup path for test data

* G-API/infer2: use randu instead of imread. CI war is over

Author: dmatveev

modules/gapi/include/opencv2/gapi/garray.hpp

@@ -49,6 +49,31 @@ std::ostream& operator<<(std::ostream& os, const cv::GArrayDesc &desc);
 
 namespace detail
 {
+    // FIXME: This type spec needs to be:
+    // 1) shared with GOpaque (not needed right now)
+    // 2) unified with the serialization (S11N, not merged right now).
+    // Adding it to type traits is problematic due to our header deps
+    // (which also need to be fixed).
+    enum class TypeSpec: int {
+        OPAQUE_SPEC,
+        MAT,
+        RECT
+    };
+    // FIXME: Reuse the below from "opaque traits" of S11N!
+    template<typename T> struct GTypeSpec;
+    template<typename T> struct GTypeSpec
+    {
+        static constexpr const TypeSpec spec = TypeSpec::OPAQUE_SPEC;
+    };
+    template<>           struct GTypeSpec<cv::Mat>
+    {
+        static constexpr const TypeSpec spec = TypeSpec::MAT;
+    };
+    template<>           struct GTypeSpec<cv::Rect>
+    {
+        static constexpr const TypeSpec spec = TypeSpec::RECT;
+    };
+
     // ConstructVec is a callback which stores information about T and is used by
     // G-API runtime to construct arrays in host memory (T remains opaque for G-API).
     // ConstructVec is carried into G-API internals by GArrayU.
@@ -110,12 +135,15 @@ namespace detail
     class BasicVectorRef
     {
     public:
+        // These fields are set by the derived class(es)
         std::size_t    m_elemSize = 0ul;
         cv::GArrayDesc m_desc;
+        TypeSpec       m_spec;
         virtual ~BasicVectorRef() {}
 
         virtual void mov(BasicVectorRef &ref) = 0;
         virtual const void* ptr() const = 0;
+        virtual std::size_t size() const = 0;
     };
 
     template<typename T> class VectorRefT final: public BasicVectorRef
@@ -135,6 +163,7 @@ namespace detail
         {
             m_elemSize = sizeof(T);
             if (vec) m_desc = cv::descr_of(*vec);
+            m_spec = GTypeSpec<T>::spec;
         }
 
     public:
@@ -209,7 +238,9 @@ namespace detail
             wref() = std::move(tv->wref());
         }
 
+
         virtual const void* ptr() const override { return &rref(); }
+        virtual std::size_t size() const override { return rref().size(); }
     };
 
     // This class strips type information from VectorRefT<> and makes it usable
@@ -265,8 +296,18 @@ namespace detail
             return m_ref->m_desc;
         }
 
+        std::size_t size() const
+        {
+            return m_ref->size();
+        }
+
         // May be used to uniquely identify this object internally
         const void *ptr() const { return m_ref->ptr(); }
+
+        TypeSpec spec() const
+        {
+            return m_ref->m_spec;
+        }
     };
 
     // Helper (FIXME: work-around?)

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

@@ -26,6 +26,7 @@
 
 namespace cv {
 
+using GSpecs = std::vector<cv::detail::ArgSpec>;
 using GShapes = std::vector<GShape>;
 
 // GKernel describes kernel API to the system
@@ -38,8 +39,11 @@ struct GAPI_EXPORTS GKernel
     const std::string name;       // kernel ID, defined by its API (signature)
     const std::string tag;        // some (implementation-specific) tag
     const M           outMeta;    // generic adaptor to API::outMeta(...)
+    const GSpecs      inSpecs;    // specs of kernel's inputs (FIXME: below)
     const GShapes     outShapes;  // types (shapes) kernel's outputs
 };
+// TODO: It's questionable if inSpecs should really be here. Instead,
+// this information could come from meta.
 
 // GKernelImpl describes particular kernel implementation to the system
 struct GAPI_EXPORTS GKernelImpl
@@ -203,10 +207,15 @@ class GKernelTypeM<K, std::function<std::tuple<R...>(Args...)> >
     using InArgs  = std::tuple<Args...>;
     using OutArgs = std::tuple<R...>;
 
+    // TODO: Args&&... here?
     static std::tuple<R...> on(Args... args)
     {
-        cv::GCall call(GKernel{K::id(), K::tag(), &K::getOutMeta, {detail::GTypeTraits<R>::shape...}});
-        call.pass(args...);
+        cv::GCall call(GKernel{ K::id()
+                              , K::tag()
+                              , &K::getOutMeta
+                              , {detail::GTypeTraits<Args>::spec...}
+                              , {detail::GTypeTraits<R>::shape...}});
+        call.pass(args...); // TODO: std::forward() here?
         return yield(call, typename detail::MkSeq<sizeof...(R)>::type());
     }
 };
@@ -226,7 +235,11 @@ class GKernelType<K, std::function<R(Args...)> >
 
     static R on(Args... args)
     {
-        cv::GCall call(GKernel{K::id(), K::tag(), &K::getOutMeta, {detail::GTypeTraits<R>::shape}});
+        cv::GCall call(GKernel{ K::id()
+                              , K::tag()
+                              , &K::getOutMeta
+                              , {detail::GTypeTraits<Args>::spec...}
+                              , {detail::GTypeTraits<R>::shape}});
         call.pass(args...);
         return detail::Yield<R>::yield(call, 0);
     }

modules/gapi/include/opencv2/gapi/gopaque.hpp

@@ -46,6 +46,7 @@ std::ostream& operator<<(std::ostream& os, const cv::GOpaqueDesc &desc);
 
 namespace detail
 {
+
     // ConstructOpaque is a callback which stores information about T and is used by
     // G-API runtime to construct an object in host memory (T remains opaque for G-API).
     // ConstructOpaque is carried into G-API internals by GOpaqueU.

modules/gapi/include/opencv2/gapi/gtype_traits.hpp

@@ -2,7 +2,7 @@
 // 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) 2018 Intel Corporation
+// Copyright (C) 2018-2020 Intel Corporation
 
 
 #ifndef OPENCV_GAPI_GTYPE_TRAITS_HPP
@@ -41,6 +41,32 @@ namespace detail
         GOPAQUE,      // a cv::GOpaqueU (note - exactly GOpaqueU, not GOpaque<T>!)
     };
 
+    // This enum captures some information about T in GArray<T> and GOpaque<T>
+    enum class ArgSpec: int
+    {
+        OPAQUE_SPEC,  // Unknown, generic, opaque-to-GAPI data type
+        GMAT,         // a GMat
+        RECT,         // a cv::Rect
+        // NB: Add more types when required
+    };
+
+    // Describe specialization types of interest first
+    // FIXME: It comes to GArg but ideally it should go to *Desc{}
+    // type family. Bringing it there is a more massive change though.
+    template<typename T> struct GSpecTraits;
+    template<typename T> struct GSpecTraits
+    {
+        static constexpr const ArgSpec spec = ArgSpec::OPAQUE_SPEC;
+    };
+    template<>           struct GSpecTraits<cv::GMat>
+    {
+        static constexpr const ArgSpec spec = ArgSpec::GMAT;
+    };
+    template<>           struct GSpecTraits<cv::Rect>
+    {
+        static constexpr const ArgSpec spec = ArgSpec::RECT;
+    };
+
     enum class OpaqueKind: int
     {
         CV_UNKNOWN,    // Unknown, generic, opaque-to-GAPI data type unsupported in graph seriallization
@@ -69,35 +95,44 @@ namespace detail
     // cv::GArg to store meta information about types passed into
     // operation arguments. Please note that cv::GComputation is
     // defined on GProtoArgs, not GArgs!
+    //
+    // spec is a type specialization (makes sense for GArray<> and GOpaque<>)
+    // for the rest, it is just OPAQUE_VAL by default.
     template<typename T> struct GTypeTraits;
     template<typename T> struct GTypeTraits
     {
         static constexpr const ArgKind kind = ArgKind::OPAQUE_VAL;
+        static constexpr const ArgSpec spec = ArgSpec::OPAQUE_SPEC;
     };
     template<>           struct GTypeTraits<cv::GMat>
     {
         static constexpr const ArgKind kind = ArgKind::GMAT;
         static constexpr const GShape shape = GShape::GMAT;
+        static constexpr const ArgSpec spec = ArgSpec::OPAQUE_SPEC;
     };
     template<>           struct GTypeTraits<cv::GMatP>
     {
         static constexpr const ArgKind kind = ArgKind::GMATP;
         static constexpr const GShape shape = GShape::GMAT;
+        static constexpr const ArgSpec spec = ArgSpec::OPAQUE_SPEC;
     };
     template<>           struct GTypeTraits<cv::GFrame>
     {
         static constexpr const ArgKind kind = ArgKind::GFRAME;
         static constexpr const GShape shape = GShape::GMAT;
+        static constexpr const ArgSpec spec = ArgSpec::OPAQUE_SPEC;
     };
     template<>           struct GTypeTraits<cv::GScalar>
     {
         static constexpr const ArgKind kind = ArgKind::GSCALAR;
         static constexpr const GShape shape = GShape::GSCALAR;
+        static constexpr const ArgSpec spec = ArgSpec::OPAQUE_SPEC;
     };
     template<class T> struct GTypeTraits<cv::GArray<T> >
     {
         static constexpr const ArgKind kind = ArgKind::GARRAY;
         static constexpr const GShape shape = GShape::GARRAY;
+        static constexpr const ArgSpec spec = GSpecTraits<T>::spec;
         using host_type  = std::vector<T>;
         using strip_type = cv::detail::VectorRef;
         static cv::detail::GArrayU   wrap_value(const cv::GArray<T>  &t) { return t.strip();}
@@ -108,6 +143,7 @@ namespace detail
     {
         static constexpr const ArgKind kind = ArgKind::GOPAQUE;
         static constexpr const GShape shape = GShape::GOPAQUE;
+        static constexpr const ArgSpec spec = GSpecTraits<T>::spec;
         using host_type  = T;
         using strip_type = cv::detail::OpaqueRef;
         static cv::detail::GOpaqueU  wrap_value(const cv::GOpaque<T>  &t) { return t.strip();}
@@ -140,6 +176,7 @@ namespace detail
     template<>           struct GTypeOf<cv::Scalar>            { using type = cv::GScalar;   };
     template<typename U> struct GTypeOf<std::vector<U> >       { using type = cv::GArray<U>; };
     template<typename U> struct GTypeOf                        { using type = cv::GOpaque<U>;};
+
     // FIXME: This is not quite correct since IStreamSource may produce not only Mat but also Scalar
     // and vector data. TODO: Extend the type dispatching on these types too.
     template<>           struct GTypeOf<cv::gapi::wip::IStreamSource::Ptr> { using type = cv::GMat;};