Enabled VAS OT in G-API Python interface

modules/gapi/include/opencv2/gapi/cpu/ot.hpp

@@ -19,7 +19,7 @@ namespace gapi {
  */
 namespace ot {
 namespace cpu {
-GAPI_EXPORTS GKernelPackage kernels();
+GAPI_EXPORTS_W GKernelPackage kernels();
 } // namespace cpu
 } // namespace ot
 } // namespace gapi

modules/gapi/include/opencv2/gapi/ot.hpp

@@ -24,7 +24,7 @@ namespace ot {
  *
  * Tracking status twin for vas::ot::TrackingStatus
  */
-enum class TrackingStatus: int32_t
+enum TrackingStatus
 {
     NEW = 0,     /**< The object is newly added. */
     TRACKED,     /**< The object is being tracked. */
@@ -32,7 +32,7 @@ enum class TrackingStatus: int32_t
                       by specifying detected object manually. */
 };
 
-struct ObjectTrackerParams
+struct GAPI_EXPORTS_W_SIMPLE ObjectTrackerParams
 {
     /**
      * Maximum number of trackable objects in a frame.
@@ -40,12 +40,12 @@ struct ObjectTrackerParams
      * of maximum number in X86. KMB/TBH has limitation up to 1024.
      * Default value is -1 which means there is no limitation in X86. KMB/TBH is -1 means 200.
      */
-    int32_t max_num_objects = -1;
+    GAPI_PROP_RW int32_t max_num_objects = -1;
 
     /**
      * Input color format. Supports 0(BGR), 1(NV12), 2(BGRX) and 4(I420)
      */
-    int32_t input_image_format = 0;
+    GAPI_PROP_RW int32_t input_image_format = 0;
 
     /**
      * Specifies whether tracker to use detection class for keeping id of an object.
@@ -60,7 +60,7 @@ struct ObjectTrackerParams
      * @n
      * Default value is true.
      */
-    bool tracking_per_class = true;
+    GAPI_PROP_RW bool tracking_per_class = true;
 
     bool operator==(const ObjectTrackerParams& other) const
     {
@@ -70,7 +70,7 @@ struct ObjectTrackerParams
     }
 };
 
-using GTrackedInfo = std::tuple<cv::GArray<cv::Rect>, cv::GArray<int32_t>, cv::GArray<uint64_t>, cv::GArray<TrackingStatus>>;
+using GTrackedInfo = std::tuple<cv::GArray<cv::Rect>, cv::GArray<int32_t>, cv::GArray<uint64_t>, cv::GArray<int>>;
 
 G_API_OP(GTrackFromMat, <GTrackedInfo(cv::GMat, cv::GArray<cv::Rect>, cv::GArray<int32_t>, float)>, "com.intel.track_from_mat")
 {
@@ -107,23 +107,26 @@ G_API_OP(GTrackFromFrame, <GTrackedInfo(cv::GFrame, cv::GArray<cv::Rect>, cv::GA
  * @param delta                     Frame_delta_t Delta time between two consecutive tracking in seconds.
  *                                  The valid range is [0.005 ~ 0.5].
  * @return                          Tracking results of target objects.
- *                                  cv::GArray<cv::Rect>          Array of rectangles for tracked objects.
+ *                                  cv::GArray<cv::Rect>  Array of rectangles for tracked objects.
- *                                  cv::GArray<int32_t>           Array of detected objects labels.
+ *                                  cv::GArray<int32_t>   Array of detected objects labels.
- *                                  cv::GArray<uint64_t>          Array of tracking IDs for objects.
+ *                                  cv::GArray<uint64_t>  Array of tracking IDs for objects.
- *                                                                Numbering sequence starts from 1.
+ *                                                        Numbering sequence starts from 1.
- *                                                                The value 0 means the tracking ID of this object has
+ *                                                        The value 0 means the tracking ID of this object has
- *                                                                not been assigned.
+ *                                                        not been assigned.
- *                                  cv::GArray<TrackingStatus>    Array of tracking statuses for objects.
+ *                                  cv::GArray<int>       Array of tracking statuses for objects.
  */
-GAPI_EXPORTS std::tuple<cv::GArray<cv::Rect>,
+GAPI_EXPORTS_W std::tuple<cv::GArray<cv::Rect>,
-                        cv::GArray<int32_t>,
+                          cv::GArray<int>,
-                        cv::GArray<uint64_t>,
+                          cv::GArray<uint64_t>,
-                        cv::GArray<TrackingStatus>> track(const cv::GMat& mat,
+                          cv::GArray<int>>
-                                                          const cv::GArray<cv::Rect>& detected_rects,
+    track(const cv::GMat& mat,
-                                                          const cv::GArray<int>& detected_class_labels,
+          const cv::GArray<cv::Rect>& detected_rects,
-                                                          float delta);
+          const cv::GArray<int>& detected_class_labels,
+          float delta);
+
 
 /**
+   @overload
  * @brief   Tracks objects with video frames. Overload of track(...) for frame as GFrame.
  *
  * @param frame                     Input frame.
@@ -139,15 +142,16 @@ GAPI_EXPORTS std::tuple<cv::GArray<cv::Rect>,
  *                                                                Numbering sequence starts from 1.
  *                                                                The value 0 means the tracking ID of this object has
  *                                                                not been assigned.
- *                                  cv::GArray<TrackingStatus>    Array of tracking statuses for objects.
+ *                                  cv::GArray<int>    Array of tracking statuses for objects.
  */
-GAPI_EXPORTS std::tuple<cv::GArray<cv::Rect>,
+GAPI_EXPORTS_W std::tuple<cv::GArray<cv::Rect>,
-                        cv::GArray<int32_t>,
+                         cv::GArray<int>,
-                        cv::GArray<uint64_t>,
+                         cv::GArray<uint64_t>,
-                        cv::GArray<TrackingStatus>> track(const cv::GFrame& frame,
+                         cv::GArray<int>>
-                                                          const cv::GArray<cv::Rect>& detected_rects,
+    track(const cv::GFrame& frame,
-                                                          const cv::GArray<int>& detected_class_labels,
+          const cv::GArray<cv::Rect>& detected_rects,
-                                                          float delta);
+          const cv::GArray<int>& detected_class_labels,
+          float delta);
 } // namespace ot
 } // namespace gapi
 } // namespace cv

modules/gapi/misc/python/package/gapi/__init__.py

@@ -56,6 +56,14 @@ class GOpaque():
         def __new__(self):
             return cv.GOpaqueT(cv.gapi.CV_INT)
 
+    class Int64():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_INT64)
+
+    class UInt64():
+        def __new__(self):
+            return cv.GOpaqueT(cv.gapi.CV_UINT64)
+
     class Double():
         def __new__(self):
             return cv.GOpaqueT(cv.gapi.CV_DOUBLE)
@@ -111,6 +119,14 @@ class GArray():
         def __new__(self):
             return cv.GArrayT(cv.gapi.CV_INT)
 
+    class Int64():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_INT64)
+
+    class UInt64():
+        def __new__(self):
+            return cv.GArrayT(cv.gapi.CV_UINT64)
+
     class Double():
         def __new__(self):
             return cv.GArrayT(cv.gapi.CV_DOUBLE)
@@ -170,6 +186,8 @@ def op(op_id, in_types, out_types):
     garray_types= {
             cv.GArray.Bool:    cv.gapi.CV_BOOL,
             cv.GArray.Int:     cv.gapi.CV_INT,
+            cv.GArray.Int64:   cv.gapi.CV_INT64,
+            cv.GArray.UInt64:  cv.gapi.CV_UINT64,
             cv.GArray.Double:  cv.gapi.CV_DOUBLE,
             cv.GArray.Float:   cv.gapi.CV_FLOAT,
             cv.GArray.String:  cv.gapi.CV_STRING,
@@ -190,6 +208,8 @@ def op(op_id, in_types, out_types):
             cv.GOpaque.Rect:    cv.gapi.CV_RECT,
             cv.GOpaque.Bool:    cv.gapi.CV_BOOL,
             cv.GOpaque.Int:     cv.gapi.CV_INT,
+            cv.GOpaque.Int64:   cv.gapi.CV_INT64,
+            cv.GOpaque.UInt64:  cv.gapi.CV_UINT64,
             cv.GOpaque.Double:  cv.gapi.CV_DOUBLE,
             cv.GOpaque.Float:   cv.gapi.CV_FLOAT,
             cv.GOpaque.String:  cv.gapi.CV_STRING,
@@ -205,6 +225,8 @@ def op(op_id, in_types, out_types):
     type2str = {
         cv.gapi.CV_BOOL:      'cv.gapi.CV_BOOL' ,
         cv.gapi.CV_INT:       'cv.gapi.CV_INT' ,
+        cv.gapi.CV_INT64:     'cv.gapi.CV_INT64' ,
+        cv.gapi.CV_UINT64:    'cv.gapi.CV_UINT64' ,
         cv.gapi.CV_DOUBLE:    'cv.gapi.CV_DOUBLE' ,
         cv.gapi.CV_FLOAT:     'cv.gapi.CV_FLOAT' ,
         cv.gapi.CV_STRING:    'cv.gapi.CV_STRING' ,

modules/gapi/misc/python/pyopencv_gapi.hpp

@@ -246,6 +246,7 @@ PyObject* pyopencv_from(const cv::GArg& value)
         HANDLE_CASE(BOOL,      bool);
         HANDLE_CASE(INT,       int);
         HANDLE_CASE(INT64,     int64_t);
+        HANDLE_CASE(UINT64,    uint64_t);
         HANDLE_CASE(DOUBLE,    double);
         HANDLE_CASE(FLOAT,     float);
         HANDLE_CASE(STRING,    std::string);
@@ -258,7 +259,6 @@ PyObject* pyopencv_from(const cv::GArg& value)
         HANDLE_CASE(MAT,       cv::Mat);
         HANDLE_CASE(UNKNOWN,   cv::detail::PyObjectHolder);
         HANDLE_CASE(DRAW_PRIM, cv::gapi::wip::draw::Prim);
-        UNSUPPORTED(UINT64);
 #undef HANDLE_CASE
 #undef UNSUPPORTED
     }
@@ -304,6 +304,7 @@ PyObject* pyopencv_from(const cv::detail::OpaqueRef& o)
         case cv::detail::OpaqueKind::CV_BOOL      : return pyopencv_from(o.rref<bool>());
         case cv::detail::OpaqueKind::CV_INT       : return pyopencv_from(o.rref<int>());
         case cv::detail::OpaqueKind::CV_INT64     : return pyopencv_from(o.rref<int64_t>());
+        case cv::detail::OpaqueKind::CV_UINT64    : return pyopencv_from(o.rref<uint64_t>());
         case cv::detail::OpaqueKind::CV_DOUBLE    : return pyopencv_from(o.rref<double>());
         case cv::detail::OpaqueKind::CV_FLOAT     : return pyopencv_from(o.rref<float>());
         case cv::detail::OpaqueKind::CV_STRING    : return pyopencv_from(o.rref<std::string>());
@@ -314,7 +315,6 @@ PyObject* pyopencv_from(const cv::detail::OpaqueRef& o)
         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>());
         case cv::detail::OpaqueKind::CV_DRAW_PRIM : return pyopencv_from(o.rref<cv::gapi::wip::draw::Prim>());
-        case cv::detail::OpaqueKind::CV_UINT64    : break;
         case cv::detail::OpaqueKind::CV_SCALAR    : break;
         case cv::detail::OpaqueKind::CV_MAT       : break;
     }
@@ -331,6 +331,7 @@ PyObject* pyopencv_from(const cv::detail::VectorRef& v)
         case cv::detail::OpaqueKind::CV_BOOL      : return pyopencv_from_generic_vec(v.rref<bool>());
         case cv::detail::OpaqueKind::CV_INT       : return pyopencv_from_generic_vec(v.rref<int>());
         case cv::detail::OpaqueKind::CV_INT64     : return pyopencv_from_generic_vec(v.rref<int64_t>());
+        case cv::detail::OpaqueKind::CV_UINT64    : return pyopencv_from_generic_vec(v.rref<uint64_t>());
         case cv::detail::OpaqueKind::CV_DOUBLE    : return pyopencv_from_generic_vec(v.rref<double>());
         case cv::detail::OpaqueKind::CV_FLOAT     : return pyopencv_from_generic_vec(v.rref<float>());
         case cv::detail::OpaqueKind::CV_STRING    : return pyopencv_from_generic_vec(v.rref<std::string>());
@@ -343,7 +344,6 @@ PyObject* pyopencv_from(const cv::detail::VectorRef& v)
         case cv::detail::OpaqueKind::CV_MAT       : return pyopencv_from_generic_vec(v.rref<cv::Mat>());
         case cv::detail::OpaqueKind::CV_UNKNOWN   : return pyopencv_from_generic_vec(v.rref<cv::GArg>());
         case cv::detail::OpaqueKind::CV_DRAW_PRIM : return pyopencv_from_generic_vec(v.rref<cv::gapi::wip::draw::Prim>());
-        case cv::detail::OpaqueKind::CV_UINT64    : break;
     }
 
     PyErr_SetString(PyExc_TypeError, "Unsupported GArray type");
@@ -502,6 +502,8 @@ static cv::detail::OpaqueRef extract_opaque_ref(PyObject* from, cv::detail::Opaq
     {
         HANDLE_CASE(BOOL,    bool);
         HANDLE_CASE(INT,     int);
+        HANDLE_CASE(INT64,   int64_t);
+        HANDLE_CASE(UINT64,  uint64_t);
         HANDLE_CASE(DOUBLE,  double);
         HANDLE_CASE(FLOAT,   float);
         HANDLE_CASE(STRING,  std::string);
@@ -511,8 +513,6 @@ static cv::detail::OpaqueRef extract_opaque_ref(PyObject* from, cv::detail::Opaq
         HANDLE_CASE(SIZE,    cv::Size);
         HANDLE_CASE(RECT,    cv::Rect);
         HANDLE_CASE(UNKNOWN, cv::GArg);
-        UNSUPPORTED(UINT64);
-        UNSUPPORTED(INT64);
         UNSUPPORTED(SCALAR);
         UNSUPPORTED(MAT);
         UNSUPPORTED(DRAW_PRIM);
@@ -535,6 +535,8 @@ static cv::detail::VectorRef extract_vector_ref(PyObject* from, cv::detail::Opaq
     {
         HANDLE_CASE(BOOL,      bool);
         HANDLE_CASE(INT,       int);
+        HANDLE_CASE(INT64,     int64_t);
+        HANDLE_CASE(UINT64,    uint64_t);
         HANDLE_CASE(DOUBLE,    double);
         HANDLE_CASE(FLOAT,     float);
         HANDLE_CASE(STRING,    std::string);
@@ -547,8 +549,6 @@ static cv::detail::VectorRef extract_vector_ref(PyObject* from, cv::detail::Opaq
         HANDLE_CASE(MAT,       cv::Mat);
         HANDLE_CASE(UNKNOWN,   cv::GArg);
         HANDLE_CASE(DRAW_PRIM, cv::gapi::wip::draw::Prim);
-        UNSUPPORTED(UINT64);
-        UNSUPPORTED(INT64);
 #undef HANDLE_CASE
 #undef UNSUPPORTED
     }

modules/gapi/misc/python/python_bridge.hpp

@@ -31,6 +31,7 @@ using cv::gapi::wip::draw::Prim;
 WRAP_ARGS(bool        , cv::gapi::ArgType::CV_BOOL,      G)  \
 WRAP_ARGS(int         , cv::gapi::ArgType::CV_INT,       G)  \
 WRAP_ARGS(int64_t     , cv::gapi::ArgType::CV_INT64,     G)  \
+WRAP_ARGS(uint64_t    , cv::gapi::ArgType::CV_UINT64,    G)  \
 WRAP_ARGS(double      , cv::gapi::ArgType::CV_DOUBLE,    G)  \
 WRAP_ARGS(float       , cv::gapi::ArgType::CV_FLOAT,     G)  \
 WRAP_ARGS(std::string , cv::gapi::ArgType::CV_STRING,    G)  \
@@ -49,6 +50,7 @@ WRAP_ARGS(cv::GMat    , cv::gapi::ArgType::CV_GMAT,      G2) \
 WRAP_ARGS(bool        , cv::gapi::ArgType::CV_BOOL,    G)  \
 WRAP_ARGS(int         , cv::gapi::ArgType::CV_INT,     G)  \
 WRAP_ARGS(int64_t     , cv::gapi::ArgType::CV_INT64,   G)  \
+WRAP_ARGS(uint64_t    , cv::gapi::ArgType::CV_UINT64,  G)  \
 WRAP_ARGS(double      , cv::gapi::ArgType::CV_DOUBLE,  G)  \
 WRAP_ARGS(float       , cv::gapi::ArgType::CV_FLOAT,   G)  \
 WRAP_ARGS(std::string , cv::gapi::ArgType::CV_STRING,  G)  \
@@ -67,6 +69,7 @@ enum ArgType {
     CV_BOOL,
     CV_INT,
     CV_INT64,
+    CV_UINT64,
     CV_DOUBLE,
     CV_FLOAT,
     CV_STRING,

modules/gapi/misc/python/shadow_gapi.hpp

@@ -8,6 +8,7 @@ struct GAPI_EXPORTS_W_SIMPLE GCompileArg
     GAPI_WRAP GCompileArg(GKernelPackage arg);
     GAPI_WRAP GCompileArg(gapi::GNetPackage arg);
     GAPI_WRAP GCompileArg(gapi::streaming::queue_capacity arg);
+    GAPI_WRAP GCompileArg(gapi::ot::ObjectTrackerParams arg);
 };
 
 class GAPI_EXPORTS_W_SIMPLE GInferInputs

modules/gapi/misc/python/test/test_gapi_ot.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+
+import numpy as np
+import cv2 as cv
+import os
+import sys
+import unittest
+
+from tests_common import NewOpenCVTests
+
+
+try:
+
+    if sys.version_info[:2] < (3, 0):
+        raise unittest.SkipTest('Python 2.x is not supported')
+
+    class gapi_ot_test(NewOpenCVTests):
+
+        def test_ot_smoke(self):
+            # Input
+            img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
+            in_image = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2BGR)
+            in_rects = [ (138, 89, 71, 64) ]
+            in_rects_cls = [ 0 ]
+
+            # G-API
+            g_in = cv.GMat()
+            g_in_rects = cv.GArray.Rect()
+            g_in_rects_cls = cv.GArray.Int()
+            delta = 0.5
+
+            g_out_rects, g_out_rects_cls, g_track_ids, g_track_sts = \
+                cv.gapi.ot.track(g_in, g_in_rects, g_in_rects_cls, delta)
+
+
+            comp = cv.GComputation(cv.GIn(g_in, g_in_rects, g_in_rects_cls),
+                                   cv.GOut(g_out_rects, g_out_rects_cls,
+                                           g_track_ids, g_track_sts))
+
+            __, __, __, sts = comp.apply(cv.gin(in_image, in_rects, in_rects_cls),
+                args=cv.gapi.compile_args(cv.gapi.ot.cpu.kernels()))
+
+            self.assertEqual(cv.gapi.ot.NEW, sts[0])
+
+except unittest.SkipTest as e:
+
+    message = str(e)
+
+    class TestSkip(unittest.TestCase):
+        def setUp(self):
+            self.skipTest('Skip tests: ' + message)
+
+        def test_skip():
+            pass
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/gapi/misc/python/test/test_gapi_types.py

@@ -17,10 +17,10 @@ try:
     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,
+            types = [cv.gapi.CV_BOOL   , cv.gapi.CV_INT    , cv.gapi.CV_INT64 , cv.gapi.CV_UINT64,
-                     cv.gapi.CV_STRING, cv.gapi.CV_POINT , cv.gapi.CV_POINT2F, cv.gapi.CV_POINT3F ,
+                     cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT  , cv.gapi.CV_STRING, cv.gapi.CV_POINT ,
-                     cv.gapi.CV_SIZE  , cv.gapi.CV_RECT  , cv.gapi.CV_SCALAR , cv.gapi.CV_MAT  ,
+                     cv.gapi.CV_POINT2F, cv.gapi.CV_POINT3F, cv.gapi.CV_SIZE  , cv.gapi.CV_RECT  ,
-                     cv.gapi.CV_GMAT]
+                     cv.gapi.CV_SCALAR , cv.gapi.CV_MAT    , cv.gapi.CV_GMAT]
 
             for t in types:
                 g_array = cv.GArrayT(t)
@@ -28,9 +28,9 @@ try:
 
 
         def test_gopaque_type(self):
-            types = [cv.gapi.CV_BOOL  , cv.gapi.CV_INT  , cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT  ,
+            types = [cv.gapi.CV_BOOL   , cv.gapi.CV_INT    ,  cv.gapi.CV_INT64 , cv.gapi.CV_UINT64,
-                     cv.gapi.CV_STRING, cv.gapi.CV_POINT, cv.gapi.CV_POINT2F, cv.gapi.CV_POINT3F,
+                     cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT  ,  cv.gapi.CV_STRING, cv.gapi.CV_POINT ,
-                     cv.gapi.CV_SIZE  , cv.gapi.CV_RECT]
+                     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)

modules/gapi/src/api/kernels_ot.cpp

@@ -18,10 +18,11 @@ namespace ot
 GAPI_EXPORTS_W std::tuple<cv::GArray<cv::Rect>,
                           cv::GArray<int32_t>,
                           cv::GArray<uint64_t>,
-                          cv::GArray<TrackingStatus>> track(const cv::GMat& mat,
+                          cv::GArray<int>>
-                                                            const cv::GArray<cv::Rect>& detected_rects,
+    track(const cv::GMat& mat,
-                                                            const cv::GArray<int>& detected_class_labels,
+          const cv::GArray<cv::Rect>& detected_rects,
-                                                            float delta)
+          const cv::GArray<int>& detected_class_labels,
+          float delta)
 {
     return GTrackFromMat::on(mat, detected_rects, detected_class_labels, delta);
 }
@@ -29,10 +30,11 @@ GAPI_EXPORTS_W std::tuple<cv::GArray<cv::Rect>,
 GAPI_EXPORTS_W std::tuple<cv::GArray<cv::Rect>,
                           cv::GArray<int32_t>,
                           cv::GArray<uint64_t>,
-                          cv::GArray<TrackingStatus>> track(const cv::GFrame& frame,
+                          cv::GArray<int>>
-                                                            const cv::GArray<cv::Rect>& detected_rects,
+    track(const cv::GFrame& frame,
-                                                            const cv::GArray<int>& detected_class_labels,
+          const cv::GArray<cv::Rect>& detected_rects,
-                                                            float delta)
+          const cv::GArray<int>& detected_class_labels,
+          float delta)
 {
     return GTrackFromFrame::on(frame, detected_rects, detected_class_labels, delta);
 }

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

@@ -72,7 +72,7 @@ GAPI_OCV_KERNEL_ST(GTrackFromMatImpl, cv::gapi::ot::GTrackFromMat, vas::ot::Obje
                     std::vector<cv::Rect>& out_tr_rects,
                     std::vector<int32_t>& out_rects_classes,
                     std::vector<uint64_t>& out_tr_ids,
-                    std::vector<TrackingStatus>& out_tr_statuses,
+                    std::vector<int>& out_tr_statuses,
                     vas::ot::ObjectTracker& state)
     {
         std::vector<vas::ot::DetectedObject> detected_objs;
@@ -87,7 +87,7 @@ GAPI_OCV_KERNEL_ST(GTrackFromMatImpl, cv::gapi::ot::GTrackFromMat, vas::ot::Obje
             out_tr_rects.push_back(object.rect);
             out_rects_classes.push_back(object.class_label);
             out_tr_ids.push_back(object.tracking_id);
-            out_tr_statuses.push_back(TrackingStatus(static_cast<int>(object.status)));
+            out_tr_statuses.push_back(static_cast<int>(object.status));
         }
     }
 };
@@ -111,7 +111,7 @@ GAPI_OCV_KERNEL_ST(GTrackFromFrameImpl, cv::gapi::ot::GTrackFromFrame, vas::ot::
                     std::vector<cv::Rect>& out_tr_rects,
                     std::vector<int32_t>& out_rects_classes,
                     std::vector<uint64_t>& out_tr_ids,
-                    std::vector<TrackingStatus>& out_tr_statuses,
+                    std::vector<int>& out_tr_statuses,
                     vas::ot::ObjectTracker& state)
     {
         std::vector<vas::ot::DetectedObject> detected_objs;
@@ -144,7 +144,7 @@ GAPI_OCV_KERNEL_ST(GTrackFromFrameImpl, cv::gapi::ot::GTrackFromFrame, vas::ot::
             out_tr_rects.push_back(object.rect);
             out_rects_classes.push_back(object.class_label);
             out_tr_ids.push_back(object.tracking_id);
-            out_tr_statuses.push_back(TrackingStatus(static_cast<int>(object.status)));
+            out_tr_statuses.push_back(static_cast<int>(object.status));
         }
     }
 };

modules/gapi/test/cpu/gapi_ot_tests_cpu.cpp

@@ -120,7 +120,7 @@ GAPI_OCV_KERNEL_ST(OCV_CvVideo768x576_Detect, CvVideo768x576_Detect, FrameDetect
 };
 
 G_API_OP(CheckTrackerResults, <cv::GOpaque<bool>(cv::GArray<cv::Rect>, cv::GArray<int32_t>,
-                                                 cv::GArray<uint64_t>, cv::GArray<cv::gapi::ot::TrackingStatus>)>,
+                                                 cv::GArray<uint64_t>, cv::GArray<int>)>,
     "test.custom.check_tracker_results") {
     static cv::GOpaqueDesc outMeta(cv::GArrayDesc, cv::GArrayDesc, cv::GArrayDesc, cv::GArrayDesc) {
         return cv::empty_gopaque_desc();
@@ -140,7 +140,7 @@ GAPI_OCV_KERNEL_ST(OCVCheckTrackerResults, CheckTrackerResults, TrackerReference
     static void run(const std::vector<cv::Rect> &in_tr_rcts,
                     const std::vector<int32_t> &in_det_ids,
                     const std::vector<uint64_t> &in_tr_ids,
-                    const std::vector<cv::gapi::ot::TrackingStatus> &in_tr_statuses,
+                    const std::vector<int> &in_tr_statuses,
                     bool& success,
                     TrackerReference& state) {
 
@@ -237,7 +237,7 @@ TEST(VASObjectTracker, PipelineTest)
     cv::GArray<cv::Rect> tracking_rects;
     cv::GArray<int32_t> tracking_det_ids;
     cv::GArray<uint64_t> tracking_ids;
-    cv::GArray<cv::gapi::ot::TrackingStatus> tracking_statuses;
+    cv::GArray<int> tracking_statuses;
     std::tie(tracking_rects, tracking_det_ids, tracking_ids, tracking_statuses) =
         cv::gapi::ot::track(in, detections, det_ids, delta_time);
 

modules/python/src2/cv2_convert.hpp

@@ -156,6 +156,33 @@ struct PyOpenCV_Converter
     }
 };
 
+// There is conflict between "uint64_t" and "size_t".
+// They are the same type on some 32-bit platforms.
+template<typename T>
+struct PyOpenCV_Converter
+    < T, typename std::enable_if< std::is_same<uint64_t, T>::value && !std::is_same<uint64_t, size_t>::value >::type >
+{
+    static inline PyObject* from(const uint64_t& value)
+    {
+        return PyLong_FromUnsignedLongLong(value);
+    }
+
+    static inline bool to(PyObject* obj, uint64_t& value, const ArgInfo& info)
+    {
+        CV_UNUSED(info);
+        if(!obj || obj == Py_None)
+            return true;
+        if(PyInt_Check(obj))
+            value = (uint64_t)PyInt_AsUnsignedLongLongMask(obj);
+        else if(PyLong_Check(obj))
+            value = (uint64_t)PyLong_AsUnsignedLongLong(obj);
+        else
+            return false;
+        return value != (uint64_t)-1 || !PyErr_Occurred();
+    }
+};
+
+
 // --- uchar
 template<> bool pyopencv_to(PyObject* obj, uchar& value, const ArgInfo& info);
 template<> PyObject* pyopencv_from(const uchar& value);

modules/python/src2/pycompat.hpp

@@ -53,6 +53,7 @@
 #define PyInt_CheckExact PyLong_CheckExact
 #define PyInt_AsLong PyLong_AsLong
 #define PyInt_AS_LONG PyLong_AS_LONG
+#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
 #define PyInt_FromLong PyLong_FromLong
 #define PyNumber_Int PyNumber_Long