opencv
diff --git a/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions b/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/core.hpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎modules/gapi/include/opencv2/gapi/core.hpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/imgproc.hpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎modules/gapi/include/opencv2/gapi/imgproc.hpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎modules/gapi/include/opencv2/gapi/python/python.hpp
Copy file name to clipboard
+58Lines changed: 58 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/python/python.hpp
Copy file name to clipboard
+58Lines changed: 58 additions & 0 deletions
diff --git a/‎modules/gapi/misc/python/pyopencv_gapi.hpp
Copy file name to clipboard
+142-13Lines changed: 142 additions & 13 deletions b/‎modules/gapi/misc/python/pyopencv_gapi.hpp
Copy file name to clipboard
+142-13Lines changed: 142 additions & 13 deletions
@@ -53,6 +53,7 @@ file(GLOB gapi_ext_hdrs
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/streaming/*.hpp"
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/plaidml/*.hpp"
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/util/*.hpp"
+    "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/python/*.hpp"
     )
 
 set(gapi_srcs
@@ -158,6 +159,7 @@ set(gapi_srcs
 
     # Python bridge
     src/backends/ie/bindings_ie.cpp
+    src/backends/python/gpythonbackend.cpp
     )
 
 ocv_add_dispatched_file(backends/fluid/gfluidimgproc_func SSE4_1 AVX2)
 
@@ -645,7 +645,7 @@ Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref
 @param ddepth optional depth of the output matrix.
 @sa sub, addWeighted
 */
-GAPI_EXPORTS GMat addC(const GMat& src1, const GScalar& c, int ddepth = -1);
+GAPI_EXPORTS_W GMat addC(const GMat& src1, const GScalar& c, int ddepth = -1);
 //! @overload
 GAPI_EXPORTS GMat addC(const GScalar& c, const GMat& src1, int ddepth = -1);
 
@@ -1945,7 +1945,7 @@ Gets dimensions from rectangle.
 @param r Input rectangle.
 @return Size (rectangle dimensions).
 */
-GAPI_EXPORTS GOpaque<Size> size(const GOpaque<Rect>& r);
+GAPI_EXPORTS_W GOpaque<Size> size(const GOpaque<Rect>& r);
 
 /** @brief Gets dimensions from MediaFrame.
 
 
@@ -1168,7 +1168,7 @@ Calculates the up-right bounding rectangle of a point set.
 
 @param src Input 2D point set, stored in std::vector<cv::Point2i>.
  */
-GAPI_EXPORTS GOpaque<Rect> boundingRect(const GArray<Point2i>& src);
+GAPI_EXPORTS_W GOpaque<Rect> boundingRect(const GArray<Point2i>& src);
 
 /** @overload
 
 
@@ -0,0 +1,58 @@
+// 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 https://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 {
+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
@@ -3,10 +3,13 @@
 
 #ifdef HAVE_OPENCV_GAPI
 
+#include <opencv2/gapi/cpu/gcpukernel.hpp>
+#include <opencv2/gapi/python/python.hpp>
+
 // NB: Python wrapper replaces :: with _ for classes
-using gapi_GKernelPackage = cv::gapi::GKernelPackage;
-using gapi_GNetPackage = cv::gapi::GNetPackage;
-using gapi_ie_PyParams = cv::gapi::ie::PyParams;
+using gapi_GKernelPackage        = cv::gapi::GKernelPackage;
+using gapi_GNetPackage           = cv::gapi::GNetPackage;
+using gapi_ie_PyParams           = cv::gapi::ie::PyParams;
 using gapi_wip_IStreamSource_Ptr = cv::Ptr<cv::gapi::wip::IStreamSource>;
 using detail_ExtractArgsCallback = cv::detail::ExtractArgsCallback;
 using detail_ExtractMetaCallback = cv::detail::ExtractMetaCallback;
@@ -18,7 +21,7 @@ using GOpaque_int     = cv::GOpaque<int>;
 using GOpaque_double  = cv::GOpaque<double>;
 using GOpaque_float   = cv::GOpaque<double>;
 using GOpaque_string  = cv::GOpaque<std::string>;
-using GOpaque_Point   = cv::GOpaque<cv::Point>;
+using GOpaque_Point2i = cv::GOpaque<cv::Point>;
 using GOpaque_Point2f = cv::GOpaque<cv::Point2f>;
 using GOpaque_Size    = cv::GOpaque<cv::Size>;
 using GOpaque_Rect    = cv::GOpaque<cv::Rect>;
@@ -28,7 +31,7 @@ using GArray_int     = cv::GArray<int>;
 using GArray_double  = cv::GArray<double>;
 using GArray_float   = cv::GArray<double>;
 using GArray_string  = cv::GArray<std::string>;
-using GArray_Point   = cv::GArray<cv::Point>;
+using GArray_Point2i = cv::GArray<cv::Point>;
 using GArray_Point2f = cv::GArray<cv::Point2f>;
 using GArray_Size    = cv::GArray<cv::Size>;
 using GArray_Rect    = cv::GArray<cv::Rect>;
@@ -41,19 +44,19 @@ using GArray_GMat    = cv::GArray<cv::GMat>;
 // WA: Create using
 using std::string;
 
-template<>
+template <>
 bool pyopencv_to(PyObject* obj, std::vector<GCompileArg>& value, const ArgInfo& info)
 {
     return pyopencv_to_generic_vec(obj, value, info);
 }
 
-template<>
+template <>
 PyObject* pyopencv_from(const std::vector<GCompileArg>& value)
 {
     return pyopencv_from_generic_vec(value);
 }
 
-template<>
+template <>
 bool pyopencv_to(PyObject* obj, GRunArgs& value, const ArgInfo& info)
 {
     return pyopencv_to_generic_vec(obj, value, info);
@@ -267,10 +270,9 @@ static cv::detail::OpaqueRef extract_opaque_ref(PyObject* from, cv::detail::Opaq
         UNSUPPORTED(SCALAR);
         UNSUPPORTED(MAT);
         UNSUPPORTED(DRAW_PRIM);
-    }
 #undef HANDLE_CASE
 #undef UNSUPPORTED
-
+    }
     util::throw_error(std::logic_error("Unsupported type for GOpaqueT"));
 }
 
@@ -302,8 +304,7 @@ static cv::detail::VectorRef extract_vector_ref(PyObject* from, cv::detail::Opaq
 #undef HANDLE_CASE
 #undef UNSUPPORTED
     }
-
-    util::throw_error(std::logic_error("Unsupported type for GOpaqueT"));
+    util::throw_error(std::logic_error("Unsupported type for GArrayT"));
 }
 
 static cv::GRunArg extract_run_arg(const cv::GTypeInfo& info, PyObject* item)
@@ -340,6 +341,7 @@ static cv::GRunArg extract_run_arg(const cv::GTypeInfo& info, PyObject* item)
         }
         case cv::GShape::GFRAME:
         {
+            // NB: Isn't supported yet.
             break;
         }
     }
@@ -391,7 +393,6 @@ static cv::GMetaArg extract_meta_arg(const cv::GTypeInfo& info, PyObject* item)
             break;
         }
     }
-
     util::throw_error(std::logic_error("Unsupported output shape"));
 }
 
@@ -409,6 +410,134 @@ static cv::GMetaArgs extract_meta_args(const cv::GTypesInfo& info, PyObject* py_
     return metas;
 }
 
+inline PyObject* extract_opaque_value(const cv::GArg& value)
+{
+    GAPI_Assert(value.kind != cv::detail::ArgKind::GOBJREF);
+#define HANDLE_CASE(T, O) case cv::detail::OpaqueKind::CV_##T:  \
+    {                                                           \
+        return pyopencv_from(value.get<O>());                   \
+    }
+
+#define UNSUPPORTED(T) case cv::detail::OpaqueKind::CV_##T: break
+    switch (value.opaque_kind)
+    {
+        HANDLE_CASE(BOOL,    bool);
+        HANDLE_CASE(INT,     int);
+        HANDLE_CASE(DOUBLE,  double);
+        HANDLE_CASE(FLOAT,   float);
+        HANDLE_CASE(STRING,  std::string);
+        HANDLE_CASE(POINT,   cv::Point);
+        HANDLE_CASE(POINT2F, cv::Point2f);
+        HANDLE_CASE(SIZE,    cv::Size);
+        HANDLE_CASE(RECT,    cv::Rect);
+        HANDLE_CASE(SCALAR,  cv::Scalar);
+        HANDLE_CASE(MAT,     cv::Mat);
+        UNSUPPORTED(UNKNOWN);
+        UNSUPPORTED(UINT64);
+        UNSUPPORTED(DRAW_PRIM);
+#undef HANDLE_CASE
+#undef UNSUPPORTED
+    }
+    util::throw_error(std::logic_error("Unsupported kernel input type"));
+}
+
+static cv::GRunArgs run_py_kernel(PyObject* kernel,
+                                  const cv::gapi::python::GPythonContext &ctx)
+{
+    const auto& ins      = ctx.ins;
+    const auto& in_metas = ctx.in_metas;
+    const auto& out_info = ctx.out_info;
+
+    PyGILState_STATE gstate;
+    gstate = PyGILState_Ensure();
+
+    cv::GRunArgs outs;
+    try
+    {
+        int in_idx = 0;
+        PyObject* args = PyTuple_New(ins.size());
+        for (size_t i = 0; i < ins.size(); ++i)
+        {
+            // NB: If meta is monostate then object isn't associated with G-TYPE, so in case it
+            // kind matches with supported types do conversion from c++ to python, if not (CV_UNKNOWN)
+            // obtain PyObject* and pass as-is.
+            if (cv::util::holds_alternative<cv::util::monostate>(in_metas[i]))
+            {
+                PyTuple_SetItem(args, i,
+                        ins[i].opaque_kind != cv::detail::OpaqueKind::CV_UNKNOWN ? extract_opaque_value(ins[i])
+                                                                                 : ins[i].get<PyObject*>());
+                continue;
+            }
+
+            switch (in_metas[i].index())
+            {
+                case cv::GMetaArg::index_of<cv::GMatDesc>():
+                    PyTuple_SetItem(args, i, pyopencv_from(ins[i].get<cv::Mat>()));
+                    break;
+                case cv::GMetaArg::index_of<cv::GScalarDesc>():
+                    PyTuple_SetItem(args, i, pyopencv_from(ins[i].get<cv::Scalar>()));
+                    break;
+                case cv::GMetaArg::index_of<cv::GOpaqueDesc>():
+                    PyTuple_SetItem(args, i, pyopencv_from(ins[i].get<cv::detail::OpaqueRef>()));
+                    break;
+                case cv::GMetaArg::index_of<cv::GArrayDesc>():
+                    PyTuple_SetItem(args, i, pyopencv_from(ins[i].get<cv::detail::VectorRef>()));
+                    break;
+                case cv::GMetaArg::index_of<cv::GFrameDesc>():
+                    util::throw_error(std::logic_error("GFrame isn't supported for custom operation"));
+                    break;
+            }
+            ++in_idx;
+        }
+
+        PyObject* result = PyObject_CallObject(kernel, args);
+
+        outs = out_info.size() == 1 ? cv::GRunArgs{extract_run_arg(out_info[0], result)}
+                                    : extract_run_args(out_info, result);
+    }
+    catch (...)
+    {
+        PyGILState_Release(gstate);
+        throw;
+    }
+    PyGILState_Release(gstate);
+
+    return outs;
+}
+
+// FIXME: Now it's impossible to obtain meta function from operation,
+// because kernel connects to operation only by id (string).
+static GMetaArgs empty_meta(const cv::GMetaArgs &, const cv::GArgs &) {
+    return {};
+}
+
+static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObject*)
+{
+    using namespace cv;
+    gapi::GKernelPackage pkg;
+    Py_ssize_t size = PyTuple_Size(py_args);
+    for (int i = 0; i < size; ++i)
+    {
+        PyObject* pair   = PyTuple_GetItem(py_args, i);
+        PyObject* kernel = PyTuple_GetItem(pair, 0);
+
+        std::string id;
+        if (!pyopencv_to(PyTuple_GetItem(pair, 1), id, ArgInfo("id", false)))
+        {
+            PyErr_SetString(PyExc_TypeError, "Failed to obtain: kernel id must be a string");
+            return NULL;
+        }
+        Py_INCREF(kernel);
+        gapi::python::GPythonFunctor f(id.c_str(),
+                                       empty_meta,
+                                       std::bind(run_py_kernel,
+                                                 kernel,
+                                                 std::placeholders::_1));
+        pkg.include(f);
+    }
+    return pyopencv_from(pkg);
+}
+
 static PyObject* pyopencv_cv_gin(PyObject*, PyObject* py_args, PyObject*)
 {
     Py_INCREF(py_args);
Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,7 @@ file(GLOB gapi_ext_hdrs`
`53`	`53`	`"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/streaming/*.hpp"`
`54`	`54`	`"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/plaidml/*.hpp"`
`55`	`55`	`"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/util/*.hpp"`
	`56`	`+ "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/python/*.hpp"`
`56`	`57`	`)`
`57`	`58`
`58`	`59`	`set(gapi_srcs`
`@@ -158,6 +159,7 @@ set(gapi_srcs`
`158`	`159`
`159`	`160`	`# Python bridge`
`160`	`161`	`src/backends/ie/bindings_ie.cpp`
	`162`	`+ src/backends/python/gpythonbackend.cpp`
`161`	`163`	`)`
`162`	`164`
`163`	`165`	`ocv_add_dispatched_file(backends/fluid/gfluidimgproc_func SSE4_1 AVX2)`