opencv
diff --git a/‎modules/gapi/include/opencv2/gapi/garray.hpp
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/garray.hpp
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/gcommon.hpp
Copy file name to clipboard
+4-2Lines changed: 4 additions & 2 deletions b/‎modules/gapi/include/opencv2/gapi/gcommon.hpp
Copy file name to clipboard
+4-2Lines changed: 4 additions & 2 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/gkernel.hpp
Copy file name to clipboard
+10-3Lines changed: 10 additions & 3 deletions b/‎modules/gapi/include/opencv2/gapi/gkernel.hpp
Copy file name to clipboard
+10-3Lines changed: 10 additions & 3 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/imgproc.hpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎modules/gapi/include/opencv2/gapi/imgproc.hpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/opencv_includes.hpp
Copy file name to clipboard
+6-5Lines changed: 6 additions & 5 deletions b/‎modules/gapi/include/opencv2/gapi/opencv_includes.hpp
Copy file name to clipboard
+6-5Lines changed: 6 additions & 5 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/own/types.hpp
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/own/types.hpp
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/s11n.hpp
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/s11n.hpp
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions
diff --git a/‎modules/gapi/misc/python/pyopencv_gapi.hpp
Copy file name to clipboard
+18-3Lines changed: 18 additions & 3 deletions b/‎modules/gapi/misc/python/pyopencv_gapi.hpp
Copy file name to clipboard
+18-3Lines changed: 18 additions & 3 deletions
diff --git a/‎modules/gapi/misc/python/shadow_gapi.hpp
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions b/‎modules/gapi/misc/python/shadow_gapi.hpp
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions
diff --git a/‎modules/gapi/misc/python/test/test_gapi_core.py
Copy file name to clipboard
+41-34Lines changed: 41 additions & 34 deletions b/‎modules/gapi/misc/python/test/test_gapi_core.py
Copy file name to clipboard
+41-34Lines changed: 41 additions & 34 deletions
@@ -368,6 +368,8 @@ template<typename T> class GArray
     detail::GArrayU m_ref;
 };
 
+using GArrayP2f = GArray<cv::Point2f>;
+
 /** @} */
 
 } // namespace cv
 
@@ -49,6 +49,7 @@ namespace detail
         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
@@ -68,15 +69,16 @@ namespace detail
     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,
+    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::Rect,
+    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
 
 
@@ -26,9 +26,16 @@
 
 namespace cv {
 
-using GShapes = std::vector<GShape>;
-using GKinds = std::vector<cv::detail::OpaqueKind>;
-using GCtors  = std::vector<detail::HostCtor>;
+struct GTypeInfo
+{
+    GShape                 shape;
+    cv::detail::OpaqueKind kind;
+};
+
+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
 
@@ -1035,7 +1035,7 @@ or #cornerMinEigenVal.
 
 @return vector of detected corners.
  */
-GAPI_EXPORTS GArray<Point2f> goodFeaturesToTrack(const GMat  &image,
+GAPI_EXPORTS_W GArray<Point2f> goodFeaturesToTrack(const GMat  &image,
                                                        int    maxCorners,
                                                        double qualityLevel,
                                                        double minDistance,
@@ -1350,7 +1350,7 @@ Resulting gray color value computed as
 @param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1.
 @sa RGB2YUV
  */
-GAPI_EXPORTS GMat RGB2Gray(const GMat& src);
+GAPI_EXPORTS_W GMat RGB2Gray(const GMat& src);
 
 /** @overload
 Resulting gray color value computed as
 
@@ -21,11 +21,12 @@
 #  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 Scalar = gapi::own::Scalar;
-    using Mat    = gapi::own::Mat;
+    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)
 
 
@@ -28,6 +28,16 @@ class Point
     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:
 
@@ -121,6 +121,9 @@ GAPI_EXPORTS std::unique_ptr<IIStream> getInStream(const std::vector<char> &p);
 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);
 
 
@@ -47,8 +47,20 @@ static PyObject* from_grunarg(const GRunArg& v)
             const auto& s = util::get<cv::Scalar>(v);
             return pyopencv_from(s);
         }
-
+        case GRunArg::index_of<cv::detail::VectorRef>():
+        {
+            const auto& vref = util::get<cv::detail::VectorRef>(v);
+            switch (vref.getKind())
+            {
+                case cv::detail::OpaqueKind::CV_POINT2F:
+                    return pyopencv_from(vref.rref<cv::Point2f>());
+                default:
+                    PyErr_SetString(PyExc_TypeError, "Unsupported kind for GArray");
+                    return NULL;
+            }
+        }
         default:
+            PyErr_SetString(PyExc_TypeError, "Failed to unpack GRunArgs");
             return NULL;
     }
     GAPI_Assert(false);
@@ -65,7 +77,6 @@ PyObject* pyopencv_from(const GRunArgs& value)
         PyObject* item = from_grunarg(value[0]);
         if(!item)
         {
-            PyErr_SetString(PyExc_TypeError, "Failed to unpack GRunArgs");
             return NULL;
         }
         return item;
@@ -117,9 +128,13 @@ static PyObject* extract_proto_args(PyObject* py_args, PyObject* kw)
         {
             args.emplace_back(reinterpret_cast<pyopencv_GMat_t*>(item)->v);
         }
+        else if (PyObject_TypeCheck(item, reinterpret_cast<PyTypeObject*>(pyopencv_GArrayP2f_TypePtr)))
+        {
+            args.emplace_back(reinterpret_cast<pyopencv_GArrayP2f_t*>(item)->v.strip());
+        }
         else
         {
-            PyErr_SetString(PyExc_TypeError, "cv.GIn() supports only cv.GMat and cv.GScalar");
+            PyErr_SetString(PyExc_TypeError, "Unsupported type for cv.GIn()/cv.GOut()");
             return NULL;
         }
     }
 
@@ -16,6 +16,8 @@ namespace cv
    class GAPI_EXPORTS_W_SIMPLE GRunArg { };
    class GAPI_EXPORTS_W_SIMPLE GMetaArg { };
 
+   class GAPI_EXPORTS_W_SIMPLE GArrayP2f { };
+
    using GProtoInputArgs  = GIOProtoArgs<In_Tag>;
    using GProtoOutputArgs = GIOProtoArgs<Out_Tag>;
 
 
@@ -2,26 +2,27 @@
 
 import numpy as np
 import cv2 as cv
+import os
 
 from tests_common import NewOpenCVTests
 
 
 # Plaidml is an optional backend
 pkgs = [
-         cv.gapi.core.ocl.kernels(),
-         cv.gapi.core.cpu.kernels(),
-         cv.gapi.core.fluid.kernels()
-         # cv.gapi.core.plaidml.kernels()
-       ]
+          ('ocl'    , cv.gapi.core.ocl.kernels()),
+          ('cpu'    , cv.gapi.core.cpu.kernels()),
+          ('fluid'  , cv.gapi.core.fluid.kernels())
+          # ('plaidml', cv.gapi.core.plaidml.kernels())
+      ]
 
 
 class gapi_core_test(NewOpenCVTests):
 
     def test_add(self):
         # TODO: Extend to use any type and size here
-        sz = (1280, 720)
-        in1 = np.random.randint(0, 100, sz)
-        in2 = np.random.randint(0, 100, sz)
+        sz = (720, 1280)
+        in1 = np.full(sz, 100)
+        in2 = np.full(sz, 50)
 
         # OpenCV
         expected = cv.add(in1, in2)
@@ -32,17 +33,18 @@ def test_add(self):
         g_out = cv.gapi.add(g_in1, g_in2)
         comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
 
-        for pkg in pkgs:
+        for pkg_name, pkg in pkgs:
             actual = comp.apply(cv.gin(in1, in2), args=cv.compile_args(pkg))
             # Comparison
-            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
-            self.assertEqual(expected.dtype, actual.dtype)
+            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
+                             'Failed on ' + pkg_name + ' backend')
+            self.assertEqual(expected.dtype, actual.dtype, 'Failed on ' + pkg_name + ' backend')
 
 
     def test_add_uint8(self):
-        sz = (1280, 720)
-        in1 = np.random.randint(0, 100, sz).astype(np.uint8)
-        in2 = np.random.randint(0, 100, sz).astype(np.uint8)
+        sz = (720, 1280)
+        in1 = np.full(sz, 100, dtype=np.uint8)
+        in2 = np.full(sz, 50 , dtype=np.uint8)
 
         # OpenCV
         expected = cv.add(in1, in2)
@@ -53,16 +55,17 @@ def test_add_uint8(self):
         g_out = cv.gapi.add(g_in1, g_in2)
         comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
 
-        for pkg in pkgs:
+        for pkg_name, pkg in pkgs:
             actual = comp.apply(cv.gin(in1, in2), args=cv.compile_args(pkg))
             # Comparison
-            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
-            self.assertEqual(expected.dtype, actual.dtype)
+            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
+                             'Failed on ' + pkg_name + ' backend')
+            self.assertEqual(expected.dtype, actual.dtype, 'Failed on ' + pkg_name + ' backend')
 
 
     def test_mean(self):
-        sz = (1280, 720, 3)
-        in_mat = np.random.randint(0, 100, sz)
+        img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
+        in_mat = cv.imread(img_path)
 
         # OpenCV
         expected = cv.mean(in_mat)
@@ -72,15 +75,16 @@ def test_mean(self):
         g_out = cv.gapi.mean(g_in)
         comp = cv.GComputation(g_in, g_out)
 
-        for pkg in pkgs:
+        for pkg_name, pkg in pkgs:
             actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
             # Comparison
-            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
+                             'Failed on ' + pkg_name + ' backend')
 
 
     def test_split3(self):
-        sz = (1280, 720, 3)
-        in_mat = np.random.randint(0, 100, sz)
+        img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
+        in_mat = cv.imread(img_path)
 
         # OpenCV
         expected = cv.split(in_mat)
@@ -90,19 +94,19 @@ def test_split3(self):
         b, g, r = cv.gapi.split3(g_in)
         comp = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r))
 
-        for pkg in pkgs:
+        for pkg_name, pkg in pkgs:
             actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
             # Comparison
             for e, a in zip(expected, actual):
-                self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF))
-                self.assertEqual(e.dtype, a.dtype)
+                self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF),
+                                 'Failed on ' + pkg_name + ' backend')
+                self.assertEqual(e.dtype, a.dtype, 'Failed on ' + pkg_name + ' backend')
 
 
     def test_threshold(self):
-        sz = (1280, 720)
-        in_mat = np.random.randint(0, 100, sz).astype(np.uint8)
-        rand_int = np.random.randint(0, 50)
-        maxv = (rand_int, rand_int)
+        img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
+        in_mat = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2GRAY)
+        maxv = (30, 30)
 
         # OpenCV
         expected_thresh, expected_mat = cv.threshold(in_mat, maxv[0], maxv[0], cv.THRESH_TRIANGLE)
@@ -113,12 +117,15 @@ def test_threshold(self):
         mat, threshold = cv.gapi.threshold(g_in, g_sc, cv.THRESH_TRIANGLE)
         comp = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(mat, threshold))
 
-        for pkg in pkgs:
+        for pkg_name, pkg in pkgs:
             actual_mat, actual_thresh = comp.apply(cv.gin(in_mat, maxv), args=cv.compile_args(pkg))
             # Comparison
-            self.assertEqual(0.0, cv.norm(expected_mat, actual_mat, cv.NORM_INF))
-            self.assertEqual(expected_mat.dtype, actual_mat.dtype)
-            self.assertEqual(expected_thresh, actual_thresh[0])
+            self.assertEqual(0.0, cv.norm(expected_mat, actual_mat, cv.NORM_INF),
+                             'Failed on ' + pkg_name + ' backend')
+            self.assertEqual(expected_mat.dtype, actual_mat.dtype,
+                             'Failed on ' + pkg_name + ' backend')
+            self.assertEqual(expected_thresh, actual_thresh[0],
+                             'Failed on ' + pkg_name + ' backend')
 
 
 if __name__ == '__main__':
Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,20 @@ static PyObject* from_grunarg(const GRunArg& v)`
`47`	`47`	`const auto& s = util::get<cv::Scalar>(v);`
`48`	`48`	`return pyopencv_from(s);`
`49`	`49`	`}`
`50`		`-`
	`50`	`+ case GRunArg::index_of<cv::detail::VectorRef>():`
	`51`	`+ {`
	`52`	`+ const auto& vref = util::get<cv::detail::VectorRef>(v);`
	`53`	`+ switch (vref.getKind())`
	`54`	`+ {`
	`55`	`+ case cv::detail::OpaqueKind::CV_POINT2F:`
	`56`	`+ return pyopencv_from(vref.rref<cv::Point2f>());`
	`57`	`+ default:`
	`58`	`+ PyErr_SetString(PyExc_TypeError, "Unsupported kind for GArray");`
	`59`	`+ return NULL;`
	`60`	`+ }`
	`61`	`+ }`
`51`	`62`	`default:`
	`63`	`+ PyErr_SetString(PyExc_TypeError, "Failed to unpack GRunArgs");`
`52`	`64`	`return NULL;`
`53`	`65`	`}`
`54`	`66`	`GAPI_Assert(false);`
`@@ -65,7 +77,6 @@ PyObject* pyopencv_from(const GRunArgs& value)`
`65`	`77`	`PyObject* item = from_grunarg(value[0]);`
`66`	`78`	`if(!item)`
`67`	`79`	`{`
`68`		`- PyErr_SetString(PyExc_TypeError, "Failed to unpack GRunArgs");`
`69`	`80`	`return NULL;`
`70`	`81`	`}`
`71`	`82`	`return item;`
`@@ -117,9 +128,13 @@ static PyObject* extract_proto_args(PyObject* py_args, PyObject* kw)`
`117`	`128`	`{`
`118`	`129`	`args.emplace_back(reinterpret_cast<pyopencv_GMat_t*>(item)->v);`
`119`	`130`	`}`
	`131`	`+ else if (PyObject_TypeCheck(item, reinterpret_cast<PyTypeObject*>(pyopencv_GArrayP2f_TypePtr)))`
	`132`	`+ {`
	`133`	`+ args.emplace_back(reinterpret_cast<pyopencv_GArrayP2f_t*>(item)->v.strip());`
	`134`	`+ }`
`120`	`135`	`else`
`121`	`136`	`{`
`122`		`- PyErr_SetString(PyExc_TypeError, "cv.GIn() supports only cv.GMat and cv.GScalar");`
	`137`	`+ PyErr_SetString(PyExc_TypeError, "Unsupported type for cv.GIn()/cv.GOut()");`
`123`	`138`	`return NULL;`
`124`	`139`	`}`
`125`	`140`	`}`