cv2.cpp 34.4 KB
Newer Older
wester committed
1 2 3 4 5 6 7
#if defined(_MSC_VER) && (_MSC_VER >= 1800)
// eliminating duplicated round() declaration
#define HAVE_ROUND 1
#endif

#include <Python.h>

wester committed
8 9 10 11
#if !PYTHON_USE_NUMPY
#error "The module can only be built if NumPy is available"
#endif

wester committed
12 13
#define MODULESTR "cv2"

wester committed
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include "numpy/ndarrayobject.h"

#include "opencv2/core/core.hpp"
#include "opencv2/contrib/contrib.hpp"
#include "opencv2/flann/miniflann.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/calib3d/calib3d.hpp"
#include "opencv2/ml/ml.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/video/tracking.hpp"
#include "opencv2/video/background_segm.hpp"
#include "opencv2/photo/photo.hpp"
#include "opencv2/highgui/highgui.hpp"
wester committed
29 30 31

#include "opencv2/opencv_modules.hpp"

wester committed
32 33 34
#ifdef HAVE_OPENCV_NONFREE
#  include "opencv2/nonfree/nonfree.hpp"
#endif
wester committed
35

wester committed
36 37
using cv::flann::IndexParams;
using cv::flann::SearchParams;
wester committed
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105

static PyObject* opencv_error = 0;

static int failmsg(const char *fmt, ...)
{
    char str[1000];

    va_list ap;
    va_start(ap, fmt);
    vsnprintf(str, sizeof(str), fmt, ap);
    va_end(ap);

    PyErr_SetString(PyExc_TypeError, str);
    return 0;
}

struct ArgInfo
{
    const char * name;
    bool outputarg;
    // more fields may be added if necessary

    ArgInfo(const char * name_, bool outputarg_)
        : name(name_)
        , outputarg(outputarg_) {}

    // to match with older pyopencv_to function signature
    operator const char *() const { return name; }
};

class PyAllowThreads
{
public:
    PyAllowThreads() : _state(PyEval_SaveThread()) {}
    ~PyAllowThreads()
    {
        PyEval_RestoreThread(_state);
    }
private:
    PyThreadState* _state;
};

class PyEnsureGIL
{
public:
    PyEnsureGIL() : _state(PyGILState_Ensure()) {}
    ~PyEnsureGIL()
    {
        PyGILState_Release(_state);
    }
private:
    PyGILState_STATE _state;
};

#define ERRWRAP2(expr) \
try \
{ \
    PyAllowThreads allowThreads; \
    expr; \
} \
catch (const cv::Exception &e) \
{ \
    PyErr_SetString(opencv_error, e.what()); \
    return 0; \
}

using namespace cv;

wester committed
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
typedef vector<uchar> vector_uchar;
typedef vector<int> vector_int;
typedef vector<float> vector_float;
typedef vector<double> vector_double;
typedef vector<Point> vector_Point;
typedef vector<Point2f> vector_Point2f;
typedef vector<Vec2f> vector_Vec2f;
typedef vector<Vec3f> vector_Vec3f;
typedef vector<Vec4f> vector_Vec4f;
typedef vector<Vec6f> vector_Vec6f;
typedef vector<Vec4i> vector_Vec4i;
typedef vector<Rect> vector_Rect;
typedef vector<KeyPoint> vector_KeyPoint;
typedef vector<Mat> vector_Mat;
typedef vector<DMatch> vector_DMatch;
typedef vector<string> vector_string;
typedef vector<vector<Point> > vector_vector_Point;
typedef vector<vector<Point2f> > vector_vector_Point2f;
typedef vector<vector<Point3f> > vector_vector_Point3f;
typedef vector<vector<DMatch> > vector_vector_DMatch;

typedef Ptr<Algorithm> Ptr_Algorithm;
typedef Ptr<FeatureDetector> Ptr_FeatureDetector;
typedef Ptr<DescriptorExtractor> Ptr_DescriptorExtractor;
typedef Ptr<Feature2D> Ptr_Feature2D;
typedef Ptr<DescriptorMatcher> Ptr_DescriptorMatcher;
typedef Ptr<CLAHE> Ptr_CLAHE;

a  
Kai Westerkamp committed
134 135 136 137
typedef SimpleBlobDetector::Params SimpleBlobDetector_Params;

typedef cvflann::flann_distance_t cvflann_flann_distance_t;
typedef cvflann::flann_algorithm_t cvflann_flann_algorithm_t;
wester committed
138 139
typedef Ptr<flann::IndexParams> Ptr_flann_IndexParams;
typedef Ptr<flann::SearchParams> Ptr_flann_SearchParams;
a  
Kai Westerkamp committed
140

wester committed
141 142
typedef Ptr<FaceRecognizer> Ptr_FaceRecognizer;
typedef vector<Scalar> vector_Scalar;
wester committed
143 144 145 146 147 148 149 150 151 152 153 154 155 156

static PyObject* failmsgp(const char *fmt, ...)
{
  char str[1000];

  va_list ap;
  va_start(ap, fmt);
  vsnprintf(str, sizeof(str), fmt, ap);
  va_end(ap);

  PyErr_SetString(PyExc_TypeError, str);
  return 0;
}

wester committed
157 158 159 160 161 162 163 164 165 166 167 168 169
static size_t REFCOUNT_OFFSET = (size_t)&(((PyObject*)0)->ob_refcnt) +
    (0x12345678 != *(const size_t*)"\x78\x56\x34\x12\0\0\0\0\0")*sizeof(int);

static inline PyObject* pyObjectFromRefcount(const int* refcount)
{
    return (PyObject*)((size_t)refcount - REFCOUNT_OFFSET);
}

static inline int* refcountFromPyObject(const PyObject* obj)
{
    return (int*)((size_t)obj + REFCOUNT_OFFSET);
}

wester committed
170 171 172
class NumpyAllocator : public MatAllocator
{
public:
wester committed
173
    NumpyAllocator() {}
wester committed
174 175
    ~NumpyAllocator() {}

wester committed
176 177
    void allocate(int dims, const int* sizes, int type, int*& refcount,
                  uchar*& datastart, uchar*& data, size_t* step)
wester committed
178 179 180 181 182 183 184
    {
        PyEnsureGIL gil;

        int depth = CV_MAT_DEPTH(type);
        int cn = CV_MAT_CN(type);
        const int f = (int)(sizeof(size_t)/8);
        int typenum = depth == CV_8U ? NPY_UBYTE : depth == CV_8S ? NPY_BYTE :
wester committed
185 186 187 188 189
                      depth == CV_16U ? NPY_USHORT : depth == CV_16S ? NPY_SHORT :
                      depth == CV_32S ? NPY_INT : depth == CV_32F ? NPY_FLOAT :
                      depth == CV_64F ? NPY_DOUBLE : f*NPY_ULONGLONG + (f^1)*NPY_UINT;
        int i;
        npy_intp _sizes[CV_MAX_DIM+1];
wester committed
190 191 192
        for( i = 0; i < dims; i++ )
            _sizes[i] = sizes[i];
        if( cn > 1 )
wester committed
193 194 195 196 197 198
        {
            /*if( _sizes[dims-1] == 1 )
                _sizes[dims-1] = cn;
            else*/
                _sizes[dims++] = cn;
        }
wester committed
199 200
        PyObject* o = PyArray_SimpleNew(dims, _sizes, typenum);
        if(!o)
wester committed
201 202 203 204 205 206
            CV_Error_(CV_StsError, ("The numpy array of typenum=%d, ndims=%d can not be created", typenum, dims));
        refcount = refcountFromPyObject(o);
        npy_intp* _strides = PyArray_STRIDES((PyArrayObject*) o);
        for( i = 0; i < dims - (cn > 1); i++ )
            step[i] = (size_t)_strides[i];
        datastart = data = (uchar*)PyArray_DATA((PyArrayObject*) o);
wester committed
207 208
    }

wester committed
209
    void deallocate(int* refcount, uchar*, uchar*)
wester committed
210 211
    {
        PyEnsureGIL gil;
wester committed
212 213 214 215 216
        if( !refcount )
            return;
        PyObject* o = pyObjectFromRefcount(refcount);
        Py_INCREF(o);
        Py_DECREF(o);
wester committed
217 218 219 220 221 222 223 224
    }
};

NumpyAllocator g_numpyAllocator;

enum { ARG_NONE = 0, ARG_MAT = 1, ARG_SCALAR = 2 };

// special case, when the convertor needs full ArgInfo structure
wester committed
225
static int pyopencv_to(const PyObject* o, Mat& m, const ArgInfo info, bool allowND=true)
wester committed
226 227 228 229 230 231 232 233 234 235
{
    if(!o || o == Py_None)
    {
        if( !m.data )
            m.allocator = &g_numpyAllocator;
        return true;
    }

    if( PyInt_Check(o) )
    {
wester committed
236 237 238 239 240 241
        double v[] = {
            static_cast<double>(PyInt_AsLong((PyObject*)o)),
            0.,
            0.,
            0.,
        };
wester committed
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
        m = Mat(4, 1, CV_64F, v).clone();
        return true;
    }
    if( PyFloat_Check(o) )
    {
        double v[] = {PyFloat_AsDouble((PyObject*)o), 0., 0., 0.};
        m = Mat(4, 1, CV_64F, v).clone();
        return true;
    }
    if( PyTuple_Check(o) )
    {
        int i, sz = (int)PyTuple_Size((PyObject*)o);
        m = Mat(sz, 1, CV_64F);
        for( i = 0; i < sz; i++ )
        {
            PyObject* oi = PyTuple_GET_ITEM(o, i);
            if( PyInt_Check(oi) )
                m.at<double>(i) = (double)PyInt_AsLong(oi);
            else if( PyFloat_Check(oi) )
                m.at<double>(i) = (double)PyFloat_AsDouble(oi);
            else
            {
                failmsg("%s is not a numerical tuple", info.name);
                m.release();
                return false;
            }
        }
        return true;
    }

    if( !PyArray_Check(o) )
    {
        failmsg("%s is not a numpy array, neither a scalar", info.name);
        return false;
    }

    PyArrayObject* oarr = (PyArrayObject*) o;

    bool needcopy = false, needcast = false;
    int typenum = PyArray_TYPE(oarr), new_typenum = typenum;
    int type = typenum == NPY_UBYTE ? CV_8U :
               typenum == NPY_BYTE ? CV_8S :
               typenum == NPY_USHORT ? CV_16U :
               typenum == NPY_SHORT ? CV_16S :
               typenum == NPY_INT ? CV_32S :
               typenum == NPY_INT32 ? CV_32S :
               typenum == NPY_FLOAT ? CV_32F :
               typenum == NPY_DOUBLE ? CV_64F : -1;

    if( type < 0 )
    {
        if( typenum == NPY_INT64 || typenum == NPY_UINT64 || typenum == NPY_LONG )
        {
            needcopy = needcast = true;
            new_typenum = NPY_INT;
            type = CV_32S;
        }
        else
        {
            failmsg("%s data type = %d is not supported", info.name, typenum);
            return false;
        }
    }

    int ndims = PyArray_NDIM(oarr);
    if(ndims >= CV_MAX_DIM)
    {
        failmsg("%s dimensionality (=%d) is too high", info.name, ndims);
        return false;
    }

    int size[CV_MAX_DIM+1];
wester committed
314
    size_t step[CV_MAX_DIM+1], elemsize = CV_ELEM_SIZE1(type);
wester committed
315 316 317 318 319 320 321 322 323 324
    const npy_intp* _sizes = PyArray_DIMS(oarr);
    const npy_intp* _strides = PyArray_STRIDES(oarr);
    bool ismultichannel = ndims == 3 && _sizes[2] <= CV_CN_MAX;

    for( int i = ndims-1; i >= 0 && !needcopy; i-- )
    {
        // these checks handle cases of
        //  a) multi-dimensional (ndims > 2) arrays, as well as simpler 1- and 2-dimensional cases
        //  b) transposed arrays, where _strides[] elements go in non-descending order
        //  c) flipped arrays, where some of _strides[] elements are negative
wester committed
325 326
        if( (i == ndims-1 && (size_t)_strides[i] != elemsize) ||
            (i < ndims-1 && _strides[i] < _strides[i+1]) )
wester committed
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
            needcopy = true;
    }

    if( ismultichannel && _strides[1] != (npy_intp)elemsize*_sizes[2] )
        needcopy = true;

    if (needcopy)
    {
        if (info.outputarg)
        {
            failmsg("Layout of the output array %s is incompatible with cv::Mat (step[ndims-1] != elemsize or step[1] != elemsize*nchannels)", info.name);
            return false;
        }

        if( needcast ) {
            o = PyArray_Cast(oarr, new_typenum);
            oarr = (PyArrayObject*) o;
        }
        else {
            oarr = PyArray_GETCONTIGUOUS(oarr);
            o = (PyObject*) oarr;
        }

        _strides = PyArray_STRIDES(oarr);
    }

wester committed
353
    for(int i = 0; i < ndims; i++)
wester committed
354 355
    {
        size[i] = (int)_sizes[i];
wester committed
356
        step[i] = (size_t)_strides[i];
wester committed
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
    }

    // handle degenerate case
    if( ndims == 0) {
        size[ndims] = 1;
        step[ndims] = elemsize;
        ndims++;
    }

    if( ismultichannel )
    {
        ndims--;
        type |= CV_MAKETYPE(0, size[2]);
    }

    if( ndims > 2 && !allowND )
    {
        failmsg("%s has more than 2 dimensions", info.name);
        return false;
    }

    m = Mat(ndims, size, type, PyArray_DATA(oarr), step);

wester committed
380
    if( m.data )
wester committed
381
    {
wester committed
382 383 384 385 386 387 388
        m.refcount = refcountFromPyObject(o);
        if (!needcopy)
        {
            m.addref(); // protect the original numpy array from deallocation
                        // (since Mat destructor will decrement the reference counter)
        }
    };
wester committed
389 390 391 392 393
    m.allocator = &g_numpyAllocator;

    return true;
}

wester committed
394
static PyObject* pyopencv_from(const Mat& m)
wester committed
395 396 397 398
{
    if( !m.data )
        Py_RETURN_NONE;
    Mat temp, *p = (Mat*)&m;
wester committed
399
    if(!p->refcount || p->allocator != &g_numpyAllocator)
wester committed
400 401 402 403 404
    {
        temp.allocator = &g_numpyAllocator;
        ERRWRAP2(m.copyTo(temp));
        p = &temp;
    }
wester committed
405 406
    p->addref();
    return pyObjectFromRefcount(p->refcount);
wester committed
407 408
}

wester committed
409
static bool pyopencv_to(PyObject *o, Scalar& s, const char *name = "<unknown>")
wester committed
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
{
    if(!o || o == Py_None)
        return true;
    if (PySequence_Check(o)) {
        PyObject *fi = PySequence_Fast(o, name);
        if (fi == NULL)
            return false;
        if (4 < PySequence_Fast_GET_SIZE(fi))
        {
            failmsg("Scalar value for argument '%s' is longer than 4", name);
            return false;
        }
        for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
            PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
            if (PyFloat_Check(item) || PyInt_Check(item)) {
                s[(int)i] = PyFloat_AsDouble(item);
            } else {
                failmsg("Scalar value for argument '%s' is not numeric", name);
                return false;
            }
        }
        Py_DECREF(fi);
    } else {
        if (PyFloat_Check(o) || PyInt_Check(o)) {
            s[0] = PyFloat_AsDouble(o);
        } else {
            failmsg("Scalar value for argument '%s' is not numeric", name);
            return false;
        }
    }
    return true;
}

wester committed
443
static inline PyObject* pyopencv_from(const Scalar& src)
wester committed
444 445 446 447
{
    return Py_BuildValue("(dddd)", src[0], src[1], src[2], src[3]);
}

wester committed
448
static PyObject* pyopencv_from(bool value)
wester committed
449 450 451 452
{
    return PyBool_FromLong(value);
}

wester committed
453
static bool pyopencv_to(PyObject* obj, bool& value, const char* name = "<unknown>")
wester committed
454 455 456 457 458 459 460 461 462 463 464
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    int _val = PyObject_IsTrue(obj);
    if(_val < 0)
        return false;
    value = _val > 0;
    return true;
}

wester committed
465
static PyObject* pyopencv_from(size_t value)
wester committed
466
{
wester committed
467
    return PyLong_FromUnsignedLong((unsigned long)value);
wester committed
468 469
}

wester committed
470
static bool pyopencv_to(PyObject* obj, size_t& value, const char* name = "<unknown>")
wester committed
471 472 473 474 475 476 477 478
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    value = (int)PyLong_AsUnsignedLong(obj);
    return value != (size_t)-1 || !PyErr_Occurred();
}

wester committed
479
static PyObject* pyopencv_from(int value)
wester committed
480 481 482 483
{
    return PyInt_FromLong(value);
}

wester committed
484
static PyObject* pyopencv_from(cvflann_flann_algorithm_t value)
a  
Kai Westerkamp committed
485 486 487 488
{
    return PyInt_FromLong(int(value));
}

wester committed
489
static PyObject* pyopencv_from(cvflann_flann_distance_t value)
a  
Kai Westerkamp committed
490 491 492 493
{
    return PyInt_FromLong(int(value));
}

wester committed
494
static bool pyopencv_to(PyObject* obj, int& value, const char* name = "<unknown>")
wester committed
495 496 497 498 499 500 501 502 503 504 505 506 507
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    if(PyInt_Check(obj))
        value = (int)PyInt_AsLong(obj);
    else if(PyLong_Check(obj))
        value = (int)PyLong_AsLong(obj);
    else
        return false;
    return value != -1 || !PyErr_Occurred();
}

wester committed
508
static PyObject* pyopencv_from(uchar value)
wester committed
509 510 511 512
{
    return PyInt_FromLong(value);
}

wester committed
513
static bool pyopencv_to(PyObject* obj, uchar& value, const char* name = "<unknown>")
wester committed
514 515 516 517 518 519 520 521 522
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    int ivalue = (int)PyInt_AsLong(obj);
    value = cv::saturate_cast<uchar>(ivalue);
    return ivalue != -1 || !PyErr_Occurred();
}

wester committed
523
static PyObject* pyopencv_from(double value)
wester committed
524 525 526 527
{
    return PyFloat_FromDouble(value);
}

wester committed
528
static bool pyopencv_to(PyObject* obj, double& value, const char* name = "<unknown>")
wester committed
529 530 531 532 533 534 535 536 537 538 539
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    if(!!PyInt_CheckExact(obj))
        value = (double)PyInt_AS_LONG(obj);
    else
        value = PyFloat_AsDouble(obj);
    return !PyErr_Occurred();
}

wester committed
540
static PyObject* pyopencv_from(float value)
wester committed
541 542 543 544
{
    return PyFloat_FromDouble(value);
}

wester committed
545
static bool pyopencv_to(PyObject* obj, float& value, const char* name = "<unknown>")
wester committed
546 547 548 549 550 551 552 553 554 555 556
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    if(!!PyInt_CheckExact(obj))
        value = (float)PyInt_AS_LONG(obj);
    else
        value = (float)PyFloat_AsDouble(obj);
    return !PyErr_Occurred();
}

wester committed
557
static PyObject* pyopencv_from(int64 value)
wester committed
558
{
wester committed
559
    return PyFloat_FromDouble((double)value);
wester committed
560 561
}

wester committed
562
static PyObject* pyopencv_from(const string& value)
wester committed
563 564 565 566
{
    return PyString_FromString(value.empty() ? "" : value.c_str());
}

wester committed
567
static bool pyopencv_to(PyObject* obj, string& value, const char* name = "<unknown>")
wester committed
568 569 570 571 572 573 574
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    char* str = PyString_AsString(obj);
    if(!str)
        return false;
wester committed
575
    value = string(str);
wester committed
576 577 578
    return true;
}

wester committed
579
static inline bool pyopencv_to(PyObject* obj, Size& sz, const char* name = "<unknown>")
wester committed
580 581 582 583 584 585 586
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    return PyArg_ParseTuple(obj, "ii", &sz.width, &sz.height) > 0;
}

wester committed
587
static inline PyObject* pyopencv_from(const Size& sz)
wester committed
588 589 590 591
{
    return Py_BuildValue("(ii)", sz.width, sz.height);
}

wester committed
592
static inline bool pyopencv_to(PyObject* obj, Rect& r, const char* name = "<unknown>")
wester committed
593 594 595 596 597 598 599
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    return PyArg_ParseTuple(obj, "iiii", &r.x, &r.y, &r.width, &r.height) > 0;
}

wester committed
600
static inline PyObject* pyopencv_from(const Rect& r)
wester committed
601 602 603 604
{
    return Py_BuildValue("(iiii)", r.x, r.y, r.width, r.height);
}

wester committed
605
static inline bool pyopencv_to(PyObject* obj, Range& r, const char* name = "<unknown>")
wester committed
606 607 608 609
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
wester committed
610 611 612 613 614 615
    if(PyObject_Size(obj) == 0)
    {
        r = Range::all();
        return true;
    }
    return PyArg_ParseTuple(obj, "ii", &r.start, &r.end) > 0;
wester committed
616 617
}

wester committed
618
static inline PyObject* pyopencv_from(const Range& r)
wester committed
619
{
wester committed
620
    return Py_BuildValue("(ii)", r.start, r.end);
wester committed
621 622
}

wester committed
623
static inline bool pyopencv_to(PyObject* obj, CvSlice& r, const char* name = "<unknown>")
wester committed
624 625 626 627 628 629
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    if(PyObject_Size(obj) == 0)
    {
wester committed
630
        r = CV_WHOLE_SEQ;
wester committed
631 632
        return true;
    }
wester committed
633
    return PyArg_ParseTuple(obj, "ii", &r.start_index, &r.end_index) > 0;
wester committed
634 635
}

wester committed
636
static inline PyObject* pyopencv_from(const CvSlice& r)
wester committed
637
{
wester committed
638
    return Py_BuildValue("(ii)", r.start_index, r.end_index);
wester committed
639 640
}

wester committed
641
static inline bool pyopencv_to(PyObject* obj, Point& p, const char* name = "<unknown>")
wester committed
642 643 644 645 646 647 648 649 650 651 652 653 654 655
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    if(!!PyComplex_CheckExact(obj))
    {
        Py_complex c = PyComplex_AsCComplex(obj);
        p.x = saturate_cast<int>(c.real);
        p.y = saturate_cast<int>(c.imag);
        return true;
    }
    return PyArg_ParseTuple(obj, "ii", &p.x, &p.y) > 0;
}

wester committed
656
static inline bool pyopencv_to(PyObject* obj, Point2f& p, const char* name = "<unknown>")
wester committed
657 658 659 660 661 662 663 664 665 666 667 668 669 670
{
    (void)name;
    if(!obj || obj == Py_None)
        return true;
    if(!!PyComplex_CheckExact(obj))
    {
        Py_complex c = PyComplex_AsCComplex(obj);
        p.x = saturate_cast<float>(c.real);
        p.y = saturate_cast<float>(c.imag);
        return true;
    }
    return PyArg_ParseTuple(obj, "ff", &p.x, &p.y) > 0;
}

wester committed
671
static inline PyObject* pyopencv_from(const Point& p)
wester committed
672 673 674 675
{
    return Py_BuildValue("(ii)", p.x, p.y);
}

wester committed
676
static inline PyObject* pyopencv_from(const Point2f& p)
wester committed
677 678 679 680
{
    return Py_BuildValue("(dd)", p.x, p.y);
}

wester committed
681
static inline bool pyopencv_to(PyObject* obj, Vec3d& v, const char* name = "<unknown>")
wester committed
682 683 684 685 686 687 688
{
    (void)name;
    if(!obj)
        return true;
    return PyArg_ParseTuple(obj, "ddd", &v[0], &v[1], &v[2]) > 0;
}

wester committed
689
static inline PyObject* pyopencv_from(const Vec3d& v)
wester committed
690 691 692 693
{
    return Py_BuildValue("(ddd)", v[0], v[1], v[2]);
}

wester committed
694
static inline PyObject* pyopencv_from(const Point2d& p)
wester committed
695 696 697 698 699 700
{
    return Py_BuildValue("(dd)", p.x, p.y);
}

template<typename _Tp> struct pyopencvVecConverter
{
wester committed
701
    static bool to(PyObject* obj, vector<_Tp>& value, const ArgInfo info)
wester committed
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
    {
        typedef typename DataType<_Tp>::channel_type _Cp;
        if(!obj || obj == Py_None)
            return true;
        if (PyArray_Check(obj))
        {
            Mat m;
            pyopencv_to(obj, m, info);
            m.copyTo(value);
        }
        if (!PySequence_Check(obj))
            return false;
        PyObject *seq = PySequence_Fast(obj, info.name);
        if (seq == NULL)
            return false;
        int i, j, n = (int)PySequence_Fast_GET_SIZE(seq);
        value.resize(n);

        int type = DataType<_Tp>::type;
        int depth = CV_MAT_DEPTH(type), channels = CV_MAT_CN(type);
        PyObject** items = PySequence_Fast_ITEMS(seq);

        for( i = 0; i < n; i++ )
        {
            PyObject* item = items[i];
            PyObject* seq_i = 0;
            PyObject** items_i = &item;
            _Cp* data = (_Cp*)&value[i];

            if( channels == 2 && PyComplex_CheckExact(item) )
            {
                Py_complex c = PyComplex_AsCComplex(obj);
                data[0] = saturate_cast<_Cp>(c.real);
                data[1] = saturate_cast<_Cp>(c.imag);
                continue;
            }
            if( channels > 1 )
            {
                if( PyArray_Check(item))
                {
                    Mat src;
                    pyopencv_to(item, src, info);
                    if( src.dims != 2 || src.channels() != 1 ||
                       ((src.cols != 1 || src.rows != channels) &&
                        (src.cols != channels || src.rows != 1)))
                        break;
                    Mat dst(src.rows, src.cols, depth, data);
                    src.convertTo(dst, type);
                    if( dst.data != (uchar*)data )
                        break;
                    continue;
                }

                seq_i = PySequence_Fast(item, info.name);
                if( !seq_i || (int)PySequence_Fast_GET_SIZE(seq_i) != channels )
                {
                    Py_XDECREF(seq_i);
                    break;
                }
                items_i = PySequence_Fast_ITEMS(seq_i);
            }

            for( j = 0; j < channels; j++ )
            {
                PyObject* item_ij = items_i[j];
                if( PyInt_Check(item_ij))
                {
                    int v = (int)PyInt_AsLong(item_ij);
                    if( v == -1 && PyErr_Occurred() )
                        break;
                    data[j] = saturate_cast<_Cp>(v);
                }
                else if( PyLong_Check(item_ij))
                {
                    int v = (int)PyLong_AsLong(item_ij);
                    if( v == -1 && PyErr_Occurred() )
                        break;
                    data[j] = saturate_cast<_Cp>(v);
                }
                else if( PyFloat_Check(item_ij))
                {
                    double v = PyFloat_AsDouble(item_ij);
                    if( PyErr_Occurred() )
                        break;
                    data[j] = saturate_cast<_Cp>(v);
                }
                else
                    break;
            }
            Py_XDECREF(seq_i);
            if( j < channels )
                break;
        }
        Py_DECREF(seq);
        return i == n;
    }

wester committed
799
    static PyObject* from(const vector<_Tp>& value)
wester committed
800 801 802 803 804 805 806 807
    {
        if(value.empty())
            return PyTuple_New(0);
        Mat src((int)value.size(), DataType<_Tp>::channels, DataType<_Tp>::depth, (uchar*)&value[0]);
        return pyopencv_from(src);
    }
};

wester committed
808 809

template<typename _Tp> static inline bool pyopencv_to(PyObject* obj, vector<_Tp>& value, const ArgInfo info)
wester committed
810 811 812 813
{
    return pyopencvVecConverter<_Tp>::to(obj, value, info);
}

wester committed
814
template<typename _Tp> static inline PyObject* pyopencv_from(const vector<_Tp>& value)
wester committed
815 816 817 818
{
    return pyopencvVecConverter<_Tp>::from(value);
}

wester committed
819 820 821 822
static PyObject* pyopencv_from(const KeyPoint&);
static PyObject* pyopencv_from(const DMatch&);

template<typename _Tp> static inline bool pyopencv_to_generic_vec(PyObject* obj, vector<_Tp>& value, const ArgInfo info)
wester committed
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
{
    if(!obj || obj == Py_None)
       return true;
    if (!PySequence_Check(obj))
        return false;
    PyObject *seq = PySequence_Fast(obj, info.name);
    if (seq == NULL)
        return false;
    int i, n = (int)PySequence_Fast_GET_SIZE(seq);
    value.resize(n);

    PyObject** items = PySequence_Fast_ITEMS(seq);

    for( i = 0; i < n; i++ )
    {
        PyObject* item = items[i];
        if(!pyopencv_to(item, value[i], info))
            break;
    }
    Py_DECREF(seq);
    return i == n;
}

wester committed
846
template<typename _Tp> static inline PyObject* pyopencv_from_generic_vec(const vector<_Tp>& value)
wester committed
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
{
    int i, n = (int)value.size();
    PyObject* seq = PyList_New(n);
    for( i = 0; i < n; i++ )
    {
        PyObject* item = pyopencv_from(value[i]);
        if(!item)
            break;
        PyList_SET_ITEM(seq, i, item);
    }
    if( i < n )
    {
        Py_DECREF(seq);
        return 0;
    }
    return seq;
}


wester committed
866
template<typename _Tp> struct pyopencvVecConverter<vector<_Tp> >
wester committed
867
{
wester committed
868
    static bool to(PyObject* obj, vector<vector<_Tp> >& value, const char* name="<unknown>")
wester committed
869
    {
wester committed
870
        return pyopencv_to_generic_vec(obj, value, name);
wester committed
871 872
    }

wester committed
873
    static PyObject* from(const vector<vector<_Tp> >& value)
wester committed
874 875 876 877 878 879 880
    {
        return pyopencv_from_generic_vec(value);
    }
};

template<> struct pyopencvVecConverter<Mat>
{
wester committed
881
    static bool to(PyObject* obj, vector<Mat>& value, const ArgInfo info)
wester committed
882 883 884 885
    {
        return pyopencv_to_generic_vec(obj, value, info);
    }

wester committed
886
    static PyObject* from(const vector<Mat>& value)
wester committed
887 888 889 890 891 892 893
    {
        return pyopencv_from_generic_vec(value);
    }
};

template<> struct pyopencvVecConverter<KeyPoint>
{
wester committed
894
    static bool to(PyObject* obj, vector<KeyPoint>& value, const ArgInfo info)
wester committed
895 896 897 898
    {
        return pyopencv_to_generic_vec(obj, value, info);
    }

wester committed
899
    static PyObject* from(const vector<KeyPoint>& value)
wester committed
900 901 902 903 904 905 906
    {
        return pyopencv_from_generic_vec(value);
    }
};

template<> struct pyopencvVecConverter<DMatch>
{
wester committed
907
    static bool to(PyObject* obj, vector<DMatch>& value, const ArgInfo info)
wester committed
908 909 910 911
    {
        return pyopencv_to_generic_vec(obj, value, info);
    }

wester committed
912
    static PyObject* from(const vector<DMatch>& value)
wester committed
913 914 915 916 917
    {
        return pyopencv_from_generic_vec(value);
    }
};

wester committed
918
template<> struct pyopencvVecConverter<string>
wester committed
919
{
wester committed
920
    static bool to(PyObject* obj, vector<string>& value, const ArgInfo info)
wester committed
921 922 923 924
    {
        return pyopencv_to_generic_vec(obj, value, info);
    }

wester committed
925
    static PyObject* from(const vector<string>& value)
wester committed
926 927 928 929 930
    {
        return pyopencv_from_generic_vec(value);
    }
};

wester committed
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945

static inline bool pyopencv_to(PyObject *obj, CvTermCriteria& dst, const char *name="<unknown>")
{
    (void)name;
    if(!obj)
        return true;
    return PyArg_ParseTuple(obj, "iid", &dst.type, &dst.max_iter, &dst.epsilon) > 0;
}

static inline PyObject* pyopencv_from(const CvTermCriteria& src)
{
    return Py_BuildValue("(iid)", src.type, src.max_iter, src.epsilon);
}

static inline bool pyopencv_to(PyObject *obj, TermCriteria& dst, const char *name="<unknown>")
wester committed
946 947 948 949 950 951 952
{
    (void)name;
    if(!obj)
        return true;
    return PyArg_ParseTuple(obj, "iid", &dst.type, &dst.maxCount, &dst.epsilon) > 0;
}

wester committed
953
static inline PyObject* pyopencv_from(const TermCriteria& src)
wester committed
954 955 956 957
{
    return Py_BuildValue("(iid)", src.type, src.maxCount, src.epsilon);
}

wester committed
958
static inline bool pyopencv_to(PyObject *obj, RotatedRect& dst, const char *name="<unknown>")
wester committed
959 960 961 962 963 964 965
{
    (void)name;
    if(!obj)
        return true;
    return PyArg_ParseTuple(obj, "(ff)(ff)f", &dst.center.x, &dst.center.y, &dst.size.width, &dst.size.height, &dst.angle) > 0;
}

wester committed
966
static inline PyObject* pyopencv_from(const RotatedRect& src)
wester committed
967 968 969 970
{
    return Py_BuildValue("((ff)(ff)f)", src.center.x, src.center.y, src.size.width, src.size.height, src.angle);
}

wester committed
971
static inline PyObject* pyopencv_from(const Moments& m)
wester committed
972 973 974 975 976 977 978 979 980 981 982
{
    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}",
                         "m00", m.m00, "m10", m.m10, "m01", m.m01,
                         "m20", m.m20, "m11", m.m11, "m02", m.m02,
                         "m30", m.m30, "m21", m.m21, "m12", m.m12, "m03", m.m03,
                         "mu20", m.mu20, "mu11", m.mu11, "mu02", m.mu02,
                         "mu30", m.mu30, "mu21", m.mu21, "mu12", m.mu12, "mu03", m.mu03,
                         "nu20", m.nu20, "nu11", m.nu11, "nu02", m.nu02,
                         "nu30", m.nu30, "nu21", m.nu21, "nu12", m.nu12, "nu03", m.nu03);
}

wester committed
983 984 985 986 987 988 989 990
static inline PyObject* pyopencv_from(const CvDTreeNode* node)
{
    double value = node->value;
    int ivalue = cvRound(value);
    return value == ivalue ? PyInt_FromLong(ivalue) : PyFloat_FromDouble(value);
}

static bool pyopencv_to(PyObject *o, cv::flann::IndexParams& p, const char *name="<unknown>")
a  
Kai Westerkamp committed
991 992
{
    (void)name;
wester committed
993 994 995
    bool ok = false;
    PyObject* keys = PyObject_CallMethod(o,(char*)"keys",0);
    PyObject* values = PyObject_CallMethod(o,(char*)"values",0);
a  
Kai Westerkamp committed
996

wester committed
997 998 999 1000 1001 1002 1003 1004 1005 1006
    if( keys && values )
    {
        int i, n = (int)PyList_GET_SIZE(keys);
        for( i = 0; i < n; i++ )
        {
            PyObject* key = PyList_GET_ITEM(keys, i);
            PyObject* item = PyList_GET_ITEM(values, i);
            if( !PyString_Check(key) )
                break;
            std::string k = PyString_AsString(key);
a  
Kai Westerkamp committed
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
            if( PyString_Check(item) )
            {
                const char* value = PyString_AsString(item);
                p.setString(k, value);
            }
            else if( !!PyBool_Check(item) )
                p.setBool(k, item == Py_True);
            else if( PyInt_Check(item) )
            {
                int value = (int)PyInt_AsLong(item);
                if( strcmp(k.c_str(), "algorithm") == 0 )
                    p.setAlgorithm(value);
                else
                    p.setInt(k, value);
            }
            else if( PyFloat_Check(item) )
            {
                double value = PyFloat_AsDouble(item);
                p.setDouble(k, value);
            }
            else
                break;
        }
wester committed
1030
        ok = i == n && !PyErr_Occurred();
a  
Kai Westerkamp committed
1031 1032
    }

wester committed
1033 1034 1035
    Py_XDECREF(keys);
    Py_XDECREF(values);
    return ok;
a  
Kai Westerkamp committed
1036 1037
}

wester committed
1038 1039
template <class T>
static bool pyopencv_to(PyObject *o, Ptr<T>& p, const char *name="<unknown>")
a  
Kai Westerkamp committed
1040
{
wester committed
1041
    p = new T();
a  
Kai Westerkamp committed
1042 1043 1044
    return pyopencv_to(o, *p, name);
}

wester committed
1045 1046

static bool pyopencv_to(PyObject *o, cvflann::flann_distance_t& dist, const char *name="<unknown>")
a  
Kai Westerkamp committed
1047 1048 1049 1050 1051 1052 1053 1054
{
    int d = (int)dist;
    bool ok = pyopencv_to(o, d, name);
    dist = (cvflann::flann_distance_t)d;
    return ok;
}

////////////////////////////////////////////////////////////////////////////////////////////////////
wester committed
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088

static void OnMouse(int event, int x, int y, int flags, void* param)
{
    PyGILState_STATE gstate;
    gstate = PyGILState_Ensure();

    PyObject *o = (PyObject*)param;
    PyObject *args = Py_BuildValue("iiiiO", event, x, y, flags, PyTuple_GetItem(o, 1));

    PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
    if (r == NULL)
        PyErr_Print();
    else
        Py_DECREF(r);
    Py_DECREF(args);
    PyGILState_Release(gstate);
}

static PyObject *pycvSetMouseCallback(PyObject*, PyObject *args, PyObject *kw)
{
    const char *keywords[] = { "window_name", "on_mouse", "param", NULL };
    char* name;
    PyObject *on_mouse;
    PyObject *param = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|O", (char**)keywords, &name, &on_mouse, &param))
        return NULL;
    if (!PyCallable_Check(on_mouse)) {
        PyErr_SetString(PyExc_TypeError, "on_mouse must be callable");
        return NULL;
    }
    if (param == NULL) {
        param = Py_None;
    }
wester committed
1089
    ERRWRAP2(cvSetMouseCallback(name, OnMouse, Py_BuildValue("OO", on_mouse, param)));
wester committed
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
    Py_RETURN_NONE;
}

static void OnChange(int pos, void *param)
{
    PyGILState_STATE gstate;
    gstate = PyGILState_Ensure();

    PyObject *o = (PyObject*)param;
    PyObject *args = Py_BuildValue("(i)", pos);
    PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
    if (r == NULL)
        PyErr_Print();
    Py_DECREF(args);
    PyGILState_Release(gstate);
}

static PyObject *pycvCreateTrackbar(PyObject*, PyObject *args)
{
    PyObject *on_change;
    char* trackbar_name;
    char* window_name;
    int *value = new int;
    int count;

    if (!PyArg_ParseTuple(args, "ssiiO", &trackbar_name, &window_name, value, &count, &on_change))
        return NULL;
    if (!PyCallable_Check(on_change)) {
        PyErr_SetString(PyExc_TypeError, "on_change must be callable");
        return NULL;
    }
wester committed
1121
    ERRWRAP2(cvCreateTrackbar2(trackbar_name, window_name, value, count, OnChange, Py_BuildValue("OO", on_change, Py_None)));
wester committed
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
    Py_RETURN_NONE;
}

///////////////////////////////////////////////////////////////////////////////////////

#define MKTYPE2(NAME) pyopencv_##NAME##_specials(); if (!to_ok(&pyopencv_##NAME##_Type)) return

#ifdef __GNUC__
#  pragma GCC diagnostic ignored "-Wunused-parameter"
#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#endif

#include "pyopencv_generated_types.h"
#include "pyopencv_generated_funcs.h"

wester committed
1137 1138 1139
static PyMethodDef methods[] = {

#include "pyopencv_generated_func_tab.h"
wester committed
1140
  {"createTrackbar", pycvCreateTrackbar, METH_VARARGS, "createTrackbar(trackbarName, windowName, value, count, onChange) -> None"},
wester committed
1141
  {"setMouseCallback", (PyCFunction)pycvSetMouseCallback, METH_KEYWORDS, "setMouseCallback(windowName, onMouse [, param]) -> None"},
wester committed
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
  {NULL, NULL},
};

/************************************************************************/
/* Module init */

static int to_ok(PyTypeObject *to)
{
  to->tp_alloc = PyType_GenericAlloc;
  to->tp_new = PyType_GenericNew;
  to->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
  return (PyType_Ready(to) == 0);
}

wester committed
1156
#include "cv2.cv.hpp"
wester committed
1157

wester committed
1158 1159 1160 1161 1162
extern "C"
#if defined WIN32 || defined _WIN32
__declspec(dllexport)
#endif
void initcv2();
wester committed
1163 1164 1165

void initcv2()
{
wester committed
1166 1167 1168
#if PYTHON_USE_NUMPY
    import_array();
#endif
wester committed
1169

wester committed
1170
#if PYTHON_USE_NUMPY
wester committed
1171 1172 1173
#include "pyopencv_generated_type_reg.h"
#endif

wester committed
1174
  PyObject* m = Py_InitModule(MODULESTR, methods);
wester committed
1175 1176 1177 1178 1179 1180 1181
  PyObject* d = PyModule_GetDict(m);

  PyDict_SetItemString(d, "__version__", PyString_FromString(CV_VERSION));

  opencv_error = PyErr_NewException((char*)MODULESTR".error", NULL, NULL);
  PyDict_SetItemString(d, "error", opencv_error);

wester committed
1182 1183 1184 1185
  PyObject* cv_m = init_cv();

  PyDict_SetItemString(d, "cv", cv_m);

wester committed
1186
#define PUBLISH(I) PyDict_SetItemString(d, #I, PyInt_FromLong(I))
wester committed
1187
#define PUBLISHU(I) PyDict_SetItemString(d, #I, PyLong_FromUnsignedLong(I))
wester committed
1188 1189
#define PUBLISH2(I, value) PyDict_SetItemString(d, #I, PyLong_FromLong(value))

wester committed
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
  PUBLISHU(IPL_DEPTH_8U);
  PUBLISHU(IPL_DEPTH_8S);
  PUBLISHU(IPL_DEPTH_16U);
  PUBLISHU(IPL_DEPTH_16S);
  PUBLISHU(IPL_DEPTH_32S);
  PUBLISHU(IPL_DEPTH_32F);
  PUBLISHU(IPL_DEPTH_64F);

  PUBLISH(CV_LOAD_IMAGE_COLOR);
  PUBLISH(CV_LOAD_IMAGE_GRAYSCALE);
  PUBLISH(CV_LOAD_IMAGE_UNCHANGED);
  PUBLISH(CV_HIST_ARRAY);
  PUBLISH(CV_HIST_SPARSE);
wester committed
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
  PUBLISH(CV_8U);
  PUBLISH(CV_8UC1);
  PUBLISH(CV_8UC2);
  PUBLISH(CV_8UC3);
  PUBLISH(CV_8UC4);
  PUBLISH(CV_8S);
  PUBLISH(CV_8SC1);
  PUBLISH(CV_8SC2);
  PUBLISH(CV_8SC3);
  PUBLISH(CV_8SC4);
  PUBLISH(CV_16U);
  PUBLISH(CV_16UC1);
  PUBLISH(CV_16UC2);
  PUBLISH(CV_16UC3);
  PUBLISH(CV_16UC4);
  PUBLISH(CV_16S);
  PUBLISH(CV_16SC1);
  PUBLISH(CV_16SC2);
  PUBLISH(CV_16SC3);
  PUBLISH(CV_16SC4);
  PUBLISH(CV_32S);
  PUBLISH(CV_32SC1);
  PUBLISH(CV_32SC2);
  PUBLISH(CV_32SC3);
  PUBLISH(CV_32SC4);
  PUBLISH(CV_32F);
  PUBLISH(CV_32FC1);
  PUBLISH(CV_32FC2);
  PUBLISH(CV_32FC3);
  PUBLISH(CV_32FC4);
  PUBLISH(CV_64F);
  PUBLISH(CV_64FC1);
  PUBLISH(CV_64FC2);
  PUBLISH(CV_64FC3);
  PUBLISH(CV_64FC4);
wester committed
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
  PUBLISH(CV_NEXT_AROUND_ORG);
  PUBLISH(CV_NEXT_AROUND_DST);
  PUBLISH(CV_PREV_AROUND_ORG);
  PUBLISH(CV_PREV_AROUND_DST);
  PUBLISH(CV_NEXT_AROUND_LEFT);
  PUBLISH(CV_NEXT_AROUND_RIGHT);
  PUBLISH(CV_PREV_AROUND_LEFT);
  PUBLISH(CV_PREV_AROUND_RIGHT);

  PUBLISH(CV_WINDOW_AUTOSIZE);

  PUBLISH(CV_PTLOC_INSIDE);
  PUBLISH(CV_PTLOC_ON_EDGE);
  PUBLISH(CV_PTLOC_VERTEX);
  PUBLISH(CV_PTLOC_OUTSIDE_RECT);

  PUBLISH(GC_BGD);
  PUBLISH(GC_FGD);
  PUBLISH(GC_PR_BGD);
  PUBLISH(GC_PR_FGD);
  PUBLISH(GC_INIT_WITH_RECT);
  PUBLISH(GC_INIT_WITH_MASK);
  PUBLISH(GC_EVAL);

  PUBLISH(CV_ROW_SAMPLE);
  PUBLISH(CV_VAR_NUMERICAL);
  PUBLISH(CV_VAR_ORDERED);
  PUBLISH(CV_VAR_CATEGORICAL);

  PUBLISH(CV_AA);

#include "pyopencv_generated_const_reg.h"
wester committed
1270
}