modules/python/src2/cv2.cpp

   1 //warning number '5033' not a valid compiler warning in vc12
   2 #if defined(_MSC_VER) && (_MSC_VER > 1800)
   3 // eliminating duplicated round() declaration
   4 #define HAVE_ROUND 1
   5 #pragma warning(push)
   6 #pragma warning(disable:5033)  // 'register' is no longer a supported storage class
   7 #endif
   8
   9 // #define CVPY_DYNAMIC_INIT
  10 // #define Py_DEBUG
  11
  12 #if defined(CVPY_DYNAMIC_INIT) && !defined(Py_DEBUG)
  13 #   define Py_LIMITED_API 0x03030000
  14 #endif
  15
  16 #include <cmath>
  17 #include <Python.h>
  18 #include <limits>
  19
  20 #if PY_MAJOR_VERSION < 3
  21 #undef CVPY_DYNAMIC_INIT
  22 #else
  23 #define CV_PYTHON_3 1
  24 #endif
  25
  26 #if defined(_MSC_VER) && (_MSC_VER > 1800)
  27 #pragma warning(pop)
  28 #endif
  29
  30 #define MODULESTR "cv2"
  31 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
  32
  33 #include <numpy/ndarrayobject.h>
  34
  35 #include "opencv2/core/utils/configuration.private.hpp"
  36 #include "opencv2/core/utils/logger.hpp"
  37 #include "opencv2/core/utils/tls.hpp"
  38
  39 #include "pyopencv_generated_include.h"
  40 #include "opencv2/core/types_c.h"
  41 #include "opencv2/opencv_modules.hpp"
  42 #include "pycompat.hpp"
  43 #include <map>
  44
  45 #include <type_traits>  // std::enable_if
  46
  47 #define CV_HAS_CONVERSION_ERROR(x) (((x) == -1) && PyErr_Occurred())
  48
  49
  50 class ArgInfo
  51 {
  52 public:
  53     const char* name;
  54     bool outputarg;
  55     // more fields may be added if necessary
  56
  57     ArgInfo(const char* name_, bool outputarg_) : name(name_), outputarg(outputarg_) {}
  58
  59 private:
  60     ArgInfo(const ArgInfo&) = delete;
  61     ArgInfo& operator=(const ArgInfo&) = delete;
  62 };
  63
  64 template<typename T, class TEnable = void>  // TEnable is used for SFINAE checks
  65 struct PyOpenCV_Converter
  66 {
  67     //static inline bool to(PyObject* obj, T& p, const ArgInfo& info);
  68     //static inline PyObject* from(const T& src);
  69 };
  70
  71 template<typename T> static
  72 bool pyopencv_to(PyObject* obj, T& p, const ArgInfo& info) { return PyOpenCV_Converter<T>::to(obj, p, info); }
  73
  74 template<typename T> static
  75 PyObject* pyopencv_from(const T& src) { return PyOpenCV_Converter<T>::from(src); }
  76
  77 static PyObject* opencv_error = NULL;
  78
  79 static bool isPythonBindingsDebugEnabled()
  80 {
  81     static bool param_debug = cv::utils::getConfigurationParameterBool("OPENCV_PYTHON_DEBUG", false);
  82     return param_debug;
  83 }
  84
  85 static void emit_failmsg(PyObject * exc, const char *msg)
  86 {
  87     static bool param_debug = isPythonBindingsDebugEnabled();
  88     if (param_debug)
  89     {
  90         CV_LOG_WARNING(NULL, "Bindings conversion failed: " << msg);
  91     }
  92     PyErr_SetString(exc, msg);
  93 }
  94
  95 static int failmsg(const char *fmt, ...)
  96 {
  97     char str[1000];
  98
  99     va_list ap;
 100     va_start(ap, fmt);
 101     vsnprintf(str, sizeof(str), fmt, ap);
 102     va_end(ap);
 103
 104     emit_failmsg(PyExc_TypeError, str);
 105     return 0;
 106 }
 107
 108 static PyObject* failmsgp(const char *fmt, ...)
 109 {
 110     char str[1000];
 111
 112     va_list ap;
 113     va_start(ap, fmt);
 114     vsnprintf(str, sizeof(str), fmt, ap);
 115     va_end(ap);
 116
 117     emit_failmsg(PyExc_TypeError, str);
 118     return 0;
 119 }
 120
 121 class PyAllowThreads
 122 {
 123 public:
 124     PyAllowThreads() : _state(PyEval_SaveThread()) {}
 125     ~PyAllowThreads()
 126     {
 127         PyEval_RestoreThread(_state);
 128     }
 129 private:
 130     PyThreadState* _state;
 131 };
 132
 133 class PyEnsureGIL
 134 {
 135 public:
 136     PyEnsureGIL() : _state(PyGILState_Ensure()) {}
 137     ~PyEnsureGIL()
 138     {
 139         PyGILState_Release(_state);
 140     }
 141 private:
 142     PyGILState_STATE _state;
 143 };
 144
 145 /**
 146  * Light weight RAII wrapper for `PyObject*` owning references.
 147  * In comparisson to C++11 `std::unique_ptr` with custom deleter, it provides
 148  * implicit conversion functions that might be useful to initialize it with
 149  * Python functions those returns owning references through the `PyObject**`
 150  * e.g. `PyErr_Fetch` or directly pass it to functions those want to borrow
 151  * reference to object (doesn't extend object lifetime) e.g. `PyObject_Str`.
 152  */
 153 class PySafeObject
 154 {
 155 public:
 156     PySafeObject() : obj_(NULL) {}
 157
 158     explicit PySafeObject(PyObject* obj) : obj_(obj) {}
 159
 160     ~PySafeObject()
 161     {
 162         Py_CLEAR(obj_);
 163     }
 164
 165     operator PyObject*()
 166     {
 167         return obj_;
 168     }
 169
 170     operator PyObject**()
 171     {
 172         return &obj_;
 173     }
 174
 175     PyObject* release()
 176     {
 177         PyObject* obj = obj_;
 178         obj_ = NULL;
 179         return obj;
 180     }
 181
 182 private:
 183     PyObject* obj_;
 184
 185     // Explicitly disable copy operations
 186     PySafeObject(const PySafeObject*); // = delete
 187     PySafeObject& operator=(const PySafeObject&); // = delete
 188 };
 189
 190 static void pyRaiseCVException(const cv::Exception &e)
 191 {
 192     PyObject_SetAttrString(opencv_error, "file", PyString_FromString(e.file.c_str()));
 193     PyObject_SetAttrString(opencv_error, "func", PyString_FromString(e.func.c_str()));
 194     PyObject_SetAttrString(opencv_error, "line", PyInt_FromLong(e.line));
 195     PyObject_SetAttrString(opencv_error, "code", PyInt_FromLong(e.code));
 196     PyObject_SetAttrString(opencv_error, "msg", PyString_FromString(e.msg.c_str()));
 197     PyObject_SetAttrString(opencv_error, "err", PyString_FromString(e.err.c_str()));
 198     PyErr_SetString(opencv_error, e.what());
 199 }
 200
 201 #define ERRWRAP2(expr) \
 202 try \
 203 { \
 204     PyAllowThreads allowThreads; \
 205     expr; \
 206 } \
 207 catch (const cv::Exception &e) \
 208 { \
 209     pyRaiseCVException(e); \
 210     return 0; \
 211 }
 212
 213 using namespace cv;
 214
 215
 216 namespace {
 217 template<class T>
 218 NPY_TYPES asNumpyType()
 219 {
 220     return NPY_OBJECT;
 221 }
 222
 223 template<>
 224 NPY_TYPES asNumpyType<bool>()
 225 {
 226     return NPY_BOOL;
 227 }
 228
 229 #define CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(src, dst) \
 230     template<>                                             \
 231     NPY_TYPES asNumpyType<src>()                           \
 232     {                                                      \
 233         return NPY_##dst;                                  \
 234     }                                                      \
 235     template<>                                             \
 236     NPY_TYPES asNumpyType<u##src>()                        \
 237     {                                                      \
 238         return NPY_U##dst;                                 \
 239     }
 240
 241 CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int8_t, INT8);
 242
 243 CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int16_t, INT16);
 244
 245 CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int32_t, INT32);
 246
 247 CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int64_t, INT64);
 248
 249 #undef CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION
 250
 251 template<>
 252 NPY_TYPES asNumpyType<float>()
 253 {
 254     return NPY_FLOAT;
 255 }
 256
 257 template<>
 258 NPY_TYPES asNumpyType<double>()
 259 {
 260     return NPY_DOUBLE;
 261 }
 262
 263 template <class T>
 264 PyArray_Descr* getNumpyTypeDescriptor()
 265 {
 266     return PyArray_DescrFromType(asNumpyType<T>());
 267 }
 268
 269 template <>
 270 PyArray_Descr* getNumpyTypeDescriptor<size_t>()
 271 {
 272 #if SIZE_MAX == ULONG_MAX
 273     return PyArray_DescrFromType(NPY_ULONG);
 274 #elif SIZE_MAX == ULLONG_MAX
 275     return PyArray_DescrFromType(NPY_ULONGLONG);
 276 #else
 277     return PyArray_DescrFromType(NPY_UINT);
 278 #endif
 279 }
 280
 281 template <class T, class U>
 282 bool isRepresentable(U value) {
 283     return (std::numeric_limits<T>::min() <= value) && (value <= std::numeric_limits<T>::max());
 284 }
 285
 286 template<class T>
 287 bool canBeSafelyCasted(PyObject* obj, PyArray_Descr* to)
 288 {
 289     return PyArray_CanCastTo(PyArray_DescrFromScalar(obj), to) != 0;
 290 }
 291
 292
 293 template<>
 294 bool canBeSafelyCasted<size_t>(PyObject* obj, PyArray_Descr* to)
 295 {
 296     PyArray_Descr* from = PyArray_DescrFromScalar(obj);
 297     if (PyArray_CanCastTo(from, to))
 298     {
 299         return true;
 300     }
 301     else
 302     {
 303         // False negative scenarios:
 304         // - Signed input is positive so it can be safely cast to unsigned output
 305         // - Input has wider limits but value is representable within output limits
 306         // - All the above
 307         if (PyDataType_ISSIGNED(from))
 308         {
 309             int64_t input = 0;
 310             PyArray_CastScalarToCtype(obj, &input, getNumpyTypeDescriptor<int64_t>());
 311             return (input >= 0) && isRepresentable<size_t>(static_cast<uint64_t>(input));
 312         }
 313         else
 314         {
 315             uint64_t input = 0;
 316             PyArray_CastScalarToCtype(obj, &input, getNumpyTypeDescriptor<uint64_t>());
 317             return isRepresentable<size_t>(input);
 318         }
 319         return false;
 320     }
 321 }
 322
 323
 324 template<class T>
 325 bool parseNumpyScalar(PyObject* obj, T& value)
 326 {
 327     if (PyArray_CheckScalar(obj))
 328     {
 329         // According to the numpy documentation:
 330         // There are 21 statically-defined PyArray_Descr objects for the built-in data-types
 331         // So descriptor pointer is not owning.
 332         PyArray_Descr* to = getNumpyTypeDescriptor<T>();
 333         if (canBeSafelyCasted<T>(obj, to))
 334         {
 335             PyArray_CastScalarToCtype(obj, &value, to);
 336             return true;
 337         }
 338     }
 339     return false;
 340 }
 341
 342 TLSData<std::vector<std::string> > conversionErrorsTLS;
 343
 344 inline void pyPrepareArgumentConversionErrorsStorage(std::size_t size)
 345 {
 346     std::vector<std::string>& conversionErrors = conversionErrorsTLS.getRef();
 347     conversionErrors.clear();
 348     conversionErrors.reserve(size);
 349 }
 350
 351 void pyRaiseCVOverloadException(const std::string& functionName)
 352 {
 353     const std::vector<std::string>& conversionErrors = conversionErrorsTLS.getRef();
 354     const std::size_t conversionErrorsCount = conversionErrors.size();
 355     if (conversionErrorsCount > 0)
 356     {
 357         // In modern std libraries small string optimization is used = no dynamic memory allocations,
 358         // but it can be applied only for string with length < 18 symbols (in GCC)
 359         const std::string bullet = "\n - ";
 360
 361         // Estimate required buffer size - save dynamic memory allocations = faster
 362         std::size_t requiredBufferSize = bullet.size() * conversionErrorsCount;
 363         for (std::size_t i = 0; i < conversionErrorsCount; ++i)
 364         {
 365             requiredBufferSize += conversionErrors[i].size();
 366         }
 367
 368         // Only string concatenation is required so std::string is way faster than
 369         // std::ostringstream
 370         std::string errorMessage("Overload resolution failed:");
 371         errorMessage.reserve(errorMessage.size() + requiredBufferSize);
 372         for (std::size_t i = 0; i < conversionErrorsCount; ++i)
 373         {
 374             errorMessage += bullet;
 375             errorMessage += conversionErrors[i];
 376         }
 377         cv::Exception exception(CV_StsBadArg, errorMessage, functionName, "", -1);
 378         pyRaiseCVException(exception);
 379     }
 380     else
 381     {
 382         cv::Exception exception(CV_StsInternal, "Overload resolution failed, but no errors reported",
 383                                 functionName, "", -1);
 384         pyRaiseCVException(exception);
 385     }
 386 }
 387
 388 void pyPopulateArgumentConversionErrors()
 389 {
 390     if (PyErr_Occurred())
 391     {
 392         PySafeObject exception_type;
 393         PySafeObject exception_value;
 394         PySafeObject exception_traceback;
 395         PyErr_Fetch(exception_type, exception_value, exception_traceback);
 396         PyErr_NormalizeException(exception_type, exception_value,
 397                                  exception_traceback);
 398
 399         PySafeObject exception_message(PyObject_Str(exception_value));
 400         std::string message;
 401         getUnicodeString(exception_message, message);
 402 #ifdef CV_CXX11
 403         conversionErrorsTLS.getRef().push_back(std::move(message));
 404 #else
 405         conversionErrorsTLS.getRef().push_back(message);
 406 #endif
 407     }
 408 }
 409
 410 struct SafeSeqItem
 411 {
 412     PyObject * item;
 413     SafeSeqItem(PyObject *obj, size_t idx) { item = PySequence_GetItem(obj, idx); }
 414     ~SafeSeqItem() { Py_XDECREF(item); }
 415
 416 private:
 417     SafeSeqItem(const SafeSeqItem&); // = delete
 418     SafeSeqItem& operator=(const SafeSeqItem&); // = delete
 419 };
 420
 421 template <class T>
 422 class RefWrapper
 423 {
 424 public:
 425     RefWrapper(T& item) : item_(item) {}
 426
 427     T& get() CV_NOEXCEPT { return item_; }
 428
 429 private:
 430     T& item_;
 431 };
 432
 433 // In order to support this conversion on 3.x branch - use custom reference_wrapper
 434 // and C-style array instead of std::array<T, N>
 435 template <class T, std::size_t N>
 436 bool parseSequence(PyObject* obj, RefWrapper<T> (&value)[N], const ArgInfo& info)
 437 {
 438     if (!obj || obj == Py_None)
 439     {
 440         return true;
 441     }
 442     if (!PySequence_Check(obj))
 443     {
 444         failmsg("Can't parse '%s'. Input argument doesn't provide sequence "
 445                 "protocol", info.name);
 446         return false;
 447     }
 448     const std::size_t sequenceSize = PySequence_Size(obj);
 449     if (sequenceSize != N)
 450     {
 451         failmsg("Can't parse '%s'. Expected sequence length %lu, got %lu",
 452                 info.name, N, sequenceSize);
 453         return false;
 454     }
 455     for (std::size_t i = 0; i < N; ++i)
 456     {
 457         SafeSeqItem seqItem(obj, i);
 458         if (!pyopencv_to(seqItem.item, value[i].get(), info))
 459         {
 460             failmsg("Can't parse '%s'. Sequence item with index %lu has a "
 461                     "wrong type", info.name, i);
 462             return false;
 463         }
 464     }
 465     return true;
 466 }
 467 } // namespace
 468
 469 typedef std::vector<uchar> vector_uchar;
 470 typedef std::vector<char> vector_char;
 471 typedef std::vector<int> vector_int;
 472 typedef std::vector<float> vector_float;
 473 typedef std::vector<double> vector_double;
 474 typedef std::vector<size_t> vector_size_t;
 475 typedef std::vector<Point> vector_Point;
 476 typedef std::vector<Point2f> vector_Point2f;
 477 typedef std::vector<Point3f> vector_Point3f;
 478 typedef std::vector<Size> vector_Size;
 479 typedef std::vector<Vec2f> vector_Vec2f;
 480 typedef std::vector<Vec3f> vector_Vec3f;
 481 typedef std::vector<Vec4f> vector_Vec4f;
 482 typedef std::vector<Vec6f> vector_Vec6f;
 483 typedef std::vector<Vec4i> vector_Vec4i;
 484 typedef std::vector<Rect> vector_Rect;
 485 typedef std::vector<Rect2d> vector_Rect2d;
 486 typedef std::vector<RotatedRect> vector_RotatedRect;
 487 typedef std::vector<KeyPoint> vector_KeyPoint;
 488 typedef std::vector<Mat> vector_Mat;
 489 typedef std::vector<std::vector<Mat> > vector_vector_Mat;
 490 typedef std::vector<UMat> vector_UMat;
 491 typedef std::vector<DMatch> vector_DMatch;
 492 typedef std::vector<String> vector_String;
 493 typedef std::vector<std::string> vector_string;
 494 typedef std::vector<Scalar> vector_Scalar;
 495
 496 typedef std::vector<std::vector<char> > vector_vector_char;
 497 typedef std::vector<std::vector<Point> > vector_vector_Point;
 498 typedef std::vector<std::vector<Point2f> > vector_vector_Point2f;
 499 typedef std::vector<std::vector<Point3f> > vector_vector_Point3f;
 500 typedef std::vector<std::vector<DMatch> > vector_vector_DMatch;
 501 typedef std::vector<std::vector<KeyPoint> > vector_vector_KeyPoint;
 502
 503 class NumpyAllocator : public MatAllocator
 504 {
 505 public:
 506     NumpyAllocator() { stdAllocator = Mat::getStdAllocator(); }
 507     ~NumpyAllocator() {}
 508
 509     UMatData* allocate(PyObject* o, int dims, const int* sizes, int type, size_t* step) const
 510     {
 511         UMatData* u = new UMatData(this);
 512         u->data = u->origdata = (uchar*)PyArray_DATA((PyArrayObject*) o);
 513         npy_intp* _strides = PyArray_STRIDES((PyArrayObject*) o);
 514         for( int i = 0; i < dims - 1; i++ )
 515             step[i] = (size_t)_strides[i];
 516         step[dims-1] = CV_ELEM_SIZE(type);
 517         u->size = sizes[0]*step[0];
 518         u->userdata = o;
 519         return u;
 520     }
 521
 522     UMatData* allocate(int dims0, const int* sizes, int type, void* data, size_t* step, AccessFlag flags, UMatUsageFlags usageFlags) const CV_OVERRIDE
 523     {
 524         if( data != 0 )
 525         {
 526             // issue #6969: CV_Error(Error::StsAssert, "The data should normally be NULL!");
 527             // probably this is safe to do in such extreme case
 528             return stdAllocator->allocate(dims0, sizes, type, data, step, flags, usageFlags);
 529         }
 530         PyEnsureGIL gil;
 531
 532         int depth = CV_MAT_DEPTH(type);
 533         int cn = CV_MAT_CN(type);
 534         const int f = (int)(sizeof(size_t)/8);
 535         int typenum = depth == CV_8U ? NPY_UBYTE : depth == CV_8S ? NPY_BYTE :
 536         depth == CV_16U ? NPY_USHORT : depth == CV_16S ? NPY_SHORT :
 537         depth == CV_32S ? NPY_INT : depth == CV_32F ? NPY_FLOAT :
 538         depth == CV_64F ? NPY_DOUBLE : f*NPY_ULONGLONG + (f^1)*NPY_UINT;
 539         int i, dims = dims0;
 540         cv::AutoBuffer<npy_intp> _sizes(dims + 1);
 541         for( i = 0; i < dims; i++ )
 542             _sizes[i] = sizes[i];
 543         if( cn > 1 )
 544             _sizes[dims++] = cn;
 545         PyObject* o = PyArray_SimpleNew(dims, _sizes.data(), typenum);
 546         if(!o)
 547             CV_Error_(Error::StsError, ("The numpy array of typenum=%d, ndims=%d can not be created", typenum, dims));
 548         return allocate(o, dims0, sizes, type, step);
 549     }
 550
 551     bool allocate(UMatData* u, AccessFlag accessFlags, UMatUsageFlags usageFlags) const CV_OVERRIDE
 552     {
 553         return stdAllocator->allocate(u, accessFlags, usageFlags);
 554     }
 555
 556     void deallocate(UMatData* u) const CV_OVERRIDE
 557     {
 558         if(!u)
 559             return;
 560         PyEnsureGIL gil;
 561         CV_Assert(u->urefcount >= 0);
 562         CV_Assert(u->refcount >= 0);
 563         if(u->refcount == 0)
 564         {
 565             PyObject* o = (PyObject*)u->userdata;
 566             Py_XDECREF(o);
 567             delete u;
 568         }
 569     }
 570
 571     const MatAllocator* stdAllocator;
 572 };
 573
 574 NumpyAllocator g_numpyAllocator;
 575
 576
 577 enum { ARG_NONE = 0, ARG_MAT = 1, ARG_SCALAR = 2 };
 578
 579 static bool isBool(PyObject* obj) CV_NOEXCEPT
 580 {
 581     return PyArray_IsScalar(obj, Bool) || PyBool_Check(obj);
 582 }
 583
 584 // special case, when the converter needs full ArgInfo structure
 585 static bool pyopencv_to(PyObject* o, Mat& m, const ArgInfo& info)
 586 {
 587     bool allowND = true;
 588     if(!o || o == Py_None)
 589     {
 590         if( !m.data )
 591             m.allocator = &g_numpyAllocator;
 592         return true;
 593     }
 594
 595     if( PyInt_Check(o) )
 596     {
 597         double v[] = {static_cast<double>(PyInt_AsLong((PyObject*)o)), 0., 0., 0.};
 598         m = Mat(4, 1, CV_64F, v).clone();
 599         return true;
 600     }
 601     if( PyFloat_Check(o) )
 602     {
 603         double v[] = {PyFloat_AsDouble((PyObject*)o), 0., 0., 0.};
 604         m = Mat(4, 1, CV_64F, v).clone();
 605         return true;
 606     }
 607     if( PyTuple_Check(o) )
 608     {
 609         int i, sz = (int)PyTuple_Size((PyObject*)o);
 610         m = Mat(sz, 1, CV_64F);
 611         for( i = 0; i < sz; i++ )
 612         {
 613             PyObject* oi = PyTuple_GetItem(o, i);
 614             if( PyInt_Check(oi) )
 615                 m.at<double>(i) = (double)PyInt_AsLong(oi);
 616             else if( PyFloat_Check(oi) )
 617                 m.at<double>(i) = (double)PyFloat_AsDouble(oi);
 618             else
 619             {
 620                 failmsg("%s is not a numerical tuple", info.name);
 621                 m.release();
 622                 return false;
 623             }
 624         }
 625         return true;
 626     }
 627
 628     if( !PyArray_Check(o) )
 629     {
 630         failmsg("%s is not a numpy array, neither a scalar", info.name);
 631         return false;
 632     }
 633
 634     PyArrayObject* oarr = (PyArrayObject*) o;
 635
 636     bool needcopy = false, needcast = false;
 637     int typenum = PyArray_TYPE(oarr), new_typenum = typenum;
 638     int type = typenum == NPY_UBYTE ? CV_8U :
 639                typenum == NPY_BYTE ? CV_8S :
 640                typenum == NPY_USHORT ? CV_16U :
 641                typenum == NPY_SHORT ? CV_16S :
 642                typenum == NPY_INT ? CV_32S :
 643                typenum == NPY_INT32 ? CV_32S :
 644                typenum == NPY_FLOAT ? CV_32F :
 645                typenum == NPY_DOUBLE ? CV_64F : -1;
 646
 647     if( type < 0 )
 648     {
 649         if( typenum == NPY_INT64 || typenum == NPY_UINT64 || typenum == NPY_LONG )
 650         {
 651             needcopy = needcast = true;
 652             new_typenum = NPY_INT;
 653             type = CV_32S;
 654         }
 655         else
 656         {
 657             failmsg("%s data type = %d is not supported", info.name, typenum);
 658             return false;
 659         }
 660     }
 661
 662 #ifndef CV_MAX_DIM
 663     const int CV_MAX_DIM = 32;
 664 #endif
 665
 666     int ndims = PyArray_NDIM(oarr);
 667     if(ndims >= CV_MAX_DIM)
 668     {
 669         failmsg("%s dimensionality (=%d) is too high", info.name, ndims);
 670         return false;
 671     }
 672
 673     int size[CV_MAX_DIM+1];
 674     size_t step[CV_MAX_DIM+1];
 675     size_t elemsize = CV_ELEM_SIZE1(type);
 676     const npy_intp* _sizes = PyArray_DIMS(oarr);
 677     const npy_intp* _strides = PyArray_STRIDES(oarr);
 678     bool ismultichannel = ndims == 3 && _sizes[2] <= CV_CN_MAX;
 679
 680     for( int i = ndims-1; i >= 0 && !needcopy; i-- )
 681     {
 682         // these checks handle cases of
 683         //  a) multi-dimensional (ndims > 2) arrays, as well as simpler 1- and 2-dimensional cases
 684         //  b) transposed arrays, where _strides[] elements go in non-descending order
 685         //  c) flipped arrays, where some of _strides[] elements are negative
 686         // the _sizes[i] > 1 is needed to avoid spurious copies when NPY_RELAXED_STRIDES is set
 687         if( (i == ndims-1 && _sizes[i] > 1 && (size_t)_strides[i] != elemsize) ||
 688             (i < ndims-1 && _sizes[i] > 1 && _strides[i] < _strides[i+1]) )
 689             needcopy = true;
 690     }
 691
 692     if( ismultichannel && _strides[1] != (npy_intp)elemsize*_sizes[2] )
 693         needcopy = true;
 694
 695     if (needcopy)
 696     {
 697         if (info.outputarg)
 698         {
 699             failmsg("Layout of the output array %s is incompatible with cv::Mat (step[ndims-1] != elemsize or step[1] != elemsize*nchannels)", info.name);
 700             return false;
 701         }
 702
 703         if( needcast ) {
 704             o = PyArray_Cast(oarr, new_typenum);
 705             oarr = (PyArrayObject*) o;
 706         }
 707         else {
 708             oarr = PyArray_GETCONTIGUOUS(oarr);
 709             o = (PyObject*) oarr;
 710         }
 711
 712         _strides = PyArray_STRIDES(oarr);
 713     }
 714
 715     // Normalize strides in case NPY_RELAXED_STRIDES is set
 716     size_t default_step = elemsize;
 717     for ( int i = ndims - 1; i >= 0; --i )
 718     {
 719         size[i] = (int)_sizes[i];
 720         if ( size[i] > 1 )
 721         {
 722             step[i] = (size_t)_strides[i];
 723             default_step = step[i] * size[i];
 724         }
 725         else
 726         {
 727             step[i] = default_step;
 728             default_step *= size[i];
 729         }
 730     }
 731
 732     // handle degenerate case
 733     if( ndims == 0) {
 734         size[ndims] = 1;
 735         step[ndims] = elemsize;
 736         ndims++;
 737     }
 738
 739     if( ismultichannel )
 740     {
 741         ndims--;
 742         type |= CV_MAKETYPE(0, size[2]);
 743     }
 744
 745     if( ndims > 2 && !allowND )
 746     {
 747         failmsg("%s has more than 2 dimensions", info.name);
 748         return false;
 749     }
 750
 751     m = Mat(ndims, size, type, PyArray_DATA(oarr), step);
 752     m.u = g_numpyAllocator.allocate(o, ndims, size, type, step);
 753     m.addref();
 754
 755     if( !needcopy )
 756     {
 757         Py_INCREF(o);
 758     }
 759     m.allocator = &g_numpyAllocator;
 760
 761     return true;
 762 }
 763
 764 template<typename _Tp, int m, int n>
 765 bool pyopencv_to(PyObject* o, Matx<_Tp, m, n>& mx, const ArgInfo& info)
 766 {
 767     Mat tmp;
 768     if (!pyopencv_to(o, tmp, info)) {
 769         return false;
 770     }
 771
 772     tmp.copyTo(mx);
 773     return true;
 774 }
 775
 776 template<typename _Tp, int cn>
 777 bool pyopencv_to(PyObject* o, Vec<_Tp, cn>& vec, const ArgInfo& info)
 778 {
 779     return pyopencv_to(o, (Matx<_Tp, cn, 1>&)vec, info);
 780 }
 781
 782 template<>
 783 PyObject* pyopencv_from(const Mat& m)
 784 {
 785     if( !m.data )
 786         Py_RETURN_NONE;
 787     Mat temp, *p = (Mat*)&m;
 788     if(!p->u || p->allocator != &g_numpyAllocator)
 789     {
 790         temp.allocator = &g_numpyAllocator;
 791         ERRWRAP2(m.copyTo(temp));
 792         p = &temp;
 793     }
 794     PyObject* o = (PyObject*)p->u->userdata;
 795     Py_INCREF(o);
 796     return o;
 797 }
 798
 799 template<typename _Tp, int m, int n>
 800 PyObject* pyopencv_from(const Matx<_Tp, m, n>& matx)
 801 {
 802     return pyopencv_from(Mat(matx));
 803 }
 804
 805 template<typename T>
 806 struct PyOpenCV_Converter< cv::Ptr<T> >
 807 {
 808     static PyObject* from(const cv::Ptr<T>& p)
 809     {
 810         if (!p)
 811             Py_RETURN_NONE;
 812         return pyopencv_from(*p);
 813     }
 814     static bool to(PyObject *o, Ptr<T>& p, const ArgInfo& info)
 815     {
 816         if (!o || o == Py_None)
 817             return true;
 818         p = makePtr<T>();
 819         return pyopencv_to(o, *p, info);
 820     }
 821 };
 822
 823 template<>
 824 bool pyopencv_to(PyObject* obj, void*& ptr, const ArgInfo& info)
 825 {
 826     CV_UNUSED(info);
 827     if (!obj || obj == Py_None)
 828         return true;
 829
 830     if (!PyLong_Check(obj))
 831         return false;
 832     ptr = PyLong_AsVoidPtr(obj);
 833     return ptr != NULL && !PyErr_Occurred();
 834 }
 835
 836 static PyObject* pyopencv_from(void*& ptr)
 837 {
 838     return PyLong_FromVoidPtr(ptr);
 839 }
 840
 841 static bool pyopencv_to(PyObject *o, Scalar& s, const ArgInfo& info)
 842 {
 843     if(!o || o == Py_None)
 844         return true;
 845     if (PySequence_Check(o)) {
 846         if (4 < PySequence_Size(o))
 847         {
 848             failmsg("Scalar value for argument '%s' is longer than 4", info.name);
 849             return false;
 850         }
 851         for (Py_ssize_t i = 0; i < PySequence_Size(o); i++) {
 852             SafeSeqItem item_wrap(o, i);
 853             PyObject *item = item_wrap.item;
 854             if (PyFloat_Check(item) || PyInt_Check(item)) {
 855                 s[(int)i] = PyFloat_AsDouble(item);
 856             } else {
 857                 failmsg("Scalar value for argument '%s' is not numeric", info.name);
 858                 return false;
 859             }
 860         }
 861     } else {
 862         if (PyFloat_Check(o) || PyInt_Check(o)) {
 863             s[0] = PyFloat_AsDouble(o);
 864         } else {
 865             failmsg("Scalar value for argument '%s' is not numeric", info.name);
 866             return false;
 867         }
 868     }
 869     return true;
 870 }
 871
 872 template<>
 873 PyObject* pyopencv_from(const Scalar& src)
 874 {
 875     return Py_BuildValue("(dddd)", src[0], src[1], src[2], src[3]);
 876 }
 877
 878 template<>
 879 PyObject* pyopencv_from(const bool& value)
 880 {
 881     return PyBool_FromLong(value);
 882 }
 883
 884 template<>
 885 bool pyopencv_to(PyObject* obj, bool& value, const ArgInfo& info)
 886 {
 887     if (!obj || obj == Py_None)
 888     {
 889         return true;
 890     }
 891     if (isBool(obj) || PyArray_IsIntegerScalar(obj))
 892     {
 893         npy_bool npy_value = NPY_FALSE;
 894         const int ret_code = PyArray_BoolConverter(obj, &npy_value);
 895         if (ret_code >= 0)
 896         {
 897             value = (npy_value == NPY_TRUE);
 898             return true;
 899         }
 900     }
 901     failmsg("Argument '%s' is not convertable to bool", info.name);
 902     return false;
 903 }
 904
 905 template<>
 906 PyObject* pyopencv_from(const size_t& value)
 907 {
 908     return PyLong_FromSize_t(value);
 909 }
 910
 911 template<>
 912 bool pyopencv_to(PyObject* obj, size_t& value, const ArgInfo& info)
 913 {
 914     if (!obj || obj == Py_None)
 915     {
 916         return true;
 917     }
 918     if (isBool(obj))
 919     {
 920         failmsg("Argument '%s' must be integer type, not bool", info.name);
 921         return false;
 922     }
 923     if (PyArray_IsIntegerScalar(obj))
 924     {
 925         if (PyLong_Check(obj))
 926         {
 927 #if defined(CV_PYTHON_3)
 928             value = PyLong_AsSize_t(obj);
 929 #else
 930     #if ULONG_MAX == SIZE_MAX
 931             value = PyLong_AsUnsignedLong(obj);
 932     #else
 933             value = PyLong_AsUnsignedLongLong(obj);
 934     #endif
 935 #endif
 936         }
 937 #if !defined(CV_PYTHON_3)
 938         // Python 2.x has PyIntObject which is not a subtype of PyLongObject
 939         // Overflow check here is unnecessary because object will be converted to long on the
 940         // interpreter side
 941         else if (PyInt_Check(obj))
 942         {
 943             const long res = PyInt_AsLong(obj);
 944             if (res < 0) {
 945                 failmsg("Argument '%s' can not be safely parsed to 'size_t'", info.name);
 946                 return false;
 947             }
 948     #if ULONG_MAX == SIZE_MAX
 949             value = PyInt_AsUnsignedLongMask(obj);
 950     #else
 951             value = PyInt_AsUnsignedLongLongMask(obj);
 952     #endif
 953         }
 954 #endif
 955         else
 956         {
 957             const bool isParsed = parseNumpyScalar<size_t>(obj, value);
 958             if (!isParsed) {
 959                 failmsg("Argument '%s' can not be safely parsed to 'size_t'", info.name);
 960                 return false;
 961             }
 962         }
 963     }
 964     else
 965     {
 966         failmsg("Argument '%s' is required to be an integer", info.name);
 967         return false;
 968     }
 969     return !PyErr_Occurred();
 970 }
 971
 972 template<>
 973 PyObject* pyopencv_from(const int& value)
 974 {
 975     return PyInt_FromLong(value);
 976 }
 977
 978 template<>
 979 bool pyopencv_to(PyObject* obj, int& value, const ArgInfo& info)
 980 {
 981     if (!obj || obj == Py_None)
 982     {
 983         return true;
 984     }
 985     if (isBool(obj))
 986     {
 987         failmsg("Argument '%s' must be integer, not bool", info.name);
 988         return false;
 989     }
 990     if (PyArray_IsIntegerScalar(obj))
 991     {
 992         value = PyArray_PyIntAsInt(obj);
 993     }
 994     else
 995     {
 996         failmsg("Argument '%s' is required to be an integer", info.name);
 997         return false;
 998     }
 999     return !CV_HAS_CONVERSION_ERROR(value);
1000 }
1001
1002 // There is conflict between "size_t" and "unsigned int".
1003 // They are the same type on some 32-bit platforms.
1004 template<typename T>
1005 struct PyOpenCV_Converter
1006     < T, typename std::enable_if< std::is_same<unsigned int, T>::value && !std::is_same<unsigned int, size_t>::value >::type >
1007 {
1008     static inline PyObject* from(const unsigned int& value)
1009     {
1010         return PyLong_FromUnsignedLong(value);
1011     }
1012
1013     static inline bool to(PyObject* obj, unsigned int& value, const ArgInfo& info)
1014     {
1015         CV_UNUSED(info);
1016         if(!obj || obj == Py_None)
1017             return true;
1018         if(PyInt_Check(obj))
1019             value = (unsigned int)PyInt_AsLong(obj);
1020         else if(PyLong_Check(obj))
1021             value = (unsigned int)PyLong_AsLong(obj);
1022         else
1023             return false;
1024         return value != (unsigned int)-1 || !PyErr_Occurred();
1025     }
1026 };
1027
1028 template<>
1029 PyObject* pyopencv_from(const uchar& value)
1030 {
1031     return PyInt_FromLong(value);
1032 }
1033
1034 template<>
1035 bool pyopencv_to(PyObject* obj, uchar& value, const ArgInfo& info)
1036 {
1037     CV_UNUSED(info);
1038     if(!obj || obj == Py_None)
1039         return true;
1040     int ivalue = (int)PyInt_AsLong(obj);
1041     value = cv::saturate_cast<uchar>(ivalue);
1042     return ivalue != -1 || !PyErr_Occurred();
1043 }
1044
1045 template<>
1046 PyObject* pyopencv_from(const double& value)
1047 {
1048     return PyFloat_FromDouble(value);
1049 }
1050
1051 template<>
1052 bool pyopencv_to(PyObject* obj, double& value, const ArgInfo& info)
1053 {
1054     if (!obj || obj == Py_None)
1055     {
1056         return true;
1057     }
1058     if (isBool(obj))
1059     {
1060         failmsg("Argument '%s' must be double, not bool", info.name);
1061         return false;
1062     }
1063     if (PyArray_IsPythonNumber(obj))
1064     {
1065         if (PyLong_Check(obj))
1066         {
1067             value = PyLong_AsDouble(obj);
1068         }
1069         else
1070         {
1071             value = PyFloat_AsDouble(obj);
1072         }
1073     }
1074     else if (PyArray_CheckScalar(obj))
1075     {
1076         const bool isParsed = parseNumpyScalar<double>(obj, value);
1077         if (!isParsed) {
1078             failmsg("Argument '%s' can not be safely parsed to 'double'", info.name);
1079             return false;
1080         }
1081     }
1082     else
1083     {
1084         failmsg("Argument '%s' can not be treated as a double", info.name);
1085         return false;
1086     }
1087     return !PyErr_Occurred();
1088 }
1089
1090 template<>
1091 PyObject* pyopencv_from(const float& value)
1092 {
1093     return PyFloat_FromDouble(value);
1094 }
1095
1096 template<>
1097 bool pyopencv_to(PyObject* obj, float& value, const ArgInfo& info)
1098 {
1099     if (!obj || obj == Py_None)
1100     {
1101         return true;
1102     }
1103     if (isBool(obj))
1104     {
1105         failmsg("Argument '%s' must be float, not bool", info.name);
1106         return false;
1107     }
1108     if (PyArray_IsPythonNumber(obj))
1109     {
1110         if (PyLong_Check(obj))
1111         {
1112             double res = PyLong_AsDouble(obj);
1113             value = static_cast<float>(res);
1114         }
1115         else
1116         {
1117             double res = PyFloat_AsDouble(obj);
1118             value = static_cast<float>(res);
1119         }
1120     }
1121     else if (PyArray_CheckScalar(obj))
1122     {
1123        const bool isParsed = parseNumpyScalar<float>(obj, value);
1124         if (!isParsed) {
1125             failmsg("Argument '%s' can not be safely parsed to 'float'", info.name);
1126             return false;
1127         }
1128     }
1129     else
1130     {
1131         failmsg("Argument '%s' can't be treated as a float", info.name);
1132         return false;
1133     }
1134     return !PyErr_Occurred();
1135 }
1136
1137 template<>
1138 PyObject* pyopencv_from(const int64& value)
1139 {
1140     return PyLong_FromLongLong(value);
1141 }
1142
1143 template<>
1144 PyObject* pyopencv_from(const String& value)
1145 {
1146     return PyString_FromString(value.empty() ? "" : value.c_str());
1147 }
1148
1149 #if CV_VERSION_MAJOR == 3
1150 template<>
1151 PyObject* pyopencv_from(const std::string& value)
1152 {
1153     return PyString_FromString(value.empty() ? "" : value.c_str());
1154 }
1155 #endif
1156
1157 template<>
1158 bool pyopencv_to(PyObject* obj, String &value, const ArgInfo& info)
1159 {
1160     if(!obj || obj == Py_None)
1161     {
1162         return true;
1163     }
1164     std::string str;
1165     if (getUnicodeString(obj, str))
1166     {
1167         value = str;
1168         return true;
1169     }
1170     else
1171     {
1172         // If error hasn't been already set by Python conversion functions
1173         if (!PyErr_Occurred())
1174         {
1175             // Direct access to underlying slots of PyObjectType is not allowed
1176             // when limited API is enabled
1177 #ifdef Py_LIMITED_API
1178             failmsg("Can't convert object to 'str' for '%s'", info.name);
1179 #else
1180             failmsg("Can't convert object of type '%s' to 'str' for '%s'",
1181                     obj->ob_type->tp_name, info.name);
1182 #endif
1183         }
1184     }
1185     return false;
1186 }
1187
1188 template<>
1189 bool pyopencv_to(PyObject* obj, Size& sz, const ArgInfo& info)
1190 {
1191     RefWrapper<int> values[] = {RefWrapper<int>(sz.width),
1192                                 RefWrapper<int>(sz.height)};
1193     return parseSequence(obj, values, info);
1194 }
1195
1196 template<>
1197 PyObject* pyopencv_from(const Size& sz)
1198 {
1199     return Py_BuildValue("(ii)", sz.width, sz.height);
1200 }
1201
1202 template<>
1203 bool pyopencv_to(PyObject* obj, Size_<float>& sz, const ArgInfo& info)
1204 {
1205     RefWrapper<float> values[] = {RefWrapper<float>(sz.width),
1206                                   RefWrapper<float>(sz.height)};
1207     return parseSequence(obj, values, info);
1208 }
1209
1210 template<>
1211 PyObject* pyopencv_from(const Size_<float>& sz)
1212 {
1213     return Py_BuildValue("(ff)", sz.width, sz.height);
1214 }
1215
1216 template<>
1217 bool pyopencv_to(PyObject* obj, Rect& r, const ArgInfo& info)
1218 {
1219     RefWrapper<int> values[] = {RefWrapper<int>(r.x), RefWrapper<int>(r.y),
1220                                 RefWrapper<int>(r.width),
1221                                 RefWrapper<int>(r.height)};
1222     return parseSequence(obj, values, info);
1223 }
1224
1225 template<>
1226 PyObject* pyopencv_from(const Rect& r)
1227 {
1228     return Py_BuildValue("(iiii)", r.x, r.y, r.width, r.height);
1229 }
1230
1231 template<>
1232 bool pyopencv_to(PyObject* obj, Rect2d& r, const ArgInfo& info)
1233 {
1234     RefWrapper<double> values[] = {
1235         RefWrapper<double>(r.x), RefWrapper<double>(r.y),
1236         RefWrapper<double>(r.width), RefWrapper<double>(r.height)};
1237     return parseSequence(obj, values, info);
1238 }
1239
1240 template<>
1241 PyObject* pyopencv_from(const Rect2d& r)
1242 {
1243     return Py_BuildValue("(dddd)", r.x, r.y, r.width, r.height);
1244 }
1245
1246 template<>
1247 bool pyopencv_to(PyObject* obj, Range& r, const ArgInfo& info)
1248 {
1249     if (!obj || obj == Py_None)
1250     {
1251         return true;
1252     }
1253     if (PyObject_Size(obj) == 0)
1254     {
1255         r = Range::all();
1256         return true;
1257     }
1258     RefWrapper<int> values[] = {RefWrapper<int>(r.start), RefWrapper<int>(r.end)};
1259     return parseSequence(obj, values, info);
1260 }
1261
1262 template<>
1263 PyObject* pyopencv_from(const Range& r)
1264 {
1265     return Py_BuildValue("(ii)", r.start, r.end);
1266 }
1267
1268 template<>
1269 bool pyopencv_to(PyObject* obj, Point& p, const ArgInfo& info)
1270 {
1271     RefWrapper<int> values[] = {RefWrapper<int>(p.x), RefWrapper<int>(p.y)};
1272     return parseSequence(obj, values, info);
1273 }
1274
1275 template <>
1276 bool pyopencv_to(PyObject* obj, Point2f& p, const ArgInfo& info)
1277 {
1278     RefWrapper<float> values[] = {RefWrapper<float>(p.x),
1279                                   RefWrapper<float>(p.y)};
1280     return parseSequence(obj, values, info);
1281 }
1282
1283 template<>
1284 bool pyopencv_to(PyObject* obj, Point2d& p, const ArgInfo& info)
1285 {
1286     RefWrapper<double> values[] = {RefWrapper<double>(p.x),
1287                                    RefWrapper<double>(p.y)};
1288     return parseSequence(obj, values, info);
1289 }
1290
1291 template<>
1292 bool pyopencv_to(PyObject* obj, Point3f& p, const ArgInfo& info)
1293 {
1294     RefWrapper<float> values[] = {RefWrapper<float>(p.x),
1295                                   RefWrapper<float>(p.y),
1296                                   RefWrapper<float>(p.z)};
1297     return parseSequence(obj, values, info);
1298 }
1299
1300 template<>
1301 bool pyopencv_to(PyObject* obj, Point3d& p, const ArgInfo& info)
1302 {
1303     RefWrapper<double> values[] = {RefWrapper<double>(p.x),
1304                                    RefWrapper<double>(p.y),
1305                                    RefWrapper<double>(p.z)};
1306     return parseSequence(obj, values, info);
1307 }
1308
1309 template<>
1310 PyObject* pyopencv_from(const Point& p)
1311 {
1312     return Py_BuildValue("(ii)", p.x, p.y);
1313 }
1314
1315 template<>
1316 PyObject* pyopencv_from(const Point2f& p)
1317 {
1318     return Py_BuildValue("(dd)", p.x, p.y);
1319 }
1320
1321 template<>
1322 PyObject* pyopencv_from(const Point3f& p)
1323 {
1324     return Py_BuildValue("(ddd)", p.x, p.y, p.z);
1325 }
1326
1327 static bool pyopencv_to(PyObject* obj, Vec4d& v, ArgInfo& info)
1328 {
1329     RefWrapper<double> values[] = {RefWrapper<double>(v[0]), RefWrapper<double>(v[1]),
1330                                    RefWrapper<double>(v[2]), RefWrapper<double>(v[3])};
1331     return parseSequence(obj, values, info);
1332 }
1333
1334 static bool pyopencv_to(PyObject* obj, Vec4f& v, ArgInfo& info)
1335 {
1336     RefWrapper<float> values[] = {RefWrapper<float>(v[0]), RefWrapper<float>(v[1]),
1337                                   RefWrapper<float>(v[2]), RefWrapper<float>(v[3])};
1338     return parseSequence(obj, values, info);
1339 }
1340
1341 static bool pyopencv_to(PyObject* obj, Vec4i& v, ArgInfo& info)
1342 {
1343     RefWrapper<int> values[] = {RefWrapper<int>(v[0]), RefWrapper<int>(v[1]),
1344                                 RefWrapper<int>(v[2]), RefWrapper<int>(v[3])};
1345     return parseSequence(obj, values, info);
1346 }
1347
1348 static bool pyopencv_to(PyObject* obj, Vec3d& v, ArgInfo& info)
1349 {
1350     RefWrapper<double> values[] = {RefWrapper<double>(v[0]),
1351                                    RefWrapper<double>(v[1]),
1352                                    RefWrapper<double>(v[2])};
1353     return parseSequence(obj, values, info);
1354 }
1355
1356 static bool pyopencv_to(PyObject* obj, Vec3f& v, ArgInfo& info)
1357 {
1358     RefWrapper<float> values[] = {RefWrapper<float>(v[0]),
1359                                   RefWrapper<float>(v[1]),
1360                                   RefWrapper<float>(v[2])};
1361     return parseSequence(obj, values, info);
1362 }
1363
1364 static bool pyopencv_to(PyObject* obj, Vec3i& v, ArgInfo& info)
1365 {
1366     RefWrapper<int> values[] = {RefWrapper<int>(v[0]), RefWrapper<int>(v[1]),
1367                                 RefWrapper<int>(v[2])};
1368     return parseSequence(obj, values, info);
1369 }
1370
1371 static bool pyopencv_to(PyObject* obj, Vec2d& v, ArgInfo& info)
1372 {
1373     RefWrapper<double> values[] = {RefWrapper<double>(v[0]),
1374                                    RefWrapper<double>(v[1])};
1375     return parseSequence(obj, values, info);
1376 }
1377
1378 static bool pyopencv_to(PyObject* obj, Vec2f& v, ArgInfo& info)
1379 {
1380     RefWrapper<float> values[] = {RefWrapper<float>(v[0]),
1381                                   RefWrapper<float>(v[1])};
1382     return parseSequence(obj, values, info);
1383 }
1384
1385 static bool pyopencv_to(PyObject* obj, Vec2i& v, ArgInfo& info)
1386 {
1387     RefWrapper<int> values[] = {RefWrapper<int>(v[0]), RefWrapper<int>(v[1])};
1388     return parseSequence(obj, values, info);
1389 }
1390
1391 template<>
1392 PyObject* pyopencv_from(const Vec4d& v)
1393 {
1394     return Py_BuildValue("(dddd)", v[0], v[1], v[2], v[3]);
1395 }
1396
1397 template<>
1398 PyObject* pyopencv_from(const Vec4f& v)
1399 {
1400     return Py_BuildValue("(ffff)", v[0], v[1], v[2], v[3]);
1401 }
1402
1403 template<>
1404 PyObject* pyopencv_from(const Vec4i& v)
1405 {
1406     return Py_BuildValue("(iiii)", v[0], v[1], v[2], v[3]);
1407 }
1408
1409 template<>
1410 PyObject* pyopencv_from(const Vec3d& v)
1411 {
1412     return Py_BuildValue("(ddd)", v[0], v[1], v[2]);
1413 }
1414
1415 template<>
1416 PyObject* pyopencv_from(const Vec3f& v)
1417 {
1418     return Py_BuildValue("(fff)", v[0], v[1], v[2]);
1419 }
1420
1421 template<>
1422 PyObject* pyopencv_from(const Vec3i& v)
1423 {
1424     return Py_BuildValue("(iii)", v[0], v[1], v[2]);
1425 }
1426
1427 template<>
1428 PyObject* pyopencv_from(const Vec2d& v)
1429 {
1430     return Py_BuildValue("(dd)", v[0], v[1]);
1431 }
1432
1433 template<>
1434 PyObject* pyopencv_from(const Vec2f& v)
1435 {
1436     return Py_BuildValue("(ff)", v[0], v[1]);
1437 }
1438
1439 template<>
1440 PyObject* pyopencv_from(const Vec2i& v)
1441 {
1442     return Py_BuildValue("(ii)", v[0], v[1]);
1443 }
1444
1445 template<>
1446 PyObject* pyopencv_from(const Point2d& p)
1447 {
1448     return Py_BuildValue("(dd)", p.x, p.y);
1449 }
1450
1451 template<>
1452 PyObject* pyopencv_from(const Point3d& p)
1453 {
1454     return Py_BuildValue("(ddd)", p.x, p.y, p.z);
1455 }
1456
1457 template<typename _Tp> struct pyopencvVecConverter
1458 {
1459     typedef typename DataType<_Tp>::channel_type _Cp;
1460     static inline bool copyOneItem(PyObject *obj, size_t start, int channels, _Cp * data)
1461     {
1462         for(size_t j = 0; (int)j < channels; j++ )
1463         {
1464             SafeSeqItem sub_item_wrap(obj, start + j);
1465             PyObject* item_ij = sub_item_wrap.item;
1466             if( PyInt_Check(item_ij))
1467             {
1468                 int v = (int)PyInt_AsLong(item_ij);
1469                 if( v == -1 && PyErr_Occurred() )
1470                     return false;
1471                 data[j] = saturate_cast<_Cp>(v);
1472             }
1473             else if( PyLong_Check(item_ij))
1474             {
1475                 int v = (int)PyLong_AsLong(item_ij);
1476                 if( v == -1 && PyErr_Occurred() )
1477                     return false;
1478                 data[j] = saturate_cast<_Cp>(v);
1479             }
1480             else if( PyFloat_Check(item_ij))
1481             {
1482                 double v = PyFloat_AsDouble(item_ij);
1483                 if( PyErr_Occurred() )
1484                     return false;
1485                 data[j] = saturate_cast<_Cp>(v);
1486             }
1487             else
1488                 return false;
1489         }
1490         return true;
1491     }
1492     static bool to(PyObject* obj, std::vector<_Tp>& value, const ArgInfo& info)
1493     {
1494         if(!obj || obj == Py_None)
1495             return true;
1496         if (PyArray_Check(obj))
1497         {
1498             Mat m;
1499             pyopencv_to(obj, m, info);
1500             m.copyTo(value);
1501             return true;
1502         }
1503         else if (PySequence_Check(obj))
1504         {
1505             const int type = traits::Type<_Tp>::value;
1506             const int depth = CV_MAT_DEPTH(type), channels = CV_MAT_CN(type);
1507             size_t i, n = PySequence_Size(obj);
1508             value.resize(n);
1509             for (i = 0; i < n; i++ )
1510             {
1511                 SafeSeqItem item_wrap(obj, i);
1512                 PyObject* item = item_wrap.item;
1513                 _Cp* data = (_Cp*)&value[i];
1514
1515                 if( channels == 2 && PyComplex_Check(item) )
1516                 {
1517                     data[0] = saturate_cast<_Cp>(PyComplex_RealAsDouble(item));
1518                     data[1] = saturate_cast<_Cp>(PyComplex_ImagAsDouble(item));
1519                 }
1520                 else if( channels > 1 )
1521                 {
1522                     if( PyArray_Check(item))
1523                     {
1524                         Mat src;
1525                         pyopencv_to(item, src, info);
1526                         if( src.dims != 2 || src.channels() != 1 ||
1527                            ((src.cols != 1 || src.rows != channels) &&
1528                             (src.cols != channels || src.rows != 1)))
1529                             break;
1530                         Mat dst(src.rows, src.cols, depth, data);
1531                         src.convertTo(dst, type);
1532                         if( dst.data != (uchar*)data )
1533                             break;
1534                     }
1535                     else if (PySequence_Check(item))
1536                     {
1537                         if (!copyOneItem(item, 0, channels, data))
1538                             break;
1539                     }
1540                     else
1541                     {
1542                         break;
1543                     }
1544                 }
1545                 else if (channels == 1)
1546                 {
1547                     if (!copyOneItem(obj, i, channels, data))
1548                         break;
1549                 }
1550                 else
1551                 {
1552                     break;
1553                 }
1554             }
1555             if (i != n)
1556             {
1557                 failmsg("Can't convert vector element for '%s', index=%d", info.name, i);
1558             }
1559             return i == n;
1560         }
1561         failmsg("Can't convert object to vector for '%s', unsupported type", info.name);
1562         return false;
1563     }
1564
1565     static PyObject* from(const std::vector<_Tp>& value)
1566     {
1567         if(value.empty())
1568             return PyTuple_New(0);
1569         int type = traits::Type<_Tp>::value;
1570         int depth = CV_MAT_DEPTH(type), channels = CV_MAT_CN(type);
1571         Mat src((int)value.size(), channels, depth, (uchar*)&value[0]);
1572         return pyopencv_from(src);
1573     }
1574 };
1575
1576 template<typename _Tp>
1577 bool pyopencv_to(PyObject* obj, std::vector<_Tp>& value, const ArgInfo& info)
1578 {
1579     return pyopencvVecConverter<_Tp>::to(obj, value, info);
1580 }
1581
1582 template<typename _Tp>
1583 PyObject* pyopencv_from(const std::vector<_Tp>& value)
1584 {
1585     return pyopencvVecConverter<_Tp>::from(value);
1586 }
1587
1588 template<typename _Tp> static inline bool pyopencv_to_generic_vec(PyObject* obj, std::vector<_Tp>& value, const ArgInfo& info)
1589 {
1590     if(!obj || obj == Py_None)
1591        return true;
1592     if (!PySequence_Check(obj))
1593         return false;
1594     size_t n = PySequence_Size(obj);
1595     value.resize(n);
1596     for(size_t i = 0; i < n; i++ )
1597     {
1598         SafeSeqItem item_wrap(obj, i);
1599         if(!pyopencv_to(item_wrap.item, value[i], info))
1600             return false;
1601     }
1602     return true;
1603 }
1604
1605 template<typename _Tp> static inline PyObject* pyopencv_from_generic_vec(const std::vector<_Tp>& value)
1606 {
1607     int i, n = (int)value.size();
1608     PyObject* seq = PyList_New(n);
1609     for( i = 0; i < n; i++ )
1610     {
1611         PyObject* item = pyopencv_from(value[i]);
1612         if(!item)
1613             break;
1614         PyList_SetItem(seq, i, item);
1615     }
1616     if( i < n )
1617     {
1618         Py_DECREF(seq);
1619         return 0;
1620     }
1621     return seq;
1622 }
1623
1624 template<std::size_t I = 0, typename... Tp>
1625 inline typename std::enable_if<I == sizeof...(Tp), void>::type
1626 convert_to_python_tuple(const std::tuple<Tp...>&, PyObject*) {  }
1627
1628 template<std::size_t I = 0, typename... Tp>
1629 inline typename std::enable_if<I < sizeof...(Tp), void>::type
1630 convert_to_python_tuple(const std::tuple<Tp...>& cpp_tuple, PyObject* py_tuple)
1631 {
1632     PyObject* item = pyopencv_from(std::get<I>(cpp_tuple));
1633
1634     if (!item)
1635         return;
1636
1637     PyTuple_SetItem(py_tuple, I, item);
1638     convert_to_python_tuple<I + 1, Tp...>(cpp_tuple, py_tuple);
1639 }
1640
1641
1642 template<typename... Ts>
1643 PyObject* pyopencv_from(const std::tuple<Ts...>& cpp_tuple)
1644 {
1645     size_t size = sizeof...(Ts);
1646     PyObject* py_tuple = PyTuple_New(size);
1647     convert_to_python_tuple(cpp_tuple, py_tuple);
1648     size_t actual_size = PyTuple_Size(py_tuple);
1649
1650     if (actual_size < size)
1651     {
1652         Py_DECREF(py_tuple);
1653         return NULL;
1654     }
1655
1656     return py_tuple;
1657 }
1658
1659 template<>
1660 PyObject* pyopencv_from(const std::pair<int, double>& src)
1661 {
1662     return Py_BuildValue("(id)", src.first, src.second);
1663 }
1664
1665 template<typename _Tp, typename _Tr> struct pyopencvVecConverter<std::pair<_Tp, _Tr> >
1666 {
1667     static bool to(PyObject* obj, std::vector<std::pair<_Tp, _Tr> >& value, const ArgInfo& info)
1668     {
1669         return pyopencv_to_generic_vec(obj, value, info);
1670     }
1671
1672     static PyObject* from(const std::vector<std::pair<_Tp, _Tr> >& value)
1673     {
1674         return pyopencv_from_generic_vec(value);
1675     }
1676 };
1677
1678 template<typename _Tp> struct pyopencvVecConverter<std::vector<_Tp> >
1679 {
1680     static bool to(PyObject* obj, std::vector<std::vector<_Tp> >& value, const ArgInfo& info)
1681     {
1682         return pyopencv_to_generic_vec(obj, value, info);
1683     }
1684
1685     static PyObject* from(const std::vector<std::vector<_Tp> >& value)
1686     {
1687         return pyopencv_from_generic_vec(value);
1688     }
1689 };
1690
1691 template<> struct pyopencvVecConverter<Mat>
1692 {
1693     static bool to(PyObject* obj, std::vector<Mat>& value, const ArgInfo& info)
1694     {
1695         return pyopencv_to_generic_vec(obj, value, info);
1696     }
1697
1698     static PyObject* from(const std::vector<Mat>& value)
1699     {
1700         return pyopencv_from_generic_vec(value);
1701     }
1702 };
1703
1704 template<> struct pyopencvVecConverter<UMat>
1705 {
1706     static bool to(PyObject* obj, std::vector<UMat>& value, const ArgInfo& info)
1707     {
1708         return pyopencv_to_generic_vec(obj, value, info);
1709     }
1710
1711     static PyObject* from(const std::vector<UMat>& value)
1712     {
1713         return pyopencv_from_generic_vec(value);
1714     }
1715 };
1716
1717 template<> struct pyopencvVecConverter<KeyPoint>
1718 {
1719     static bool to(PyObject* obj, std::vector<KeyPoint>& value, const ArgInfo& info)
1720     {
1721         return pyopencv_to_generic_vec(obj, value, info);
1722     }
1723
1724     static PyObject* from(const std::vector<KeyPoint>& value)
1725     {
1726         return pyopencv_from_generic_vec(value);
1727     }
1728 };
1729
1730 template<> struct pyopencvVecConverter<DMatch>
1731 {
1732     static bool to(PyObject* obj, std::vector<DMatch>& value, const ArgInfo& info)
1733     {
1734         return pyopencv_to_generic_vec(obj, value, info);
1735     }
1736
1737     static PyObject* from(const std::vector<DMatch>& value)
1738     {
1739         return pyopencv_from_generic_vec(value);
1740     }
1741 };
1742
1743 template<> struct pyopencvVecConverter<String>
1744 {
1745     static bool to(PyObject* obj, std::vector<String>& value, const ArgInfo& info)
1746     {
1747         return pyopencv_to_generic_vec(obj, value, info);
1748     }
1749
1750     static PyObject* from(const std::vector<String>& value)
1751     {
1752         return pyopencv_from_generic_vec(value);
1753     }
1754 };
1755
1756 template<> struct pyopencvVecConverter<RotatedRect>
1757 {
1758     static bool to(PyObject* obj, std::vector<RotatedRect>& value, const ArgInfo& info)
1759     {
1760         return pyopencv_to_generic_vec(obj, value, info);
1761     }
1762     static PyObject* from(const std::vector<RotatedRect>& value)
1763     {
1764         return pyopencv_from_generic_vec(value);
1765     }
1766 };
1767
1768 template<>
1769 bool pyopencv_to(PyObject* obj, TermCriteria& dst, const ArgInfo& info)
1770 {
1771     if (!obj || obj == Py_None)
1772     {
1773         return true;
1774     }
1775     if (!PySequence_Check(obj))
1776     {
1777         failmsg("Can't parse '%s' as TermCriteria."
1778                 "Input argument doesn't provide sequence protocol",
1779                 info.name);
1780         return false;
1781     }
1782     const std::size_t sequenceSize = PySequence_Size(obj);
1783     if (sequenceSize != 3) {
1784         failmsg("Can't parse '%s' as TermCriteria. Expected sequence length 3, "
1785                 "got %lu",
1786                 info.name, sequenceSize);
1787         return false;
1788     }
1789     {
1790         const String typeItemName = format("'%s' criteria type", info.name);
1791         const ArgInfo typeItemInfo(typeItemName.c_str(), false);
1792         SafeSeqItem typeItem(obj, 0);
1793         if (!pyopencv_to(typeItem.item, dst.type, typeItemInfo))
1794         {
1795             return false;
1796         }
1797     }
1798     {
1799         const String maxCountItemName = format("'%s' max count", info.name);
1800         const ArgInfo maxCountItemInfo(maxCountItemName.c_str(), false);
1801         SafeSeqItem maxCountItem(obj, 1);
1802         if (!pyopencv_to(maxCountItem.item, dst.maxCount, maxCountItemInfo))
1803         {
1804             return false;
1805         }
1806     }
1807     {
1808         const String epsilonItemName = format("'%s' epsilon", info.name);
1809         const ArgInfo epsilonItemInfo(epsilonItemName.c_str(), false);
1810         SafeSeqItem epsilonItem(obj, 2);
1811         if (!pyopencv_to(epsilonItem.item, dst.epsilon, epsilonItemInfo))
1812         {
1813             return false;
1814         }
1815     }
1816     return true;
1817 }
1818
1819 template<>
1820 PyObject* pyopencv_from(const TermCriteria& src)
1821 {
1822     return Py_BuildValue("(iid)", src.type, src.maxCount, src.epsilon);
1823 }
1824
1825 template<>
1826 bool pyopencv_to(PyObject* obj, RotatedRect& dst, const ArgInfo& info)
1827 {
1828     if (!obj || obj == Py_None)
1829     {
1830         return true;
1831     }
1832     if (!PySequence_Check(obj))
1833     {
1834         failmsg("Can't parse '%s' as RotatedRect."
1835                 "Input argument doesn't provide sequence protocol",
1836                 info.name);
1837         return false;
1838     }
1839     const std::size_t sequenceSize = PySequence_Size(obj);
1840     if (sequenceSize != 3)
1841     {
1842         failmsg("Can't parse '%s' as RotatedRect. Expected sequence length 3, got %lu",
1843                 info.name, sequenceSize);
1844         return false;
1845     }
1846     {
1847         const String centerItemName = format("'%s' center point", info.name);
1848         const ArgInfo centerItemInfo(centerItemName.c_str(), false);
1849         SafeSeqItem centerItem(obj, 0);
1850         if (!pyopencv_to(centerItem.item, dst.center, centerItemInfo))
1851         {
1852             return false;
1853         }
1854     }
1855     {
1856         const String sizeItemName = format("'%s' size", info.name);
1857         const ArgInfo sizeItemInfo(sizeItemName.c_str(), false);
1858         SafeSeqItem sizeItem(obj, 1);
1859         if (!pyopencv_to(sizeItem.item, dst.size, sizeItemInfo))
1860         {
1861             return false;
1862         }
1863     }
1864     {
1865         const String angleItemName = format("'%s' angle", info.name);
1866         const ArgInfo angleItemInfo(angleItemName.c_str(), false);
1867         SafeSeqItem angleItem(obj, 2);
1868         if (!pyopencv_to(angleItem.item, dst.angle, angleItemInfo))
1869         {
1870             return false;
1871         }
1872     }
1873     return true;
1874 }
1875
1876 template<>
1877 PyObject* pyopencv_from(const RotatedRect& src)
1878 {
1879     return Py_BuildValue("((ff)(ff)f)", src.center.x, src.center.y, src.size.width, src.size.height, src.angle);
1880 }
1881
1882 template<>
1883 PyObject* pyopencv_from(const Moments& m)
1884 {
1885     return Py_BuildValue("{s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d}",
1886                          "m00", m.m00, "m10", m.m10, "m01", m.m01,
1887                          "m20", m.m20, "m11", m.m11, "m02", m.m02,
1888                          "m30", m.m30, "m21", m.m21, "m12", m.m12, "m03", m.m03,
1889                          "mu20", m.mu20, "mu11", m.mu11, "mu02", m.mu02,
1890                          "mu30", m.mu30, "mu21", m.mu21, "mu12", m.mu12, "mu03", m.mu03,
1891                          "nu20", m.nu20, "nu11", m.nu11, "nu02", m.nu02,
1892                          "nu30", m.nu30, "nu21", m.nu21, "nu12", m.nu12, "nu03", m.nu03);
1893 }
1894
1895 static int OnError(int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)
1896 {
1897     PyGILState_STATE gstate;
1898     gstate = PyGILState_Ensure();
1899
1900     PyObject *on_error = (PyObject*)userdata;
1901     PyObject *args = Py_BuildValue("isssi", status, func_name, err_msg, file_name, line);
1902
1903     PyObject *r = PyObject_Call(on_error, args, NULL);
1904     if (r == NULL) {
1905         PyErr_Print();
1906     } else {
1907         Py_DECREF(r);
1908     }
1909
1910     Py_DECREF(args);
1911     PyGILState_Release(gstate);
1912
1913     return 0; // The return value isn't used
1914 }
1915
1916 static PyObject *pycvRedirectError(PyObject*, PyObject *args, PyObject *kw)
1917 {
1918     const char *keywords[] = { "on_error", NULL };
1919     PyObject *on_error;
1920
1921     if (!PyArg_ParseTupleAndKeywords(args, kw, "O", (char**)keywords, &on_error))
1922         return NULL;
1923
1924     if ((on_error != Py_None) && !PyCallable_Check(on_error))  {
1925         PyErr_SetString(PyExc_TypeError, "on_error must be callable");
1926         return NULL;
1927     }
1928
1929     // Keep track of the previous handler parameter, so we can decref it when no longer used
1930     static PyObject* last_on_error = NULL;
1931     if (last_on_error) {
1932         Py_DECREF(last_on_error);
1933         last_on_error = NULL;
1934     }
1935
1936     if (on_error == Py_None) {
1937         ERRWRAP2(redirectError(NULL));
1938     } else {
1939         last_on_error = on_error;
1940         Py_INCREF(last_on_error);
1941         ERRWRAP2(redirectError(OnError, last_on_error));
1942     }
1943     Py_RETURN_NONE;
1944 }
1945
1946 static void OnMouse(int event, int x, int y, int flags, void* param)
1947 {
1948     PyGILState_STATE gstate;
1949     gstate = PyGILState_Ensure();
1950
1951     PyObject *o = (PyObject*)param;
1952     PyObject *args = Py_BuildValue("iiiiO", event, x, y, flags, PyTuple_GetItem(o, 1));
1953
1954     PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
1955     if (r == NULL)
1956         PyErr_Print();
1957     else
1958         Py_DECREF(r);
1959     Py_DECREF(args);
1960     PyGILState_Release(gstate);
1961 }
1962
1963 #ifdef HAVE_OPENCV_HIGHGUI
1964 static PyObject *pycvSetMouseCallback(PyObject*, PyObject *args, PyObject *kw)
1965 {
1966     const char *keywords[] = { "window_name", "on_mouse", "param", NULL };
1967     char* name;
1968     PyObject *on_mouse;
1969     PyObject *param = NULL;
1970
1971     if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|O", (char**)keywords, &name, &on_mouse, &param))
1972         return NULL;
1973     if (!PyCallable_Check(on_mouse)) {
1974         PyErr_SetString(PyExc_TypeError, "on_mouse must be callable");
1975         return NULL;
1976     }
1977     if (param == NULL) {
1978         param = Py_None;
1979     }
1980     PyObject* py_callback_info = Py_BuildValue("OO", on_mouse, param);
1981     static std::map<std::string, PyObject*> registered_callbacks;
1982     std::map<std::string, PyObject*>::iterator i = registered_callbacks.find(name);
1983     if (i != registered_callbacks.end())
1984     {
1985         Py_DECREF(i->second);
1986         i->second = py_callback_info;
1987     }
1988     else
1989     {
1990         registered_callbacks.insert(std::pair<std::string, PyObject*>(std::string(name), py_callback_info));
1991     }
1992     ERRWRAP2(setMouseCallback(name, OnMouse, py_callback_info));
1993     Py_RETURN_NONE;
1994 }
1995 #endif
1996
1997 static void OnChange(int pos, void *param)
1998 {
1999     PyGILState_STATE gstate;
2000     gstate = PyGILState_Ensure();
2001
2002     PyObject *o = (PyObject*)param;
2003     PyObject *args = Py_BuildValue("(i)", pos);
2004     PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
2005     if (r == NULL)
2006         PyErr_Print();
2007     else
2008         Py_DECREF(r);
2009     Py_DECREF(args);
2010     PyGILState_Release(gstate);
2011 }
2012
2013 #ifdef HAVE_OPENCV_HIGHGUI
2014 static PyObject *pycvCreateTrackbar(PyObject*, PyObject *args)
2015 {
2016     PyObject *on_change;
2017     char* trackbar_name;
2018     char* window_name;
2019     int *value = new int;
2020     int count;
2021
2022     if (!PyArg_ParseTuple(args, "ssiiO", &trackbar_name, &window_name, value, &count, &on_change))
2023         return NULL;
2024     if (!PyCallable_Check(on_change)) {
2025         PyErr_SetString(PyExc_TypeError, "on_change must be callable");
2026         return NULL;
2027     }
2028     PyObject* py_callback_info = Py_BuildValue("OO", on_change, Py_None);
2029     std::string name = std::string(window_name) + ":" + std::string(trackbar_name);
2030     static std::map<std::string, PyObject*> registered_callbacks;
2031     std::map<std::string, PyObject*>::iterator i = registered_callbacks.find(name);
2032     if (i != registered_callbacks.end())
2033     {
2034         Py_DECREF(i->second);
2035         i->second = py_callback_info;
2036     }
2037     else
2038     {
2039         registered_callbacks.insert(std::pair<std::string, PyObject*>(name, py_callback_info));
2040     }
2041     ERRWRAP2(createTrackbar(trackbar_name, window_name, value, count, OnChange, py_callback_info));
2042     Py_RETURN_NONE;
2043 }
2044
2045 static void OnButtonChange(int state, void *param)
2046 {
2047     PyGILState_STATE gstate;
2048     gstate = PyGILState_Ensure();
2049
2050     PyObject *o = (PyObject*)param;
2051     PyObject *args;
2052     if(PyTuple_GetItem(o, 1) != NULL)
2053     {
2054         args = Py_BuildValue("(iO)", state, PyTuple_GetItem(o,1));
2055     }
2056     else
2057     {
2058         args = Py_BuildValue("(i)", state);
2059     }
2060
2061     PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
2062     if (r == NULL)
2063         PyErr_Print();
2064     else
2065         Py_DECREF(r);
2066     Py_DECREF(args);
2067     PyGILState_Release(gstate);
2068 }
2069
2070 static PyObject *pycvCreateButton(PyObject*, PyObject *args, PyObject *kw)
2071 {
2072     const char* keywords[] = {"buttonName", "onChange", "userData", "buttonType", "initialButtonState", NULL};
2073     PyObject *on_change;
2074     PyObject *userdata = NULL;
2075     char* button_name;
2076     int button_type = 0;
2077     int initial_button_state = 0;
2078
2079     if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|Oii", (char**)keywords, &button_name, &on_change, &userdata, &button_type, &initial_button_state))
2080         return NULL;
2081     if (!PyCallable_Check(on_change)) {
2082         PyErr_SetString(PyExc_TypeError, "onChange must be callable");
2083         return NULL;
2084     }
2085     if (userdata == NULL) {
2086         userdata = Py_None;
2087     }
2088
2089     PyObject* py_callback_info = Py_BuildValue("OO", on_change, userdata);
2090     std::string name(button_name);
2091
2092     static std::map<std::string, PyObject*> registered_callbacks;
2093     std::map<std::string, PyObject*>::iterator i = registered_callbacks.find(name);
2094     if (i != registered_callbacks.end())
2095     {
2096         Py_DECREF(i->second);
2097         i->second = py_callback_info;
2098     }
2099     else
2100     {
2101         registered_callbacks.insert(std::pair<std::string, PyObject*>(name, py_callback_info));
2102     }
2103     ERRWRAP2(createButton(button_name, OnButtonChange, py_callback_info, button_type, initial_button_state != 0));
2104     Py_RETURN_NONE;
2105 }
2106 #endif
2107
2108 ///////////////////////////////////////////////////////////////////////////////////////
2109
2110 static int convert_to_char(PyObject *o, char *dst, const ArgInfo& info)
2111 {
2112     std::string str;
2113     if (getUnicodeString(o, str))
2114     {
2115         *dst = str[0];
2116         return 1;
2117     }
2118     (*dst) = 0;
2119     return failmsg("Expected single character string for argument '%s'", info.name);
2120 }
2121
2122 #ifdef __GNUC__
2123 #  pragma GCC diagnostic ignored "-Wunused-parameter"
2124 #  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
2125 #endif
2126
2127
2128 #include "pyopencv_generated_enums.h"
2129
2130 #ifdef CVPY_DYNAMIC_INIT
2131 #define CVPY_TYPE(NAME, STORAGE, SNAME, _1, _2) CVPY_TYPE_DECLARE_DYNAMIC(NAME, STORAGE, SNAME)
2132 #else
2133 #define CVPY_TYPE(NAME, STORAGE, SNAME, _1, _2) CVPY_TYPE_DECLARE(NAME, STORAGE, SNAME)
2134 #endif
2135 #include "pyopencv_generated_types.h"
2136 #undef CVPY_TYPE
2137 #include "pyopencv_custom_headers.h"
2138
2139 #include "pyopencv_generated_types_content.h"
2140 #include "pyopencv_generated_funcs.h"
2141
2142
2143 static PyMethodDef special_methods[] = {
2144   {"redirectError", CV_PY_FN_WITH_KW(pycvRedirectError), "redirectError(onError) -> None"},
2145 #ifdef HAVE_OPENCV_HIGHGUI
2146   {"createTrackbar", (PyCFunction)pycvCreateTrackbar, METH_VARARGS, "createTrackbar(trackbarName, windowName, value, count, onChange) -> None"},
2147   {"createButton", CV_PY_FN_WITH_KW(pycvCreateButton), "createButton(buttonName, onChange [, userData, buttonType, initialButtonState]) -> None"},
2148   {"setMouseCallback", CV_PY_FN_WITH_KW(pycvSetMouseCallback), "setMouseCallback(windowName, onMouse [, param]) -> None"},
2149 #endif
2150 #ifdef HAVE_OPENCV_DNN
2151   {"dnn_registerLayer", CV_PY_FN_WITH_KW(pyopencv_cv_dnn_registerLayer), "registerLayer(type, class) -> None"},
2152   {"dnn_unregisterLayer", CV_PY_FN_WITH_KW(pyopencv_cv_dnn_unregisterLayer), "unregisterLayer(type) -> None"},
2153 #endif
2154 #ifdef HAVE_OPENCV_GAPI
2155   {"GIn", CV_PY_FN_WITH_KW(pyopencv_cv_GIn), "GIn(...) -> GInputProtoArgs"},
2156   {"GOut", CV_PY_FN_WITH_KW(pyopencv_cv_GOut), "GOut(...) -> GOutputProtoArgs"},
2157   {"gin", CV_PY_FN_WITH_KW(pyopencv_cv_gin), "gin(...) -> GRunArgs"},
2158 #endif
2159   {NULL, NULL},
2160 };
2161
2162 /************************************************************************/
2163 /* Module init */
2164
2165 struct ConstDef
2166 {
2167     const char * name;
2168     long long val;
2169 };
2170
2171 static void init_submodule(PyObject * root, const char * name, PyMethodDef * methods, ConstDef * consts)
2172 {
2173   // traverse and create nested submodules
2174   std::string s = name;
2175   size_t i = s.find('.');
2176   while (i < s.length() && i != std::string::npos)
2177   {
2178     size_t j = s.find('.', i);
2179     if (j == std::string::npos)
2180         j = s.length();
2181     std::string short_name = s.substr(i, j-i);
2182     std::string full_name = s.substr(0, j);
2183     i = j+1;
2184
2185     PyObject * d = PyModule_GetDict(root);
2186     PyObject * submod = PyDict_GetItemString(d, short_name.c_str());
2187     if (submod == NULL)
2188     {
2189         submod = PyImport_AddModule(full_name.c_str());
2190         PyDict_SetItemString(d, short_name.c_str(), submod);
2191     }
2192
2193     if (short_name != "")
2194         root = submod;
2195   }
2196
2197   // populate module's dict
2198   PyObject * d = PyModule_GetDict(root);
2199   for (PyMethodDef * m = methods; m->ml_name != NULL; ++m)
2200   {
2201     PyObject * method_obj = PyCFunction_NewEx(m, NULL, NULL);
2202     PyDict_SetItemString(d, m->ml_name, method_obj);
2203     Py_DECREF(method_obj);
2204   }
2205   for (ConstDef * c = consts; c->name != NULL; ++c)
2206   {
2207     PyDict_SetItemString(d, c->name, PyLong_FromLongLong(c->val));
2208   }
2209
2210 }
2211
2212 #include "pyopencv_generated_modules_content.h"
2213
2214 static bool init_body(PyObject * m)
2215 {
2216 #define CVPY_MODULE(NAMESTR, NAME) \
2217     init_submodule(m, MODULESTR NAMESTR, methods_##NAME, consts_##NAME)
2218     #include "pyopencv_generated_modules.h"
2219 #undef CVPY_MODULE
2220
2221 #ifdef CVPY_DYNAMIC_INIT
2222 #define CVPY_TYPE(NAME, _1, _2, BASE, CONSTRUCTOR) CVPY_TYPE_INIT_DYNAMIC(NAME, return false, BASE, CONSTRUCTOR)
2223     PyObject * pyopencv_NoBase_TypePtr = NULL;
2224 #else
2225 #define CVPY_TYPE(NAME, _1, _2, BASE, CONSTRUCTOR) CVPY_TYPE_INIT_STATIC(NAME, return false, BASE, CONSTRUCTOR)
2226     PyTypeObject * pyopencv_NoBase_TypePtr = NULL;
2227 #endif
2228     #include "pyopencv_generated_types.h"
2229 #undef CVPY_TYPE
2230
2231     PyObject* d = PyModule_GetDict(m);
2232
2233
2234     PyDict_SetItemString(d, "__version__", PyString_FromString(CV_VERSION));
2235
2236     PyObject *opencv_error_dict = PyDict_New();
2237     PyDict_SetItemString(opencv_error_dict, "file", Py_None);
2238     PyDict_SetItemString(opencv_error_dict, "func", Py_None);
2239     PyDict_SetItemString(opencv_error_dict, "line", Py_None);
2240     PyDict_SetItemString(opencv_error_dict, "code", Py_None);
2241     PyDict_SetItemString(opencv_error_dict, "msg", Py_None);
2242     PyDict_SetItemString(opencv_error_dict, "err", Py_None);
2243     opencv_error = PyErr_NewException((char*)MODULESTR".error", NULL, opencv_error_dict);
2244     Py_DECREF(opencv_error_dict);
2245     PyDict_SetItemString(d, "error", opencv_error);
2246
2247
2248 #define PUBLISH(I) PyDict_SetItemString(d, #I, PyInt_FromLong(I))
2249     PUBLISH(CV_8U);
2250     PUBLISH(CV_8UC1);
2251     PUBLISH(CV_8UC2);
2252     PUBLISH(CV_8UC3);
2253     PUBLISH(CV_8UC4);
2254     PUBLISH(CV_8S);
2255     PUBLISH(CV_8SC1);
2256     PUBLISH(CV_8SC2);
2257     PUBLISH(CV_8SC3);
2258     PUBLISH(CV_8SC4);
2259     PUBLISH(CV_16U);
2260     PUBLISH(CV_16UC1);
2261     PUBLISH(CV_16UC2);
2262     PUBLISH(CV_16UC3);
2263     PUBLISH(CV_16UC4);
2264     PUBLISH(CV_16S);
2265     PUBLISH(CV_16SC1);
2266     PUBLISH(CV_16SC2);
2267     PUBLISH(CV_16SC3);
2268     PUBLISH(CV_16SC4);
2269     PUBLISH(CV_32S);
2270     PUBLISH(CV_32SC1);
2271     PUBLISH(CV_32SC2);
2272     PUBLISH(CV_32SC3);
2273     PUBLISH(CV_32SC4);
2274     PUBLISH(CV_32F);
2275     PUBLISH(CV_32FC1);
2276     PUBLISH(CV_32FC2);
2277     PUBLISH(CV_32FC3);
2278     PUBLISH(CV_32FC4);
2279     PUBLISH(CV_64F);
2280     PUBLISH(CV_64FC1);
2281     PUBLISH(CV_64FC2);
2282     PUBLISH(CV_64FC3);
2283     PUBLISH(CV_64FC4);
2284 #undef PUBLISH
2285
2286     return true;
2287 }
2288
2289 #if defined(__GNUC__)
2290 #pragma GCC visibility push(default)
2291 #endif
2292
2293 #if defined(CV_PYTHON_3)
2294 // === Python 3
2295
2296 static struct PyModuleDef cv2_moduledef =
2297 {
2298     PyModuleDef_HEAD_INIT,
2299     MODULESTR,
2300     "Python wrapper for OpenCV.",
2301     -1,     /* size of per-interpreter state of the module,
2302                or -1 if the module keeps state in global variables. */
2303     special_methods
2304 };
2305
2306 PyMODINIT_FUNC PyInit_cv2();
2307 PyObject* PyInit_cv2()
2308 {
2309     import_array(); // from numpy
2310     PyObject* m = PyModule_Create(&cv2_moduledef);
2311     if (!init_body(m))
2312         return NULL;
2313     return m;
2314 }
2315
2316 #else
2317 // === Python 2
2318 PyMODINIT_FUNC initcv2();
2319 void initcv2()
2320 {
2321     import_array(); // from numpy
2322     PyObject* m = Py_InitModule(MODULESTR, special_methods);
2323     init_body(m);
2324 }
2325
2326 #endif