feat: 切换后端至PaddleOCR-NCNN，切换工程为CMake

1.项目后端整体迁移至PaddleOCR-NCNN算法，已通过基本的兼容性测试
2.工程改为使用CMake组织，后续为了更好地兼容第三方库，不再提供QMake工程
3.重整权利声明文件，重整代码工程，确保最小化侵权风险

Log: 切换后端至PaddleOCR-NCNN，切换工程为CMake
Change-Id: I4d5d2c5d37505a4a24b389b1a4c5d12f17bfa38c

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi.hpp

@@ -0,0 +1,42 @@
+// 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-2021 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_HPP
+#define OPENCV_GAPI_HPP
+
+#include <memory>
+
+/** \defgroup gapi G-API framework
+@{
+    @defgroup gapi_main_classes G-API Main Classes
+    @defgroup gapi_data_objects G-API Data Types
+    @{
+      @defgroup gapi_meta_args G-API Metadata Descriptors
+    @}
+    @defgroup gapi_std_backends G-API Standard Backends
+    @defgroup gapi_compile_args G-API Graph Compilation Arguments
+    @defgroup gapi_serialization G-API Serialization functionality
+@}
+ */
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/garray.hpp>
+#include <opencv2/gapi/gscalar.hpp>
+#include <opencv2/gapi/gopaque.hpp>
+#include <opencv2/gapi/gframe.hpp>
+#include <opencv2/gapi/gcomputation.hpp>
+#include <opencv2/gapi/gcompiled.hpp>
+#include <opencv2/gapi/gtyped.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/operators.hpp>
+
+// Include these files here to avoid cyclic dependency between
+// Desync & GKernel & GComputation & GStreamingCompiled.
+#include <opencv2/gapi/streaming/desync.hpp>
+#include <opencv2/gapi/streaming/format.hpp>
+
+#endif // OPENCV_GAPI_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/cpu/core.hpp

@@ -0,0 +1,27 @@
+// 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_CPU_CORE_API_HPP
+#define OPENCV_GAPI_CPU_CORE_API_HPP
+
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+#include <opencv2/gapi/own/exports.hpp> // GAPI_EXPORTS
+
+namespace cv {
+namespace gapi {
+namespace core {
+namespace cpu {
+
+GAPI_EXPORTS_W cv::gapi::GKernelPackage kernels();
+
+} // namespace cpu
+} // namespace core
+} // namespace gapi
+} // namespace cv
+
+
+#endif // OPENCV_GAPI_CPU_CORE_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/cpu/gcpukernel.hpp

@@ -0,0 +1,542 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GCPUKERNEL_HPP
+#define OPENCV_GAPI_GCPUKERNEL_HPP
+
+#include <functional>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <opencv2/core/mat.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/gmetaarg.hpp>
+#include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning
+#include <opencv2/gapi/util/util.hpp>
+
+// FIXME: namespace scheme for backends?
+namespace cv {
+
+namespace gimpl
+{
+    // Forward-declare an internal class
+    class GCPUExecutable;
+
+    namespace render
+    {
+    namespace ocv
+    {
+        class GRenderExecutable;
+    }
+    }
+} // namespace gimpl
+
+namespace gapi
+{
+/**
+ * @brief This namespace contains G-API CPU backend functions,
+ * structures, and symbols.
+ */
+namespace cpu
+{
+    /**
+     * \addtogroup gapi_std_backends
+     * @{
+     *
+     * @brief G-API backends available in this OpenCV version
+     *
+     * G-API backends play a corner stone role in G-API execution
+     * stack. Every backend is hardware-oriented and thus can run its
+     * kernels efficiently on the target platform.
+     *
+     * Backends are usually "black boxes" for G-API users -- on the API
+     * side, all backends are represented as different objects of the
+     * same class cv::gapi::GBackend.
+     * User can manipulate with backends by specifying which kernels to use.
+     *
+     * @sa @ref gapi_hld
+     */
+
+    /**
+     * @brief Get a reference to CPU (OpenCV) backend.
+     *
+     * This is the default backend in G-API at the moment, providing
+     * broader functional coverage but losing some graph model
+     * advantages. Provided mostly for reference and prototyping
+     * purposes.
+     *
+     * @sa gapi_std_backends
+     */
+    GAPI_EXPORTS cv::gapi::GBackend backend();
+    /** @} */
+
+    class GOCVFunctor;
+
+    //! @cond IGNORED
+    template<typename K, typename Callable>
+    GOCVFunctor ocv_kernel(const Callable& c);
+
+    template<typename K, typename Callable>
+    GOCVFunctor ocv_kernel(Callable& c);
+    //! @endcond
+
+} // namespace cpu
+} // namespace gapi
+
+// Represents arguments which are passed to a wrapped CPU function
+// FIXME: put into detail?
+class GAPI_EXPORTS GCPUContext
+{
+public:
+    // Generic accessor API
+    template<typename T>
+    const T& inArg(int input) { return m_args.at(input).get<T>(); }
+
+    // Syntax sugar
+    const cv::Mat&   inMat(int input);
+    cv::Mat&         outMatR(int output); // FIXME: Avoid cv::Mat m = ctx.outMatR()
+
+    const cv::Scalar& inVal(int input);
+    cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR()
+    cv::MediaFrame& outFrame(int output);
+    template<typename T> std::vector<T>& outVecR(int output) // FIXME: the same issue
+    {
+        return outVecRef(output).wref<T>();
+    }
+    template<typename T> T& outOpaqueR(int output) // FIXME: the same issue
+    {
+        return outOpaqueRef(output).wref<T>();
+    }
+
+    GArg state()
+    {
+        return m_state;
+    }
+
+protected:
+    detail::VectorRef& outVecRef(int output);
+    detail::OpaqueRef& outOpaqueRef(int output);
+
+    std::vector<GArg> m_args;
+    GArg m_state;
+
+    //FIXME: avoid conversion of arguments from internal representation to OpenCV one on each call
+    //to OCV kernel. (This can be achieved by a two single time conversions in GCPUExecutable::run,
+    //once on enter for input and output arguments, and once before return for output arguments only
+    std::unordered_map<std::size_t, GRunArgP> m_results;
+
+    friend class gimpl::GCPUExecutable;
+    friend class gimpl::render::ocv::GRenderExecutable;
+};
+
+class GAPI_EXPORTS GCPUKernel
+{
+public:
+    // This function is a kernel's execution entry point (does the processing work)
+    using RunF = std::function<void(GCPUContext &)>;
+    // This function is a stateful kernel's setup routine (configures state)
+    using SetupF = std::function<void(const GMetaArgs &, const GArgs &,
+                                      GArg &, const GCompileArgs &)>;
+
+    GCPUKernel();
+    GCPUKernel(const RunF& runF, const SetupF& setupF = nullptr);
+
+    RunF m_runF = nullptr;
+    SetupF m_setupF = nullptr;
+
+    bool m_isStateful = false;
+};
+
+// FIXME: This is an ugly ad-hoc implementation. TODO: refactor
+
+namespace detail
+{
+template<class T> struct get_in;
+template<> struct get_in<cv::GMat>
+{
+    static cv::Mat    get(GCPUContext &ctx, int idx) { return ctx.inMat(idx); }
+};
+template<> struct get_in<cv::GMatP>
+{
+    static cv::Mat    get(GCPUContext &ctx, int idx) { return get_in<cv::GMat>::get(ctx, idx); }
+};
+template<> struct get_in<cv::GFrame>
+{
+    static cv::MediaFrame get(GCPUContext &ctx, int idx) { return ctx.inArg<cv::MediaFrame>(idx); }
+};
+template<> struct get_in<cv::GScalar>
+{
+    static cv::Scalar get(GCPUContext &ctx, int idx) { return ctx.inVal(idx); }
+};
+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): GArray<vector<U>>/GArray<GArray<U>> conversion should be done more gracefully in the system
+template<typename U> struct get_in<cv::GArray<cv::GArray<U>> >: public get_in<cv::GArray<std::vector<U>> >
+{
+};
+
+//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); }
+};
+
+struct tracked_cv_mat{
+    tracked_cv_mat(cv::Mat& m) : r{m}, original_data{m.data} {}
+    cv::Mat r;
+    uchar* original_data;
+
+    operator cv::Mat& (){ return r;}
+    void validate() const{
+        if (r.data != original_data)
+        {
+            util::throw_error
+                (std::logic_error
+                 ("OpenCV kernel output parameter was reallocated. \n"
+                  "Incorrect meta data was provided ?"));
+        }
+    }
+};
+
+template<typename... Outputs>
+void postprocess(Outputs&... outs)
+{
+    struct
+    {
+        void operator()(tracked_cv_mat* bm) { bm->validate();  }
+        void operator()(...)                {                  }
+
+    } validate;
+    //dummy array to unfold parameter pack
+    int dummy[] = { 0, (validate(&outs), 0)... };
+    cv::util::suppress_unused_warning(dummy);
+}
+
+template<class T> struct get_out;
+template<> struct get_out<cv::GMat>
+{
+    static tracked_cv_mat get(GCPUContext &ctx, int idx)
+    {
+        auto& r = ctx.outMatR(idx);
+        return {r};
+    }
+};
+template<> struct get_out<cv::GMatP>
+{
+    static tracked_cv_mat get(GCPUContext &ctx, int idx)
+    {
+        return get_out<cv::GMat>::get(ctx, idx);
+    }
+};
+template<> struct get_out<cv::GScalar>
+{
+    static cv::Scalar& get(GCPUContext &ctx, int idx)
+    {
+        return ctx.outValR(idx);
+    }
+};
+template<> struct get_out<cv::GFrame>
+{
+    static cv::MediaFrame& get(GCPUContext &ctx, int idx)
+    {
+        return ctx.outFrame(idx);
+    }
+};
+template<typename U> struct get_out<cv::GArray<U>>
+{
+    static std::vector<U>& get(GCPUContext &ctx, int idx)
+    {
+        return ctx.outVecR<U>(idx);
+    }
+};
+
+//FIXME(dm): GArray<Mat>/GArray<GMat> conversion should be done more gracefully in the system
+template<> struct get_out<cv::GArray<cv::GMat> >: public get_out<cv::GArray<cv::Mat> >
+{
+};
+
+// FIXME(dm): GArray<vector<U>>/GArray<GArray<U>> conversion should be done more gracefully in the system
+template<typename U> struct get_out<cv::GArray<cv::GArray<U>> >: public get_out<cv::GArray<std::vector<U>> >
+{
+};
+
+template<typename U> struct get_out<cv::GOpaque<U>>
+{
+    static U& get(GCPUContext &ctx, int idx)
+    {
+        return ctx.outOpaqueR<U>(idx);
+    }
+};
+
+template<typename, typename>
+struct OCVSetupHelper;
+
+template<typename Impl, typename... Ins>
+struct OCVSetupHelper<Impl, std::tuple<Ins...>>
+{
+    // Using 'auto' return type and 'decltype' specifier in both 'setup_impl' versions
+    // to check existence of required 'Impl::setup' functions.
+    // While 'decltype' specifier accepts expression we pass expression with 'comma-operator'
+    // where first operand of comma-operator is call attempt to desired 'Impl::setup' and
+    // the second operand is 'void()' expression.
+    //
+    // SFINAE for 'Impl::setup' which accepts compile arguments.
+    template<int... IIs>
+    static auto setup_impl(const GMetaArgs &metaArgs, const GArgs &args,
+                           GArg &state, const GCompileArgs &compileArgs,
+                           detail::Seq<IIs...>) ->
+        decltype(Impl::setup(detail::get_in_meta<Ins>(metaArgs, args, IIs)...,
+                             std::declval<typename std::add_lvalue_reference<
+                                              std::shared_ptr<typename Impl::State>
+                                                                            >::type
+                                         >(),
+                            compileArgs)
+                 , void())
+    {
+        // TODO: unique_ptr <-> shared_ptr conversion ?
+        // To check: Conversion is possible only if the state which should be passed to
+        // 'setup' user callback isn't required to have previous value
+        std::shared_ptr<typename Impl::State> stPtr;
+        Impl::setup(detail::get_in_meta<Ins>(metaArgs, args, IIs)..., stPtr, compileArgs);
+        state = GArg(stPtr);
+    }
+
+    // SFINAE for 'Impl::setup' which doesn't accept compile arguments.
+    template<int... IIs>
+    static auto setup_impl(const GMetaArgs &metaArgs, const GArgs &args,
+                           GArg &state, const GCompileArgs &/* compileArgs */,
+                           detail::Seq<IIs...>) ->
+        decltype(Impl::setup(detail::get_in_meta<Ins>(metaArgs, args, IIs)...,
+                             std::declval<typename std::add_lvalue_reference<
+                                              std::shared_ptr<typename Impl::State>
+                                                                            >::type
+                                         >()
+                            )
+                 , void())
+    {
+        // The same comment as in 'setup' above.
+        std::shared_ptr<typename Impl::State> stPtr;
+        Impl::setup(detail::get_in_meta<Ins>(metaArgs, args, IIs)..., stPtr);
+        state = GArg(stPtr);
+    }
+
+    static void setup(const GMetaArgs &metaArgs, const GArgs &args,
+                      GArg& state, const GCompileArgs &compileArgs)
+    {
+        setup_impl(metaArgs, args, state, compileArgs,
+                   typename detail::MkSeq<sizeof...(Ins)>::type());
+    }
+};
+
+// OCVCallHelper is a helper class to call stateless OCV kernels and OCV kernel functors.
+template<typename, typename, typename>
+struct OCVCallHelper;
+
+// FIXME: probably can be simplified with std::apply or analogue.
+template<typename Impl, typename... Ins, typename... Outs>
+struct OCVCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...>>
+{
+    template<typename... Inputs>
+    struct call_and_postprocess
+    {
+        template<typename... Outputs>
+        static void call(Inputs&&... ins, Outputs&&... outs)
+        {
+            //not using a std::forward on outs is deliberate in order to
+            //cause compilation error, by trying to bind rvalue references to lvalue references
+            Impl::run(std::forward<Inputs>(ins)..., outs...);
+            postprocess(outs...);
+        }
+
+        template<typename... Outputs>
+        static void call(Impl& impl, Inputs&&... ins, Outputs&&... outs)
+        {
+            impl(std::forward<Inputs>(ins)..., outs...);
+        }
+    };
+
+    template<int... IIs, int... OIs>
+    static void call_impl(GCPUContext &ctx, detail::Seq<IIs...>, detail::Seq<OIs...>)
+    {
+        //Make sure that OpenCV kernels do not reallocate memory for output parameters
+        //by comparing it's state (data ptr) before and after the call.
+        //This is done by converting each output Mat into tracked_cv_mat object, and binding
+        //them to parameters of ad-hoc function
+        call_and_postprocess<decltype(get_in<Ins>::get(ctx, IIs))...>
+            ::call(get_in<Ins>::get(ctx, IIs)..., get_out<Outs>::get(ctx, OIs)...);
+    }
+
+    template<int... IIs, int... OIs>
+    static void call_impl(cv::GCPUContext &ctx, Impl& impl,
+                          detail::Seq<IIs...>, detail::Seq<OIs...>)
+    {
+        call_and_postprocess<decltype(get_in<Ins>::get(ctx, IIs))...>
+            ::call(impl, get_in<Ins>::get(ctx, IIs)..., get_out<Outs>::get(ctx, OIs)...);
+    }
+
+    static void call(GCPUContext &ctx)
+    {
+        call_impl(ctx,
+                  typename detail::MkSeq<sizeof...(Ins)>::type(),
+                  typename detail::MkSeq<sizeof...(Outs)>::type());
+    }
+
+    // NB: Same as call but calling the object
+    // This necessary for kernel implementations that have a state
+    // and are represented as an object
+    static void callFunctor(cv::GCPUContext &ctx, Impl& impl)
+    {
+        call_impl(ctx, impl,
+                  typename detail::MkSeq<sizeof...(Ins)>::type(),
+                  typename detail::MkSeq<sizeof...(Outs)>::type());
+    }
+};
+
+// OCVStCallHelper is a helper class to call stateful OCV kernels.
+template<typename, typename, typename>
+struct OCVStCallHelper;
+
+template<typename Impl, typename... Ins, typename... Outs>
+struct OCVStCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...>> :
+    OCVCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...>>
+{
+    template<typename... Inputs>
+    struct call_and_postprocess
+    {
+        template<typename... Outputs>
+        static void call(typename Impl::State& st, Inputs&&... ins, Outputs&&... outs)
+        {
+            Impl::run(std::forward<Inputs>(ins)..., outs..., st);
+            postprocess(outs...);
+        }
+    };
+
+    template<int... IIs, int... OIs>
+    static void call_impl(GCPUContext &ctx, detail::Seq<IIs...>, detail::Seq<OIs...>)
+    {
+        auto& st = *ctx.state().get<std::shared_ptr<typename Impl::State>>();
+        call_and_postprocess<decltype(get_in<Ins>::get(ctx, IIs))...>
+            ::call(st, get_in<Ins>::get(ctx, IIs)..., get_out<Outs>::get(ctx, OIs)...);
+    }
+
+    static void call(GCPUContext &ctx)
+    {
+        call_impl(ctx,
+                  typename detail::MkSeq<sizeof...(Ins)>::type(),
+                  typename detail::MkSeq<sizeof...(Outs)>::type());
+    }
+};
+
+} // namespace detail
+
+template<class Impl, class K>
+class GCPUKernelImpl: public cv::detail::KernelTag
+{
+    using CallHelper = cv::detail::OCVCallHelper<Impl, typename K::InArgs, typename K::OutArgs>;
+
+public:
+    using API = K;
+
+    static cv::gapi::GBackend backend() { return cv::gapi::cpu::backend(); }
+    static cv::GCPUKernel      kernel() { return GCPUKernel(&CallHelper::call); }
+};
+
+template<class Impl, class K, class S>
+class GCPUStKernelImpl: public cv::detail::KernelTag
+{
+    using StSetupHelper = detail::OCVSetupHelper<Impl, typename K::InArgs>;
+    using StCallHelper  = detail::OCVStCallHelper<Impl, typename K::InArgs, typename K::OutArgs>;
+
+public:
+    using API = K;
+    using State = S;
+
+    static cv::gapi::GBackend backend() { return cv::gapi::cpu::backend(); }
+    static cv::GCPUKernel     kernel()  { return GCPUKernel(&StCallHelper::call,
+                                                            &StSetupHelper::setup); }
+};
+
+#define GAPI_OCV_KERNEL(Name, API) struct Name: public cv::GCPUKernelImpl<Name, API>
+
+// TODO: Reuse Anatoliy's logic for support of types with commas in macro.
+//       Retrieve the common part from Anatoliy's logic to the separate place.
+#define GAPI_OCV_KERNEL_ST(Name, API, State)                   \
+    struct Name: public cv::GCPUStKernelImpl<Name, API, State> \
+
+/// @private
+class gapi::cpu::GOCVFunctor : public gapi::GFunctor
+{
+public:
+    using Impl = std::function<void(GCPUContext &)>;
+    using Meta = cv::GKernel::M;
+
+    GOCVFunctor(const char* id, const Meta &meta, const Impl& impl)
+        : gapi::GFunctor(id), impl_{GCPUKernel(impl), meta}
+    {
+    }
+
+    GKernelImpl    impl()    const override { return impl_;                }
+    gapi::GBackend backend() const override { return gapi::cpu::backend(); }
+
+private:
+    GKernelImpl impl_;
+};
+
+//! @cond IGNORED
+template<typename K, typename Callable>
+gapi::cpu::GOCVFunctor gapi::cpu::ocv_kernel(Callable& c)
+{
+    using P = cv::detail::OCVCallHelper<Callable, typename K::InArgs, typename K::OutArgs>;
+    return GOCVFunctor{ K::id()
+                      , &K::getOutMeta
+                      , std::bind(&P::callFunctor, std::placeholders::_1, std::ref(c))
+                      };
+}
+
+template<typename K, typename Callable>
+gapi::cpu::GOCVFunctor gapi::cpu::ocv_kernel(const Callable& c)
+{
+    using P = cv::detail::OCVCallHelper<Callable, typename K::InArgs, typename K::OutArgs>;
+    return GOCVFunctor{ K::id()
+                      , &K::getOutMeta
+                      , std::bind(&P::callFunctor, std::placeholders::_1, c)
+                      };
+}
+//! @endcond
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GCPUKERNEL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/cpu/imgproc.hpp

@@ -0,0 +1,27 @@
+// 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_CPU_IMGPROC_API_HPP
+#define OPENCV_GAPI_CPU_IMGPROC_API_HPP
+
+#include <opencv2/core/cvdef.h>     // GAPI_EXPORTS
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+
+namespace cv {
+namespace gapi {
+namespace imgproc {
+namespace cpu {
+
+GAPI_EXPORTS GKernelPackage kernels();
+
+} // namespace cpu
+} // namespace imgproc
+} // namespace gapi
+} // namespace cv
+
+
+#endif // OPENCV_GAPI_CPU_IMGPROC_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/cpu/stereo.hpp

@@ -0,0 +1,48 @@
+// 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) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_CPU_STEREO_API_HPP
+#define OPENCV_GAPI_CPU_STEREO_API_HPP
+
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+
+namespace cv {
+namespace gapi {
+namespace calib3d {
+namespace cpu {
+
+GAPI_EXPORTS GKernelPackage kernels();
+
+/** @brief Structure for the Stereo operation initialization parameters.*/
+struct GAPI_EXPORTS StereoInitParam {
+    StereoInitParam(int nD, int bS, double bL, double f):
+        numDisparities(nD), blockSize(bS), baseline(bL), focus(f) {}
+
+    StereoInitParam() = default;
+
+    int numDisparities = 0;
+    int blockSize = 21;
+    double baseline = 63.5;
+    double focus = 3.6;
+};
+
+} // namespace cpu
+} // namespace calib3d
+} // namespace gapi
+
+namespace detail {
+
+    template<> struct CompileArgTag<cv::gapi::calib3d::cpu::StereoInitParam> {
+    static const char* tag() {
+        return "org.opencv.stereoInit";
+    }
+};
+
+} // namespace detail
+} // namespace cv
+
+
+#endif // OPENCV_GAPI_CPU_STEREO_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/cpu/video.hpp

@@ -0,0 +1,25 @@
+// 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) 2020 Intel Corporation
+
+#ifndef OPENCV_GAPI_CPU_VIDEO_API_HPP
+#define OPENCV_GAPI_CPU_VIDEO_API_HPP
+
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+
+namespace cv {
+namespace gapi {
+namespace video {
+namespace cpu {
+
+GAPI_EXPORTS GKernelPackage kernels();
+
+} // namespace cpu
+} // namespace video
+} // namespace gapi
+} // namespace cv
+
+
+#endif // OPENCV_GAPI_CPU_VIDEO_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/fluid/core.hpp

@@ -0,0 +1,20 @@
+// 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_FLUID_CORE_HPP
+#define OPENCV_GAPI_FLUID_CORE_HPP
+
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+#include <opencv2/gapi/own/exports.hpp> // GAPI_EXPORTS
+
+namespace cv { namespace gapi { namespace core { namespace fluid {
+
+GAPI_EXPORTS_W cv::gapi::GKernelPackage kernels();
+
+}}}}
+
+#endif // OPENCV_GAPI_FLUID_CORE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/fluid/gfluidbuffer.hpp

@@ -0,0 +1,154 @@
+// 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_FLUID_BUFFER_HPP
+#define OPENCV_GAPI_FLUID_BUFFER_HPP
+
+#include <list>
+#include <numeric> // accumulate
+#include <ostream> // ostream
+#include <cstdint> // uint8_t
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/gmat.hpp>
+
+#include <opencv2/gapi/util/optional.hpp>
+
+namespace cv {
+namespace gapi {
+namespace fluid {
+
+struct Border
+{
+    // This constructor is required to support existing kernels which are part of G-API
+    Border(int _type, cv::Scalar _val) : type(_type), value(_val) {};
+
+    int type;
+    cv::Scalar value;
+};
+
+using BorderOpt = util::optional<Border>;
+
+bool operator == (const Border& b1, const Border& b2);
+
+class GAPI_EXPORTS Buffer;
+
+class GAPI_EXPORTS View
+{
+public:
+    struct Cache
+    {
+        std::vector<const uint8_t*> m_linePtrs;
+        GMatDesc m_desc;
+        int m_border_size = 0;
+
+        inline const uint8_t* linePtr(int index) const
+        {
+            // "out_of_window" check:
+            // user must not request the lines which are outside of specified kernel window
+            GAPI_DbgAssert(index >= -m_border_size
+                        && index <  -m_border_size + static_cast<int>(m_linePtrs.size()));
+            return m_linePtrs[index + m_border_size];
+        }
+    };
+
+    const inline uint8_t* InLineB(int index) const // -(w-1)/2...0...+(w-1)/2 for Filters
+    {
+        return m_cache->linePtr(index);
+    }
+
+    template<typename T> const inline T* InLine(int i) const
+    {
+        const uint8_t* ptr = this->InLineB(i);
+        return reinterpret_cast<const T*>(ptr);
+    }
+
+    inline operator bool() const { return m_priv != nullptr; }
+    bool ready() const;
+    inline int length() const { return m_cache->m_desc.size.width; }
+    int y() const;
+
+    inline const GMatDesc& meta() const { return m_cache->m_desc; }
+
+    class GAPI_EXPORTS Priv;      // internal use only
+    Priv& priv();               // internal use only
+    const Priv& priv() const;   // internal use only
+
+    View();
+    View(std::unique_ptr<Priv>&& p);
+    View(View&& v);
+    View& operator=(View&& v);
+    ~View();
+
+private:
+    std::unique_ptr<Priv> m_priv;
+    const Cache* m_cache = nullptr;
+};
+
+class GAPI_EXPORTS Buffer
+{
+public:
+    struct Cache
+    {
+        std::vector<uint8_t*> m_linePtrs;
+        GMatDesc m_desc;
+    };
+
+    // Default constructor (executable creation stage,
+    // all following initialization performed in Priv::init())
+    Buffer();
+    // Scratch constructor (user kernels)
+    Buffer(const cv::GMatDesc &desc);
+
+    // Constructor for intermediate buffers (for tests)
+    Buffer(const cv::GMatDesc &desc,
+           int max_line_consumption, int border_size,
+           int skew,
+           int wlpi,
+           BorderOpt border);
+    // Constructor for in/out buffers (for tests)
+    Buffer(const cv::Mat &data, bool is_input);
+    ~Buffer();
+    Buffer& operator=(Buffer&&);
+
+    inline uint8_t* OutLineB(int index = 0)
+    {
+        return m_cache->m_linePtrs[index];
+    }
+
+    template<typename T> inline T* OutLine(int index = 0)
+    {
+        uint8_t* ptr = this->OutLineB(index);
+        return reinterpret_cast<T*>(ptr);
+    }
+
+    int y() const;
+
+    int linesReady() const;
+    void debug(std::ostream &os) const;
+    inline int length() const { return m_cache->m_desc.size.width; }
+    int lpi() const;  // LPI for WRITER
+
+    inline const GMatDesc& meta() const { return m_cache->m_desc; }
+
+    View mkView(int borderSize, bool ownStorage);
+    void addView(const View* v);
+
+    class GAPI_EXPORTS Priv;      // internal use only
+    Priv& priv();               // internal use only
+    const Priv& priv() const;   // internal use only
+
+private:
+    std::unique_ptr<Priv> m_priv;
+    const Cache* m_cache;
+};
+
+} // namespace cv::gapi::fluid
+} // namespace cv::gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_FLUID_BUFFER_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/fluid/gfluidkernel.hpp

@@ -0,0 +1,442 @@
+// 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
+
+
+#ifndef OPENCV_GAPI_FLUID_KERNEL_HPP
+#define OPENCV_GAPI_FLUID_KERNEL_HPP
+
+#include <vector>
+#include <functional>
+#include <map>
+#include <unordered_map>
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/garg.hpp>
+
+#include <opencv2/gapi/fluid/gfluidbuffer.hpp>
+
+// FIXME: namespace scheme for backends?
+namespace cv {
+
+namespace gapi
+{
+/**
+ * @brief This namespace contains G-API Fluid backend functions, structures, and symbols.
+ */
+namespace fluid
+{
+    /**
+     * \addtogroup gapi_std_backends G-API Standard Backends
+     * @{
+     */
+    /**
+     * @brief Get a reference to Fluid backend.
+     *
+     * @sa gapi_std_backends
+     */
+    GAPI_EXPORTS cv::gapi::GBackend backend();
+    /** @} */
+} // namespace fluid
+} // namespace gapi
+
+
+class GAPI_EXPORTS GFluidKernel
+{
+public:
+    enum class Kind
+    {
+        Filter,
+        Resize,
+        YUV420toRGB //Color conversion of 4:2:0 chroma sub-sampling formats (NV12, I420 ..etc) to RGB
+    };
+
+    // This function is a generic "doWork" callback
+    using F = std::function<void(const cv::GArgs&, const std::vector<gapi::fluid::Buffer*> &)>;
+
+    // This function is a generic "initScratch" callback
+    using IS = std::function<void(const cv::GMetaArgs &, const cv::GArgs&, gapi::fluid::Buffer &)>;
+
+    // This function is a generic "resetScratch" callback
+    using RS = std::function<void(gapi::fluid::Buffer &)>;
+
+    // This function describes kernel metadata inference rule.
+    using M = std::function<GMetaArgs(const GMetaArgs &, const GArgs &)>;
+
+    // This function is a generic "getBorder" callback (extracts border-related data from kernel's input parameters)
+    using B = std::function<gapi::fluid::BorderOpt(const GMetaArgs&, const GArgs&)>;
+
+    // This function is a generic "getWindow" callback (extracts window-related data from kernel's input parameters)
+    using GW = std::function<int(const GMetaArgs&, const GArgs&)>;
+
+    // FIXME: move implementations out of header file
+    GFluidKernel() {}
+    GFluidKernel(Kind k, int l, bool scratch, const F& f, const IS &is, const RS &rs, const B& b, const GW& win)
+        : m_kind(k)
+        , m_lpi(l)
+        , m_scratch(scratch)
+        , m_f(f)
+        , m_is(is)
+        , m_rs(rs)
+        , m_b(b)
+        , m_gw(win) {}
+
+    Kind m_kind;
+    const int  m_lpi     = -1;
+    const bool m_scratch = false;
+
+    const F    m_f;
+    const IS   m_is;
+    const RS   m_rs;
+    const B    m_b;
+    const GW   m_gw;
+};
+
+// FIXME!!!
+// This is the temporary and experimental API
+// which should be replaced by runtime roi-based scheduling
+/** \addtogroup gapi_compile_args
+ * @{
+ */
+/**
+ * @brief This structure allows to control the output image region
+ * which Fluid backend will produce in the graph.
+ *
+ * This feature is useful for external tiling and parallelism, but
+ * will be deprecated in the future releases.
+ */
+struct GFluidOutputRois
+{
+    std::vector<cv::Rect> rois;
+};
+
+/**
+ * @brief This structure forces Fluid backend to generate multiple
+ * parallel output regions in the graph. These regions execute in parallel.
+ *
+ * This feature may be deprecated in the future releases.
+ */
+struct GFluidParallelOutputRois
+{
+    std::vector<GFluidOutputRois> parallel_rois;
+};
+
+/**
+ * @brief This structure allows to customize the way how Fluid executes
+ * parallel regions.
+ *
+ * For example, user can utilize his own threading runtime via this parameter.
+ * The `parallel_for` member functor is called by the Fluid runtime with the
+ * following arguments:
+ *
+ * @param size Size of the parallel range to process
+ * @param f A function which should be called for every integer index
+ *   in this range by the specified parallel_for implementation.
+ *
+ * This feature may be deprecated in the future releases.
+ */
+struct GFluidParallelFor
+{
+    //this function accepts:
+    // - size of the "parallel" range as the first argument
+    // - and a function to be called on the range items, designated by item index
+    std::function<void(std::size_t size, std::function<void(std::size_t index)>)> parallel_for;
+};
+/** @} gapi_compile_args */
+
+namespace detail
+{
+template<> struct CompileArgTag<GFluidOutputRois>
+{
+    static const char* tag() { return "gapi.fluid.outputRois"; }
+};
+
+template<> struct CompileArgTag<GFluidParallelFor>
+{
+    static const char* tag() { return "gapi.fluid.parallelFor"; }
+};
+
+template<> struct CompileArgTag<GFluidParallelOutputRois>
+{
+    static const char* tag() { return "gapi.fluid.parallelOutputRois"; }
+};
+
+} // namespace detail
+
+namespace detail
+{
+template<class T> struct fluid_get_in;
+template<> struct fluid_get_in<cv::GMat>
+{
+    static const cv::gapi::fluid::View& get(const cv::GArgs &in_args, int idx)
+    {
+        return *in_args[idx].unsafe_get<cv::gapi::fluid::View*>();
+    }
+};
+
+template<> struct fluid_get_in<cv::GScalar>
+{
+    // FIXME: change to return by reference when moved to own::Scalar
+    static const cv::Scalar get(const cv::GArgs &in_args, int idx)
+    {
+        return in_args[idx].unsafe_get<cv::Scalar>();
+    }
+};
+
+template<typename U> struct fluid_get_in<cv::GArray<U>>
+{
+    static const std::vector<U>& get(const cv::GArgs &in_args, int idx)
+    {
+        return in_args.at(idx).unsafe_get<cv::detail::VectorRef>().rref<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)
+    {
+        return in_args[idx].unsafe_get<T>();
+    }
+};
+
+template<bool, typename Impl, typename... Ins>
+struct scratch_helper;
+
+template<typename Impl, typename... Ins>
+struct scratch_helper<true, Impl, Ins...>
+{
+    // Init
+    template<int... IIs>
+    static void help_init_impl(const cv::GMetaArgs &metas,
+                               const cv::GArgs     &in_args,
+                               gapi::fluid::Buffer &scratch_buf,
+                               detail::Seq<IIs...>)
+    {
+        Impl::initScratch(get_in_meta<Ins>(metas, in_args, IIs)..., scratch_buf);
+    }
+
+    static void help_init(const cv::GMetaArgs &metas,
+                          const cv::GArgs     &in_args,
+                          gapi::fluid::Buffer &b)
+    {
+        help_init_impl(metas, in_args, b, typename detail::MkSeq<sizeof...(Ins)>::type());
+    }
+
+    // Reset
+    static void help_reset(gapi::fluid::Buffer &b)
+    {
+        Impl::resetScratch(b);
+    }
+};
+
+template<typename Impl, typename... Ins>
+struct scratch_helper<false, Impl, Ins...>
+{
+    static void help_init(const cv::GMetaArgs &,
+                          const cv::GArgs     &,
+                          gapi::fluid::Buffer &)
+    {
+        GAPI_Assert(false);
+    }
+    static void help_reset(gapi::fluid::Buffer &)
+    {
+        GAPI_Assert(false);
+    }
+};
+
+template<typename T> struct is_gmat_type
+{
+    static const constexpr bool value = std::is_same<cv::GMat, T>::value;
+};
+
+template<bool CallCustomGetBorder, typename Impl, typename... Ins>
+struct get_border_helper;
+
+template<typename Impl, typename... Ins>
+struct get_border_helper<true, Impl, Ins...>
+{
+    template<int... IIs>
+    static gapi::fluid::BorderOpt get_border_impl(const GMetaArgs &metas,
+                                                  const cv::GArgs &in_args,
+                                                  cv::detail::Seq<IIs...>)
+    {
+        return util::make_optional(Impl::getBorder(cv::detail::get_in_meta<Ins>(metas, in_args, IIs)...));
+    }
+
+    static gapi::fluid::BorderOpt help(const GMetaArgs &metas,
+                                       const cv::GArgs &in_args)
+    {
+        return get_border_impl(metas, in_args, typename detail::MkSeq<sizeof...(Ins)>::type());
+    }
+};
+
+template<typename Impl, typename... Ins>
+struct get_border_helper<false, Impl, Ins...>
+{
+    static gapi::fluid::BorderOpt help(const cv::GMetaArgs &,
+                                       const cv::GArgs     &)
+    {
+        return {};
+    }
+};
+
+template<bool CallCustomGetWindow, typename, typename... Ins>
+struct get_window_helper;
+
+template<typename Impl, typename... Ins>
+struct get_window_helper<true, Impl, Ins...>
+{
+    template<int... IIs>
+    static int get_window_impl(const GMetaArgs &metas,
+                               const cv::GArgs &in_args,
+                               cv::detail::Seq<IIs...>)
+    {
+        return Impl::getWindow(cv::detail::get_in_meta<Ins>(metas, in_args, IIs)...);
+    }
+
+    static int help(const GMetaArgs &metas, const cv::GArgs &in_args)
+    {
+        return get_window_impl(metas, in_args, typename detail::MkSeq<sizeof...(Ins)>::type());
+    }
+};
+
+template<typename Impl, typename... Ins>
+struct get_window_helper<false, Impl, Ins...>
+{
+    static int help(const cv::GMetaArgs &,
+                    const cv::GArgs     &)
+    {
+        return Impl::Window;
+    }
+};
+
+template<typename C, typename T>
+struct has_Window
+{
+private:
+    template<class U>
+    static constexpr auto Check(U*) -> typename std::is_same<decltype(U::Window), T>::type;
+
+    template<typename>
+    static constexpr std::false_type Check(...);
+
+    typedef decltype(Check<C>(0)) Result;
+
+public:
+    static constexpr bool value = Result::value;
+};
+
+template<bool hasWindow, typename Impl>
+struct callCustomGetBorder;
+
+template<typename Impl>
+struct callCustomGetBorder<true, Impl>
+{
+    static constexpr bool value = (Impl::Window != 1);
+};
+
+template<typename Impl>
+struct callCustomGetBorder<false, Impl>
+{
+    static constexpr bool value = true;
+};
+
+template<typename, typename, typename, bool UseScratch>
+struct FluidCallHelper;
+
+template<typename Impl, typename... Ins, typename... Outs, bool UseScratch>
+struct FluidCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...>, UseScratch>
+{
+    static_assert(all_satisfy<is_gmat_type, Outs...>::value, "return type must be GMat");
+    static_assert(contains<GMat, Ins...>::value, "input must contain at least one GMat");
+
+    // Execution dispatcher ////////////////////////////////////////////////////
+    template<int... IIs, int... OIs>
+    static void call_impl(const cv::GArgs &in_args,
+                          const std::vector<gapi::fluid::Buffer*> &out_bufs,
+                          detail::Seq<IIs...>,
+                          detail::Seq<OIs...>)
+    {
+        Impl::run(fluid_get_in<Ins>::get(in_args, IIs)..., *out_bufs[OIs]...);
+    }
+
+    static void call(const cv::GArgs &in_args,
+                     const std::vector<gapi::fluid::Buffer*> &out_bufs)
+    {
+        constexpr int numOuts = (sizeof...(Outs)) + (UseScratch ? 1 : 0);
+        call_impl(in_args, out_bufs,
+                  typename detail::MkSeq<sizeof...(Ins)>::type(),
+                  typename detail::MkSeq<numOuts>::type());
+    }
+
+    // Scratch buffer initialization dispatcher ////////////////////////////////
+    static void init_scratch(const GMetaArgs &metas,
+                             const cv::GArgs &in_args,
+                             gapi::fluid::Buffer &b)
+    {
+        scratch_helper<UseScratch, Impl, Ins...>::help_init(metas, in_args, b);
+    }
+
+    // Scratch buffer reset dispatcher /////////////////////////////////////////
+    static void reset_scratch(gapi::fluid::Buffer &scratch_buf)
+    {
+        scratch_helper<UseScratch, Impl, Ins...>::help_reset(scratch_buf);
+    }
+
+    static gapi::fluid::BorderOpt getBorder(const GMetaArgs &metas, const cv::GArgs &in_args)
+    {
+        constexpr bool hasWindow = has_Window<Impl, const int>::value;
+
+        // User must provide "init" callback if Window != 1
+        // TODO: move to constexpr if when we enable C++17
+        return get_border_helper<callCustomGetBorder<hasWindow, Impl>::value, Impl, Ins...>::help(metas, in_args);
+    }
+
+    static int getWindow(const GMetaArgs &metas, const cv::GArgs &in_args)
+    {
+        constexpr bool callCustomGetWindow = !(has_Window<Impl, const int>::value);
+        return get_window_helper<callCustomGetWindow, Impl, Ins...>::help(metas, in_args);
+    }
+};
+} // namespace detail
+
+
+template<class Impl, class K, bool UseScratch>
+class GFluidKernelImpl : public cv::detail::KernelTag
+{
+    static const int LPI = 1;
+    static const auto Kind = GFluidKernel::Kind::Filter;
+    using P = detail::FluidCallHelper<Impl, typename K::InArgs, typename K::OutArgs, UseScratch>;
+
+public:
+    using API = K;
+
+    static GFluidKernel kernel()
+    {
+        // FIXME: call() and getOutMeta() needs to be renamed so it is clear these
+        // functions are internal wrappers, not user API
+        return GFluidKernel(Impl::Kind, Impl::LPI,
+                            UseScratch,
+                            &P::call, &P::init_scratch, &P::reset_scratch, &P::getBorder, &P::getWindow);
+    }
+
+    static cv::gapi::GBackend backend() { return cv::gapi::fluid::backend(); }
+};
+
+#define GAPI_FLUID_KERNEL(Name, API, Scratch) struct Name: public cv::GFluidKernelImpl<Name, API, Scratch>
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GCPUKERNEL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/fluid/imgproc.hpp

@@ -0,0 +1,20 @@
+// 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_FLUID_IMGPROC_HPP
+#define OPENCV_GAPI_FLUID_IMGPROC_HPP
+
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+#include <opencv2/gapi/own/exports.hpp> // GAPI_EXPORTS
+
+namespace cv { namespace gapi { namespace imgproc { namespace fluid {
+
+GAPI_EXPORTS GKernelPackage kernels();
+
+}}}}
+
+#endif // OPENCV_GAPI_FLUID_IMGPROC_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/garg.hpp

@@ -0,0 +1,309 @@
+// 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-2021 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GARG_HPP
+#define OPENCV_GAPI_GARG_HPP
+
+#include <vector>
+#include <unordered_map>
+#include <type_traits>
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/own/mat.hpp>
+#include <opencv2/gapi/media.hpp>
+
+#include <opencv2/gapi/util/util.hpp>
+#include <opencv2/gapi/util/any.hpp>
+#include <opencv2/gapi/util/variant.hpp>
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/gscalar.hpp>
+#include <opencv2/gapi/garray.hpp>
+#include <opencv2/gapi/gopaque.hpp>
+#include <opencv2/gapi/gframe.hpp>
+#include <opencv2/gapi/gtype_traits.hpp>
+#include <opencv2/gapi/gmetaarg.hpp>
+#include <opencv2/gapi/streaming/source.hpp>
+#include <opencv2/gapi/rmat.hpp>
+
+namespace cv {
+
+class GArg;
+
+namespace detail {
+    template<typename T>
+    using is_garg = std::is_same<GArg, typename std::decay<T>::type>;
+}
+
+// Parameter holder class for a node
+// Depending on platform capabilities, can either support arbitrary types
+// (as `boost::any`) or a limited number of types (as `boot::variant`).
+// FIXME: put into "details" as a user shouldn't use it in his code
+class GAPI_EXPORTS GArg
+{
+public:
+    GArg() {}
+
+    template<typename T, typename std::enable_if<!detail::is_garg<T>::value, int>::type = 0>
+    explicit GArg(const T &t)
+        : kind(detail::GTypeTraits<T>::kind)
+        , opaque_kind(detail::GOpaqueTraits<T>::kind)
+        , value(detail::wrap_gapi_helper<T>::wrap(t))
+    {
+    }
+
+    template<typename T, typename std::enable_if<!detail::is_garg<T>::value, int>::type = 0>
+    explicit GArg(T &&t)
+        : kind(detail::GTypeTraits<typename std::decay<T>::type>::kind)
+        , opaque_kind(detail::GOpaqueTraits<typename std::decay<T>::type>::kind)
+        , value(detail::wrap_gapi_helper<T>::wrap(t))
+    {
+    }
+
+    template<typename T> inline T& get()
+    {
+        return util::any_cast<typename std::remove_reference<T>::type>(value);
+    }
+
+    template<typename T> inline const T& get() const
+    {
+        return util::any_cast<typename std::remove_reference<T>::type>(value);
+    }
+
+    template<typename T> inline T& unsafe_get()
+    {
+        return util::unsafe_any_cast<typename std::remove_reference<T>::type>(value);
+    }
+
+    template<typename T> inline const T& unsafe_get() const
+    {
+        return util::unsafe_any_cast<typename std::remove_reference<T>::type>(value);
+    }
+
+    detail::ArgKind kind = detail::ArgKind::OPAQUE_VAL;
+    detail::OpaqueKind opaque_kind = detail::OpaqueKind::CV_UNKNOWN;
+
+protected:
+    util::any value;
+};
+
+using GArgs = std::vector<GArg>;
+
+// FIXME: Express as M<GProtoArg...>::type
+// FIXME: Move to a separate file!
+using GRunArgBase  = util::variant<
+#if !defined(GAPI_STANDALONE)
+    cv::UMat,
+#endif // !defined(GAPI_STANDALONE)
+    cv::RMat,
+    cv::gapi::wip::IStreamSource::Ptr,
+    cv::Mat,
+    cv::Scalar,
+    cv::detail::VectorRef,
+    cv::detail::OpaqueRef,
+    cv::MediaFrame
+    >;
+
+namespace detail {
+template<typename,typename>
+struct in_variant;
+
+template<typename T, typename... Types>
+struct in_variant<T, util::variant<Types...> >
+    : std::integral_constant<bool, cv::detail::contains<T, Types...>::value > {
+};
+} // namespace detail
+
+struct GAPI_EXPORTS GRunArg: public GRunArgBase
+{
+    // Metadata information here
+    using Meta = std::unordered_map<std::string, util::any>;
+    Meta meta;
+
+    // Mimic the old GRunArg semantics here, old of the times when
+    // GRunArg was an alias to variant<>
+    GRunArg();
+    GRunArg(const cv::GRunArg &arg);
+    GRunArg(cv::GRunArg &&arg);
+
+    GRunArg& operator= (const GRunArg &arg);
+    GRunArg& operator= (GRunArg &&arg);
+
+    template <typename T>
+    GRunArg(const T &t,
+            const Meta &m = Meta{},
+            typename std::enable_if< detail::in_variant<T, GRunArgBase>::value, int>::type = 0)
+        : GRunArgBase(t)
+        , meta(m)
+    {
+    }
+    template <typename T>
+    GRunArg(T &&t,
+            const Meta &m = Meta{},
+            typename std::enable_if< detail::in_variant<T, GRunArgBase>::value, int>::type = 0)
+        : GRunArgBase(std::move(t))
+        , meta(m)
+    {
+    }
+    template <typename T> auto operator= (const T &t)
+        -> typename std::enable_if< detail::in_variant<T, GRunArgBase>::value, cv::GRunArg>::type&
+    {
+        GRunArgBase::operator=(t);
+        return *this;
+    }
+    template <typename T> auto operator= (T&& t)
+        -> typename std::enable_if< detail::in_variant<T, GRunArgBase>::value, cv::GRunArg>::type&
+    {
+        GRunArgBase::operator=(std::move(t));
+        return *this;
+    }
+};
+using GRunArgs = std::vector<GRunArg>;
+
+// TODO: Think about the addition operator
+/**
+ * @brief This operator allows to complement the input vector at runtime.
+ *
+ * It's an ordinary overload of addition assignment operator.
+ *
+ * Example of usage:
+ * @snippet modules/gapi/samples/dynamic_graph.cpp GRunArgs usage
+ *
+ */
+inline GRunArgs& operator += (GRunArgs &lhs, const GRunArgs &rhs)
+{
+    lhs.reserve(lhs.size() + rhs.size());
+    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
+    return lhs;
+}
+
+namespace gapi
+{
+namespace wip
+{
+/**
+ * @brief This aggregate type represents all types which G-API can
+ * handle (via variant).
+ *
+ * It only exists to overcome C++ language limitations (where a
+ * `using`-defined class can't be forward-declared).
+ */
+struct GAPI_EXPORTS Data: public GRunArg
+{
+    using GRunArg::GRunArg;
+    template <typename T>
+    Data& operator= (const T& t) { GRunArg::operator=(t); return *this; }
+    template <typename T>
+    Data& operator= (T&& t) { GRunArg::operator=(std::move(t)); return *this; }
+};
+} // namespace wip
+} // namespace gapi
+
+using GRunArgP = util::variant<
+#if !defined(GAPI_STANDALONE)
+    cv::UMat*,
+#endif // !defined(GAPI_STANDALONE)
+    cv::Mat*,
+    cv::RMat*,
+    cv::Scalar*,
+    cv::MediaFrame*,
+    cv::detail::VectorRef,
+    cv::detail::OpaqueRef
+    >;
+using GRunArgsP = std::vector<GRunArgP>;
+
+// TODO: Think about the addition operator
+/**
+ * @brief This operator allows to complement the output vector at runtime.
+ *
+ * It's an ordinary overload of addition assignment operator.
+ *
+ * Example of usage:
+ * @snippet modules/gapi/samples/dynamic_graph.cpp GRunArgsP usage
+ *
+ */
+inline GRunArgsP& operator += (GRunArgsP &lhs, const GRunArgsP &rhs)
+{
+    lhs.reserve(lhs.size() + rhs.size());
+    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
+    return lhs;
+}
+
+namespace gapi
+{
+/**
+ * \addtogroup gapi_serialization
+ * @{
+ *
+ * @brief G-API functions and classes for serialization and deserialization.
+ */
+/** @brief Wraps deserialized output GRunArgs to GRunArgsP which can be used by GCompiled.
+ *
+ * Since it's impossible to get modifiable output arguments from deserialization
+ * it needs to be wrapped by this function.
+ *
+ * Example of usage:
+ * @snippet modules/gapi/samples/api_ref_snippets.cpp bind after deserialization
+ *
+ * @param out_args deserialized GRunArgs.
+ * @return the same GRunArgs wrapped in GRunArgsP.
+ * @see deserialize
+ */
+GAPI_EXPORTS cv::GRunArgsP bind(cv::GRunArgs &out_args);
+/** @brief Wraps output GRunArgsP available during graph execution to GRunArgs which can be serialized.
+ *
+ * GRunArgsP is pointer-to-value, so to be serialized they need to be binded to real values
+ * which this function does.
+ *
+ * Example of usage:
+ * @snippet modules/gapi/samples/api_ref_snippets.cpp bind before serialization
+ *
+ * @param out output GRunArgsP available during graph execution.
+ * @return the same GRunArgsP wrapped in serializable GRunArgs.
+ * @see serialize
+ */
+GAPI_EXPORTS cv::GRunArg   bind(cv::GRunArgP &out);     // FIXME: think more about it
+/** @} */
+}
+
+template<typename... Ts> inline GRunArgs gin(const Ts&... args)
+{
+    return GRunArgs{ GRunArg(detail::wrap_host_helper<Ts>::wrap_in(args))... };
+}
+
+template<typename... Ts> inline GRunArgsP gout(Ts&... args)
+{
+    return GRunArgsP{ GRunArgP(detail::wrap_host_helper<Ts>::wrap_out(args))... };
+}
+
+struct GTypeInfo;
+using GTypesInfo = std::vector<GTypeInfo>;
+
+// FIXME: Needed for python bridge, must be moved to more appropriate header
+namespace detail {
+struct ExtractArgsCallback
+{
+    cv::GRunArgs operator()(const cv::GTypesInfo& info) const { return c(info); }
+    using CallBackT = std::function<cv::GRunArgs(const cv::GTypesInfo& info)>;
+    CallBackT c;
+};
+
+struct ExtractMetaCallback
+{
+    cv::GMetaArgs operator()(const cv::GTypesInfo& info) const { return c(info); }
+    using CallBackT = std::function<cv::GMetaArgs(const cv::GTypesInfo& info)>;
+    CallBackT c;
+};
+
+void constructGraphOutputs(const cv::GTypesInfo &out_info,
+                           cv::GRunArgs         &args,
+                           cv::GRunArgsP        &outs);
+} // namespace detail
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GARG_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/garray.hpp

@@ -0,0 +1,440 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GARRAY_HPP
+#define OPENCV_GAPI_GARRAY_HPP
+
+#include <functional>
+#include <ostream>
+#include <vector>
+#include <memory>
+
+#include <opencv2/gapi/own/exports.hpp>
+#include <opencv2/gapi/opencv_includes.hpp>
+
+#include <opencv2/gapi/util/variant.hpp>
+#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
+// (user-inaccessible) classes.
+class GNode;
+struct GOrigin;
+template<typename T> class GArray;
+
+/**
+ * \addtogroup gapi_meta_args
+ * @{
+ */
+struct GAPI_EXPORTS_W_SIMPLE GArrayDesc
+{
+    // FIXME: Body
+    // FIXME: Also implement proper operator== then
+    bool operator== (const GArrayDesc&) const { return true; }
+};
+template<typename U> GArrayDesc descr_of(const std::vector<U> &) { return {};}
+GAPI_EXPORTS_W inline GArrayDesc empty_array_desc() {return {}; }
+/** @} */
+
+std::ostream& operator<<(std::ostream& os, const cv::GArrayDesc &desc);
+
+namespace detail
+{
+    // 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.
+    // Currently it is suitable for Host (CPU) plugins only, real offload may require
+    // more information for manual memory allocation on-device.
+    class VectorRef;
+    using ConstructVec = std::function<void(VectorRef&)>;
+
+    // This is the base struct for GArrayU type holder
+    struct TypeHintBase{virtual ~TypeHintBase() = default;};
+
+    // This class holds type of initial GArray to be checked from GArrayU
+    template <typename T>
+    struct TypeHint final : public TypeHintBase{};
+
+    // This class strips type information from GArray<T> and makes it usable
+    // in the G-API graph compiler (expression unrolling, graph generation, etc).
+    // Part of GProtoArg.
+    class GAPI_EXPORTS GArrayU
+    {
+    public:
+        GArrayU(const GNode &n, std::size_t out); // Operation result constructor
+
+        template <typename T>
+        bool holds() const;                       // Check if was created from GArray<T>
+
+        GOrigin& priv();                          // Internal use only
+        const GOrigin& priv() const;              // Internal use only
+
+    protected:
+        GArrayU();                                // Default constructor
+        GArrayU(const detail::VectorRef& vref);   // Constant value constructor
+        template<class> friend class cv::GArray;  //  (available to GArray<T> only)
+
+        void setConstructFcn(ConstructVec &&cv);  // Store T-aware constructor
+
+        template <typename T>
+        void specifyType();                       // Store type of initial GArray<T>
+
+        template <typename T>
+        void storeKind();
+
+        void setKind(cv::detail::OpaqueKind);
+
+        std::shared_ptr<GOrigin> m_priv;
+        std::shared_ptr<TypeHintBase> m_hint;
+    };
+
+    template <typename T>
+    bool GArrayU::holds() const{
+        GAPI_Assert(m_hint != nullptr);
+        using U = typename std::decay<T>::type;
+        return dynamic_cast<TypeHint<U>*>(m_hint.get()) != nullptr;
+    };
+
+    template <typename T>
+    void GArrayU::specifyType(){
+        m_hint.reset(new TypeHint<typename std::decay<T>::type>);
+    };
+
+    template <typename T>
+    void GArrayU::storeKind(){
+        setKind(cv::detail::GOpaqueTraits<T>::kind);
+    };
+
+    // This class represents a typed STL vector reference.
+    // Depending on origins, this reference may be either "just a" reference to
+    // an object created externally, OR actually own the underlying object
+    // (be value holder).
+    class BasicVectorRef
+    {
+    public:
+        // These fields are set by the derived class(es)
+        std::size_t    m_elemSize = 0ul;
+        cv::GArrayDesc m_desc;
+        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
+    {
+        using empty_t  = util::monostate;
+        using ro_ext_t = const std::vector<T> *;
+        using rw_ext_t =       std::vector<T> *;
+        using rw_own_t =       std::vector<T>  ;
+        util::variant<empty_t, ro_ext_t, rw_ext_t, rw_own_t> m_ref;
+
+        inline bool isEmpty() const { return util::holds_alternative<empty_t>(m_ref);  }
+        inline bool isROExt() const { return util::holds_alternative<ro_ext_t>(m_ref); }
+        inline bool isRWExt() const { return util::holds_alternative<rw_ext_t>(m_ref); }
+        inline bool isRWOwn() const { return util::holds_alternative<rw_own_t>(m_ref); }
+
+        void init(const std::vector<T>* vec = nullptr)
+        {
+            m_elemSize = sizeof(T);
+            if (vec) m_desc = cv::descr_of(*vec);
+        }
+
+    public:
+        VectorRefT() { init(); }
+        virtual ~VectorRefT() {}
+
+        explicit VectorRefT(const std::vector<T>& vec) : m_ref(&vec)      { init(&vec); }
+        explicit VectorRefT(std::vector<T>& vec)  : m_ref(&vec)           { init(&vec); }
+        explicit VectorRefT(std::vector<T>&& vec) : m_ref(std::move(vec)) { init(&vec); }
+
+        // Reset a VectorRefT. Called only for objects instantiated
+        // internally in G-API (e.g. temporary GArray<T>'s within a
+        // computation).  Reset here means both initialization
+        // (creating an object) and reset (discarding its existing
+        // content before the next execution).  Must never be called
+        // for external VectorRefTs.
+        void reset()
+        {
+            if (isEmpty())
+            {
+                std::vector<T> empty_vector;
+                m_desc = cv::descr_of(empty_vector);
+                m_ref  = std::move(empty_vector);
+                GAPI_Assert(isRWOwn());
+            }
+            else if (isRWOwn())
+            {
+                util::get<rw_own_t>(m_ref).clear();
+            }
+            else GAPI_Assert(false); // shouldn't be called in *EXT modes
+        }
+
+        // Obtain a WRITE reference to underlying object
+        // Used by CPU kernel API wrappers when a kernel execution frame
+        // is created
+        std::vector<T>& wref()
+        {
+            GAPI_Assert(isRWExt() || isRWOwn());
+            if (isRWExt()) return *util::get<rw_ext_t>(m_ref);
+            if (isRWOwn()) return  util::get<rw_own_t>(m_ref);
+            util::throw_error(std::logic_error("Impossible happened"));
+        }
+
+        // Obtain a READ reference to underlying object
+        // Used by CPU kernel API wrappers when a kernel execution frame
+        // is created
+        const std::vector<T>& rref() const
+        {
+            // ANY vector can be accessed for reading, even if it declared for
+            // output. Example -- a GComputation from [in] to [out1,out2]
+            // where [out2] is a result of operation applied to [out1]:
+            //
+            //            GComputation boundary
+            //            . . . . . . .
+            //            .           .
+            //     [in] ----> foo() ----> [out1]
+            //            .           .    :
+            //            .           . . .:. . .
+            //            .                V    .
+            //            .              bar() ---> [out2]
+            //            . . . . . . . . . . . .
+            //
+            if (isROExt()) return *util::get<ro_ext_t>(m_ref);
+            if (isRWExt()) return *util::get<rw_ext_t>(m_ref);
+            if (isRWOwn()) return  util::get<rw_own_t>(m_ref);
+            util::throw_error(std::logic_error("Impossible happened"));
+        }
+
+        virtual void mov(BasicVectorRef &v) override {
+            VectorRefT<T> *tv = dynamic_cast<VectorRefT<T>*>(&v);
+            GAPI_Assert(tv != nullptr);
+            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
+    // in the G-API executables (carrying run-time data/information to kernels).
+    // Part of GRunArg.
+    // Its methods are typed proxies to VectorRefT<T>.
+    // VectorRef maintains "reference" semantics so two copies of VectoRef refer
+    // to the same underlying object.
+    // FIXME: Put a good explanation on why cv::OutputArray doesn't fit this role
+    class VectorRef
+    {
+        std::shared_ptr<BasicVectorRef> m_ref;
+        cv::detail::OpaqueKind m_kind;
+
+        template<typename T> inline void check() const
+        {
+            GAPI_DbgAssert(dynamic_cast<VectorRefT<T>*>(m_ref.get()) != nullptr);
+            GAPI_Assert(sizeof(T) == m_ref->m_elemSize);
+        }
+
+    public:
+        VectorRef() = default;
+        template<typename T> explicit VectorRef(const std::vector<T>& vec)
+            : m_ref(new VectorRefT<T>(vec))
+            , m_kind(GOpaqueTraits<T>::kind)
+        {}
+        template<typename T> explicit VectorRef(std::vector<T>& vec)
+            : m_ref(new VectorRefT<T>(vec))
+            , m_kind(GOpaqueTraits<T>::kind)
+        {}
+        template<typename T> explicit VectorRef(std::vector<T>&& vec)
+            : m_ref(new VectorRefT<T>(std::move(vec)))
+            , m_kind(GOpaqueTraits<T>::kind)
+        {}
+
+        cv::detail::OpaqueKind getKind() const
+        {
+            return m_kind;
+        }
+
+        template<typename T> void reset()
+        {
+            if (!m_ref) m_ref.reset(new VectorRefT<T>());
+            check<T>();
+            storeKind<T>();
+            static_cast<VectorRefT<T>&>(*m_ref).reset();
+        }
+
+        template <typename T>
+        void storeKind()
+        {
+            m_kind = cv::detail::GOpaqueTraits<T>::kind;
+        }
+
+        template<typename T> std::vector<T>& wref()
+        {
+            check<T>();
+            return static_cast<VectorRefT<T>&>(*m_ref).wref();
+        }
+
+        template<typename T> const std::vector<T>& rref() const
+        {
+            check<T>();
+            return static_cast<VectorRefT<T>&>(*m_ref).rref();
+        }
+
+        // Check if was created for/from std::vector<T>
+        template <typename T> bool holds() const
+        {
+            if (!m_ref) return false;
+            using U = typename std::decay<T>::type;
+            return dynamic_cast<VectorRefT<U>*>(m_ref.get()) != nullptr;
+        }
+
+        void mov(VectorRef &v)
+        {
+            m_ref->mov(*v.m_ref);
+        }
+
+        cv::GArrayDesc descr_of() const
+        {
+            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(); }
+    };
+
+    // 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<GArray<T>> { using type = std::vector<T>; };
+    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
+ * @{
+ */
+/**
+ * @brief `cv::GArray<T>` template class represents a list of objects
+ * of class `T` in the graph.
+ *
+ * `cv::GArray<T>` describes a functional relationship between
+ * operations consuming and producing arrays of objects of class
+ * `T`. The primary purpose of `cv::GArray<T>` is to represent a
+ * dynamic list of objects -- where the size of the list is not known
+ * at the graph construction or compile time. Examples include: corner
+ * and feature detectors (`cv::GArray<cv::Point>`), object detection
+ * and tracking  results (`cv::GArray<cv::Rect>`). Programmers can use
+ * their own types with `cv::GArray<T>` in the custom operations.
+ *
+ * Similar to `cv::GScalar`, `cv::GArray<T>` may be value-initialized
+ * -- in this case a graph-constant value is associated with the object.
+ *
+ * `GArray<T>` is a virtual counterpart of `std::vector<T>`, which is
+ * usually used to represent the `GArray<T>` data in G-API during the
+ * execution.
+ *
+ * @sa `cv::GOpaque<T>`
+ */
+template<typename T> class GArray
+{
+public:
+    // Host type (or Flat type) - the type this GArray is actually
+    // specified to.
+    /// @private
+    using HT = typename detail::flatten_g<typename std::decay<T>::type>::type;
+
+    /**
+     * @brief Constructs a value-initialized `cv::GArray<T>`
+     *
+     * `cv::GArray<T>` objects  may have their values
+     * be associated at graph construction time. It is useful when
+     * some operation has a `cv::GArray<T>` input which doesn't change during
+     * the program execution, and is set only once. In this case,
+     * there is no need to declare such `cv::GArray<T>` as a graph input.
+     *
+     * @note The value of `cv::GArray<T>` may be overwritten by assigning some
+     * other `cv::GArray<T>` to the object using `operator=` -- on the
+     * assigment, the old association or value is discarded.
+     *
+     * @param v a std::vector<T> to associate with this
+     * `cv::GArray<T>` object. Vector data is copied into the
+     * `cv::GArray<T>` (no reference to the passed data is held).
+     */
+    explicit GArray(const std::vector<HT>& v) // Constant value constructor
+        : m_ref(detail::GArrayU(detail::VectorRef(v))) { putDetails(); }
+
+    /**
+     * @overload
+     * @brief Constructs a value-initialized `cv::GArray<T>`
+     *
+     * @param v a std::vector<T> to associate with this
+     * `cv::GArray<T>` object. Vector data is moved into the `cv::GArray<T>`.
+     */
+    explicit GArray(std::vector<HT>&& v)      // Move-constructor
+        : m_ref(detail::GArrayU(detail::VectorRef(std::move(v)))) { putDetails(); }
+
+    /**
+     * @brief Constructs an empty `cv::GArray<T>`
+     *
+     * Normally, empty G-API data objects denote a starting point of
+     * the graph. When an empty `cv::GArray<T>` is assigned to a result
+     * of some operation, it obtains a functional link to this
+     * operation (and is not empty anymore).
+     */
+    GArray() { putDetails(); }                // Empty constructor
+
+    /// @private
+    explicit GArray(detail::GArrayU &&ref)    // GArrayU-based constructor
+        : m_ref(ref) { putDetails(); }        //   (used by GCall, not for users)
+
+    /// @private
+    detail::GArrayU strip() const {
+        return m_ref;
+    }
+    /// @private
+    static void VCtor(detail::VectorRef& vref) {
+        vref.reset<HT>();
+    }
+
+private:
+    void putDetails() {
+        m_ref.setConstructFcn(&VCtor);
+        m_ref.specifyType<HT>();  // FIXME: to unify those 2 to avoid excessive dynamic_cast
+        m_ref.storeKind<HT>();    //
+    }
+
+    detail::GArrayU m_ref;
+};
+
+/** @} */
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GARRAY_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gasync_context.hpp

@@ -0,0 +1,63 @@
+// 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_GASYNC_CONTEXT_HPP
+#define OPENCV_GAPI_GASYNC_CONTEXT_HPP
+
+#if !defined(GAPI_STANDALONE)
+#  include <opencv2/core/cvdef.h>
+#else   // Without OpenCV
+#  include <opencv2/gapi/own/cvdefs.hpp>
+#endif // !defined(GAPI_STANDALONE)
+
+#include <opencv2/gapi/own/exports.hpp>
+
+namespace cv {
+namespace gapi{
+
+/**
+ * @brief This namespace contains experimental G-API functionality,
+ * functions or structures in this namespace are subjects to change or
+ * removal in the future releases. This namespace also contains
+ * functions which API is not stabilized yet.
+ */
+namespace wip {
+
+/**
+ * @brief A class to group async requests to cancel them in a single shot.
+ *
+ * GAsyncContext is passed as an argument to async() and async_apply() functions
+ */
+
+class GAPI_EXPORTS GAsyncContext{
+    std::atomic<bool> cancelation_requested = {false};
+public:
+    /**
+     * @brief Start cancellation process for an associated request.
+     *
+     * User still has to wait for each individual request (either via callback or according std::future object) to make sure it actually canceled.
+     *
+     * @return true if it was a first request to cancel the context
+     */
+    bool cancel();
+
+    /**
+    * @brief Returns true if cancellation was requested for this context.
+    *
+    * @return true if cancellation was requested for this context
+    */
+    bool isCanceled() const;
+};
+
+class GAPI_EXPORTS GAsyncCanceled : public std::exception {
+public:
+    virtual const char* what() const noexcept CV_OVERRIDE;
+};
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif //OPENCV_GAPI_GASYNC_CONTEXT_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gcall.hpp

@@ -0,0 +1,78 @@
+// 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_GCALL_HPP
+#define OPENCV_GAPI_GCALL_HPP
+
+#include <opencv2/gapi/garg.hpp>      // GArg
+#include <opencv2/gapi/gmat.hpp>      // GMat
+#include <opencv2/gapi/gscalar.hpp>   // GScalar
+#include <opencv2/gapi/gframe.hpp>    // GFrame
+#include <opencv2/gapi/garray.hpp>    // GArray<T>
+#include <opencv2/gapi/gopaque.hpp>   // GOpaque<T>
+
+namespace cv {
+
+struct GKernel;
+
+// The whole idea of this class is to represent an operation
+// which is applied to arguments. This is part of public API,
+// since it is what users should use to define kernel interfaces.
+
+class GAPI_EXPORTS GCall final
+{
+public:
+    class Priv;
+
+    explicit GCall(const GKernel &k);
+    ~GCall();
+
+    template<typename... Ts>
+    GCall& pass(Ts&&... args)
+    {
+        setArgs({cv::GArg(std::move(args))...});
+        return *this;
+    }
+
+    // A generic yield method - obtain a link to operator's particular GMat output
+    GMat    yield      (int output = 0);
+    GMatP   yieldP     (int output = 0);
+    GScalar yieldScalar(int output = 0);
+    GFrame  yieldFrame (int output = 0);
+
+    template<class T> GArray<T> yieldArray(int output = 0)
+    {
+        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;
+
+    // GKernel and params can be modified, it's needed for infer<Generic>,
+    // because information about output shapes doesn't exist in compile time
+    GKernel& kernel();
+    cv::util::any& params();
+
+    void setArgs(std::vector<GArg> &&args);
+
+protected:
+    std::shared_ptr<Priv> m_priv;
+
+    // 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
+
+#endif // OPENCV_GAPI_GCALL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gcommon.hpp

@@ -0,0 +1,287 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GCOMMON_HPP
+#define OPENCV_GAPI_GCOMMON_HPP
+
+#include <functional>   // std::hash
+#include <vector>       // std::vector
+#include <type_traits>  // decay
+
+#include <opencv2/gapi/opencv_includes.hpp>
+
+#include <opencv2/gapi/util/any.hpp>
+#include <opencv2/gapi/util/optional.hpp>
+#include <opencv2/gapi/own/exports.hpp>
+#include <opencv2/gapi/own/assert.hpp>
+#include <opencv2/gapi/render/render_types.hpp>
+#include <opencv2/gapi/s11n/base.hpp>
+
+namespace cv {
+
+class GMat; // FIXME: forward declaration for GOpaqueTraits
+
+namespace detail
+{
+    // This is a trait-like structure to mark backend-specific compile arguments
+    // with tags
+    template<typename T> struct CompileArgTag;
+
+    // These structures are tags which separate kernels and transformations
+    struct KernelTag
+    {};
+    struct TransformTag
+    {};
+
+    // This enum is utilized mostly by GArray and GOpaque to store and recognize their internal data
+    // types (aka Host type). Also it is widely used during serialization routine.
+    enum class OpaqueKind: int
+    {
+        CV_UNKNOWN,    // Unknown, generic, opaque-to-GAPI data type unsupported in graph seriallization
+        CV_BOOL,       // bool user G-API data
+        CV_INT,        // int user G-API data
+        CV_INT64,      // int64_t user G-API data
+        CV_DOUBLE,     // double user G-API data
+        CV_FLOAT,      // float user G-API data
+        CV_UINT64,     // uint64_t user G-API data
+        CV_STRING,     // std::string user G-API data
+        CV_POINT,      // cv::Point user G-API data
+        CV_POINT2F,    // cv::Point2f user G-API data
+        CV_SIZE,       // cv::Size user G-API data
+        CV_RECT,       // cv::Rect user G-API data
+        CV_SCALAR,     // cv::Scalar user G-API data
+        CV_MAT,        // cv::Mat user G-API data
+        CV_DRAW_PRIM,  // cv::gapi::wip::draw::Prim user G-API data
+    };
+
+    // Type traits helper which simplifies the extraction of kind from type
+    template<typename T> struct GOpaqueTraits;
+    template<typename T> struct GOpaqueTraits    { static constexpr const OpaqueKind kind = OpaqueKind::CV_UNKNOWN; };
+    template<> struct GOpaqueTraits<int>         { static constexpr const OpaqueKind kind = OpaqueKind::CV_INT; };
+    template<> struct GOpaqueTraits<int64_t>     { static constexpr const OpaqueKind kind = OpaqueKind::CV_INT64; };
+    template<> struct GOpaqueTraits<double>      { static constexpr const OpaqueKind kind = OpaqueKind::CV_DOUBLE; };
+    template<> struct GOpaqueTraits<float>       { static constexpr const OpaqueKind kind = OpaqueKind::CV_FLOAT; };
+    template<> struct GOpaqueTraits<uint64_t>    { static constexpr const OpaqueKind kind = OpaqueKind::CV_UINT64; };
+    template<> struct GOpaqueTraits<bool>        { static constexpr const OpaqueKind kind = OpaqueKind::CV_BOOL; };
+    template<> struct GOpaqueTraits<std::string> { static constexpr const OpaqueKind kind = OpaqueKind::CV_STRING; };
+    template<> struct GOpaqueTraits<cv::Size>    { static constexpr const OpaqueKind kind = OpaqueKind::CV_SIZE; };
+    template<> struct GOpaqueTraits<cv::Scalar>  { static constexpr const OpaqueKind kind = OpaqueKind::CV_SCALAR; };
+    template<> struct GOpaqueTraits<cv::Point>   { static constexpr const OpaqueKind kind = OpaqueKind::CV_POINT; };
+    template<> struct GOpaqueTraits<cv::Point2f> { static constexpr const OpaqueKind kind = OpaqueKind::CV_POINT2F; };
+    template<> struct GOpaqueTraits<cv::Mat>     { static constexpr const OpaqueKind kind = OpaqueKind::CV_MAT; };
+    template<> struct GOpaqueTraits<cv::Rect>    { static constexpr const OpaqueKind kind = OpaqueKind::CV_RECT; };
+    template<> struct GOpaqueTraits<cv::GMat>    { static constexpr const OpaqueKind kind = OpaqueKind::CV_MAT; };
+    template<> struct GOpaqueTraits<cv::gapi::wip::draw::Prim>
+                                                 { static constexpr const OpaqueKind kind = OpaqueKind::CV_DRAW_PRIM; };
+    using GOpaqueTraitsArrayTypes = std::tuple<int, double, float, uint64_t, bool, std::string, cv::Size, cv::Scalar, cv::Point, cv::Point2f,
+                                               cv::Mat, cv::Rect, cv::gapi::wip::draw::Prim>;
+    // GOpaque is not supporting cv::Mat and cv::Scalar since there are GScalar and GMat types
+    using GOpaqueTraitsOpaqueTypes = std::tuple<int, double, float, uint64_t, bool, std::string, cv::Size, cv::Point, cv::Point2f, cv::Rect,
+                                                cv::gapi::wip::draw::Prim>;
+} // namespace detail
+
+// This definition is here because it is reused by both public(?) and internal
+// modules. Keeping it here wouldn't expose public details (e.g., API-level)
+// to components which are internal and operate on a lower-level entities
+// (e.g., compiler, backends).
+// FIXME: merge with ArgKind?
+// FIXME: replace with variant[format desc]?
+enum class GShape: int
+{
+    GMAT,
+    GSCALAR,
+    GARRAY,
+    GOPAQUE,
+    GFRAME,
+};
+
+namespace gapi {
+namespace s11n {
+namespace detail {
+template<typename T> struct wrap_serialize;
+} // namespace detail
+} // namespace s11n
+} // namespace gapi
+
+
+struct GCompileArg;
+
+namespace detail {
+    template<typename T>
+    using is_compile_arg = std::is_same<GCompileArg, typename std::decay<T>::type>;
+} // namespace detail
+
+// CompileArg is an unified interface over backend-specific compilation
+// information
+// FIXME: Move to a separate file?
+/** \addtogroup gapi_compile_args
+ * @{
+ *
+ * @brief Compilation arguments: data structures controlling the
+ * compilation process
+ *
+ * G-API comes with a number of graph compilation options which can be
+ * passed to cv::GComputation::apply() or
+ * cv::GComputation::compile(). Known compilation options are listed
+ * in this page, while extra backends may introduce their own
+ * compilation options (G-API transparently accepts _everything_ which
+ * can be passed to cv::compile_args(), it depends on underlying
+ * backends if an option would be interpreted or not).
+ *
+ * For example, if an example computation is executed like this:
+ *
+ * @snippet modules/gapi/samples/api_ref_snippets.cpp graph_decl_apply
+ *
+ * Extra parameter specifying which kernels to compile with can be
+ * passed like this:
+ *
+ * @snippet modules/gapi/samples/api_ref_snippets.cpp apply_with_param
+ */
+
+/**
+ * @brief Represents an arbitrary compilation argument.
+ *
+ * Any value can be wrapped into cv::GCompileArg, but only known ones
+ * (to G-API or its backends) can be interpreted correctly.
+ *
+ * Normally objects of this class shouldn't be created manually, use
+ * cv::compile_args() function which automatically wraps everything
+ * passed in (a variadic template parameter pack) into a vector of
+ * cv::GCompileArg objects.
+ */
+struct GCompileArg
+{
+public:
+    // NB: Required for pythnon bindings
+    GCompileArg() = default;
+
+    std::string tag;
+
+    // FIXME: use decay in GArg/other trait-based wrapper before leg is shot!
+    template<typename T, typename std::enable_if<!detail::is_compile_arg<T>::value, int>::type = 0>
+    explicit GCompileArg(T &&t)
+        : tag(detail::CompileArgTag<typename std::decay<T>::type>::tag())
+        , serializeF(cv::gapi::s11n::detail::has_S11N_spec<T>::value ?
+                     &cv::gapi::s11n::detail::wrap_serialize<T>::serialize :
+                     nullptr)
+        , arg(t)
+    {
+    }
+
+    template<typename T> T& get()
+    {
+        return util::any_cast<T>(arg);
+    }
+
+    template<typename T> const T& get() const
+    {
+        return util::any_cast<T>(arg);
+    }
+
+    void serialize(cv::gapi::s11n::IOStream& os) const
+    {
+        if (serializeF)
+        {
+            serializeF(os, *this);
+        }
+    }
+
+private:
+    std::function<void(cv::gapi::s11n::IOStream&, const GCompileArg&)> serializeF;
+    util::any arg;
+};
+
+using GCompileArgs = std::vector<GCompileArg>;
+
+inline cv::GCompileArgs& operator += (      cv::GCompileArgs &lhs,
+                                      const cv::GCompileArgs &rhs)
+{
+    lhs.reserve(lhs.size() + rhs.size());
+    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
+    return lhs;
+}
+
+/**
+ * @brief Wraps a list of arguments (a parameter pack) into a vector of
+ *        compilation arguments (cv::GCompileArg).
+ */
+template<typename... Ts> GCompileArgs compile_args(Ts&&... args)
+{
+    return GCompileArgs{ GCompileArg(args)... };
+}
+
+namespace gapi
+{
+/**
+ * @brief Retrieves particular compilation argument by its type from
+ *        cv::GCompileArgs
+ */
+template<typename T>
+inline cv::util::optional<T> getCompileArg(const cv::GCompileArgs &args)
+{
+    for (auto &compile_arg : args)
+    {
+        if (compile_arg.tag == cv::detail::CompileArgTag<T>::tag())
+        {
+            return cv::util::optional<T>(compile_arg.get<T>());
+        }
+    }
+    return cv::util::optional<T>();
+}
+
+namespace s11n {
+namespace detail {
+template<typename T> struct wrap_serialize
+{
+    static void serialize(IOStream& os, const GCompileArg& arg)
+    {
+        using DT = typename std::decay<T>::type;
+        S11N<DT>::serialize(os, arg.get<DT>());
+    }
+};
+} // namespace detail
+} // namespace s11n
+} // namespace gapi
+
+/**
+ * @brief Ask G-API to dump compiled graph in Graphviz format under
+ * the given file name.
+ *
+ * Specifies a graph dump path (path to .dot file to be generated).
+ * G-API will dump a .dot file under specified path during a
+ * compilation process if this flag is passed.
+ */
+struct graph_dump_path
+{
+    std::string m_dump_path;
+};
+/** @} */
+
+namespace detail
+{
+    template<> struct CompileArgTag<cv::graph_dump_path>
+    {
+        static const char* tag() { return "gapi.graph_dump_path"; }
+    };
+}
+
+} // namespace cv
+
+// std::hash overload for GShape
+namespace std
+{
+template<> struct hash<cv::GShape>
+{
+    size_t operator() (cv::GShape sh) const
+    {
+        return std::hash<int>()(static_cast<int>(sh));
+    }
+};
+} // namespace std
+
+
+#endif // OPENCV_GAPI_GCOMMON_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gcompiled.hpp

@@ -0,0 +1,232 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GCOMPILED_HPP
+#define OPENCV_GAPI_GCOMPILED_HPP
+
+#include <vector>
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/own/assert.hpp>
+#include <opencv2/gapi/garg.hpp>
+
+namespace cv {
+
+// This class represents a compiled computation.
+// In theory (and ideally), it can be used w/o the rest of APIs.
+// In theory (and ideally), it can be serialized/deserialized.
+// It can enable scenarious like deployment to an autonomous devince, FuSa, etc.
+//
+// Currently GCompiled assumes all GMats you used to pass data to G-API
+// are valid and not destroyed while you use a GCompiled object.
+//
+// FIXME: In future, there should be a way to name I/O objects and specify it
+// to GCompiled externally (for example, when it is loaded on the target system).
+
+/**
+ * \addtogroup gapi_main_classes
+ * @{
+ */
+/**
+ * @brief Represents a compiled computation (graph). Can only be used
+ * with image / data formats & resolutions it was compiled for, with
+ * some exceptions.
+ *
+ * This class represents a product of graph compilation (calling
+ * cv::GComputation::compile()). Objects of this class actually do
+ * data processing, and graph execution is incapsulated into objects
+ * of this class. Execution model itself depends on kernels and
+ * backends which were using during the compilation, see @ref
+ * gapi_compile_args for details.
+ *
+ * In a general case, GCompiled objects can be applied to data only in
+ * that formats/resolutions they were compiled for (see @ref
+ * gapi_meta_args). However, if the underlying backends allow, a
+ * compiled object can be _reshaped_ to handle data (images) of
+ * different resolution, though formats and types must remain the same.
+ *
+ * GCompiled is very similar to `std::function<>` in its semantics --
+ * running it looks like a function call in the user code.
+ *
+ * At the moment, GCompiled objects are not reentrant -- generally,
+ * the objects are stateful since graph execution itself is a stateful
+ * process and this state is now maintained in GCompiled's own memory
+ * (not on the process stack).
+ *
+ * At the same time, two different GCompiled objects produced from the
+ * single cv::GComputation are completely independent and can be used
+ * concurrently.
+ *
+ * @sa GStreamingCompiled
+ */
+class GAPI_EXPORTS GCompiled
+{
+public:
+    /// @private
+    class GAPI_EXPORTS Priv;
+
+    /**
+     * @brief Constructs an empty object
+     */
+    GCompiled();
+
+    /**
+     * @brief Run the compiled computation, a generic version.
+     *
+     * @param ins vector of inputs to process.
+     * @param outs vector of outputs to produce.
+     *
+     * Input/output vectors must have the same number of elements as
+     * defined in the cv::GComputation protocol (at the moment of its
+     * construction). Shapes of elements also must conform to protocol
+     * (e.g. cv::Mat needs to be passed where cv::GMat has been
+     * declared as input, and so on). Run-time exception is generated
+     * otherwise.
+     *
+     * Objects in output vector may remain empty (like cv::Mat) --
+     * G-API will automatically initialize output objects to proper formats.
+     *
+     * @note Don't construct GRunArgs/GRunArgsP objects manually, use
+     * cv::gin()/cv::gout() wrappers instead.
+     */
+    void operator() (GRunArgs &&ins, GRunArgsP &&outs);          // Generic arg-to-arg
+#if !defined(GAPI_STANDALONE)
+
+    /**
+     * @brief Execute an unary computation
+     *
+     * @overload
+     * @param in input cv::Mat for unary computation
+     * @param out output cv::Mat for unary computation
+     * process.
+     */
+    void operator() (cv::Mat in, cv::Mat &out);                  // Unary overload
+
+    /**
+     * @brief Execute an unary computation
+     *
+     * @overload
+     * @param in input cv::Mat for unary computation
+     * @param out output cv::Scalar for unary computation
+     * process.
+     */
+    void operator() (cv::Mat in, cv::Scalar &out);               // Unary overload (scalar)
+
+    /**
+     * @brief Execute a binary computation
+     *
+     * @overload
+     * @param in1 first input cv::Mat for binary computation
+     * @param in2 second input cv::Mat for binary computation
+     * @param out output cv::Mat for binary computation
+     * process.
+     */
+    void operator() (cv::Mat in1, cv::Mat in2, cv::Mat &out);    // Binary overload
+
+    /**
+     * @brief Execute an binary computation
+     *
+     * @overload
+     * @param in1 first input cv::Mat for binary computation
+     * @param in2 second input cv::Mat for binary computation
+     * @param out output cv::Scalar for binary computation
+     * process.
+     */
+    void operator() (cv::Mat in1, cv::Mat in2, cv::Scalar &out); // Binary overload (scalar)
+
+    /**
+     * @brief Execute a computation with arbitrary number of
+     * inputs/outputs.
+     *
+     * @overload
+     * @param ins vector of input cv::Mat objects to process by the
+     * computation.
+     * @param outs vector of output cv::Mat objects to produce by the
+     * computation.
+     *
+     * Numbers of elements in ins/outs vectors must match numbers of
+     * inputs/outputs which were used to define the source GComputation.
+     */
+    void operator() (const std::vector<cv::Mat> &ins,            // Compatibility overload
+                     const std::vector<cv::Mat> &outs);
+#endif  // !defined(GAPI_STANDALONE)
+    /// @private
+    Priv& priv();
+
+    /**
+     * @brief Check if compiled object is valid (non-empty)
+     *
+     * @return true if the object is runnable (valid), false otherwise
+     */
+    explicit operator bool () const;
+
+    /**
+     * @brief Vector of metadata this graph was compiled for.
+     *
+     * @return Unless _reshape_ is not supported, return value is the
+     * same vector which was passed to cv::GComputation::compile() to
+     * produce this compiled object. Otherwise, it is the latest
+     * metadata vector passed to reshape() (if that call was
+     * successful).
+     */
+    const GMetaArgs& metas() const; // Meta passed to compile()
+
+    /**
+     * @brief Vector of metadata descriptions of graph outputs
+     *
+     * @return vector with formats/resolutions of graph's output
+     * objects, auto-inferred from input metadata vector by
+     * operations which form this computation.
+     *
+     * @note GCompiled objects produced from the same
+     * cv::GComputiation graph with different input metas may return
+     * different values in this vector.
+     */
+    const GMetaArgs& outMetas() const;
+
+    /**
+     * @brief Check if the underlying backends support reshape or not.
+     *
+     * @return true if supported, false otherwise.
+     */
+    bool canReshape() const;
+
+    /**
+     * @brief Reshape a compiled graph to support new image
+     * resolutions.
+     *
+     * Throws an exception if an error occurs.
+     *
+     * @param inMetas new metadata to reshape on. Vector size and
+     * metadata shapes must match the computation's protocol.
+     * @param args compilation arguments to use.
+     */
+    // FIXME: Why it requires compile args?
+    void reshape(const GMetaArgs& inMetas, const GCompileArgs& args);
+
+    /**
+     * @brief Prepare inner kernels states for a new video-stream.
+     *
+     * GCompiled objects may be used to process video streams frame by frame.
+     * In this case, a GCompiled is called on every image frame individually.
+     * Starting OpenCV 4.4, some kernels in the graph may have their internal
+     * states (see GAPI_OCV_KERNEL_ST for the OpenCV backend).
+     * In this case, if user starts processing another video stream with
+     * this GCompiled, this method needs to be called to let kernels re-initialize
+     * their internal states to a new video stream.
+     */
+    void prepareForNewStream();
+
+protected:
+    /// @private
+    std::shared_ptr<Priv> m_priv;
+};
+/** @} */
+
+}
+
+#endif // OPENCV_GAPI_GCOMPILED_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gcompiled_async.hpp

@@ -0,0 +1,73 @@
+// 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_GCOMPILED_ASYNC_HPP
+#define OPENCV_GAPI_GCOMPILED_ASYNC_HPP
+
+#include <future>           //for std::future
+#include <exception>        //for std::exception_ptr
+#include <functional>       //for std::function
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/own/exports.hpp>
+
+namespace cv {
+    //fwd declaration
+    class GCompiled;
+
+namespace gapi{
+namespace wip {
+    class GAsyncContext;
+    /**
+    These functions asynchronously (i.e. probably on a separate thread of execution) call GCompiled::operator() member function of their first argument with copies of rest of arguments (except callback) passed in.
+    The difference between the function is the way to get the completion notification (via callback or a waiting on std::future object)
+    If exception is occurred during execution of apply it is transferred to the callback (via function parameter) or passed to future (and will be thrown on call to std::future::get)
+
+    N.B. :
+    Input arguments are copied on call to async function (actually on call to cv::gin) and thus do not have to outlive the actual completion of asynchronous activity.
+    While output arguments are "captured" by reference(pointer) and therefore _must_ outlive the asynchronous activity
+    (i.e. live at least until callback is called or future is unblocked)
+
+    @param gcmpld       Compiled computation (graph) to start asynchronously
+    @param callback     Callback to be called when execution of gcmpld is done
+    @param ins          Input parameters for gcmpld
+    @param outs         Output parameters for gcmpld
+    */
+    GAPI_EXPORTS void                async(GCompiled& gcmpld, std::function<void(std::exception_ptr)>&& callback, GRunArgs &&ins, GRunArgsP &&outs);
+
+    /** @overload
+    @param gcmpld       Compiled computation (graph) to run asynchronously
+    @param callback     Callback to be called when execution of gcmpld is done
+    @param ins          Input parameters for gcmpld
+    @param outs         Output parameters for gcmpld
+    @param ctx          Context this request belongs to
+    @see   async GAsyncContext
+    */
+    GAPI_EXPORTS void                async(GCompiled& gcmpld, std::function<void(std::exception_ptr)>&& callback, GRunArgs &&ins, GRunArgsP &&outs, GAsyncContext& ctx);
+
+    /** @overload
+    @param gcmpld       Compiled computation (graph) to run asynchronously
+    @param ins          Input parameters for gcmpld
+    @param outs         Output parameters for gcmpld
+    @return             std::future<void> object to wait for completion of async operation
+    @see async
+    */
+    GAPI_EXPORTS std::future<void>   async(GCompiled& gcmpld, GRunArgs &&ins, GRunArgsP &&outs);
+
+    /**
+    @param gcmpld       Compiled computation (graph) to run asynchronously
+    @param ins          Input parameters for gcmpld
+    @param outs         Output parameters for gcmpld
+    @param ctx          Context this request belongs to
+    @return             std::future<void> object to wait for completion of async operation
+    @see   async GAsyncContext
+    */
+    GAPI_EXPORTS std::future<void>   async(GCompiled& gcmpld, GRunArgs &&ins, GRunArgsP &&outs, GAsyncContext& ctx);
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_GCOMPILED_ASYNC_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gcompoundkernel.hpp

@@ -0,0 +1,139 @@
+// 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
+
+
+#ifndef OPENCV_GAPI_GCOMPOUNDKERNEL_HPP
+#define OPENCV_GAPI_GCOMPOUNDKERNEL_HPP
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/garg.hpp>
+
+namespace cv {
+namespace gapi
+{
+namespace compound
+{
+    // FIXME User does not need to know about this function
+    // Needs that user may define compound kernels(as cpu kernels)
+    GAPI_EXPORTS cv::gapi::GBackend backend();
+} // namespace compound
+} // namespace gapi
+
+namespace detail
+{
+
+struct GCompoundContext
+{
+    explicit GCompoundContext(const GArgs& in_args);
+    template<typename T>
+    const T& inArg(int input) { return m_args.at(input).get<T>(); }
+
+    GArgs m_args;
+    GArgs m_results;
+};
+
+class GAPI_EXPORTS GCompoundKernel
+{
+// Compound kernel must use all of it's inputs
+public:
+    using F = std::function<void(GCompoundContext& ctx)>;
+
+    explicit GCompoundKernel(const F& f);
+    void apply(GCompoundContext& ctx);
+
+protected:
+    F m_f;
+};
+
+template<typename T> struct get_compound_in
+{
+    static T get(GCompoundContext &ctx, int idx) { return ctx.inArg<T>(idx); }
+};
+
+template<typename U> struct get_compound_in<cv::GArray<U>>
+{
+    static cv::GArray<U> get(GCompoundContext &ctx, int idx)
+    {
+        auto array = cv::GArray<U>();
+        ctx.m_args[idx] = GArg(array);
+        return array;
+    }
+};
+
+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<> struct get_compound_in<cv::GMatP>
+{
+    static cv::GMatP get(GCompoundContext &ctx, int idx)
+    {
+        auto mat = cv::GMatP();
+        ctx.m_args[idx] = GArg(mat);
+        return mat;
+    }
+};
+
+template<typename, typename, typename>
+struct GCompoundCallHelper;
+
+template<typename Impl, typename... Ins, typename... Outs>
+struct GCompoundCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...> >
+{
+    template<int... IIs, int... OIs>
+    static void expand_impl(GCompoundContext &ctx, detail::Seq<IIs...>, detail::Seq<OIs...>)
+    {
+        auto result = Impl::expand(get_compound_in<Ins>::get(ctx, IIs)...);
+        auto tuple_return = tuple_wrap_helper<decltype(result)>::get(std::move(result));
+        ctx.m_results = { cv::GArg(std::get<OIs>(tuple_return))... };
+    }
+
+    static void expand(GCompoundContext &ctx)
+    {
+        expand_impl(ctx,
+                    typename detail::MkSeq<sizeof...(Ins)>::type(),
+                    typename detail::MkSeq<sizeof...(Outs)>::type());
+    }
+};
+
+template<class Impl, class K>
+class GCompoundKernelImpl: public cv::detail::GCompoundCallHelper<Impl, typename K::InArgs, typename K::OutArgs>,
+                           public cv::detail::KernelTag
+{
+    using P = cv::detail::GCompoundCallHelper<Impl, typename K::InArgs, typename K::OutArgs>;
+
+public:
+    using API = K;
+
+    static cv::gapi::GBackend backend() { return cv::gapi::compound::backend(); }
+    static GCompoundKernel    kernel()  { return GCompoundKernel(&P::expand);   }
+};
+
+} // namespace detail
+
+
+/**
+ * Declares a new compound kernel. See this
+ * [documentation chapter](@ref gapi_kernel_compound)
+ * on compound kernels for more details.
+ *
+ * @param Name type name for new kernel
+ * @param API the interface this kernel implements
+ */
+#define GAPI_COMPOUND_KERNEL(Name, API) \
+    struct Name: public cv::detail::GCompoundKernelImpl<Name, API>
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GCOMPOUNDKERNEL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gcomputation.hpp

@@ -0,0 +1,580 @@
+// 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_GCOMPUTATION_HPP
+#define OPENCV_GAPI_GCOMPUTATION_HPP
+
+#include <functional>
+
+#include <opencv2/gapi/util/util.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+#include <opencv2/gapi/gproto.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/gcompiled.hpp>
+#include <opencv2/gapi/gstreaming.hpp>
+
+namespace cv {
+
+namespace detail
+{
+    // FIXME: move to algorithm, cover with separate tests
+    // FIXME: replace with O(1) version (both memory and compilation time)
+    template<typename...>
+    struct last_type;
+
+    template<typename T>
+    struct last_type<T> { using type = T;};
+
+    template<typename T, typename... Ts>
+    struct last_type<T, Ts...> { using type = typename last_type<Ts...>::type; };
+
+    template<typename... Ts>
+    using last_type_t = typename last_type<Ts...>::type;
+}
+
+// Forward-declare the serialization objects
+namespace gapi {
+namespace s11n {
+    struct IIStream;
+    struct IOStream;
+} // namespace s11n
+} // namespace gapi
+
+/**
+ * \addtogroup gapi_main_classes
+ * @{
+ *
+ * @brief G-API classes for constructed and compiled graphs.
+ */
+/**
+ * @brief GComputation class represents a captured computation
+ * graph. GComputation objects form boundaries for expression code
+ * user writes with G-API, allowing to compile and execute it.
+ *
+ * G-API computations are defined with input/output data
+ * objects. G-API will track automatically which operations connect
+ * specified outputs to the inputs, forming up a call graph to be
+ * executed. The below example expresses calculation of Sobel operator
+ * for edge detection (\f$G = \sqrt{G_x^2 + G_y^2}\f$):
+ *
+ * @snippet modules/gapi/samples/api_ref_snippets.cpp graph_def
+ *
+ * Full pipeline can be now captured with this object declaration:
+ *
+ * @snippet modules/gapi/samples/api_ref_snippets.cpp graph_cap_full
+ *
+ * Input/output data objects on which a call graph should be
+ * reconstructed are passed using special wrappers cv::GIn and
+ * cv::GOut. G-API will track automatically which operations form a
+ * path from inputs to outputs and build the execution graph appropriately.
+ *
+ * Note that cv::GComputation doesn't take ownership on data objects
+ * it is defined. Moreover, multiple GComputation objects may be
+ * defined on the same expressions, e.g. a smaller pipeline which
+ * expects that image gradients are already pre-calculated may be
+ * defined like this:
+ *
+ * @snippet modules/gapi/samples/api_ref_snippets.cpp graph_cap_sub
+ *
+ * The resulting graph would expect two inputs and produce one
+ * output. In this case, it doesn't matter if gx/gy data objects are
+ * results of cv::gapi::Sobel operators -- G-API will stop unrolling
+ * expressions and building the underlying graph one reaching this
+ * data objects.
+ *
+ * The way how GComputation is defined is important as its definition
+ * specifies graph _protocol_ -- the way how the graph should be
+ * used. Protocol is defined by number of inputs, number of outputs,
+ * and shapes of inputs and outputs.
+ *
+ * In the above example, sobelEdge expects one Mat on input and
+ * produces one Mat; while sobelEdgeSub expects two Mats on input and
+ * produces one Mat. GComputation's protocol defines how other
+ * computation methods should be used -- cv::GComputation::compile() and
+ * cv::GComputation::apply(). For example, if a graph is defined on
+ * two GMat inputs, two cv::Mat objects have to be passed to apply()
+ * for execution. GComputation checks protocol correctness in runtime
+ * so passing a different number of objects in apply() or passing
+ * cv::Scalar instead of cv::Mat there would compile well as a C++
+ * source but raise an exception in run-time. G-API also comes with a
+ * typed wrapper cv::GComputationT<> which introduces this type-checking in
+ * compile-time.
+ *
+ * cv::GComputation itself is a thin object which just captures what
+ * the graph is. The compiled graph (which actually process data) is
+ * represented by class GCompiled. Use compile() method to generate a
+ * compiled graph with given compile options. cv::GComputation can
+ * also be used to process data with implicit graph compilation
+ * on-the-fly, see apply() for details.
+ *
+ * GComputation is a reference-counted object -- once defined, all its
+ * copies will refer to the same instance.
+ *
+ * @sa GCompiled
+ */
+class GAPI_EXPORTS_W GComputation
+{
+public:
+    class Priv;
+    typedef std::function<GComputation()> Generator;
+
+    // Various constructors enable different ways to define a computation: /////
+    // 1. Generic constructors
+    /**
+     * @brief Define a computation using a generator function.
+     *
+     * Graph can be defined in-place directly at the moment of its
+     * construction with a lambda:
+     *
+     * @snippet modules/gapi/samples/api_ref_snippets.cpp graph_gen
+     *
+     * This may be useful since all temporary objects (cv::GMats) and
+     * namespaces can be localized to scope of lambda, without
+     * contaminating the parent scope with probably unnecessary objects
+     * and information.
+     *
+     * @param gen generator function which returns a cv::GComputation,
+     * see Generator.
+     */
+    GComputation(const Generator& gen);                // Generator
+                                                       // overload
+
+    /**
+     * @brief Generic GComputation constructor.
+     *
+     * Constructs a new graph with a given protocol, specified as a
+     * flow of operations connecting input/output objects. Throws if
+     * the passed boundaries are invalid, e.g. if there's no
+     * functional dependency (path) between given outputs and inputs.
+     *
+     * @param ins Input data vector.
+     * @param outs Output data vector.
+     *
+     * @note Don't construct GProtoInputArgs/GProtoOutputArgs objects
+     * directly, use cv::GIn()/cv::GOut() wrapper functions instead.
+     *
+     * @sa @ref gapi_data_objects
+     */
+    GAPI_WRAP GComputation(GProtoInputArgs &&ins,
+                           GProtoOutputArgs &&outs);             // Arg-to-arg overload
+
+    // 2. Syntax sugar and compatibility overloads
+    /**
+     * @brief Defines an unary (one input -- one output) computation
+     *
+     * @overload
+     * @param in input GMat of the defined unary computation
+     * @param out output GMat of the defined unary computation
+     */
+    GAPI_WRAP GComputation(GMat in, GMat out);  // Unary overload
+
+    /**
+     * @brief Defines an unary (one input -- one output) computation
+     *
+     * @overload
+     * @param in input GMat of the defined unary computation
+     * @param out output GScalar of the defined unary computation
+     */
+    GAPI_WRAP GComputation(GMat in, GScalar out);      // Unary overload (scalar)
+
+    /**
+     * @brief Defines a binary (two inputs -- one output) computation
+     *
+     * @overload
+     * @param in1 first input GMat of the defined binary computation
+     * @param in2 second input GMat of the defined binary computation
+     * @param out output GMat of the defined binary computation
+     */
+    GAPI_WRAP GComputation(GMat in1, GMat in2, GMat out);        // Binary overload
+
+    /**
+     * @brief Defines a binary (two inputs -- one output) computation
+     *
+     * @overload
+     * @param in1 first input GMat of the defined binary computation
+     * @param in2 second input GMat of the defined binary computation
+     * @param out output GScalar of the defined binary computation
+     */
+    GComputation(GMat in1, GMat in2, GScalar out);     // Binary
+                                                       // overload
+                                                       // (scalar)
+
+    /**
+     * @brief Defines a computation with arbitrary input/output number.
+     *
+     * @overload
+     * @param ins vector of inputs GMats for this computation
+     * @param outs vector of outputs GMats for this computation
+     *
+     * Use this overload for cases when number of computation
+     * inputs/outputs is not known in compile-time -- e.g. when graph
+     * is programmatically generated to build an image pyramid with
+     * the given number of levels, etc.
+     */
+    GComputation(const std::vector<GMat> &ins,         // Compatibility overload
+                 const std::vector<GMat> &outs);
+
+    // Various versions of apply(): ////////////////////////////////////////////
+    // 1. Generic apply()
+    /**
+     * @brief Compile graph on-the-fly and immediately execute it on
+     * the inputs data vectors.
+     *
+     * Number of input/output data objects must match GComputation's
+     * protocol, also types of host data objects (cv::Mat, cv::Scalar)
+     * must match the shapes of data objects from protocol (cv::GMat,
+     * cv::GScalar). If there's a mismatch, a run-time exception will
+     * be generated.
+     *
+     * Internally, a cv::GCompiled object is created for the given
+     * input format configuration, which then is executed on the input
+     * data immediately. cv::GComputation caches compiled objects
+     * produced within apply() -- if this method would be called next
+     * time with the same input parameters (image formats, image
+     * resolution, etc), the underlying compiled graph will be reused
+     * without recompilation. If new metadata doesn't match the cached
+     * one, the underlying compiled graph is regenerated.
+     *
+     * @note compile() always triggers a compilation process and
+     * produces a new GCompiled object regardless if a similar one has
+     * been cached via apply() or not.
+     *
+     * @param ins vector of input data to process. Don't create
+     * GRunArgs object manually, use cv::gin() wrapper instead.
+     * @param outs vector of output data to fill results in. cv::Mat
+     * objects may be empty in this vector, G-API will automatically
+     * initialize it with the required format & dimensions. Don't
+     * create GRunArgsP object manually, use cv::gout() wrapper instead.
+     * @param args a list of compilation arguments to pass to the
+     * underlying compilation process. Don't create GCompileArgs
+     * object manually, use cv::compile_args() wrapper instead.
+     *
+     * @sa @ref gapi_data_objects, @ref gapi_compile_args
+     */
+    void apply(GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args = {});       // Arg-to-arg overload
+
+    /// @private -- Exclude this function from OpenCV documentation
+    GAPI_WRAP GRunArgs apply(const cv::detail::ExtractArgsCallback  &callback,
+                                   GCompileArgs                    &&args = {});
+
+    /// @private -- Exclude this function from OpenCV documentation
+    void apply(const std::vector<cv::Mat>& ins,                                   // Compatibility overload
+               const std::vector<cv::Mat>& outs,
+               GCompileArgs &&args = {});
+
+    // 2. Syntax sugar and compatibility overloads
+#if !defined(GAPI_STANDALONE)
+    /**
+     * @brief Execute an unary computation (with compilation on the fly)
+     *
+     * @overload
+     * @param in input cv::Mat for unary computation
+     * @param out output cv::Mat for unary computation
+     * @param args compilation arguments for underlying compilation
+     * process.
+     */
+    void apply(cv::Mat in, cv::Mat &out, GCompileArgs &&args = {}); // Unary overload
+
+    /**
+     * @brief Execute an unary computation (with compilation on the fly)
+     *
+     * @overload
+     * @param in input cv::Mat for unary computation
+     * @param out output cv::Scalar for unary computation
+     * @param args compilation arguments for underlying compilation
+     * process.
+     */
+    void apply(cv::Mat in, cv::Scalar &out, GCompileArgs &&args = {}); // Unary overload (scalar)
+
+    /**
+     * @brief Execute a binary computation (with compilation on the fly)
+     *
+     * @overload
+     * @param in1 first input cv::Mat for binary computation
+     * @param in2 second input cv::Mat for binary computation
+     * @param out output cv::Mat for binary computation
+     * @param args compilation arguments for underlying compilation
+     * process.
+     */
+    void apply(cv::Mat in1, cv::Mat in2, cv::Mat &out, GCompileArgs &&args = {}); // Binary overload
+
+    /**
+     * @brief Execute an binary computation (with compilation on the fly)
+     *
+     * @overload
+     * @param in1 first input cv::Mat for binary computation
+     * @param in2 second input cv::Mat for binary computation
+     * @param out output cv::Scalar for binary computation
+     * @param args compilation arguments for underlying compilation
+     * process.
+     */
+    void apply(cv::Mat in1, cv::Mat in2, cv::Scalar &out, GCompileArgs &&args = {}); // Binary overload (scalar)
+
+    /**
+     * @brief Execute a computation with arbitrary number of
+     * inputs/outputs (with compilation on-the-fly).
+     *
+     * @overload
+     * @param ins vector of input cv::Mat objects to process by the
+     * computation.
+     * @param outs vector of output cv::Mat objects to produce by the
+     * computation.
+     * @param args compilation arguments for underlying compilation
+     * process.
+     *
+     * Numbers of elements in ins/outs vectors must match numbers of
+     * inputs/outputs which were used to define this GComputation.
+     */
+    void apply(const std::vector<cv::Mat>& ins,         // Compatibility overload
+                     std::vector<cv::Mat>& outs,
+               GCompileArgs &&args = {});
+#endif // !defined(GAPI_STANDALONE)
+    // Various versions of compile(): //////////////////////////////////////////
+    // 1. Generic compile() - requires metas to be passed as vector
+    /**
+     * @brief Compile the computation for specific input format(s).
+     *
+     * This method triggers compilation process and produces a new
+     * GCompiled object which then can process data of the given
+     * format. Passing data with different format to the compiled
+     * computation will generate a run-time exception.
+     *
+     * @param in_metas vector of input metadata configuration. Grab
+     * metadata from real data objects (like cv::Mat or cv::Scalar)
+     * using cv::descr_of(), or create it on your own.
+     * @param args compilation arguments for this compilation
+     * process. Compilation arguments directly affect what kind of
+     * executable object would be produced, e.g. which kernels (and
+     * thus, devices) would be used to execute computation.
+     *
+     * @return GCompiled, an executable computation compiled
+     * specifically for the given input parameters.
+     *
+     * @sa @ref gapi_compile_args
+     */
+    GCompiled compile(GMetaArgs &&in_metas, GCompileArgs &&args = {});
+
+    // 2. Syntax sugar - variadic list of metas, no extra compile args
+    // FIXME: SFINAE looks ugly in the generated documentation
+    /**
+     * @overload
+     *
+     * Takes a variadic parameter pack with metadata
+     * descriptors for which a compiled object needs to be produced.
+     *
+     * @return GCompiled, an executable computation compiled
+     * specifically for the given input parameters.
+     */
+    template<typename... Ts>
+    auto compile(const Ts&... metas) ->
+        typename std::enable_if<detail::are_meta_descrs<Ts...>::value, GCompiled>::type
+    {
+        return compile(GMetaArgs{GMetaArg(metas)...}, GCompileArgs());
+    }
+
+    // 3. Syntax sugar - variadic list of metas, extra compile args
+    // (seems optional parameters don't work well when there's an variadic template
+    // comes first)
+    //
+    // Ideally it should look like:
+    //
+    //     template<typename... Ts>
+    //     GCompiled compile(const Ts&... metas, GCompileArgs &&args)
+    //
+    // But not all compilers can handle this (and seems they shouldn't be able to).
+    // FIXME: SFINAE looks ugly in the generated documentation
+    /**
+     * @overload
+     *
+     * Takes a  variadic parameter pack with metadata
+     * descriptors for which a compiled object needs to be produced,
+     * followed by GCompileArgs object representing compilation
+     * arguments for this process.
+     *
+     * @return GCompiled, an executable computation compiled
+     * specifically for the given input parameters.
+     */
+    template<typename... Ts>
+    auto compile(const Ts&... meta_and_compile_args) ->
+        typename std::enable_if<detail::are_meta_descrs_but_last<Ts...>::value
+                                && std::is_same<GCompileArgs, detail::last_type_t<Ts...> >::value,
+                                GCompiled>::type
+    {
+        //FIXME: wrapping meta_and_compile_args into a tuple to unwrap them inside a helper function is the overkill
+        return compile(std::make_tuple(meta_and_compile_args...),
+                       typename detail::MkSeq<sizeof...(Ts)-1>::type());
+    }
+
+
+    // FIXME: Document properly in the Doxygen format
+    // Video-oriented pipeline compilation:
+    // 1. A generic version
+    /**
+     * @brief Compile the computation for streaming mode.
+     *
+     * This method triggers compilation process and produces a new
+     * GStreamingCompiled object which then can process video stream
+     * data of the given format. Passing a stream in a different
+     * format to the compiled computation will generate a run-time
+     * exception.
+     *
+     * @param in_metas vector of input metadata configuration. Grab
+     * metadata from real data objects (like cv::Mat or cv::Scalar)
+     * using cv::descr_of(), or create it on your own.
+     *
+     * @param args compilation arguments for this compilation
+     * process. Compilation arguments directly affect what kind of
+     * executable object would be produced, e.g. which kernels (and
+     * thus, devices) would be used to execute computation.
+     *
+     * @return GStreamingCompiled, a streaming-oriented executable
+     * computation compiled specifically for the given input
+     * parameters.
+     *
+     * @sa @ref gapi_compile_args
+     */
+    GAPI_WRAP GStreamingCompiled compileStreaming(GMetaArgs &&in_metas, GCompileArgs &&args = {});
+
+    /**
+     * @brief Compile the computation for streaming mode.
+     *
+     * This method triggers compilation process and produces a new
+     * GStreamingCompiled object which then can process video stream
+     * data in any format. Underlying mechanisms will be adjusted to
+     * every new input video stream automatically, but please note that
+     * _not all_ existing backends support this (see reshape()).
+     *
+     * @param args compilation arguments for this compilation
+     * process. Compilation arguments directly affect what kind of
+     * executable object would be produced, e.g. which kernels (and
+     * thus, devices) would be used to execute computation.
+     *
+     * @return GStreamingCompiled, a streaming-oriented executable
+     * computation compiled for any input image format.
+     *
+     * @sa @ref gapi_compile_args
+     */
+    GAPI_WRAP GStreamingCompiled compileStreaming(GCompileArgs &&args = {});
+
+    /// @private -- Exclude this function from OpenCV documentation
+    GAPI_WRAP GStreamingCompiled compileStreaming(const cv::detail::ExtractMetaCallback &callback,
+                                                        GCompileArgs                   &&args = {});
+
+    // 2. Direct metadata version
+    /**
+     * @overload
+     *
+     * Takes a variadic parameter pack with metadata
+     * descriptors for which a compiled object needs to be produced.
+     *
+     * @return GStreamingCompiled, a streaming-oriented executable
+     * computation compiled specifically for the given input
+     * parameters.
+     */
+    template<typename... Ts>
+    auto compileStreaming(const Ts&... metas) ->
+        typename std::enable_if<detail::are_meta_descrs<Ts...>::value, GStreamingCompiled>::type
+    {
+        return compileStreaming(GMetaArgs{GMetaArg(metas)...}, GCompileArgs());
+    }
+
+    // 2. Direct metadata + compile arguments version
+    /**
+     * @overload
+     *
+     * Takes a  variadic parameter pack with metadata
+     * descriptors for which a compiled object needs to be produced,
+     * followed by GCompileArgs object representing compilation
+     * arguments for this process.
+     *
+     * @return GStreamingCompiled, a streaming-oriented executable
+     * computation compiled specifically for the given input
+     * parameters.
+     */
+    template<typename... Ts>
+    auto compileStreaming(const Ts&... meta_and_compile_args) ->
+        typename std::enable_if<detail::are_meta_descrs_but_last<Ts...>::value
+                                && std::is_same<GCompileArgs, detail::last_type_t<Ts...> >::value,
+                                GStreamingCompiled>::type
+    {
+        //FIXME: wrapping meta_and_compile_args into a tuple to unwrap them inside a helper function is the overkill
+        return compileStreaming(std::make_tuple(meta_and_compile_args...),
+                                typename detail::MkSeq<sizeof...(Ts)-1>::type());
+    }
+
+    // Internal use only
+    /// @private
+    Priv& priv();
+    /// @private
+    const Priv& priv() const;
+    /// @private
+    explicit GComputation(cv::gapi::s11n::IIStream &);
+    /// @private
+    void serialize(cv::gapi::s11n::IOStream &) const;
+
+protected:
+
+    // 4. Helper methods for (3)
+    /// @private
+    template<typename... Ts, int... IIs>
+    GCompiled compile(const std::tuple<Ts...> &meta_and_compile_args, detail::Seq<IIs...>)
+    {
+        GMetaArgs meta_args = {GMetaArg(std::get<IIs>(meta_and_compile_args))...};
+        GCompileArgs comp_args = std::get<sizeof...(Ts)-1>(meta_and_compile_args);
+        return compile(std::move(meta_args), std::move(comp_args));
+    }
+    template<typename... Ts, int... IIs>
+    GStreamingCompiled compileStreaming(const std::tuple<Ts...> &meta_and_compile_args, detail::Seq<IIs...>)
+    {
+        GMetaArgs meta_args = {GMetaArg(std::get<IIs>(meta_and_compile_args))...};
+        GCompileArgs comp_args = std::get<sizeof...(Ts)-1>(meta_and_compile_args);
+        return compileStreaming(std::move(meta_args), std::move(comp_args));
+    }
+    void recompile(GMetaArgs&& in_metas, GCompileArgs &&args);
+    /// @private
+    std::shared_ptr<Priv> m_priv;
+};
+/** @} */
+
+namespace gapi
+{
+    // FIXME: all these standalone functions need to be added to some
+    // common documentation section
+    /**
+     * @brief Define an tagged island (subgraph) within a computation.
+     *
+     * Declare an Island tagged with `name` and defined from `ins` to `outs`
+     * (exclusively, as ins/outs are data objects, and regioning is done on
+     * operations level).
+     * Throws if any operation between `ins` and `outs` are already assigned
+     * to another island.
+     *
+     * Islands allow to partition graph into subgraphs, fine-tuning
+     * the way it is scheduled by the underlying executor.
+     *
+     * @param name name of the Island to create
+     * @param ins vector of input data objects where the subgraph
+     * begins
+     * @param outs vector of output data objects where the subgraph
+     * ends.
+     *
+     * The way how an island is defined is similar to how
+     * cv::GComputation is defined on input/output data objects.
+     * Same rules apply here as well -- if there's no functional
+     * dependency between inputs and outputs or there's not enough
+     * input data objects were specified to properly calculate all
+     * outputs, an exception is thrown.
+     *
+     * Use cv::GIn() / cv::GOut() to specify input/output vectors.
+     */
+    void GAPI_EXPORTS island(const std::string &name,
+                             GProtoInputArgs  &&ins,
+                             GProtoOutputArgs &&outs);
+} // namespace gapi
+
+} // namespace cv
+#endif // OPENCV_GAPI_GCOMPUTATION_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gcomputation_async.hpp

@@ -0,0 +1,69 @@
+// 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_GCOMPUTATION_ASYNC_HPP
+#define OPENCV_GAPI_GCOMPUTATION_ASYNC_HPP
+
+
+#include <future>                           //for std::future
+#include <exception>                        //for std::exception_ptr
+#include <functional>                       //for std::function
+#include <opencv2/gapi/garg.hpp>            //for GRunArgs, GRunArgsP
+#include <opencv2/gapi/gcommon.hpp>         //for GCompileArgs
+#include <opencv2/gapi/own/exports.hpp>
+
+
+namespace cv {
+    //fwd declaration
+    class GComputation;
+namespace gapi {
+namespace wip  {
+    class GAsyncContext;
+    /** In contrast to async() functions, these do call GComputation::apply() member function of the GComputation passed in.
+
+    @param gcomp        Computation (graph) to run asynchronously
+    @param callback     Callback to be called when execution of gcomp is done
+    @param ins          Input parameters for gcomp
+    @param outs         Output parameters for gcomp
+    @param args         Compile arguments to pass to GComputation::apply()
+    @see                async
+    */
+    GAPI_EXPORTS void                async_apply(GComputation& gcomp, std::function<void(std::exception_ptr)>&& callback, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args = {});
+    /** @overload
+    @param gcomp        Computation (graph) to run asynchronously
+    @param callback     Callback to be called when execution of gcomp is done
+    @param ins          Input parameters for gcomp
+    @param outs         Output parameters for gcomp
+    @param args         Compile arguments to pass to GComputation::apply()
+    @param ctx          Context this request belongs to
+    @see                async_apply async GAsyncContext
+    */
+    GAPI_EXPORTS void                async_apply(GComputation& gcomp, std::function<void(std::exception_ptr)>&& callback, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args, GAsyncContext& ctx);
+    /** @overload
+    @param gcomp        Computation (graph) to run asynchronously
+    @param ins          Input parameters for gcomp
+    @param outs         Output parameters for gcomp
+    @param args         Compile arguments to pass to GComputation::apply()
+    @return             std::future<void> object to wait for completion of async operation
+    @see                async_apply async
+    */
+    GAPI_EXPORTS std::future<void>   async_apply(GComputation& gcomp, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args = {});
+    /** @overload
+    @param gcomp        Computation (graph) to run asynchronously
+    @param ins          Input parameters for gcomp
+    @param outs         Output parameters for gcomp
+    @param args         Compile arguments to pass to GComputation::apply()
+    @param ctx          Context this request belongs to
+    @return             std::future<void> object to wait for completion of async operation
+    @see                async_apply async GAsyncContext
+    */
+    GAPI_EXPORTS std::future<void>   async_apply(GComputation& gcomp, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args,  GAsyncContext& ctx);
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+
+#endif //OPENCV_GAPI_GCOMPUTATION_ASYNC_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gframe.hpp

@@ -0,0 +1,112 @@
+// 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) 2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GFRAME_HPP
+#define OPENCV_GAPI_GFRAME_HPP
+
+#include <ostream>
+#include <memory>                 // std::shared_ptr
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/gcommon.hpp> // GShape
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/own/assert.hpp>
+
+// TODO GAPI_EXPORTS or so
+namespace cv
+{
+// Forward declaration; GNode and GOrigin are an internal
+// (user-inaccessible) classes.
+class GNode;
+struct GOrigin;
+
+/** \addtogroup gapi_data_objects
+ * @{
+ */
+/**
+ * @brief GFrame class represents an image or media frame in the graph.
+ *
+ * GFrame doesn't store any data itself, instead it describes a
+ * functional relationship between operations consuming and producing
+ * GFrame objects.
+ *
+ * GFrame is introduced to handle various media formats (e.g., NV12 or
+ * I420) under the same type. Various image formats may differ in the
+ * number of planes (e.g. two for NV12, three for I420) and the pixel
+ * layout inside. GFrame type allows to handle these media formats in
+ * the graph uniformly -- the graph structure will not change if the
+ * media format changes, e.g. a different camera or decoder is used
+ * with the same graph. G-API provides a number of operations which
+ * operate directly on GFrame, like `infer<>()` or
+ * renderFrame(); these operations are expected to handle different
+ * media formats inside. There is also a number of accessor
+ * operations like BGR(), Y(), UV() -- these operations provide
+ * access to frame's data in the familiar cv::GMat form, which can be
+ * used with the majority of the existing G-API operations. These
+ * accessor functions may perform color space converion on the fly if
+ * the image format of the GFrame they are applied to differs from the
+ * operation's semantic (e.g. the BGR() accessor is called on an NV12
+ * image frame).
+ *
+ * GFrame is a virtual counterpart of cv::MediaFrame.
+ *
+ * @sa cv::MediaFrame, cv::GFrameDesc, BGR(), Y(), UV(), infer<>().
+ */
+class GAPI_EXPORTS_W_SIMPLE GFrame
+{
+public:
+    /**
+     * @brief Constructs an empty GFrame
+     *
+     * Normally, empty G-API data objects denote a starting point of
+     * the graph. When an empty GFrame is assigned to a result of some
+     * operation, it obtains a functional link to this operation (and
+     * is not empty anymore).
+     */
+    GAPI_WRAP GFrame();                      // Empty constructor
+
+    /// @private
+    GFrame(const GNode &n, std::size_t out); // Operation result constructor
+    /// @private
+    GOrigin& priv();                         // Internal use only
+    /// @private
+    const GOrigin& priv()  const;            // Internal use only
+
+private:
+    std::shared_ptr<GOrigin> m_priv;
+};
+/** @} */
+
+enum class MediaFormat: int
+{
+    BGR = 0,
+    NV12,
+};
+
+/**
+ * \addtogroup gapi_meta_args
+ * @{
+ */
+struct GAPI_EXPORTS GFrameDesc
+{
+    MediaFormat fmt;
+    cv::Size size;
+
+    bool operator== (const GFrameDesc &) const;
+};
+static inline GFrameDesc empty_gframe_desc() { return GFrameDesc{}; }
+/** @} */
+
+class MediaFrame;
+GAPI_EXPORTS GFrameDesc descr_of(const MediaFrame &frame);
+
+GAPI_EXPORTS std::ostream& operator<<(std::ostream& os, const cv::GFrameDesc &desc);
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GFRAME_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gkernel.hpp

@@ -0,0 +1,749 @@
+// 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-2021 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GKERNEL_HPP
+#define OPENCV_GAPI_GKERNEL_HPP
+
+#include <functional>
+#include <iostream>
+#include <string>  // string
+#include <type_traits> // false_type, true_type
+#include <unordered_map> // map (for GKernelPackage)
+#include <utility> // tuple
+
+#include <opencv2/gapi/gcommon.hpp> // CompileArgTag
+#include <opencv2/gapi/util/util.hpp> // Seq
+#include <opencv2/gapi/gcall.hpp>
+#include <opencv2/gapi/garg.hpp>      // GArg
+#include <opencv2/gapi/gmetaarg.hpp>  // GMetaArg
+#include <opencv2/gapi/gtype_traits.hpp> // GTypeTraits
+#include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning
+#include <opencv2/gapi/gtransform.hpp>
+
+namespace cv {
+
+struct GTypeInfo
+{
+    GShape                 shape;
+    cv::detail::OpaqueKind kind;
+    detail::HostCtor       ctor;
+};
+
+using GShapes    = std::vector<GShape>;
+using GKinds     = std::vector<cv::detail::OpaqueKind>;
+using GCtors     = std::vector<detail::HostCtor>;
+using GTypesInfo = std::vector<GTypeInfo>;
+
+// GKernel describes kernel API to the system
+// FIXME: add attributes of a kernel, (e.g. number and types
+// of inputs, etc)
+struct GAPI_EXPORTS GKernel
+{
+    using M = std::function<GMetaArgs(const GMetaArgs &, const GArgs &)>;
+
+    std::string name;       // kernel ID, defined by its API (signature)
+    std::string tag;        // some (implementation-specific) tag
+    M           outMeta;    // generic adaptor to API::outMeta(...)
+    GShapes     outShapes;  // types (shapes) kernel's outputs
+    GKinds      inKinds;    // kinds of kernel's inputs (fixme: below)
+    GCtors      outCtors;   // captured constructors for template output types
+};
+// TODO: It's questionable if inKinds should really be here. Instead,
+// this information could come from meta.
+
+// GKernelImpl describes particular kernel implementation to the system
+struct GAPI_EXPORTS GKernelImpl
+{
+    util::any         opaque;    // backend-specific opaque info
+    GKernel::M        outMeta;   // for deserialized graphs, the outMeta is taken here
+};
+
+template<typename, typename> class GKernelTypeM;
+
+namespace detail
+{
+    ////////////////////////////////////////////////////////////////////////////
+    // yield() is used in graph construction time as a generic method to obtain
+    // lazy "return value" of G-API operations
+    //
+    template<typename T> struct Yield;
+    template<> struct Yield<cv::GMat>
+    {
+        static inline cv::GMat yield(cv::GCall &call, int i) { return call.yield(i); }
+    };
+    template<> struct Yield<cv::GMatP>
+    {
+        static inline cv::GMatP yield(cv::GCall &call, int i) { return call.yieldP(i); }
+    };
+    template<> struct Yield<cv::GScalar>
+    {
+        static inline cv::GScalar yield(cv::GCall &call, int i) { return call.yieldScalar(i); }
+    };
+    template<typename U> struct Yield<cv::GArray<U> >
+    {
+        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); }
+    };
+    template<> struct Yield<GFrame>
+    {
+        static inline cv::GFrame yield(cv::GCall &call, int i) { return call.yieldFrame(i); }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Helper classes which brings outputMeta() marshalling to kernel
+    // implementations
+    //
+    // 1. MetaType establishes G#Type -> G#Meta mapping between G-API dynamic
+    //    types and its metadata descriptor types.
+    //    This mapping is used to transform types to call outMeta() callback.
+    template<typename T> struct MetaType;
+    template<> struct MetaType<cv::GMat>    { using type = GMatDesc; };
+    template<> struct MetaType<cv::GMatP>   { using type = GMatDesc; };
+    template<> struct MetaType<cv::GFrame>  { using type = GFrameDesc; };
+    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::GOpaque<U> > { using type = GOpaqueDesc; };
+    template<typename T> struct MetaType    { using type = T; }; // opaque args passed as-is
+    // FIXME: Move it to type traits?
+
+    // 2. Hacky test based on MetaType to check if we operate on G-* type or not
+    template<typename T> using is_nongapi_type = std::is_same<T, typename MetaType<T>::type>;
+
+    // 3. Two ways to transform input arguments to its meta - for G-* and non-G* types:
+    template<typename T>
+    typename std::enable_if<!is_nongapi_type<T>::value, typename MetaType<T>::type>
+    ::type get_in_meta(const GMetaArgs &in_meta, const GArgs &, int idx)
+    {
+        return util::get<typename MetaType<T>::type>(in_meta.at(idx));
+    }
+
+    template<typename T>
+    typename std::enable_if<is_nongapi_type<T>::value, T>
+    ::type get_in_meta(const GMetaArgs &, const GArgs &in_args, int idx)
+    {
+        return in_args.at(idx).template get<T>();
+    }
+
+    // 4. The MetaHelper itself: an entity which generates outMeta() call
+    //    based on kernel signature, with arguments properly substituted.
+    // 4.1 - case for multiple return values
+    // FIXME: probably can be simplified with std::apply or analogue.
+    template<typename, typename, typename>
+    struct MetaHelper;
+
+    template<typename K, typename... Ins, typename... Outs>
+    struct MetaHelper<K, std::tuple<Ins...>, std::tuple<Outs...> >
+    {
+        template<int... IIs, int... OIs>
+        static GMetaArgs getOutMeta_impl(const GMetaArgs &in_meta,
+                                         const GArgs &in_args,
+                                         detail::Seq<IIs...>,
+                                         detail::Seq<OIs...>)
+        {
+            // FIXME: decay?
+            using R   = std::tuple<typename MetaType<Outs>::type...>;
+            const R r = K::outMeta( get_in_meta<Ins>(in_meta, in_args, IIs)... );
+            return GMetaArgs{ GMetaArg(std::get<OIs>(r))... };
+        }
+        // FIXME: help users identify how outMeta must look like (via default impl w/static_assert?)
+
+        static GMetaArgs getOutMeta(const GMetaArgs &in_meta,
+                                    const GArgs &in_args)
+        {
+            return getOutMeta_impl(in_meta,
+                                   in_args,
+                                   typename detail::MkSeq<sizeof...(Ins)>::type(),
+                                   typename detail::MkSeq<sizeof...(Outs)>::type());
+        }
+    };
+
+    // 4.1 - case for a single return value
+    // FIXME: How to avoid duplication here?
+    template<typename K, typename... Ins, typename Out>
+    struct MetaHelper<K, std::tuple<Ins...>, Out >
+    {
+        template<int... IIs>
+        static GMetaArgs getOutMeta_impl(const GMetaArgs &in_meta,
+                                         const GArgs &in_args,
+                                         detail::Seq<IIs...>)
+        {
+            // FIXME: decay?
+            using R = typename MetaType<Out>::type;
+            const R r = K::outMeta( get_in_meta<Ins>(in_meta, in_args, IIs)... );
+            return GMetaArgs{ GMetaArg(r) };
+        }
+        // FIXME: help users identify how outMeta must look like (via default impl w/static_assert?)
+
+        static GMetaArgs getOutMeta(const GMetaArgs &in_meta,
+                                    const GArgs &in_args)
+        {
+            return getOutMeta_impl(in_meta,
+                                   in_args,
+                                   typename detail::MkSeq<sizeof...(Ins)>::type());
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    // 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()
+// method based on kernel signature. GKernelTypeM stands for multiple-return-value kernels
+//
+// G_TYPED_KERNEL and G_TYPED_KERNEL_M macros inherit user classes from GKernelType and
+// 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...>>
+    , public detail::NoTag
+{
+    template<int... IIs>
+    static std::tuple<R...> yield(cv::GCall &call, detail::Seq<IIs...>)
+    {
+        return std::make_tuple(detail::Yield<R>::yield(call, IIs)...);
+    }
+
+public:
+    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...}
+                              , {detail::GTypeTraits<Args>::op_kind...}
+                              , {detail::GObtainCtor<R>::get()...}});
+        call.pass(args...); // TODO: std::forward() here?
+        return yield(call, typename detail::MkSeq<sizeof...(R)>::type());
+    }
+};
+
+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>
+    , public detail::NoTag
+{
+public:
+    using InArgs  = std::tuple<Args...>;
+    using OutArgs = std::tuple<R>;
+
+    static R on(Args... args)
+    {
+        cv::GCall call(GKernel{ K::id()
+                              , K::tag()
+                              , &K::getOutMeta
+                              , {detail::GTypeTraits<R>::shape}
+                              , {detail::GTypeTraits<Args>::op_kind...}
+                              , {detail::GObtainCtor<R>::get()}});
+        call.pass(args...);
+        return detail::Yield<R>::yield(call, 0);
+    }
+};
+
+namespace detail {
+// This tiny class eliminates the semantic difference between
+// GKernelType and GKernelTypeM.
+template<typename, typename> class KernelTypeMedium;
+
+template<typename K, typename... R, typename... Args>
+class KernelTypeMedium<K, std::function<std::tuple<R...>(Args...)>> :
+    public cv::GKernelTypeM<K, std::function<std::tuple<R...>(Args...)>> {};
+
+template<typename K, typename R, typename... Args>
+class KernelTypeMedium<K, std::function<R(Args...)>> :
+    public cv::GKernelType<K, std::function<R(Args...)>> {};
+} // namespace detail
+
+} // namespace cv
+
+
+// FIXME: I don't know a better way so far. Feel free to suggest one
+// The problem is that every typed kernel should have ::id() but body
+// of the class is defined by user (with outMeta, other stuff)
+
+//! @cond IGNORED
+#define G_ID_HELPER_CLASS(Class)  Class##IdHelper
+
+#define G_ID_HELPER_BODY(Class, Id)                                         \
+    struct G_ID_HELPER_CLASS(Class)                                         \
+    {                                                                       \
+        static constexpr const char * id() {return Id;}                     \
+    };                                                                      \
+//! @endcond
+
+#define GET_G_TYPED_KERNEL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, NAME, ...) NAME
+#define COMBINE_SIGNATURE(...) __VA_ARGS__
+// Ensure correct __VA_ARGS__ expansion on Windows
+#define __WRAP_VAARGS(x) x
+
+/**
+ * Helper for G_TYPED_KERNEL declares a new G-API Operation. See [Kernel API](@ref gapi_kernel_api)
+ * for more details.
+ *
+ * @param Class type name for this operation.
+ * @param API an `std::function<>`-like signature for the operation;
+ *        return type is a single value or a tuple of multiple values.
+ * @param Id string identifier for the operation. Must be unique.
+ */
+#define G_TYPED_KERNEL_HELPER(Class, API, Id)                                               \
+    G_ID_HELPER_BODY(Class, Id)                                                             \
+    struct Class final: public cv::detail::KernelTypeMedium<Class, std::function API >,     \
+                        public G_ID_HELPER_CLASS(Class)
+// {body} is to be defined by user
+
+#define G_TYPED_KERNEL_HELPER_2(Class, _1, _2, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2), Id)
+
+#define G_TYPED_KERNEL_HELPER_3(Class, _1, _2, _3, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3), Id)
+
+#define G_TYPED_KERNEL_HELPER_4(Class, _1, _2, _3, _4, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4), Id)
+
+#define G_TYPED_KERNEL_HELPER_5(Class, _1, _2, _3, _4, _5, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5), Id)
+
+#define G_TYPED_KERNEL_HELPER_6(Class, _1, _2, _3, _4, _5, _6, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6), Id)
+
+#define G_TYPED_KERNEL_HELPER_7(Class, _1, _2, _3, _4, _5, _6, _7, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6, _7), Id)
+
+#define G_TYPED_KERNEL_HELPER_8(Class, _1, _2, _3, _4, _5, _6, _7, _8, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6, _7, _8), Id)
+
+#define G_TYPED_KERNEL_HELPER_9(Class, _1, _2, _3, _4, _5, _6, _7, _8, _9, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6, _7, _8, _9), Id)
+
+#define G_TYPED_KERNEL_HELPER_10(Class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, Id) \
+G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10), Id)
+
+/**
+ * Declares a new G-API Operation. See [Kernel API](@ref gapi_kernel_api)
+ * for more details.
+ *
+ * @param Class type name for this operation.
+ */
+#define G_TYPED_KERNEL(Class, ...) __WRAP_VAARGS(GET_G_TYPED_KERNEL(__VA_ARGS__, \
+                                                 G_TYPED_KERNEL_HELPER_10, \
+                                                 G_TYPED_KERNEL_HELPER_9, \
+                                                 G_TYPED_KERNEL_HELPER_8, \
+                                                 G_TYPED_KERNEL_HELPER_7, \
+                                                 G_TYPED_KERNEL_HELPER_6, \
+                                                 G_TYPED_KERNEL_HELPER_5, \
+                                                 G_TYPED_KERNEL_HELPER_4, \
+                                                 G_TYPED_KERNEL_HELPER_3, \
+                                                 G_TYPED_KERNEL_HELPER_2, \
+                                                 G_TYPED_KERNEL_HELPER)(Class, __VA_ARGS__)) \
+
+/**
+ * Declares a new G-API Operation. See [Kernel API](@ref gapi_kernel_api) for more details.
+ *
+ * @deprecated This macro is deprecated in favor of `G_TYPED_KERNEL` that is used for declaring any
+ * G-API Operation.
+ *
+ * @param Class type name for this operation.
+ */
+#define G_TYPED_KERNEL_M G_TYPED_KERNEL
+
+#define G_API_OP   G_TYPED_KERNEL
+#define G_API_OP_M G_API_OP
+
+namespace cv
+{
+namespace gapi
+{
+    // Prework: model "Device" API before it gets to G-API headers.
+    // FIXME: Don't mix with internal Backends class!
+    /// @private
+    class GAPI_EXPORTS GBackend
+    {
+    public:
+        class Priv;
+
+        // TODO: make it template (call `new` within??)
+        GBackend();
+        explicit GBackend(std::shared_ptr<Priv> &&p);
+
+        Priv& priv();
+        const Priv& priv() const;
+        std::size_t hash() const;
+
+        bool operator== (const GBackend &rhs) const;
+
+    private:
+        std::shared_ptr<Priv> m_priv;
+    };
+
+    inline bool operator != (const GBackend &lhs, const GBackend &rhs)
+    {
+        return !(lhs == rhs);
+    }
+} // namespace gapi
+} // namespace cv
+
+namespace std
+{
+    template<> struct hash<cv::gapi::GBackend>
+    {
+        std::size_t operator() (const cv::gapi::GBackend &b) const
+        {
+            return b.hash();
+        }
+    };
+} // namespace std
+
+
+namespace cv {
+namespace gapi {
+    /// @private
+    class GFunctor
+    {
+    public:
+        virtual cv::GKernelImpl impl()       const = 0;
+        virtual cv::gapi::GBackend backend() const = 0;
+        const char* id()                     const { return m_id; }
+
+        virtual ~GFunctor() = default;
+    protected:
+        GFunctor(const char* id) : m_id(id) { };
+    private:
+        const char* m_id;
+    };
+
+    /** \addtogroup gapi_compile_args
+     * @{
+     */
+
+    // FIXME: Hide implementation
+    /**
+     * @brief A container class for heterogeneous kernel
+     * implementation collections and graph transformations.
+     *
+     * GKernelPackage is a special container class which stores kernel
+     * _implementations_ and graph _transformations_. Objects of this class
+     * are created and passed to cv::GComputation::compile() to specify
+     * which kernels to use and which transformations to apply in the
+     * compiled graph. GKernelPackage may contain kernels of
+     * different backends, e.g. be heterogeneous.
+     *
+     * The most easy way to create a kernel package is to use function
+     * cv::gapi::kernels(). This template functions takes kernel
+     * implementations in form of type list (variadic template) and
+     * generates a kernel package atop of that.
+     *
+     * Kernel packages can be also generated programmatically, starting
+     * with an empty package (created with the default constructor)
+     * and then by populating it with kernels via call to
+     * GKernelPackage::include(). Note this method is also a template
+     * one since G-API kernel and transformation implementations are _types_,
+     * not objects.
+     *
+     * Finally, two kernel packages can be combined into a new one
+     * with function cv::gapi::combine().
+     */
+    class GAPI_EXPORTS_W_SIMPLE GKernelPackage
+    {
+
+        /// @private
+        using M = std::unordered_map<std::string, std::pair<GBackend, GKernelImpl>>;
+
+        /// @private
+        M m_id_kernels;
+
+        /// @private
+        std::vector<GTransform> m_transformations;
+
+    protected:
+        /// @private
+        // Remove ALL implementations of the given API (identified by ID)
+        void removeAPI(const std::string &id);
+
+        /// @private
+        // Partial include() specialization for kernels
+        template <typename KImpl>
+        typename std::enable_if<(std::is_base_of<cv::detail::KernelTag, KImpl>::value), void>::type
+        includeHelper()
+        {
+            auto backend     = KImpl::backend();
+            auto kernel_id   = KImpl::API::id();
+            auto kernel_impl = GKernelImpl{KImpl::kernel(), &KImpl::API::getOutMeta};
+            removeAPI(kernel_id);
+
+            m_id_kernels[kernel_id] = std::make_pair(backend, kernel_impl);
+        }
+
+        /// @private
+        // Partial include() specialization for transformations
+        template <typename TImpl>
+        typename std::enable_if<(std::is_base_of<cv::detail::TransformTag, TImpl>::value), void>::type
+        includeHelper()
+        {
+            m_transformations.emplace_back(TImpl::transformation());
+        }
+
+    public:
+        void include(const GFunctor& functor)
+        {
+            m_id_kernels[functor.id()] = std::make_pair(functor.backend(), functor.impl());
+        }
+        /**
+         * @brief Returns total number of kernels
+         * in the package (across all backends included)
+         *
+         * @return a number of kernels in the package
+         */
+        std::size_t size() const;
+
+        /**
+         * @brief Returns vector of transformations included in the package
+         *
+         * @return vector of transformations included in the package
+         */
+        const std::vector<GTransform>& get_transformations() const;
+
+        /**
+         * @brief Returns vector of kernel ids included in the package
+         *
+         * @return vector of kernel ids included in the package
+         */
+        std::vector<std::string> get_kernel_ids() const;
+
+        /**
+         * @brief Test if a particular kernel _implementation_ KImpl is
+         * included in this kernel package.
+         *
+         * @sa includesAPI()
+         *
+         * @note cannot be applied to transformations
+         *
+         * @return true if there is such kernel, false otherwise.
+         */
+        template<typename KImpl>
+        bool includes() const
+        {
+            static_assert(std::is_base_of<cv::detail::KernelTag, KImpl>::value,
+                          "includes() can be applied to kernels only");
+
+            auto kernel_it = m_id_kernels.find(KImpl::API::id());
+            return kernel_it != m_id_kernels.end() &&
+                   kernel_it->second.first == KImpl::backend();
+        }
+
+        /**
+         * @brief Remove all kernels associated with the given backend
+         * from the package.
+         *
+         * Does nothing if there's no kernels of this backend in the package.
+         *
+         * @param backend backend which kernels to remove
+         */
+        void remove(const GBackend& backend);
+
+        /**
+         * @brief Remove all kernels implementing the given API from
+         * the package.
+         *
+         * Does nothing if there's no kernels implementing the given interface.
+         */
+        template<typename KAPI>
+        void remove()
+        {
+            removeAPI(KAPI::id());
+        }
+
+        // FIXME: Rename to includes() and distinguish API/impl case by
+        //     statically?
+        /**
+         * Check if package contains ANY implementation of a kernel API
+         * by API type.
+         */
+        template<typename KAPI>
+        bool includesAPI() const
+        {
+            return includesAPI(KAPI::id());
+        }
+
+        /// @private
+        bool includesAPI(const std::string &id) const;
+
+        // FIXME: The below comment is wrong, and who needs this function?
+        /**
+         * @brief Find a kernel (by its API)
+         *
+         * Returns implementation corresponding id.
+         * Throws if nothing found.
+         *
+         * @return Backend which hosts matching kernel implementation.
+         *
+         */
+        template<typename KAPI>
+        GBackend lookup() const
+        {
+            return lookup(KAPI::id()).first;
+        }
+
+        /// @private
+        std::pair<cv::gapi::GBackend, cv::GKernelImpl>
+        lookup(const std::string &id) const;
+
+        // FIXME: No overwrites allowed?
+        /**
+         * @brief Put a new kernel implementation or a new transformation
+         * KImpl into the package.
+         */
+        template<typename KImpl>
+        void include()
+        {
+            includeHelper<KImpl>();
+        }
+
+        /**
+         * @brief Adds a new kernel based on it's backend and id into the kernel package
+         *
+         * @param backend backend associated with the kernel
+         * @param kernel_id a name/id of the kernel
+         */
+        void include(const cv::gapi::GBackend& backend, const std::string& kernel_id)
+        {
+            removeAPI(kernel_id);
+            m_id_kernels[kernel_id] = std::make_pair(backend, GKernelImpl{{}, {}});
+        }
+
+        /**
+         * @brief Lists all backends which are included into package
+         *
+         * @return vector of backends
+         */
+        std::vector<GBackend> backends() const;
+
+        // TODO: Doxygen bug -- it wants me to place this comment
+        // here, not below.
+        /**
+         * @brief Create a new package based on `lhs` and `rhs`.
+         *
+         * @param lhs "Left-hand-side" package in the process
+         * @param rhs "Right-hand-side" package in the process
+         * @return a new kernel package.
+         */
+        friend GAPI_EXPORTS GKernelPackage combine(const GKernelPackage  &lhs,
+                                                   const GKernelPackage  &rhs);
+    };
+
+    /**
+     * @brief Create a kernel package object containing kernels
+     * and transformations specified in variadic template argument.
+     *
+     * In G-API, kernel implementations and transformations are _types_.
+     * Every backend has its own kernel API (like GAPI_OCV_KERNEL() and
+     * GAPI_FLUID_KERNEL()) but all of that APIs define a new type for
+     * each kernel implementation.
+     *
+     * Use this function to pass kernel implementations (defined in
+     * either way) and transformations to the system. Example:
+     *
+     * @snippet modules/gapi/samples/api_ref_snippets.cpp kernels_snippet
+     *
+     * Note that kernels() itself is a function returning object, not
+     * a type, so having `()` at the end is important -- it must be a
+     * function call.
+     */
+    template<typename... KK> GKernelPackage kernels()
+    {
+        // FIXME: currently there is no check that transformations' signatures are unique
+        // and won't be any intersection in graph compilation stage
+        static_assert(cv::detail::all_unique<typename KK::API...>::value, "Kernels API must be unique");
+
+        GKernelPackage pkg;
+
+        // For those who wonder - below is a trick to call a number of
+        // methods based on parameter pack (zeroes just help hiding these
+        // calls into a sequence which helps to expand this parameter pack).
+        // Just note that `f(),a` always equals to `a` (with f() called!)
+        // and parentheses are used to hide function call in the expanded sequence.
+        // Leading 0 helps to handle case when KK is an empty list (kernels<>()).
+        int unused[] = { 0, (pkg.include<KK>(), 0)... };
+        cv::util::suppress_unused_warning(unused);
+        return pkg;
+    };
+
+    template<typename... FF>
+    GKernelPackage kernels(FF&... functors)
+    {
+        GKernelPackage pkg;
+        int unused[] = { 0, (pkg.include(functors), 0)... };
+        cv::util::suppress_unused_warning(unused);
+        return pkg;
+    };
+
+    /** @} */
+
+    // FYI - this function is already commented above
+    GAPI_EXPORTS GKernelPackage combine(const GKernelPackage  &lhs,
+                                        const GKernelPackage  &rhs);
+
+    /**
+     * @brief Combines multiple G-API kernel packages into one
+     *
+     * @overload
+     *
+     * This function successively combines the passed kernel packages using a right fold.
+     * Calling `combine(a, b, c)` is equal to `combine(a, combine(b, c))`.
+     *
+     * @return The resulting kernel package
+     */
+    template<typename... Ps>
+    GKernelPackage combine(const GKernelPackage &a, const GKernelPackage &b, Ps&&... rest)
+    {
+        return combine(a, combine(b, rest...));
+    }
+
+    /** \addtogroup gapi_compile_args
+     * @{
+     */
+    /**
+     * @brief cv::use_only() is a special combinator which hints G-API to use only
+     * kernels specified in cv::GComputation::compile() (and not to extend kernels available by
+     * default with that package).
+     */
+    struct GAPI_EXPORTS use_only
+    {
+        GKernelPackage pkg;
+    };
+    /** @} */
+
+} // namespace gapi
+
+namespace detail
+{
+    template<> struct CompileArgTag<cv::gapi::GKernelPackage>
+    {
+        static const char* tag() { return "gapi.kernel_package"; }
+    };
+
+    template<> struct CompileArgTag<cv::gapi::use_only>
+    {
+        static const char* tag() { return "gapi.use_only"; }
+    };
+} // namespace detail
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GKERNEL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gmat.hpp

@@ -0,0 +1,279 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GMAT_HPP
+#define OPENCV_GAPI_GMAT_HPP
+
+#include <ostream>
+#include <memory>                 // std::shared_ptr
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/gcommon.hpp> // GShape
+
+#include <opencv2/gapi/own/assert.hpp>
+
+// TODO GAPI_EXPORTS or so
+namespace cv
+{
+// Forward declaration; GNode and GOrigin are an internal
+// (user-inaccessible) classes.
+class GNode;
+struct GOrigin;
+
+/** \addtogroup gapi_data_objects
+ * @{
+ *
+ * @brief G-API data objects used to build G-API expressions.
+ *
+ * These objects do not own any particular data (except compile-time
+ * associated values like with cv::GScalar or `cv::GArray<T>`) and are
+ * used only to construct graphs.
+ *
+ * Every graph in G-API starts and ends with data objects.
+ *
+ * Once constructed and compiled, G-API operates with regular host-side
+ * data instead. Refer to the below table to find the mapping between
+ * G-API and regular data types when passing input and output data
+ * structures to G-API:
+ *
+ *    G-API data type    | I/O data type
+ *    ------------------ | -------------
+ *    cv::GMat           | cv::Mat, cv::UMat, cv::RMat
+ *    cv::GScalar        | cv::Scalar
+ *    `cv::GArray<T>`    | std::vector<T>
+ *    `cv::GOpaque<T>`   | T
+ *    cv::GFrame         | cv::MediaFrame
+ */
+/**
+ * @brief GMat class represents image or tensor data in the
+ * graph.
+ *
+ * GMat doesn't store any data itself, instead it describes a
+ * functional relationship between operations consuming and producing
+ * GMat objects.
+ *
+ * GMat is a virtual counterpart of Mat and UMat, but it
+ * doesn't mean G-API use Mat or UMat objects internally to represent
+ * GMat objects -- the internal data representation may be
+ * backend-specific or optimized out at all.
+ *
+ * @sa Mat, GMatDesc
+ */
+class GAPI_EXPORTS_W_SIMPLE GMat
+{
+public:
+    /**
+     * @brief Constructs an empty GMat
+     *
+     * Normally, empty G-API data objects denote a starting point of
+     * the graph. When an empty GMat is assigned to a result of some
+     * operation, it obtains a functional link to this operation (and
+     * is not empty anymore).
+     */
+    GAPI_WRAP GMat();                       // Empty constructor
+
+    /// @private
+    GMat(const GNode &n, std::size_t out);  // Operation result constructor
+    /// @private
+    GOrigin& priv();                        // Internal use only
+    /// @private
+    const GOrigin& priv()  const;           // Internal use only
+
+private:
+    std::shared_ptr<GOrigin> m_priv;
+};
+
+class GAPI_EXPORTS GMatP : public GMat
+{
+public:
+    using GMat::GMat;
+};
+
+class RMat;
+
+/** @} */
+
+/**
+ * \addtogroup gapi_meta_args
+ * @{
+ */
+struct GAPI_EXPORTS_W_SIMPLE GMatDesc
+{
+    // FIXME: Default initializers in C++14
+    GAPI_PROP int depth;
+    GAPI_PROP int chan;
+    GAPI_PROP cv::Size size; // NB.: no multi-dimensional cases covered yet
+    GAPI_PROP bool planar;
+    GAPI_PROP std::vector<int> dims; // FIXME: Maybe it's real questionable to have it here
+
+    GAPI_WRAP GMatDesc(int d, int c, cv::Size s, bool p = false)
+        : depth(d), chan(c), size(s), planar(p) {}
+
+    GAPI_WRAP GMatDesc(int d, const std::vector<int> &dd)
+        : depth(d), chan(-1), size{-1,-1}, planar(false), dims(dd) {}
+
+    GAPI_WRAP GMatDesc(int d, std::vector<int> &&dd)
+        : depth(d), chan(-1), size{-1,-1}, planar(false), dims(std::move(dd)) {}
+
+    GAPI_WRAP 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
+               && dims   == rhs.dims;
+    }
+
+    inline bool operator!= (const GMatDesc &rhs) const
+    {
+        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)
+    // and as a 3-channel planar mat with height divided by 3)
+    bool canDescribe(const cv::Mat& mat) const;
+
+    bool canDescribe(const cv::RMat& mat) const;
+
+    // Meta combinator: return a new GMatDesc which differs in size by delta
+    // (all other fields are taken unchanged from this GMatDesc)
+    // FIXME: a better name?
+    GAPI_WRAP GMatDesc withSizeDelta(cv::Size delta) const
+    {
+        GMatDesc desc(*this);
+        desc.size += delta;
+        return desc;
+    }
+    // Meta combinator: return a new GMatDesc which differs in size by delta
+    // (all other fields are taken unchanged from this GMatDesc)
+    //
+    // This is an overload.
+    GAPI_WRAP GMatDesc withSizeDelta(int dx, int dy) const
+    {
+        return withSizeDelta(cv::Size{dx,dy});
+    }
+
+    GAPI_WRAP GMatDesc withSize(cv::Size sz) const
+    {
+        GMatDesc desc(*this);
+        desc.size = sz;
+        return desc;
+    }
+
+    // Meta combinator: return a new GMatDesc with specified data depth.
+    // (all other fields are taken unchanged from this GMatDesc)
+    GAPI_WRAP GMatDesc withDepth(int ddepth) const
+    {
+        GAPI_Assert(CV_MAT_CN(ddepth) == 1 || ddepth == -1);
+        GMatDesc desc(*this);
+        if (ddepth != -1) desc.depth = ddepth;
+        return desc;
+    }
+
+    // Meta combinator: return a new GMatDesc with specified data depth
+    // and number of channels.
+    // (all other fields are taken unchanged from this GMatDesc)
+    GAPI_WRAP GMatDesc withType(int ddepth, int dchan) const
+    {
+        GAPI_Assert(CV_MAT_CN(ddepth) == 1 || ddepth == -1);
+        GMatDesc desc = withDepth(ddepth);
+        desc.chan = dchan;
+        return desc;
+    }
+
+    // Meta combinator: return a new GMatDesc with planar flag set
+    // (no size changes are performed, only channel interpretation is changed
+    // (interleaved -> planar)
+    GAPI_WRAP GMatDesc asPlanar() const
+    {
+        GAPI_Assert(planar == false);
+        GMatDesc desc(*this);
+        desc.planar = true;
+        return desc;
+    }
+
+    // Meta combinator: return a new GMatDesc
+    // reinterpreting 1-channel input as planar image
+    // (size height is divided by plane number)
+    GAPI_WRAP GMatDesc asPlanar(int planes) const
+    {
+        GAPI_Assert(planar == false);
+        GAPI_Assert(chan == 1);
+        GAPI_Assert(planes > 1);
+        GAPI_Assert(size.height % planes == 0);
+        GMatDesc desc(*this);
+        desc.size.height /=  planes;
+        desc.chan = planes;
+        return desc.asPlanar();
+    }
+
+    // Meta combinator: return a new GMatDesc with planar flag set to false
+    // (no size changes are performed, only channel interpretation is changed
+    // (planar -> interleaved)
+    GAPI_WRAP GMatDesc asInterleaved() const
+    {
+        GAPI_Assert(planar == true);
+        GMatDesc desc(*this);
+        desc.planar = false;
+        return desc;
+    }
+};
+
+static inline GMatDesc empty_gmat_desc() { return GMatDesc{-1,-1,{-1,-1}}; }
+
+namespace gapi { namespace detail {
+/** Checks GMatDesc fields if the passed matrix is a set of n-dimentional points.
+@param in GMatDesc to check.
+@param n expected dimensionality.
+@return the amount of points. In case input matrix can't be described as vector of points
+of expected dimensionality, returns -1.
+ */
+int checkVector(const GMatDesc& in, const size_t n);
+
+/** @overload
+
+Checks GMatDesc fields if the passed matrix can be described as a set of points of any
+dimensionality.
+
+@return array of two elements in form of std::vector<int>: the amount of points
+and their calculated dimensionality. In case input matrix can't be described as vector of points,
+returns {-1, -1}.
+ */
+std::vector<int> checkVector(const GMatDesc& in);
+}} // namespace gapi::detail
+
+#if !defined(GAPI_STANDALONE)
+GAPI_EXPORTS GMatDesc descr_of(const cv::UMat &mat);
+#endif // !defined(GAPI_STANDALONE)
+
+//Fwd declarations
+namespace gapi { namespace own {
+    class Mat;
+    GAPI_EXPORTS GMatDesc descr_of(const Mat &mat);
+}}//gapi::own
+
+GAPI_EXPORTS GMatDesc descr_of(const RMat &mat);
+
+#if !defined(GAPI_STANDALONE)
+GAPI_EXPORTS GMatDesc descr_of(const cv::Mat &mat);
+#else
+using gapi::own::descr_of;
+#endif
+
+/** @} */
+
+GAPI_EXPORTS std::ostream& operator<<(std::ostream& os, const cv::GMatDesc &desc);
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GMAT_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gmetaarg.hpp

@@ -0,0 +1,80 @@
+// 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_GMETAARG_HPP
+#define OPENCV_GAPI_GMETAARG_HPP
+
+#include <vector>
+#include <type_traits>
+
+#include <opencv2/gapi/util/util.hpp>
+#include <opencv2/gapi/util/variant.hpp>
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/gscalar.hpp>
+#include <opencv2/gapi/garray.hpp>
+#include <opencv2/gapi/gopaque.hpp>
+#include <opencv2/gapi/gframe.hpp>
+
+namespace cv
+{
+// FIXME: Rename to GMeta?
+// FIXME: user shouldn't deal with it - put to detail?
+// GMetaArg is an union type over descriptions of G-types which can serve as
+// GComputation's in/output slots.
+//
+// GMetaArg objects are passed as arguments to GComputation::compile()
+// to specify which data a compiled computation should be specialized on.
+// For manual compile(), user must supply this metadata, in case of apply()
+// this metadata is taken from arguments computation should operate on.
+//
+// The first type (monostate) is equal to "uninitialized"/"unresolved" meta.
+using GMetaArg = util::variant
+    < util::monostate
+    , GMatDesc
+    , GScalarDesc
+    , GArrayDesc
+    , GOpaqueDesc
+    , GFrameDesc
+    >;
+GAPI_EXPORTS std::ostream& operator<<(std::ostream& os, const GMetaArg &);
+
+using GMetaArgs = std::vector<GMetaArg>;
+
+namespace detail
+{
+    // These traits are used by GComputation::compile()
+
+    // FIXME: is_constructible<T> doesn't work as variant doesn't do any SFINAE
+    // in its current template constructor
+
+    template<typename T> struct is_meta_descr    : std::false_type {};
+    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...>;
+
+    template<typename... Ts>
+    using are_meta_descrs_but_last = all_satisfy<is_meta_descr, typename all_but_last<Ts...>::type>;
+
+} // namespace detail
+
+// Note: descr_of(std::vector<..>) returns a GArrayDesc, while
+//       descrs_of(std::vector<..>) returns an array of Meta args!
+class UMat;
+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 {
+    GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector<Mat> &vec);
+}} // namespace gapi::own
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GMETAARG_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gopaque.hpp

@@ -0,0 +1,369 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GOPAQUE_HPP
+#define OPENCV_GAPI_GOPAQUE_HPP
+
+#include <functional>
+#include <ostream>
+#include <memory>
+
+#include <opencv2/gapi/own/exports.hpp>
+#include <opencv2/gapi/opencv_includes.hpp>
+
+#include <opencv2/gapi/util/any.hpp>
+#include <opencv2/gapi/util/variant.hpp>
+#include <opencv2/gapi/util/throw.hpp>
+#include <opencv2/gapi/util/type_traits.hpp>
+#include <opencv2/gapi/own/assert.hpp>
+
+#include <opencv2/gapi/gcommon.hpp>  // OpaqueKind
+#include <opencv2/gapi/garray.hpp>  // TypeHintBase
+
+namespace cv
+{
+// Forward declaration; GNode and GOrigin are an internal
+// (user-inaccessible) classes.
+class GNode;
+struct GOrigin;
+template<typename T> class GOpaque;
+
+/**
+ * \addtogroup gapi_meta_args
+ * @{
+ */
+struct GAPI_EXPORTS_W_SIMPLE GOpaqueDesc
+{
+    // FIXME: Body
+    // FIXME: Also implement proper operator== then
+    bool operator== (const GOpaqueDesc&) const { return true; }
+};
+template<typename U> GOpaqueDesc descr_of(const U &) { return {};}
+GAPI_EXPORTS_W inline GOpaqueDesc empty_gopaque_desc() {return {}; }
+/** @} */
+
+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.
+    // Currently it is suitable for Host (CPU) plugins only, real offload may require
+    // more information for manual memory allocation on-device.
+    class OpaqueRef;
+    using ConstructOpaque = std::function<void(OpaqueRef&)>;
+
+    // FIXME: garray.hpp already contains hint classes (for actual T type verification),
+    // need to think where it can be moved (currently opaque uses it from garray)
+
+    // This class strips type information from GOpaque<T> and makes it usable
+    // in the G-API graph compiler (expression unrolling, graph generation, etc).
+    // Part of GProtoArg.
+    class GAPI_EXPORTS GOpaqueU
+    {
+    public:
+        GOpaqueU(const GNode &n, std::size_t out); // Operation result constructor
+
+        template <typename T>
+        bool holds() const;                       // Check if was created from GOpaque<T>
+
+        GOrigin& priv();                          // Internal use only
+        const GOrigin& priv() const;              // Internal use only
+
+    protected:
+        GOpaqueU();                                // Default constructor
+        template<class> friend class cv::GOpaque;  // (available for GOpaque<T> only)
+
+        void setConstructFcn(ConstructOpaque &&cv);  // Store T-aware constructor
+
+        template <typename T>
+        void specifyType();                       // Store type of initial GOpaque<T>
+
+        template <typename T>
+        void storeKind();
+
+        void setKind(cv::detail::OpaqueKind);
+
+        std::shared_ptr<GOrigin> m_priv;
+        std::shared_ptr<TypeHintBase> m_hint;
+    };
+
+    template <typename T>
+    bool GOpaqueU::holds() const{
+        GAPI_Assert(m_hint != nullptr);
+        using U = util::decay_t<T>;
+        return dynamic_cast<TypeHint<U>*>(m_hint.get()) != nullptr;
+    };
+
+    template <typename T>
+    void GOpaqueU::specifyType(){
+        m_hint.reset(new TypeHint<util::decay_t<T>>);
+    };
+
+    template <typename T>
+    void GOpaqueU::storeKind(){
+        // FIXME: Add assert here on cv::Mat and cv::Scalar?
+        setKind(cv::detail::GOpaqueTraits<T>::kind);
+    };
+
+    // This class represents a typed object reference.
+    // Depending on origins, this reference may be either "just a" reference to
+    // an object created externally, OR actually own the underlying object
+    // (be value holder).
+    class BasicOpaqueRef
+    {
+    public:
+        cv::GOpaqueDesc m_desc;
+        virtual ~BasicOpaqueRef() {}
+
+        virtual void mov(BasicOpaqueRef &ref) = 0;
+        virtual const void* ptr() const = 0;
+        virtual void set(const cv::util::any &a) = 0;
+    };
+
+    template<typename T> class OpaqueRefT final: public BasicOpaqueRef
+    {
+        using empty_t  = util::monostate;
+        using ro_ext_t = const T *;
+        using rw_ext_t =       T *;
+        using rw_own_t =       T  ;
+        util::variant<empty_t, ro_ext_t, rw_ext_t, rw_own_t> m_ref;
+
+        inline bool isEmpty() const { return util::holds_alternative<empty_t>(m_ref);  }
+        inline bool isROExt() const { return util::holds_alternative<ro_ext_t>(m_ref); }
+        inline bool isRWExt() const { return util::holds_alternative<rw_ext_t>(m_ref); }
+        inline bool isRWOwn() const { return util::holds_alternative<rw_own_t>(m_ref); }
+
+        void init(const T* obj = nullptr)
+        {
+            if (obj) m_desc = cv::descr_of(*obj);
+        }
+
+    public:
+        OpaqueRefT() { init(); }
+        virtual ~OpaqueRefT() {}
+
+        explicit OpaqueRefT(const T&  obj) : m_ref(&obj)           { init(&obj); }
+        explicit OpaqueRefT(      T&  obj) : m_ref(&obj)           { init(&obj); }
+        explicit OpaqueRefT(      T&& obj) : m_ref(std::move(obj)) { init(&obj); }
+
+        // Reset a OpaqueRefT. Called only for objects instantiated
+        // internally in G-API (e.g. temporary GOpaque<T>'s within a
+        // computation).  Reset here means both initialization
+        // (creating an object) and reset (discarding its existing
+        // content before the next execution). Must never be called
+        // for external OpaqueRefTs.
+        void reset()
+        {
+            if (isEmpty())
+            {
+                T empty_obj{};
+                m_desc = cv::descr_of(empty_obj);
+                m_ref  = std::move(empty_obj);
+                GAPI_Assert(isRWOwn());
+            }
+            else if (isRWOwn())
+            {
+                util::get<rw_own_t>(m_ref) = {};
+            }
+            else GAPI_Assert(false); // shouldn't be called in *EXT modes
+        }
+
+        // Obtain a WRITE reference to underlying object
+        // Used by CPU kernel API wrappers when a kernel execution frame
+        // is created
+        T& wref()
+        {
+            GAPI_Assert(isRWExt() || isRWOwn());
+            if (isRWExt()) return *util::get<rw_ext_t>(m_ref);
+            if (isRWOwn()) return  util::get<rw_own_t>(m_ref);
+            util::throw_error(std::logic_error("Impossible happened"));
+        }
+
+        // Obtain a READ reference to underlying object
+        // Used by CPU kernel API wrappers when a kernel execution frame
+        // is created
+        const T& rref() const
+        {
+            // ANY object can be accessed for reading, even if it declared for
+            // output. Example -- a GComputation from [in] to [out1,out2]
+            // where [out2] is a result of operation applied to [out1]:
+            //
+            //            GComputation boundary
+            //            . . . . . . .
+            //            .           .
+            //     [in] ----> foo() ----> [out1]
+            //            .           .    :
+            //            .           . . .:. . .
+            //            .                V    .
+            //            .              bar() ---> [out2]
+            //            . . . . . . . . . . . .
+            //
+            if (isROExt()) return *util::get<ro_ext_t>(m_ref);
+            if (isRWExt()) return *util::get<rw_ext_t>(m_ref);
+            if (isRWOwn()) return  util::get<rw_own_t>(m_ref);
+            util::throw_error(std::logic_error("Impossible happened"));
+        }
+
+        virtual void mov(BasicOpaqueRef &v) override {
+            OpaqueRefT<T> *tv = dynamic_cast<OpaqueRefT<T>*>(&v);
+            GAPI_Assert(tv != nullptr);
+            wref() = std::move(tv->wref());
+        }
+
+        virtual const void* ptr() const override { return &rref(); }
+
+        virtual void set(const cv::util::any &a) override {
+            wref() = util::any_cast<T>(a);
+        }
+    };
+
+    // This class strips type information from OpaqueRefT<> and makes it usable
+    // in the G-API executables (carrying run-time data/information to kernels).
+    // Part of GRunArg.
+    // Its methods are typed proxies to OpaqueRefT<T>.
+    // OpaqueRef maintains "reference" semantics so two copies of OpaqueRef refer
+    // to the same underlying object.
+    class OpaqueRef
+    {
+        std::shared_ptr<BasicOpaqueRef> m_ref;
+        cv::detail::OpaqueKind m_kind;
+
+        template<typename T> inline void check() const
+        {
+            GAPI_DbgAssert(dynamic_cast<OpaqueRefT<T>*>(m_ref.get()) != nullptr);
+        }
+
+    public:
+        OpaqueRef() = default;
+
+        template<
+            typename T,
+            typename = util::are_different_t<OpaqueRef, T>
+        >
+        // FIXME: probably won't work with const object
+        explicit OpaqueRef(T&& obj) :
+            m_ref(new OpaqueRefT<util::decay_t<T>>(std::forward<T>(obj))),
+            m_kind(GOpaqueTraits<util::decay_t<T>>::kind) {}
+
+        cv::detail::OpaqueKind getKind() const
+        {
+            return m_kind;
+        }
+
+        template<typename T> void reset()
+        {
+            if (!m_ref) m_ref.reset(new OpaqueRefT<T>());
+            check<T>();
+            storeKind<T>();
+            static_cast<OpaqueRefT<T>&>(*m_ref).reset();
+        }
+
+        template <typename T>
+        void storeKind()
+        {
+            m_kind = cv::detail::GOpaqueTraits<T>::kind;
+        }
+
+        template<typename T> T& wref()
+        {
+            check<T>();
+            return static_cast<OpaqueRefT<T>&>(*m_ref).wref();
+        }
+
+        template<typename T> const T& rref() const
+        {
+            check<T>();
+            return static_cast<OpaqueRefT<T>&>(*m_ref).rref();
+        }
+
+        void mov(OpaqueRef &v)
+        {
+            m_ref->mov(*v.m_ref);
+        }
+
+        cv::GOpaqueDesc descr_of() const
+        {
+            return m_ref->m_desc;
+        }
+
+        // May be used to uniquely identify this object internally
+        const void *ptr() const { return m_ref->ptr(); }
+
+        // Introduced for in-graph meta handling
+        OpaqueRef& operator= (const cv::util::any &a)
+        {
+            m_ref->set(a);
+            return *this;
+        }
+    };
+} // namespace detail
+
+/** \addtogroup gapi_data_objects
+ * @{
+ */
+/**
+ * @brief `cv::GOpaque<T>` template class represents an object of
+ * class `T` in the graph.
+ *
+ * `cv::GOpaque<T>` describes a functional relationship between operations
+ * consuming and producing object of class `T`. `cv::GOpaque<T>` is
+ * designed to extend G-API with user-defined data types, which are
+ * often required with user-defined operations. G-API can't apply any
+ * optimizations to user-defined types since these types are opaque to
+ * the framework. However, there is a number of G-API operations
+ * declared with `cv::GOpaque<T>` as a return type,
+ * e.g. cv::gapi::streaming::timestamp() or cv::gapi::streaming::size().
+ *
+ * @sa `cv::GArray<T>`
+ */
+template<typename T> class GOpaque
+{
+public:
+    // Host type (or Flat type) - the type this GOpaque is actually
+    // specified to.
+    /// @private
+    using HT = typename detail::flatten_g<util::decay_t<T>>::type;
+
+    /**
+     * @brief Constructs an empty `cv::GOpaque<T>`
+     *
+     * Normally, empty G-API data objects denote a starting point of
+     * the graph. When an empty `cv::GOpaque<T>` is assigned to a result
+     * of some operation, it obtains a functional link to this
+     * operation (and is not empty anymore).
+     */
+    GOpaque() { putDetails(); }              // Empty constructor
+
+    /// @private
+    explicit GOpaque(detail::GOpaqueU &&ref) // GOpaqueU-based constructor
+        : m_ref(ref) { putDetails(); }       // (used by GCall, not for users)
+
+    /// @private
+    detail::GOpaqueU strip() const {
+        return m_ref;
+    }
+    /// @private
+    static void Ctor(detail::OpaqueRef& ref) {
+        ref.reset<HT>();
+    }
+private:
+    void putDetails() {
+        m_ref.setConstructFcn(&Ctor);
+        m_ref.specifyType<HT>();
+        m_ref.storeKind<HT>();
+    }
+
+    detail::GOpaqueU m_ref;
+};
+
+/** @} */
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GOPAQUE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gproto.hpp

@@ -0,0 +1,159 @@
+// 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_GPROTO_HPP
+#define OPENCV_GAPI_GPROTO_HPP
+
+#include <type_traits>
+#include <vector>
+#include <ostream>
+
+#include <opencv2/gapi/util/variant.hpp>
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/gscalar.hpp>
+#include <opencv2/gapi/garray.hpp>
+#include <opencv2/gapi/gopaque.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/gmetaarg.hpp>
+
+namespace cv {
+
+// FIXME: user shouldn't deal with it - put to detail?
+// GProtoArg is an union type over G-types which can serve as
+// GComputation's in/output slots. In other words, GProtoArg
+// wraps any type which can serve as G-API exchange type.
+//
+// In Runtime, GProtoArgs are substituted with appropriate GRunArgs.
+//
+// GProtoArg objects are constructed in-place when user describes
+// (captures) computations, user doesn't interact with these types
+// directly.
+using GProtoArg = util::variant
+    < GMat
+    , GMatP
+    , GFrame
+    , GScalar
+    , detail::GArrayU  // instead of GArray<T>
+    , detail::GOpaqueU // instead of GOpaque<T>
+    >;
+
+using GProtoArgs = std::vector<GProtoArg>;
+
+namespace detail
+{
+template<typename... Ts> inline GProtoArgs packArgs(Ts... args)
+{
+    return GProtoArgs{ GProtoArg(wrap_gapi_helper<Ts>::wrap(args))... };
+}
+
+}
+
+template<class Tag>
+struct GIOProtoArgs
+{
+public:
+    // NB: Used by python wrapper
+    GIOProtoArgs() = default;
+    explicit GIOProtoArgs(const GProtoArgs& args) : m_args(args) {}
+    explicit GIOProtoArgs(GProtoArgs &&args)      : m_args(std::move(args)) {}
+
+    GProtoArgs m_args;
+
+    // TODO: Think about the addition operator
+    /**
+     * @brief This operator allows to complement the proto vectors at runtime.
+     *
+     * It's an ordinary overload of addition assignment operator.
+     *
+     * Example of usage:
+     * @snippet modules/gapi/samples/dynamic_graph.cpp  GIOProtoArgs usage
+     *
+     */
+    template<typename Tg>
+    friend GIOProtoArgs<Tg>& operator += (GIOProtoArgs<Tg> &lhs, const GIOProtoArgs<Tg> &rhs);
+};
+
+template<typename Tg>
+cv::GIOProtoArgs<Tg>& operator += (cv::GIOProtoArgs<Tg> &lhs, const cv::GIOProtoArgs<Tg> &rhs)
+{
+    lhs.m_args.reserve(lhs.m_args.size() + rhs.m_args.size());
+    lhs.m_args.insert(lhs.m_args.end(), rhs.m_args.begin(), rhs.m_args.end());
+    return lhs;
+}
+
+struct In_Tag{};
+struct Out_Tag{};
+
+using GProtoInputArgs  = GIOProtoArgs<In_Tag>;
+using GProtoOutputArgs = GIOProtoArgs<Out_Tag>;
+
+// Perfect forwarding
+template<typename... Ts> inline GProtoInputArgs GIn(Ts&&... ts)
+{
+    return GProtoInputArgs(detail::packArgs(std::forward<Ts>(ts)...));
+}
+
+template<typename... Ts> inline GProtoOutputArgs GOut(Ts&&... ts)
+{
+    return GProtoOutputArgs(detail::packArgs(std::forward<Ts>(ts)...));
+}
+
+namespace detail
+{
+    // Extract elements form tuple
+    // FIXME: Someday utilize a generic tuple_to_vec<> routine
+    template<typename... Ts, int... Indexes>
+    static GProtoOutputArgs getGOut_impl(const std::tuple<Ts...>& ts, detail::Seq<Indexes...>)
+    {
+        return GProtoOutputArgs{ detail::packArgs(std::get<Indexes>(ts)...)};
+    }
+}
+
+template<typename... Ts> inline GProtoOutputArgs GOut(const std::tuple<Ts...>& ts)
+{
+    // TODO: think of std::forward(ts)
+    return detail::getGOut_impl(ts, typename detail::MkSeq<sizeof...(Ts)>::type());
+}
+
+// Takes rvalue as input arg
+template<typename... Ts> inline GProtoOutputArgs GOut(std::tuple<Ts...>&& ts)
+{
+    // TODO: think of std::forward(ts)
+    return detail::getGOut_impl(ts, typename detail::MkSeq<sizeof...(Ts)>::type());
+}
+
+// Extract run-time arguments from node origin
+// Can be used to extract constant values associated with G-objects
+// (like GScalar) at graph construction time
+GRunArg value_of(const GOrigin &origin);
+
+// Transform run-time computation arguments into a collection of metadata
+// extracted from that arguments
+GMetaArg  GAPI_EXPORTS descr_of(const GRunArg  &arg );
+GMetaArgs GAPI_EXPORTS descr_of(const GRunArgs &args);
+
+// Transform run-time operation result argument into metadata extracted from that argument
+// Used to compare the metadata, which generated at compile time with the metadata result operation in run time
+GMetaArg GAPI_EXPORTS descr_of(const GRunArgP& argp);
+
+// Checks if run-time computation argument can be described by metadata
+bool GAPI_EXPORTS can_describe(const GMetaArg&  meta,  const GRunArg&  arg);
+bool GAPI_EXPORTS can_describe(const GMetaArgs& metas, const GRunArgs& args);
+
+// Checks if run-time computation result argument can be described by metadata.
+// Used to check if the metadata generated at compile time
+// coincides with output arguments passed to computation in cpu and ocl backends
+bool GAPI_EXPORTS can_describe(const GMetaArg&  meta,  const GRunArgP& argp);
+
+// Validates input arguments
+void GAPI_EXPORTS validate_input_arg(const GRunArg& arg);
+void GAPI_EXPORTS validate_input_args(const GRunArgs& args);
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GPROTO_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gpu/core.hpp

@@ -0,0 +1,27 @@
+// 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_GPU_CORE_API_HPP
+#define OPENCV_GAPI_GPU_CORE_API_HPP
+/** @file
+* @deprecated Use <opencv2/gapi/ocl/core.hpp> instead.
+*/
+
+#include <opencv2/gapi/ocl/core.hpp>
+
+namespace cv {
+namespace gapi {
+namespace core {
+namespace gpu {
+    using namespace ocl;
+} // namespace gpu
+} // namespace core
+} // namespace gapi
+} // namespace cv
+
+
+#endif // OPENCV_GAPI_GPU_CORE_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gpu/ggpukernel.hpp

@@ -0,0 +1,18 @@
+// 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_GGPUKERNEL_HPP
+#define OPENCV_GAPI_GGPUKERNEL_HPP
+/** @file
+* @deprecated Use <opencv2/gapi/ocl/goclkernel.hpp> instead.
+*/
+
+#include <opencv2/gapi/ocl/goclkernel.hpp>
+#define GAPI_GPU_KERNEL GAPI_OCL_KERNEL
+
+
+#endif // OPENCV_GAPI_GGPUKERNEL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gpu/imgproc.hpp

@@ -0,0 +1,28 @@
+// 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_GPU_IMGPROC_API_HPP
+#define OPENCV_GAPI_GPU_IMGPROC_API_HPP
+/** @file
+* @deprecated Use <opencv2/gapi/ocl/imgproc.hpp> instead.
+*/
+
+#include <opencv2/gapi/ocl/imgproc.hpp>
+
+
+namespace cv {
+namespace gapi {
+namespace imgproc {
+namespace gpu {
+    using namespace ocl;
+} // namespace gpu
+} // namespace imgproc
+} // namespace gapi
+} // namespace cv
+
+
+#endif // OPENCV_GAPI_GPU_IMGPROC_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gscalar.hpp

@@ -0,0 +1,140 @@
+// 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_GSCALAR_HPP
+#define OPENCV_GAPI_GSCALAR_HPP
+
+#include <ostream>
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/gcommon.hpp> // GShape
+#include <opencv2/gapi/util/optional.hpp>
+
+namespace cv
+{
+// Forward declaration; GNode and GOrigin are an internal
+// (user-inaccessible) classes.
+class GNode;
+struct GOrigin;
+
+/** \addtogroup gapi_data_objects
+ * @{
+ */
+/**
+ * @brief GScalar class represents cv::Scalar data in the graph.
+ *
+ * GScalar may be associated with a cv::Scalar value, which becomes
+ * its constant value bound in graph compile time. cv::GScalar describes a
+ * functional relationship between operations consuming and producing
+ * GScalar objects.
+ *
+ * GScalar is a virtual counterpart of cv::Scalar, which is usually used
+ * to represent the GScalar data in G-API during the execution.
+ *
+ * @sa Scalar
+ */
+class GAPI_EXPORTS_W_SIMPLE GScalar
+{
+public:
+    /**
+     * @brief Constructs an empty GScalar
+     *
+     * Normally, empty G-API data objects denote a starting point of
+     * the graph. When an empty GScalar is assigned to a result of some
+     * operation, it obtains a functional link to this operation (and
+     * is not empty anymore).
+     */
+    GAPI_WRAP GScalar();
+
+    /**
+     * @brief Constructs a value-initialized GScalar
+     *
+     * In contrast with GMat (which can be either an explicit graph input
+     * or a result of some operation), GScalars may have their values
+     * be associated at graph construction time. It is useful when
+     * some operation has a GScalar input which doesn't change during
+     * the program execution, and is set only once. In this case,
+     * there is no need to declare such GScalar as a graph input.
+     *
+     * @note The value of GScalar may be overwritten by assigning some
+     * other GScalar to the object using `operator=` -- on the
+     * assigment, the old GScalar value is discarded.
+     *
+     * @param s a cv::Scalar value to associate with this GScalar object.
+     */
+    explicit GScalar(const cv::Scalar& s);
+
+    /**
+     * @overload
+     * @brief Constructs a value-initialized GScalar
+     *
+     * @param s a cv::Scalar value to associate with this GScalar object.
+     */
+    explicit GScalar(cv::Scalar&& s);       // Constant value move-constructor from cv::Scalar
+
+    /**
+     * @overload
+     * @brief Constructs a value-initialized GScalar
+     *
+     * @param v0 A `double` value to associate with this GScalar. Note
+     *  that only the first component of a four-component cv::Scalar is
+     *  set to this value, with others remain zeros.
+     *
+     * This constructor overload is not marked `explicit` and can be
+     * used in G-API expression code like this:
+     *
+     * @snippet modules/gapi/samples/api_ref_snippets.cpp gscalar_implicit
+     *
+     * Here operator+(GMat,GScalar) is used to wrap cv::gapi::addC()
+     * and a value-initialized GScalar is created on the fly.
+     *
+     * @overload
+     */
+    GScalar(double v0);                                // Constant value constructor from double
+
+    /// @private
+    GScalar(const GNode &n, std::size_t out);          // Operation result constructor
+    /// @private
+    GOrigin& priv();                                   // Internal use only
+    /// @private
+    const GOrigin& priv()  const;                      // Internal use only
+
+private:
+    std::shared_ptr<GOrigin> m_priv;
+};
+
+/** @} */
+
+/**
+ * \addtogroup gapi_meta_args
+ * @{
+ */
+struct GAPI_EXPORTS_W_SIMPLE GScalarDesc
+{
+    // NB.: right now it is empty
+
+    inline bool operator== (const GScalarDesc &) const
+    {
+        return true; // NB: implement this method if GScalar meta appears
+    }
+
+    inline bool operator!= (const GScalarDesc &rhs) const
+    {
+        return !(*this == rhs);
+    }
+};
+
+GAPI_EXPORTS_W inline GScalarDesc empty_scalar_desc() { return GScalarDesc(); }
+
+GAPI_EXPORTS GScalarDesc descr_of(const cv::Scalar &scalar);
+
+std::ostream& operator<<(std::ostream& os, const cv::GScalarDesc &desc);
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GSCALAR_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gstreaming.hpp

@@ -0,0 +1,430 @@
+// 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-2021 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GSTREAMING_COMPILED_HPP
+#define OPENCV_GAPI_GSTREAMING_COMPILED_HPP
+
+#include <memory>
+#include <vector>
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/own/assert.hpp>
+#include <opencv2/gapi/util/optional.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/streaming/source.hpp>
+
+namespace cv {
+
+template<class T> using optional = cv::util::optional<T>;
+
+namespace detail {
+template<typename T> struct wref_spec {
+    using type = T;
+};
+template<typename T> struct wref_spec<std::vector<T> > {
+    using type = T;
+};
+
+template<typename RefHolder>
+struct OptRef {
+    struct OptHolder {
+        virtual void mov(RefHolder &h) = 0;
+        virtual void reset() = 0;
+        virtual ~OptHolder() = default;
+        using Ptr = std::shared_ptr<OptHolder>;
+    };
+    template<class T> struct Holder final: OptHolder {
+        std::reference_wrapper<cv::optional<T> > m_opt_ref;
+
+        explicit Holder(cv::optional<T>& opt) : m_opt_ref(std::ref(opt)) {
+        }
+        virtual void mov(RefHolder &h) override {
+            using U = typename wref_spec<T>::type;
+            m_opt_ref.get() = cv::util::make_optional(std::move(h.template wref<U>()));
+        }
+        virtual void reset() override {
+            m_opt_ref.get().reset();
+        }
+    };
+    template<class T>
+    explicit OptRef(cv::optional<T>& t) : m_opt{new Holder<T>(t)} {}
+    void mov(RefHolder &h) { m_opt->mov(h); }
+    void reset()           { m_opt->reset();}
+private:
+    typename OptHolder::Ptr m_opt;
+};
+using OptionalVectorRef = OptRef<cv::detail::VectorRef>;
+using OptionalOpaqueRef = OptRef<cv::detail::OpaqueRef>;
+} // namespace detail
+
+// TODO: Keep it in sync with GRunArgP (derive the type automatically?)
+using GOptRunArgP = util::variant<
+    optional<cv::Mat>*,
+    optional<cv::RMat>*,
+    optional<cv::MediaFrame>*,
+    optional<cv::Scalar>*,
+    cv::detail::OptionalVectorRef,
+    cv::detail::OptionalOpaqueRef
+>;
+using GOptRunArgsP = std::vector<GOptRunArgP>;
+
+using GOptRunArg = util::variant<
+    optional<cv::Mat>,
+    optional<cv::RMat>,
+    optional<cv::MediaFrame>,
+    optional<cv::Scalar>,
+    optional<cv::detail::VectorRef>,
+    optional<cv::detail::OpaqueRef>
+>;
+using GOptRunArgs = std::vector<GOptRunArg>;
+
+namespace detail {
+
+template<typename T> inline GOptRunArgP wrap_opt_arg(optional<T>& arg) {
+    // By default, T goes to an OpaqueRef. All other types are specialized
+    return GOptRunArgP{OptionalOpaqueRef(arg)};
+}
+
+template<typename T> inline GOptRunArgP wrap_opt_arg(optional<std::vector<T> >& arg) {
+    return GOptRunArgP{OptionalVectorRef(arg)};
+}
+
+template<> inline GOptRunArgP wrap_opt_arg(optional<cv::Mat> &m) {
+    return GOptRunArgP{&m};
+}
+
+template<> inline GOptRunArgP wrap_opt_arg(optional<cv::RMat> &m) {
+    return GOptRunArgP{&m};
+}
+
+template<> inline GOptRunArgP wrap_opt_arg(optional<cv::MediaFrame> &f) {
+    return GOptRunArgP{&f};
+}
+
+template<> inline GOptRunArgP wrap_opt_arg(optional<cv::Scalar> &s) {
+    return GOptRunArgP{&s};
+}
+
+} // namespace detail
+
+// Now cv::gout() may produce an empty vector (see "dynamic graphs"), so
+// there may be a conflict between these two. State here that Opt version
+// _must_ have at least one input for this overload
+template<typename T, typename... Ts>
+inline GOptRunArgsP gout(optional<T>&arg, optional<Ts>&... args)
+{
+    return GOptRunArgsP{ detail::wrap_opt_arg(arg), detail::wrap_opt_arg(args)... };
+}
+
+/**
+ * \addtogroup gapi_main_classes
+ * @{
+ */
+/**
+ * @brief Represents a computation (graph) compiled for streaming.
+ *
+ * This class represents a product of graph compilation (calling
+ * cv::GComputation::compileStreaming()). Objects of this class
+ * actually do stream processing, and the whole pipeline execution
+ * complexity is incapsulated into objects of this class. Execution
+ * model has two levels: at the very top, the execution of a
+ * heterogeneous graph is aggressively pipelined; at the very bottom
+ * the execution of every internal block is determined by its
+ * associated backend. Backends are selected based on kernel packages
+ * passed via compilation arguments ( see @ref gapi_compile_args,
+ * GNetworkPackage, GKernelPackage for details).
+ *
+ * GStreamingCompiled objects have a "player" semantics -- there are
+ * methods like start() and stop(). GStreamingCompiled has a full
+ * control over a videostream and so is stateful. You need to specify the
+ * input stream data using setSource() and then call start() to
+ * actually start processing. After that, use pull() or try_pull() to
+ * obtain next processed data frame from the graph in a blocking or
+ * non-blocking way, respectively.
+ *
+ * Currently a single GStreamingCompiled can process only one video
+ * streat at time. Produce multiple GStreamingCompiled objects to run the
+ * same graph on multiple video streams.
+ *
+ * @sa GCompiled
+ */
+class GAPI_EXPORTS_W_SIMPLE GStreamingCompiled
+{
+public:
+    class GAPI_EXPORTS Priv;
+    GAPI_WRAP GStreamingCompiled();
+
+    // FIXME: More overloads?
+    /**
+     * @brief Specify the input data to GStreamingCompiled for
+     * processing, a generic version.
+     *
+     * Use gin() to create an input parameter vector.
+     *
+     * Input vectors must have the same number of elements as defined
+     * in the cv::GComputation protocol (at the moment of its
+     * construction). Shapes of elements also must conform to protocol
+     * (e.g. cv::Mat needs to be passed where cv::GMat has been
+     * declared as input, and so on). Run-time exception is generated
+     * on type mismatch.
+     *
+     * In contrast with regular GCompiled, user can also pass an
+     * object of type GVideoCapture for a GMat parameter of the parent
+     * GComputation.  The compiled pipeline will start fetching data
+     * from that GVideoCapture and feeding it into the
+     * pipeline. Pipeline stops when a GVideoCapture marks end of the
+     * stream (or when stop() is called).
+     *
+     * Passing a regular Mat for a GMat parameter makes it "infinite"
+     * source -- pipeline may run forever feeding with this Mat until
+     * stopped explicitly.
+     *
+     * Currently only a single GVideoCapture is supported as input. If
+     * the parent GComputation is declared with multiple input GMat's,
+     * one of those can be specified as GVideoCapture but all others
+     * must be regular Mat objects.
+     *
+     * Throws if pipeline is already running. Use stop() and then
+     * setSource() to run the graph on a new video stream.
+     *
+     * @note This method is not thread-safe (with respect to the user
+     * side) at the moment. Protect the access if
+     * start()/stop()/setSource() may be called on the same object in
+     * multiple threads in your application.
+     *
+     * @param ins vector of inputs to process.
+     * @sa gin
+     */
+    void setSource(GRunArgs &&ins);
+
+    /// @private -- Exclude this function from OpenCV documentation
+    GAPI_WRAP void setSource(const cv::detail::ExtractArgsCallback& callback);
+
+    /**
+     * @brief Specify an input video stream for a single-input
+     * computation pipeline.
+     *
+     * Throws if pipeline is already running. Use stop() and then
+     * setSource() to run the graph on a new video stream.
+     *
+     * @overload
+     * @param s a shared pointer to IStreamSource representing the
+     * input video stream.
+     */
+    void setSource(const gapi::wip::IStreamSource::Ptr& s);
+
+    /**
+     * @brief Constructs and specifies an input video stream for a
+     * single-input computation pipeline with the given parameters.
+     *
+     * Throws if pipeline is already running. Use stop() and then
+     * setSource() to run the graph on a new video stream.
+     *
+     * @overload
+     * @param args arguments used to contruct and initialize a stream
+     * source.
+     */
+    template<typename T, typename... Args>
+    void setSource(Args&&... args) {
+        setSource(cv::gapi::wip::make_src<T>(std::forward<Args>(args)...));
+    }
+
+    /**
+     * @brief Start the pipeline execution.
+     *
+     * Use pull()/try_pull() to obtain data. Throws an exception if
+     * a video source was not specified.
+     *
+     * setSource() must be called first, even if the pipeline has been
+     * working already and then stopped (explicitly via stop() or due
+     * stream completion)
+     *
+     * @note This method is not thread-safe (with respect to the user
+     * side) at the moment. Protect the access if
+     * start()/stop()/setSource() may be called on the same object in
+     * multiple threads in your application.
+     */
+    GAPI_WRAP void start();
+
+    /**
+     * @brief Get the next processed frame from the pipeline.
+     *
+     * Use gout() to create an output parameter vector.
+     *
+     * Output vectors must have the same number of elements as defined
+     * in the cv::GComputation protocol (at the moment of its
+     * construction). Shapes of elements also must conform to protocol
+     * (e.g. cv::Mat needs to be passed where cv::GMat has been
+     * declared as output, and so on). Run-time exception is generated
+     * on type mismatch.
+     *
+     * This method writes new data into objects passed via output
+     * vector.  If there is no data ready yet, this method blocks. Use
+     * try_pull() if you need a non-blocking version.
+     *
+     * @param outs vector of output parameters to obtain.
+     * @return true if next result has been obtained,
+     *    false marks end of the stream.
+     */
+    bool pull(cv::GRunArgsP &&outs);
+
+    // NB: Used from python
+    /// @private -- Exclude this function from OpenCV documentation
+    GAPI_WRAP std::tuple<bool, cv::util::variant<cv::GRunArgs, cv::GOptRunArgs>> pull();
+
+    /**
+     * @brief Get some next available data from the pipeline.
+     *
+     * This method takes a vector of cv::optional object. An object is
+     * assigned to some value if this value is available (ready) at
+     * the time of the call, and resets the object to empty() if it is
+     * not.
+     *
+     * This is a blocking method which guarantees that some data has
+     * been written to the output vector on return.
+     *
+     * Using this method only makes sense if the graph has
+     * desynchronized parts (see cv::gapi::desync). If there is no
+     * desynchronized parts in the graph, the behavior of this
+     * method is identical to the regular pull() (all data objects are
+     * produced synchronously in the output vector).
+     *
+     * Use gout() to create an output parameter vector.
+     *
+     * Output vectors must have the same number of elements as defined
+     * in the cv::GComputation protocol (at the moment of its
+     * construction). Shapes of elements also must conform to protocol
+     * (e.g. cv::optional<cv::Mat> needs to be passed where cv::GMat
+     * has been declared as output, and so on). Run-time exception is
+     * generated on type mismatch.
+     *
+     * This method writes new data into objects passed via output
+     * vector.  If there is no data ready yet, this method blocks. Use
+     * try_pull() if you need a non-blocking version.
+     *
+     * @param outs vector of output parameters to obtain.
+     * @return true if next result has been obtained,
+     *    false marks end of the stream.
+     *
+     * @sa cv::gapi::desync
+     */
+    bool pull(cv::GOptRunArgsP &&outs);
+
+    /**
+     * @brief Try to get the next processed frame from the pipeline.
+     *
+     * Use gout() to create an output parameter vector.
+     *
+     * This method writes new data into objects passed via output
+     * vector.  If there is no data ready yet, the output vector
+     * remains unchanged and false is returned.
+     *
+     * @return true if data has been obtained, and false if it was
+     *    not. Note: false here doesn't mark the end of the stream.
+     */
+    bool try_pull(cv::GRunArgsP &&outs);
+
+    /**
+     * @brief Stop (abort) processing the pipeline.
+     *
+     * Note - it is not pause but a complete stop. Calling start()
+     * will cause G-API to start processing the stream from the early beginning.
+     *
+     * Throws if the pipeline is not running.
+     */
+    GAPI_WRAP void stop();
+
+    /**
+     * @brief Test if the pipeline is running.
+     *
+     * @note This method is not thread-safe (with respect to the user
+     * side) at the moment. Protect the access if
+     * start()/stop()/setSource() may be called on the same object in
+     * multiple threads in your application.
+     *
+     * @return true if the current stream is not over yet.
+     */
+    GAPI_WRAP bool running() const;
+
+    /// @private
+    Priv& priv();
+
+    /**
+     * @brief Check if compiled object is valid (non-empty)
+     *
+     * @return true if the object is runnable (valid), false otherwise
+     */
+    explicit operator bool () const;
+
+    /**
+     * @brief Vector of metadata this graph was compiled for.
+     *
+     * @return Unless _reshape_ is not supported, return value is the
+     * same vector which was passed to cv::GComputation::compile() to
+     * produce this compiled object. Otherwise, it is the latest
+     * metadata vector passed to reshape() (if that call was
+     * successful).
+     */
+    const GMetaArgs& metas() const; // Meta passed to compile()
+
+    /**
+     * @brief Vector of metadata descriptions of graph outputs
+     *
+     * @return vector with formats/resolutions of graph's output
+     * objects, auto-inferred from input metadata vector by
+     * operations which form this computation.
+     *
+     * @note GCompiled objects produced from the same
+     * cv::GComputiation graph with different input metas may return
+     * different values in this vector.
+     */
+    const GMetaArgs& outMetas() const;
+
+protected:
+    /// @private
+    std::shared_ptr<Priv> m_priv;
+};
+/** @} */
+
+namespace gapi {
+
+/**
+ * @brief This namespace contains G-API functions, structures, and
+ * symbols related to the Streaming execution mode.
+ *
+ * Some of the operations defined in this namespace (e.g. size(),
+ * BGR(), etc.) can be used in the traditional execution mode too.
+ */
+namespace streaming {
+/**
+ * @brief Specify queue capacity for streaming execution.
+ *
+ * In the streaming mode the pipeline steps are connected with queues
+ * and this compile argument controls every queue's size.
+ */
+struct GAPI_EXPORTS_W_SIMPLE queue_capacity
+{
+    GAPI_WRAP
+    explicit queue_capacity(size_t cap = 1) : capacity(cap) { };
+    GAPI_PROP_RW
+    size_t capacity;
+};
+/** @} */
+} // namespace streaming
+} // namespace gapi
+
+namespace detail
+{
+template<> struct CompileArgTag<cv::gapi::streaming::queue_capacity>
+{
+    static const char* tag() { return "gapi.queue_capacity"; }
+};
+}
+
+}
+
+#endif // OPENCV_GAPI_GSTREAMING_COMPILED_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gtransform.hpp

@@ -0,0 +1,103 @@
+// 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_GTRANSFORM_HPP
+#define OPENCV_GAPI_GTRANSFORM_HPP
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include <opencv2/gapi/gcommon.hpp>
+#include <opencv2/gapi/util/util.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/gtype_traits.hpp>
+#include <opencv2/gapi/util/compiler_hints.hpp>
+#include <opencv2/gapi/gcomputation.hpp>
+
+namespace cv
+{
+
+struct GAPI_EXPORTS GTransform
+{
+    // FIXME: consider another simplified
+    // class instead of GComputation
+    using F = std::function<GComputation()>;
+
+    std::string description;
+    F pattern;
+    F substitute;
+
+    GTransform(const std::string& d, const F &p, const F &s) : description(d), pattern(p), substitute(s){};
+};
+
+namespace detail
+{
+
+template <typename, typename, typename>
+struct TransHelper;
+
+template <typename K, typename... Ins, typename Out>
+struct TransHelper<K, std::tuple<Ins...>, Out>
+{
+    template <typename Callable, int... IIs, int... OIs>
+    static GComputation invoke(Callable f, Seq<IIs...>, Seq<OIs...>)
+    {
+        const std::tuple<Ins...> ins;
+        const auto r = tuple_wrap_helper<Out>::get(f(std::get<IIs>(ins)...));
+        return GComputation(cv::GIn(std::get<IIs>(ins)...),
+                            cv::GOut(std::get<OIs>(r)...));
+    }
+
+    static GComputation get_pattern()
+    {
+        return invoke(K::pattern, typename MkSeq<sizeof...(Ins)>::type(),
+                      typename MkSeq<std::tuple_size<typename tuple_wrap_helper<Out>::type>::value>::type());
+    }
+    static GComputation get_substitute()
+    {
+        return invoke(K::substitute, typename MkSeq<sizeof...(Ins)>::type(),
+                      typename MkSeq<std::tuple_size<typename tuple_wrap_helper<Out>::type>::value>::type());
+    }
+};
+} // namespace detail
+
+template <typename, typename>
+class GTransformImpl;
+
+template <typename K, typename R, typename... Args>
+class GTransformImpl<K, std::function<R(Args...)>> : public cv::detail::TransHelper<K, std::tuple<Args...>, R>,
+                                                     public cv::detail::TransformTag
+{
+public:
+    // FIXME: currently there is no check that transformations' signatures are unique
+    // and won't be any intersection in graph compilation stage
+    using API = K;
+
+    static GTransform transformation()
+    {
+        return GTransform(K::descr(), &K::get_pattern, &K::get_substitute);
+    }
+};
+} // namespace cv
+
+#define G_DESCR_HELPER_CLASS(Class) Class##DescrHelper
+
+#define G_DESCR_HELPER_BODY(Class, Descr)                       \
+    namespace detail                                            \
+    {                                                           \
+    struct G_DESCR_HELPER_CLASS(Class)                          \
+    {                                                           \
+        static constexpr const char *descr() { return Descr; }; \
+    };                                                          \
+    }
+
+#define GAPI_TRANSFORM(Class, API, Descr)                                     \
+    G_DESCR_HELPER_BODY(Class, Descr)                                         \
+    struct Class final : public cv::GTransformImpl<Class, std::function API>, \
+                         public detail::G_DESCR_HELPER_CLASS(Class)
+
+#endif // OPENCV_GAPI_GTRANSFORM_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gtype_traits.hpp

@@ -0,0 +1,220 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GTYPE_TRAITS_HPP
+#define OPENCV_GAPI_GTYPE_TRAITS_HPP
+
+#include <vector>
+#include <type_traits>
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/gscalar.hpp>
+#include <opencv2/gapi/garray.hpp>
+#include <opencv2/gapi/gopaque.hpp>
+#include <opencv2/gapi/gframe.hpp>
+#include <opencv2/gapi/streaming/source.hpp>
+#include <opencv2/gapi/media.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+
+namespace cv
+{
+namespace detail
+{
+    // FIXME: These traits and enum and possible numerous switch(kind)
+    // block may be replaced with a special Handler<T> object or with
+    // a double dispatch
+    enum class ArgKind: int
+    {
+        OPAQUE_VAL,   // Unknown, generic, opaque-to-GAPI data type - STATIC
+                      // Note: OPAQUE is sometimes defined in Win sys headers
+#if !defined(OPAQUE) && !defined(CV_DOXYGEN)
+        OPAQUE = OPAQUE_VAL,  // deprecated value used for compatibility, use OPAQUE_VAL instead
+#endif
+        GOBJREF,      // <internal> reference to object
+        GMAT,         // a cv::GMat
+        GMATP,        // a cv::GMatP
+        GFRAME,       // a cv::GFrame
+        GSCALAR,      // a cv::GScalar
+        GARRAY,       // a cv::GArrayU  (note - exactly GArrayU,  not GArray<T>!)
+        GOPAQUE,      // a cv::GOpaqueU (note - exactly GOpaqueU, not GOpaque<T>!)
+    };
+
+    // Describe G-API types (G-types) with traits.  Mostly used by
+    // cv::GArg to store meta information about types passed into
+    // operation arguments. Please note that cv::GComputation is
+    // defined on GProtoArgs, not GArgs!
+    template<typename T> struct GTypeTraits;
+    template<typename T> struct GTypeTraits
+    {
+        static constexpr const ArgKind kind = ArgKind::OPAQUE_VAL;
+        static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN;
+    };
+    template<>           struct GTypeTraits<cv::GMat>
+    {
+        static constexpr const ArgKind kind = ArgKind::GMAT;
+        static constexpr const GShape shape = GShape::GMAT;
+        static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN;
+    };
+    template<>           struct GTypeTraits<cv::GMatP>
+    {
+        static constexpr const ArgKind kind = ArgKind::GMATP;
+        static constexpr const GShape shape = GShape::GMAT;
+        static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN;
+    };
+    template<>           struct GTypeTraits<cv::GFrame>
+    {
+        static constexpr const ArgKind kind = ArgKind::GFRAME;
+        static constexpr const GShape shape = GShape::GFRAME;
+        static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN;
+    };
+    template<>           struct GTypeTraits<cv::GScalar>
+    {
+        static constexpr const ArgKind kind = ArgKind::GSCALAR;
+        static constexpr const GShape shape = GShape::GSCALAR;
+        static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN;
+    };
+    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 OpaqueKind op_kind = GOpaqueTraits<T>::kind;
+        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();}
+        static cv::detail::VectorRef wrap_in   (const std::vector<T> &t) { return detail::VectorRef(t); }
+        static cv::detail::VectorRef wrap_out  (      std::vector<T> &t) { return detail::VectorRef(t); }
+    };
+    template<class T> struct GTypeTraits<cv::GOpaque<T> >
+    {
+        static constexpr const ArgKind kind = ArgKind::GOPAQUE;
+        static constexpr const GShape shape = GShape::GOPAQUE;
+        static constexpr const OpaqueKind op_kind = GOpaqueTraits<T>::kind;
+        using host_type  = T;
+        using strip_type = cv::detail::OpaqueRef;
+        static cv::detail::GOpaqueU  wrap_value(const cv::GOpaque<T>  &t) { return t.strip();}
+        static cv::detail::OpaqueRef wrap_in   (const T &t) { return detail::OpaqueRef(t); }
+        static cv::detail::OpaqueRef wrap_out  (      T &t) { return detail::OpaqueRef(t); }
+    };
+
+    // Tests if Trait for type T requires extra marshalling ("custom wrap") or not.
+    // If Traits<T> has wrap_value() defined, it does.
+    template<class T> struct has_custom_wrap
+    {
+        template<class,class> class check;
+        template<typename C> static std::true_type  test(check<C, decltype(&GTypeTraits<C>::wrap_value)> *);
+        template<typename C> static std::false_type test(...);
+        using type = decltype(test<T>(nullptr));
+        static const constexpr bool value = std::is_same<std::true_type, decltype(test<T>(nullptr))>::value;
+    };
+
+    // Resolve a Host type back to its associated G-Type.
+    // FIXME: Probably it can be avoided
+    // FIXME: GMatP is not present here.
+    // (Actually these traits is used only to check
+    // if associated G-type has custom wrap functions
+    // and GMat behavior is correct for GMatP)
+    template<typename T> struct GTypeOf;
+#if !defined(GAPI_STANDALONE)
+    template<>           struct GTypeOf<cv::UMat>              { using type = cv::GMat;      };
+#endif // !defined(GAPI_STANDALONE)
+    template<>           struct GTypeOf<cv::Mat>               { using type = cv::GMat;      };
+    template<>           struct GTypeOf<cv::RMat>              { using type = cv::GMat;      };
+    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>;};
+    template<>           struct GTypeOf<cv::MediaFrame>        { using type = cv::GFrame;    };
+    // 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;};
+    template<class T> using g_type_of_t = typename GTypeOf<T>::type;
+
+    // Marshalling helper for G-types and its Host types. Helps G-API
+    // to store G types in internal generic containers for further
+    // processing. Implements the following callbacks:
+    //
+    // * wrap() - converts user-facing G-type into an internal one
+    //   for internal storage.
+    //   Used when G-API operation is instantiated (G<Kernel>::on(),
+    //   etc) during expressing a pipeline. Mostly returns input
+    //   value "as is" except the case when G-type is a template. For
+    //   template G-classes, calls custom wrap() from Traits.
+    //   The value returned by wrap() is then wrapped into GArg() and
+    //   stored in G-API metadata.
+    //
+    //   Example:
+    //   - cv::GMat arguments are passed as-is.
+    //   - integers, pointers, STL containers, user types are passed as-is.
+    //   - cv::GArray<T> is converted to cv::GArrayU.
+    //
+    // * wrap_in() / wrap_out() - convert Host type associated with
+    //   G-type to internal representation type.
+    //
+    //   - For "simple" (non-template) G-types, returns value as-is.
+    //     Example: cv::GMat has host type cv::Mat, when user passes a
+    //              cv::Mat, system stores it internally as cv::Mat.
+    //
+    //   - For "complex" (template) G-types, utilizes custom
+    //     wrap_in()/wrap_out() as described in Traits.
+    //     Example: cv::GArray<T> has host type std::vector<T>, when
+    //              user passes a std::vector<T>, system stores it
+    //              internally as VectorRef (with <T> stripped away).
+    template<typename T, class Custom = void> struct WrapValue
+    {
+        static auto wrap(const T& t) ->
+            typename std::remove_reference<T>::type
+        {
+            return static_cast<typename std::remove_reference<T>::type>(t);
+        }
+
+        template<typename U> static U  wrap_in (const U &u) { return  u;  }
+        template<typename U> static U* wrap_out(U &u)       { return &u;  }
+    };
+    template<typename T> struct WrapValue<T, typename std::enable_if<has_custom_wrap<T>::value>::type>
+    {
+        static auto wrap(const T& t) -> decltype(GTypeTraits<T>::wrap_value(t))
+        {
+            return GTypeTraits<T>::wrap_value(t);
+        }
+        template<typename U> static auto wrap_in (const U &u) -> typename GTypeTraits<T>::strip_type
+        {
+            return GTypeTraits<T>::wrap_in(u);
+        }
+        template<typename U> static auto wrap_out(U &u) -> typename GTypeTraits<T>::strip_type
+        {
+            return GTypeTraits<T>::wrap_out(u);
+        }
+    };
+
+    template<typename T> using wrap_gapi_helper = WrapValue<typename std::decay<T>::type>;
+    template<typename T> using wrap_host_helper = WrapValue<typename std::decay<g_type_of_t<T> >::type>;
+
+// Union type for various user-defined type constructors (GArray<T>,
+// GOpaque<T>, etc)
+//
+// TODO: Replace construct-only API with a more generic one (probably
+//    with bits of introspection)
+//
+// Not required for non-user-defined types (GMat, GScalar, etc)
+using HostCtor = util::variant
+    < util::monostate
+    , detail::ConstructVec
+    , detail::ConstructOpaque
+    >;
+
+template<typename T> struct GObtainCtor {
+    static HostCtor get() { return HostCtor{}; }
+};
+template<typename T> struct GObtainCtor<GArray<T> > {
+    static HostCtor get() { return HostCtor{ConstructVec{&GArray<T>::VCtor}}; };
+};
+template<typename T> struct GObtainCtor<GOpaque<T> > {
+    static HostCtor get() { return HostCtor{ConstructOpaque{&GOpaque<T>::Ctor}}; };
+};
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_GAPI_GTYPE_TRAITS_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/gtyped.hpp

@@ -0,0 +1,246 @@
+// 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_GTYPED_HPP
+#define OPENCV_GAPI_GTYPED_HPP
+#if !defined(GAPI_STANDALONE)
+
+#include <vector>
+
+#include <opencv2/gapi/gcomputation.hpp>
+#include <opencv2/gapi/gcompiled.hpp>
+#include <opencv2/gapi/gproto.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+
+namespace cv {
+
+namespace detail
+{
+    // FIXME: How to prevent coolhackers from extending it by their own types?
+    // FIXME: ...Should we care?
+    template<typename T> struct ProtoToParam;
+    template<> struct ProtoToParam<cv::GMat>    { using type = cv::Mat; };
+    template<> struct ProtoToParam<cv::GScalar> { using type = cv::Scalar; };
+    template<typename U> struct ProtoToParam<cv::GArray<U> >  { using type = std::vector<U>; };
+    template<> struct ProtoToParam<cv::GArray<cv::GMat>>      { using type = std::vector<cv::Mat>; };
+    template<typename U> struct ProtoToParam<cv::GOpaque<U> > { using type = U; };
+    template<typename T> using ProtoToParamT = typename ProtoToParam<T>::type;
+
+    template<typename T> struct ProtoToMeta;
+    template<> struct ProtoToMeta<cv::GMat>     { using type = cv::GMatDesc; };
+    template<> struct ProtoToMeta<cv::GScalar>  { using type = cv::GScalarDesc; };
+    template<typename U> struct ProtoToMeta<cv::GArray<U> >  { using type = cv::GArrayDesc; };
+    template<typename U> struct ProtoToMeta<cv::GOpaque<U> > { using type = cv::GOpaqueDesc; };
+    template<typename T> using ProtoToMetaT = typename ProtoToMeta<T>::type;
+
+    //workaround for MSVC 19.0 bug
+    template <typename T>
+    auto make_default()->decltype(T{}) {return {};}
+}; // detail
+
+/**
+ * @brief This class is a typed wrapper over a regular GComputation.
+ *
+ * `std::function<>`-like template parameter specifies the graph
+ *  signature so methods so the object's constructor, methods like
+ *  `apply()` and the derived `GCompiledT::operator()` also become
+ *  typed.
+ *
+ *  There is no need to use cv::gin() or cv::gout() modifiers with
+ *  objects of this class.  Instead, all input arguments are followed
+ *  by all output arguments in the order from the template argument
+ *  signature.
+ *
+ *  Refer to the following example. Regular (untyped) code is written this way:
+ *
+ *  @snippet modules/gapi/samples/api_ref_snippets.cpp Untyped_Example
+ *
+ *  Here:
+ *
+ *  - cv::GComputation object is created with a lambda constructor
+ *    where it is defined as a two-input, one-output graph.
+ *
+ *  - Its method `apply()` in fact takes arbitrary number of arguments
+ *    (as vectors) so user can pass wrong number of inputs/outputs
+ *    here. C++ compiler wouldn't notice that since the cv::GComputation
+ *    API is polymorphic, and only a run-time error will be generated.
+ *
+ *  Now the same code written with typed API:
+ *
+ *  @snippet modules/gapi/samples/api_ref_snippets.cpp Typed_Example
+ *
+ *  The key difference is:
+ *
+ *  - Now the constructor lambda *must take* parameters and *must
+ *    return* values as defined in the `GComputationT<>` signature.
+ *  - Its method `apply()` does not require any extra specifiers to
+ *    separate input arguments from the output ones
+ *  - A `GCompiledT` (compilation product) takes input/output
+ *    arguments with no extra specifiers as well.
+ */
+template<typename> class GComputationT;
+
+// Single return value implementation
+template<typename R, typename... Args> class GComputationT<R(Args...)>
+{
+public:
+    typedef std::function<R(Args...)> Gen;
+
+    class GCompiledT
+    {
+    private:
+        friend class GComputationT<R(Args...)>;
+
+        cv::GCompiled m_comp;
+
+        explicit GCompiledT(const cv::GCompiled &comp) : m_comp(comp) {}
+
+    public:
+        GCompiledT() {}
+
+        void operator()(detail::ProtoToParamT<Args>... inArgs,
+                        detail::ProtoToParamT<R> &outArg)
+        {
+            m_comp(cv::gin(inArgs...), cv::gout(outArg));
+        }
+
+        explicit operator bool() const
+        {
+            return static_cast<bool>(m_comp);
+        }
+    };
+
+private:
+    typedef std::pair<R, GProtoInputArgs > Captured;
+
+    Captured capture(const Gen& g, Args... args)
+    {
+        return Captured(g(args...), cv::GIn(args...));
+    }
+
+    Captured m_capture;
+    cv::GComputation m_comp;
+
+public:
+    GComputationT(const Gen &generator)
+        : m_capture(capture(generator, detail::make_default<Args>()...))
+        , m_comp(cv::GProtoInputArgs(std::move(m_capture.second)),
+                 cv::GOut(m_capture.first))
+    {
+    }
+
+    void apply(detail::ProtoToParamT<Args>... inArgs,
+               detail::ProtoToParamT<R> &outArg,
+               GCompileArgs &&args)
+    {
+        m_comp.apply(cv::gin(inArgs...), cv::gout(outArg), std::move(args));
+    }
+
+    void apply(detail::ProtoToParamT<Args>... inArgs,
+               detail::ProtoToParamT<R> &outArg)
+    {
+        apply(inArgs..., outArg, GCompileArgs());
+    }
+
+
+    GCompiledT compile(detail::ProtoToMetaT<Args>... inDescs)
+    {
+        GMetaArgs inMetas = { GMetaArg(inDescs)... };
+        return GCompiledT(m_comp.compile(std::move(inMetas), GCompileArgs()));
+    }
+
+    GCompiledT compile(detail::ProtoToMetaT<Args>... inDescs, GCompileArgs &&args)
+    {
+        GMetaArgs inMetas = { GMetaArg(inDescs)... };
+        return GCompiledT(m_comp.compile(std::move(inMetas), std::move(args)));
+    }
+};
+
+// Multiple (fixed) return value implementation. FIXME: How to avoid copy-paste?
+template<typename... R, typename... Args> class GComputationT<std::tuple<R...>(Args...)>
+{
+public:
+    typedef std::function<std::tuple<R...>(Args...)> Gen;
+
+    class GCompiledT
+    {
+    private:
+        friend class GComputationT<std::tuple<R...>(Args...)>;
+
+        cv::GCompiled m_comp;
+        explicit GCompiledT(const cv::GCompiled &comp) : m_comp(comp) {}
+
+    public:
+        GCompiledT() {}
+
+        void operator()(detail::ProtoToParamT<Args>... inArgs,
+                        detail::ProtoToParamT<R>&... outArgs)
+        {
+            m_comp(cv::gin(inArgs...), cv::gout(outArgs...));
+        }
+
+        explicit operator bool() const
+        {
+            return static_cast<bool>(m_comp);
+        }
+    };
+
+private:
+    typedef std::pair<GProtoArgs, GProtoArgs> Captured;
+
+    template<int... IIs>
+    Captured capture(GProtoArgs &&args, const std::tuple<R...> &rr, detail::Seq<IIs...>)
+    {
+        return Captured(cv::GOut(std::get<IIs>(rr)...).m_args, args);
+    }
+
+    Captured capture(const Gen& g, Args... args)
+    {
+        return capture(cv::GIn(args...).m_args, g(args...), typename detail::MkSeq<sizeof...(R)>::type());
+    }
+
+    Captured m_capture;
+    cv::GComputation m_comp;
+
+public:
+    GComputationT(const Gen &generator)
+        : m_capture(capture(generator, detail::make_default<Args>()...))
+        , m_comp(cv::GProtoInputArgs(std::move(m_capture.second)),
+                 cv::GProtoOutputArgs(std::move(m_capture.first)))
+    {
+    }
+
+    void apply(detail::ProtoToParamT<Args>... inArgs,
+               detail::ProtoToParamT<R>&... outArgs,
+               GCompileArgs &&args)
+    {
+        m_comp.apply(cv::gin(inArgs...), cv::gout(outArgs...), std::move(args));
+    }
+
+    void apply(detail::ProtoToParamT<Args>... inArgs,
+               detail::ProtoToParamT<R>&... outArgs)
+    {
+        apply(inArgs..., outArgs..., GCompileArgs());
+    }
+
+
+    GCompiledT compile(detail::ProtoToMetaT<Args>... inDescs)
+    {
+        GMetaArgs inMetas = { GMetaArg(inDescs)... };
+        return GCompiledT(m_comp.compile(std::move(inMetas), GCompileArgs()));
+    }
+
+    GCompiledT compile(detail::ProtoToMetaT<Args>... inDescs, GCompileArgs &&args)
+    {
+        GMetaArgs inMetas = { GMetaArg(inDescs)... };
+        return GCompiledT(m_comp.compile(std::move(inMetas), std::move(args)));
+    }
+};
+
+} // namespace cv
+#endif // !defined(GAPI_STANDALONE)
+#endif // OPENCV_GAPI_GTYPED_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/infer.hpp

@@ -0,0 +1,714 @@
+// 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-2021 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 <type_traits> // is_same, false_type
+
+#include <opencv2/gapi/util/util.hpp> // all_satisfy
+#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 {
+
+template<typename, typename> class GNetworkType;
+
+namespace detail {
+
+// Infer ///////////////////////////////////////////////////////////////////////
+template<typename T>
+struct accepted_infer_types {
+    static constexpr const auto value =
+            std::is_same<typename std::decay<T>::type, cv::GMat>::value
+         || std::is_same<typename std::decay<T>::type, cv::GFrame>::value;
+};
+
+template<typename... Ts>
+using valid_infer_types = all_satisfy<accepted_infer_types, Ts...>;
+
+// Infer2 //////////////////////////////////////////////////////////////////////
+
+template<typename, typename>
+struct valid_infer2_types;
+
+// Terminal case 1 (50/50 success)
+template<typename T>
+struct valid_infer2_types< std::tuple<cv::GMat>, std::tuple<T> > {
+    // By default, Nets are limited to GMat argument types only
+    // for infer2, every GMat argument may translate to either
+    // GArray<GMat> or GArray<Rect>. GArray<> part is stripped
+    // already at this point.
+    static constexpr const auto value =
+            std::is_same<typename std::decay<T>::type, cv::GMat>::value
+         || std::is_same<typename std::decay<T>::type, cv::Rect>::value;
+};
+
+// Terminal case 2 (100% failure)
+template<typename... Ts>
+struct valid_infer2_types< std::tuple<>, std::tuple<Ts...> >
+    : public std::false_type {
+};
+
+// Terminal case 3 (100% failure)
+template<typename... Ns>
+struct valid_infer2_types< std::tuple<Ns...>, std::tuple<> >
+    : public std::false_type {
+};
+
+// Recursion -- generic
+template<typename... Ns, typename T, typename...Ts>
+struct valid_infer2_types< std::tuple<cv::GMat,Ns...>, std::tuple<T,Ts...> > {
+    static constexpr const auto value =
+           valid_infer2_types< std::tuple<cv::GMat>, std::tuple<T> >::value
+        && valid_infer2_types< std::tuple<Ns...>, std::tuple<Ts...> >::value;
+};
+
+// Struct stores network input/output names.
+// Used by infer<Generic>
+struct InOutInfo
+{
+    std::vector<std::string> in_names;
+    std::vector<std::string> out_names;
+};
+
+template <typename OutT>
+class GInferOutputsTyped
+{
+public:
+    GInferOutputsTyped() = default;
+    GInferOutputsTyped(std::shared_ptr<cv::GCall> call)
+        : m_priv(std::make_shared<Priv>(std::move(call)))
+    {
+    }
+
+    OutT at(const std::string& name)
+    {
+        auto it = m_priv->blobs.find(name);
+        if (it == m_priv->blobs.end()) {
+            // FIXME: Avoid modifying GKernel
+            auto shape = cv::detail::GTypeTraits<OutT>::shape;
+            m_priv->call->kernel().outShapes.push_back(shape);
+            m_priv->call->kernel().outCtors.emplace_back(cv::detail::GObtainCtor<OutT>::get());
+            auto out_idx = static_cast<int>(m_priv->blobs.size());
+            it = m_priv->blobs.emplace(name,
+                    cv::detail::Yield<OutT>::yield(*(m_priv->call), out_idx)).first;
+            m_priv->info->out_names.push_back(name);
+        }
+        return it->second;
+    }
+private:
+    struct Priv
+    {
+        Priv(std::shared_ptr<cv::GCall> c)
+            : call(std::move(c)), info(cv::util::any_cast<InOutInfo>(&call->params()))
+        {
+        }
+
+        std::shared_ptr<cv::GCall> call;
+        InOutInfo* info = nullptr;
+        std::unordered_map<std::string, OutT> blobs;
+    };
+
+    std::shared_ptr<Priv> m_priv;
+};
+
+template <typename... Ts>
+class GInferInputsTyped
+{
+public:
+    GInferInputsTyped()
+        : m_priv(std::make_shared<Priv>())
+    {
+    }
+
+    template <typename U>
+    GInferInputsTyped<Ts...>& setInput(const std::string& name, U in)
+    {
+        m_priv->blobs.emplace(std::piecewise_construct,
+                              std::forward_as_tuple(name),
+                              std::forward_as_tuple(in));
+        return *this;
+    }
+
+    using StorageT = cv::util::variant<Ts...>;
+    StorageT& operator[](const std::string& name) {
+        return m_priv->blobs[name];
+    }
+
+    using Map = std::unordered_map<std::string, StorageT>;
+    const Map& getBlobs() const {
+        return m_priv->blobs;
+    }
+
+private:
+    struct Priv
+    {
+        std::unordered_map<std::string, StorageT> blobs;
+    };
+
+    std::shared_ptr<Priv> m_priv;
+};
+
+template<typename InferT>
+std::shared_ptr<cv::GCall> makeCall(const std::string         &tag,
+                                    std::vector<cv::GArg>    &&args,
+                                    std::vector<std::string> &&names,
+                                    cv::GKinds               &&kinds) {
+    auto call = std::make_shared<cv::GCall>(GKernel{
+                InferT::id(),
+                tag,
+                InferT::getOutMeta,
+                {}, // outShape will be filled later
+                std::move(kinds),
+                {}, // outCtors will be filled later
+            });
+
+    call->setArgs(std::move(args));
+    call->params() = cv::detail::InOutInfo{std::move(names), {}};
+
+    return call;
+}
+
+} // namespace detail
+
+// 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>... >;
+};
+
+// 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>;
+};
+
+// InferAPI: Accepts either GMat or GFrame for very individual network's input
+template<class Net, class... Ts>
+struct InferAPI {
+    using type = typename std::enable_if
+        <    detail::valid_infer_types<Ts...>::value
+          && std::tuple_size<typename Net::InArgs>::value == sizeof...(Ts)
+        , std::function<typename Net::Result(Ts...)>
+        >::type;
+};
+
+// InferAPIRoi: Accepts a rectangle and either GMat or GFrame
+template<class Net, class T>
+struct InferAPIRoi {
+    using type = typename std::enable_if
+        <    detail::valid_infer_types<T>::value
+          && std::tuple_size<typename Net::InArgs>::value == 1u
+          , std::function<typename Net::Result(cv::GOpaque<cv::Rect>, T)>
+        >::type;
+};
+
+// InferAPIList: Accepts a list of rectangles and list of GMat/GFrames;
+// crops every input.
+template<class Net, class... Ts>
+struct InferAPIList {
+    using type = typename std::enable_if
+        <    detail::valid_infer_types<Ts...>::value
+          && std::tuple_size<typename Net::InArgs>::value == sizeof...(Ts)
+        , std::function<typename Net::ResultL(cv::GArray<cv::Rect>, Ts...)>
+        >::type;
+};
+
+// APIList2 is also template to allow different calling options
+// (GArray<cv::Rect> vs GArray<cv::GMat> per input)
+template<class Net, typename T, class... Ts>
+struct InferAPIList2 {
+    using type = typename std::enable_if
+        < detail::valid_infer_types<T>::value &&
+          cv::detail::valid_infer2_types< typename Net::InArgs
+                                        , std::tuple<Ts...> >::value,
+          std::function<typename Net::ResultL(T, cv::GArray<Ts>...)>
+        >::type;
+};
+
+// 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 "InferROI" kernel.
+// All notes from "Infer" kernel apply here as well.
+struct GInferROIBase {
+    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
+    }
+};
+
+// 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-list-1"; // Universal stub
+    }
+    static GMetaArgs getOutMeta(const GMetaArgs &, const GArgs &) {
+        return GMetaArgs{};                       // One more universal stub
+    }
+};
+
+// Base "Infer list 2" kernel.
+// All notes from "Infer" kernel apply here as well.
+struct GInferList2Base {
+    static constexpr const char * id() {
+        return "org.opencv.dnn.infer-roi-list-2"; // 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, typename... Args>
+struct GInfer final
+    : public GInferBase
+    , public detail::KernelTypeMedium< GInfer<Net, Args...>
+                                     , typename InferAPI<Net, Args...>::type > {
+    using GInferBase::getOutMeta; // FIXME: name lookup conflict workaround?
+
+    static constexpr const char* tag() { return Net::tag(); }
+};
+
+// A specific roi-inference kernel. API (::on()) is fixed here and
+// verified against Net.
+template<typename Net, typename T>
+struct GInferROI final
+    : public GInferROIBase
+    , public detail::KernelTypeMedium< GInferROI<Net, T>
+                                     , typename InferAPIRoi<Net, T>::type > {
+    using GInferROIBase::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, typename... Args>
+struct GInferList final
+    : public GInferListBase
+    , public detail::KernelTypeMedium< GInferList<Net, Args...>
+                                     , typename InferAPIList<Net, Args...>::type > {
+    using GInferListBase::getOutMeta; // FIXME: name lookup conflict workaround?
+
+    static constexpr const char* tag() { return Net::tag(); }
+};
+
+// An even more generic roi-list inference kernel. API (::on()) is
+// derived from the Net template parameter (see more in infer<>
+// overload).
+// Takes an extra variadic template list to reflect how this network
+// was called (with Rects or GMats as array parameters)
+template<typename Net, typename T, typename... Args>
+struct GInferList2 final
+    : public GInferList2Base
+    , public detail::KernelTypeMedium< GInferList2<Net, T, Args...>
+                                     , typename InferAPIList2<Net, T, Args...>::type > {
+    using GInferList2Base::getOutMeta; // FIXME: name lookup conflict workaround?
+
+    static constexpr const char* tag() { return Net::tag(); }
+};
+
+/**
+ * @brief G-API object used to collect network inputs
+ */
+using GInferInputs = cv::detail::GInferInputsTyped<cv::GMat, cv::GFrame>;
+
+/**
+ * @brief G-API object used to collect the list of network inputs
+ */
+using GInferListInputs = cv::detail::GInferInputsTyped<cv::GArray<cv::GMat>, cv::GArray<cv::Rect>>;
+
+/**
+ * @brief G-API object used to collect network outputs
+ */
+using GInferOutputs = cv::detail::GInferOutputsTyped<cv::GMat>;
+
+/**
+ * @brief G-API object used to collect the list of network outputs
+ */
+using GInferListOutputs = cv::detail::GInferOutputsTyped<cv::GArray<cv::GMat>>;
+
+namespace detail {
+void inline unpackBlobs(const cv::GInferInputs::Map& blobs,
+                        std::vector<cv::GArg>& args,
+                        std::vector<std::string>& names,
+                        cv::GKinds& kinds)
+{
+    for (auto&& p : blobs) {
+        names.emplace_back(p.first);
+        switch (p.second.index()) {
+            case cv::GInferInputs::StorageT::index_of<cv::GMat>():
+                args.emplace_back(cv::util::get<cv::GMat>(p.second));
+                kinds.emplace_back(cv::detail::OpaqueKind::CV_MAT);
+                break;
+            case cv::GInferInputs::StorageT::index_of<cv::GFrame>():
+                args.emplace_back(cv::util::get<cv::GFrame>(p.second));
+                kinds.emplace_back(cv::detail::OpaqueKind::CV_UNKNOWN);
+                break;
+            default:
+                GAPI_Assert(false);
+        }
+    }
+}
+
+template <typename InferType>
+struct InferROITraits;
+
+template <>
+struct InferROITraits<GInferROIBase>
+{
+    using outType = cv::GInferOutputs;
+    using inType  = cv::GOpaque<cv::Rect>;
+};
+
+template <>
+struct InferROITraits<GInferListBase>
+{
+    using outType = cv::GInferListOutputs;
+    using inType  = cv::GArray<cv::Rect>;
+};
+
+template<typename InferType>
+typename InferROITraits<InferType>::outType
+inferGenericROI(const std::string& tag,
+         const typename InferROITraits<InferType>::inType& in,
+         const cv::GInferInputs& inputs)
+{
+    std::vector<cv::GArg> args;
+    std::vector<std::string> names;
+    cv::GKinds kinds;
+
+    args.emplace_back(in);
+    kinds.emplace_back(cv::detail::OpaqueKind::CV_RECT);
+
+    unpackBlobs(inputs.getBlobs(), args, names, kinds);
+
+    auto call = cv::detail::makeCall<InferType>(tag,
+                                                std::move(args),
+                                                std::move(names),
+                                                std::move(kinds));
+
+    return {std::move(call)};
+}
+
+} // namespace detail
+} // 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 response for the specified network (template
+ *     parameter) for the specified region in the source image.
+ *     Currently expects a single-input network only.
+ *
+ * @tparam A network type defined with G_API_NET() macro.
+ * @param in input image where to take ROI from.
+ * @param roi an object describing the region of interest
+ *   in the source image. May be calculated in the same graph dynamically.
+ * @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 appropriate type is returned.
+ * @sa  G_API_NET()
+ */
+template<typename Net, typename T>
+typename Net::Result infer(cv::GOpaque<cv::Rect> roi, T in) {
+    return GInferROI<Net, T>::on(roi, in);
+}
+
+/** @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, Args...>::on(roi, std::forward<Args>(args)...);
+}
+
+/** @brief Calculates responses for the specified network (template
+ *     parameter) for every region in the source image, extended version.
+ *
+ * @tparam A network type defined with G_API_NET() macro.
+ * @param image A source image containing regions of interest
+ * @param args GArray<> objects of cv::Rect or cv::GMat, one per every
+ * network input:
+ * - If a cv::GArray<cv::Rect> is passed, the appropriate
+ *   regions are taken from `image` and preprocessed to this particular
+ *   network input;
+ * - If a cv::GArray<cv::GMat> is passed, the underlying data traited
+ *   as tensor (no automatic preprocessing happen).
+ * @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 T, typename... Args>
+typename Net::ResultL infer2(T image, cv::GArray<Args>... args) {
+    // FIXME: Declared as "2" because in the current form it steals
+    // overloads from the regular infer
+    return GInferList2<Net, T, Args...>::on(image, 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 appropriate type is returned.
+ * @sa  G_API_NET()
+ */
+template<typename Net, typename... Args>
+typename Net::Result infer(Args&&... args) {
+    return GInfer<Net, Args...>::on(std::forward<Args>(args)...);
+}
+
+/**
+ * @brief Generic network type: input and output layers are configured dynamically at runtime
+ *
+ * Unlike the network types defined with G_API_NET macro, this one
+ * doesn't fix number of network inputs and outputs at the compilation stage
+ * thus providing user with an opportunity to program them in runtime.
+ */
+struct Generic { };
+
+/**
+ * @brief Calculates response for generic network
+ *
+ * @param tag a network tag
+ * @param inputs networks's inputs
+ * @return a GInferOutputs
+ */
+template<typename T = Generic> cv::GInferOutputs
+infer(const std::string& tag, const cv::GInferInputs& inputs)
+{
+    std::vector<cv::GArg> args;
+    std::vector<std::string> names;
+    cv::GKinds kinds;
+
+    cv::detail::unpackBlobs(inputs.getBlobs(), args, names, kinds);
+
+    auto call = cv::detail::makeCall<GInferBase>(tag,
+                                                 std::move(args),
+                                                 std::move(names),
+                                                 std::move(kinds));
+
+    return cv::GInferOutputs{std::move(call)};
+}
+
+/** @brief Calculates response for the generic network
+ *     for the specified region in the source image.
+ *     Currently expects a single-input network only.
+ *
+ * @param tag a network tag
+ * @param roi a an object describing the region of interest
+ *   in the source image. May be calculated in the same graph dynamically.
+ * @param inputs networks's inputs
+ * @return a cv::GInferOutputs
+ */
+template<typename T = Generic> cv::GInferOutputs
+infer(const std::string& tag, const cv::GOpaque<cv::Rect>& roi, const cv::GInferInputs& inputs)
+{
+    return cv::detail::inferGenericROI<GInferROIBase>(tag, roi, inputs);
+}
+
+/** @brief Calculates responses for the specified network
+ *     for every region in the source image.
+ *
+ * @param tag a network tag
+ * @param rois a list of rectangles describing regions of interest
+ *   in the source image. Usually an output of object detector or tracker.
+ * @param inputs networks's inputs
+ * @return a cv::GInferListOutputs
+ */
+template<typename T = Generic> cv::GInferListOutputs
+infer(const std::string& tag, const cv::GArray<cv::Rect>& rois, const cv::GInferInputs& inputs)
+{
+    return cv::detail::inferGenericROI<GInferListBase>(tag, rois, inputs);
+}
+
+/** @brief Calculates responses for the specified network
+ *     for every region in the source image, extended version.
+ *
+ * @param tag a network tag
+ * @param in a source image containing regions of interest.
+ * @param inputs networks's inputs
+ * @return a cv::GInferListOutputs
+ */
+template<typename T = Generic, typename Input>
+typename std::enable_if<cv::detail::accepted_infer_types<Input>::value, cv::GInferListOutputs>::type
+infer2(const std::string& tag,
+       const Input& in,
+       const cv::GInferListInputs& inputs)
+{
+    std::vector<cv::GArg> args;
+    std::vector<std::string> names;
+    cv::GKinds kinds;
+
+    args.emplace_back(in);
+    auto k = cv::detail::GOpaqueTraits<Input>::kind;
+    kinds.emplace_back(k);
+
+    for (auto&& p : inputs.getBlobs()) {
+        names.emplace_back(p.first);
+        switch (p.second.index()) {
+            case cv::GInferListInputs::StorageT::index_of<cv::GArray<cv::GMat>>():
+                args.emplace_back(cv::util::get<cv::GArray<cv::GMat>>(p.second));
+                kinds.emplace_back(cv::detail::OpaqueKind::CV_MAT);
+                break;
+            case cv::GInferListInputs::StorageT::index_of<cv::GArray<cv::Rect>>():
+                args.emplace_back(cv::util::get<cv::GArray<cv::Rect>>(p.second));
+                kinds.emplace_back(cv::detail::OpaqueKind::CV_RECT);
+                break;
+            default:
+                GAPI_Assert(false);
+        }
+    }
+
+    auto call = cv::detail::makeCall<GInferList2Base>(tag,
+                                                      std::move(args),
+                                                      std::move(names),
+                                                      std::move(kinds));
+
+    return cv::GInferListOutputs{std::move(call)};
+}
+
+} // 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.
+/// @private
+struct GAPI_EXPORTS_W_SIMPLE GNetParam {
+    std::string tag;     // FIXME: const?
+    GBackend backend;    // Specifies the execution model
+    util::any params;    // Backend-interpreted parameter structure
+};
+
+/** \addtogroup gapi_compile_args
+ * @{
+ */
+/**
+ * @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_W_SIMPLE GNetPackage {
+    GAPI_WRAP GNetPackage() = default;
+    GAPI_WRAP explicit GNetPackage(std::vector<GNetParam> nets);
+    explicit GNetPackage(std::initializer_list<GNetParam> ii);
+    std::vector<GBackend> backends() const;
+    std::vector<GNetParam> networks;
+};
+/** @} gapi_compile_args */
+} // 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)... });
+}
+
+inline cv::gapi::GNetPackage& operator += (      cv::gapi::GNetPackage& lhs,
+                                           const cv::gapi::GNetPackage& rhs) {
+    lhs.networks.reserve(lhs.networks.size() + rhs.networks.size());
+    lhs.networks.insert(lhs.networks.end(), rhs.networks.begin(), rhs.networks.end());
+    return lhs;
+}
+
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_INFER_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/infer/bindings_ie.hpp

@@ -0,0 +1,67 @@
+// 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) 2020 Intel Corporation
+
+#ifndef OPENCV_GAPI_INFER_BINDINGS_IE_HPP
+#define OPENCV_GAPI_INFER_BINDINGS_IE_HPP
+
+#include <opencv2/gapi/util/any.hpp>
+#include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS
+#include <opencv2/gapi/gkernel.hpp>     // GKernelPackage
+#include <opencv2/gapi/infer/ie.hpp>    // Params
+
+#include <string>
+
+namespace cv {
+namespace gapi {
+namespace ie {
+
+// NB: Used by python wrapper
+// This class can be marked as SIMPLE, because it's implemented as pimpl
+class GAPI_EXPORTS_W_SIMPLE PyParams {
+public:
+    GAPI_WRAP
+    PyParams() = default;
+
+    GAPI_WRAP
+    PyParams(const std::string &tag,
+             const std::string &model,
+             const std::string &weights,
+             const std::string &device);
+
+    GAPI_WRAP
+    PyParams(const std::string &tag,
+             const std::string &model,
+             const std::string &device);
+
+    GAPI_WRAP
+    PyParams& constInput(const std::string &layer_name,
+                         const cv::Mat &data,
+                         TraitAs hint = TraitAs::TENSOR);
+
+    GAPI_WRAP
+    PyParams& cfgNumRequests(size_t nireq);
+
+    GBackend      backend() const;
+    std::string   tag()     const;
+    cv::util::any params()  const;
+
+private:
+    std::shared_ptr<Params<cv::gapi::Generic>> m_priv;
+};
+
+GAPI_EXPORTS_W PyParams params(const std::string &tag,
+                               const std::string &model,
+                               const std::string &weights,
+                               const std::string &device);
+
+GAPI_EXPORTS_W PyParams params(const std::string &tag,
+                               const std::string &model,
+                               const std::string &device);
+} // namespace ie
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_INFER_BINDINGS_IE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/infer/ie.hpp

@@ -0,0 +1,453 @@
+// 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-2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_INFER_IE_HPP
+#define OPENCV_GAPI_INFER_IE_HPP
+
+#include <unordered_map>
+#include <unordered_set>
+#include <string>
+#include <array>
+#include <tuple> // tuple, tuple_size
+#include <map>
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/util/any.hpp>
+
+#include <opencv2/core/cvdef.h>     // GAPI_EXPORTS
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+#include <opencv2/gapi/infer.hpp>   // Generic
+
+namespace cv {
+namespace gapi {
+// FIXME: introduce a new sub-namespace for NN?
+
+/**
+ * @brief This namespace contains G-API OpenVINO backend functions,
+ * structures, and symbols.
+ */
+namespace ie {
+
+GAPI_EXPORTS cv::gapi::GBackend backend();
+
+/**
+ * Specifies how G-API and IE should trait input data
+ *
+ * In OpenCV, the same cv::Mat is used to represent both
+ * image and tensor data. Sometimes those are hardly distinguishable,
+ * so this extra parameter is used to give G-API a hint.
+ *
+ * This hint controls how G-API reinterprets the data when converting
+ * it to IE Blob format (and which layout/etc is assigned to this data).
+ */
+enum class TraitAs: int
+{
+    TENSOR, //!< G-API traits an associated cv::Mat as a raw tensor and passes dimensions as-is
+    IMAGE   //!< G-API traits an associated cv::Mat as an image so creates an "image" blob (NCHW/NHWC, etc)
+};
+
+using IEConfig = std::map<std::string, std::string>;
+
+namespace detail {
+struct ParamDesc {
+    std::string model_path;
+    std::string weights_path;
+    std::string device_id;
+
+    std::vector<std::string> input_names;
+    std::vector<std::string> output_names;
+
+    using ConstInput = std::pair<cv::Mat, TraitAs>;
+    std::unordered_map<std::string, ConstInput> const_inputs;
+
+    std::size_t num_in;
+    std::size_t num_out;
+
+    enum class Kind {Load, Import};
+    Kind kind;
+    bool is_generic;
+    IEConfig config;
+
+    std::map<std::string, std::vector<std::size_t>> reshape_table;
+    std::unordered_set<std::string> layer_names_to_reshape;
+
+    // NB: Number of asyncrhonious infer requests
+    size_t nireq;
+
+    // NB: An optional config to setup RemoteContext for IE
+    cv::util::any context_config;
+};
+} // 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 >;
+};
+
+/**
+ * @brief This structure provides functions
+ * that fill inference parameters for "OpenVINO Toolkit" model.
+ */
+template<typename Net> class Params {
+public:
+    /** @brief Class constructor.
+
+    Constructs Params based on model information and specifies default values for other
+    inference description parameters. Model is loaded and compiled using "OpenVINO Toolkit".
+
+    @param model Path to topology IR (.xml file).
+    @param weights Path to weights (.bin file).
+    @param device target device to use.
+    */
+    Params(const std::string &model,
+           const std::string &weights,
+           const std::string &device)
+        : desc{ model, weights, device, {}, {}, {}
+              , std::tuple_size<typename Net::InArgs>::value  // num_in
+              , std::tuple_size<typename Net::OutArgs>::value // num_out
+              , detail::ParamDesc::Kind::Load
+              , false
+              , {}
+              , {}
+              , {}
+              , 1u
+              , {}} {
+    };
+
+    /** @overload
+    Use this constructor to work with pre-compiled network.
+    Model is imported from a pre-compiled blob.
+
+    @param model Path to model.
+    @param device target device to use.
+    */
+    Params(const std::string &model,
+           const std::string &device)
+        : desc{ model, {}, device, {}, {}, {}
+              , std::tuple_size<typename Net::InArgs>::value  // num_in
+              , std::tuple_size<typename Net::OutArgs>::value // num_out
+              , detail::ParamDesc::Kind::Import
+              , false
+              , {}
+              , {}
+              , {}
+              , 1u
+              , {}} {
+    };
+
+    /** @brief Specifies sequence of network input layers names for inference.
+
+    The function is used to associate cv::gapi::infer<> inputs with the model inputs.
+    Number of names has to match the number of network inputs as defined in G_API_NET().
+    In case a network has only single input layer, there is no need to specify name manually.
+
+    @param layer_names std::array<std::string, N> where N is the number of inputs
+    as defined in the @ref G_API_NET. Contains names of input layers.
+    @return reference to this parameter structure.
+    */
+    Params<Net>& cfgInputLayers(const typename PortCfg<Net>::In &layer_names) {
+        desc.input_names.clear();
+        desc.input_names.reserve(layer_names.size());
+        std::copy(layer_names.begin(), layer_names.end(),
+                  std::back_inserter(desc.input_names));
+        return *this;
+    }
+
+    /** @brief Specifies sequence of network output layers names for inference.
+
+    The function is used to associate cv::gapi::infer<> outputs with the model outputs.
+    Number of names has to match the number of network outputs as defined in G_API_NET().
+    In case a network has only single output layer, there is no need to specify name manually.
+
+    @param layer_names std::array<std::string, N> where N is the number of outputs
+    as defined in the @ref G_API_NET. Contains names of output layers.
+    @return reference to this parameter structure.
+    */
+    Params<Net>& cfgOutputLayers(const typename PortCfg<Net>::Out &layer_names) {
+        desc.output_names.clear();
+        desc.output_names.reserve(layer_names.size());
+        std::copy(layer_names.begin(), layer_names.end(),
+                  std::back_inserter(desc.output_names));
+        return *this;
+    }
+
+    /** @brief Specifies a constant input.
+
+    The function is used to set a constant input. This input has to be
+    a preprocessed tensor if its type is TENSOR. Need to provide name of the
+    network layer which will receive provided data.
+
+    @param layer_name Name of network layer.
+    @param data cv::Mat that contains data which will be associated with network layer.
+    @param hint Input type @sa cv::gapi::ie::TraitAs.
+    @return reference to this parameter structure.
+    */
+    Params<Net>& constInput(const std::string &layer_name,
+                            const cv::Mat &data,
+                            TraitAs hint = TraitAs::TENSOR) {
+        desc.const_inputs[layer_name] = {data, hint};
+        return *this;
+    }
+
+    /** @brief Specifies OpenVINO plugin configuration.
+
+    The function is used to set configuration for OpenVINO plugin. Some parameters
+    can be different for each plugin. Please follow https://docs.openvinotoolkit.org/latest/index.html
+    to check information about specific plugin.
+
+    @param cfg Map of pairs: (config parameter name, config parameter value).
+    @return reference to this parameter structure.
+    */
+       Params& pluginConfig(const IEConfig& cfg) {
+        desc.config = cfg;
+        return *this;
+    }
+
+    /** @overload
+    Function with a rvalue parameter.
+
+    @param cfg rvalue map of pairs: (config parameter name, config parameter value).
+    @return reference to this parameter structure.
+    */
+    Params& pluginConfig(IEConfig&& cfg) {
+        desc.config = std::move(cfg);
+        return *this;
+    }
+
+    /** @brief Specifies configuration for RemoteContext in InferenceEngine.
+
+    When RemoteContext is configured the backend imports the networks using the context.
+    It also expects cv::MediaFrames to be actually remote, to operate with blobs via the context.
+
+    @param ctx_cfg cv::util::any value which holds InferenceEngine::ParamMap.
+    @return reference to this parameter structure.
+    */
+    Params& cfgContextParams(const cv::util::any& ctx_cfg) {
+        desc.context_config = ctx_cfg;
+        return *this;
+    }
+
+    /** @overload
+    Function with an rvalue parameter.
+
+    @param ctx_cfg cv::util::any value which holds InferenceEngine::ParamMap.
+    @return reference to this parameter structure.
+    */
+    Params& cfgContextParams(cv::util::any&& ctx_cfg) {
+        desc.context_config = std::move(ctx_cfg);
+        return *this;
+    }
+
+    /** @brief Specifies number of asynchronous inference requests.
+
+    @param nireq Number of inference asynchronous requests.
+    @return reference to this parameter structure.
+    */
+    Params& cfgNumRequests(size_t nireq) {
+        GAPI_Assert(nireq > 0 && "Number of infer requests must be greater than zero!");
+        desc.nireq = nireq;
+        return *this;
+    }
+
+    /** @brief Specifies new input shapes for the network inputs.
+
+    The function is used to specify new input shapes for the network inputs.
+    Follow https://docs.openvinotoolkit.org/latest/classInferenceEngine_1_1networkNetwork.html
+    for additional information.
+
+    @param reshape_table Map of pairs: name of corresponding data and its dimension.
+    @return reference to this parameter structure.
+    */
+    Params<Net>& cfgInputReshape(const std::map<std::string, std::vector<std::size_t>>& reshape_table) {
+        desc.reshape_table = reshape_table;
+        return *this;
+    }
+
+    /** @overload */
+    Params<Net>& cfgInputReshape(std::map<std::string, std::vector<std::size_t>>&& reshape_table) {
+        desc.reshape_table = std::move(reshape_table);
+        return *this;
+    }
+
+    /** @overload
+
+    @param layer_name Name of layer.
+    @param layer_dims New dimensions for this layer.
+    @return reference to this parameter structure.
+    */
+    Params<Net>& cfgInputReshape(const std::string& layer_name, const std::vector<size_t>& layer_dims) {
+        desc.reshape_table.emplace(layer_name, layer_dims);
+        return *this;
+    }
+
+    /** @overload */
+    Params<Net>& cfgInputReshape(std::string&& layer_name, std::vector<size_t>&& layer_dims) {
+        desc.reshape_table.emplace(layer_name, layer_dims);
+        return *this;
+    }
+
+    /** @overload
+
+    @param layer_names set of names of network layers that will be used for network reshape.
+    @return reference to this parameter structure.
+    */
+    Params<Net>& cfgInputReshape(const std::unordered_set<std::string>& layer_names) {
+        desc.layer_names_to_reshape = layer_names;
+        return *this;
+    }
+
+    /** @overload
+
+    @param layer_names rvalue set of the selected layers will be reshaped automatically
+    its input image size.
+    @return reference to this parameter structure.
+    */
+    Params<Net>& cfgInputReshape(std::unordered_set<std::string>&& layer_names) {
+        desc.layer_names_to_reshape = std::move(layer_names);
+        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;
+};
+
+/*
+* @brief This structure provides functions for generic network type that
+* fill inference parameters.
+* @see struct Generic
+*/
+template<>
+class Params<cv::gapi::Generic> {
+public:
+    /** @brief Class constructor.
+
+    Constructs Params based on model information and sets default values for other
+    inference description parameters. Model is loaded and compiled using OpenVINO Toolkit.
+
+    @param tag string tag of the network for which these parameters are intended.
+    @param model path to topology IR (.xml file).
+    @param weights path to weights (.bin file).
+    @param device target device to use.
+    */
+    Params(const std::string &tag,
+           const std::string &model,
+           const std::string &weights,
+           const std::string &device)
+        : desc{ model, weights, device, {}, {}, {}, 0u, 0u,
+                detail::ParamDesc::Kind::Load, true, {}, {}, {}, 1u,
+                {}},
+          m_tag(tag) {
+    };
+
+    /** @overload
+
+    This constructor for pre-compiled networks. Model is imported from pre-compiled
+    blob.
+
+    @param tag string tag of the network for which these parameters are intended.
+    @param model path to model.
+    @param device target device to use.
+    */
+    Params(const std::string &tag,
+           const std::string &model,
+           const std::string &device)
+        : desc{ model, {}, device, {}, {}, {}, 0u, 0u,
+                detail::ParamDesc::Kind::Import, true, {}, {}, {}, 1u,
+                {}},
+          m_tag(tag) {
+    };
+
+    /** @see ie::Params::pluginConfig. */
+    Params& pluginConfig(const IEConfig& cfg) {
+        desc.config = cfg;
+        return *this;
+    }
+
+    /** @overload */
+    Params& pluginConfig(IEConfig&& cfg) {
+        desc.config = std::move(cfg);
+        return *this;
+    }
+
+    /** @see ie::Params::constInput. */
+    Params& constInput(const std::string &layer_name,
+                       const cv::Mat &data,
+                       TraitAs hint = TraitAs::TENSOR) {
+        desc.const_inputs[layer_name] = {data, hint};
+        return *this;
+    }
+
+    /** @see ie::Params::cfgNumRequests. */
+    Params& cfgNumRequests(size_t nireq) {
+        GAPI_Assert(nireq > 0 && "Number of infer requests must be greater than zero!");
+        desc.nireq = nireq;
+        return *this;
+    }
+
+    /** @see ie::Params::cfgInputReshape */
+    Params& cfgInputReshape(const std::map<std::string, std::vector<std::size_t>>&reshape_table) {
+        desc.reshape_table = reshape_table;
+        return *this;
+    }
+
+    /** @overload */
+    Params& cfgInputReshape(std::map<std::string, std::vector<std::size_t>> && reshape_table) {
+        desc.reshape_table = std::move(reshape_table);
+        return *this;
+    }
+
+    /** @overload */
+    Params& cfgInputReshape(std::string && layer_name, std::vector<size_t> && layer_dims) {
+        desc.reshape_table.emplace(layer_name, layer_dims);
+        return *this;
+    }
+
+    /** @overload */
+    Params& cfgInputReshape(const std::string & layer_name, const std::vector<size_t>&layer_dims) {
+        desc.reshape_table.emplace(layer_name, layer_dims);
+        return *this;
+    }
+
+    /** @overload */
+    Params& cfgInputReshape(std::unordered_set<std::string> && layer_names) {
+        desc.layer_names_to_reshape = std::move(layer_names);
+        return *this;
+    }
+
+    /** @overload */
+    Params& cfgInputReshape(const std::unordered_set<std::string>&layer_names) {
+        desc.layer_names_to_reshape = layer_names;
+        return *this;
+    }
+
+    // BEGIN(G-API's network parametrization API)
+    GBackend      backend()    const { return cv::gapi::ie::backend();  }
+    std::string   tag()        const { return m_tag; }
+    cv::util::any params()     const { return { desc }; }
+    // END(G-API's network parametrization API)
+
+protected:
+    detail::ParamDesc desc;
+    std::string m_tag;
+};
+
+} // namespace ie
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_INFER_IE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/infer/onnx.hpp

@@ -0,0 +1,284 @@
+// 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) 2020-2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_INFER_ONNX_HPP
+#define OPENCV_GAPI_INFER_ONNX_HPP
+
+#include <unordered_map>
+#include <string>
+#include <array>
+#include <tuple> // tuple, tuple_size
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/util/any.hpp>
+
+#include <opencv2/core/cvdef.h>     // GAPI_EXPORTS
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+
+namespace cv {
+namespace gapi {
+
+/**
+ * @brief This namespace contains G-API ONNX Runtime backend functions, structures, and symbols.
+ */
+namespace onnx {
+
+GAPI_EXPORTS cv::gapi::GBackend backend();
+
+enum class TraitAs: int {
+    TENSOR, //!< G-API traits an associated cv::Mat as a raw tensor
+            // and passes dimensions as-is
+    IMAGE   //!< G-API traits an associated cv::Mat as an image so
+            // creates an "image" blob (NCHW/NHWC, etc)
+};
+
+using PostProc = std::function<void(const std::unordered_map<std::string, cv::Mat> &,
+                                          std::unordered_map<std::string, cv::Mat> &)>;
+
+namespace detail {
+/**
+* @brief This structure contains description of inference parameters
+* which is specific to ONNX models.
+*/
+struct ParamDesc {
+    std::string model_path; //!< Path to model.
+
+    // 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
+
+    // NB: Here order follows the `Net` API
+    std::vector<std::string> input_names; //!< Names of input network layers.
+    std::vector<std::string> output_names; //!< Names of output network layers.
+
+    using ConstInput = std::pair<cv::Mat, TraitAs>;
+    std::unordered_map<std::string, ConstInput> const_inputs; //!< Map with pair of name of network layer and ConstInput which will be associated with this.
+
+    std::vector<cv::Scalar> mean; //!< Mean values for preprocessing.
+    std::vector<cv::Scalar> stdev; //!< Standard deviation values for preprocessing.
+
+    std::vector<cv::GMatDesc> out_metas; //!< Out meta information about your output (type, dimension).
+    PostProc custom_post_proc; //!< Post processing function.
+
+    std::vector<bool> normalize; //!< Vector of bool values that enabled or disabled normalize of input data.
+
+    std::vector<std::string> names_to_remap; //!< Names of output layers that will be processed in PostProc function.
+};
+} // namespace detail
+
+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 >;
+    using NormCoefs = std::array
+        < cv::Scalar
+        , std::tuple_size<typename Net::InArgs>::value >;
+    using Normalize = std::array
+        < bool
+        , std::tuple_size<typename Net::InArgs>::value >;
+};
+
+/**
+ * Contains description of inference parameters and kit of functions that
+ * fill this parameters.
+ */
+template<typename Net> class Params {
+public:
+    /** @brief Class constructor.
+
+    Constructs Params based on model information and sets default values for other
+    inference description parameters.
+
+    @param model Path to model (.onnx file).
+    */
+    Params(const std::string &model) {
+        desc.model_path = model;
+        desc.num_in  = std::tuple_size<typename Net::InArgs>::value;
+        desc.num_out = std::tuple_size<typename Net::OutArgs>::value;
+    };
+
+    /** @brief Specifies sequence of network input layers names for inference.
+
+    The function is used to associate data of graph inputs with input layers of
+    network topology. Number of names has to match the number of network inputs. If a network
+    has only one input layer, there is no need to call it as the layer is
+    associated with input automatically but this doesn't prevent you from
+    doing it yourself. Count of names has to match to number of network inputs.
+
+    @param layer_names std::array<std::string, N> where N is the number of inputs
+    as defined in the @ref G_API_NET. Contains names of input layers.
+    @return the reference on modified object.
+    */
+    Params<Net>& cfgInputLayers(const typename PortCfg<Net>::In &layer_names) {
+        desc.input_names.assign(layer_names.begin(), layer_names.end());
+        return *this;
+    }
+
+    /** @brief Specifies sequence of output layers names for inference.
+
+     The function is used to associate data of graph outputs with output layers of
+    network topology. If a network has only one output layer, there is no need to call it
+    as the layer is associated with ouput automatically but this doesn't prevent
+    you from doing it yourself. Count of names has to match to number of network
+    outputs or you can set your own output but for this case you have to
+    additionally use @ref cfgPostProc function.
+
+    @param layer_names std::array<std::string, N> where N is the number of outputs
+    as defined in the @ref G_API_NET. Contains names of output layers.
+    @return the reference on modified object.
+    */
+    Params<Net>& cfgOutputLayers(const typename PortCfg<Net>::Out &layer_names) {
+        desc.output_names.assign(layer_names.begin(), layer_names.end());
+        return *this;
+    }
+
+    /** @brief Sets a constant input.
+
+    The function is used to set constant input. This input has to be
+    a prepared tensor since preprocessing is disabled for this case. You should
+    provide name of network layer which will receive provided data.
+
+    @param layer_name Name of network layer.
+    @param data cv::Mat that contains data which will be associated with network layer.
+    @param hint Type of input (TENSOR).
+    @return the reference on modified object.
+    */
+    Params<Net>& constInput(const std::string &layer_name,
+                            const cv::Mat &data,
+                            TraitAs hint = TraitAs::TENSOR) {
+        desc.const_inputs[layer_name] = {data, hint};
+        return *this;
+    }
+
+    /** @brief Specifies mean value and standard deviation for preprocessing.
+
+    The function is used to set mean value and standard deviation for preprocessing
+    of input data.
+
+    @param m std::array<cv::Scalar, N> where N is the number of inputs
+    as defined in the @ref G_API_NET. Contains mean values.
+    @param s std::array<cv::Scalar, N> where N is the number of inputs
+    as defined in the @ref G_API_NET. Contains standard deviation values.
+    @return the reference on modified object.
+    */
+    Params<Net>& cfgMeanStd(const typename PortCfg<Net>::NormCoefs &m,
+                            const typename PortCfg<Net>::NormCoefs &s) {
+        desc.mean.assign(m.begin(), m.end());
+        desc.stdev.assign(s.begin(), s.end());
+        return *this;
+    }
+
+    /** @brief Configures graph output and provides the post processing function from user.
+
+    The function is used when you work with networks with dynamic outputs.
+    Since we can't know dimensions of inference result needs provide them for
+    construction of graph output. This dimensions can differ from inference result.
+    So you have to provide @ref PostProc function that gets information from inference
+    result and fill output which is constructed by dimensions from out_metas.
+
+    @param out_metas Out meta information about your output (type, dimension).
+    @param remap_function Post processing function, which has two parameters. First is onnx
+    result, second is graph output. Both parameters is std::map that contain pair of
+    layer's name and cv::Mat.
+    @return the reference on modified object.
+    */
+    Params<Net>& cfgPostProc(const std::vector<cv::GMatDesc> &out_metas,
+                             const PostProc &remap_function) {
+        desc.out_metas        = out_metas;
+        desc.custom_post_proc = remap_function;
+        return *this;
+    }
+
+    /** @overload
+    Function with a rvalue parameters.
+
+    @param out_metas rvalue out meta information about your output (type, dimension).
+    @param remap_function rvalue post processing function, which has two parameters. First is onnx
+    result, second is graph output. Both parameters is std::map that contain pair of
+    layer's name and cv::Mat.
+    @return the reference on modified object.
+    */
+    Params<Net>& cfgPostProc(std::vector<cv::GMatDesc> &&out_metas,
+                             PostProc &&remap_function) {
+        desc.out_metas        = std::move(out_metas);
+        desc.custom_post_proc = std::move(remap_function);
+        return *this;
+    }
+
+    /** @overload
+    The function has additional parameter names_to_remap. This parameter provides
+    information about output layers which will be used for inference and post
+    processing function.
+
+    @param out_metas Out meta information.
+    @param remap_function Post processing function.
+    @param names_to_remap Names of output layers. network's inference will
+    be done on these layers. Inference's result will be processed in post processing
+    function using these names.
+    @return the reference on modified object.
+    */
+    Params<Net>& cfgPostProc(const std::vector<cv::GMatDesc> &out_metas,
+                             const PostProc &remap_function,
+                             const std::vector<std::string> &names_to_remap) {
+        desc.out_metas        = out_metas;
+        desc.custom_post_proc = remap_function;
+        desc.names_to_remap   = names_to_remap;
+        return *this;
+    }
+
+    /** @overload
+    Function with a rvalue parameters and additional parameter names_to_remap.
+
+    @param out_metas rvalue out meta information.
+    @param remap_function rvalue post processing function.
+    @param names_to_remap rvalue names of output layers. network's inference will
+    be done on these layers. Inference's result will be processed in post processing
+    function using these names.
+    @return the reference on modified object.
+    */
+    Params<Net>& cfgPostProc(std::vector<cv::GMatDesc> &&out_metas,
+                             PostProc &&remap_function,
+                             std::vector<std::string> &&names_to_remap) {
+        desc.out_metas        = std::move(out_metas);
+        desc.custom_post_proc = std::move(remap_function);
+        desc.names_to_remap   = std::move(names_to_remap);
+        return *this;
+    }
+
+    /** @brief Specifies normalize parameter for preprocessing.
+
+    The function is used to set normalize parameter for preprocessing of input data.
+
+    @param normalizations std::array<cv::Scalar, N> where N is the number of inputs
+    as defined in the @ref G_API_NET. Сontains bool values that enabled or disabled
+    normalize of input data.
+    @return the reference on modified object.
+    */
+    Params<Net>& cfgNormalize(const typename PortCfg<Net>::Normalize &normalizations) {
+        desc.normalize.assign(normalizations.begin(), normalizations.end());
+        return *this;
+    }
+
+    // BEGIN(G-API's network parametrization API)
+    GBackend      backend() const { return cv::gapi::onnx::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 onnx
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_INFER_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/infer/parsers.hpp

@@ -0,0 +1,138 @@
+// 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) 2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_PARSERS_HPP
+#define OPENCV_GAPI_PARSERS_HPP
+
+#include <utility> // std::tuple
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+
+namespace cv { namespace gapi {
+namespace nn {
+namespace parsers {
+    using GRects      = GArray<Rect>;
+    using GDetections = std::tuple<GArray<Rect>, GArray<int>>;
+
+    G_TYPED_KERNEL(GParseSSDBL, <GDetections(GMat, GOpaque<Size>, float, int)>,
+                   "org.opencv.nn.parsers.parseSSD_BL") {
+        static std::tuple<GArrayDesc,GArrayDesc> outMeta(const GMatDesc&, const GOpaqueDesc&, float, int) {
+            return std::make_tuple(empty_array_desc(), empty_array_desc());
+        }
+    };
+
+    G_TYPED_KERNEL(GParseSSD, <GRects(GMat, GOpaque<Size>, float, bool, bool)>,
+                   "org.opencv.nn.parsers.parseSSD") {
+        static GArrayDesc outMeta(const GMatDesc&, const GOpaqueDesc&, float, bool, bool) {
+            return empty_array_desc();
+        }
+    };
+
+    G_TYPED_KERNEL(GParseYolo, <GDetections(GMat, GOpaque<Size>, float, float, std::vector<float>)>,
+                   "org.opencv.nn.parsers.parseYolo") {
+        static std::tuple<GArrayDesc, GArrayDesc> outMeta(const GMatDesc&, const GOpaqueDesc&,
+                                                          float, float, const std::vector<float>&) {
+            return std::make_tuple(empty_array_desc(), empty_array_desc());
+        }
+        static const std::vector<float>& defaultAnchors() {
+            static std::vector<float> anchors {
+                0.57273f, 0.677385f, 1.87446f, 2.06253f, 3.33843f, 5.47434f, 7.88282f, 3.52778f, 9.77052f, 9.16828f
+            };
+            return anchors;
+        }
+    };
+} // namespace parsers
+} // namespace nn
+
+/** @brief Parses output of SSD network.
+
+Extracts detection information (box, confidence, label) from SSD output and
+filters it by given confidence and label.
+
+@note Function textual ID is "org.opencv.nn.parsers.parseSSD_BL"
+
+@param in Input CV_32F tensor with {1,1,N,7} dimensions.
+@param inSz Size to project detected boxes to (size of the input image).
+@param confidenceThreshold If confidence of the
+detection is smaller than confidence threshold, detection is rejected.
+@param filterLabel If provided (!= -1), only detections with
+given label will get to the output.
+@return a tuple with a vector of detected boxes and a vector of appropriate labels.
+*/
+GAPI_EXPORTS_W std::tuple<GArray<Rect>, GArray<int>> parseSSD(const GMat& in,
+                                                              const GOpaque<Size>& inSz,
+                                                              const float confidenceThreshold = 0.5f,
+                                                              const int   filterLabel = -1);
+
+/** @brief Parses output of SSD network.
+
+Extracts detection information (box, confidence) from SSD output and
+filters it by given confidence and by going out of bounds.
+
+@note Function textual ID is "org.opencv.nn.parsers.parseSSD"
+
+@param in Input CV_32F tensor with {1,1,N,7} dimensions.
+@param inSz Size to project detected boxes to (size of the input image).
+@param confidenceThreshold If confidence of the
+detection is smaller than confidence threshold, detection is rejected.
+@param alignmentToSquare If provided true, bounding boxes are extended to squares.
+The center of the rectangle remains unchanged, the side of the square is
+the larger side of the rectangle.
+@param filterOutOfBounds If provided true, out-of-frame boxes are filtered.
+@return a vector of detected bounding boxes.
+*/
+GAPI_EXPORTS_W GArray<Rect> parseSSD(const GMat& in,
+                                     const GOpaque<Size>& inSz,
+                                     const float confidenceThreshold,
+                                     const bool alignmentToSquare,
+                                     const bool filterOutOfBounds);
+
+/** @brief Parses output of Yolo network.
+
+Extracts detection information (box, confidence, label) from Yolo output,
+filters it by given confidence and performs non-maximum supression for overlapping boxes.
+
+@note Function textual ID is "org.opencv.nn.parsers.parseYolo"
+
+@param in Input CV_32F tensor with {1,13,13,N} dimensions, N should satisfy:
+\f[\texttt{N} = (\texttt{num_classes} + \texttt{5}) * \texttt{5},\f]
+where num_classes - a number of classes Yolo network was trained with.
+@param inSz Size to project detected boxes to (size of the input image).
+@param confidenceThreshold If confidence of the
+detection is smaller than confidence threshold, detection is rejected.
+@param nmsThreshold Non-maximum supression threshold which controls minimum
+relative box intersection area required for rejecting the box with a smaller confidence.
+If 1.f, nms is not performed and no boxes are rejected.
+@param anchors Anchors Yolo network was trained with.
+@note The default anchor values are specified for YOLO v2 Tiny as described in Intel Open Model Zoo
+<a href="https://github.com/openvinotoolkit/open_model_zoo/blob/master/models/public/yolo-v2-tiny-tf/yolo-v2-tiny-tf.md">documentation</a>.
+@return a tuple with a vector of detected boxes and a vector of appropriate labels.
+*/
+GAPI_EXPORTS_W std::tuple<GArray<Rect>, GArray<int>> parseYolo(const GMat& in,
+                                                               const GOpaque<Size>& inSz,
+                                                               const float confidenceThreshold = 0.5f,
+                                                               const float nmsThreshold = 0.5f,
+                                                               const std::vector<float>& anchors
+                                                                   = nn::parsers::GParseYolo::defaultAnchors());
+
+} // namespace gapi
+} // namespace cv
+
+// Reimport parseSSD & parseYolo under their initial namespace
+namespace cv {
+namespace gapi {
+namespace streaming {
+
+using cv::gapi::parseSSD;
+using cv::gapi::parseYolo;
+
+} // namespace streaming
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_PARSERS_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/media.hpp

@@ -0,0 +1,257 @@
+// 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) 2020 Intel Corporation
+
+#ifndef OPENCV_GAPI_MEDIA_HPP
+#define OPENCV_GAPI_MEDIA_HPP
+
+#include <memory>     // unique_ptr<>, shared_ptr<>
+#include <array>      // array<>
+#include <functional> // function<>
+#include <utility>    // forward<>()
+
+#include <opencv2/gapi/gframe.hpp>
+#include <opencv2/gapi/util/any.hpp>
+
+// Forward declaration
+namespace cv {
+namespace gapi {
+namespace s11n {
+struct IOStream;
+struct IIStream;
+} // namespace s11n
+} // namespace gapi
+} // namespace cv
+
+namespace cv {
+
+/** \addtogroup gapi_data_structures
+ * @{
+ *
+ * @brief Extra G-API data structures used to pass input/output data
+ * to the graph for processing.
+ */
+/**
+ * @brief cv::MediaFrame class represents an image/media frame
+ * obtained from an external source.
+ *
+ * cv::MediaFrame represents image data as specified in
+ * cv::MediaFormat. cv::MediaFrame is designed to be a thin wrapper over some
+ * external memory of buffer; the class itself provides an uniform
+ * interface over such types of memory. cv::MediaFrame wraps data from
+ * a camera driver or from a media codec and provides an abstraction
+ * layer over this memory to G-API. MediaFrame defines a compact interface
+ * to access and manage the underlying data; the implementation is
+ * fully defined by the associated Adapter (which is usually
+ * user-defined).
+ *
+ * @sa cv::RMat
+ */
+class GAPI_EXPORTS MediaFrame {
+public:
+    /// This enum defines different types of cv::MediaFrame provided
+    /// access to the underlying data. Note that different flags can't
+    /// be combined in this version.
+    enum class Access {
+        R, ///< Access data for reading
+        W, ///< Access data for writing
+    };
+    class IAdapter;
+    class View;
+    using AdapterPtr = std::unique_ptr<IAdapter>;
+
+    /**
+     * @brief Constructs an empty MediaFrame
+     *
+     * The constructed object has no any data associated with it.
+     */
+    MediaFrame();
+
+    /**
+     * @brief Constructs a MediaFrame with the given
+     * Adapter. MediaFrame takes ownership over the passed adapter.
+     *
+     * @param p an unique pointer to instance of IAdapter derived class.
+     */
+    explicit MediaFrame(AdapterPtr &&p);
+
+    /**
+     * @overload
+     * @brief Constructs a MediaFrame with the given parameters for
+     * the Adapter. The adapter of type `T` is costructed on the fly.
+     *
+     * @param args list of arguments to construct an adapter of type
+     * `T`.
+     */
+    template<class T, class... Args> static cv::MediaFrame Create(Args&&... args);
+
+    /**
+     * @brief Obtain access to the underlying data with the given
+     * mode.
+     *
+     * Depending on the associated Adapter and the data wrapped, this
+     * method may be cheap (e.g., the underlying memory is local) or
+     * costly (if the underlying memory is external or device
+     * memory).
+     *
+     * @param mode an access mode flag
+     * @return a MediaFrame::View object. The views should be handled
+     * carefully, refer to the MediaFrame::View documentation for details.
+     */
+    View access(Access mode) const;
+
+    /**
+     * @brief Returns a media frame descriptor -- the information
+     * about the media format, dimensions, etc.
+     * @return a cv::GFrameDesc
+     */
+    cv::GFrameDesc desc() const;
+
+    // FIXME: design a better solution
+    // Should be used only if the actual adapter provides implementation
+    /// @private -- exclude from the OpenCV documentation for now.
+    cv::util::any blobParams() const;
+
+    /**
+     * @brief Casts and returns the associated MediaFrame adapter to
+     * the particular adapter type `T`, returns nullptr if the type is
+     * different.
+     *
+     * This method may be useful if the adapter type is known by the
+     * caller, and some lower level access to the memory is required.
+     * Depending on the memory type, it may be more efficient than
+     * access().
+     *
+     * @return a pointer to the adapter object, nullptr if the adapter
+     * type is different.
+     */
+    template<typename T> T* get() const {
+        static_assert(std::is_base_of<IAdapter, T>::value,
+                      "T is not derived from cv::MediaFrame::IAdapter!");
+        auto* adapter = getAdapter();
+        GAPI_Assert(adapter != nullptr);
+        return dynamic_cast<T*>(adapter);
+    }
+
+    /**
+     * @brief Serialize MediaFrame's data to a byte array.
+     *
+     * @note The actual logic is implemented by frame's adapter class.
+     * Does nothing by default.
+     *
+     * @param os Bytestream to store serialized MediaFrame data in.
+     */
+    void serialize(cv::gapi::s11n::IOStream& os) const;
+
+private:
+    struct Priv;
+    std::shared_ptr<Priv> m;
+    IAdapter* getAdapter() const;
+};
+
+template<class T, class... Args>
+inline cv::MediaFrame cv::MediaFrame::Create(Args&&... args) {
+    std::unique_ptr<T> ptr(new T(std::forward<Args>(args)...));
+    return cv::MediaFrame(std::move(ptr));
+}
+
+/**
+ * @brief Provides access to the MediaFrame's underlying data.
+ *
+ * This object contains the necessary information to access the pixel
+ * data of the associated MediaFrame: arrays of pointers and strides
+ * (distance between every plane row, in bytes) for every image
+ * plane, as defined in cv::MediaFormat.
+ * There may be up to four image planes in MediaFrame.
+ *
+ * Depending on the MediaFrame::Access flag passed in
+ * MediaFrame::access(), a MediaFrame::View may be read- or
+ * write-only.
+ *
+ * Depending on the MediaFrame::IAdapter implementation associated
+ * with the parent MediaFrame, writing to memory with
+ * MediaFrame::Access::R flag may have no effect or lead to
+ * undefined behavior. Same applies to reading the memory with
+ * MediaFrame::Access::W flag -- again, depending on the IAdapter
+ * implementation, the host-side buffer the view provides access to
+ * may have no current data stored in (so in-place editing of the
+ * buffer contents may not be possible).
+ *
+ * MediaFrame::View objects must be handled carefully, as an external
+ * resource associated with MediaFrame may be locked for the time the
+ * MediaFrame::View object exists. Obtaining MediaFrame::View should
+ * be seen as "map" and destroying it as "unmap" in the "map/unmap"
+ * idiom (applicable to OpenCL, device memory, remote
+ * memory).
+ *
+ * When a MediaFrame buffer is accessed for writing, and the memory
+ * under MediaFrame::View::Ptrs is altered, the data synchronization
+ * of a host-side and device/remote buffer is not guaranteed until the
+ * MediaFrame::View is destroyed. In other words, the real data on the
+ * device or in a remote target may be updated at the MediaFrame::View
+ * destruction only -- but it depends on the associated
+ * MediaFrame::IAdapter implementation.
+ */
+class GAPI_EXPORTS MediaFrame::View final {
+public:
+    static constexpr const size_t MAX_PLANES = 4;
+    using Ptrs     = std::array<void*, MAX_PLANES>;
+    using Strides  = std::array<std::size_t, MAX_PLANES>; // in bytes
+    using Callback = std::function<void()>;
+
+    /// @private
+    View(Ptrs&& ptrs, Strides&& strs, Callback &&cb = [](){});
+
+    /// @private
+    View(const View&) = delete;
+
+    /// @private
+    View(View&&) = default;
+
+    /// @private
+    View& operator = (const View&) = delete;
+
+    ~View();
+
+    Ptrs    ptr; ///< Array of image plane pointers
+    Strides stride; ///< Array of image plane strides, in bytes.
+
+private:
+    Callback m_cb;
+};
+
+/**
+ * @brief An interface class for MediaFrame data adapters.
+ *
+ * Implement this interface to wrap media data in the MediaFrame. It
+ * makes sense to implement this class if there is a custom
+ * cv::gapi::wip::IStreamSource defined -- in this case, a stream
+ * source can produce MediaFrame objects with this adapter and the
+ * media data may be passed to graph without any copy. For example, a
+ * GStreamer-based stream source can implement an adapter over
+ * `GstBuffer` and G-API will transparently use it in the graph.
+ */
+class GAPI_EXPORTS MediaFrame::IAdapter {
+public:
+    virtual ~IAdapter() = 0;
+    virtual cv::GFrameDesc meta() const = 0;
+    virtual MediaFrame::View access(MediaFrame::Access) = 0;
+    // FIXME: design a better solution
+    // The default implementation does nothing
+    virtual cv::util::any blobParams() const;
+    virtual void serialize(cv::gapi::s11n::IOStream&) {
+        GAPI_Assert(false && "Generic serialize method of MediaFrame::IAdapter does nothing by default. "
+                             "Please, implement it in derived class to properly serialize the object.");
+    }
+    virtual void deserialize(cv::gapi::s11n::IIStream&) {
+        GAPI_Assert(false && "Generic deserialize method of MediaFrame::IAdapter does nothing by default. "
+                             "Please, implement it in derived class to properly deserialize the object.");
+    }
+};
+/** @} */
+
+} //namespace cv
+
+#endif // OPENCV_GAPI_MEDIA_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/ocl/core.hpp

@@ -0,0 +1,27 @@
+// 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_OCL_CORE_API_HPP
+#define OPENCV_GAPI_OCL_CORE_API_HPP
+
+#include <opencv2/core/cvdef.h>     // GAPI_EXPORTS
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+
+namespace cv {
+namespace gapi {
+namespace core {
+namespace ocl {
+
+        GAPI_EXPORTS_W cv::gapi::GKernelPackage kernels();
+
+} // namespace ocl
+} // namespace core
+} // namespace gapi
+} // namespace cv
+
+
+#endif // OPENCV_GAPI_OCL_CORE_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/ocl/goclkernel.hpp

@@ -0,0 +1,249 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GOCLKERNEL_HPP
+#define OPENCV_GAPI_GOCLKERNEL_HPP
+
+#include <vector>
+#include <functional>
+#include <map>
+#include <unordered_map>
+
+#include <opencv2/core/mat.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/garg.hpp>
+
+// FIXME: namespace scheme for backends?
+namespace cv {
+
+namespace gimpl
+{
+    // Forward-declare an internal class
+    class GOCLExecutable;
+} // namespace gimpl
+
+namespace gapi
+{
+/**
+ * @brief This namespace contains G-API OpenCL backend functions, structures, and symbols.
+ */
+namespace ocl
+{
+    /**
+     * \addtogroup gapi_std_backends G-API Standard Backends
+     * @{
+     */
+    /**
+     * @brief Get a reference to OCL backend.
+     *
+     * At the moment, the OCL backend is built atop of OpenCV
+     * "Transparent API" (T-API), see cv::UMat for details.
+     *
+     * @sa gapi_std_backends
+     */
+    GAPI_EXPORTS cv::gapi::GBackend backend();
+    /** @} */
+} // namespace ocl
+} // namespace gapi
+
+
+// Represents arguments which are passed to a wrapped OCL function
+// FIXME: put into detail?
+class GAPI_EXPORTS GOCLContext
+{
+public:
+    // Generic accessor API
+    template<typename T>
+    const T& inArg(int input) { return m_args.at(input).get<T>(); }
+
+    // Syntax sugar
+    const cv::UMat&  inMat(int input);
+    cv::UMat&  outMatR(int output); // FIXME: Avoid cv::Mat m = ctx.outMatR()
+
+    const cv::Scalar& inVal(int input);
+    cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR()
+    template<typename T> std::vector<T>& outVecR(int output) // FIXME: the same issue
+    {
+        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;
+    std::unordered_map<std::size_t, GRunArgP> m_results;
+
+
+    friend class gimpl::GOCLExecutable;
+};
+
+class GAPI_EXPORTS GOCLKernel
+{
+public:
+    // This function is kernel's execution entry point (does the processing work)
+    using F = std::function<void(GOCLContext &)>;
+
+    GOCLKernel();
+    explicit GOCLKernel(const F& f);
+
+    void apply(GOCLContext &ctx);
+
+protected:
+    F m_f;
+};
+
+// FIXME: This is an ugly ad-hoc implementation. TODO: refactor
+
+namespace detail
+{
+template<class T> struct ocl_get_in;
+template<> struct ocl_get_in<cv::GMat>
+{
+    static cv::UMat    get(GOCLContext &ctx, int idx) { return ctx.inMat(idx); }
+};
+template<> struct ocl_get_in<cv::GScalar>
+{
+    static cv::Scalar get(GOCLContext &ctx, int idx) { return ctx.inVal(idx); }
+};
+template<typename U> struct ocl_get_in<cv::GArray<U> >
+{
+    static const std::vector<U>& get(GOCLContext &ctx, int idx) { return ctx.inArg<VectorRef>(idx).rref<U>(); }
+};
+template<typename U> struct ocl_get_in<cv::GOpaque<U> >
+{
+    static const U& get(GOCLContext &ctx, int idx) { return ctx.inArg<OpaqueRef>(idx).rref<U>(); }
+};
+template<class T> struct ocl_get_in
+{
+    static T get(GOCLContext &ctx, int idx) { return ctx.inArg<T>(idx); }
+};
+
+struct tracked_cv_umat{
+    //TODO Think if T - API could reallocate UMat to a proper size - how do we handle this ?
+    //tracked_cv_umat(cv::UMat& m) : r{(m)}, original_data{m.getMat(ACCESS_RW).data} {}
+    tracked_cv_umat(cv::UMat& m) : r(m), original_data{ nullptr } {}
+    cv::UMat &r; // FIXME: It was a value (not a reference) before.
+                 // Actually OCL backend should allocate its internal data!
+    uchar* original_data;
+
+    operator cv::UMat& (){ return r;}
+    void validate() const{
+        //if (r.getMat(ACCESS_RW).data != original_data)
+        //{
+        //    util::throw_error
+        //        (std::logic_error
+        //         ("OpenCV kernel output parameter was reallocated. \n"
+        //          "Incorrect meta data was provided ?"));
+        //}
+
+    }
+};
+
+template<typename... Outputs>
+void postprocess_ocl(Outputs&... outs)
+{
+    struct
+    {
+        void operator()(tracked_cv_umat* bm) { bm->validate(); }
+        void operator()(...) {                  }
+
+    } validate;
+    //dummy array to unfold parameter pack
+    int dummy[] = { 0, (validate(&outs), 0)... };
+    cv::util::suppress_unused_warning(dummy);
+}
+
+template<class T> struct ocl_get_out;
+template<> struct ocl_get_out<cv::GMat>
+{
+    static tracked_cv_umat get(GOCLContext &ctx, int idx)
+    {
+        auto& r = ctx.outMatR(idx);
+        return{ r };
+    }
+};
+template<> struct ocl_get_out<cv::GScalar>
+{
+    static cv::Scalar& get(GOCLContext &ctx, int idx)
+    {
+        return ctx.outValR(idx);
+    }
+};
+template<typename U> struct ocl_get_out<cv::GArray<U> >
+{
+    static std::vector<U>& get(GOCLContext &ctx, int idx) { return ctx.outVecR<U>(idx);  }
+};
+template<typename U> struct ocl_get_out<cv::GOpaque<U> >
+{
+    static U& get(GOCLContext &ctx, int idx) { return ctx.outOpaqueR<U>(idx);  }
+};
+
+template<typename, typename, typename>
+struct OCLCallHelper;
+
+// FIXME: probably can be simplified with std::apply or analogue.
+template<typename Impl, typename... Ins, typename... Outs>
+struct OCLCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...> >
+{
+    template<typename... Inputs>
+    struct call_and_postprocess
+    {
+        template<typename... Outputs>
+        static void call(Inputs&&... ins, Outputs&&... outs)
+        {
+            //not using a std::forward on outs is deliberate in order to
+            //cause compilation error, by trying to bind rvalue references to lvalue references
+            Impl::run(std::forward<Inputs>(ins)..., outs...);
+
+            postprocess_ocl(outs...);
+        }
+    };
+
+    template<int... IIs, int... OIs>
+    static void call_impl(GOCLContext &ctx, detail::Seq<IIs...>, detail::Seq<OIs...>)
+    {
+        //TODO: Make sure that OpenCV kernels do not reallocate memory for output parameters
+        //by comparing it's state (data ptr) before and after the call.
+        //Convert own::Scalar to cv::Scalar before call kernel and run kernel
+        //convert cv::Scalar to own::Scalar after call kernel and write back results
+        call_and_postprocess<decltype(ocl_get_in<Ins>::get(ctx, IIs))...>::call(ocl_get_in<Ins>::get(ctx, IIs)..., ocl_get_out<Outs>::get(ctx, OIs)...);
+    }
+
+    static void call(GOCLContext &ctx)
+    {
+        call_impl(ctx,
+            typename detail::MkSeq<sizeof...(Ins)>::type(),
+            typename detail::MkSeq<sizeof...(Outs)>::type());
+    }
+};
+
+} // namespace detail
+
+template<class Impl, class K>
+class GOCLKernelImpl: public cv::detail::OCLCallHelper<Impl, typename K::InArgs, typename K::OutArgs>,
+                      public cv::detail::KernelTag
+{
+    using P = detail::OCLCallHelper<Impl, typename K::InArgs, typename K::OutArgs>;
+
+public:
+    using API = K;
+
+    static cv::gapi::GBackend backend()  { return cv::gapi::ocl::backend(); }
+    static cv::GOCLKernel     kernel()   { return GOCLKernel(&P::call);     }
+};
+
+#define GAPI_OCL_KERNEL(Name, API) struct Name: public cv::GOCLKernelImpl<Name, API>
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GOCLKERNEL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/ocl/imgproc.hpp

@@ -0,0 +1,27 @@
+// 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_OCL_IMGPROC_API_HPP
+#define OPENCV_GAPI_OCL_IMGPROC_API_HPP
+
+#include <opencv2/core/cvdef.h>     // GAPI_EXPORTS
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+
+namespace cv {
+namespace gapi {
+namespace imgproc {
+namespace ocl {
+
+    GAPI_EXPORTS GKernelPackage kernels();
+
+} // namespace ocl
+} // namespace imgproc
+} // namespace gapi
+} // namespace cv
+
+
+#endif // OPENCV_GAPI_OCL_IMGPROC_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/opencv_includes.hpp

@@ -0,0 +1,33 @@
+// 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_OPENCV_INCLUDES_HPP
+#define OPENCV_GAPI_OPENCV_INCLUDES_HPP
+
+#if !defined(GAPI_STANDALONE)
+#  include <opencv2/core/mat.hpp>
+#  include <opencv2/core/cvdef.h>
+#  include <opencv2/core/types.hpp>
+#  include <opencv2/core/base.hpp>
+#else   // Without OpenCV
+#  include <opencv2/gapi/own/cvdefs.hpp>
+#  include <opencv2/gapi/own/types.hpp>  // cv::gapi::own::Rect/Size/Point
+#  include <opencv2/gapi/own/scalar.hpp> // cv::gapi::own::Scalar
+#  include <opencv2/gapi/own/mat.hpp>
+// replacement of cv's structures:
+namespace cv {
+    using Rect    = gapi::own::Rect;
+    using Size    = gapi::own::Size;
+    using Point   = gapi::own::Point;
+    using Point2f = gapi::own::Point2f;
+    using Scalar  = gapi::own::Scalar;
+    using Mat     = gapi::own::Mat;
+}  // namespace cv
+#endif // !defined(GAPI_STANDALONE)
+
+#endif // OPENCV_GAPI_OPENCV_INCLUDES_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/operators.hpp

@@ -0,0 +1,70 @@
+// 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_OPERATORS_HPP
+#define OPENCV_GAPI_OPERATORS_HPP
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/gscalar.hpp>
+
+namespace cv
+{
+GAPI_EXPORTS cv::GMat operator+(const cv::GMat&    lhs, const cv::GMat&    rhs);
+
+GAPI_EXPORTS cv::GMat operator+(const cv::GMat&    lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator+(const cv::GScalar& lhs, const cv::GMat&    rhs);
+
+GAPI_EXPORTS cv::GMat operator-(const cv::GMat&    lhs, const cv::GMat&    rhs);
+
+GAPI_EXPORTS cv::GMat operator-(const cv::GMat&    lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator-(const cv::GScalar& lhs, const cv::GMat&    rhs);
+
+GAPI_EXPORTS cv::GMat operator*(const cv::GMat&    lhs, float              rhs);
+GAPI_EXPORTS cv::GMat operator*(float              lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator*(const cv::GMat&    lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator*(const cv::GScalar& lhs, const cv::GMat&    rhs);
+
+GAPI_EXPORTS cv::GMat operator/(const cv::GMat&    lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator/(const cv::GScalar& lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator/(const cv::GMat&    lhs, const cv::GMat&    rhs);
+
+GAPI_EXPORTS cv::GMat operator&(const cv::GMat&    lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator|(const cv::GMat&    lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator^(const cv::GMat&    lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator~(const cv::GMat&    lhs);
+
+GAPI_EXPORTS cv::GMat operator&(const cv::GScalar& lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator|(const cv::GScalar& lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator^(const cv::GScalar& lhs, const cv::GMat&    rhs);
+
+GAPI_EXPORTS cv::GMat operator&(const cv::GMat& lhs, const cv::GScalar&    rhs);
+GAPI_EXPORTS cv::GMat operator|(const cv::GMat& lhs, const cv::GScalar&    rhs);
+GAPI_EXPORTS cv::GMat operator^(const cv::GMat& lhs, const cv::GScalar&    rhs);
+
+GAPI_EXPORTS cv::GMat operator>(const cv::GMat&    lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator>=(const cv::GMat&   lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator<(const cv::GMat&    lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator<=(const cv::GMat&   lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator==(const cv::GMat&   lhs, const cv::GMat&    rhs);
+GAPI_EXPORTS cv::GMat operator!=(const cv::GMat&   lhs, const cv::GMat&    rhs);
+
+GAPI_EXPORTS cv::GMat operator>(const cv::GMat&    lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator>=(const cv::GMat&   lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator<(const cv::GMat&    lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator<=(const cv::GMat&   lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator==(const cv::GMat&   lhs, const cv::GScalar& rhs);
+GAPI_EXPORTS cv::GMat operator!=(const cv::GMat&   lhs, const cv::GScalar& rhs);
+
+GAPI_EXPORTS cv::GMat operator>(const cv::GScalar&    lhs, const cv::GMat& rhs);
+GAPI_EXPORTS cv::GMat operator>=(const cv::GScalar&   lhs, const cv::GMat& rhs);
+GAPI_EXPORTS cv::GMat operator<(const cv::GScalar&    lhs, const cv::GMat& rhs);
+GAPI_EXPORTS cv::GMat operator<=(const cv::GScalar&   lhs, const cv::GMat& rhs);
+GAPI_EXPORTS cv::GMat operator==(const cv::GScalar&   lhs, const cv::GMat& rhs);
+GAPI_EXPORTS cv::GMat operator!=(const cv::GScalar&   lhs, const cv::GMat& rhs);
+} // cv
+
+#endif // OPENCV_GAPI_OPERATORS_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/own/assert.hpp

@@ -0,0 +1,55 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_OWN_ASSERT_HPP
+#define OPENCV_GAPI_OWN_ASSERT_HPP
+
+#include <opencv2/gapi/util/compiler_hints.hpp>
+
+#define GAPI_DbgAssertNoOp(expr) {                  \
+    constexpr bool _assert_tmp = false && (expr);   \
+    cv::util::suppress_unused_warning(_assert_tmp); \
+}
+
+#if !defined(GAPI_STANDALONE)
+#include <opencv2/core/base.hpp>
+#define GAPI_Assert CV_Assert
+
+#if defined _DEBUG || defined CV_STATIC_ANALYSIS
+#  define GAPI_DbgAssert CV_DbgAssert
+#else
+#  define GAPI_DbgAssert(expr) GAPI_DbgAssertNoOp(expr)
+#endif
+
+#else
+#include <stdexcept>
+#include <sstream>
+#include <opencv2/gapi/util/throw.hpp>
+
+namespace detail
+{
+    [[noreturn]] inline void assert_abort(const char* str, int line, const char* file, const char* func)
+    {
+        std::stringstream ss;
+        ss << file << ":" << line << ": Assertion " << str << " in function " << func << " failed\n";
+        cv::util::throw_error(std::logic_error(ss.str()));
+    }
+}
+
+#define GAPI_Assert(expr) \
+{ if (!(expr)) ::detail::assert_abort(#expr, __LINE__, __FILE__, __func__); }
+
+
+#ifdef NDEBUG
+#  define GAPI_DbgAssert(expr) GAPI_DbgAssertNoOp(expr)
+#else
+#  define GAPI_DbgAssert(expr) GAPI_Assert(expr)
+#endif
+
+#endif // GAPI_STANDALONE
+
+#endif // OPENCV_GAPI_OWN_ASSERT_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/own/convert.hpp

@@ -0,0 +1,55 @@
+// 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_OWN_CONVERT_HPP
+#define OPENCV_GAPI_OWN_CONVERT_HPP
+
+#if !defined(GAPI_STANDALONE)
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/own/mat.hpp>
+
+namespace cv
+{
+    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};
+    };
+
+namespace gapi
+{
+namespace own
+{
+
+    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;
+
+} // namespace own
+} // namespace gapi
+} // namespace cv
+
+#endif // !defined(GAPI_STANDALONE)
+
+#endif // OPENCV_GAPI_OWN_CONVERT_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/own/cvdefs.hpp

@@ -0,0 +1,149 @@
+// 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_CV_DEFS_HPP
+#define OPENCV_GAPI_CV_DEFS_HPP
+
+#if defined(GAPI_STANDALONE)
+// Simulate OpenCV definitions taken from various
+// OpenCV interface headers if G-API is built in a
+// standalone mode.
+
+// interface.h:
+
+typedef unsigned char uchar;
+typedef          char schar;
+
+typedef unsigned short ushort;
+
+#define CV_CN_MAX     512
+#define CV_CN_SHIFT   3
+#define CV_DEPTH_MAX  (1 << CV_CN_SHIFT)
+
+
+#define CV_8U   0
+#define CV_8S   1
+#define CV_16U  2
+#define CV_16S  3
+#define CV_32S  4
+#define CV_32F  5
+#define CV_64F  6
+#define CV_USRTYPE1 7
+
+#define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)
+#define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)
+
+#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
+#define CV_MAKE_TYPE CV_MAKETYPE
+
+#define CV_8UC1 CV_MAKETYPE(CV_8U,1)
+#define CV_8UC2 CV_MAKETYPE(CV_8U,2)
+#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
+#define CV_8UC4 CV_MAKETYPE(CV_8U,4)
+#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))
+
+#define CV_8SC1 CV_MAKETYPE(CV_8S,1)
+#define CV_8SC2 CV_MAKETYPE(CV_8S,2)
+#define CV_8SC3 CV_MAKETYPE(CV_8S,3)
+#define CV_8SC4 CV_MAKETYPE(CV_8S,4)
+#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))
+
+#define CV_16UC1 CV_MAKETYPE(CV_16U,1)
+#define CV_16UC2 CV_MAKETYPE(CV_16U,2)
+#define CV_16UC3 CV_MAKETYPE(CV_16U,3)
+#define CV_16UC4 CV_MAKETYPE(CV_16U,4)
+#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))
+
+#define CV_16SC1 CV_MAKETYPE(CV_16S,1)
+#define CV_16SC2 CV_MAKETYPE(CV_16S,2)
+#define CV_16SC3 CV_MAKETYPE(CV_16S,3)
+#define CV_16SC4 CV_MAKETYPE(CV_16S,4)
+#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))
+
+#define CV_32SC1 CV_MAKETYPE(CV_32S,1)
+#define CV_32SC2 CV_MAKETYPE(CV_32S,2)
+#define CV_32SC3 CV_MAKETYPE(CV_32S,3)
+#define CV_32SC4 CV_MAKETYPE(CV_32S,4)
+#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))
+
+#define CV_32FC1 CV_MAKETYPE(CV_32F,1)
+#define CV_32FC2 CV_MAKETYPE(CV_32F,2)
+#define CV_32FC3 CV_MAKETYPE(CV_32F,3)
+#define CV_32FC4 CV_MAKETYPE(CV_32F,4)
+#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))
+
+#define CV_64FC1 CV_MAKETYPE(CV_64F,1)
+#define CV_64FC2 CV_MAKETYPE(CV_64F,2)
+#define CV_64FC3 CV_MAKETYPE(CV_64F,3)
+#define CV_64FC4 CV_MAKETYPE(CV_64F,4)
+#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))
+
+// cvdef.h:
+
+#define CV_MAT_CN_MASK          ((CV_CN_MAX - 1) << CV_CN_SHIFT)
+#define CV_MAT_CN(flags)        ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
+#define CV_MAT_TYPE_MASK        (CV_DEPTH_MAX*CV_CN_MAX - 1)
+#define CV_MAT_TYPE(flags)      ((flags) & CV_MAT_TYPE_MASK)
+#define CV_MAT_CONT_FLAG_SHIFT  14
+#define CV_MAT_CONT_FLAG        (1 << CV_MAT_CONT_FLAG_SHIFT)
+#define CV_IS_MAT_CONT(flags)   ((flags) & CV_MAT_CONT_FLAG)
+#define CV_IS_CONT_MAT          CV_IS_MAT_CONT
+#define CV_SUBMAT_FLAG_SHIFT    15
+#define CV_SUBMAT_FLAG          (1 << CV_SUBMAT_FLAG_SHIFT)
+#define CV_IS_SUBMAT(flags)     ((flags) & CV_MAT_SUBMAT_FLAG)
+
+///** Size of each channel item,
+//   0x8442211 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */
+//#define CV_ELEM_SIZE1(type) \
+//    ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15)
+
+#define CV_MAT_TYPE(flags)      ((flags) & CV_MAT_TYPE_MASK)
+
+/** 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */
+#define CV_ELEM_SIZE(type) \
+    (CV_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> CV_MAT_DEPTH(type)*2) & 3))
+
+#ifndef CV_OVERRIDE
+#  define CV_OVERRIDE override
+#endif
+
+// base.h:
+namespace cv
+{
+enum BorderTypes {
+    BORDER_CONSTANT    = 0, //!< `iiiiii|abcdefgh|iiiiiii`  with some specified `i`
+    BORDER_REPLICATE   = 1, //!< `aaaaaa|abcdefgh|hhhhhhh`
+    BORDER_REFLECT     = 2, //!< `fedcba|abcdefgh|hgfedcb`
+    BORDER_WRAP        = 3, //!< `cdefgh|abcdefgh|abcdefg`
+    BORDER_REFLECT_101 = 4, //!< `gfedcb|abcdefgh|gfedcba`
+    BORDER_TRANSPARENT = 5, //!< `uvwxyz|abcdefgh|ijklmno`
+
+    BORDER_REFLECT101  = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101
+    BORDER_DEFAULT     = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101
+    BORDER_ISOLATED    = 16 //!< do not look outside of ROI
+};
+// imgproc.hpp:
+enum InterpolationFlags{
+    INTER_NEAREST        = 0,
+    INTER_LINEAR         = 1,
+    INTER_CUBIC          = 2,
+    INTER_AREA           = 3,
+    INTER_LANCZOS4       = 4,
+    INTER_LINEAR_EXACT   = 5,
+    INTER_MAX            = 7,
+};
+} // namespace cv
+
+static inline int cvFloor( double value )
+{
+    int i = (int)value;
+    return i - (i > value);
+}
+
+#endif //  defined(GAPI_STANDALONE)
+
+#endif //  OPENCV_GAPI_CV_DEFS_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/own/exports.hpp

@@ -0,0 +1,42 @@
+// 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_OWN_TYPES_HPP
+#define OPENCV_GAPI_OWN_TYPES_HPP
+
+#   if defined(__OPENCV_BUILD)
+#       include <opencv2/core/base.hpp>
+#       define GAPI_EXPORTS CV_EXPORTS
+        /* special informative macros for wrapper generators */
+#       define GAPI_PROP CV_PROP
+#       define GAPI_PROP_RW CV_PROP_RW
+#       define GAPI_WRAP CV_WRAP
+#       define GAPI_EXPORTS_W_SIMPLE CV_EXPORTS_W_SIMPLE
+#       define GAPI_EXPORTS_W CV_EXPORTS_W
+#   else
+#       define GAPI_PROP
+#       define GAPI_PROP_RW
+#       define GAPI_WRAP
+#       define GAPI_EXPORTS
+#       define GAPI_EXPORTS_W_SIMPLE
+#       define GAPI_EXPORTS_W
+
+#if 0  // Note: the following version currently is not needed for non-OpenCV build
+#       if defined _WIN32
+#           define GAPI_EXPORTS __declspec(dllexport)
+#       elif defined __GNUC__ && __GNUC__ >= 4
+#           define GAPI_EXPORTS __attribute__ ((visibility ("default")))
+#       endif
+
+#       ifndef GAPI_EXPORTS
+#           define GAPI_EXPORTS
+#       endif
+#endif
+
+#   endif
+
+#endif // OPENCV_GAPI_OWN_TYPES_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/own/mat.hpp

@@ -0,0 +1,354 @@
+// 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_OWN_MAT_HPP
+#define OPENCV_GAPI_OWN_MAT_HPP
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/own/types.hpp>
+#include <opencv2/gapi/own/scalar.hpp>
+#include <opencv2/gapi/own/saturate.hpp>
+#include <opencv2/gapi/own/assert.hpp>
+
+#include <memory>                   //std::shared_ptr
+#include <cstring>                  //std::memcpy
+#include <numeric>                  //std::accumulate
+#include <vector>
+#include <opencv2/gapi/util/throw.hpp>
+
+namespace cv { namespace gapi { namespace own {
+    namespace detail {
+        template <typename T, unsigned char channels>
+        void assign_row(void* ptr, int cols, Scalar const& s)
+        {
+            auto p = static_cast<T*>(ptr);
+            for (int c = 0; c < cols; c++)
+            {
+                for (int ch = 0; ch < channels; ch++)
+                {
+                    p[c * channels + ch] = saturate<T>(s[ch], roundd);
+                }
+            }
+        }
+
+        inline size_t default_step(int type, int cols)
+        {
+            return CV_ELEM_SIZE(type) * cols;
+        }
+        //Matrix header, i.e. fields that are unique to each Mat object.
+        //Devoted class is needed to implement custom behavior on move (erasing state of moved from object)
+        struct MatHeader{
+            enum { AUTO_STEP = 0};
+            enum { TYPE_MASK = 0x00000FFF  };
+
+            MatHeader() = default;
+
+            MatHeader(int _rows, int _cols, int type, void* _data, size_t _step)
+            : 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
+            {
+                MatHeader empty; //give it a name to call copy(not move) assignment below
+                src = empty;
+            }
+            MatHeader& operator=(const MatHeader& ) = default;
+            MatHeader& operator=(MatHeader&& src)
+            {
+                *this = src; //calling a copy assignment here, not move one
+                MatHeader empty; //give it a name to call copy(not move) assignment below
+                src = empty;
+                return *this;
+            }
+            /*! includes several bit-fields:
+                 - depth
+                 - number of channels
+             */
+            int flags = 0;
+
+            //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
+            int rows = 0, cols = 0;
+            //! 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:
+
+        Mat() = default;
+
+        /** @overload
+        @param _rows Number of rows in a 2D array.
+        @param _cols Number of columns in a 2D array.
+        @param _type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or
+        CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices.
+        @param _data Pointer to the user data. Matrix constructors that take data and step parameters do not
+        allocate matrix data. Instead, they just initialize the matrix header that points to the specified
+        data, which means that no data is copied. This operation is very efficient and can be used to
+        process external data using OpenCV functions. The external data is not automatically deallocated, so
+        you should take care of it.
+        @param _step Number of bytes each matrix row occupies. The value should include the padding bytes at
+        the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed
+        and the actual step is calculated as cols*elemSize(). See Mat::elemSize.
+        */
+        Mat(int _rows, int _cols, int _type, void* _data, size_t _step = AUTO_STEP)
+        : 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)
+        {
+           rows = roi.height;
+           cols = roi.width;
+           data = ptr(roi.y, roi.x);
+        }
+
+        Mat(Mat const& ) = default;
+        Mat(Mat&& ) = default;
+
+        Mat& operator=(Mat const& ) = default;
+        Mat& operator=(Mat&& ) = default;
+
+        /** @brief Sets all or some of the array elements to the specified value.
+        @param s Assigned scalar converted to the actual array type.
+        */
+        Mat& operator = (const Scalar& s)
+        {
+            constexpr unsigned max_channels = 4; //Scalar can't fit more than 4
+            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>}
+            static constexpr func_p_t func_tbl[][max_channels] = {
+                    TABLE_ENTRY(uchar),
+                    TABLE_ENTRY(schar),
+                    TABLE_ENTRY(ushort),
+                    TABLE_ENTRY(short),
+                    TABLE_ENTRY(int),
+                    TABLE_ENTRY(float),
+                    TABLE_ENTRY(double)
+            };
+            #undef TABLE_ENTRY
+
+            static_assert(CV_8U == 0 && CV_8S == 1  && CV_16U == 2 && CV_16S == 3
+                       && CV_32S == 4 && CV_32F == 5 && CV_64F == 6,
+                       "OCV type ids used as indexes to array, thus exact numbers are important!"
+            );
+
+            const auto depth = static_cast<unsigned int>(this->depth());
+            GAPI_Assert(depth < sizeof(func_tbl)/sizeof(func_tbl[0]));
+
+            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][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;
+        }
+
+        /** @brief Returns the matrix element size in bytes.
+
+        The method returns the matrix element size in bytes. For example, if the matrix type is CV_16SC3 ,
+        the method returns 3\*sizeof(short) or 6.
+         */
+        size_t elemSize() const
+        {
+            return CV_ELEM_SIZE(type());
+        }
+        /** @brief Returns the type of a matrix element.
+
+        The method returns a matrix element type. This is an identifier compatible with the CvMat type
+        system, like CV_16SC3 or 16-bit signed 3-channel array, and so on.
+         */
+        int type() const            {return CV_MAT_TYPE(flags);}
+
+        /** @brief Returns the depth of a matrix element.
+
+        The method returns the identifier of the matrix element depth (the type of each individual channel).
+        For example, for a 16-bit signed element array, the method returns CV_16S . A complete list of
+        matrix types contains the following values:
+        -   CV_8U - 8-bit unsigned integers ( 0..255 )
+        -   CV_8S - 8-bit signed integers ( -128..127 )
+        -   CV_16U - 16-bit unsigned integers ( 0..65535 )
+        -   CV_16S - 16-bit signed integers ( -32768..32767 )
+        -   CV_32S - 32-bit signed integers ( -2147483648..2147483647 )
+        -   CV_32F - 32-bit floating-point numbers ( -FLT_MAX..FLT_MAX, INF, NAN )
+        -   CV_64F - 64-bit floating-point numbers ( -DBL_MAX..DBL_MAX, INF, NAN )
+         */
+        int depth() const           {return CV_MAT_DEPTH(flags);}
+
+        /** @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 dims.empty() ? CV_MAT_CN(flags) : -1;}
+
+        /**
+        @param _rows New number of rows.
+        @param _cols New number of columns.
+        @param _type New matrix type.
+         */
+        void create(int _rows, int _cols, int _type)
+        {
+            create(Size{_cols, _rows}, _type);
+        }
+        /** @overload
+        @param _size Alternative new matrix size specification: Size(cols, rows)
+        @param _type New matrix type.
+        */
+        void create(Size _size, int _type)
+        {
+            GAPI_Assert(_size.height >= 0 && _size.width >= 0);
+            if (_size != Size{cols, rows} )
+            {
+                Mat tmp{_size.height, _size.width, _type, nullptr};
+                tmp.memory.reset(new uchar[ tmp.step * tmp.rows], [](uchar * p){delete[] p;});
+                tmp.data = tmp.memory.get();
+
+                *this = std::move(tmp);
+            }
+        }
+
+        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 Creates a full copy of the matrix and the underlying data.
+
+        The method creates a full copy of the matrix. The original step[] is not taken into account.
+        So, the copy has a continuous buffer occupying total() * elemSize() bytes.
+         */
+        Mat clone() const
+        {
+            Mat m;
+            copyTo(m);
+            return m;
+        }
+
+        /** @brief Copies the matrix to another one.
+
+        The method copies the matrix data to another matrix. Before copying the data, the method invokes :
+        @code
+            m.create(this->size(), this->type());
+        @endcode
+        so that the destination matrix is reallocated if needed. While m.copyTo(m); works flawlessly, the
+        function does not handle the case of a partial overlap between the source and the destination
+        matrices.
+         */
+        void copyTo(Mat& dst) const
+        {
+            if (dims.empty())
+            {
+                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);
+            }
+        }
+
+        /** @brief Returns true if the array has no elements.
+
+        The method returns true if Mat::total() is 0 or if Mat::data is NULL. Because of pop_back() and
+        resize() methods `M.total() == 0` does not imply that `M.data == NULL`.
+         */
+        bool empty() const
+        {
+            return data == 0 || total() == 0;
+        }
+
+        /** @brief Returns the total number of array elements.
+
+        The method returns the number of array elements (a number of pixels if the array represents an
+        image).
+         */
+        size_t total() const
+        {
+            return dims.empty()
+                 ? (static_cast<std::size_t>(rows) * cols)
+                 : std::accumulate(dims.begin(), dims.end(), static_cast<std::size_t>(1), std::multiplies<size_t>());
+        }
+
+        /** @overload
+        @param roi Extracted submatrix specified as a rectangle.
+        */
+        Mat operator()( const Rect& roi ) const
+        {
+            return Mat{*this, roi};
+        }
+
+
+        /** @brief Returns a pointer to the specified matrix row.
+
+        The methods return `uchar*` or typed pointer to the specified matrix row. See the sample in
+        Mat::isContinuous to know how to use these methods.
+        @param row Index along the dimension 0
+        @param col Index along the dimension 1
+        */
+        uchar* ptr(int row, int col = 0)
+        {
+            return const_cast<uchar*>(const_cast<const Mat*>(this)->ptr(row,col));
+        }
+        /** @overload */
+        const uchar* ptr(int row, int col = 0) const
+        {
+            return data + step * row + CV_ELEM_SIZE(type()) * col;
+        }
+
+
+    private:
+        //actual memory allocated for storage, or nullptr if object is non owning view to over memory
+        std::shared_ptr<uchar> memory;
+    };
+
+} //namespace own
+} //namespace gapi
+} //namespace cv
+
+#endif /* OPENCV_GAPI_OWN_MAT_HPP */

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/own/saturate.hpp

@@ -0,0 +1,90 @@
+// 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_OWN_SATURATE_HPP
+#define OPENCV_GAPI_OWN_SATURATE_HPP
+
+#include <math.h>
+
+#include <limits>
+#include <type_traits>
+
+#include <opencv2/gapi/own/assert.hpp>
+
+namespace cv { namespace gapi { namespace own {
+//-----------------------------
+//
+// Numeric cast with saturation
+//
+//-----------------------------
+
+template<typename DST, typename SRC>
+static inline DST saturate(SRC x)
+{
+    // only integral types please!
+    GAPI_DbgAssert(std::is_integral<DST>::value &&
+                   std::is_integral<SRC>::value);
+
+    if (std::is_same<DST, SRC>::value)
+        return static_cast<DST>(x);
+
+    if (sizeof(DST) > sizeof(SRC))
+        return static_cast<DST>(x);
+
+    // compiler must recognize this saturation,
+    // so compile saturate<s16>(a + b) with adds
+    // instruction (e.g.: _mm_adds_epi16 if x86)
+    return x < std::numeric_limits<DST>::min()?
+               std::numeric_limits<DST>::min():
+           x > std::numeric_limits<DST>::max()?
+               std::numeric_limits<DST>::max():
+           static_cast<DST>(x);
+}
+
+// Note, that OpenCV rounds differently:
+// - like std::round() for add, subtract
+// - like std::rint() for multiply, divide
+template<typename DST, typename SRC, typename R>
+static inline DST saturate(SRC x, R round)
+{
+    if (std::is_floating_point<DST>::value)
+    {
+        return static_cast<DST>(x);
+    }
+    else if (std::is_integral<SRC>::value)
+    {
+        GAPI_DbgAssert(std::is_integral<DST>::value &&
+                       std::is_integral<SRC>::value);
+        return saturate<DST>(x);
+    }
+    else
+    {
+        GAPI_DbgAssert(std::is_integral<DST>::value &&
+                 std::is_floating_point<SRC>::value);
+#ifdef _WIN32
+// Suppress warning about converting x to floating-point
+// Note that x is already floating-point at this point
+#pragma warning(disable: 4244)
+#endif
+        int ix = static_cast<int>(round(x));
+#ifdef _WIN32
+#pragma warning(default: 4244)
+#endif
+        return saturate<DST>(ix);
+    }
+}
+
+// explicit suffix 'd' for double type
+inline double  ceild(double x) { return ceil(x); }
+inline double floord(double x) { return floor(x); }
+inline double roundd(double x) { return round(x); }
+inline double  rintd(double x) { return rint(x); }
+
+} //namespace own
+} //namespace gapi
+} //namespace cv
+#endif /* OPENCV_GAPI_OWN_SATURATE_HPP */

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/own/scalar.hpp

@@ -0,0 +1,47 @@
+// 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_GAPI_OWN_SCALAR_HPP
+#define OPENCV_GAPI_GAPI_OWN_SCALAR_HPP
+
+#include <opencv2/gapi/own/exports.hpp>
+
+namespace cv
+{
+namespace gapi
+{
+namespace own
+{
+
+class GAPI_EXPORTS Scalar
+{
+public:
+    Scalar() = default;
+    explicit Scalar(double v0) { val[0] = v0; };
+    Scalar(double v0, double v1, double v2 = 0, double v3 = 0)
+        : val{v0, v1, v2, v3}
+    {
+    }
+
+    const double& operator[](int i) const { return val[i]; }
+          double& operator[](int i)       { return val[i]; }
+
+    static Scalar all(double v0) { return Scalar(v0, v0, v0, v0); }
+
+    double val[4] = {0};
+};
+
+inline bool operator==(const Scalar& lhs, const Scalar& rhs)
+{
+    return std::equal(std::begin(lhs.val), std::end(lhs.val), std::begin(rhs.val));
+}
+
+} // namespace own
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_GAPI_OWN_SCALAR_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/own/types.hpp

@@ -0,0 +1,150 @@
+// 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_TYPES_HPP
+#define OPENCV_GAPI_TYPES_HPP
+
+#include <algorithm>              // std::max, std::min
+#include <ostream>
+
+namespace cv
+{
+namespace gapi
+{
+
+/**
+ * @brief This namespace contains G-API own data structures used in
+ * its standalone mode build.
+ */
+namespace own
+{
+
+class Point
+{
+public:
+    Point() = default;
+    Point(int _x, int _y) : x(_x),  y(_y) {}
+
+    int x = 0;
+    int y = 0;
+};
+
+class Point2f
+{
+public:
+    Point2f() = default;
+    Point2f(float _x, float _y) : x(_x),  y(_y) {}
+
+    float x = 0.f;
+    float y = 0.f;
+};
+
+class Rect
+{
+public:
+    Rect() = default;
+    Rect(int _x, int _y, int _width, int _height) : x(_x), y(_y),   width(_width),  height(_height) {}
+#if !defined(GAPI_STANDALONE)
+    Rect(const cv::Rect& other) : x(other.x), y(other.y), width(other.width), height(other.height) {}
+    inline Rect& operator=(const cv::Rect& other)
+    {
+        x = other.x;
+        y = other.x;
+        width  = other.width;
+        height = other.height;
+        return *this;
+    }
+#endif // !defined(GAPI_STANDALONE)
+
+    int x      = 0; //!< x coordinate of the top-left corner
+    int y      = 0; //!< y coordinate of the top-left corner
+    int width  = 0; //!< width of the rectangle
+    int height = 0; //!< height of the rectangle
+};
+
+inline bool operator==(const Rect& lhs, const Rect& rhs)
+{
+    return lhs.x == rhs.x && lhs.y == rhs.y && lhs.width == rhs.width && lhs.height == rhs.height;
+}
+
+inline bool operator!=(const Rect& lhs, const Rect& rhs)
+{
+    return !(lhs == rhs);
+}
+
+inline Rect& operator&=(Rect& lhs, const Rect& rhs)
+{
+    int x1 = std::max(lhs.x, rhs.x);
+    int y1 = std::max(lhs.y, rhs.y);
+    lhs.width  = std::min(lhs.x + lhs.width,  rhs.x + rhs.width) -  x1;
+    lhs.height = std::min(lhs.y + lhs.height, rhs.y + rhs.height) - y1;
+    lhs.x = x1;
+    lhs.y = y1;
+    if( lhs.width <= 0 || lhs.height <= 0 )
+        lhs = Rect();
+    return lhs;
+}
+
+inline const Rect operator&(const Rect& lhs, const Rect& rhs)
+{
+    Rect result = lhs;
+    return result &= rhs;
+}
+
+inline std::ostream& operator<<(std::ostream& o, const Rect& rect)
+{
+    return o << "[" << rect.width << " x " << rect.height << " from (" << rect.x << ", " << rect.y << ")]";
+}
+
+class Size
+{
+public:
+    Size() = default;
+    Size(int _width, int _height) : width(_width),  height(_height) {}
+#if !defined(GAPI_STANDALONE)
+    Size(const cv::Size& other) : width(other.width), height(other.height) {}
+    inline Size& operator=(const cv::Size& rhs)
+    {
+        width  = rhs.width;
+        height = rhs.height;
+        return *this;
+    }
+#endif // !defined(GAPI_STANDALONE)
+
+    int width  = 0;
+    int height = 0;
+};
+
+inline Size& operator+=(Size& lhs, const Size& rhs)
+{
+    lhs.width  += rhs.width;
+    lhs.height += rhs.height;
+    return lhs;
+}
+
+inline bool operator==(const Size& lhs, const Size& rhs)
+{
+    return lhs.width == rhs.width && lhs.height == rhs.height;
+}
+
+inline bool operator!=(const Size& lhs, const Size& rhs)
+{
+    return !(lhs == rhs);
+}
+
+
+inline std::ostream& operator<<(std::ostream& o, const Size& s)
+{
+    o << "[" << s.width << " x " << s.height << "]";
+    return o;
+}
+
+} // namespace own
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_TYPES_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/plaidml/core.hpp

@@ -0,0 +1,20 @@
+// 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_PLAIDML_CORE_HPP
+#define OPENCV_GAPI_PLAIDML_CORE_HPP
+
+#include <opencv2/gapi/gkernel.hpp>     // GKernelPackage
+#include <opencv2/gapi/own/exports.hpp> // GAPI_EXPORTS
+
+namespace cv { namespace gapi { namespace core { namespace plaidml {
+
+GAPI_EXPORTS cv::gapi::GKernelPackage kernels();
+
+}}}}
+
+#endif // OPENCV_GAPI_PLAIDML_CORE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/plaidml/gplaidmlkernel.hpp

@@ -0,0 +1,140 @@
+// 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_GPLAIDMLKERNEL_HPP
+#define OPENCV_GAPI_GPLAIDMLKERNEL_HPP
+
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/garg.hpp>
+
+namespace plaidml
+{
+namespace edsl
+{
+    class Tensor;
+} // namespace edsl
+} // namespace plaidml
+
+namespace cv
+{
+namespace gapi
+{
+namespace plaidml
+{
+
+GAPI_EXPORTS cv::gapi::GBackend backend();
+
+} // namespace plaidml
+} // namespace gapi
+
+struct GPlaidMLContext
+{
+    // Generic accessor API
+    template<typename T>
+    const T& inArg(int input) { return m_args.at(input).get<T>(); }
+
+    // Syntax sugar
+    const plaidml::edsl::Tensor& inTensor(int input)
+    {
+        return inArg<plaidml::edsl::Tensor>(input);
+    }
+
+    plaidml::edsl::Tensor& outTensor(int output)
+    {
+        return *(m_results.at(output).get<plaidml::edsl::Tensor*>());
+    }
+
+    std::vector<GArg> m_args;
+    std::unordered_map<std::size_t, GArg> m_results;
+};
+
+class GAPI_EXPORTS GPlaidMLKernel
+{
+public:
+    using F = std::function<void(GPlaidMLContext &)>;
+
+    GPlaidMLKernel() = default;
+    explicit GPlaidMLKernel(const F& f) : m_f(f) {};
+
+    void apply(GPlaidMLContext &ctx) const
+    {
+        GAPI_Assert(m_f);
+        m_f(ctx);
+    }
+
+protected:
+    F m_f;
+};
+
+
+namespace detail
+{
+
+template<class T> struct plaidml_get_in;
+template<> struct plaidml_get_in<cv::GMat>
+{
+    static const plaidml::edsl::Tensor& get(GPlaidMLContext& ctx, int idx)
+    {
+        return ctx.inTensor(idx);
+    }
+};
+
+template<class T> struct plaidml_get_in
+{
+    static T get(GPlaidMLContext &ctx, int idx) { return ctx.inArg<T>(idx); }
+};
+
+template<class T> struct plaidml_get_out;
+template<> struct plaidml_get_out<cv::GMat>
+{
+    static plaidml::edsl::Tensor& get(GPlaidMLContext& ctx, int idx)
+    {
+        return ctx.outTensor(idx);
+    }
+};
+
+template<typename, typename, typename>
+struct PlaidMLCallHelper;
+
+template<typename Impl, typename... Ins, typename... Outs>
+struct PlaidMLCallHelper<Impl, std::tuple<Ins...>, std::tuple<Outs...> >
+{
+    template<int... IIs, int... OIs>
+    static void call_impl(GPlaidMLContext &ctx, detail::Seq<IIs...>, detail::Seq<OIs...>)
+    {
+        Impl::run(plaidml_get_in<Ins>::get(ctx, IIs)..., plaidml_get_out<Outs>::get(ctx, OIs)...);
+    }
+
+    static void call(GPlaidMLContext& ctx)
+    {
+        call_impl(ctx,
+                  typename detail::MkSeq<sizeof...(Ins)>::type(),
+                  typename detail::MkSeq<sizeof...(Outs)>::type());
+    }
+};
+
+} // namespace detail
+
+template<class Impl, class K>
+class GPlaidMLKernelImpl: public cv::detail::PlaidMLCallHelper<Impl, typename K::InArgs, typename K::OutArgs>,
+                          public cv::detail::KernelTag
+{
+    using P = detail::PlaidMLCallHelper<Impl, typename K::InArgs, typename K::OutArgs>;
+
+public:
+    using API = K;
+
+    static cv::gapi::GBackend backend()  { return cv::gapi::plaidml::backend(); }
+    static cv::GPlaidMLKernel kernel()   { return GPlaidMLKernel(&P::call);     }
+};
+
+#define GAPI_PLAIDML_KERNEL(Name, API) struct Name: public cv::GPlaidMLKernelImpl<Name, API>
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_GPLAIDMLKERNEL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/plaidml/plaidml.hpp

@@ -0,0 +1,53 @@
+// 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_PLAIDML_PLAIDML_HPP
+#define OPENCV_GAPI_PLAIDML_PLAIDML_HPP
+
+#include <string>
+#include <opencv2/gapi/gcommon.hpp> // CompileArgTag
+
+namespace cv
+{
+namespace gapi
+{
+
+/**
+ * @brief This namespace contains G-API PlaidML backend functions,
+ * structures, and symbols.
+ */
+namespace plaidml
+{
+
+/** \addtogroup gapi_compile_args
+ * @{
+ */
+/**
+ * @brief This structure represents the basic parameters for the experimental
+ * PlaidML backend.
+ */
+struct config
+{
+    std::string dev_id; //!< Device ID. Refer to PlaidML documentation for details.
+    std::string trg_id; //!< Target ID. Refer to PlaidML documentation for details.
+};
+/** @} gapi_compile_args */
+
+} // namespace plaidml
+} // namespace gapi
+
+namespace detail
+{
+    template<> struct CompileArgTag<cv::gapi::plaidml::config>
+    {
+        static const char* tag() { return "gapi.plaidml.config"; }
+    };
+} // namespace detail
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_PLAIDML_PLAIDML_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/python/python.hpp

@@ -0,0 +1,67 @@
+// 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) 2021 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_PYTHON_API_HPP
+#define OPENCV_GAPI_PYTHON_API_HPP
+
+#include <opencv2/gapi/gkernel.hpp>     // GKernelPackage
+#include <opencv2/gapi/own/exports.hpp> // GAPI_EXPORTS
+
+namespace cv {
+namespace gapi {
+
+/**
+ * @brief This namespace contains G-API Python backend functions,
+ * structures, and symbols.
+ *
+ * This functionality is required to enable G-API custom operations
+ * and kernels when using G-API from Python, no need to use it in the
+ * C++ form.
+ */
+namespace python {
+
+GAPI_EXPORTS cv::gapi::GBackend backend();
+
+struct GPythonContext
+{
+    const cv::GArgs      &ins;
+    const cv::GMetaArgs  &in_metas;
+    const cv::GTypesInfo &out_info;
+};
+
+using Impl = std::function<cv::GRunArgs(const GPythonContext&)>;
+
+class GAPI_EXPORTS GPythonKernel
+{
+public:
+    GPythonKernel() = default;
+    GPythonKernel(Impl run);
+
+    cv::GRunArgs operator()(const GPythonContext& ctx);
+private:
+    Impl m_run;
+};
+
+class GAPI_EXPORTS GPythonFunctor : public cv::gapi::GFunctor
+{
+public:
+    using Meta = cv::GKernel::M;
+
+    GPythonFunctor(const char* id, const Meta &meta, const Impl& impl);
+
+    GKernelImpl    impl()    const override;
+    gapi::GBackend backend() const override;
+
+private:
+    GKernelImpl impl_;
+};
+
+} // namespace python
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_PYTHON_API_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/render.hpp

@@ -0,0 +1,14 @@
+// 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_RENDER_ROOT_HPP
+#define OPENCV_GAPI_RENDER_ROOT_HPP
+
+// This file is just a shortcut to render/render.hpp
+
+#include <opencv2/gapi/render/render.hpp>
+
+#endif // OPENCV_GAPI_RENDER_ROOT_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/render/render.hpp

@@ -0,0 +1,196 @@
+// 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-2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_RENDER_HPP
+#define OPENCV_GAPI_RENDER_HPP
+
+#include <opencv2/gapi/render/render_types.hpp>
+
+#include <opencv2/gapi.hpp>
+
+/** \defgroup gapi_draw G-API Drawing and composition functionality
+ *  @{
+ *
+ *  @brief Functions for in-graph drawing.
+ *
+ *  @note This is a Work in Progress functionality and APIs may
+ *  change in the future releases.
+ *
+ *  G-API can do some in-graph drawing with a generic operations and a
+ *  set of [rendering primitives](@ref gapi_draw_prims).
+ *  In contrast with traditional OpenCV, in G-API user need to form a
+ *  *rendering list* of primitives to draw. This list can be built
+ *  manually or generated within a graph. This list is passed to
+ *  [special operations or functions](@ref gapi_draw_api) where all
+ *  primitives are interpreted and applied to the image.
+ *
+ *  For example, in a complex pipeline a list of detected objects
+ *  can be translated in-graph to a list of cv::gapi::wip::draw::Rect
+ *  primitives to highlight those with bounding boxes, or a list of
+ *  detected faces can be translated in-graph to a list of
+ *  cv::gapi::wip::draw::Mosaic primitives to hide sensitive content
+ *  or protect privacy.
+ *
+ *  Like any other operations, rendering in G-API can be reimplemented
+ *  by different backends. Currently only an OpenCV-based backend is
+ *  available.
+ *
+ *  In addition to the graph-level operations, there are also regular
+ *  (immediate) OpenCV-like functions are available -- see
+ *  cv::gapi::wip::draw::render(). These functions are just wrappers
+ *  over regular G-API and build the rendering graphs on the fly, so
+ *  take compilation arguments as parameters.
+ *
+ *  Currently this API is more machine-oriented than human-oriented.
+ *  The main purpose is to translate a set of domain-specific objects
+ *  to a list of primitives to draw. For example, in order to generate
+ *  a picture like this:
+ *
+ *  ![](modules/gapi/doc/pics/render_example.png)
+ *
+ *  Rendering list needs to be generated as follows:
+ *
+ *  @include modules/gapi/samples/draw_example.cpp
+ *
+ *  @defgroup gapi_draw_prims Drawing primitives
+ *  @defgroup gapi_draw_api Drawing operations and functions
+ *  @}
+ */
+
+namespace cv
+{
+namespace gapi
+{
+namespace wip
+{
+namespace draw
+{
+
+using GMat2     = std::tuple<cv::GMat,cv::GMat>;
+using GMatDesc2 = std::tuple<cv::GMatDesc,cv::GMatDesc>;
+
+//! @addtogroup gapi_draw_api
+//! @{
+/** @brief The function renders on the input image passed drawing primitivies
+
+@param bgr input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
+@param prims vector of drawing primitivies
+@param args graph compile time parameters
+*/
+void GAPI_EXPORTS_W render(cv::Mat& bgr,
+                           const Prims& prims,
+                           cv::GCompileArgs&& args = {});
+
+/** @brief The function renders on two NV12 planes passed drawing primitivies
+
+@param y_plane input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
+@param uv_plane input image: 8-bit unsigned 2-channel image @ref CV_8UC2.
+@param prims vector of drawing primitivies
+@param args graph compile time parameters
+*/
+void GAPI_EXPORTS_W render(cv::Mat& y_plane,
+                           cv::Mat& uv_plane,
+                           const Prims& prims,
+                           cv::GCompileArgs&& args = {});
+
+/** @brief The function renders on the input media frame passed drawing primitivies
+
+@param frame input Media Frame :  @ref cv::MediaFrame.
+@param prims vector of drawing primitivies
+@param args graph compile time parameters
+*/
+void GAPI_EXPORTS render(cv::MediaFrame& frame,
+                         const Prims& prims,
+                         cv::GCompileArgs&& args = {});
+
+
+G_TYPED_KERNEL_M(GRenderNV12, <GMat2(cv::GMat,cv::GMat,cv::GArray<wip::draw::Prim>)>, "org.opencv.render.nv12")
+{
+     static GMatDesc2 outMeta(GMatDesc y_plane, GMatDesc uv_plane, GArrayDesc)
+     {
+         return std::make_tuple(y_plane, uv_plane);
+     }
+};
+
+G_TYPED_KERNEL(GRenderBGR, <cv::GMat(cv::GMat,cv::GArray<wip::draw::Prim>)>, "org.opencv.render.bgr")
+{
+     static GMatDesc outMeta(GMatDesc bgr, GArrayDesc)
+     {
+         return bgr;
+     }
+};
+
+G_TYPED_KERNEL(GRenderFrame, <cv::GFrame(cv::GFrame, cv::GArray<wip::draw::Prim>)>, "org.opencv.render.frame")
+{
+    static GFrameDesc outMeta(GFrameDesc desc, GArrayDesc)
+    {
+        return desc;
+    }
+};
+
+/** @brief Renders on 3 channels input
+
+Output image must be 8-bit unsigned planar 3-channel image
+
+@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3
+@param prims draw primitives
+*/
+GAPI_EXPORTS_W GMat render3ch(const GMat& src, const GArray<Prim>& prims);
+
+/** @brief Renders on two planes
+
+Output y image must be 8-bit unsigned planar 1-channel image @ref CV_8UC1
+uv image must be 8-bit unsigned planar 2-channel image @ref CV_8UC2
+
+@param y  input image: 8-bit unsigned 1-channel image @ref CV_8UC1
+@param uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2
+@param prims draw primitives
+*/
+GAPI_EXPORTS_W GMat2 renderNV12(const GMat& y,
+                                const GMat& uv,
+                                const GArray<Prim>& prims);
+
+/** @brief Renders Media Frame
+
+Output media frame frame cv::MediaFrame
+
+@param m_frame input image: cv::MediaFrame @ref cv::MediaFrame
+@param prims draw primitives
+*/
+GAPI_EXPORTS GFrame renderFrame(const GFrame& m_frame,
+                                const GArray<Prim>& prims);
+
+//! @} gapi_draw_api
+
+} // namespace draw
+} // namespace wip
+
+/**
+ * @brief This namespace contains G-API CPU rendering backend functions,
+ * structures, and symbols. See @ref gapi_draw for details.
+ */
+namespace render
+{
+namespace ocv
+{
+    GAPI_EXPORTS_W cv::gapi::GKernelPackage kernels();
+
+} // namespace ocv
+} // namespace render
+} // namespace gapi
+
+namespace detail
+{
+    template<> struct CompileArgTag<cv::gapi::wip::draw::freetype_font>
+    {
+        static const char* tag() { return "gapi.freetype_font"; }
+    };
+} // namespace detail
+
+} // namespace cv
+
+#endif // OPENCV_GAPI_RENDER_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/render/render_types.hpp

@@ -0,0 +1,359 @@
+// 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) 2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_RENDER_TYPES_HPP
+#define OPENCV_GAPI_RENDER_TYPES_HPP
+
+#include <string>
+#include <vector>
+
+#include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/util/variant.hpp>
+#include <opencv2/gapi/own/exports.hpp>
+
+namespace cv
+{
+namespace gapi
+{
+namespace wip
+{
+namespace draw
+{
+
+/**
+ * @brief This structure specifies which FreeType font to use by FText primitives.
+ */
+struct freetype_font
+{
+    /*@{*/
+    std::string path; //!< The path to the font file (.ttf)
+    /*@{*/
+};
+
+//! @addtogroup gapi_draw_prims
+//! @{
+/**
+ * @brief This structure represents a text string to draw.
+ *
+ * Parameters match cv::putText().
+ */
+struct GAPI_EXPORTS_W_SIMPLE Text
+{
+    /**
+     * @brief Text constructor
+     *
+     * @param text_               The text string to be drawn
+     * @param org_                The bottom-left corner of the text string in the image
+     * @param ff_                 The font type, see #HersheyFonts
+     * @param fs_                 The font scale factor that is multiplied by the font-specific base size
+     * @param color_              The text color
+     * @param thick_              The thickness of the lines used to draw a text
+     * @param lt_                 The line type. See #LineTypes
+     * @param bottom_left_origin_ When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner
+     */
+    GAPI_WRAP
+    Text(const std::string& text_,
+         const cv::Point& org_,
+         int ff_,
+         double fs_,
+         const cv::Scalar& color_,
+         int thick_ = 1,
+         int lt_ = 8,
+         bool bottom_left_origin_ = false) :
+        text(text_), org(org_), ff(ff_), fs(fs_),
+        color(color_), thick(thick_), lt(lt_), bottom_left_origin(bottom_left_origin_)
+    {
+    }
+
+    GAPI_WRAP
+    Text() = default;
+
+    /*@{*/
+    GAPI_PROP_RW std::string text;               //!< The text string to be drawn
+    GAPI_PROP_RW cv::Point   org;                //!< The bottom-left corner of the text string in the image
+    GAPI_PROP_RW int         ff;                 //!< The font type, see #HersheyFonts
+    GAPI_PROP_RW double      fs;                 //!< The font scale factor that is multiplied by the font-specific base size
+    GAPI_PROP_RW cv::Scalar  color;              //!< The text color
+    GAPI_PROP_RW int         thick;              //!< The thickness of the lines used to draw a text
+    GAPI_PROP_RW int         lt;                 //!< The line type. See #LineTypes
+    GAPI_PROP_RW bool        bottom_left_origin; //!< When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner
+    /*@{*/
+};
+
+/**
+ * @brief This structure represents a text string to draw using
+ * FreeType renderer.
+ *
+ * If OpenCV is built without FreeType support, this primitive will
+ * fail at the execution stage.
+ */
+struct FText
+{
+    /**
+     * @brief FText constructor
+     *
+     * @param text_ The text string to be drawn
+     * @param org_  The bottom-left corner of the text string in the image
+     * @param fh_   The height of text
+     * @param color_ The text color
+     */
+    FText(const std::wstring& text_,
+          const cv::Point& org_,
+          int fh_,
+          const cv::Scalar& color_) :
+        text(text_), org(org_), fh(fh_), color(color_)
+    {
+    }
+
+    FText() = default;
+
+    /*@{*/
+    std::wstring text;              //!< The text string to be drawn
+    cv::Point    org;               //!< The bottom-left corner of the text string in the image
+    int          fh;                //!< The height of text
+    cv::Scalar   color;             //!< The text color
+    /*@{*/
+};
+
+/**
+ * @brief This structure represents a rectangle to draw.
+ *
+ * Parameters match cv::rectangle().
+ */
+struct GAPI_EXPORTS_W_SIMPLE Rect
+{
+    /**
+     * @brief Rect constructor
+     *
+     * @param rect_   Coordinates of the rectangle
+     * @param color_  The bottom-left corner of the text string in the image
+     * @param thick_  The thickness of lines that make up the rectangle. Negative values, like #FILLED, mean that the function has to draw a filled rectangle
+     * @param lt_     The type of the line. See #LineTypes
+     * @param shift_  The number of fractional bits in the point coordinates
+     */
+    Rect(const cv::Rect& rect_,
+         const cv::Scalar& color_,
+         int thick_ = 1,
+         int lt_ = 8,
+         int shift_ = 0) :
+        rect(rect_), color(color_), thick(thick_), lt(lt_), shift(shift_)
+    {
+    }
+
+    GAPI_WRAP
+    Rect() = default;
+
+    /*@{*/
+    GAPI_PROP_RW cv::Rect   rect;  //!< Coordinates of the rectangle
+    GAPI_PROP_RW cv::Scalar color; //!< The rectangle color or brightness (grayscale image)
+    GAPI_PROP_RW int        thick; //!< The thickness of lines that make up the rectangle. Negative values, like #FILLED, mean that the function has to draw a filled rectangle
+    GAPI_PROP_RW int        lt;    //!< The type of the line. See #LineTypes
+    GAPI_PROP_RW int        shift; //!< The number of fractional bits in the point coordinates
+    /*@{*/
+};
+
+/**
+ * @brief This structure represents a circle to draw.
+ *
+ * Parameters match cv::circle().
+ */
+struct GAPI_EXPORTS_W_SIMPLE Circle
+{
+    /**
+     * @brief Circle constructor
+     *
+     * @param  center_ The center of the circle
+     * @param  radius_ The radius of the circle
+     * @param  color_  The color of the  circle
+     * @param  thick_  The thickness of the circle outline, if positive. Negative values, like #FILLED, mean that a filled circle is to be drawn
+     * @param  lt_     The Type of the circle boundary. See #LineTypes
+     * @param  shift_  The Number of fractional bits in the coordinates of the center and in the radius value
+     */
+    GAPI_WRAP
+    Circle(const cv::Point& center_,
+           int radius_,
+           const cv::Scalar& color_,
+           int thick_ = 1,
+           int lt_ = 8,
+           int shift_ = 0) :
+        center(center_), radius(radius_), color(color_), thick(thick_), lt(lt_), shift(shift_)
+    {
+    }
+
+    GAPI_WRAP
+    Circle() = default;
+
+    /*@{*/
+    GAPI_PROP_RW cv::Point  center; //!< The center of the circle
+    GAPI_PROP_RW int        radius; //!< The radius of the circle
+    GAPI_PROP_RW cv::Scalar color;  //!< The color of the  circle
+    GAPI_PROP_RW int        thick;  //!< The thickness of the circle outline, if positive. Negative values, like #FILLED, mean that a filled circle is to be drawn
+    GAPI_PROP_RW int        lt;     //!< The Type of the circle boundary. See #LineTypes
+    GAPI_PROP_RW int        shift;  //!< The Number of fractional bits in the coordinates of the center and in the radius value
+    /*@{*/
+};
+
+/**
+ * @brief This structure represents a line to draw.
+ *
+ * Parameters match cv::line().
+ */
+struct GAPI_EXPORTS_W_SIMPLE Line
+{
+    /**
+     * @brief Line constructor
+     *
+     * @param  pt1_    The first point of the line segment
+     * @param  pt2_    The second point of the line segment
+     * @param  color_  The line color
+     * @param  thick_  The thickness of line
+     * @param  lt_     The Type of the line. See #LineTypes
+     * @param  shift_  The number of fractional bits in the point coordinates
+    */
+    GAPI_WRAP
+    Line(const cv::Point& pt1_,
+         const cv::Point& pt2_,
+         const cv::Scalar& color_,
+         int thick_ = 1,
+         int lt_ = 8,
+         int shift_ = 0) :
+        pt1(pt1_), pt2(pt2_), color(color_), thick(thick_), lt(lt_), shift(shift_)
+    {
+    }
+
+    GAPI_WRAP
+    Line() = default;
+
+    /*@{*/
+    GAPI_PROP_RW cv::Point  pt1;    //!< The first point of the line segment
+    GAPI_PROP_RW cv::Point  pt2;    //!< The second point of the line segment
+    GAPI_PROP_RW cv::Scalar color;  //!< The line color
+    GAPI_PROP_RW int        thick;  //!< The thickness of line
+    GAPI_PROP_RW int        lt;     //!< The Type of the line. See #LineTypes
+    GAPI_PROP_RW int        shift;  //!< The number of fractional bits in the point coordinates
+    /*@{*/
+};
+
+/**
+ * @brief This structure represents a mosaicing operation.
+ *
+ * Mosaicing is a very basic method to obfuscate regions in the image.
+ */
+struct GAPI_EXPORTS_W_SIMPLE Mosaic
+{
+    /**
+     * @brief Mosaic constructor
+     *
+     * @param mos_    Coordinates of the mosaic
+     * @param cellSz_ Cell size (same for X, Y)
+     * @param decim_  Decimation (0 stands for no decimation)
+    */
+    Mosaic(const cv::Rect& mos_,
+           int cellSz_,
+           int decim_) :
+        mos(mos_), cellSz(cellSz_), decim(decim_)
+    {
+    }
+
+    GAPI_WRAP
+    Mosaic() : cellSz(0), decim(0) {}
+
+    /*@{*/
+    GAPI_PROP_RW cv::Rect mos;    //!< Coordinates of the mosaic
+    GAPI_PROP_RW int      cellSz; //!< Cell size (same for X, Y)
+    GAPI_PROP_RW int      decim;  //!< Decimation (0 stands for no decimation)
+    /*@{*/
+};
+
+/**
+ * @brief This structure represents an image to draw.
+ *
+ * Image is blended on a frame using the specified mask.
+ */
+struct GAPI_EXPORTS_W_SIMPLE Image
+{
+    /**
+     * @brief Mosaic constructor
+     *
+     * @param  org_   The bottom-left corner of the image
+     * @param  img_   Image to draw
+     * @param  alpha_ Alpha channel for image to draw (same size and number of channels)
+    */
+    GAPI_WRAP
+    Image(const cv::Point& org_,
+          const cv::Mat& img_,
+          const cv::Mat& alpha_) :
+        org(org_), img(img_), alpha(alpha_)
+    {
+    }
+
+    GAPI_WRAP
+    Image() = default;
+
+    /*@{*/
+    GAPI_PROP_RW cv::Point org;   //!< The bottom-left corner of the image
+    GAPI_PROP_RW cv::Mat   img;   //!< Image to draw
+    GAPI_PROP_RW cv::Mat   alpha; //!< Alpha channel for image to draw (same size and number of channels)
+    /*@{*/
+};
+
+/**
+ * @brief This structure represents a polygon to draw.
+ */
+struct GAPI_EXPORTS_W_SIMPLE Poly
+{
+    /**
+     * @brief Mosaic constructor
+     *
+     * @param points_ Points to connect
+     * @param color_  The line color
+     * @param thick_  The thickness of line
+     * @param lt_     The Type of the line. See #LineTypes
+     * @param shift_  The number of fractional bits in the point coordinate
+    */
+    GAPI_WRAP
+    Poly(const std::vector<cv::Point>& points_,
+         const cv::Scalar& color_,
+         int thick_ = 1,
+         int lt_ = 8,
+         int shift_ = 0) :
+        points(points_), color(color_), thick(thick_), lt(lt_), shift(shift_)
+    {
+    }
+
+    GAPI_WRAP
+    Poly() = default;
+
+    /*@{*/
+    GAPI_PROP_RW std::vector<cv::Point> points;  //!< Points to connect
+    GAPI_PROP_RW cv::Scalar             color;   //!< The line color
+    GAPI_PROP_RW int                    thick;   //!< The thickness of line
+    GAPI_PROP_RW int                    lt;      //!< The Type of the line. See #LineTypes
+    GAPI_PROP_RW int                    shift;   //!< The number of fractional bits in the point coordinate
+    /*@{*/
+};
+
+using Prim  = util::variant
+    < Text
+    , FText
+    , Rect
+    , Circle
+    , Line
+    , Mosaic
+    , Image
+    , Poly
+    >;
+
+using Prims = std::vector<Prim>;
+//! @} gapi_draw_prims
+
+} // namespace draw
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_RENDER_TYPES_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/rmat.hpp

@@ -0,0 +1,158 @@
+// 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) 2020 Intel Corporation
+
+#ifndef OPENCV_GAPI_RMAT_HPP
+#define OPENCV_GAPI_RMAT_HPP
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/own/exports.hpp>
+
+// Forward declaration
+namespace cv {
+namespace gapi {
+namespace s11n {
+struct IOStream;
+struct IIStream;
+} // namespace s11n
+} // namespace gapi
+} // namespace cv
+
+namespace cv {
+
+// "Remote Mat", a general class which provides an abstraction layer over the data
+// storage and placement (host, remote device etc) and allows to access this data.
+//
+// The device specific implementation is hidden in the RMat::Adapter class
+//
+// The basic flow is the following:
+// * Backend which is aware of the remote device:
+//   - Implements own AdapterT class which is derived from RMat::Adapter
+//   - Wraps device memory into RMat via make_rmat utility function:
+//         cv::RMat rmat = cv::make_rmat<AdapterT>(args);
+//
+// * End user:
+//   - Writes the code which works with RMats without any knowledge of the remote device:
+//     void func(const cv::RMat& in_rmat, cv::RMat& out_rmat) {
+//         // Fetch input data from the device, get mapped memory for output
+//         cv::RMat::View  in_view =  in_rmat.access(Access::R);
+//         cv::RMat::View out_view = out_rmat.access(Access::W);
+//         performCalculations(in_view, out_view);
+//         // data from out_view is transferred to the device when out_view is destroyed
+//     }
+/** \addtogroup gapi_data_structures
+ * @{
+ */
+class GAPI_EXPORTS RMat
+{
+public:
+    // A lightweight wrapper on image data:
+    // - Doesn't own the memory;
+    // - Doesn't implement copy semantics (it's assumed that a view is created each time
+    // wrapped data is being accessed);
+    // - Has an optional callback which is called when the view is destroyed.
+    class GAPI_EXPORTS View
+    {
+    public:
+        using DestroyCallback = std::function<void()>;
+        using stepsT = std::vector<size_t>;
+
+        View() = default;
+        View(const GMatDesc& desc, uchar* data, const stepsT& steps = {}, DestroyCallback&& cb = nullptr);
+        View(const GMatDesc& desc, uchar* data, size_t step, DestroyCallback&& cb = nullptr);
+
+        View(const View&) = delete;
+        View& operator=(const View&) = delete;
+        View(View&&) = default;
+        View& operator=(View&& v);
+        ~View() { if (m_cb) m_cb(); }
+
+        cv::Size size() const { return m_desc.size; }
+        const std::vector<int>& dims() const { return m_desc.dims; }
+        int cols() const { return m_desc.size.width; }
+        int rows() const { return m_desc.size.height; }
+        int type() const;
+        int depth() const { return m_desc.depth; }
+        int chan() const { return m_desc.chan; }
+        size_t elemSize() const { return CV_ELEM_SIZE(type()); }
+
+        template<typename T = uchar> T* ptr(int y = 0) {
+            return reinterpret_cast<T*>(m_data + step()*y);
+        }
+        template<typename T = uchar> const T* ptr(int y = 0) const {
+            return reinterpret_cast<T*>(m_data + step()*y);
+        }
+        template<typename T = uchar> T* ptr(int y, int x) {
+            return reinterpret_cast<T*>(m_data + step()*y + step(1)*x);
+        }
+        template<typename T = uchar> const T* ptr(int y, int x) const {
+            return reinterpret_cast<const T*>(m_data + step()*y + step(1)*x);
+        }
+        size_t step(size_t i = 0) const { GAPI_DbgAssert(i<m_steps.size()); return m_steps[i]; }
+        const stepsT& steps() const { return m_steps; }
+
+    private:
+        GMatDesc m_desc;
+        uchar* m_data = nullptr;
+        stepsT m_steps = {0u};
+        DestroyCallback m_cb = nullptr;
+    };
+
+    enum class Access { R, W };
+    class Adapter
+    {
+    public:
+        virtual ~Adapter() = default;
+        virtual GMatDesc desc() const = 0;
+        // Implementation is responsible for setting the appropriate callback to
+        // the view when accessed for writing, to ensure that the data from the view
+        // is transferred to the device when the view is destroyed
+        virtual View access(Access) = 0;
+        virtual void serialize(cv::gapi::s11n::IOStream&) {
+            GAPI_Assert(false && "Generic serialize method of RMat::Adapter does nothing by default. "
+                                 "Please, implement it in derived class to properly serialize the object.");
+        }
+        virtual void deserialize(cv::gapi::s11n::IIStream&) {
+            GAPI_Assert(false && "Generic deserialize method of RMat::Adapter does nothing by default. "
+                                 "Please, implement it in derived class to properly deserialize the object.");
+        }
+    };
+    using AdapterP = std::shared_ptr<Adapter>;
+
+    RMat() = default;
+    RMat(AdapterP&& a) : m_adapter(std::move(a)) {}
+    GMatDesc desc() const { return m_adapter->desc(); }
+
+    // Note: When accessed for write there is no guarantee that returned view
+    // will contain actual snapshot of the mapped device memory
+    // (no guarantee that fetch from a device is performed). The only
+    // guaranty is that when the view is destroyed, its data will be
+    // transferred to the device
+    View access(Access a) const { return m_adapter->access(a); }
+
+    // Cast underlying RMat adapter to the particular adapter type,
+    // return nullptr if underlying type is different
+    template<typename T> T* get() const
+    {
+        static_assert(std::is_base_of<Adapter, T>::value, "T is not derived from Adapter!");
+        GAPI_Assert(m_adapter != nullptr);
+        return dynamic_cast<T*>(m_adapter.get());
+    }
+
+    void serialize(cv::gapi::s11n::IOStream& os) const {
+        m_adapter->serialize(os);
+    }
+
+private:
+    AdapterP m_adapter = nullptr;
+};
+
+template<typename T, typename... Ts>
+RMat make_rmat(Ts&&... args) { return { std::make_shared<T>(std::forward<Ts>(args)...) }; }
+/** @} */
+
+} //namespace cv
+
+#endif /* OPENCV_GAPI_RMAT_HPP */

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/s11n.hpp

@@ -0,0 +1,505 @@
+// 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) 2020-2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_S11N_HPP
+#define OPENCV_GAPI_S11N_HPP
+
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <opencv2/gapi/s11n/base.hpp>
+#include <opencv2/gapi/gcomputation.hpp>
+#include <opencv2/gapi/rmat.hpp>
+#include <opencv2/gapi/media.hpp>
+#include <opencv2/gapi/util/util.hpp>
+
+// FIXME: caused by deserialize_runarg
+#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
+#pragma warning(disable: 4702)
+#endif
+
+namespace cv {
+namespace gapi {
+
+/**
+* \addtogroup gapi_serialization
+* @{
+*/
+
+namespace detail {
+    GAPI_EXPORTS cv::GComputation getGraph(const std::vector<char> &bytes);
+
+    GAPI_EXPORTS cv::GMetaArgs getMetaArgs(const std::vector<char> &bytes);
+
+    GAPI_EXPORTS cv::GRunArgs getRunArgs(const std::vector<char> &bytes);
+
+    GAPI_EXPORTS std::vector<std::string> getVectorOfStrings(const std::vector<char> &bytes);
+
+    template<typename... Types>
+    cv::GCompileArgs getCompileArgs(const std::vector<char> &bytes);
+
+    template<typename... AdapterType>
+    cv::GRunArgs getRunArgsWithAdapters(const std::vector<char> &bytes);
+} // namespace detail
+
+/** @brief Serialize a graph represented by GComputation into an array of bytes.
+ *
+ * Check different overloads for more examples.
+ * @param c GComputation to serialize.
+ * @return serialized vector of bytes.
+ */
+GAPI_EXPORTS std::vector<char> serialize(const cv::GComputation &c);
+
+/** @overload
+ * @param ca GCompileArgs to serialize.
+ */
+GAPI_EXPORTS std::vector<char> serialize(const cv::GCompileArgs& ca);
+
+/** @overload
+ * @param ma GMetaArgs to serialize.
+ */
+GAPI_EXPORTS std::vector<char> serialize(const cv::GMetaArgs& ma);
+
+/** @overload
+ * @param ra GRunArgs to serialize.
+ */
+GAPI_EXPORTS std::vector<char> serialize(const cv::GRunArgs& ra);
+
+/** @overload
+ * @param vs std::vector<std::string> to serialize.
+ */
+GAPI_EXPORTS std::vector<char> serialize(const std::vector<std::string>& vs);
+
+/**
+ * @private
+ */
+template<typename T> static inline
+T deserialize(const std::vector<char> &bytes);
+
+/** @brief Deserialize GComputation from a byte array.
+ *
+ * Check different overloads for more examples.
+ * @param bytes serialized vector of bytes.
+ * @return deserialized GComputation object.
+ */
+template<> inline
+cv::GComputation deserialize(const std::vector<char> &bytes) {
+    return detail::getGraph(bytes);
+}
+
+/** @brief Deserialize GMetaArgs from a byte array.
+ *
+ * Check different overloads for more examples.
+ * @param bytes serialized vector of bytes.
+ * @return deserialized GMetaArgs object.
+ */
+template<> inline
+cv::GMetaArgs deserialize(const std::vector<char> &bytes) {
+    return detail::getMetaArgs(bytes);
+}
+
+/** @brief Deserialize GRunArgs from a byte array.
+ *
+ * Check different overloads for more examples.
+ * @param bytes serialized vector of bytes.
+ * @return deserialized GRunArgs object.
+ */
+template<> inline
+cv::GRunArgs deserialize(const std::vector<char> &bytes) {
+    return detail::getRunArgs(bytes);
+}
+
+/** @brief Deserialize std::vector<std::string> from a byte array.
+ *
+ * Check different overloads for more examples.
+ * @param bytes serialized vector of bytes.
+ * @return deserialized std::vector<std::string> object.
+ */
+template<> inline
+std::vector<std::string> deserialize(const std::vector<char> &bytes) {
+    return detail::getVectorOfStrings(bytes);
+}
+
+/**
+ * @brief Deserialize GCompileArgs which types were specified in the template from a byte array.
+ *
+ * @note cv::gapi::s11n::detail::S11N template specialization must be provided to make a custom type
+ * in GCompileArgs deserializable.
+ *
+ * @param bytes vector of bytes to deserialize GCompileArgs object from.
+ * @return GCompileArgs object.
+ * @see GCompileArgs cv::gapi::s11n::detail::S11N
+ */
+template<typename T, typename... Types> inline
+typename std::enable_if<std::is_same<T, GCompileArgs>::value, GCompileArgs>::
+type deserialize(const std::vector<char> &bytes) {
+    return detail::getCompileArgs<Types...>(bytes);
+}
+
+/**
+ * @brief Deserialize GRunArgs including RMat and MediaFrame objects if any from a byte array.
+ *
+ * Adapter types are specified in the template.
+ * @note To be used properly specified adapter types must overload their deserialize() method.
+ * @param bytes vector of bytes to deserialize GRunArgs object from.
+ * @return GRunArgs including RMat and MediaFrame objects if any.
+ * @see RMat MediaFrame
+ */
+template<typename T, typename AtLeastOneAdapterT, typename... AdapterTypes> inline
+typename std::enable_if<std::is_same<T, GRunArgs>::value, GRunArgs>::
+type deserialize(const std::vector<char> &bytes) {
+    return detail::getRunArgsWithAdapters<AtLeastOneAdapterT, AdapterTypes...>(bytes);
+}
+} // namespace gapi
+} // namespace cv
+
+namespace cv {
+namespace gapi {
+namespace s11n {
+
+/** @brief This structure is an interface for serialization routines.
+ *
+ * It's main purpose is to provide multiple overloads for operator<<()
+ * with basic C++ in addition to OpenCV/G-API types.
+ *
+ * This sctructure can be inherited and further extended with additional types.
+ *
+ * For example, it is utilized in cv::gapi::s11n::detail::S11N as input parameter
+ * in serialize() method.
+ */
+struct GAPI_EXPORTS IOStream {
+    virtual ~IOStream() = default;
+    // Define the native support for basic C++ types at the API level:
+    virtual IOStream& operator<< (bool) = 0;
+    virtual IOStream& operator<< (char) = 0;
+    virtual IOStream& operator<< (unsigned char) = 0;
+    virtual IOStream& operator<< (short) = 0;
+    virtual IOStream& operator<< (unsigned short) = 0;
+    virtual IOStream& operator<< (int) = 0;
+    virtual IOStream& operator<< (uint32_t) = 0;
+    virtual IOStream& operator<< (uint64_t) = 0;
+    virtual IOStream& operator<< (float) = 0;
+    virtual IOStream& operator<< (double) = 0;
+    virtual IOStream& operator<< (const std::string&) = 0;
+};
+
+/** @brief This structure is an interface for deserialization routines.
+ *
+ * It's main purpose is to provide multiple overloads for operator>>()
+ * with basic C++ in addition to OpenCV/G-API types.
+ *
+ * This structure can be inherited and further extended with additional types.
+ *
+ * For example, it is utilized in cv::gapi::s11n::detail::S11N as input parameter
+ * in deserialize() method.
+ */
+struct GAPI_EXPORTS IIStream {
+    virtual ~IIStream() = default;
+    virtual IIStream& operator>> (bool &) = 0;
+    virtual IIStream& operator>> (std::vector<bool>::reference) = 0;
+    virtual IIStream& operator>> (char &) = 0;
+    virtual IIStream& operator>> (unsigned char &) = 0;
+    virtual IIStream& operator>> (short &) = 0;
+    virtual IIStream& operator>> (unsigned short &) = 0;
+    virtual IIStream& operator>> (int &) = 0;
+    virtual IIStream& operator>> (float &) = 0;
+    virtual IIStream& operator>> (double &) = 0;
+    virtual IIStream& operator >> (uint32_t &) = 0;
+    virtual IIStream& operator >> (uint64_t &) = 0;
+    virtual IIStream& operator>> (std::string &) = 0;
+};
+
+namespace detail {
+GAPI_EXPORTS std::unique_ptr<IIStream> getInStream(const std::vector<char> &bytes);
+} // namespace detail
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// S11N operators
+// Note: operators for basic types are defined in IIStream/IOStream
+
+// OpenCV types ////////////////////////////////////////////////////////////////
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Point &pt);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Point &pt);
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Point2f &pt);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Point2f &pt);
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Size &sz);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Size &sz);
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Rect &rc);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Rect &rc);
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Scalar &s);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Scalar &s);
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Mat &m);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Mat &m);
+
+// FIXME: for GRunArgs serailization
+#if !defined(GAPI_STANDALONE)
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::UMat & um);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::UMat & um);
+#endif // !defined(GAPI_STANDALONE)
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::RMat &r);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::RMat &r);
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::gapi::wip::IStreamSource::Ptr &issptr);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::gapi::wip::IStreamSource::Ptr &issptr);
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::detail::VectorRef &vr);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::detail::VectorRef &vr);
+
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::detail::OpaqueRef &opr);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::detail::OpaqueRef &opr);
+
+/// @private -- Exclude this function from OpenCV documentation
+GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::MediaFrame &mf);
+/// @private -- Exclude this function from OpenCV documentation
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::MediaFrame &mf);
+
+// Generic STL types ////////////////////////////////////////////////////////////////
+template<typename K, typename V>
+IOStream& operator<< (IOStream& os, const std::map<K, V> &m) {
+    const uint32_t sz = static_cast<uint32_t>(m.size());
+    os << sz;
+    for (const auto& it : m) os << it.first << it.second;
+    return os;
+}
+template<typename K, typename V>
+IIStream& operator>> (IIStream& is, std::map<K, V> &m) {
+    m.clear();
+    uint32_t sz = 0u;
+    is >> sz;
+    for (std::size_t i = 0; i < sz; ++i) {
+        K k{};
+        V v{};
+        is >> k >> v;
+        m[k] = v;
+    }
+    return is;
+}
+
+template<typename K, typename V>
+IOStream& operator<< (IOStream& os, const std::unordered_map<K, V> &m) {
+    const uint32_t sz = static_cast<uint32_t>(m.size());
+    os << sz;
+    for (auto &&it : m) os << it.first << it.second;
+    return os;
+}
+template<typename K, typename V>
+IIStream& operator>> (IIStream& is, std::unordered_map<K, V> &m) {
+    m.clear();
+    uint32_t sz = 0u;
+    is >> sz;
+    for (std::size_t i = 0; i < sz; ++i) {
+        K k{};
+        V v{};
+        is >> k >> v;
+        m[k] = v;
+    }
+    return is;
+}
+
+template<typename T>
+IOStream& operator<< (IOStream& os, const std::vector<T> &ts) {
+    const uint32_t sz = static_cast<uint32_t>(ts.size());
+    os << sz;
+    for (auto &&v : ts) os << v;
+    return os;
+}
+template<typename T>
+IIStream& operator>> (IIStream& is, std::vector<T> &ts) {
+    uint32_t sz = 0u;
+    is >> sz;
+    if (sz == 0u) {
+        ts.clear();
+    }
+    else {
+        ts.resize(sz);
+        for (std::size_t i = 0; i < sz; ++i) is >> ts[i];
+    }
+    return is;
+}
+
+// Generic: variant serialization
+namespace detail {
+template<typename V>
+IOStream& put_v(IOStream&, const V&, std::size_t) {
+    GAPI_Assert(false && "variant>>: requested index is invalid");
+};
+
+template<typename V, typename X, typename... Xs>
+IOStream& put_v(IOStream& os, const V& v, std::size_t x) {
+    return (x == 0u)
+        ? os << cv::util::get<X>(v)
+        : put_v<V, Xs...>(os, v, x-1);
+}
+
+template<typename V>
+IIStream& get_v(IIStream&, V&, std::size_t, std::size_t) {
+    GAPI_Assert(false && "variant<<: requested index is invalid");
+}
+
+template<typename V, typename X, typename... Xs>
+IIStream& get_v(IIStream& is, V& v, std::size_t i, std::size_t gi) {
+    if (i == gi) {
+        X x{};
+        is >> x;
+        v = V{std::move(x)};
+        return is;
+    } else return get_v<V, Xs...>(is, v, i+1, gi);
+}
+} // namespace detail
+
+//! @overload
+template<typename... Ts>
+IOStream& operator<< (IOStream& os, const cv::util::variant<Ts...> &v) {
+    os << static_cast<uint32_t>(v.index());
+    return detail::put_v<cv::util::variant<Ts...>, Ts...>(os, v, v.index());
+}
+//! @overload
+template<typename... Ts>
+IIStream& operator>> (IIStream& is, cv::util::variant<Ts...> &v) {
+    int idx = -1;
+    is >> idx;
+    GAPI_Assert(idx >= 0 && idx < (int)sizeof...(Ts));
+    return detail::get_v<cv::util::variant<Ts...>, Ts...>(is, v, 0u, idx);
+}
+
+// FIXME: consider a better solution
+/// @private -- Exclude this function from OpenCV documentation
+template<typename... Ts>
+void getRunArgByIdx (IIStream& is, cv::util::variant<Ts...> &v, uint32_t idx) {
+    is = detail::get_v<cv::util::variant<Ts...>, Ts...>(is, v, 0u, idx);
+}
+} // namespace s11n
+
+namespace detail
+{
+template<typename T> struct try_deserialize_comparg;
+
+template<> struct try_deserialize_comparg<std::tuple<>> {
+static cv::util::optional<GCompileArg> exec(const std::string&, cv::gapi::s11n::IIStream&) {
+        return { };
+    }
+};
+
+template<typename T, typename... Types>
+struct try_deserialize_comparg<std::tuple<T, Types...>> {
+static cv::util::optional<GCompileArg> exec(const std::string& tag, cv::gapi::s11n::IIStream& is) {
+    if (tag == cv::detail::CompileArgTag<T>::tag()) {
+        static_assert(cv::gapi::s11n::detail::has_S11N_spec<T>::value,
+            "cv::gapi::deserialize<GCompileArgs, Types...> expects Types to have S11N "
+            "specializations with deserialization callbacks!");
+        return cv::util::optional<GCompileArg>(
+            GCompileArg { cv::gapi::s11n::detail::S11N<T>::deserialize(is) });
+    }
+    return try_deserialize_comparg<std::tuple<Types...>>::exec(tag, is);
+}
+};
+
+template<typename ...T>
+struct deserialize_arg_with_adapter;
+
+template<typename RA, typename TA>
+struct deserialize_arg_with_adapter<RA, TA> {
+static GRunArg exec(cv::gapi::s11n::IIStream& is) {
+    std::unique_ptr<TA> ptr(new TA);
+    ptr->deserialize(is);
+    return GRunArg { RA(std::move(ptr)) };
+}
+};
+
+template<typename RA>
+struct deserialize_arg_with_adapter<RA, void> {
+static GRunArg exec(cv::gapi::s11n::IIStream&) {
+    GAPI_Assert(false && "No suitable adapter class found during RMat/MediaFrame deserialization. "
+                         "Please, make sure you've passed them in cv::gapi::deserialize() template");
+    return GRunArg{};
+}
+};
+
+template<typename... Types>
+struct deserialize_runarg {
+static GRunArg exec(cv::gapi::s11n::IIStream& is, uint32_t idx) {
+    if (idx == GRunArg::index_of<RMat>()) {
+        // Type or void (if not found)
+        using TA = typename cv::util::find_adapter_impl<RMat::Adapter, Types...>::type;
+        return deserialize_arg_with_adapter<RMat, TA>::exec(is);
+    } else if (idx == GRunArg::index_of<MediaFrame>()) {
+        // Type or void (if not found)
+        using TA = typename cv::util::find_adapter_impl<MediaFrame::IAdapter, Types...>::type;
+        return deserialize_arg_with_adapter<MediaFrame, TA>::exec(is);
+    } else { // not an adapter holding type runarg - use default deserialization
+        GRunArg arg;
+        getRunArgByIdx(is, arg, idx);
+        return arg;
+    }
+}
+};
+
+template<typename... Types>
+inline cv::util::optional<GCompileArg> tryDeserializeCompArg(const std::string& tag,
+                                                             const std::vector<char>& sArg) {
+    std::unique_ptr<cv::gapi::s11n::IIStream> pArgIs = cv::gapi::s11n::detail::getInStream(sArg);
+    return try_deserialize_comparg<std::tuple<Types...>>::exec(tag, *pArgIs);
+}
+
+template<typename... Types>
+cv::GCompileArgs getCompileArgs(const std::vector<char> &sArgs) {
+    cv::GCompileArgs args;
+
+    std::unique_ptr<cv::gapi::s11n::IIStream> pIs = cv::gapi::s11n::detail::getInStream(sArgs);
+    cv::gapi::s11n::IIStream& is = *pIs;
+
+    uint32_t sz = 0;
+    is >> sz;
+    for (uint32_t i = 0; i < sz; ++i) {
+        std::string tag;
+        is >> tag;
+
+        std::vector<char> sArg;
+        is >> sArg;
+
+        cv::util::optional<GCompileArg> dArg =
+            cv::gapi::detail::tryDeserializeCompArg<Types...>(tag, sArg);
+
+        if (dArg.has_value())
+        {
+            args.push_back(dArg.value());
+        }
+    }
+
+    return args;
+}
+
+template<typename... AdapterTypes>
+cv::GRunArgs getRunArgsWithAdapters(const std::vector<char> &bytes) {
+    std::unique_ptr<cv::gapi::s11n::IIStream> pIs = cv::gapi::s11n::detail::getInStream(bytes);
+    cv::gapi::s11n::IIStream& is = *pIs;
+    cv::GRunArgs args;
+
+    uint32_t sz = 0;
+    is >> sz;
+    for (uint32_t i = 0; i < sz; ++i) {
+        uint32_t idx = 0;
+        is >> idx;
+        args.push_back(cv::gapi::detail::deserialize_runarg<AdapterTypes...>::exec(is, idx));
+    }
+
+    return args;
+}
+} // namespace detail
+/** @} */
+
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_S11N_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/s11n/base.hpp

@@ -0,0 +1,80 @@
+// 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) 2020-2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_S11N_BASE_HPP
+#define OPENCV_GAPI_S11N_BASE_HPP
+
+#include <opencv2/gapi/own/assert.hpp>
+#include <opencv2/gapi/own/exports.hpp>
+
+namespace cv {
+namespace gapi {
+
+/**
+ * @brief This namespace contains G-API serialization and
+ * deserialization functions and data structures.
+ */
+namespace s11n {
+struct IOStream;
+struct IIStream;
+
+namespace detail {
+
+//! @addtogroup gapi_serialization
+//! @{
+
+struct NotImplemented {
+};
+
+/** @brief This structure allows to implement serialization routines for custom types.
+ *
+ * The default S11N for custom types is not implemented.
+ *
+ * @note When providing an overloaded implementation for S11N with your type
+ * don't inherit it from NotImplemented structure.
+ *
+ * @note There are lots of overloaded >> and << operators for basic and OpenCV/G-API types
+ * which can be utilized when serializing a custom type.
+ *
+ * Example of usage:
+ * @snippet modules/gapi/samples/api_ref_snippets.cpp S11N usage
+ *
+ */
+template<typename T>
+struct S11N: public NotImplemented {
+    /**
+     * @brief This function allows user to serialize their custom type.
+     *
+     * @note The default overload throws an exception if called. User need to
+     * properly overload the function to use it.
+     */
+    static void serialize(IOStream &, const T &) {
+        GAPI_Assert(false && "No serialization routine is provided!");
+    }
+    /**
+     * @brief This function allows user to deserialize their custom type.
+     *
+     * @note The default overload throws an exception if called. User need to
+     * properly overload the function to use it.
+     */
+    static T deserialize(IIStream &) {
+        GAPI_Assert(false && "No deserialization routine is provided!");
+    }
+};
+
+/// @private -- Exclude this struct from OpenCV documentation
+template<typename T> struct has_S11N_spec {
+    static constexpr bool value = !std::is_base_of<NotImplemented,
+                                        S11N<typename std::decay<T>::type>>::value;
+};
+//! @} gapi_serialization
+
+} // namespace detail
+} // namespace s11n
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_S11N_BASE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/stereo.hpp

@@ -0,0 +1,85 @@
+// 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 distereoibution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_STEREO_HPP
+#define OPENCV_GAPI_STEREO_HPP
+
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/gscalar.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+
+namespace cv {
+namespace gapi {
+
+/**
+ * The enum specified format of result that you get from @ref cv::gapi::stereo.
+ */
+enum class StereoOutputFormat {
+    DEPTH_FLOAT16, ///< Floating point 16 bit value, CV_16FC1.
+                   ///< This identifier is deprecated, use DEPTH_16F instead.
+    DEPTH_FLOAT32, ///< Floating point 32 bit value, CV_32FC1
+                   ///< This identifier is deprecated, use DEPTH_16F instead.
+    DISPARITY_FIXED16_11_5, ///< 16 bit signed: first bit for sign,
+                            ///< 10 bits for integer part,
+                            ///< 5 bits for fractional part.
+                            ///< This identifier is deprecated,
+                            ///< use DISPARITY_16Q_10_5 instead.
+    DISPARITY_FIXED16_12_4, ///< 16 bit signed: first bit for sign,
+                            ///< 11 bits for integer part,
+                            ///< 4 bits for fractional part.
+                            ///< This identifier is deprecated,
+                            ///< use DISPARITY_16Q_11_4 instead.
+    DEPTH_16F = DEPTH_FLOAT16, ///< Same as DEPTH_FLOAT16
+    DEPTH_32F = DEPTH_FLOAT32, ///< Same as DEPTH_FLOAT32
+    DISPARITY_16Q_10_5 = DISPARITY_FIXED16_11_5, ///< Same as DISPARITY_FIXED16_11_5
+    DISPARITY_16Q_11_4 = DISPARITY_FIXED16_12_4 ///< Same as DISPARITY_FIXED16_12_4
+};
+
+
+/**
+ * @brief This namespace contains G-API Operation Types for Stereo and
+ * related functionality.
+ */
+namespace calib3d {
+
+G_TYPED_KERNEL(GStereo, <GMat(GMat, GMat, const StereoOutputFormat)>, "org.opencv.stereo") {
+    static GMatDesc outMeta(const GMatDesc &left, const GMatDesc &right, const StereoOutputFormat of) {
+        GAPI_Assert(left.chan == 1);
+        GAPI_Assert(left.depth == CV_8U);
+
+        GAPI_Assert(right.chan == 1);
+        GAPI_Assert(right.depth == CV_8U);
+
+        switch(of) {
+            case StereoOutputFormat::DEPTH_FLOAT16:
+                return left.withDepth(CV_16FC1);
+            case StereoOutputFormat::DEPTH_FLOAT32:
+                return left.withDepth(CV_32FC1);
+            case StereoOutputFormat::DISPARITY_FIXED16_11_5:
+            case StereoOutputFormat::DISPARITY_FIXED16_12_4:
+                return left.withDepth(CV_16SC1);
+            default:
+                GAPI_Assert(false && "Unknown output format!");
+        }
+    }
+};
+
+} // namespace calib3d
+
+/** @brief Computes disparity/depth map for the specified stereo-pair.
+The function computes disparity or depth map depending on passed StereoOutputFormat argument.
+
+@param left 8-bit single-channel left image of @ref CV_8UC1 type.
+@param right 8-bit single-channel right image of @ref CV_8UC1 type.
+@param of enum to specified output kind: depth or disparity and corresponding type
+*/
+GAPI_EXPORTS GMat stereo(const GMat& left,
+                         const GMat& right,
+                         const StereoOutputFormat of = StereoOutputFormat::DEPTH_FLOAT32);
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_STEREO_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/cap.hpp

@@ -0,0 +1,126 @@
+// 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_STREAMING_CAP_HPP
+#define OPENCV_GAPI_STREAMING_CAP_HPP
+
+/**
+ * YOUR ATTENTION PLEASE!
+ *
+ * This is a header-only implementation of cv::VideoCapture-based
+ * Stream source.  It is not built by default with G-API as G-API
+ * doesn't depend on videoio module.
+ *
+ * If you want to use it in your application, please make sure
+ * videioio is available in your OpenCV package and is linked to your
+ * application.
+ *
+ * Note for developers: please don't put videoio dependency in G-API
+ * because of this file.
+ */
+#include <chrono>
+
+#include <opencv2/videoio.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/streaming/meta.hpp>
+
+namespace cv {
+namespace gapi {
+namespace wip {
+
+/**
+ * @brief OpenCV's VideoCapture-based streaming source.
+ *
+ * This class implements IStreamSource interface.
+ * Its constructor takes the same parameters as cv::VideoCapture does.
+ *
+ * Please make sure that videoio OpenCV module is available before using
+ * this in your application (G-API doesn't depend on it directly).
+ *
+ * @note stream sources are passed to G-API via shared pointers, so
+ *  please gapi::make_src<> to create objects and ptr() to pass a
+ *  GCaptureSource to cv::gin().
+ */
+class GCaptureSource: public IStreamSource
+{
+public:
+    explicit GCaptureSource(int id) : cap(id) { prep(); }
+    explicit GCaptureSource(const std::string &path) : cap(path) { prep(); }
+
+    // TODO: Add more constructor overloads to make it
+    // fully compatible with VideoCapture's interface.
+
+protected:
+    cv::VideoCapture cap;
+    cv::Mat first;
+    bool first_pulled = false;
+    int64_t counter = 0;
+
+    void prep()
+    {
+        // Prepare first frame to report its meta to engine
+        // when needed
+        GAPI_Assert(first.empty());
+        cv::Mat tmp;
+        if (!cap.read(tmp))
+        {
+            GAPI_Assert(false && "Couldn't grab the very first frame");
+        }
+        // NOTE: Some decode/media VideoCapture backends continue
+        // owning the video buffer under cv::Mat so in order to
+        // process it safely in a highly concurrent pipeline, clone()
+        // is the only right way.
+        first = tmp.clone();
+    }
+
+    virtual bool pull(cv::gapi::wip::Data &data) override
+    {
+        if (!first_pulled)
+        {
+            GAPI_Assert(!first.empty());
+            first_pulled = true;
+            data = first; // no need to clone here since it was cloned already
+        }
+        else
+        {
+            if (!cap.isOpened()) return false;
+
+            cv::Mat frame;
+            if (!cap.read(frame))
+            {
+                // end-of-stream happened
+                return false;
+            }
+            // Same reason to clone as in prep()
+            data = frame.clone();
+        }
+        // Tag data with seq_id/ts
+        const auto now = std::chrono::system_clock::now();
+        const auto dur = std::chrono::duration_cast<std::chrono::microseconds>
+            (now.time_since_epoch());
+        data.meta[cv::gapi::streaming::meta_tag::timestamp] = int64_t{dur.count()};
+        data.meta[cv::gapi::streaming::meta_tag::seq_id]    = int64_t{counter++};
+        return true;
+    }
+
+    virtual GMetaArg descr_of() const override
+    {
+        GAPI_Assert(!first.empty());
+        return cv::GMetaArg{cv::descr_of(first)};
+    }
+};
+
+// NB: Overload for using from python
+GAPI_EXPORTS_W cv::Ptr<IStreamSource> inline make_capture_src(const std::string& path)
+{
+    return make_src<GCaptureSource>(path);
+}
+
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_STREAMING_CAP_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/desync.hpp

@@ -0,0 +1,85 @@
+// 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) 2020-2021 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GSTREAMING_DESYNC_HPP
+#define OPENCV_GAPI_GSTREAMING_DESYNC_HPP
+
+#include <tuple>
+
+#include <opencv2/gapi/util/util.hpp>
+#include <opencv2/gapi/gtype_traits.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/gcall.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+
+namespace cv {
+namespace gapi {
+namespace streaming {
+
+namespace detail {
+struct GDesync {
+    static const char *id() {
+        return "org.opencv.streaming.desync";
+    }
+
+    // An universal yield for desync.
+    // Yields output objects according to the input Types...
+    // Reuses gkernel machinery.
+    // FIXME: This function can be generic and declared in gkernel.hpp
+    //        (it is there already, but a part of GKernelType[M]
+    template<typename... R, int... IIs>
+    static std::tuple<R...> yield(cv::GCall &call, cv::detail::Seq<IIs...>) {
+        return std::make_tuple(cv::detail::Yield<R>::yield(call, IIs)...);
+    }
+};
+
+template<typename G>
+G desync(const G &g) {
+    cv::GKernel k{
+          GDesync::id()                                     // kernel id
+        , ""                                                // kernel tag
+        , [](const GMetaArgs &a, const GArgs &) {return a;} // outMeta callback
+        , {cv::detail::GTypeTraits<G>::shape}               // output Shape
+        , {cv::detail::GTypeTraits<G>::op_kind}             // input data kinds
+        , {cv::detail::GObtainCtor<G>::get()}               // output template ctors
+    };
+    cv::GCall call(std::move(k));
+    call.pass(g);
+    return std::get<0>(GDesync::yield<G>(call, cv::detail::MkSeq<1>::type()));
+}
+} // namespace detail
+
+/**
+ * @brief Starts a desynchronized branch in the graph.
+ *
+ * This operation takes a single G-API data object and returns a
+ * graph-level "duplicate" of this object.
+ *
+ * Operations which use this data object can be desynchronized
+ * from the rest of the graph.
+ *
+ * This operation has no effect when a GComputation is compiled with
+ * regular cv::GComputation::compile(), since cv::GCompiled objects
+ * always produce their full output vectors.
+ *
+ * This operation only makes sense when a GComputation is compiled in
+ * straming mode with cv::GComputation::compileStreaming(). If this
+ * operation is used and there are desynchronized outputs, the user
+ * should use a special version of cv::GStreamingCompiled::pull()
+ * which produces an array of cv::util::optional<> objects.
+ *
+ * @note This feature is highly experimental now and is currently
+ * limited to a single GMat/GFrame argument only.
+ */
+GAPI_EXPORTS GMat desync(const GMat &g);
+GAPI_EXPORTS GFrame desync(const GFrame &f);
+
+} // namespace streaming
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_GSTREAMING_DESYNC_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/format.hpp

@@ -0,0 +1,94 @@
+// 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) 2020 Intel Corporation
+
+#ifndef OPENCV_GAPI_GSTREAMING_FORMAT_HPP
+#define OPENCV_GAPI_GSTREAMING_FORMAT_HPP
+
+#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
+
+namespace cv {
+namespace gapi {
+namespace streaming {
+
+GAPI_EXPORTS cv::gapi::GKernelPackage kernels();
+
+G_API_OP(GBGR, <GMat(GFrame)>, "org.opencv.streaming.BGR")
+{
+    static GMatDesc outMeta(const GFrameDesc& in) { return GMatDesc{CV_8U, 3, in.size}; }
+};
+
+G_API_OP(GY, <GMat(GFrame)>, "org.opencv.streaming.Y") {
+    static GMatDesc outMeta(const GFrameDesc& frameDesc) {
+        return GMatDesc { CV_8U, 1, frameDesc.size , false };
+    }
+};
+
+G_API_OP(GUV, <GMat(GFrame)>, "org.opencv.streaming.UV") {
+    static GMatDesc outMeta(const GFrameDesc& frameDesc) {
+        return GMatDesc { CV_8U, 2, cv::Size(frameDesc.size.width / 2, frameDesc.size.height / 2),
+                          false };
+    }
+};
+
+/** @brief Gets bgr plane from input frame
+
+@note Function textual ID is "org.opencv.streaming.BGR"
+
+@param in Input frame
+@return Image in BGR format
+*/
+GAPI_EXPORTS cv::GMat BGR(const cv::GFrame& in);
+
+/** @brief Extracts Y plane from media frame.
+
+Output image is 8-bit 1-channel image of @ref CV_8UC1.
+
+@note Function textual ID is "org.opencv.streaming.Y"
+
+@param frame input media frame.
+*/
+GAPI_EXPORTS GMat Y(const cv::GFrame& frame);
+
+/** @brief Extracts UV plane from media frame.
+
+Output image is 8-bit 2-channel image of @ref CV_8UC2.
+
+@note Function textual ID is "org.opencv.streaming.UV"
+
+@param frame input media frame.
+*/
+GAPI_EXPORTS GMat UV(const cv::GFrame& frame);
+} // namespace streaming
+
+//! @addtogroup gapi_transform
+//! @{
+/** @brief Makes a copy of the input image. Note that this copy may be not real
+(no actual data copied). Use this function to maintain graph contracts,
+e.g when graph's input needs to be passed directly to output, like in Streaming mode.
+
+@note Function textual ID is "org.opencv.streaming.copy"
+
+@param in Input image
+@return Copy of the input
+*/
+GAPI_EXPORTS_W GMat copy(const GMat& in);
+
+/** @brief Makes a copy of the input frame. Note that this copy may be not real
+(no actual data copied). Use this function to maintain graph contracts,
+e.g when graph's input needs to be passed directly to output, like in Streaming mode.
+
+@note Function textual ID is "org.opencv.streaming.copy"
+
+@param in Input frame
+@return Copy of the input
+*/
+GAPI_EXPORTS GFrame copy(const GFrame& in);
+//! @} gapi_transform
+
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_GSTREAMING_FORMAT_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/meta.hpp

@@ -0,0 +1,79 @@
+// 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) 2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_GSTREAMING_META_HPP
+#define OPENCV_GAPI_GSTREAMING_META_HPP
+
+#include <opencv2/gapi/gopaque.hpp>
+#include <opencv2/gapi/gcall.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/gtype_traits.hpp>
+
+namespace cv {
+namespace gapi {
+namespace streaming {
+
+// FIXME: the name is debatable
+namespace meta_tag {
+static constexpr const char * timestamp = "org.opencv.gapi.meta.timestamp";
+static constexpr const char * seq_id    = "org.opencv.gapi.meta.seq_id";
+} // namespace meta_tag
+
+namespace detail {
+struct GMeta {
+    static const char *id() {
+        return "org.opencv.streaming.meta";
+    }
+    // A universal yield for meta(), same as in GDesync
+    template<typename... R, int... IIs>
+    static std::tuple<R...> yield(cv::GCall &call, cv::detail::Seq<IIs...>) {
+        return std::make_tuple(cv::detail::Yield<R>::yield(call, IIs)...);
+    }
+    // Also a universal outMeta stub here
+    static GMetaArgs getOutMeta(const GMetaArgs &args, const GArgs &) {
+        return args;
+    }
+};
+} // namespace detail
+
+template<typename T, typename G>
+cv::GOpaque<T> meta(G g, const std::string &tag) {
+    using O = cv::GOpaque<T>;
+    cv::GKernel k{
+          detail::GMeta::id()                    // kernel id
+        , tag                                    // kernel tag. Use meta tag here
+        , &detail::GMeta::getOutMeta             // outMeta callback
+        , {cv::detail::GTypeTraits<O>::shape}    // output Shape
+        , {cv::detail::GTypeTraits<G>::op_kind}  // input data kinds
+        , {cv::detail::GObtainCtor<O>::get()}    // output template ctors
+    };
+    cv::GCall call(std::move(k));
+    call.pass(g);
+    return std::get<0>(detail::GMeta::yield<O>(call, cv::detail::MkSeq<1>::type()));
+}
+
+template<typename G>
+cv::GOpaque<int64_t> timestamp(G g) {
+    return meta<int64_t>(g, meta_tag::timestamp);
+}
+
+template<typename G>
+cv::GOpaque<int64_t> seq_id(G g) {
+    return meta<int64_t>(g, meta_tag::seq_id);
+}
+
+template<typename G>
+cv::GOpaque<int64_t> seqNo(G g) {
+    // Old name, compatibility only
+    return seq_id(g);
+}
+
+} // namespace streaming
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_GSTREAMING_META_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp

@@ -0,0 +1,88 @@
+// 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) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_STREAMING_ONEVPL_CFG_PARAMS_HPP
+#define OPENCV_GAPI_STREAMING_ONEVPL_CFG_PARAMS_HPP
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include <opencv2/gapi/streaming/source.hpp>
+#include <opencv2/gapi/util/variant.hpp>
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+
+/**
+ * @brief Public class is using for creation of onevpl::GSource instances.
+ *
+ * Class members availaible through methods @ref CfgParam::get_name() and @ref CfgParam::get_value() are used by
+ * onevpl::GSource inner logic to create or find oneVPL particular implementation
+ * (software/hardware, specific API version and etc.).
+ *
+ * @note Because oneVPL may provide several implementations which are satisfying with multiple (or single one) @ref CfgParam
+ * criteria therefore it is possible to configure `preferred` parameters. This kind of CfgParams are created
+ * using `is_major = false` argument in @ref CfgParam::create method and are not used by creating oneVPL particular implementations.
+ * Instead they fill out a "score table" to select preferrable implementation from available list. Implementation are satisfying
+ * with most of these optional params would be chosen.
+ * If no one optional CfgParam params were present then first of available oneVPL implementation would be applied.
+ * Please get on https://spec.oneapi.io/versions/latest/elements/oneVPL/source/API_ref/VPL_disp_api_func.html?highlight=mfxcreateconfig#mfxsetconfigfilterproperty
+ * for using OneVPL configuration. In this schema `mfxU8 *name` represents @ref CfgParam::get_name() and
+ * `mfxVariant value` is @ref CfgParam::get_value()
+ */
+struct GAPI_EXPORTS CfgParam {
+    using name_t = std::string;
+    using value_t = cv::util::variant<uint8_t, int8_t,
+                                      uint16_t, int16_t,
+                                      uint32_t, int32_t,
+                                      uint64_t, int64_t,
+                                      float_t,
+                                      double_t,
+                                      void*,
+                                      std::string>;
+
+    /**
+     * Create onevp::GSource configuration parameter.
+     *
+     *@param name           name of parameter.
+     *@param value          value of parameter.
+     *@param is_major       TRUE if parameter MUST be provided by OneVPL inner implementation, FALSE for optional (for resolve multiple available implementations).
+     *
+     */
+    template<typename ValueType>
+    static CfgParam create(const std::string& name, ValueType&& value, bool is_major = true) {
+        CfgParam param(name, CfgParam::value_t(std::forward<ValueType>(value)), is_major);
+        return param;
+    }
+
+    struct Priv;
+
+    const name_t& get_name() const;
+    const value_t& get_value() const;
+    bool is_major() const;
+    bool operator==(const CfgParam& rhs) const;
+    bool operator< (const CfgParam& rhs) const;
+    bool operator!=(const CfgParam& rhs) const;
+
+    CfgParam& operator=(const CfgParam& src);
+    CfgParam& operator=(CfgParam&& src);
+    CfgParam(const CfgParam& src);
+    CfgParam(CfgParam&& src);
+    ~CfgParam();
+private:
+    CfgParam(const std::string& param_name, value_t&& param_value, bool is_major_param);
+    std::shared_ptr<Priv> m_priv;
+};
+
+} //namespace onevpl
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_STREAMING_ONEVPL_CFG_PARAMS_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/onevpl/data_provider_interface.hpp

@@ -0,0 +1,74 @@
+// 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) 2021 Intel Corporation
+
+#ifndef GAPI_STREAMING_ONEVPL_ONEVPL_DATA_PROVIDER_INTERFACE_HPP
+#define GAPI_STREAMING_ONEVPL_ONEVPL_DATA_PROVIDER_INTERFACE_HPP
+#include <exception>
+#include <string>
+
+#include <opencv2/gapi/own/exports.hpp> // GAPI_EXPORTS
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+
+struct GAPI_EXPORTS DataProviderException : public std::exception {
+    virtual ~DataProviderException() {};
+};
+
+struct GAPI_EXPORTS DataProviderSystemErrorException : public DataProviderException {
+    DataProviderSystemErrorException(int error_code, const std::string& desription = std::string());
+    virtual ~DataProviderSystemErrorException();
+    virtual const char* what() const noexcept override;
+
+private:
+    std::string reason;
+};
+
+/**
+ * @brief Public interface allows to customize extraction of video stream data
+ * used by onevpl::GSource instead of reading stream from file (by default).
+ *
+ * Interface implementation constructor MUST provide consistency and creates fully operable object.
+ * If error happened implementation MUST throw `DataProviderException` kind exceptions
+ *
+ * @note Interface implementation MUST manage stream and other constructed resources by itself to avoid any kind of leak.
+ * For simple interface implementation example please see `StreamDataProvider` in `tests/streaming/gapi_streaming_tests.cpp`
+ */
+struct GAPI_EXPORTS IDataProvider {
+    using Ptr = std::shared_ptr<IDataProvider>;
+
+    virtual ~IDataProvider() {};
+
+    /**
+     * The function is used by onevpl::GSource to extract binary data stream from @ref IDataProvider
+     * implementation.
+     *
+     * It MUST throw `DataProviderException` kind exceptions in fail cases.
+     * It MUST return 0 in EOF which considered as not-fail case.
+     *
+     * @param out_data_bytes_size the available capacity of out_data buffer.
+     * @param out_data the output consumer buffer with capacity out_data_bytes_size.
+     * @return fetched bytes count.
+     */
+    virtual size_t fetch_data(size_t out_data_bytes_size, void* out_data) = 0;
+
+    /**
+     * The function is used by onevpl::GSource to check more binary data availability.
+     *
+     * It MUST return TRUE in case of EOF and NO_THROW exceptions.
+     *
+     * @return boolean value which detects end of stream
+     */
+    virtual bool empty() const = 0;
+};
+} // namespace onevpl
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // GAPI_STREAMING_ONEVPL_ONEVPL_DATA_PROVIDER_INTERFACE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/onevpl/source.hpp

@@ -0,0 +1,64 @@
+// 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) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_STREAMING_ONEVPL_ONEVPL_SOURCE_HPP
+#define OPENCV_GAPI_STREAMING_ONEVPL_ONEVPL_SOURCE_HPP
+
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/streaming/meta.hpp>
+#include <opencv2/gapi/streaming/source.hpp>
+#include <opencv2/gapi/streaming/onevpl/cfg_params.hpp>
+#include <opencv2/gapi/streaming/onevpl/data_provider_interface.hpp>
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+using CfgParams = std::vector<CfgParam>;
+
+/**
+ * @brief G-API streaming source based on OneVPL implementation.
+ *
+ * This class implements IStreamSource interface.
+ * Its constructor takes source file path (in usual way) or @ref onevpl::IDataProvider
+ * interface implementation (for not file-based sources). It also allows to pass-through
+ * oneVPL configuration parameters by using several @ref onevpl::CfgParam.
+ *
+ * @note stream sources are passed to G-API via shared pointers, so
+ *  please gapi::make_onevpl_src<> to create objects and ptr() to pass a
+ *  GSource to cv::gin().
+ */
+class GAPI_EXPORTS GSource : public IStreamSource
+{
+public:
+    struct Priv;
+
+    GSource(const std::string& filePath,
+            const CfgParams& cfg_params = CfgParams{});
+    GSource(std::shared_ptr<IDataProvider> source,
+            const CfgParams& cfg_params = CfgParams{});
+    ~GSource() override;
+
+    bool pull(cv::gapi::wip::Data& data) override;
+    GMetaArg descr_of() const override;
+
+private:
+    explicit GSource(std::unique_ptr<Priv>&& impl);
+    std::unique_ptr<Priv> m_priv;
+};
+} // namespace onevpl
+
+template<class... Args>
+GAPI_EXPORTS_W cv::Ptr<IStreamSource> inline make_onevpl_src(Args&&... args)
+{
+    return make_src<onevpl::GSource>(std::forward<Args>(args)...);
+}
+
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_STREAMING_ONEVPL_ONEVPL_SOURCE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/source.hpp

@@ -0,0 +1,62 @@
+// 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_STREAMING_SOURCE_HPP
+#define OPENCV_GAPI_STREAMING_SOURCE_HPP
+
+#include <memory>                      // shared_ptr
+#include <type_traits>                 // is_base_of
+
+#include <opencv2/gapi/gmetaarg.hpp>   // GMetaArg
+
+
+namespace cv {
+namespace gapi {
+namespace wip {
+    struct Data; // "forward-declaration" of GRunArg
+
+/**
+ * @brief Abstract streaming pipeline source.
+ *
+ * Implement this interface if you want customize the way how data is
+ * streaming into GStreamingCompiled.
+ *
+ * Objects implementing this interface can be passed to
+ * GStreamingCompiled using setSource() with cv::gin(). Regular
+ * compiled graphs (GCompiled) don't support input objects of this
+ * type.
+ *
+ * Default cv::VideoCapture-based implementation is available, see
+ * cv::gapi::wip::GCaptureSource.
+ *
+ * @note stream sources are passed to G-API via shared pointers, so
+ *  please use ptr() when passing a IStreamSource implementation to
+ *  cv::gin().
+ */
+class IStreamSource: public std::enable_shared_from_this<IStreamSource>
+{
+public:
+    using Ptr = std::shared_ptr<IStreamSource>;
+    Ptr ptr() { return shared_from_this(); }
+    virtual bool pull(Data &data) = 0;
+    virtual GMetaArg descr_of() const = 0;
+    virtual ~IStreamSource() = default;
+};
+
+template<class T, class... Args>
+IStreamSource::Ptr inline make_src(Args&&... args)
+{
+    static_assert(std::is_base_of<IStreamSource, T>::value,
+                  "T must implement the cv::gapi::IStreamSource interface!");
+    auto src_ptr = std::make_shared<T>(std::forward<Args>(args)...);
+    return src_ptr->ptr();
+}
+
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_STREAMING_SOURCE_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/streaming/sync.hpp

@@ -0,0 +1,30 @@
+// 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) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_STREAMING_SYNC_HPP
+#define OPENCV_GAPI_STREAMING_SYNC_HPP
+
+namespace cv {
+namespace gapi {
+namespace streaming {
+
+enum class sync_policy {
+    dont_sync,
+    drop
+};
+
+} // namespace streaming
+} // namespace gapi
+
+namespace detail {
+    template<> struct CompileArgTag<gapi::streaming::sync_policy> {
+        static const char* tag() { return "gapi.streaming.sync_policy"; }
+    };
+
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_GAPI_STREAMING_SYNC_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/util/any.hpp

@@ -0,0 +1,186 @@
+// 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_UTIL_ANY_HPP
+#define OPENCV_GAPI_UTIL_ANY_HPP
+
+#include <memory>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+#include <opencv2/gapi/util/throw.hpp>
+
+#if defined(_MSC_VER)
+   // disable MSVC warning on "multiple copy constructors specified"
+#  pragma warning(disable: 4521)
+#endif
+
+namespace cv
+{
+
+namespace internal
+{
+    template <class T, class Source>
+    T down_cast(Source operand)
+    {
+#if defined(__GXX_RTTI) || defined(_CPPRTTI)
+       return dynamic_cast<T>(operand);
+#else
+    #warning used static cast instead of dynamic because RTTI is disabled
+       return static_cast<T>(operand);
+#endif
+    }
+}
+
+namespace util
+{
+   class bad_any_cast : public std::bad_cast
+   {
+   public:
+       virtual const char* what() const noexcept override
+       {
+           return "Bad any cast";
+       }
+   };
+
+   //modeled against C++17 std::any
+
+   class any
+   {
+   private:
+      struct holder;
+      using holder_ptr = std::unique_ptr<holder>;
+      struct holder
+      {
+         virtual holder_ptr clone() = 0;
+         virtual ~holder() = default;
+      };
+
+      template <typename value_t>
+      struct holder_impl : holder
+      {
+         value_t v;
+         template<typename arg_t>
+         holder_impl(arg_t&& a) : v(std::forward<arg_t>(a)) {}
+         holder_ptr clone() override { return holder_ptr(new holder_impl (v));}
+      };
+
+      holder_ptr hldr;
+   public:
+      template<class value_t>
+      any(value_t&& arg) :  hldr(new holder_impl<typename std::decay<value_t>::type>( std::forward<value_t>(arg))) {}
+
+      any(any const& src) : hldr( src.hldr ? src.hldr->clone() : nullptr) {}
+      //simple hack in order not to write enable_if<not any> for the template constructor
+      any(any & src) : any (const_cast<any const&>(src)) {}
+
+      any()       = default;
+      any(any&& ) = default;
+
+      any& operator=(any&&) = default;
+
+      any& operator=(any const& src)
+      {
+         any copy(src);
+         swap(*this, copy);
+         return *this;
+      }
+
+      template<class value_t>
+      friend value_t* any_cast(any* operand);
+
+      template<class value_t>
+      friend const value_t* any_cast(const any* operand);
+
+      template<class value_t>
+      friend value_t& unsafe_any_cast(any& operand);
+
+      template<class value_t>
+      friend const value_t& unsafe_any_cast(const any& operand);
+
+      friend void swap(any & lhs, any& rhs)
+      {
+         swap(lhs.hldr, rhs.hldr);
+      }
+
+   };
+
+   template<class value_t>
+   value_t* any_cast(any* operand)
+   {
+      auto casted = internal::down_cast<any::holder_impl<typename std::decay<value_t>::type> *>(operand->hldr.get());
+      if (casted){
+         return & (casted->v);
+      }
+      return nullptr;
+   }
+
+   template<class value_t>
+   const value_t* any_cast(const any* operand)
+   {
+      auto casted = internal::down_cast<any::holder_impl<typename std::decay<value_t>::type> *>(operand->hldr.get());
+      if (casted){
+         return & (casted->v);
+      }
+      return nullptr;
+   }
+
+   template<class value_t>
+   value_t& any_cast(any& operand)
+   {
+      auto ptr = any_cast<value_t>(&operand);
+      if (ptr)
+      {
+         return *ptr;
+      }
+
+      throw_error(bad_any_cast());
+   }
+
+
+   template<class value_t>
+   const value_t& any_cast(const any& operand)
+   {
+      auto ptr = any_cast<value_t>(&operand);
+      if (ptr)
+      {
+         return *ptr;
+      }
+
+      throw_error(bad_any_cast());
+   }
+
+   template<class value_t>
+   inline value_t& unsafe_any_cast(any& operand)
+   {
+#ifdef DEBUG
+      return any_cast<value_t>(operand);
+#else
+      return static_cast<any::holder_impl<typename std::decay<value_t>::type> *>(operand.hldr.get())->v;
+#endif
+   }
+
+   template<class value_t>
+   inline const value_t& unsafe_any_cast(const any& operand)
+   {
+#ifdef DEBUG
+      return any_cast<value_t>(operand);
+#else
+      return static_cast<any::holder_impl<typename std::decay<value_t>::type> *>(operand.hldr.get())->v;
+#endif
+   }
+
+} // namespace util
+} // namespace cv
+
+#if defined(_MSC_VER)
+   // Enable "multiple copy constructors specified" back
+#  pragma warning(default: 4521)
+#endif
+
+#endif // OPENCV_GAPI_UTIL_ANY_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/util/compiler_hints.hpp

@@ -0,0 +1,19 @@
+// 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_UTIL_COMPILER_HINTS_HPP
+#define OPENCV_GAPI_UTIL_COMPILER_HINTS_HPP
+
+namespace cv
+{
+namespace util
+{
+    //! Utility template function to prevent "unused" warnings by various compilers.
+    template<typename T> void suppress_unused_warning( const T& ) {}
+} // namespace util
+} // namespace cv
+
+#endif /* OPENCV_GAPI_UTIL_COMPILER_HINTS_HPP */

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/util/copy_through_move.hpp

@@ -0,0 +1,34 @@
+// 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) 2020 Intel Corporation
+
+#ifndef OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP
+#define OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP
+
+#include <opencv2/gapi/util/type_traits.hpp> //decay_t
+
+namespace cv
+{
+namespace util
+{
+    //This is a tool to move initialize captures of a lambda in C++11
+    template<typename T>
+    struct copy_through_move_t{
+       T value;
+       const T& get() const {return value;}
+       T&       get()       {return value;}
+       copy_through_move_t(T&& g) : value(std::move(g)) {}
+       copy_through_move_t(copy_through_move_t&&) = default;
+       copy_through_move_t(copy_through_move_t const& lhs) : copy_through_move_t(std::move(const_cast<copy_through_move_t&>(lhs))) {}
+    };
+
+    template<typename T>
+    copy_through_move_t<util::decay_t<T>> copy_through_move(T&& t){
+        return std::forward<T>(t);
+    }
+} // namespace util
+} // namespace cv
+
+#endif /* OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP */

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/util/optional.hpp

@@ -0,0 +1,178 @@
+// 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_UTIL_OPTIONAL_HPP
+#define OPENCV_GAPI_UTIL_OPTIONAL_HPP
+
+#include <opencv2/gapi/util/variant.hpp>
+
+// A poor man's `optional` implementation, incompletely modeled against C++17 spec.
+namespace cv
+{
+namespace util
+{
+    class bad_optional_access: public std::exception
+    {
+    public:
+        virtual const char *what() const noexcept override
+        {
+            return "Bad optional access";
+        }
+    };
+
+    // TODO: nullopt_t
+
+    // Interface ///////////////////////////////////////////////////////////////
+    template<typename T> class optional
+    {
+    public:
+        // Constructors
+        // NB.: there were issues with Clang 3.8 when =default() was used
+        // instead {}
+        optional() {};
+        optional(const optional&) = default;
+        explicit optional(T&&) noexcept;
+        explicit optional(const T&) noexcept;
+        optional(optional&&) noexcept;
+        // TODO: optional(nullopt_t) noexcept;
+        // TODO: optional(const optional<U> &)
+        // TODO: optional(optional<U> &&)
+        // TODO: optional(Args&&...)
+        // TODO: optional(initializer_list<U>)
+        // TODO: optional(U&& value);
+
+        // Assignment
+        optional& operator=(const optional&) = default;
+        optional& operator=(optional&&);
+
+        // Observers
+        T* operator-> ();
+        const T* operator-> () const;
+        T& operator* ();
+        const T& operator* () const;
+        // TODO: && versions
+
+        operator bool() const noexcept;
+        bool has_value() const noexcept;
+
+        T& value();
+        const T& value() const;
+        // TODO: && versions
+
+        template<class U>
+        T value_or(U &&default_value) const;
+
+        void swap(optional &other) noexcept;
+        void reset() noexcept;
+        // TODO: emplace
+
+        // TODO: operator==, !=, <, <=, >, >=
+
+    private:
+        struct nothing {};
+        util::variant<nothing, T> m_holder;
+    };
+
+    template<class T>
+    optional<typename std::decay<T>::type> make_optional(T&& value);
+
+    // TODO: Args... and initializer_list versions
+
+    // Implementation //////////////////////////////////////////////////////////
+    template<class T> optional<T>::optional(T &&v) noexcept
+        : m_holder(std::move(v))
+    {
+    }
+
+    template<class T> optional<T>::optional(const T &v) noexcept
+        : m_holder(v)
+    {
+    }
+
+    template<class T> optional<T>::optional(optional&& rhs) noexcept
+        : m_holder(std::move(rhs.m_holder))
+    {
+        rhs.reset();
+    }
+
+    template<class T> optional<T>& optional<T>::operator=(optional&& rhs)
+    {
+        m_holder = std::move(rhs.m_holder);
+        rhs.reset();
+        return *this;
+    }
+
+    template<class T> T* optional<T>::operator-> ()
+    {
+        return & *(*this);
+    }
+
+    template<class T> const T* optional<T>::operator-> () const
+    {
+        return & *(*this);
+    }
+
+    template<class T> T& optional<T>::operator* ()
+    {
+        return this->value();
+    }
+
+    template<class T> const T& optional<T>::operator* () const
+    {
+        return this->value();
+    }
+
+    template<class T> optional<T>::operator bool() const noexcept
+    {
+        return this->has_value();
+    }
+
+    template<class T> bool optional<T>::has_value() const noexcept
+    {
+        return util::holds_alternative<T>(m_holder);
+    }
+
+    template<class T> T& optional<T>::value()
+    {
+        if (!this->has_value())
+            throw_error(bad_optional_access());
+        return util::get<T>(m_holder);
+    }
+
+    template<class T> const T& optional<T>::value() const
+    {
+        if (!this->has_value())
+            throw_error(bad_optional_access());
+        return util::get<T>(m_holder);
+    }
+
+    template<class T>
+    template<class U> T optional<T>::value_or(U &&default_value) const
+    {
+        return (this->has_value() ? this->value() : T(default_value));
+    }
+
+    template<class T> void optional<T>::swap(optional<T> &other) noexcept
+    {
+        m_holder.swap(other.m_holder);
+    }
+
+    template<class T> void optional<T>::reset() noexcept
+    {
+        if (this->has_value())
+            m_holder = nothing{};
+    }
+
+    template<class T>
+    optional<typename std::decay<T>::type> make_optional(T&& value)
+    {
+        return optional<typename std::decay<T>::type>(std::forward<T>(value));
+    }
+} // namespace util
+} // namespace cv
+
+#endif // OPENCV_GAPI_UTIL_OPTIONAL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/util/throw.hpp

@@ -0,0 +1,36 @@
+// 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_UTIL_THROW_HPP
+#define OPENCV_GAPI_UTIL_THROW_HPP
+
+#include <utility>  // std::forward
+
+#if !defined(__EXCEPTIONS)
+#include <stdlib.h>
+#include <stdio.h>
+#endif
+
+namespace cv
+{
+namespace util
+{
+template <class ExceptionType>
+[[noreturn]] void throw_error(ExceptionType &&e)
+{
+#if defined(__EXCEPTIONS) || defined(_CPPUNWIND)
+    throw std::forward<ExceptionType>(e);
+#else
+    fprintf(stderr, "An exception thrown! %s\n" , e.what());
+    fflush(stderr);
+    abort();
+#endif
+}
+} // namespace util
+} // namespace cv
+
+#endif // OPENCV_GAPI_UTIL_THROW_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/util/type_traits.hpp

@@ -0,0 +1,31 @@
+// 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) 2020 Intel Corporation
+
+
+#ifndef OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP
+#define OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP
+
+#include <type_traits>
+
+namespace cv
+{
+namespace util
+{
+    //these are C++14 parts of type_traits :
+    template< bool B, class T = void >
+    using enable_if_t = typename std::enable_if<B,T>::type;
+
+    template<typename T>
+    using decay_t = typename std::decay<T>::type;
+
+    //this is not part of C++14 but still, of pretty common usage
+    template<class T, class U, class V = void>
+    using are_different_t = enable_if_t< !std::is_same<decay_t<T>, decay_t<U>>::value, V>;
+
+} // namespace cv
+} // namespace util
+
+#endif // OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/util/util.hpp

@@ -0,0 +1,183 @@
+// 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
+
+
+#ifndef OPENCV_GAPI_UTIL_HPP
+#define OPENCV_GAPI_UTIL_HPP
+
+#include <tuple>
+
+// \cond HIDDEN_SYMBOLS
+// This header file contains some generic utility functions which are
+// used in other G-API Public API headers.
+//
+// PLEASE don't put any stuff here if it is NOT used in public API headers!
+
+namespace cv
+{
+namespace detail
+{
+    // Recursive integer sequence type, useful for enumerating elements of
+    // template parameter packs.
+    template<int... I> struct Seq     { using next = Seq<I..., sizeof...(I)>; };
+    template<int Sz>   struct MkSeq   { using type = typename MkSeq<Sz-1>::type::next; };
+    template<>         struct MkSeq<0>{ using type = Seq<>; };
+
+    // Checks if elements of variadic template satisfy the given Predicate.
+    // Implemented via tuple, with an interface to accept plain type lists
+    template<template<class> class, typename, typename...> struct all_satisfy;
+
+    template<template<class> class F, typename T, typename... Ts>
+    struct all_satisfy<F, std::tuple<T, Ts...> >
+    {
+        static const constexpr bool value = F<T>::value
+            && all_satisfy<F, std::tuple<Ts...> >::value;
+    };
+    template<template<class> class F, typename T>
+    struct all_satisfy<F, std::tuple<T> >
+    {
+        static const constexpr bool value = F<T>::value;
+    };
+
+    template<template<class> class F, typename T, typename... Ts>
+    struct all_satisfy: public all_satisfy<F, std::tuple<T, Ts...> > {};
+
+    // Permute given tuple type C with given integer sequence II
+    // Sequence may be less than tuple C size.
+    template<class, class> struct permute_tuple;
+
+    template<class C, int... IIs>
+    struct permute_tuple<C, Seq<IIs...> >
+    {
+        using type = std::tuple< typename std::tuple_element<IIs, C>::type... >;
+    };
+
+    // Given T..., generates a type sequence of sizeof...(T)-1 elements
+    // which is T... without its last element
+    // Implemented via tuple, with an interface to accept plain type lists
+    template<typename T, typename... Ts> struct all_but_last;
+
+    template<typename T, typename... Ts>
+    struct all_but_last<std::tuple<T, Ts...> >
+    {
+        using C    = std::tuple<T, Ts...>;
+        using S    = typename MkSeq<std::tuple_size<C>::value - 1>::type;
+        using type = typename permute_tuple<C, S>::type;
+    };
+
+    template<typename T, typename... Ts>
+    struct all_but_last: public all_but_last<std::tuple<T, Ts...> > {};
+
+    template<typename... Ts>
+    using all_but_last_t = typename all_but_last<Ts...>::type;
+
+    // NB.: This is here because there's no constexpr std::max in C++11
+    template<std::size_t S0, std::size_t... SS> struct max_of_t
+    {
+        static constexpr const std::size_t rest  = max_of_t<SS...>::value;
+        static constexpr const std::size_t value = rest > S0 ? rest : S0;
+    };
+    template<std::size_t S> struct max_of_t<S>
+    {
+        static constexpr const std::size_t value = S;
+    };
+
+    template <typename...>
+    struct contains : std::false_type{};
+
+    template <typename T1, typename T2, typename... Ts>
+    struct contains<T1, T2, Ts...> : std::integral_constant<bool, std::is_same<T1, T2>::value ||
+                                                                  contains<T1, Ts...>::value> {};
+    template<typename T, typename... Types>
+    struct contains<T, std::tuple<Types...>> : std::integral_constant<bool, contains<T, Types...>::value> {};
+
+    template <typename...>
+    struct all_unique : std::true_type{};
+
+    template <typename T1, typename... Ts>
+    struct all_unique<T1, Ts...> : std::integral_constant<bool, !contains<T1, Ts...>::value &&
+                                                                 all_unique<Ts...>::value> {};
+
+    template<typename>
+    struct tuple_wrap_helper;
+
+    template<typename T> struct tuple_wrap_helper
+    {
+        using type = std::tuple<T>;
+        static type get(T&& obj) { return std::make_tuple(std::move(obj)); }
+    };
+
+    template<typename... Objs>
+    struct tuple_wrap_helper<std::tuple<Objs...>>
+    {
+        using type = std::tuple<Objs...>;
+        static type get(std::tuple<Objs...>&& objs) { return std::forward<std::tuple<Objs...>>(objs); }
+    };
+} // namespace detail
+
+namespace util
+{
+template<typename ...L>
+struct overload_lamba_set;
+
+template<typename L1>
+struct overload_lamba_set<L1> : public L1
+{
+    overload_lamba_set(L1&& lambda) : L1(std::move(lambda)) {}
+    overload_lamba_set(const L1& lambda) : L1(lambda) {}
+
+    using L1::operator();
+};
+
+template<typename L1, typename ...L>
+struct overload_lamba_set<L1, L...> : public L1, public overload_lamba_set<L...>
+{
+    using base_type = overload_lamba_set<L...>;
+    overload_lamba_set(L1 &&lambda1, L&& ...lambdas):
+        L1(std::move(lambda1)),
+        base_type(std::forward<L>(lambdas)...) {}
+
+    overload_lamba_set(const L1 &lambda1, L&& ...lambdas):
+        L1(lambda1),
+        base_type(std::forward<L>(lambdas)...) {}
+
+    using L1::operator();
+    using base_type::operator();
+};
+
+template<typename... L>
+overload_lamba_set<L...> overload_lambdas(L&& ...lambdas)
+{
+    return overload_lamba_set<L...>(std::forward<L>(lambdas)...);
+}
+
+template<typename ...T>
+struct find_adapter_impl;
+
+template<typename AdapterT, typename T>
+struct find_adapter_impl<AdapterT, T>
+{
+    using type = typename std::conditional<std::is_base_of<AdapterT, T>::value,
+                                           T,
+                                           void>::type;
+    static constexpr bool found = std::is_base_of<AdapterT, T>::value;
+};
+
+template<typename AdapterT, typename T, typename... Types>
+struct find_adapter_impl<AdapterT, T, Types...>
+{
+    using type = typename std::conditional<std::is_base_of<AdapterT, T>::value,
+                                           T,
+                                           typename find_adapter_impl<AdapterT, Types...>::type>::type;
+    static constexpr bool found = std::is_base_of<AdapterT, T>::value ||
+                                  find_adapter_impl<AdapterT, Types...>::found;
+};
+} // namespace util
+} // namespace cv
+
+// \endcond
+
+#endif //  OPENCV_GAPI_UTIL_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/util/variant.hpp

@@ -0,0 +1,658 @@
+// 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_UTIL_VARIANT_HPP
+#define OPENCV_GAPI_UTIL_VARIANT_HPP
+
+#include <array>
+#include <type_traits>
+
+#include <opencv2/gapi/util/compiler_hints.hpp>
+#include <opencv2/gapi/util/throw.hpp>
+#include <opencv2/gapi/util/util.hpp> // max_of_t
+#include <opencv2/gapi/util/type_traits.hpp>
+
+// A poor man's `variant` implementation, incompletely modeled against C++17 spec.
+namespace cv
+{
+namespace util
+{
+    namespace detail
+    {
+        template<std::size_t I, typename Target, typename First, typename... Remaining>
+        struct type_list_index_helper
+        {
+            static const constexpr bool is_same = std::is_same<Target, First>::value;
+            static const constexpr std::size_t value =
+                std::conditional<is_same, std::integral_constant<std::size_t, I>, type_list_index_helper<I + 1, Target, Remaining...>>::type::value;
+        };
+
+        template<std::size_t I, typename Target, typename First>
+        struct type_list_index_helper<I, Target, First>
+        {
+            static_assert(std::is_same<Target, First>::value, "Type not found");
+            static const constexpr std::size_t value = I;
+        };
+    }
+
+    template<typename Target, typename... Types>
+    struct type_list_index
+    {
+        static const constexpr std::size_t value = detail::type_list_index_helper<0, Target, Types...>::value;
+    };
+
+    template<std::size_t Index, class... Types >
+    struct type_list_element
+    {
+        using type = typename std::tuple_element<Index, std::tuple<Types...> >::type;
+    };
+
+    class bad_variant_access: public std::exception
+    {
+    public:
+        virtual const char *what() const noexcept override
+        {
+            return "Bad variant access";
+        }
+    };
+
+    // Interface ///////////////////////////////////////////////////////////////
+    struct monostate {};
+    inline bool operator==(const util::monostate&, const util::monostate&)
+    {
+        return true;
+    }
+
+    template<typename... Ts> // FIXME: no references, arrays, and void
+    class variant
+    {
+        // FIXME: Replace with std::aligned_union after gcc4.8 support is dropped
+        static constexpr const std::size_t S = cv::detail::max_of_t<sizeof(Ts)...>::value;
+        static constexpr const std::size_t A = cv::detail::max_of_t<alignof(Ts)...>::value;
+        using Memory = typename std::aligned_storage<S, A>::type[1];
+
+        template<typename T> struct cctr_h {
+            static void help(Memory memory, const Memory from) {
+                new (memory) T(*reinterpret_cast<const T*>(from));
+            }
+        };
+
+        template<typename T> struct mctr_h {
+            static void help(Memory memory, void *pval) {
+                new (memory) T(std::move(*reinterpret_cast<T*>(pval)));
+            }
+        };
+
+        //FIXME: unify with cctr_h and mctr_h
+        template<typename T> struct cnvrt_ctor_h {
+            static void help(Memory memory, void* from) {
+                using util::decay_t;
+                new (memory) decay_t<T>(std::forward<T>(*reinterpret_cast<decay_t<T>*>(from)));
+            }
+        };
+
+        template<typename T> struct copy_h {
+            static void help(Memory to, const Memory from) {
+                *reinterpret_cast<T*>(to) = *reinterpret_cast<const T*>(from);
+            }
+        };
+
+        template<typename T> struct move_h {
+            static void help(Memory to, Memory from) {
+                *reinterpret_cast<T*>(to) = std::move(*reinterpret_cast<T*>(from));
+            }
+        };
+
+        //FIXME: unify with copy_h and move_h
+        template<typename T> struct cnvrt_assign_h {
+            static void help(Memory to, void* from) {
+                using util::decay_t;
+                *reinterpret_cast<decay_t<T>*>(to) = std::forward<T>(*reinterpret_cast<decay_t<T>*>(from));
+            }
+        };
+
+        template<typename T> struct swap_h {
+            static void help(Memory to, Memory from) {
+                std::swap(*reinterpret_cast<T*>(to), *reinterpret_cast<T*>(from));
+            }
+        };
+
+        template<typename T> struct dtor_h {
+            static void help(Memory memory) {
+                (void) memory; // MSCV warning
+                reinterpret_cast<T*>(memory)->~T();
+            }
+        };
+
+        template<typename T> struct equal_h {
+            static bool help(const Memory lhs, const Memory rhs) {
+                const T& t_lhs = *reinterpret_cast<const T*>(lhs);
+                const T& t_rhs = *reinterpret_cast<const T*>(rhs);
+                return t_lhs == t_rhs;
+            }
+        };
+
+        typedef void (*CCtr) (Memory, const Memory);  // Copy c-tor (variant)
+        typedef void (*MCtr) (Memory, void*);         // Generic move c-tor
+        typedef void (*Copy) (Memory, const Memory);  // Copy assignment
+        typedef void (*Move) (Memory, Memory);        // Move assignment
+
+        typedef void (*Swap) (Memory, Memory);        // Swap
+        typedef void (*Dtor) (Memory);                // Destructor
+
+        using  cnvrt_assgn_t   = void (*) (Memory, void*);  // Converting assignment (via std::forward)
+        using  cnvrt_ctor_t    = void (*) (Memory, void*);  // Converting constructor (via std::forward)
+
+        typedef bool (*Equal)(const Memory, const Memory); // Equality test (external)
+
+        static constexpr std::array<CCtr, sizeof...(Ts)> cctrs(){ return {{(&cctr_h<Ts>::help)...}};}
+        static constexpr std::array<MCtr, sizeof...(Ts)> mctrs(){ return {{(&mctr_h<Ts>::help)...}};}
+        static constexpr std::array<Copy, sizeof...(Ts)> cpyrs(){ return {{(&copy_h<Ts>::help)...}};}
+        static constexpr std::array<Move, sizeof...(Ts)> mvers(){ return {{(&move_h<Ts>::help)...}};}
+        static constexpr std::array<Swap, sizeof...(Ts)> swprs(){ return {{(&swap_h<Ts>::help)...}};}
+        static constexpr std::array<Dtor, sizeof...(Ts)> dtors(){ return {{(&dtor_h<Ts>::help)...}};}
+
+        template<bool cond, typename T>
+        struct conditional_ref : std::conditional<cond, typename std::remove_reference<T>::type&, typename std::remove_reference<T>::type > {};
+
+        template<bool cond, typename T>
+        using conditional_ref_t = typename conditional_ref<cond, T>::type;
+
+
+        template<bool is_lvalue_arg>
+        static constexpr std::array<cnvrt_assgn_t, sizeof...(Ts)> cnvrt_assgnrs(){
+            return {{(&cnvrt_assign_h<conditional_ref_t<is_lvalue_arg,Ts>>::help)...}};
+        }
+
+        template<bool is_lvalue_arg>
+        static constexpr std::array<cnvrt_ctor_t, sizeof...(Ts)> cnvrt_ctors(){
+            return {{(&cnvrt_ctor_h<conditional_ref_t<is_lvalue_arg,Ts>>::help)...}};
+        }
+
+        std::size_t m_index = 0;
+
+    protected:
+        template<typename T, typename... Us> friend T& get(variant<Us...> &v);
+        template<typename T, typename... Us> friend const T& get(const variant<Us...> &v);
+        template<typename T, typename... Us> friend T* get_if(variant<Us...> *v) noexcept;
+        template<typename T, typename... Us> friend const T* get_if(const variant<Us...> *v) noexcept;
+
+        template<typename... Us> friend bool operator==(const variant<Us...> &lhs,
+                                                        const variant<Us...> &rhs);
+        Memory memory;
+
+    public:
+        // Constructors
+        variant() noexcept;
+        variant(const variant& other);
+        variant(variant&& other) noexcept;
+        // are_different_t is a SFINAE trick to avoid variant(T &&t) with T=variant
+        // for some reason, this version is called instead of variant(variant&& o) when
+        // variant is used in STL containers (examples: vector assignment).
+        template<
+            typename T,
+            typename = util::are_different_t<variant, T>
+        >
+        explicit variant(T&& t);
+        // template<class T, class... Args> explicit variant(Args&&... args);
+        // FIXME: other constructors
+
+        // Destructor
+        ~variant();
+
+        // Assignment
+        variant& operator=(const variant& rhs);
+        variant& operator=(variant &&rhs) noexcept;
+
+        // SFINAE trick to avoid operator=(T&&) with T=variant<>, see comment above
+        template<
+            typename T,
+            typename = util::are_different_t<variant, T>
+        >
+        variant& operator=(T&& t) noexcept;
+
+        // Observers
+        std::size_t index() const noexcept;
+        // FIXME: valueless_by_exception()
+
+        // Modifiers
+        // FIXME: emplace()
+        void swap(variant &rhs) noexcept;
+
+        // Non-C++17x!
+        template<typename T> static constexpr std::size_t index_of();
+    };
+
+    // FIMXE: visit
+    template<typename T, typename... Types>
+    T* get_if(util::variant<Types...>* v) noexcept;
+
+    template<typename T, typename... Types>
+    const T* get_if(const util::variant<Types...>* v) noexcept;
+
+    template<typename T, typename... Types>
+    T& get(util::variant<Types...> &v);
+
+    template<typename T, typename... Types>
+    const T& get(const util::variant<Types...> &v);
+
+    template<std::size_t Index, typename... Types>
+    typename util::type_list_element<Index, Types...>::type& get(util::variant<Types...> &v);
+
+    template<std::size_t Index, typename... Types>
+    const typename util::type_list_element<Index, Types...>::type& get(const util::variant<Types...> &v);
+
+    template<typename T, typename... Types>
+    bool holds_alternative(const util::variant<Types...> &v) noexcept;
+
+
+    // Visitor
+    namespace detail
+    {
+        struct visitor_interface {};
+
+        // Class `visitor_return_type_deduction_helper`
+        // introduces solution for deduction `return_type` in `visit` function in common way
+        // for both Lambda and class Visitor and keep one interface invocation point: `visit` only
+        // his helper class is required to unify return_type deduction mechanism because
+        // for Lambda it is possible to take type of `decltype(visitor(get<0>(var)))`
+        // but for class Visitor there is no operator() in base case,
+        // because it provides `operator() (std::size_t index, ...)`
+        // So `visitor_return_type_deduction_helper` expose `operator()`
+        // uses only for class Visitor only for deduction `return type` in visit()
+        template<typename R>
+        struct visitor_return_type_deduction_helper
+        {
+            using return_type = R;
+
+            // to be used in Lambda return type deduction context only
+            template<typename T>
+            return_type operator() (T&&);
+        };
+    }
+
+    // Special purpose `static_visitor` can receive additional arguments
+    template<typename R, typename Impl>
+    struct static_visitor : public detail::visitor_interface,
+                            public detail::visitor_return_type_deduction_helper<R> {
+
+        // assign responsibility for return type deduction to helper class
+        using return_type = typename detail::visitor_return_type_deduction_helper<R>::return_type;
+        using detail::visitor_return_type_deduction_helper<R>::operator();
+        friend Impl;
+
+        template<typename VariantValue, typename ...Args>
+        return_type operator() (std::size_t index, VariantValue&& value, Args&& ...args)
+        {
+            suppress_unused_warning(index);
+            return static_cast<Impl*>(this)-> visit(
+                                                std::forward<VariantValue>(value),
+                                                std::forward<Args>(args)...);
+        }
+    };
+
+    // Special purpose `static_indexed_visitor` can receive additional arguments
+    // And make forwarding current variant index as runtime function argument to its `Impl`
+    template<typename R, typename Impl>
+    struct static_indexed_visitor : public detail::visitor_interface,
+                                    public detail::visitor_return_type_deduction_helper<R> {
+
+        // assign responsibility for return type deduction to helper class
+        using return_type = typename detail::visitor_return_type_deduction_helper<R>::return_type;
+        using detail::visitor_return_type_deduction_helper<R>::operator();
+        friend Impl;
+
+        template<typename VariantValue, typename ...Args>
+        return_type operator() (std::size_t Index, VariantValue&& value, Args&& ...args)
+        {
+            return static_cast<Impl*>(this)-> visit(Index,
+                                                std::forward<VariantValue>(value),
+                                                std::forward<Args>(args)...);
+        }
+    };
+
+    template <class T>
+    struct variant_size;
+
+    template <class... Types>
+    struct variant_size<util::variant<Types...>>
+        : std::integral_constant<std::size_t, sizeof...(Types)> { };
+    // FIXME: T&&, const TT&& versions.
+
+    // Implementation //////////////////////////////////////////////////////////
+    template<typename... Ts>
+    variant<Ts...>::variant() noexcept
+    {
+        typedef typename std::tuple_element<0, std::tuple<Ts...> >::type TFirst;
+        new (memory) TFirst();
+    }
+
+    template<typename... Ts>
+    variant<Ts...>::variant(const variant &other)
+        : m_index(other.m_index)
+    {
+        (cctrs()[m_index])(memory, other.memory);
+    }
+
+    template<typename... Ts>
+    variant<Ts...>::variant(variant &&other) noexcept
+        : m_index(other.m_index)
+    {
+        (mctrs()[m_index])(memory, other.memory);
+    }
+
+    template<typename... Ts>
+    template<class T, typename>
+    variant<Ts...>::variant(T&& t)
+        : m_index(util::type_list_index<util::decay_t<T>, Ts...>::value)
+    {
+        const constexpr bool is_lvalue_arg =  std::is_lvalue_reference<T>::value;
+        (cnvrt_ctors<is_lvalue_arg>()[m_index])(memory, const_cast<util::decay_t<T> *>(&t));
+    }
+
+    template<typename... Ts>
+    variant<Ts...>::~variant()
+    {
+        (dtors()[m_index])(memory);
+    }
+
+    template<typename... Ts>
+    variant<Ts...>& variant<Ts...>::operator=(const variant<Ts...> &rhs)
+    {
+        if (m_index != rhs.m_index)
+        {
+            (dtors()[    m_index])(memory);
+            (cctrs()[rhs.m_index])(memory, rhs.memory);
+            m_index = rhs.m_index;
+        }
+        else
+        {
+            (cpyrs()[rhs.m_index])(memory, rhs.memory);
+        }
+        return *this;
+    }
+
+    template<typename... Ts>
+    variant<Ts...>& variant<Ts...>::operator=(variant<Ts...> &&rhs) noexcept
+    {
+        if (m_index != rhs.m_index)
+        {
+            (dtors()[    m_index])(memory);
+            (mctrs()[rhs.m_index])(memory, rhs.memory);
+            m_index = rhs.m_index;
+        }
+        else
+        {
+            (mvers()[rhs.m_index])(memory, rhs.memory);
+        }
+        return *this;
+    }
+
+    template<typename... Ts>
+    template<typename T, typename>
+    variant<Ts...>& variant<Ts...>::operator=(T&& t) noexcept
+    {
+        using decayed_t = util::decay_t<T>;
+        // FIXME: No version with implicit type conversion available!
+        const constexpr std::size_t t_index =
+            util::type_list_index<decayed_t, Ts...>::value;
+
+        const constexpr bool is_lvalue_arg =  std::is_lvalue_reference<T>::value;
+
+        if (t_index != m_index)
+        {
+            (dtors()[m_index])(memory);
+            (cnvrt_ctors<is_lvalue_arg>()[t_index])(memory, &t);
+            m_index = t_index;
+        }
+        else
+        {
+            (cnvrt_assgnrs<is_lvalue_arg>()[m_index])(memory, &t);
+        }
+        return *this;
+
+    }
+
+    template<typename... Ts>
+    std::size_t util::variant<Ts...>::index() const noexcept
+    {
+        return m_index;
+    }
+
+    template<typename... Ts>
+    void variant<Ts...>::swap(variant<Ts...> &rhs) noexcept
+    {
+        if (m_index == rhs.index())
+        {
+            (swprs()[m_index](memory, rhs.memory));
+        }
+        else
+        {
+            variant<Ts...> tmp(std::move(*this));
+            *this = std::move(rhs);
+            rhs   = std::move(tmp);
+        }
+    }
+
+    template<typename... Ts>
+    template<typename T>
+    constexpr std::size_t variant<Ts...>::index_of()
+    {
+        return util::type_list_index<T, Ts...>::value; // FIXME: tests!
+    }
+
+    template<typename T, typename... Types>
+    T* get_if(util::variant<Types...>* v) noexcept
+    {
+        const constexpr std::size_t t_index =
+            util::type_list_index<T, Types...>::value;
+
+        if (v && v->index() == t_index)
+            return (T*)(&v->memory);  // workaround for ICC 2019
+            // original code: return reinterpret_cast<T&>(v.memory);
+        return nullptr;
+    }
+
+    template<typename T, typename... Types>
+    const T* get_if(const util::variant<Types...>* v) noexcept
+    {
+        const constexpr std::size_t t_index =
+            util::type_list_index<T, Types...>::value;
+
+        if (v && v->index() == t_index)
+            return (const T*)(&v->memory);  // workaround for ICC 2019
+            // original code: return reinterpret_cast<const T&>(v.memory);
+        return nullptr;
+    }
+
+    template<typename T, typename... Types>
+    T& get(util::variant<Types...> &v)
+    {
+        if (auto* p = get_if<T>(&v))
+            return *p;
+        else
+            throw_error(bad_variant_access());
+    }
+
+    template<typename T, typename... Types>
+    const T& get(const util::variant<Types...> &v)
+    {
+        if (auto* p = get_if<T>(&v))
+            return *p;
+        else
+            throw_error(bad_variant_access());
+    }
+
+    template<std::size_t Index, typename... Types>
+    typename util::type_list_element<Index, Types...>::type& get(util::variant<Types...> &v)
+    {
+        using ReturnType = typename util::type_list_element<Index, Types...>::type;
+        return const_cast<ReturnType&>(get<Index, Types...>(static_cast<const util::variant<Types...> &>(v)));
+    }
+
+    template<std::size_t Index, typename... Types>
+    const typename util::type_list_element<Index, Types...>::type& get(const util::variant<Types...> &v)
+    {
+        static_assert(Index < sizeof...(Types),
+                      "`Index` it out of bound of `util::variant` type list");
+        using ReturnType = typename util::type_list_element<Index, Types...>::type;
+        return get<ReturnType>(v);
+    }
+
+    template<typename T, typename... Types>
+    bool holds_alternative(const util::variant<Types...> &v) noexcept
+    {
+        return v.index() == util::variant<Types...>::template index_of<T>();
+    }
+
+    template<typename... Us> bool operator==(const variant<Us...> &lhs,
+                                             const variant<Us...> &rhs)
+    {
+        using V = variant<Us...>;
+
+        // Instantiate table only here since it requires operator== for <Us...>
+        // <Us...> should have operator== only if this one is used, not in general
+        static const std::array<typename V::Equal, sizeof...(Us)> eqs = {
+            {(&V::template equal_h<Us>::help)...}
+        };
+        if (lhs.index() != rhs.index())
+            return false;
+        return (eqs[lhs.index()])(lhs.memory, rhs.memory);
+    }
+
+    template<typename... Us> bool operator!=(const variant<Us...> &lhs,
+                                             const variant<Us...> &rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+namespace detail
+{
+    // terminate recursion implementation for `non-void` ReturnType
+    template<typename ReturnType, std::size_t CurIndex, std::size_t ElemCount,
+             typename Visitor, typename Variant, typename... VisitorArgs>
+    ReturnType apply_visitor_impl(Visitor&&, Variant&,
+                                  std::true_type, std::false_type,
+                                  VisitorArgs&& ...)
+    {
+        return {};
+    }
+
+    // terminate recursion implementation for `void` ReturnType
+    template<typename ReturnType, std::size_t CurIndex, std::size_t ElemCount,
+             typename Visitor, typename Variant, typename... VisitorArgs>
+    void apply_visitor_impl(Visitor&&, Variant&,
+                            std::true_type, std::true_type,
+                            VisitorArgs&& ...)
+    {
+    }
+
+    // Intermediate resursion processor for Lambda Visitors
+    template<typename ReturnType, std::size_t CurIndex, std::size_t ElemCount,
+             typename Visitor, typename Variant, bool no_return_value, typename... VisitorArgs>
+    typename std::enable_if<!std::is_base_of<visitor_interface, typename std::decay<Visitor>::type>::value, ReturnType>::type
+         apply_visitor_impl(Visitor&& visitor, Variant&& v, std::false_type not_processed,
+                                               std::integral_constant<bool, no_return_value> should_no_return,
+                                               VisitorArgs&& ...args)
+    {
+        static_assert(std::is_same<ReturnType, decltype(visitor(get<CurIndex>(v)))>::value,
+                      "Different `ReturnType`s detected! All `Visitor::visit` or `overload_lamba_set`"
+                      " must return the same type");
+        suppress_unused_warning(not_processed);
+        if (v.index() == CurIndex)
+        {
+            return visitor.operator()(get<CurIndex>(v), std::forward<VisitorArgs>(args)... );
+        }
+
+        using is_variant_processed_t = std::integral_constant<bool, CurIndex + 1 >= ElemCount>;
+        return apply_visitor_impl<ReturnType, CurIndex +1, ElemCount>(
+                                  std::forward<Visitor>(visitor),
+                                  std::forward<Variant>(v),
+                                  is_variant_processed_t{},
+                                  should_no_return,
+                                  std::forward<VisitorArgs>(args)...);
+    }
+
+    //Visual Studio 2014 compilation fix: cast visitor to base class before invoke operator()
+    template<std::size_t CurIndex, typename ReturnType, typename Visitor, class Value, typename... VisitorArgs>
+    typename std::enable_if<std::is_base_of<static_visitor<ReturnType, typename std::decay<Visitor>::type>,
+                                            typename std::decay<Visitor>::type>::value, ReturnType>::type
+    invoke_class_visitor(Visitor& visitor, Value&& v,  VisitorArgs&&...args)
+    {
+        return static_cast<static_visitor<ReturnType, typename std::decay<Visitor>::type>&>(visitor).operator() (CurIndex, std::forward<Value>(v), std::forward<VisitorArgs>(args)... );
+    }
+
+    //Visual Studio 2014 compilation fix: cast visitor to base class before invoke operator()
+    template<std::size_t CurIndex, typename ReturnType, typename Visitor, class Value, typename... VisitorArgs>
+    typename std::enable_if<std::is_base_of<static_indexed_visitor<ReturnType, typename std::decay<Visitor>::type>,
+                                            typename std::decay<Visitor>::type>::value, ReturnType>::type
+    invoke_class_visitor(Visitor& visitor, Value&& v,  VisitorArgs&&...args)
+    {
+        return static_cast<static_indexed_visitor<ReturnType, typename std::decay<Visitor>::type>&>(visitor).operator() (CurIndex, std::forward<Value>(v), std::forward<VisitorArgs>(args)... );
+    }
+
+    // Intermediate recursion processor for special case `visitor_interface` derived Visitors
+    template<typename ReturnType, std::size_t CurIndex, std::size_t ElemCount,
+             typename Visitor, typename Variant, bool no_return_value, typename... VisitorArgs>
+    typename std::enable_if<std::is_base_of<visitor_interface, typename std::decay<Visitor>::type>::value, ReturnType>::type
+         apply_visitor_impl(Visitor&& visitor, Variant&& v, std::false_type not_processed,
+                                               std::integral_constant<bool, no_return_value> should_no_return,
+                                               VisitorArgs&& ...args)
+    {
+        static_assert(std::is_same<ReturnType, decltype(visitor(get<CurIndex>(v)))>::value,
+                      "Different `ReturnType`s detected! All `Visitor::visit` or `overload_lamba_set`"
+                      " must return the same type");
+        suppress_unused_warning(not_processed);
+        if (v.index() == CurIndex)
+        {
+            return invoke_class_visitor<CurIndex, ReturnType>(visitor, get<CurIndex>(v), std::forward<VisitorArgs>(args)... );
+        }
+
+        using is_variant_processed_t = std::integral_constant<bool, CurIndex + 1 >= ElemCount>;
+        return apply_visitor_impl<ReturnType, CurIndex +1, ElemCount>(
+                                  std::forward<Visitor>(visitor),
+                                  std::forward<Variant>(v),
+                                  is_variant_processed_t{},
+                                  should_no_return,
+                                  std::forward<VisitorArgs>(args)...);
+    }
+} // namespace detail
+
+    template<typename Visitor, typename Variant, typename... VisitorArg>
+    auto visit(Visitor &visitor, const Variant& var, VisitorArg &&...args) -> decltype(visitor(get<0>(var)))
+    {
+        constexpr std::size_t varsize = util::variant_size<Variant>::value;
+        static_assert(varsize != 0, "utils::variant must contains one type at least ");
+        using is_variant_processed_t = std::false_type;
+
+        using ReturnType = decltype(visitor(get<0>(var)));
+        using return_t = std::is_same<ReturnType, void>;
+        return detail::apply_visitor_impl<ReturnType, 0, varsize, Visitor>(
+                                    std::forward<Visitor>(visitor),
+                                    var, is_variant_processed_t{},
+                                    return_t{},
+                                    std::forward<VisitorArg>(args)...);
+    }
+
+    template<typename Visitor, typename Variant>
+    auto visit(Visitor&& visitor, const Variant& var) -> decltype(visitor(get<0>(var)))
+    {
+        constexpr std::size_t varsize = util::variant_size<Variant>::value;
+        static_assert(varsize != 0, "utils::variant must contains one type at least ");
+        using is_variant_processed_t = std::false_type;
+
+        using ReturnType = decltype(visitor(get<0>(var)));
+        using return_t = std::is_same<ReturnType, void>;
+        return detail::apply_visitor_impl<ReturnType, 0, varsize, Visitor>(
+                                    std::forward<Visitor>(visitor),
+                                    var, is_variant_processed_t{},
+                                    return_t{});
+    }
+} // namespace util
+} // namespace cv
+
+#endif // OPENCV_GAPI_UTIL_VARIANT_HPP

3rdparty/opencv-4.5.4/modules/gapi/include/opencv2/gapi/video.hpp

@@ -0,0 +1,364 @@
+// 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) 2020 Intel Corporation
+
+#ifndef OPENCV_GAPI_VIDEO_HPP
+#define OPENCV_GAPI_VIDEO_HPP
+
+#include <utility> // std::tuple
+
+#include <opencv2/gapi/gkernel.hpp>
+
+
+/** \defgroup gapi_video G-API Video processing functionality
+ */
+
+namespace cv { namespace gapi {
+
+/** @brief Structure for the Kalman filter's initialization parameters.*/
+
+struct GAPI_EXPORTS KalmanParams
+{
+    // initial state
+
+    //! corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
+    Mat state;
+    //! posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)
+    Mat errorCov;
+
+    // dynamic system description
+
+    //! state transition matrix (A)
+    Mat transitionMatrix;
+    //! measurement matrix (H)
+    Mat measurementMatrix;
+    //! process noise covariance matrix (Q)
+    Mat processNoiseCov;
+    //! measurement noise covariance matrix (R)
+    Mat measurementNoiseCov;
+    //! control matrix (B) (Optional: not used if there's no control)
+    Mat controlMatrix;
+};
+
+/**
+ * @brief This namespace contains G-API Operations and functions for
+ * video-oriented algorithms, like optical flow and background subtraction.
+ */
+namespace  video
+{
+using GBuildPyrOutput  = std::tuple<GArray<GMat>, GScalar>;
+
+using GOptFlowLKOutput = std::tuple<cv::GArray<cv::Point2f>,
+                                    cv::GArray<uchar>,
+                                    cv::GArray<float>>;
+
+G_TYPED_KERNEL(GBuildOptFlowPyramid, <GBuildPyrOutput(GMat,Size,GScalar,bool,int,int,bool)>,
+               "org.opencv.video.buildOpticalFlowPyramid")
+{
+    static std::tuple<GArrayDesc,GScalarDesc>
+            outMeta(GMatDesc,const Size&,GScalarDesc,bool,int,int,bool)
+    {
+        return std::make_tuple(empty_array_desc(), empty_scalar_desc());
+    }
+};
+
+G_TYPED_KERNEL(GCalcOptFlowLK,
+               <GOptFlowLKOutput(GMat,GMat,cv::GArray<cv::Point2f>,cv::GArray<cv::Point2f>,Size,
+                                 GScalar,TermCriteria,int,double)>,
+               "org.opencv.video.calcOpticalFlowPyrLK")
+{
+    static std::tuple<GArrayDesc,GArrayDesc,GArrayDesc> outMeta(GMatDesc,GMatDesc,GArrayDesc,
+                                                                GArrayDesc,const Size&,GScalarDesc,
+                                                                const TermCriteria&,int,double)
+    {
+        return std::make_tuple(empty_array_desc(), empty_array_desc(), empty_array_desc());
+    }
+
+};
+
+G_TYPED_KERNEL(GCalcOptFlowLKForPyr,
+               <GOptFlowLKOutput(cv::GArray<cv::GMat>,cv::GArray<cv::GMat>,
+                                 cv::GArray<cv::Point2f>,cv::GArray<cv::Point2f>,Size,GScalar,
+                                 TermCriteria,int,double)>,
+               "org.opencv.video.calcOpticalFlowPyrLKForPyr")
+{
+    static std::tuple<GArrayDesc,GArrayDesc,GArrayDesc> outMeta(GArrayDesc,GArrayDesc,
+                                                                GArrayDesc,GArrayDesc,
+                                                                const Size&,GScalarDesc,
+                                                                const TermCriteria&,int,double)
+    {
+        return std::make_tuple(empty_array_desc(), empty_array_desc(), empty_array_desc());
+    }
+};
+
+enum BackgroundSubtractorType
+{
+    TYPE_BS_MOG2,
+    TYPE_BS_KNN
+};
+
+/** @brief Structure for the Background Subtractor operation's initialization parameters.*/
+
+struct BackgroundSubtractorParams
+{
+    //! Type of the Background Subtractor operation.
+    BackgroundSubtractorType operation = TYPE_BS_MOG2;
+
+    //! Length of the history.
+    int history = 500;
+
+    //! For MOG2: Threshold on the squared Mahalanobis distance between the pixel
+    //! and the model to decide whether a pixel is well described by
+    //! the background model.
+    //! For KNN: Threshold on the squared distance between the pixel and the sample
+    //! to decide whether a pixel is close to that sample.
+    double threshold = 16;
+
+    //! If true, the algorithm will detect shadows and mark them.
+    bool detectShadows = true;
+
+    //! The value between 0 and 1 that indicates how fast
+    //! the background model is learnt.
+    //! Negative parameter value makes the algorithm use some automatically
+    //! chosen learning rate.
+    double learningRate = -1;
+
+    //! default constructor
+    BackgroundSubtractorParams() {}
+
+    /** Full constructor
+    @param op MOG2/KNN Background Subtractor type.
+    @param histLength Length of the history.
+    @param thrshld For MOG2: Threshold on the squared Mahalanobis distance between
+    the pixel and the model to decide whether a pixel is well described by the background model.
+    For KNN: Threshold on the squared distance between the pixel and the sample to decide
+    whether a pixel is close to that sample.
+    @param detect If true, the algorithm will detect shadows and mark them. It decreases the
+    speed a bit, so if you do not need this feature, set the parameter to false.
+    @param lRate The value between 0 and 1 that indicates how fast the background model is learnt.
+    Negative parameter value makes the algorithm to use some automatically chosen learning rate.
+    */
+    BackgroundSubtractorParams(BackgroundSubtractorType op, int histLength,
+                               double thrshld, bool detect, double lRate) : operation(op),
+                                                                            history(histLength),
+                                                                            threshold(thrshld),
+                                                                            detectShadows(detect),
+                                                                            learningRate(lRate){}
+};
+
+G_TYPED_KERNEL(GBackgroundSubtractor, <GMat(GMat, BackgroundSubtractorParams)>,
+               "org.opencv.video.BackgroundSubtractor")
+{
+    static GMatDesc outMeta(const GMatDesc& in, const BackgroundSubtractorParams& bsParams)
+    {
+        GAPI_Assert(bsParams.history >= 0);
+        GAPI_Assert(bsParams.learningRate <= 1);
+        return in.withType(CV_8U, 1);
+    }
+};
+
+void checkParams(const cv::gapi::KalmanParams& kfParams,
+                 const cv::GMatDesc& measurement, const cv::GMatDesc& control = {});
+
+G_TYPED_KERNEL(GKalmanFilter, <GMat(GMat, GOpaque<bool>, GMat, KalmanParams)>,
+               "org.opencv.video.KalmanFilter")
+{
+    static GMatDesc outMeta(const GMatDesc& measurement, const GOpaqueDesc&,
+                            const GMatDesc& control, const KalmanParams& kfParams)
+    {
+        checkParams(kfParams, measurement, control);
+        return measurement.withSize(Size(1, kfParams.transitionMatrix.rows));
+    }
+};
+
+G_TYPED_KERNEL(GKalmanFilterNoControl, <GMat(GMat, GOpaque<bool>, KalmanParams)>, "org.opencv.video.KalmanFilterNoControl")
+{
+    static GMatDesc outMeta(const GMatDesc& measurement, const GOpaqueDesc&, const KalmanParams& kfParams)
+    {
+        checkParams(kfParams, measurement);
+        return measurement.withSize(Size(1, kfParams.transitionMatrix.rows));
+    }
+};
+} //namespace video
+
+//! @addtogroup gapi_video
+//! @{
+/** @brief Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.
+
+@note Function textual ID is "org.opencv.video.buildOpticalFlowPyramid"
+
+@param img                8-bit input image.
+@param winSize            window size of optical flow algorithm. Must be not less than winSize
+                          argument of calcOpticalFlowPyrLK. It is needed to calculate required
+                          padding for pyramid levels.
+@param maxLevel           0-based maximal pyramid level number.
+@param withDerivatives    set to precompute gradients for the every pyramid level. If pyramid is
+                          constructed without the gradients then calcOpticalFlowPyrLK will calculate
+                          them internally.
+@param pyrBorder          the border mode for pyramid layers.
+@param derivBorder        the border mode for gradients.
+@param tryReuseInputImage put ROI of input image into the pyramid if possible. You can pass false
+                          to force data copying.
+
+@return
+ - output pyramid.
+ - number of levels in constructed pyramid. Can be less than maxLevel.
+ */
+GAPI_EXPORTS std::tuple<GArray<GMat>, GScalar>
+buildOpticalFlowPyramid(const GMat     &img,
+                        const Size     &winSize,
+                        const GScalar  &maxLevel,
+                              bool      withDerivatives    = true,
+                              int       pyrBorder          = BORDER_REFLECT_101,
+                              int       derivBorder        = BORDER_CONSTANT,
+                              bool      tryReuseInputImage = true);
+
+/** @brief Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade
+method with pyramids.
+
+See @cite Bouguet00 .
+
+@note Function textual ID is "org.opencv.video.calcOpticalFlowPyrLK"
+
+@param prevImg first 8-bit input image (GMat) or pyramid (GArray<GMat>) constructed by
+buildOpticalFlowPyramid.
+@param nextImg second input image (GMat) or pyramid (GArray<GMat>) of the same size and the same
+type as prevImg.
+@param prevPts GArray of 2D points for which the flow needs to be found; point coordinates must be
+single-precision floating-point numbers.
+@param predPts GArray of 2D points initial for the flow search; make sense only when
+OPTFLOW_USE_INITIAL_FLOW flag is passed; in that case the vector must have the same size as in
+the input.
+@param winSize size of the search window at each pyramid level.
+@param maxLevel 0-based maximal pyramid level number; if set to 0, pyramids are not used (single
+level), if set to 1, two levels are used, and so on; if pyramids are passed to input then
+algorithm will use as many levels as pyramids have but no more than maxLevel.
+@param criteria parameter, specifying the termination criteria of the iterative search algorithm
+(after the specified maximum number of iterations criteria.maxCount or when the search window
+moves by less than criteria.epsilon).
+@param flags operation flags:
+ -   **OPTFLOW_USE_INITIAL_FLOW** uses initial estimations, stored in nextPts; if the flag is
+     not set, then prevPts is copied to nextPts and is considered the initial estimate.
+ -   **OPTFLOW_LK_GET_MIN_EIGENVALS** use minimum eigen values as an error measure (see
+     minEigThreshold description); if the flag is not set, then L1 distance between patches
+     around the original and a moved point, divided by number of pixels in a window, is used as a
+     error measure.
+@param minEigThresh the algorithm calculates the minimum eigen value of a 2x2 normal matrix of
+optical flow equations (this matrix is called a spatial gradient matrix in @cite Bouguet00), divided
+by number of pixels in a window; if this value is less than minEigThreshold, then a corresponding
+feature is filtered out and its flow is not processed, so it allows to remove bad points and get a
+performance boost.
+
+@return
+ - GArray of 2D points (with single-precision floating-point coordinates)
+containing the calculated new positions of input features in the second image.
+ - status GArray (of unsigned chars); each element of the vector is set to 1 if
+the flow for the corresponding features has been found, otherwise, it is set to 0.
+ - GArray of errors (doubles); each element of the vector is set to an error for the
+corresponding feature, type of the error measure can be set in flags parameter; if the flow wasn't
+found then the error is not defined (use the status parameter to find such cases).
+ */
+GAPI_EXPORTS std::tuple<GArray<Point2f>, GArray<uchar>, GArray<float>>
+calcOpticalFlowPyrLK(const GMat            &prevImg,
+                     const GMat            &nextImg,
+                     const GArray<Point2f> &prevPts,
+                     const GArray<Point2f> &predPts,
+                     const Size            &winSize      = Size(21, 21),
+                     const GScalar         &maxLevel     = 3,
+                     const TermCriteria    &criteria     = TermCriteria(TermCriteria::COUNT |
+                                                                        TermCriteria::EPS,
+                                                                        30, 0.01),
+                           int              flags        = 0,
+                           double           minEigThresh = 1e-4);
+
+/**
+@overload
+@note Function textual ID is "org.opencv.video.calcOpticalFlowPyrLKForPyr"
+*/
+GAPI_EXPORTS std::tuple<GArray<Point2f>, GArray<uchar>, GArray<float>>
+calcOpticalFlowPyrLK(const GArray<GMat>    &prevPyr,
+                     const GArray<GMat>    &nextPyr,
+                     const GArray<Point2f> &prevPts,
+                     const GArray<Point2f> &predPts,
+                     const Size            &winSize      = Size(21, 21),
+                     const GScalar         &maxLevel     = 3,
+                     const TermCriteria    &criteria     = TermCriteria(TermCriteria::COUNT |
+                                                                        TermCriteria::EPS,
+                                                                        30, 0.01),
+                           int              flags        = 0,
+                           double           minEigThresh = 1e-4);
+
+/** @brief Gaussian Mixture-based or K-nearest neighbours-based Background/Foreground Segmentation Algorithm.
+The operation generates a foreground mask.
+
+@return Output image is foreground mask, i.e. 8-bit unsigned 1-channel (binary) matrix @ref CV_8UC1.
+
+@note Functional textual ID is "org.opencv.video.BackgroundSubtractor"
+
+@param src input image: Floating point frame is used without scaling and should be in range [0,255].
+@param bsParams Set of initialization parameters for Background Subtractor kernel.
+*/
+GAPI_EXPORTS GMat BackgroundSubtractor(const GMat& src, const cv::gapi::video::BackgroundSubtractorParams& bsParams);
+
+/** @brief Standard Kalman filter algorithm <http://en.wikipedia.org/wiki/Kalman_filter>.
+
+@note Functional textual ID is "org.opencv.video.KalmanFilter"
+
+@param measurement input matrix: 32-bit or 64-bit float 1-channel matrix containing measurements.
+@param haveMeasurement dynamic input flag that indicates whether we get measurements
+at a particular iteration .
+@param control input matrix: 32-bit or 64-bit float 1-channel matrix contains control data
+for changing dynamic system.
+@param kfParams Set of initialization parameters for Kalman filter kernel.
+
+@return Output matrix is predicted or corrected state. They can be 32-bit or 64-bit float
+1-channel matrix @ref CV_32FC1 or @ref CV_64FC1.
+
+@details If measurement matrix is given (haveMeasurements == true), corrected state will
+be returned which corresponds to the pipeline
+cv::KalmanFilter::predict(control) -> cv::KalmanFilter::correct(measurement).
+Otherwise, predicted state will be returned which corresponds to the call of
+cv::KalmanFilter::predict(control).
+@sa cv::KalmanFilter
+*/
+GAPI_EXPORTS GMat KalmanFilter(const GMat& measurement, const GOpaque<bool>& haveMeasurement,
+                               const GMat& control, const cv::gapi::KalmanParams& kfParams);
+
+/** @overload
+The case of Standard Kalman filter algorithm when there is no control in a dynamic system.
+In this case the controlMatrix is empty and control vector is absent.
+
+@note Function textual ID is "org.opencv.video.KalmanFilterNoControl"
+
+@param measurement input matrix: 32-bit or 64-bit float 1-channel matrix containing measurements.
+@param haveMeasurement dynamic input flag that indicates whether we get measurements
+at a particular iteration.
+@param kfParams Set of initialization parameters for Kalman filter kernel.
+
+@return Output matrix is predicted or corrected state. They can be 32-bit or 64-bit float
+1-channel matrix @ref CV_32FC1 or @ref CV_64FC1.
+
+@sa cv::KalmanFilter
+ */
+GAPI_EXPORTS GMat KalmanFilter(const GMat& measurement, const GOpaque<bool>& haveMeasurement,
+                               const cv::gapi::KalmanParams& kfParams);
+
+//! @} gapi_video
+} //namespace gapi
+} //namespace cv
+
+
+namespace cv { namespace detail {
+template<> struct CompileArgTag<cv::gapi::video::BackgroundSubtractorParams>
+{
+    static const char* tag()
+    {
+        return "org.opencv.video.background_substractor_params";
+    }
+};
+}  // namespace detail
+}  // namespace cv
+
+#endif // OPENCV_GAPI_VIDEO_HPP