Merge pull request #15090 from dmatveev:dm/ng-0001-g-api-inference-api

* G-API-NG/API: Introduced inference API and IE-based backend

- Very quick-n-dirty implementation
- OpenCV's own DNN module is not used
- No tests so far

* G-API-NG/IE: Refined IE backend, added more tests

* G-API-NG/IE: Fixed various CI warnings & build issues + tests

- Added tests on multi-dimensional own::Mat
- Added tests on GMatDesc with dimensions
- Documentation on infer.hpp
- Fixed more warnings + added a ROI list test
- Fix descr_of clash for vector<Mat> & standalone mode
- Fix build issue with gcc-4.8x
- Addressed review comments

* G-API-NG/IE: Addressed review comments

- Pass `false` to findDataFile()
- Add deprecation warning suppression macros for IE

modules/gapi/CMakeLists.txt

@@ -15,6 +15,7 @@ if (NOT HAVE_CXX11 OR NOT TARGET ade)
 endif()
 
 set(the_description "OpenCV G-API Core Module")
+
 ocv_add_module(gapi opencv_imgproc)
 
 file(GLOB gapi_ext_hdrs
@@ -45,6 +46,7 @@ set(gapi_srcs
     src/api/kernels_core.cpp
     src/api/kernels_imgproc.cpp
     src/api/render.cpp
+    src/api/ginfer.cpp
 
     # Compiler part
     src/compiler/gmodel.cpp
@@ -82,6 +84,10 @@ set(gapi_srcs
     src/backends/ocl/goclimgproc.cpp
     src/backends/ocl/goclcore.cpp
 
+    # IE Backend. FIXME: should be included by CMake
+    # if and only if IE support is enabled
+    src/backends/ie/giebackend.cpp
+
     # Compound
     src/backends/common/gcompoundbackend.cpp
     src/backends/common/gcompoundkernel.cpp
@@ -100,9 +106,8 @@ ocv_module_include_directories("${CMAKE_CURRENT_LIST_DIR}/src")
 
 # Note `ade` is not a module name but link dependency for ${the_module}
 # (which is opencv_gapi)
-ocv_create_module(ade)
-
-ocv_add_accuracy_tests()
+ocv_create_module(ade ${INF_ENGINE_TARGET})
+ocv_add_accuracy_tests(${INF_ENGINE_TARGET})
 # FIXME: test binary is linked with ADE directly since ADE symbols
 # are not exported from libopencv_gapi.so in any form - thus
 # there're two copies of ADE code in memory when tests run (!)

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

@@ -20,6 +20,9 @@
 #include <opencv2/gapi/util/throw.hpp>
 #include <opencv2/gapi/own/assert.hpp>
 
+#include <opencv2/gapi/gmat.hpp>    // flatten_g only!
+#include <opencv2/gapi/gscalar.hpp> // flatten_g only!
+
 namespace cv
 {
 // Forward declaration; GNode and GOrigin are an internal
@@ -247,6 +250,24 @@ namespace detail
             return m_ref->m_desc;
         }
     };
+
+    // Helper (FIXME: work-around?)
+    // stripping G types to their host types
+    // like cv::GArray<GMat> would still map to std::vector<cv::Mat>
+    // but not to std::vector<cv::GMat>
+#if defined(GAPI_STANDALONE)
+#  define FLATTEN_NS cv::gapi::own
+#else
+#  define FLATTEN_NS cv
+#endif
+    template<class T> struct flatten_g;
+    template<> struct flatten_g<cv::GMat>    { using type = FLATTEN_NS::Mat; };
+    template<> struct flatten_g<cv::GScalar> { using type = FLATTEN_NS::Scalar; };
+    template<class T> struct flatten_g       { using type = T; };
+#undef FLATTEN_NS
+    // FIXME: the above mainly duplicates "ProtoToParam" thing from gtyped.hpp
+    // but I decided not to include gtyped here - probably worth moving that stuff
+    // to some common place? (DM)
 } // namespace detail
 
 /** \addtogroup gapi_data_objects
@@ -263,10 +284,16 @@ public:
     detail::GArrayU strip() const { return m_ref; }
 
 private:
-    static void VCTor(detail::VectorRef& vref) { vref.reset<T>(); }
+    // Host type (or Flat type) - the type this GArray is actually
+    // specified to.
+    using HT = typename detail::flatten_g<typename std::decay<T>::type>::type;
+
+    static void VCTor(detail::VectorRef& vref) {
+        vref.reset<HT>();
+    }
     void putDetails() {
         m_ref.setConstructFcn(&VCTor);
-        m_ref.specifyType<T>();
+        m_ref.specifyType<HT>();
     }
 
     detail::GArrayU m_ref;

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

@@ -36,8 +36,9 @@ struct GAPI_EXPORTS GKernel
     using M = std::function<GMetaArgs(const GMetaArgs &, const GArgs &)>;
 
     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 GShapes     outShapes; // types (shapes) kernel's outputs
+    const GShapes     outShapes;  // types (shapes) kernel's outputs
 };
 
 // GKernelImpl describes particular kernel implementation to the system
@@ -166,6 +167,12 @@ namespace detail
         }
     };
 
+    ////////////////////////////////////////////////////////////////////////////
+    // Helper class to introduce tags to calls. By default there's no tag
+    struct NoTag {
+        static constexpr const char *tag() { return ""; }
+    };
+
 } // namespace detail
 
 // GKernelType and GKernelTypeM are base classes which implement typed ::on()
@@ -175,8 +182,9 @@ namespace detail
 // GKernelTypeM respectively.
 
 template<typename K, typename... R, typename... Args>
-class GKernelTypeM<K, std::function<std::tuple<R...>(Args...)> >:
-        public detail::MetaHelper<K, std::tuple<Args...>, std::tuple<R...>>
+class GKernelTypeM<K, std::function<std::tuple<R...>(Args...)> >
+    : public detail::MetaHelper<K, std::tuple<Args...>, std::tuple<R...>>
+    , public detail::NoTag
 {
     template<int... IIs>
     static std::tuple<R...> yield(cv::GCall &call, detail::Seq<IIs...>)
@@ -190,7 +198,7 @@ public:
 
     static std::tuple<R...> on(Args... args)
     {
-        cv::GCall call(GKernel{K::id(), &K::getOutMeta, {detail::GTypeTraits<R>::shape...}});
+        cv::GCall call(GKernel{K::id(), K::tag(), &K::getOutMeta, {detail::GTypeTraits<R>::shape...}});
         call.pass(args...);
         return yield(call, typename detail::MkSeq<sizeof...(R)>::type());
     }
@@ -199,8 +207,9 @@ public:
 template<typename, typename> class GKernelType;
 
 template<typename K, typename R, typename... Args>
-class GKernelType<K, std::function<R(Args...)> >:
-        public detail::MetaHelper<K, std::tuple<Args...>, R>
+class GKernelType<K, std::function<R(Args...)> >
+    : public detail::MetaHelper<K, std::tuple<Args...>, R>
+    , public detail::NoTag
 {
 public:
     using InArgs  = std::tuple<Args...>;
@@ -208,7 +217,7 @@ public:
 
     static R on(Args... args)
     {
-        cv::GCall call(GKernel{K::id(), &K::getOutMeta, {detail::GTypeTraits<R>::shape}});
+        cv::GCall call(GKernel{K::id(), K::tag(), &K::getOutMeta, {detail::GTypeTraits<R>::shape}});
         call.pass(args...);
         return detail::Yield<R>::yield(call, 0);
     }
@@ -244,6 +253,9 @@ public:
                         public detail::G_ID_HELPER_CLASS(Class)
 // {body} is to be defined by user
 
+#define G_API_OP   G_TYPED_KERNEL
+#define G_API_OP_M G_TYPED_KERNEL_M
+
 namespace cv
 {
 namespace gapi
@@ -437,6 +449,7 @@ namespace gapi {
             return includesAPI(KAPI::id());
         }
 
+        // FIXME: The below comment is wrong, and who needs this function?
         /**
          * @brief Find a kernel (by its API)
          *

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

@@ -69,15 +69,26 @@ struct GAPI_EXPORTS GMatDesc
     int chan;
     cv::gapi::own::Size size; // NB.: no multi-dimensional cases covered yet
     bool planar;
+    std::vector<int> dims; // FIXME: Maybe it's real questionable to have it here
 
     GMatDesc(int d, int c, cv::gapi::own::Size s, bool p = false)
         : depth(d), chan(c), size(s), planar(p) {}
 
+    GMatDesc(int d, const std::vector<int> &dd)
+        : depth(d), chan(-1), size{-1,-1}, planar(false), dims(dd) {}
+
+    GMatDesc(int d, std::vector<int> &&dd)
+        : depth(d), chan(-1), size{-1,-1}, planar(false), dims(std::move(dd)) {}
+
     GMatDesc() : GMatDesc(-1, -1, {-1,-1}) {}
 
     inline bool operator== (const GMatDesc &rhs) const
     {
-        return depth == rhs.depth && chan == rhs.chan && size == rhs.size && planar == rhs.planar;
+        return    depth  == rhs.depth
+               && chan   == rhs.chan
+               && size   == rhs.size
+               && planar == rhs.planar
+               && dims   == rhs.dims;
     }
 
     inline bool operator!= (const GMatDesc &rhs) const
@@ -85,6 +96,8 @@ struct GAPI_EXPORTS GMatDesc
         return !(*this == rhs);
     }
 
+    bool isND() const { return !dims.empty(); }
+
     // Checks if the passed mat can be described by this descriptor
     // (it handles the case when
     // 1-channel mat can be reinterpreted as is (1-channel mat)

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

@@ -61,13 +61,15 @@ namespace detail
 
 } // namespace detail
 
+// Note: descr_of(std::vector<..>) returns a GArrayDesc, while
+//       descrs_of(std::vector<..>) returns an array of Meta args!
 class Mat;
 class UMat;
-GAPI_EXPORTS cv::GMetaArgs descr_of(const std::vector<cv::Mat> &vec);
-GAPI_EXPORTS cv::GMetaArgs descr_of(const std::vector<cv::UMat> &vec);
+GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<cv::Mat> &vec);
+GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<cv::UMat> &vec);
 namespace gapi { namespace own {
     class Mat;
-    GAPI_EXPORTS cv::GMetaArgs descr_of(const std::vector<Mat> &vec);
+    GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<Mat> &vec);
 }} // namespace gapi::own
 
 } // namespace cv

modules/gapi/include/opencv2/gapi/infer.hpp

+// 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) 2019 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_INFER_HPP
+#define OPENCV_GAPI_INFER_HPP
+
+// FIXME: Inference API is currently only available in full mode
+#if !defined(GAPI_STANDALONE)
+
+#include <functional>
+#include <string>  // string
+#include <utility> // tuple
+
+#include <opencv2/gapi/util/any.hpp>  // any<>
+#include <opencv2/gapi/gkernel.hpp>   // GKernelType[M], GBackend
+#include <opencv2/gapi/garg.hpp>      // GArg
+#include <opencv2/gapi/gcommon.hpp>   // CompileArgTag
+#include <opencv2/gapi/gmetaarg.hpp>  // GMetaArg
+
+namespace cv {
+
+namespace detail {
+    // This tiny class eliminates the semantic difference between
+    // GKernelType and GKernelTypeM.
+    // FIXME: Something similar can be reused for regular kernels
+    template<typename, typename>
+    struct KernelTypeMedium;
+
+    template<class K, typename... R, typename... Args>
+    struct KernelTypeMedium<K, std::function<std::tuple<R...>(Args...)> >:
+        public GKernelTypeM<K, std::function<std::tuple<R...>(Args...)> > {};
+
+    template<class K, typename R, typename... Args>
+    struct KernelTypeMedium<K, std::function<R(Args...)> >:
+        public GKernelType<K, std::function<R(Args...)> > {};
+
+} // namespace detail
+
+template<typename, typename> class GNetworkType;
+
+// TODO: maybe tuple_wrap_helper from util.hpp may help with this.
+// Multiple-return-value network definition (specialized base class)
+template<typename K, typename... R, typename... Args>
+class GNetworkType<K, std::function<std::tuple<R...>(Args...)> >
+{
+public:
+    using InArgs  = std::tuple<Args...>;
+    using OutArgs = std::tuple<R...>;
+
+    using Result  = OutArgs;
+    using API     = std::function<Result(Args...)>;
+
+    using ResultL = std::tuple< cv::GArray<R>... >;
+    using APIList = std::function<ResultL(cv::GArray<cv::Rect>, Args...)>;
+};
+
+// Single-return-value network definition (specialized base class)
+template<typename K, typename R, typename... Args>
+class GNetworkType<K, std::function<R(Args...)> >
+{
+public:
+    using InArgs  = std::tuple<Args...>;
+    using OutArgs = std::tuple<R>;
+
+    using Result  = R;
+    using API     = std::function<R(Args...)>;
+
+    using ResultL = cv::GArray<R>;
+    using APIList = std::function<ResultL(cv::GArray<cv::Rect>, Args...)>;
+};
+
+// Base "Infer" kernel. Note - for whatever network, kernel ID
+// is always the same. Different inference calls are distinguished by
+// network _tag_ (an extra field in GCall)
+//
+// getOutMeta is a stub callback collected by G-API kernel subsystem
+// automatically. This is a rare case when this callback is defined by
+// a particular backend, not by a network itself.
+struct GInferBase {
+    static constexpr const char * id() {
+        return "org.opencv.dnn.infer";     // Universal stub
+    }
+    static GMetaArgs getOutMeta(const GMetaArgs &, const GArgs &) {
+        return GMetaArgs{};                // One more universal stub
+    }
+};
+
+
+// Base "Infer list" kernel.
+// All notes from "Infer" kernel apply here as well.
+struct GInferListBase {
+    static constexpr const char * id() {
+        return "org.opencv.dnn.infer-roi"; // Universal stub
+    }
+    static GMetaArgs getOutMeta(const GMetaArgs &, const GArgs &) {
+        return GMetaArgs{};                // One more universal stub
+    }
+};
+
+// A generic inference kernel. API (::on()) is fully defined by the Net
+// template parameter.
+// Acts as a regular kernel in graph (via KernelTypeMedium).
+template<typename Net>
+struct GInfer final
+    : public GInferBase
+    , public detail::KernelTypeMedium< GInfer<Net>
+                                     , typename Net::API > {
+    using GInferBase::getOutMeta; // FIXME: name lookup conflict workaround?
+
+    static constexpr const char* tag() { return Net::tag(); }
+};
+
+// A generic roi-list inference kernel. API (::on()) is derived from
+// the Net template parameter (see more in infer<> overload).
+template<typename Net>
+struct GInferList final
+    : public GInferListBase
+    , public detail::KernelTypeMedium< GInferList<Net>
+                                     , typename Net::APIList > {
+    using GInferListBase::getOutMeta; // FIXME: name lookup conflict workaround?
+
+    static constexpr const char* tag() { return Net::tag(); }
+};
+
+} // namespace cv
+
+// FIXME: Probably the <API> signature makes a function/tuple/function round-trip
+#define G_API_NET(Class, API, Tag)                                      \
+    struct Class final: public cv::GNetworkType<Class, std::function API> { \
+        static constexpr const char * tag() { return Tag; }             \
+    }
+
+namespace cv {
+namespace gapi {
+
+
+/** @brief Calculates responses for the specified network (template
+ *     parameter) for every region in the source image.
+ *
+ * @tparam A network type defined with G_API_NET() macro.
+ * @param roi a list of rectangles describing regions of interest
+ *   in the source image. Usually an output of object detector or tracker.
+ * @param args network's input parameters as specified in G_API_NET() macro.
+ *   NOTE: verified to work reliably with 1-input topologies only.
+ * @return a list of objects of return type as defined in G_API_NET().
+ *   If a network has multiple return values (defined with a tuple), a tuple of
+ *   GArray<> objects is returned with the appropriate types inside.
+ * @sa  G_API_NET()
+ */
+template<typename Net, typename... Args>
+typename Net::ResultL infer(cv::GArray<cv::Rect> roi, Args&&... args) {
+    return GInferList<Net>::on(roi, std::forward<Args>(args)...);
+}
+
+/**
+ * @brief Calculates response for the specified network (template
+ *     parameter) given the input data.
+ *
+ * @tparam A network type defined with G_API_NET() macro.
+ * @param args network's input parameters as specified in G_API_NET() macro.
+ * @return an object of return type as defined in G_API_NET().
+ *   If a network has multiple return values (defined with a tuple), a tuple of
+ *   objects of apprpriate type is returned.
+ * @sa  G_API_NET()
+ */
+template<typename Net, typename... Args>
+typename Net::Result infer(Args&&... args) {
+    return GInfer<Net>::on(std::forward<Args>(args)...);
+}
+
+
+} // namespace gapi
+} // namespace cv
+
+#endif // GAPI_STANDALONE
+
+namespace cv {
+namespace gapi {
+
+// Note: the below code _is_ part of STANDALONE build,
+// just to make our compiler code compileable.
+
+// A type-erased form of network parameters.
+// Similar to how a type-erased GKernel is represented and used.
+struct GAPI_EXPORTS GNetParam {
+    std::string tag;     // FIXME: const?
+    GBackend backend;    // Specifies the execution model
+    util::any params;    // Backend-interpreted parameter structure
+};
+
+/**
+ * @brief A container class for network configurations. Similar to
+ * GKernelPackage.Use cv::gapi::networks() to construct this object.
+ *
+ * @sa cv::gapi::networks
+ */
+struct GAPI_EXPORTS GNetPackage {
+    explicit GNetPackage(std::initializer_list<GNetParam> &&ii = {});
+    std::vector<GBackend> backends() const;
+    std::vector<GNetParam> networks;
+};
+} // namespace gapi
+
+namespace detail {
+template<typename T>
+gapi::GNetParam strip(T&& t) {
+    return gapi::GNetParam { t.tag()
+                           , t.backend()
+                           , t.params()
+                           };
+}
+
+template<> struct CompileArgTag<cv::gapi::GNetPackage> {
+    static const char* tag() { return "gapi.net_package"; }
+};
+
+} // namespace cv::detail
+
+namespace gapi {
+template<typename... Args>
+cv::gapi::GNetPackage networks(Args&&... args) {
+    return cv::gapi::GNetPackage({ cv::detail::strip(args)... });
+}
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_INFER_HPP

modules/gapi/include/opencv2/gapi/infer/ie.hpp

+// 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) 2019 Intel Corporation
+
+#ifndef OPENCV_GAPI_INFER_IE_HPP
+#define OPENCV_GAPI_INFER_IE_HPP
+
+#ifdef HAVE_INF_ENGINE
+
+#include <unordered_map>
+#include <string>
+#include <array>
+#include <tuple> // tuple, tuple_size
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/util/any.hpp>
+
+namespace cv {
+namespace gapi {
+// FIXME: introduce a new sub-namespace for NN?
+namespace ie {
+
+GAPI_EXPORTS cv::gapi::GBackend backend();
+
+namespace detail {
+    struct ParamDesc {
+        std::string model_path;
+        std::string weights_path;
+        std::string device_id;
+
+        // NB: Here order follows the `Net` API
+        std::vector<std::string> input_names;
+        std::vector<std::string> output_names;
+
+        std::unordered_map<std::string, cv::Mat> const_inputs;
+
+        // NB: nun_* may differ from topology's real input/output port numbers
+        // (e.g. topology's partial execution)
+        std::size_t num_in;  // How many inputs are defined in the operation
+        std::size_t num_out; // How many outputs are defined in the operation
+    };
+} // namespace detail
+
+// FIXME: this is probably a shared (reusable) thing
+template<typename Net>
+struct PortCfg {
+    using In = std::array
+        < std::string
+        , std::tuple_size<typename Net::InArgs>::value >;
+    using Out = std::array
+        < std::string
+        , std::tuple_size<typename Net::OutArgs>::value >;
+};
+
+template<typename Net> class Params {
+public:
+    Params(const std::string &model,
+           const std::string &weights,
+           const std::string &device)
+        : desc{ model, weights, device, {}, {}, {}
+              , std::tuple_size<typename Net::InArgs>::value
+              , std::tuple_size<typename Net::OutArgs>::value
+              } {
+    };
+
+    Params<Net>& cfgInputLayers(const typename PortCfg<Net>::In &ll) {
+        desc.input_names.clear();
+        desc.input_names.reserve(ll.size());
+        std::copy(ll.begin(), ll.end(),
+                  std::back_inserter(desc.input_names));
+        return *this;
+    }
+
+    Params<Net>& cfgOutputLayers(const typename PortCfg<Net>::Out &ll) {
+        desc.output_names.clear();
+        desc.output_names.reserve(ll.size());
+        std::copy(ll.begin(), ll.end(),
+                  std::back_inserter(desc.output_names));
+        return *this;
+    }
+
+    Params<Net>& constInput(const std::string &layer_name,
+                            const cv::Mat &data) {
+        desc.const_inputs[layer_name] = data;
+        return *this;
+    }
+
+    // BEGIN(G-API's network parametrization API)
+    GBackend      backend() const { return cv::gapi::ie::backend();  }
+    std::string   tag()     const { return Net::tag(); }
+    cv::util::any params()  const { return { desc }; }
+    // END(G-API's network parametrization API)
+
+protected:
+    detail::ParamDesc desc;
+};
+
+} // namespace ie
+} // namespace gapi
+} // namespace cv
+
+#endif // HAVE_INF_ENGINE
+
+#endif // OPENCV_GAPI_INFER_HPP

modules/gapi/include/opencv2/gapi/infer/ie/util.hpp

+// 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) 2019 Intel Corporation
+
+#ifndef OPENCV_GAPI_INFER_IE_UTIL_HPP
+#define OPENCV_GAPI_INFER_IE_UTIL_HPP
+
+#ifdef HAVE_INF_ENGINE
+
+// NOTE: This file is not included by default in infer/ie.hpp
+// and won't be. infer/ie.hpp doesn't depend on IE headers itself.
+// This file does -- so needs to be included separately by those who care.
+
+#include "inference_engine.hpp"
+
+namespace cv {
+namespace gapi {
+namespace ie {
+namespace util {
+
+GAPI_EXPORTS std::vector<int> to_ocv(const InferenceEngine::SizeVector &dims);
+
+GAPI_EXPORTS cv::Mat to_ocv(InferenceEngine::Blob::Ptr blob);
+GAPI_EXPORTS InferenceEngine::Blob::Ptr to_ie(cv::Mat &blob);
+
+}}}}
+
+#endif // HAVE_INF_ENGINE
+#endif // OPENCV_GAPI_INFER_IE_UTIL_HPP

modules/gapi/include/opencv2/gapi/own/convert.hpp

@@ -17,8 +17,23 @@
 
 namespace cv
 {
-    inline cv::gapi::own::Mat to_own(Mat const& m) { return {m.rows, m.cols, m.type(), m.data, m.step};};
+    template<typename T>
+    std::vector<T> to_own(const cv::MatSize &sz) {
+        std::vector<T> result(sz.dims());
+        for (int i = 0; i < sz.dims(); i++) {
+            // Note: cv::MatSize is not iterable
+            result[i] = static_cast<T>(sz[i]);
+        }
+        return result;
+    }
+
            cv::gapi::own::Mat to_own(Mat&&) = delete;
+    inline cv::gapi::own::Mat to_own(Mat const& m) {
+        return (m.dims == 2)
+            ?  cv::gapi::own::Mat{m.rows, m.cols, m.type(), m.data, m.step}
+            :  cv::gapi::own::Mat{to_own<int>(m.size), m.type(), m.data};
+    };
+
 
     inline cv::gapi::own::Scalar to_own(const cv::Scalar& s) { return {s[0], s[1], s[2], s[3]}; };
 
@@ -32,7 +47,11 @@ namespace gapi
 {
 namespace own
 {
-    inline cv::Mat to_ocv(Mat const& m) { return {m.rows, m.cols, m.type(), m.data, m.step};};
+    inline cv::Mat to_ocv(Mat const& m) {
+        return m.dims.empty()
+            ? cv::Mat{m.rows, m.cols, m.type(), m.data, m.step}
+            : cv::Mat{m.dims, m.type(), m.data};
+    }
            cv::Mat to_ocv(Mat&&)    = delete;
 
     inline cv::Scalar to_ocv(const Scalar& s) { return {s[0], s[1], s[2], s[3]}; };

modules/gapi/include/opencv2/gapi/own/mat.hpp

@@ -16,6 +16,7 @@
 
 #include <memory>                   //std::shared_ptr
 #include <cstring>                  //std::memcpy
+#include <numeric>                  //std::accumulate
 #include <opencv2/gapi/util/throw.hpp>
 
 namespace cv { namespace gapi { namespace own {
@@ -49,6 +50,10 @@ namespace cv { namespace gapi { namespace own {
             : flags((type & TYPE_MASK)), rows(_rows), cols(_cols), data((uchar*)_data), step(_step == AUTO_STEP ? detail::default_step(type, _cols) : _step)
             {}
 
+            MatHeader(const std::vector<int> &_dims, int type, void* _data)
+            : flags((type & TYPE_MASK)), data((uchar*)_data), step(0), dims(_dims)
+            {}
+
             MatHeader(const MatHeader& ) = default;
             MatHeader(MatHeader&& src) : MatHeader(src) // reuse copy constructor here
             {
@@ -74,8 +79,10 @@ namespace cv { namespace gapi { namespace own {
             //! pointer to the data
             uchar* data = nullptr;
             size_t step = 0;
+            //! dimensions (ND-case)
+            std::vector<int> dims;
         };
-    }
+    } // namespace detail
     //concise version of cv::Mat suitable for GAPI needs (used when no dependence on OpenCV is required)
     class Mat : public detail::MatHeader{
     public:
@@ -100,6 +107,14 @@ namespace cv { namespace gapi { namespace own {
         : MatHeader (_rows, _cols, _type, _data, _step)
         {}
 
+        Mat(const std::vector<int> &_dims, int _type, void* _data)
+        : MatHeader (_dims, _type, _data)
+        {}
+
+        Mat(std::vector<int> &&_dims, int _type, void* _data)
+        : MatHeader (std::move(_dims), _type, _data)
+        {}
+
         Mat(Mat const& src, const Rect& roi )
         : Mat(src)
         {
@@ -120,9 +135,6 @@ namespace cv { namespace gapi { namespace own {
         Mat& operator = (const Scalar& s)
         {
             constexpr unsigned max_channels = 4; //Scalar can't fit more than 4
-            const auto channels = static_cast<unsigned int>(this->channels());
-            GAPI_Assert(channels <= max_channels);
-
             using func_p_t = void (*)(void*, int, Scalar const&);
             using detail::assign_row;
             #define TABLE_ENTRY(type)  {assign_row<type, 1>, assign_row<type, 2>, assign_row<type, 3>, assign_row<type, 4>}
@@ -145,10 +157,22 @@ namespace cv { namespace gapi { namespace own {
             const auto depth = static_cast<unsigned int>(this->depth());
             GAPI_Assert(depth < sizeof(func_tbl)/sizeof(func_tbl[0]));
 
-            for (int r = 0; r < rows; ++r)
+            if (dims.empty())
+            {
+                const auto channels = static_cast<unsigned int>(this->channels());
+                GAPI_Assert(channels <= max_channels);
+
+                auto* f = func_tbl[depth][channels - 1];
+                for (int r = 0; r < rows; ++r)
+                {
+                    (*f)(static_cast<void *>(ptr(r)), cols, s );
+                }
+            }
+            else
             {
-                auto* f = func_tbl[depth][channels -1];
-                (*f)(static_cast<void *>(ptr(r)), cols, s );
+                auto* f = func_tbl[depth][0];
+                // FIXME: better to refactor assign_row to use std::size_t by default
+                (*f)(static_cast<void *>(data), static_cast<int>(total()), s);
             }
             return *this;
         }
@@ -187,8 +211,9 @@ namespace cv { namespace gapi { namespace own {
         /** @brief Returns the number of matrix channels.
 
         The method returns the number of matrix channels.
+        If matrix is N-dimensional, -1 is returned.
          */
-        int channels() const        {return CV_MAT_CN(flags);}
+        int channels() const        {return dims.empty() ? CV_MAT_CN(flags) : -1;}
 
         /**
         @param _rows New number of rows.
@@ -197,7 +222,7 @@ namespace cv { namespace gapi { namespace own {
          */
         void create(int _rows, int _cols, int _type)
         {
-            create({_cols, _rows}, _type);
+            create(Size{_cols, _rows}, _type);
         }
         /** @overload
         @param _size Alternative new matrix size specification: Size(cols, rows)
@@ -215,6 +240,18 @@ namespace cv { namespace gapi { namespace own {
             }
         }
 
+        void create(const std::vector<int> &_dims, int _type)
+        {
+            // FIXME: make a proper reallocation-on-demands
+            // WARNING: no tensor views, so no strides
+            Mat tmp{_dims, _type, nullptr};
+            // FIXME: this accumulate duplicates a lot
+            const auto sz = std::accumulate(_dims.begin(), _dims.end(), 1, std::multiplies<int>());
+            tmp.memory.reset(new uchar[CV_ELEM_SIZE(_type)*sz], [](uchar * p){delete[] p;});
+            tmp.data = tmp.memory.get();
+            *this = std::move(tmp);
+        }
+
         /** @brief Copies the matrix to another one.
 
         The method copies the matrix data to another matrix. Before copying the data, the method invokes :
@@ -227,10 +264,18 @@ namespace cv { namespace gapi { namespace own {
          */
         void copyTo(Mat& dst) const
         {
-            dst.create(rows, cols, type());
-            for (int r = 0; r < rows; ++r)
+            if (dims.empty())
             {
-                std::copy_n(ptr(r), detail::default_step(type(),cols), dst.ptr(r));
+                dst.create(rows, cols, type());
+                for (int r = 0; r < rows; ++r)
+                {
+                    std::copy_n(ptr(r), detail::default_step(type(),cols), dst.ptr(r));
+                }
+            }
+            else
+            {
+                dst.create(dims, depth());
+                std::copy_n(data, total()*elemSize(), data);
             }
         }
 
@@ -248,10 +293,12 @@ namespace cv { namespace gapi { namespace own {
          */
         size_t total() const
         {
-            return static_cast<size_t>(rows * cols);
+            return static_cast<std::size_t>
+                (dims.empty()
+                 ? (rows * cols)
+                 : std::accumulate(dims.begin(), dims.end(), 1, std::multiplies<int>()));
         }
 
-
         /** @overload
         @param roi Extracted submatrix specified as a rectangle.
         */

modules/gapi/src/api/gbackend.cpp

@@ -7,6 +7,7 @@
 
 #include "precomp.hpp"
 #include <memory> // unique_ptr
+#include <functional> // multiplies
 
 #include <opencv2/gapi/gkernel.hpp>
 #include <opencv2/gapi/own/convert.hpp>
@@ -355,21 +356,39 @@ void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg, bool is_umat)
 
 } // namespace magazine
 
-void createMat(const cv::GMatDesc desc, cv::gapi::own::Mat& mat)
+void createMat(const cv::GMatDesc &desc, cv::gapi::own::Mat& mat)
 {
-    const auto type = desc.planar ? desc.depth : CV_MAKETYPE(desc.depth, desc.chan);
-    const auto size = desc.planar ? cv::gapi::own::Size{desc.size.width, desc.size.height*desc.chan}
-                                  : desc.size;
-    mat.create(size, type);
+    // FIXME: Refactor (probably start supporting N-Dimensional blobs natively
+    if (desc.dims.empty())
+    {
+        const auto type = desc.planar ? desc.depth : CV_MAKETYPE(desc.depth, desc.chan);
+        const auto size = desc.planar ? cv::gapi::own::Size{desc.size.width, desc.size.height*desc.chan}
+                                      : desc.size;
+        mat.create(size, type);
+    }
+    else
+    {
+        GAPI_Assert(!desc.planar);
+        mat.create(desc.dims, desc.depth);
+    }
 }
 
 #if !defined(GAPI_STANDALONE)
-void createMat(const cv::GMatDesc desc, cv::Mat& mat)
+void createMat(const cv::GMatDesc &desc, cv::Mat& mat)
 {
-    const auto type = desc.planar ? desc.depth : CV_MAKETYPE(desc.depth, desc.chan);
-    const auto size = desc.planar ? cv::Size{desc.size.width, desc.size.height*desc.chan}
-                                  : cv::gapi::own::to_ocv(desc.size);
-    mat.create(size, type);
+    // FIXME: Refactor (probably start supporting N-Dimensional blobs natively
+    if (desc.dims.empty())
+    {
+        const auto type = desc.planar ? desc.depth : CV_MAKETYPE(desc.depth, desc.chan);
+        const auto size = desc.planar ? cv::Size{desc.size.width, desc.size.height*desc.chan}
+                                      : cv::gapi::own::to_ocv(desc.size);
+        mat.create(size, type);
+    }
+    else
+    {
+        GAPI_Assert(!desc.planar);
+        mat.create(desc.dims, desc.depth);
+    }
 }
 #endif
 

modules/gapi/src/api/ginfer.cpp

+// 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) 2018-2019 Intel Corporation
+
+
+#include "precomp.hpp"
+
+#include <functional> // hash
+#include <numeric> // accumulate
+#include <unordered_set>
+#include <iterator>
+
+#include <ade/util/algorithm.hpp>
+
+#include <opencv2/gapi/infer.hpp>
+
+cv::gapi::GNetPackage::GNetPackage(std::initializer_list<GNetParam> &&ii)
+    : networks(std::move(ii)) {
+}
+
+std::vector<cv::gapi::GBackend> cv::gapi::GNetPackage::backends() const {
+    std::unordered_set<cv::gapi::GBackend> unique_set;
+    for (const auto &nn : networks) unique_set.insert(nn.backend);
+    return std::vector<cv::gapi::GBackend>(unique_set.begin(), unique_set.end());
+}

modules/gapi/src/api/gmat.cpp

@@ -6,6 +6,10 @@
 
 
 #include "precomp.hpp"
+
+#include <ade/util/iota_range.hpp>
+#include <ade/util/algorithm.hpp>
+
 #include <opencv2/gapi/opencv_includes.hpp>
 #include <opencv2/gapi/own/mat.hpp> //gapi::own::Mat
 #include <opencv2/gapi/gmat.hpp>
@@ -49,20 +53,31 @@ namespace{
 #if !defined(GAPI_STANDALONE)
 cv::GMatDesc cv::descr_of(const cv::Mat &mat)
 {
-    return GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}};
+    const auto mat_dims = mat.size.dims();
+
+    if (mat_dims == 2)
+        return GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}};
+
+    std::vector<int> dims(mat_dims);
+    for (auto i : ade::util::iota(mat_dims)) {
+        // Note: cv::MatSize is not iterable
+        dims[i] = mat.size[i];
+    }
+    return GMatDesc{mat.depth(), std::move(dims)};
 }
 
 cv::GMatDesc cv::descr_of(const cv::UMat &mat)
 {
+    GAPI_Assert(mat.size.dims() == 2);
     return GMatDesc{ mat.depth(), mat.channels(),{ mat.cols, mat.rows } };
 }
 
-cv::GMetaArgs cv::descr_of(const std::vector<cv::Mat> &vec)
+cv::GMetaArgs cv::descrs_of(const std::vector<cv::Mat> &vec)
 {
     return vec_descr_of(vec);
 }
 
-cv::GMetaArgs cv::descr_of(const std::vector<cv::UMat> &vec)
+cv::GMetaArgs cv::descrs_of(const std::vector<cv::UMat> &vec)
 {
     return vec_descr_of(vec);
 }
@@ -70,10 +85,12 @@ cv::GMetaArgs cv::descr_of(const std::vector<cv::UMat> &vec)
 
 cv::GMatDesc cv::gapi::own::descr_of(const cv::gapi::own::Mat &mat)
 {
-    return GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}};
+    return (mat.dims.empty())
+        ? GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}}
+        : GMatDesc{mat.depth(), mat.dims};
 }
 
-cv::GMetaArgs cv::gapi::own::descr_of(const std::vector<cv::gapi::own::Mat> &vec)
+cv::GMetaArgs cv::gapi::own::descrs_of(const std::vector<cv::gapi::own::Mat> &vec)
 {
     return vec_descr_of(vec);
 }

modules/gapi/src/backends/common/gbackend.hpp

@@ -99,9 +99,9 @@ inline cv::util::optional<T> getCompileArg(const cv::GCompileArgs &args)
     return cv::util::optional<T>();
 }
 
-void createMat(const cv::GMatDesc desc, cv::gapi::own::Mat& mat);
+void createMat(const cv::GMatDesc& desc, cv::gapi::own::Mat& mat);
 #if !defined(GAPI_STANDALONE)
-void createMat(const cv::GMatDesc desc, cv::Mat& mat);
+void createMat(const cv::GMatDesc& desc, cv::Mat& mat);
 #endif
 
 }} // cv::gimpl

modules/gapi/src/backends/cpu/gcpubackend.cpp

@@ -7,9 +7,6 @@
 
 #include "precomp.hpp"
 
-#include <functional>
-#include <unordered_set>
-
 #include <ade/util/algorithm.hpp>
 
 #include <ade/util/range.hpp>
@@ -26,8 +23,6 @@
 #include "compiler/gmodel.hpp"
 
 #include "backends/cpu/gcpubackend.hpp"
-#include <opencv2/gapi/cpu/imgproc.hpp>
-#include <opencv2/gapi/cpu/core.hpp>
 
 #include "api/gbackend_priv.hpp" // FIXME: Make it part of Backend SDK!
 
@@ -76,7 +71,7 @@ cv::gapi::GBackend cv::gapi::cpu::backend()
     return this_backend;
 }
 
-// GCPUExcecutable implementation //////////////////////////////////////////////
+// GCPUExecutable implementation //////////////////////////////////////////////
 cv::gimpl::GCPUExecutable::GCPUExecutable(const ade::Graph &g,
                                           const std::vector<ade::NodeHandle> &nodes)
     : m_g(g), m_gm(m_g)
@@ -92,7 +87,7 @@ cv::gimpl::GCPUExecutable::GCPUExecutable(const ade::Graph &g,
         {
             m_dataNodes.push_back(nh);
             const auto &desc = m_gm.metadata(nh).get<Data>();
-            if (desc.storage == Data::Storage::CONST)
+            if (desc.storage == Data::Storage::CONST_VAL)
             {
                 auto rc = RcDesc{desc.rc, desc.shape, desc.ctor};
                 magazine::bindInArg(m_res, rc, m_gm.metadata(nh).get<ConstValue>().arg);

modules/gapi/src/backends/cpu/gcpubackend.hpp

@@ -68,4 +68,4 @@ public:
 
 }}
 
-#endif // OPENCV_GAPI_GBACKEND_HPP
+#endif // OPENCV_GAPI_GCPUBACKEND_HPP

modules/gapi/src/backends/ie/giebackend.hpp

+// 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) 2018 Intel Corporation
+
+#ifndef OPENCV_GAPI_GIEBACKEND_HPP
+#define OPENCV_GAPI_GIEBACKEND_HPP
+
+#ifdef HAVE_INF_ENGINE
+
+#include <ade/util/algorithm.hpp> // type_list_index
+
+////////////////////////////////////////////////////////////////////////////////
+// FIXME: Suppress deprecation warnings for OpenVINO 2019R2+
+// BEGIN {{{
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+#ifdef _MSC_VER
+#pragma warning(disable: 4996)  // was declared deprecated
+#endif
+
+#if defined(__GNUC__)
+#pragma GCC visibility push(default)
+#endif
+
+#include <inference_engine.hpp>
+
+#if defined(__GNUC__)
+#pragma GCC visibility pop
+#endif
+// END }}}
+////////////////////////////////////////////////////////////////////////////////
+
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/gproto.hpp>
+#include <opencv2/gapi/infer/ie.hpp>
+
+#include "api/gorigin.hpp"
+#include "backends/common/gbackend.hpp"
+#include "compiler/gislandmodel.hpp"
+
+namespace cv {
+namespace gimpl {
+namespace ie {
+
+struct IECompiled {
+    InferenceEngine::InferencePlugin   this_plugin;
+    InferenceEngine::ExecutableNetwork this_network;
+    InferenceEngine::InferRequest      this_request;
+};
+
+class GIEExecutable final: public GIslandExecutable
+{
+    const ade::Graph &m_g;
+    GModel::ConstGraph m_gm;
+
+    // The only executable stuff in this graph
+    // (assuming it is always single-op)
+    ade::NodeHandle this_nh;
+    IECompiled this_iec;
+
+    // List of all resources in graph (both internal and external)
+    std::vector<ade::NodeHandle> m_dataNodes;
+
+    // Actual data of all resources in graph (both internal and external)
+    Mag m_res;
+
+    // Execution helpers
+    GArg packArg(const GArg &arg);
+
+public:
+    GIEExecutable(const ade::Graph                   &graph,
+                  const std::vector<ade::NodeHandle> &nodes);
+
+    virtual inline bool canReshape() const override { return false; }
+    virtual inline void reshape(ade::Graph&, const GCompileArgs&) override {
+        GAPI_Assert(false); // Not implemented yet
+    }
+
+    virtual void run(std::vector<InObj>  &&input_objs,
+                     std::vector<OutObj> &&output_objs) override;
+};
+
+}}}
+
+#endif // HAVE_INF_ENGINE
+#endif // OPENCV_GAPI_GIEBACKEND_HPP

modules/gapi/src/backends/ocl/goclbackend.cpp

@@ -7,9 +7,6 @@
 
 #include "precomp.hpp"
 
-#include <functional>
-#include <unordered_set>
-
 #include <ade/util/algorithm.hpp>
 
 #include <ade/util/range.hpp>
@@ -26,8 +23,6 @@
 #include "compiler/gmodel.hpp"
 
 #include "backends/ocl/goclbackend.hpp"
-#include "backends/ocl/goclimgproc.hpp"
-#include "backends/ocl/goclcore.hpp"
 
 #include "api/gbackend_priv.hpp" // FIXME: Make it part of Backend SDK!
 
@@ -92,7 +87,7 @@ cv::gimpl::GOCLExecutable::GOCLExecutable(const ade::Graph &g,
         {
             m_dataNodes.push_back(nh);
             const auto &desc = m_gm.metadata(nh).get<Data>();
-            if (desc.storage == Data::Storage::CONST)
+            if (desc.storage == Data::Storage::CONST_VAL)
             {
                 auto rc = RcDesc{desc.rc, desc.shape, desc.ctor};
                 magazine::bindInArg(m_res, rc, m_gm.metadata(nh).get<ConstValue>().arg);

modules/gapi/src/compiler/gcompiler.cpp

@@ -72,6 +72,12 @@ namespace
         return combine(ocv_pkg, user_pkg_with_aux);
     }
 
+    cv::gapi::GNetPackage getNetworkPackage(cv::GCompileArgs &args)
+    {
+        return cv::gimpl::getCompileArg<cv::gapi::GNetPackage>(args)
+            .value_or(cv::gapi::GNetPackage{});
+    }
+
     cv::util::optional<std::string> getGraphDumpDirectory(cv::GCompileArgs& args)
     {
         auto dump_info = cv::gimpl::getCompileArg<cv::graph_dump_path>(args);
@@ -87,6 +93,16 @@ namespace
             return cv::util::make_optional(dump_info.value().m_dump_path);
         }
     }
+
+    template<typename C>
+    cv::gapi::GKernelPackage auxKernelsFrom(const C& c) {
+        cv::gapi::GKernelPackage result;
+        for (const auto &b : c) {
+            result = cv::gapi::combine(result, b.priv().auxiliaryKernels());
+        }
+        return result;
+    }
+
 } // anonymous namespace
 
 
@@ -98,13 +114,28 @@ cv::gimpl::GCompiler::GCompiler(const cv::GComputation &c,
     : m_c(c), m_metas(std::move(metas)), m_args(std::move(args))
 {
     using namespace std::placeholders;
-    m_all_kernels       = getKernelPackage(m_args);
-    auto dump_path      = getGraphDumpDirectory(m_args);
+
+    auto kernels_to_use  = getKernelPackage(m_args);
+    auto networks_to_use = getNetworkPackage(m_args);
+    std::unordered_set<cv::gapi::GBackend> all_backends;
+    const auto take = [&](std::vector<cv::gapi::GBackend> &&v) {
+        all_backends.insert(v.begin(), v.end());
+    };
+    take(kernels_to_use.backends());
+    take(networks_to_use.backends());
+    m_all_kernels        = cv::gapi::combine(kernels_to_use,
+                                             auxKernelsFrom(all_backends));
+    // NB: The expectation in the line above is that
+    // NN backends (present here via network package) always add their
+    // inference kernels via auxiliary...()
+
+    auto dump_path       = getGraphDumpDirectory(m_args);
 
     m_e.addPassStage("init");
     m_e.addPass("init", "check_cycles",  ade::passes::CheckCycles());
-    m_e.addPass("init", "expand_kernels",  std::bind(passes::expandKernels, _1,
-                                                     m_all_kernels)); // NB: package is copied
+    m_e.addPass("init", "expand_kernels",
+                std::bind(passes::expandKernels, _1,
+                          m_all_kernels)); // NB: package is copied
     m_e.addPass("init", "topo_sort",     ade::passes::TopologicalSort());
     m_e.addPass("init", "init_islands",  passes::initIslands);
     m_e.addPass("init", "check_islands", passes::checkIslands);
@@ -117,8 +148,13 @@ cv::gimpl::GCompiler::GCompiler(const cv::GComputation &c,
     m_all_kernels.remove(cv::gapi::compound::backend());
 
     m_e.addPassStage("kernels");
-    m_e.addPass("kernels", "resolve_kernels", std::bind(passes::resolveKernels, _1,
-                                              std::ref(m_all_kernels))); // NB: and not copied here
+    m_e.addPass("kernels", "bind_net_params",
+                std::bind(passes::bindNetParams, _1,
+                          networks_to_use));
+    m_e.addPass("kernels", "resolve_kernels",
+                std::bind(passes::resolveKernels, _1,
+                          std::ref(m_all_kernels)));  // NB: and not copied here
+                                                      // (no compound backend present here)
     m_e.addPass("kernels", "check_islands_content", passes::checkIslandsContent);
 
     m_e.addPassStage("meta");
@@ -142,7 +178,9 @@ cv::gimpl::GCompiler::GCompiler(const cv::GComputation &c,
                                                   dump_path.value()));
     }
 
-    // Process backends at the last moment (after all G-API passes are added).
+    // FIXME: This should be called for "ActiveBackends" only (see metadata).
+    // However, ActiveBackends are known only after passes are actually executed.
+    // At these stage, they are not executed yet.
     ade::ExecutionEngineSetupContext ectx(m_e);
     auto backends = m_all_kernels.backends();
     for (auto &b : backends)

modules/gapi/src/compiler/gcompiler.hpp

@@ -11,6 +11,7 @@
 
 #include <opencv2/gapi/gcommon.hpp>
 #include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/infer.hpp>
 #include <opencv2/gapi/gcomputation.hpp>
 
 #include <ade/execution_engine/execution_engine.hpp>
@@ -26,6 +27,7 @@ class GAPI_EXPORTS GCompiler
     ade::ExecutionEngine     m_e;
 
     cv::gapi::GKernelPackage m_all_kernels;
+    cv::gapi::GNetPackage    m_all_networks;
 
     void validateInputMeta();
     void validateOutProtoArgs();

modules/gapi/src/compiler/gmodel.cpp

@@ -47,7 +47,7 @@ ade::NodeHandle GModel::mkDataNode(GModel::Graph &g, const GOrigin& origin)
     {
         auto value = value_of(origin);
         meta       = descr_of(value);
-        storage    = Data::Storage::CONST;
+        storage    = Data::Storage::CONST_VAL;
         g.metadata(data_h).set(ConstValue{value});
     }
     g.metadata(data_h).set(Data{origin.shape, id, meta, origin.ctor, storage});

modules/gapi/src/compiler/gmodel.hpp

@@ -22,6 +22,8 @@
 // This part of the system is API-unaware by its design.
 //
 
+#include <opencv2/gapi/util/any.hpp>
+
 #include <opencv2/gapi/garg.hpp>
 #include <opencv2/gapi/gkernel.hpp>
 
@@ -76,7 +78,8 @@ struct Data
         INTERNAL,   // data object is not listed in GComputation protocol
         INPUT,      // data object is listed in GComputation protocol as Input
         OUTPUT,     // data object is listed in GComputation protocol as Output
-        CONST,      // data object is constant
+        CONST_VAL,  // data object is constant.
+                    // Note: CONST is sometimes defined in Win sys headers
     };
     Storage storage;
 };
@@ -142,6 +145,33 @@ struct ActiveBackends
     std::unordered_set<cv::gapi::GBackend> backends;
 };
 
+// Backend-specific inference parameters for a neural network.
+// Since these parameters are set on compilation stage (not
+// on a construction stage), these parameters are bound lately
+// to the operation node.
+// NB: These parameters are not included into GModel by default
+// since it is not used regularly by all parties.
+struct NetworkParams
+{
+    static const char *name() { return "NetworkParams"; }
+    cv::util::any opaque;
+};
+
+// This is a custom metadata handling operator.
+// Sometimes outMeta() can't be bound to input parameters only
+// so several backends (today -- mainly inference) may find this useful.
+// If provided, the meta inference pass uses this function instead of
+// OP.k.outMeta.
+struct CustomMetaFunction
+{
+    static const char *name() { return "CustomMetaFunction"; }
+    using CM = std::function< cv::GMetaArgs( const ade::Graph      &,
+                                             const ade::NodeHandle &,
+                                             const cv::GMetaArgs   &,
+                                             const cv::GArgs       &)>;
+    CM customOutMeta;
+};
+
 namespace GModel
 {
     using Graph = ade::TypedGraph
@@ -159,6 +189,7 @@ namespace GModel
         , DataObjectCounter
         , IslandModel
         , ActiveBackends
+        , CustomMetaFunction
         >;
 
     // FIXME: How to define it based on GModel???
@@ -177,6 +208,7 @@ namespace GModel
         , DataObjectCounter
         , IslandModel
         , ActiveBackends
+        , CustomMetaFunction
         >;
 
     // FIXME:

modules/gapi/src/compiler/passes/kernels.cpp

@@ -12,6 +12,8 @@
 #include <ade/passes/check_cycles.hpp>
 
 #include <opencv2/gapi/gcompoundkernel.hpp> // compound::backend()
+#include <opencv2/gapi/gkernel.hpp>         // GKernelPackage
+#include <opencv2/gapi/infer.hpp>           // GNetPackage
 
 #include "compiler/gmodel.hpp"
 #include "compiler/passes/passes.hpp"
@@ -97,7 +99,37 @@ namespace
             gr.erase(subgr_out_nh);
         }
     }
+} // anonymous namespace
+
+// This pass, given the network package, associates every infer[list] node
+// with particular inference backend and its parameters.
+void cv::gimpl::passes::bindNetParams(ade::passes::PassContext &ctx,
+                                      const gapi::GNetPackage  &pkg)
+{
+    GModel::Graph gr(ctx.graph);
+    ade::TypedGraph<NetworkParams> pgr(ctx.graph);
+
+    for (const auto &nh : gr.nodes())
+    {
+        if (gr.metadata(nh).get<NodeType>().t == NodeType::OP)
+        {
+            auto &op = gr.metadata(nh).get<Op>();
+            if (op.k.tag.empty())
+                continue;
+
+            // FIXME: What if there's more than one???
+            const auto it = ade::util::find_if(pkg.networks,
+                                               [&](const cv::gapi::GNetParam &p) {
+                                                   return p.tag == op.k.tag;
+                                               });
+            if (it == std::end(pkg.networks))
+                continue;
+
+            pgr.metadata(nh).set(NetworkParams{it->params});
+        }
+    }
 }
+
 // This pass, given the kernel package, selects a kernel implementation
 // for every operation in the graph
 void cv::gimpl::passes::resolveKernels(ade::passes::PassContext   &ctx,

modules/gapi/src/compiler/passes/meta.cpp

@@ -49,7 +49,8 @@ void cv::gimpl::passes::inferMeta(ade::passes::PassContext &ctx, bool meta_is_in
 
             // Prepare operation's input metadata vector
             // Note that it's size is usually different from nh.inEdges.size(),
-            // and its element count is equal to operation's arguments count.
+            // and its element count is equal to operation's arguments count
+            // (which may contain graph-construction-time parameters like integers, etc)
             GMetaArgs input_meta_args(op.args.size());
 
             // Iterate through input edges, update input_meta_args's slots
@@ -66,16 +67,22 @@ void cv::gimpl::passes::inferMeta(ade::passes::PassContext &ctx, bool meta_is_in
                 {
                     // No meta in an input argument - a fatal error
                     // (note graph is traversed here in topoligcal order)
-                  util::throw_error(std::logic_error("Fatal: input object's metadata "
-                                                 "not found!"));
+                    util::throw_error(std::logic_error("Fatal: input object's metadata "
+                                                       "not found!"));
                     // FIXME: Add more details!!!
                 }
                 input_meta_args.at(input_port) = input_meta;
             }
+
             // Now ask kernel for it's output meta.
             // Resulting out_args may have a larger size than op.outs, since some
             // outputs could stay unused (unconnected)
-            const auto out_metas = op.k.outMeta(input_meta_args, op.args);
+            const auto out_metas = gr.metadata(nh).contains<CustomMetaFunction>()
+                ? gr.metadata(nh).get<CustomMetaFunction>().customOutMeta(ctx.graph,
+                                                                          nh,
+                                                                          input_meta_args,
+                                                                          op.args)
+                : op.k.outMeta(input_meta_args, op.args);
 
             // Walk through operation's outputs, update meta of output objects
             // appropriately

modules/gapi/src/compiler/passes/passes.hpp

@@ -25,6 +25,12 @@ namespace ade {
 
 namespace cv {
 
+// Forward declarations - internal
+namespace gapi {
+    class GKernelPackage;
+    struct GNetPackage;
+}  // namespace gapi
+
 namespace gimpl { namespace passes {
 
 void dumpDot(const ade::Graph &g, std::ostream& os);
@@ -44,6 +50,9 @@ void storeResultingMeta(ade::passes::PassContext &ctx);
 void expandKernels(ade::passes::PassContext &ctx,
                    const gapi::GKernelPackage& kernels);
 
+void bindNetParams(ade::passes::PassContext   &ctx,
+                   const gapi::GNetPackage    &networks);
+
 void resolveKernels(ade::passes::PassContext   &ctx,
                     const gapi::GKernelPackage &kernels);
 

modules/gapi/src/executor/gexecutor.cpp

@@ -88,7 +88,7 @@ void cv::gimpl::GExecutor::initResource(const ade::NodeHandle &orig_nh)
     const Data &d = m_gm.metadata(orig_nh).get<Data>();
 
     if (   d.storage != Data::Storage::INTERNAL
-        && d.storage != Data::Storage::CONST)
+        && d.storage != Data::Storage::CONST_VAL)
         return;
 
     // INTERNALS+CONST only! no need to allocate/reset output objects
@@ -105,7 +105,7 @@ void cv::gimpl::GExecutor::initResource(const ade::NodeHandle &orig_nh)
         break;
 
     case GShape::GSCALAR:
-        if (d.storage == Data::Storage::CONST)
+        if (d.storage == Data::Storage::CONST_VAL)
         {
             auto rc = RcDesc{d.rc, d.shape, d.ctor};
             magazine::bindInArg(m_res, rc, m_gm.metadata(orig_nh).get<ConstValue>().arg);

modules/gapi/test/gapi_desc_tests.cpp

@@ -31,6 +31,7 @@ TEST(GAPI_MetaDesc, MatDesc)
     EXPECT_EQ(1,     desc1.chan);
     EXPECT_EQ(320,   desc1.size.width);
     EXPECT_EQ(240,   desc1.size.height);
+    EXPECT_FALSE(desc1.isND());
 
     cv::Mat m2(480, 640, CV_8UC3);
     const auto desc2 = cv::descr_of(m2);
@@ -38,6 +39,21 @@ TEST(GAPI_MetaDesc, MatDesc)
     EXPECT_EQ(3,       desc2.chan);
     EXPECT_EQ(640,     desc2.size.width);
     EXPECT_EQ(480,     desc2.size.height);
+    EXPECT_FALSE(desc2.isND());
+}
+
+TEST(GAPI_MetaDesc, MatDescND)
+{
+    std::vector<int> dims = {1,3,299,299};
+    cv::Mat m(dims, CV_32F);
+    const auto desc = cv::descr_of(m);
+    EXPECT_EQ(CV_32F, desc.depth);
+    EXPECT_EQ(-1,     desc.chan);
+    EXPECT_EQ(1,      desc.dims[0]);
+    EXPECT_EQ(3,      desc.dims[1]);
+    EXPECT_EQ(299,    desc.dims[2]);
+    EXPECT_EQ(299,    desc.dims[3]);
+    EXPECT_TRUE(desc.isND());
 }
 
 TEST(GAPI_MetaDesc, VecMatDesc)
@@ -45,13 +61,13 @@ TEST(GAPI_MetaDesc, VecMatDesc)
     std::vector<cv::Mat> vec1 = {
     cv::Mat(240, 320, CV_8U)};
 
-    const auto desc1 = cv::descr_of(vec1);
+    const auto desc1 = cv::descrs_of(vec1);
     EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc1[0]));
 
     std::vector<cv::UMat> vec2 = {
     cv::UMat(480, 640, CV_8UC3)};
 
-    const auto desc2 = cv::descr_of(vec2);
+    const auto desc2 = cv::descrs_of(vec2);
     EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc2[0]));
 }
 
@@ -61,7 +77,7 @@ TEST(GAPI_MetaDesc, VecOwnMatDesc)
     cv::gapi::own::Mat(240, 320, CV_8U, nullptr),
     cv::gapi::own::Mat(480, 640, CV_8UC3, nullptr)};
 
-    const auto desc = cv::gapi::own::descr_of(vec);
+    const auto desc = cv::gapi::own::descrs_of(vec);
     EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc[0]));
     EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc[1]));
 }
@@ -72,7 +88,7 @@ TEST(GAPI_MetaDesc, AdlVecOwnMatDesc)
     cv::gapi::own::Mat(240, 320, CV_8U, nullptr),
     cv::gapi::own::Mat(480, 640, CV_8UC3, nullptr)};
 
-    const auto desc = descr_of(vec);
+    const auto desc = descrs_of(vec);
     EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc[0]));
     EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc[1]));
 }
@@ -93,6 +109,38 @@ TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc)
     EXPECT_TRUE(desc1 != desc2);
 }
 
+TEST(GAPI_MetaDesc, Compare_Equal_MatDesc_ND)
+{
+    const auto desc1 = cv::GMatDesc{CV_8U, {1,3,224,224}};
+    const auto desc2 = cv::GMatDesc{CV_8U, {1,3,224,224}};
+
+    EXPECT_TRUE(desc1 == desc2);
+}
+
+TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc_ND_1)
+{
+    const auto desc1 = cv::GMatDesc{CV_8U,  {1,1000}};
+    const auto desc2 = cv::GMatDesc{CV_32F, {1,1000}};
+
+    EXPECT_TRUE(desc1 != desc2);
+}
+
+TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc_ND_2)
+{
+    const auto desc1 = cv::GMatDesc{CV_8U, {1,1000}};
+    const auto desc2 = cv::GMatDesc{CV_8U, {1,1400}};
+
+    EXPECT_TRUE(desc1 != desc2);
+}
+
+TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc_ND_3)
+{
+    const auto desc1 = cv::GMatDesc{CV_8U, {1,1000}};
+    const auto desc2 = cv::GMatDesc{CV_8U, 1, {32,32}};
+
+    EXPECT_TRUE(desc1 != desc2);
+}
+
 TEST(GAPI_MetaDesc, Compile_MatchMetaNumber_1)
 {
     cv::GMat in;

modules/gapi/test/infer/gapi_infer_ie_test.cpp

+// 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) 2019 Intel Corporation
+
+#include "../test_precomp.hpp"
+
+#ifdef HAVE_INF_ENGINE
+
+#include <stdexcept>
+
+////////////////////////////////////////////////////////////////////////////////
+// FIXME: Suppress deprecation warnings for OpenVINO 2019R2+
+// BEGIN {{{
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+#ifdef _MSC_VER
+#pragma warning(disable: 4996)  // was declared deprecated
+#endif
+
+#if defined(__GNUC__)
+#pragma GCC visibility push(default)
+#endif
+
+#include <inference_engine.hpp>
+
+#if defined(__GNUC__)
+#pragma GCC visibility pop
+#endif
+// END }}}
+////////////////////////////////////////////////////////////////////////////////
+
+#include <ade/util/iota_range.hpp>
+
+#include <opencv2/gapi/infer/ie.hpp>
+#include <opencv2/gapi/infer/ie/util.hpp>
+
+namespace opencv_test
+{
+namespace {
+
+// FIXME: taken from DNN module
+static void initDLDTDataPath()
+{
+#ifndef WINRT
+    static bool initialized = false;
+    if (!initialized)
+    {
+        const char* omzDataPath = getenv("OPENCV_OPEN_MODEL_ZOO_DATA_PATH");
+        if (omzDataPath)
+            cvtest::addDataSearchPath(omzDataPath);
+        const char* dnnDataPath = getenv("OPENCV_DNN_TEST_DATA_PATH");
+        if (dnnDataPath) {
+            // Add the dnnDataPath itself - G-API is using some images there directly
+            cvtest::addDataSearchPath(dnnDataPath);
+            cvtest::addDataSearchPath(dnnDataPath + std::string("/omz_intel_models"));
+        }
+        initialized = true;
+    }
+#endif // WINRT
+}
+
+// FIXME: taken from the DNN module
+void normAssert(cv::InputArray ref, cv::InputArray test,
+                const char *comment /*= ""*/,
+                double l1 = 0.00001, double lInf = 0.0001)
+{
+    double normL1 = cvtest::norm(ref, test, cv::NORM_L1) / ref.getMat().total();
+    EXPECT_LE(normL1, l1) << comment;
+
+    double normInf = cvtest::norm(ref, test, cv::NORM_INF);
+    EXPECT_LE(normInf, lInf) << comment;
+}
+
+} // anonymous namespace
+
+// TODO: Probably DNN/IE part can be further parametrized with a template
+// NOTE: here ".." is used to leave the default "gapi/" search scope
+TEST(TestAgeGenderIE, InferBasicTensor)
+{
+    initDLDTDataPath();
+
+    const std::string path = "Retail/object_attributes/age_gender/dldt/age-gender-recognition-retail-0013";
+    const auto topology_path = findDataFile(path + ".xml", false);
+    const auto weights_path  = findDataFile(path + ".bin", false);
+
+    // Load IE network, initialize input data using that.
+    namespace IE = InferenceEngine;
+    cv::Mat in_mat;
+    cv::Mat gapi_age, gapi_gender;
+
+    IE::Blob::Ptr ie_age, ie_gender;
+    {
+        IE::CNNNetReader reader;
+        reader.ReadNetwork(topology_path);
+        reader.ReadWeights(weights_path);
+        auto net = reader.getNetwork();
+
+        const auto &iedims = net.getInputsInfo().begin()->second->getDims();
+              auto  cvdims = cv::gapi::ie::util::to_ocv(iedims);
+        std::reverse(cvdims.begin(), cvdims.end());
+        in_mat.create(cvdims, CV_32F);
+        cv::randu(in_mat, -1, 1);
+
+        auto plugin = IE::PluginDispatcher().getPluginByDevice("CPU");
+        auto plugin_net = plugin.LoadNetwork(net, {});
+        auto infer_request = plugin_net.CreateInferRequest();
+
+        infer_request.SetBlob("data", cv::gapi::ie::util::to_ie(in_mat));
+        infer_request.Infer();
+        ie_age    = infer_request.GetBlob("age_conv3");
+        ie_gender = infer_request.GetBlob("prob");
+    }
+
+    // Configure & run G-API
+    using AGInfo = std::tuple<cv::GMat, cv::GMat>;
+    G_API_NET(AgeGender, <AGInfo(cv::GMat)>, "test-age-gender");
+
+    cv::GMat in;
+    cv::GMat age, gender;
+    std::tie(age, gender) = cv::gapi::infer<AgeGender>(in);
+    cv::GComputation comp(cv::GIn(in), cv::GOut(age, gender));
+
+    auto pp = cv::gapi::ie::Params<AgeGender> {
+        topology_path, weights_path, "CPU"
+    }.cfgOutputLayers({ "age_conv3", "prob" });
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Validate with IE itself (avoid DNN module dependency here)
+    normAssert(cv::gapi::ie::util::to_ocv(ie_age),    gapi_age,    "Test age output"   );
+    normAssert(cv::gapi::ie::util::to_ocv(ie_gender), gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderIE, InferBasicImage)
+{
+    initDLDTDataPath();
+
+    const std::string path = "Retail/object_attributes/age_gender/dldt/age-gender-recognition-retail-0013";
+    const auto topology_path = findDataFile(path + ".xml", false);
+    const auto weights_path  = findDataFile(path + ".bin", false);
+
+    // FIXME: Ideally it should be an image from disk
+    // cv::Mat in_mat = cv::imread(findDataFile("grace_hopper_227.png"));
+    cv::Mat in_mat(cv::Size(320, 240), CV_8UC3);
+    cv::randu(in_mat, 0, 255);
+
+    cv::Mat gapi_age, gapi_gender;
+
+    // Load & run IE network
+    namespace IE = InferenceEngine;
+    IE::Blob::Ptr ie_age, ie_gender;
+    {
+        IE::CNNNetReader reader;
+        reader.ReadNetwork(topology_path);
+        reader.ReadWeights(weights_path);
+        auto net = reader.getNetwork();
+        auto &ii = net.getInputsInfo().at("data");
+        ii->setPrecision(IE::Precision::U8);
+        ii->setLayout(IE::Layout::NHWC);
+        ii->getPreProcess().setResizeAlgorithm(IE::RESIZE_BILINEAR);
+
+        auto plugin = IE::PluginDispatcher().getPluginByDevice("CPU");
+        auto plugin_net = plugin.LoadNetwork(net, {});
+        auto infer_request = plugin_net.CreateInferRequest();
+
+        infer_request.SetBlob("data", cv::gapi::ie::util::to_ie(in_mat));
+        infer_request.Infer();
+        ie_age    = infer_request.GetBlob("age_conv3");
+        ie_gender = infer_request.GetBlob("prob");
+    }
+
+    // Configure & run G-API
+    using AGInfo = std::tuple<cv::GMat, cv::GMat>;
+    G_API_NET(AgeGender, <AGInfo(cv::GMat)>, "test-age-gender");
+
+    cv::GMat in;
+    cv::GMat age, gender;
+    std::tie(age, gender) = cv::gapi::infer<AgeGender>(in);
+    cv::GComputation comp(cv::GIn(in), cv::GOut(age, gender));
+
+    auto pp = cv::gapi::ie::Params<AgeGender> {
+        topology_path, weights_path, "CPU"
+    }.cfgOutputLayers({ "age_conv3", "prob" });
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Validate with IE itself (avoid DNN module dependency here)
+    normAssert(cv::gapi::ie::util::to_ocv(ie_age),    gapi_age,    "Test age output"   );
+    normAssert(cv::gapi::ie::util::to_ocv(ie_gender), gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderIE, InferROIList)
+{
+    initDLDTDataPath();
+
+    const std::string path = "Retail/object_attributes/age_gender/dldt/age-gender-recognition-retail-0013";
+    const auto topology_path = findDataFile(path + ".xml", false);
+    const auto weights_path  = findDataFile(path + ".bin", false);
+
+    // FIXME: Ideally it should be an image from disk
+    // cv::Mat in_mat = cv::imread(findDataFile("grace_hopper_227.png"));
+    cv::Mat in_mat(cv::Size(640, 480), CV_8UC3);
+    cv::randu(in_mat, 0, 255);
+
+    std::vector<cv::Rect> rois = {
+        cv::Rect(cv::Point{ 0,   0}, cv::Size{80, 120}),
+        cv::Rect(cv::Point{50, 100}, cv::Size{96, 160}),
+    };
+
+    std::vector<cv::Mat> gapi_age, gapi_gender;
+
+    // Load & run IE network
+    namespace IE = InferenceEngine;
+    std::vector<cv::Mat> ie_age, ie_gender;
+    {
+        IE::CNNNetReader reader;
+        reader.ReadNetwork(topology_path);
+        reader.ReadWeights(weights_path);
+        auto net = reader.getNetwork();
+        auto &ii = net.getInputsInfo().at("data");
+        ii->setPrecision(IE::Precision::U8);
+        ii->setLayout(IE::Layout::NHWC);
+        ii->getPreProcess().setResizeAlgorithm(IE::RESIZE_BILINEAR);
+
+        auto plugin = IE::PluginDispatcher().getPluginByDevice("CPU");
+        auto plugin_net = plugin.LoadNetwork(net, {});
+        auto infer_request = plugin_net.CreateInferRequest();
+        auto frame_blob = cv::gapi::ie::util::to_ie(in_mat);
+
+        for (auto &&rc : rois) {
+            const auto ie_rc = IE::ROI {
+                  0u
+                , static_cast<std::size_t>(rc.x)
+                , static_cast<std::size_t>(rc.y)
+                , static_cast<std::size_t>(rc.width)
+                , static_cast<std::size_t>(rc.height)
+            };
+            infer_request.SetBlob("data", IE::make_shared_blob(frame_blob, ie_rc));
+            infer_request.Infer();
+
+            using namespace cv::gapi::ie::util;
+            ie_age.push_back(to_ocv(infer_request.GetBlob("age_conv3")).clone());
+            ie_gender.push_back(to_ocv(infer_request.GetBlob("prob")).clone());
+        }
+    }
+
+    // Configure & run G-API
+    using AGInfo = std::tuple<cv::GMat, cv::GMat>;
+    G_API_NET(AgeGender, <AGInfo(cv::GMat)>, "test-age-gender");
+
+    cv::GArray<cv::Rect> rr;
+    cv::GMat in;
+    cv::GArray<cv::GMat> age, gender;
+    std::tie(age, gender) = cv::gapi::infer<AgeGender>(rr, in);
+    cv::GComputation comp(cv::GIn(in, rr), cv::GOut(age, gender));
+
+    auto pp = cv::gapi::ie::Params<AgeGender> {
+        topology_path, weights_path, "CPU"
+    }.cfgOutputLayers({ "age_conv3", "prob" });
+    comp.apply(cv::gin(in_mat, rois), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Validate with IE itself (avoid DNN module dependency here)
+    ASSERT_EQ(2u, ie_age.size()   );
+    ASSERT_EQ(2u, ie_gender.size());
+    ASSERT_EQ(2u, gapi_age.size()   );
+    ASSERT_EQ(2u, gapi_gender.size());
+
+    normAssert(ie_age   [0], gapi_age   [0], "0: Test age output");
+    normAssert(ie_gender[0], gapi_gender[0], "0: Test gender output");
+    normAssert(ie_age   [1], gapi_age   [1], "1: Test age output");
+    normAssert(ie_gender[1], gapi_gender[1], "1: Test gender output");
+}
+
+
+} // namespace opencv_test
+
+#endif //  HAVE_INF_ENGINE

modules/gapi/test/internal/gapi_int_gmodel_builder_test.cpp

@@ -23,12 +23,12 @@ namespace
 {
     cv::GMat unaryOp(cv::GMat m)
     {
-        return cv::GCall(cv::GKernel{"gapi.test.unaryop", nullptr, { GShape::GMAT } }).pass(m).yield(0);
+        return cv::GCall(cv::GKernel{"gapi.test.unaryop", "", nullptr, { GShape::GMAT } }).pass(m).yield(0);
     }
 
     cv::GMat binaryOp(cv::GMat m1, cv::GMat m2)
     {
-        return cv::GCall(cv::GKernel{"gapi.test.binaryOp", nullptr, { GShape::GMAT } }).pass(m1, m2).yield(0);
+        return cv::GCall(cv::GKernel{"gapi.test.binaryOp", "", nullptr, { GShape::GMAT } }).pass(m1, m2).yield(0);
     }
 
     std::vector<ade::NodeHandle> collectOperations(const cv::gimpl::GModel::Graph& gr)

modules/gapi/test/own/mat_tests.cpp

@@ -12,6 +12,7 @@
 namespace opencv_test
 {
 using Mat = cv::gapi::own::Mat;
+using Dims = std::vector<int>;
 
 TEST(OwnMat, DefaultConstruction)
 {
@@ -22,6 +23,7 @@ TEST(OwnMat, DefaultConstruction)
     ASSERT_EQ(m.cols, 0);
     ASSERT_EQ(m.type(), 0);
     ASSERT_EQ(m.depth(), 0);
+    ASSERT_TRUE(m.dims.empty());
 }
 
 TEST(OwnMat, Create)
@@ -39,6 +41,25 @@ TEST(OwnMat, Create)
     ASSERT_EQ(m.channels(), 1);
     ASSERT_EQ(m.elemSize(), sizeof(uint8_t));
     ASSERT_EQ(m.step,   sizeof(uint8_t) * m.cols);
+    ASSERT_TRUE(m.dims.empty());
+}
+
+TEST(OwnMat, CreateND)
+{
+    Dims dims = {1,1,32,32};
+    Mat m;
+    m.create(dims, CV_32F);
+
+    ASSERT_NE(nullptr        , m.data      );
+    ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{m.cols, m.rows}));
+
+    ASSERT_EQ(static_cast<size_t>(dims[0]*dims[1]*dims[2]*dims[3]), m.total());
+    ASSERT_EQ(CV_32F         , m.type()    );
+    ASSERT_EQ(CV_32F         , m.depth()   );
+    ASSERT_EQ(-1             , m.channels());
+    ASSERT_EQ(sizeof(float)  , m.elemSize());
+    ASSERT_EQ(0u             , m.step      );
+    ASSERT_EQ(dims           , m.dims      );
 }
 
 TEST(OwnMat, CreateOverload)
@@ -56,7 +77,9 @@ TEST(OwnMat, CreateOverload)
     ASSERT_EQ(m.channels(), 1);
     ASSERT_EQ(m.elemSize(), sizeof(uint8_t));
     ASSERT_EQ(m.step,   sizeof(uint8_t) * m.cols);
+    ASSERT_TRUE(m.dims.empty());
 }
+
 TEST(OwnMat, Create3chan)
 {
     auto size = cv::Size{32,16};
@@ -71,6 +94,7 @@ TEST(OwnMat, Create3chan)
     ASSERT_EQ(m.channels(), 3);
     ASSERT_EQ(m.elemSize(), 3 * sizeof(uint8_t));
     ASSERT_EQ(m.step,       3*  sizeof(uint8_t) * m.cols);
+    ASSERT_TRUE(m.dims.empty());
 }
 
 struct NonEmptyMat {
@@ -91,7 +115,8 @@ namespace {
                 cv::Size{mat.cols, mat.rows},
                 mat.type(),
                 mat.depth(),
-                mat.channels()
+                mat.channels(),
+                mat.dims
         );
     };
 
@@ -194,6 +219,23 @@ TEST(OwnMatConversion, WithStep)
     << (cvMat != cvMatFromOwn);
 }
 
+TEST(OwnMatConversion, WithND)
+{
+    const Dims dims = {1,3,8,8};
+    std::vector<uint8_t> data(dims[0]*dims[1]*dims[2]*dims[3]);
+    for (size_t i = 0u; i < data.size(); i++)
+    {
+        data[i] = static_cast<uint8_t>(i);
+    }
+    cv::Mat cvMat(dims, CV_32S, data.data());
+    auto ownMat = to_own(cvMat);
+    auto cvMatFromOwn = cv::gapi::own::to_ocv(ownMat);
+
+    EXPECT_EQ(0, cv::countNonZero(cvMat != cvMatFromOwn))
+        << cvMat << std::endl
+        << (cvMat != cvMatFromOwn);
+}
+
 TEST(OwnMat, PtrWithStep)
 {
     constexpr int width  = 8;
@@ -242,6 +284,149 @@ TEST(OwnMat, CopyToWithStep)
     << (to_ocv(mat) != to_ocv(dst));
 }
 
+TEST(OwnMat, AssignNDtoRegular)
+{
+    const auto sz   = cv::gapi::own::Size{32,32};
+    const auto dims = Dims{1,3,224,224};
+
+    Mat a;
+    a.create(sz, CV_8U);
+    const auto *old_ptr = a.data;
+
+    ASSERT_NE(nullptr , a.data);
+    ASSERT_EQ(sz      , (cv::gapi::own::Size{a.cols, a.rows}));
+    ASSERT_EQ(static_cast<size_t>(sz.width*sz.height), a.total());
+    ASSERT_EQ(CV_8U   , a.type());
+    ASSERT_EQ(CV_8U   , a.depth());
+    ASSERT_EQ(1       , a.channels());
+    ASSERT_EQ(sizeof(uint8_t), a.elemSize());
+    ASSERT_EQ(static_cast<size_t>(sz.width), a.step);
+    ASSERT_TRUE(a.dims.empty());
+
+    Mat b;
+    b.create(dims, CV_32F);
+    a = b;
+
+    ASSERT_NE(nullptr , a.data);
+    ASSERT_NE(old_ptr , a.data);
+    ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{a.cols, a.rows}));
+    ASSERT_EQ(static_cast<size_t>(dims[0]*dims[1]*dims[2]*dims[3]), a.total());
+    ASSERT_EQ(CV_32F  , a.type());
+    ASSERT_EQ(CV_32F  , a.depth());
+    ASSERT_EQ(-1      , a.channels());
+    ASSERT_EQ(sizeof(float), a.elemSize());
+    ASSERT_EQ(0u      , a.step);
+    ASSERT_EQ(dims    , a.dims);
+}
+
+TEST(OwnMat, AssignRegularToND)
+{
+    const auto sz   = cv::gapi::own::Size{32,32};
+    const auto dims = Dims{1,3,224,224};
+
+    Mat a;
+    a.create(dims, CV_32F);
+    const auto *old_ptr = a.data;
+
+    ASSERT_NE(nullptr , a.data);
+    ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{a.cols, a.rows}));
+    ASSERT_EQ(static_cast<size_t>(dims[0]*dims[1]*dims[2]*dims[3]), a.total());
+    ASSERT_EQ(CV_32F  , a.type());
+    ASSERT_EQ(CV_32F  , a.depth());
+    ASSERT_EQ(-1      , a.channels());
+    ASSERT_EQ(sizeof(float), a.elemSize());
+    ASSERT_EQ(0u      , a.step);
+    ASSERT_EQ(dims    , a.dims);
+
+    Mat b;
+    b.create(sz, CV_8U);
+    a = b;
+
+    ASSERT_NE(nullptr , a.data);
+    ASSERT_NE(old_ptr , a.data);
+    ASSERT_EQ(sz      , (cv::gapi::own::Size{a.cols, a.rows}));
+    ASSERT_EQ(static_cast<size_t>(sz.width*sz.height), a.total());
+    ASSERT_EQ(CV_8U   , a.type());
+    ASSERT_EQ(CV_8U   , a.depth());
+    ASSERT_EQ(1       , a.channels());
+    ASSERT_EQ(sizeof(uint8_t), a.elemSize());
+    ASSERT_EQ(static_cast<size_t>(sz.width), a.step);
+    ASSERT_TRUE(a.dims.empty());
+}
+
+TEST(OwnMat, CopyNDtoRegular)
+{
+    const auto sz   = cv::gapi::own::Size{32,32};
+    const auto dims = Dims{1,3,224,224};
+
+    Mat a;
+    a.create(sz, CV_8U);
+    const auto *old_ptr = a.data;
+
+    ASSERT_NE(nullptr , a.data);
+    ASSERT_EQ(sz      , (cv::gapi::own::Size{a.cols, a.rows}));
+    ASSERT_EQ(static_cast<size_t>(sz.width*sz.height), a.total());
+    ASSERT_EQ(CV_8U   , a.type());
+    ASSERT_EQ(CV_8U   , a.depth());
+    ASSERT_EQ(1       , a.channels());
+    ASSERT_EQ(sizeof(uint8_t), a.elemSize());
+    ASSERT_EQ(static_cast<size_t>(sz.width), a.step);
+    ASSERT_TRUE(a.dims.empty());
+
+    Mat b;
+    b.create(dims, CV_32F);
+    b.copyTo(a);
+
+    ASSERT_NE(nullptr , a.data);
+    ASSERT_NE(old_ptr , a.data);
+    ASSERT_NE(b.data  , a.data);
+    ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{a.cols, a.rows}));
+    ASSERT_EQ(static_cast<size_t>(dims[0]*dims[1]*dims[2]*dims[3]), a.total());
+    ASSERT_EQ(CV_32F  , a.type());
+    ASSERT_EQ(CV_32F  , a.depth());
+    ASSERT_EQ(-1      , a.channels());
+    ASSERT_EQ(sizeof(float), a.elemSize());
+    ASSERT_EQ(0u      , a.step);
+    ASSERT_EQ(dims    , a.dims);
+}
+
+TEST(OwnMat, CopyRegularToND)
+{
+    const auto sz   = cv::gapi::own::Size{32,32};
+    const auto dims = Dims{1,3,224,224};
+
+    Mat a;
+    a.create(dims, CV_32F);
+    const auto *old_ptr = a.data;
+
+
+    ASSERT_NE(nullptr , a.data);
+    ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{a.cols, a.rows}));
+    ASSERT_EQ(static_cast<size_t>(dims[0]*dims[1]*dims[2]*dims[3]), a.total());
+    ASSERT_EQ(CV_32F  , a.type());
+    ASSERT_EQ(CV_32F  , a.depth());
+    ASSERT_EQ(-1      , a.channels());
+    ASSERT_EQ(sizeof(float), a.elemSize());
+    ASSERT_EQ(0u      , a.step);
+    ASSERT_EQ(dims    , a.dims);
+
+    Mat b;
+    b.create(sz, CV_8U);
+    b.copyTo(a);
+
+    ASSERT_NE(nullptr , a.data);
+    ASSERT_NE(old_ptr , a.data);
+    ASSERT_NE(b.data  , a.data);
+    ASSERT_EQ(sz      , (cv::gapi::own::Size{a.cols, a.rows}));
+    ASSERT_EQ(static_cast<size_t>(sz.width*sz.height), a.total());
+    ASSERT_EQ(CV_8U   , a.type());
+    ASSERT_EQ(CV_8U   , a.depth());
+    ASSERT_EQ(1       , a.channels());
+    ASSERT_EQ(sizeof(uint8_t), a.elemSize());
+    ASSERT_EQ(static_cast<size_t>(sz.width), a.step);
+    ASSERT_TRUE(a.dims.empty());
+}
+
 TEST(OwnMat, ScalarAssign32SC1)
 {
     constexpr int width  = 8;
@@ -304,6 +489,19 @@ TEST(OwnMat, ScalarAssign8UC1)
     << cmp_result_mat << std::endl;
 }
 
+TEST(OwnMat, ScalarAssignND)
+{
+    std::vector<int> dims = {1,1000};
+    Mat m;
+    m.create(dims, CV_32F);
+    m = cv::gapi::own::Scalar{-1};
+    const float *ptr = reinterpret_cast<float*>(m.data);
+
+    for (auto i = 0u; i < m.total(); i++) {
+        EXPECT_EQ(-1.f, ptr[i]);
+    }
+}
+
 TEST(OwnMat, ScalarAssign8UC3)
 {
     constexpr auto cv_type = CV_8SC3;

modules/gapi/test/test_precomp.hpp

@@ -14,6 +14,7 @@
 #include <vector>
 
 #include <opencv2/ts.hpp>
+
 #include <opencv2/gapi.hpp>
 #include <opencv2/gapi/imgproc.hpp>
 #include <opencv2/gapi/core.hpp>
@@ -25,5 +26,6 @@
 #include <opencv2/gapi/operators.hpp>
 #include <opencv2/gapi/fluid/imgproc.hpp>
 #include <opencv2/gapi/fluid/core.hpp>
+#include <opencv2/gapi/infer.hpp>
 
 #endif // __OPENCV_GAPI_TEST_PRECOMP_HPP__