Merge pull request #22494 from TolyaTalamanov:at/expose-all-core-to-python

TolyaTalamanov · web-flow · commit 2aad039b4f64 · 2022-11-08T11:43:38.000Z
G-API Expose all core operations to python

* Expose all G-API core operations to python

* Fix typo in python gapi types test
diff --git a/modules/gapi/include/opencv2/gapi/core.hpp b/modules/gapi/include/opencv2/gapi/core.hpp
diff --git a/modules/gapi/include/opencv2/gapi/gcommon.hpp b/modules/gapi/include/opencv2/gapi/gcommon.hpp
@@ -51,6 +51,7 @@ namespace detail
         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_POINT3F,    // cv::Point3f 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
@@ -72,16 +73,17 @@ namespace detail
     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::Point3f> { static constexpr const OpaqueKind kind = OpaqueKind::CV_POINT3F; };
     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>;
+                                               cv::Point3f, 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>;
+    using GOpaqueTraitsOpaqueTypes = std::tuple<int, double, float, uint64_t, bool, std::string, cv::Size, cv::Point, cv::Point2f, cv::Point3f,
+                                                cv::Rect, cv::gapi::wip::draw::Prim>;
 } // namespace detail
 
 // This definition is here because it is reused by both public(?) and internal
diff --git a/modules/gapi/include/opencv2/gapi/gscalar.hpp b/modules/gapi/include/opencv2/gapi/gscalar.hpp
@@ -67,6 +67,7 @@ class GAPI_EXPORTS_W_SIMPLE GScalar
      *
      * @param s a cv::Scalar value to associate with this GScalar object.
      */
+    GAPI_WRAP
     explicit GScalar(const cv::Scalar& s);
 
     /**
diff --git a/modules/gapi/include/opencv2/gapi/imgproc.hpp b/modules/gapi/include/opencv2/gapi/imgproc.hpp
@@ -654,8 +654,8 @@ center.
 @param borderValue border value in case of constant border type
 @sa  boxFilter, bilateralFilter, GaussianBlur, medianBlur
  */
-GAPI_EXPORTS GMat blur(const GMat& src, const Size& ksize, const Point& anchor = Point(-1,-1),
-                       int borderType = BORDER_DEFAULT, const Scalar& borderValue = Scalar(0));
+GAPI_EXPORTS_W GMat blur(const GMat& src, const Size& ksize, const Point& anchor = Point(-1,-1),
+                         int borderType = BORDER_DEFAULT, const Scalar& borderValue = Scalar(0));
 
 
 //GAPI_EXPORTS_W void blur( InputArray src, OutputArray dst,
diff --git a/modules/gapi/include/opencv2/gapi/s11n.hpp b/modules/gapi/include/opencv2/gapi/s11n.hpp
@@ -229,6 +229,9 @@ 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::Point3f &pt);
+GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Point3f &pt);
+
 GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Size &sz);
 GAPI_EXPORTS IIStream& operator>> (IIStream& is,       cv::Size &sz);
 
diff --git a/modules/gapi/misc/python/package/gapi/__init__.py b/modules/gapi/misc/python/package/gapi/__init__.py
@@ -76,6 +76,10 @@ class Point2f():
         def __new__(self):
             return cv.GOpaqueT(cv.gapi.CV_POINT2F)
 
+    class Point3f():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_POINT3F)
+
     class Size():
         def __new__(self):
             return cv.GOpaqueT(cv.gapi.CV_SIZE)
@@ -127,6 +131,10 @@ class Point2f():
         def __new__(self):
             return cv.GArrayT(cv.gapi.CV_POINT2F)
 
+    class Point3f():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_POINT3F)
+
     class Size():
         def __new__(self):
             return cv.GArrayT(cv.gapi.CV_SIZE)
@@ -167,6 +175,7 @@ def op(op_id, in_types, out_types):
             cv.GArray.String:  cv.gapi.CV_STRING,
             cv.GArray.Point:   cv.gapi.CV_POINT,
             cv.GArray.Point2f: cv.gapi.CV_POINT2F,
+            cv.GArray.Point3f: cv.gapi.CV_POINT3F,
             cv.GArray.Size:    cv.gapi.CV_SIZE,
             cv.GArray.Rect:    cv.gapi.CV_RECT,
             cv.GArray.Scalar:  cv.gapi.CV_SCALAR,
@@ -186,6 +195,7 @@ def op(op_id, in_types, out_types):
             cv.GOpaque.String:  cv.gapi.CV_STRING,
             cv.GOpaque.Point:   cv.gapi.CV_POINT,
             cv.GOpaque.Point2f: cv.gapi.CV_POINT2F,
+            cv.GOpaque.Point3f: cv.gapi.CV_POINT3F,
             cv.GOpaque.Size:    cv.gapi.CV_SIZE,
             cv.GOpaque.Rect:    cv.gapi.CV_RECT,
             cv.GOpaque.Prim:    cv.gapi.CV_DRAW_PRIM,
@@ -200,6 +210,7 @@ def op(op_id, in_types, out_types):
         cv.gapi.CV_STRING:    'cv.gapi.CV_STRING' ,
         cv.gapi.CV_POINT:     'cv.gapi.CV_POINT' ,
         cv.gapi.CV_POINT2F:   'cv.gapi.CV_POINT2F' ,
+        cv.gapi.CV_POINT3F:   'cv.gapi.CV_POINT3F' ,
         cv.gapi.CV_SIZE:      'cv.gapi.CV_SIZE',
         cv.gapi.CV_RECT:      'cv.gapi.CV_RECT',
         cv.gapi.CV_SCALAR:    'cv.gapi.CV_SCALAR',
diff --git a/modules/gapi/misc/python/pyopencv_gapi.hpp b/modules/gapi/misc/python/pyopencv_gapi.hpp
@@ -19,6 +19,7 @@ using gapi_wip_IStreamSource_Ptr    = cv::Ptr<cv::gapi::wip::IStreamSource>;
 using detail_ExtractArgsCallback    = cv::detail::ExtractArgsCallback;
 using detail_ExtractMetaCallback    = cv::detail::ExtractMetaCallback;
 using vector_GNetParam              = std::vector<cv::gapi::GNetParam>;
+using vector_GMat                   = std::vector<cv::GMat>;
 using gapi_streaming_queue_capacity = cv::gapi::streaming::queue_capacity;
 using GStreamerSource_OutputType    = cv::gapi::wip::GStreamerSource::OutputType;
 
@@ -41,6 +42,7 @@ using GArray_float   = cv::GArray<double>;
 using GArray_string  = cv::GArray<std::string>;
 using GArray_Point2i = cv::GArray<cv::Point>;
 using GArray_Point2f = cv::GArray<cv::Point2f>;
+using GArray_Point3f = cv::GArray<cv::Point3f>;
 using GArray_Size    = cv::GArray<cv::Size>;
 using GArray_Rect    = cv::GArray<cv::Rect>;
 using GArray_Scalar  = cv::GArray<cv::Scalar>;
@@ -238,6 +240,7 @@ PyObject* pyopencv_from(const cv::GArg& value)
         HANDLE_CASE(STRING,    std::string);
         HANDLE_CASE(POINT,     cv::Point);
         HANDLE_CASE(POINT2F,   cv::Point2f);
+        HANDLE_CASE(POINT3F,   cv::Point3f);
         HANDLE_CASE(SIZE,      cv::Size);
         HANDLE_CASE(RECT,      cv::Rect);
         HANDLE_CASE(SCALAR,    cv::Scalar);
@@ -295,6 +298,7 @@ PyObject* pyopencv_from(const cv::detail::OpaqueRef& o)
         case cv::detail::OpaqueKind::CV_STRING    : return pyopencv_from(o.rref<std::string>());
         case cv::detail::OpaqueKind::CV_POINT     : return pyopencv_from(o.rref<cv::Point>());
         case cv::detail::OpaqueKind::CV_POINT2F   : return pyopencv_from(o.rref<cv::Point2f>());
+        case cv::detail::OpaqueKind::CV_POINT3F   : return pyopencv_from(o.rref<cv::Point3f>());
         case cv::detail::OpaqueKind::CV_SIZE      : return pyopencv_from(o.rref<cv::Size>());
         case cv::detail::OpaqueKind::CV_RECT      : return pyopencv_from(o.rref<cv::Rect>());
         case cv::detail::OpaqueKind::CV_UNKNOWN   : return pyopencv_from(o.rref<cv::GArg>());
@@ -321,6 +325,7 @@ PyObject* pyopencv_from(const cv::detail::VectorRef& v)
         case cv::detail::OpaqueKind::CV_STRING    : return pyopencv_from_generic_vec(v.rref<std::string>());
         case cv::detail::OpaqueKind::CV_POINT     : return pyopencv_from_generic_vec(v.rref<cv::Point>());
         case cv::detail::OpaqueKind::CV_POINT2F   : return pyopencv_from_generic_vec(v.rref<cv::Point2f>());
+        case cv::detail::OpaqueKind::CV_POINT3F   : return pyopencv_from_generic_vec(v.rref<cv::Point3f>());
         case cv::detail::OpaqueKind::CV_SIZE      : return pyopencv_from_generic_vec(v.rref<cv::Size>());
         case cv::detail::OpaqueKind::CV_RECT      : return pyopencv_from_generic_vec(v.rref<cv::Rect>());
         case cv::detail::OpaqueKind::CV_SCALAR    : return pyopencv_from_generic_vec(v.rref<cv::Scalar>());
@@ -491,6 +496,7 @@ static cv::detail::OpaqueRef extract_opaque_ref(PyObject* from, cv::detail::Opaq
         HANDLE_CASE(STRING,  std::string);
         HANDLE_CASE(POINT,   cv::Point);
         HANDLE_CASE(POINT2F, cv::Point2f);
+        HANDLE_CASE(POINT3F, cv::Point3f);
         HANDLE_CASE(SIZE,    cv::Size);
         HANDLE_CASE(RECT,    cv::Rect);
         HANDLE_CASE(UNKNOWN, cv::GArg);
@@ -523,6 +529,7 @@ static cv::detail::VectorRef extract_vector_ref(PyObject* from, cv::detail::Opaq
         HANDLE_CASE(STRING,    std::string);
         HANDLE_CASE(POINT,     cv::Point);
         HANDLE_CASE(POINT2F,   cv::Point2f);
+        HANDLE_CASE(POINT3F,   cv::Point3f);
         HANDLE_CASE(SIZE,      cv::Size);
         HANDLE_CASE(RECT,      cv::Rect);
         HANDLE_CASE(SCALAR,    cv::Scalar);
diff --git a/modules/gapi/misc/python/python_bridge.hpp b/modules/gapi/misc/python/python_bridge.hpp
@@ -36,6 +36,7 @@ WRAP_ARGS(float       , cv::gapi::ArgType::CV_FLOAT,     G)  \
 WRAP_ARGS(std::string , cv::gapi::ArgType::CV_STRING,    G)  \
 WRAP_ARGS(cv::Point   , cv::gapi::ArgType::CV_POINT,     G)  \
 WRAP_ARGS(cv::Point2f , cv::gapi::ArgType::CV_POINT2F,   G)  \
+WRAP_ARGS(cv::Point3f , cv::gapi::ArgType::CV_POINT3F,   G)  \
 WRAP_ARGS(cv::Size    , cv::gapi::ArgType::CV_SIZE,      G)  \
 WRAP_ARGS(cv::Rect    , cv::gapi::ArgType::CV_RECT,      G)  \
 WRAP_ARGS(cv::Scalar  , cv::gapi::ArgType::CV_SCALAR,    G)  \
@@ -53,6 +54,7 @@ WRAP_ARGS(float       , cv::gapi::ArgType::CV_FLOAT,   G)  \
 WRAP_ARGS(std::string , cv::gapi::ArgType::CV_STRING,  G)  \
 WRAP_ARGS(cv::Point   , cv::gapi::ArgType::CV_POINT,   G)  \
 WRAP_ARGS(cv::Point2f , cv::gapi::ArgType::CV_POINT2F, G)  \
+WRAP_ARGS(cv::Point3f , cv::gapi::ArgType::CV_POINT3F, G)  \
 WRAP_ARGS(cv::Size    , cv::gapi::ArgType::CV_SIZE,    G)  \
 WRAP_ARGS(cv::GArg    , cv::gapi::ArgType::CV_ANY,     G)  \
 WRAP_ARGS(cv::Rect    , cv::gapi::ArgType::CV_RECT,    G2) \
@@ -70,6 +72,7 @@ enum ArgType {
     CV_STRING,
     CV_POINT,
     CV_POINT2F,
+    CV_POINT3F,
     CV_SIZE,
     CV_RECT,
     CV_SCALAR,
diff --git a/modules/gapi/misc/python/test/test_gapi_core.py b/modules/gapi/misc/python/test/test_gapi_core.py
@@ -164,7 +164,7 @@ def test_kmeans(self):
 
         def generate_random_points(self, sz):
             arr = np.random.random(sz).astype(np.float32).T
-            return list(zip(arr[0], arr[1]))
+            return list(zip(*[arr[i] for i in range(sz[1])]))
 
 
         def test_kmeans_2d(self):
@@ -194,6 +194,33 @@ def test_kmeans_2d(self):
             self.assertEqual(K, len(centers))
 
 
+        def test_kmeans_3d(self):
+            # K-means 3D params
+            count     = 100
+            sz        = (count, 3)
+            amount    = sz[0]
+            K         = 5
+            flags     = cv.KMEANS_RANDOM_CENTERS
+            attempts  = 1
+            criteria  = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0)
+            in_vector = self.generate_random_points(sz)
+            in_labels = []
+
+            # G-API
+            data        = cv.GArrayT(cv.gapi.CV_POINT3F)
+            best_labels = cv.GArrayT(cv.gapi.CV_INT)
+
+            compactness, out_labels, centers = cv.gapi.kmeans(data, K, best_labels, criteria, attempts, flags)
+            comp = cv.GComputation(cv.GIn(data, best_labels), cv.GOut(compactness, out_labels, centers))
+
+            compact, labels, centers = comp.apply(cv.gin(in_vector, in_labels))
+
+            # Assert
+            self.assertTrue(compact >= 0)
+            self.assertEqual(amount, len(labels))
+            self.assertEqual(K, len(centers))
+
+
 except unittest.SkipTest as e:
 
     message = str(e)
diff --git a/modules/gapi/misc/python/test/test_gapi_types.py b/modules/gapi/misc/python/test/test_gapi_types.py
@@ -18,18 +18,19 @@ class gapi_types_test(NewOpenCVTests):
 
         def test_garray_type(self):
             types = [cv.gapi.CV_BOOL  , cv.gapi.CV_INT   , cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT,
-                     cv.gapi.CV_STRING, cv.gapi.CV_POINT , cv.gapi.CV_POINT2F, cv.gapi.CV_SIZE ,
-                     cv.gapi.CV_RECT  , cv.gapi.CV_SCALAR, cv.gapi.CV_MAT    , cv.gapi.CV_GMAT]
+                     cv.gapi.CV_STRING, cv.gapi.CV_POINT , cv.gapi.CV_POINT2F, cv.gapi.CV_POINT3F ,
+                     cv.gapi.CV_SIZE  , cv.gapi.CV_RECT  , cv.gapi.CV_SCALAR , cv.gapi.CV_MAT  ,
+                     cv.gapi.CV_GMAT]
 
             for t in types:
                 g_array = cv.GArrayT(t)
                 self.assertEqual(t, g_array.type())
 
 
         def test_gopaque_type(self):
-            types = [cv.gapi.CV_BOOL  , cv.gapi.CV_INT   , cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT,
-                     cv.gapi.CV_STRING, cv.gapi.CV_POINT , cv.gapi.CV_POINT2F, cv.gapi.CV_SIZE ,
-                     cv.gapi.CV_RECT]
+            types = [cv.gapi.CV_BOOL  , cv.gapi.CV_INT  , cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT  ,
+                     cv.gapi.CV_STRING, cv.gapi.CV_POINT, cv.gapi.CV_POINT2F, cv.gapi.CV_POINT3F,
+                     cv.gapi.CV_SIZE  , cv.gapi.CV_RECT]
 
             for t in types:
                 g_opaque = cv.GOpaqueT(t)
diff --git a/modules/gapi/src/backends/common/serialization.cpp b/modules/gapi/src/backends/common/serialization.cpp
@@ -176,6 +176,13 @@ IIStream& operator>> (IIStream& is, cv::Point2f& pt) {
     return is >> pt.x >> pt.y;
 }
 
+IOStream& operator<< (IOStream& os, const cv::Point3f &pt) {
+    return os << pt.x << pt.y << pt.z;
+}
+IIStream& operator>> (IIStream& is, cv::Point3f& pt) {
+    return is >> pt.x >> pt.y >> pt.z;
+}
+
 IOStream& operator<< (IOStream& os, const cv::Size &sz) {
     return os << sz.width << sz.height;
 }
@@ -584,6 +591,7 @@ IIStream& operator>> (IIStream& is, cv::GArg &arg) {
             HANDLE_CASE(STRING  , std::string);
             HANDLE_CASE(POINT   , cv::Point);
             HANDLE_CASE(POINT2F , cv::Point2f);
+            HANDLE_CASE(POINT3F , cv::Point3f);
             HANDLE_CASE(SIZE    , cv::Size);
             HANDLE_CASE(RECT    , cv::Rect);
             HANDLE_CASE(SCALAR  , cv::Scalar);

Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,7 @@ class GAPI_EXPORTS_W_SIMPLE GScalar`
`67`	`67`	`*`
`68`	`68`	`* @param s a cv::Scalar value to associate with this GScalar object.`
`69`	`69`	`*/`
	`70`	`+ GAPI_WRAP`
`70`	`71`	`explicit GScalar(const cv::Scalar& s);`
`71`	`72`
`72`	`73`	`/**`