opencv/interfaces/python/cv.cpp

   1 #include <Python.h>
   2
   3 #include <assert.h>
   4
   5 #include <opencv/cxcore.h>
   6 #include <opencv/cv.h>
   7 #include <opencv/cvaux.h>
   8 #include <opencv/cvwimage.h>
   9 #include <opencv/highgui.h>
  10
  11 #define MODULESTR "cv"
  12
  13 static PyObject *opencv_error;
  14
  15 struct memtrack_t {
  16   PyObject_HEAD
  17   void *ptr;
  18   Py_ssize_t size;
  19 };
  20
  21 struct iplimage_t {
  22   PyObject_HEAD
  23   IplImage *a;
  24   PyObject *data;
  25   size_t offset;
  26 };
  27
  28 struct cvmat_t {
  29   PyObject_HEAD
  30   CvMat *a;
  31   PyObject *data;
  32   size_t offset;
  33 };
  34
  35 struct cvmatnd_t {
  36   PyObject_HEAD
  37   CvMatND *a;
  38   PyObject *data;
  39   size_t offset;
  40 };
  41
  42 struct cvhistogram_t {
  43   PyObject_HEAD
  44   CvHistogram h;
  45   PyObject *bins;
  46 };
  47
  48 struct cvmemstorage_t {
  49   PyObject_HEAD
  50   CvMemStorage *a;
  51 };
  52
  53 struct cvseq_t {
  54   PyObject_HEAD
  55   CvSeq *a;
  56   PyObject *container;  // Containing cvmemstorage_t
  57 };
  58
  59 struct cvset_t {
  60   PyObject_HEAD
  61   CvSet *a;
  62   PyObject *container;  // Containing cvmemstorage_t
  63   int i;
  64 };
  65
  66 struct cvsubdiv2d_t {
  67   PyObject_HEAD
  68   CvSubdiv2D *a;
  69   PyObject *container;  // Containing cvmemstorage_t
  70 };
  71
  72 struct cvsubdiv2dpoint_t {
  73   PyObject_HEAD
  74   CvSubdiv2DPoint *a;
  75   PyObject *container;  // Containing cvmemstorage_t
  76 };
  77
  78 struct cvsubdiv2dedge_t {
  79   PyObject_HEAD
  80   CvSubdiv2DEdge a;
  81   PyObject *container;  // Containing cvmemstorage_t
  82 };
  83
  84 struct cvlineiterator_t {
  85   PyObject_HEAD
  86   CvLineIterator iter;
  87   int count;
  88   int type;
  89 };
  90
  91 typedef IplImage ROIplImage;
  92
  93 struct cvmoments_t {
  94   PyObject_HEAD
  95   CvMoments a;
  96 };
  97
  98 struct cvfont_t {
  99   PyObject_HEAD
 100   CvFont a;
 101 };
 102
 103 struct cvhaarclassifiercascade_t {
 104   PyObject_HEAD
 105   CvHaarClassifierCascade *a;
 106 };
 107
 108 struct cvcontourtree_t {
 109   PyObject_HEAD
 110   CvContourTree *a;
 111 };
 112
 113 struct cvrng_t {
 114   PyObject_HEAD
 115   CvRNG a;
 116 };
 117
 118 static int is_iplimage(PyObject *o);
 119 static int is_cvmat(PyObject *o);
 120 static int is_cvmatnd(PyObject *o);
 121 static int convert_to_CvArr(PyObject *o, CvArr **dst, const char *name = "no_name");
 122 static int convert_to_IplImage(PyObject *o, IplImage **dst, const char *name = "no_name");
 123 static int convert_to_CvMat(PyObject *o, CvMat **dst, const char *name = "no_name");
 124 static int convert_to_CvMatND(PyObject *o, CvMatND **dst, const char *name = "no_name");
 125 static PyObject *what_data(PyObject *o);
 126 static PyObject *FROM_CvMat(CvMat *r);
 127
 128 static void translate_error_to_exception(void)
 129 {
 130   PyErr_SetString(opencv_error, cvErrorStr(cvGetErrStatus()));
 131   cvSetErrStatus(0);
 132 }
 133
 134 #define ERRCHK do { if (cvGetErrStatus() != 0) { translate_error_to_exception(); return NULL; } } while (0)
 135 #define ERRWRAP(F) \
 136     do { \
 137         try \
 138         { \
 139             F; \
 140         } \
 141         catch (const cv::Exception &e) \
 142         { \
 143            PyErr_SetString(opencv_error, e.err.c_str()); \
 144            return NULL; \
 145         } \
 146         ERRCHK; \
 147     } while(0)
 148
 149 /************************************************************************/
 150
 151 static int failmsg(const char *fmt, ...)
 152 {
 153   char str[1000];
 154
 155   va_list ap;
 156   va_start(ap, fmt);
 157   vsnprintf(str, sizeof(str), fmt, ap);
 158   va_end(ap);
 159
 160   PyErr_SetString(PyExc_TypeError, str);
 161   return 0;
 162 }
 163
 164 /************************************************************************/
 165
 166 /* These get/setters are polymorphic, used in both iplimage and cvmat */
 167
 168 static PyObject *PyObject_FromCvScalar(CvScalar s, int type)
 169 {
 170   int i, spe = CV_MAT_CN(type);
 171   PyObject *r;
 172   if (spe > 1) {
 173     r = PyTuple_New(spe);
 174     for (i = 0; i < spe; i++)
 175       PyTuple_SET_ITEM(r, i, PyFloat_FromDouble(s.val[i]));
 176   } else {
 177     r = PyFloat_FromDouble(s.val[0]);
 178   }
 179   return r;
 180 }
 181
 182 static PyObject *cvarr_GetItem(PyObject *o, PyObject *key);
 183 static int cvarr_SetItem(PyObject *o, PyObject *key, PyObject *v);
 184
 185 // o is a Python string or buffer object.  Return its size.
 186
 187 static Py_ssize_t what_size(PyObject *o)
 188 {
 189   void *buffer;
 190   Py_ssize_t buffer_len;
 191
 192   if (PyString_Check(o)) {
 193     return PyString_Size(o);
 194   } else if (PyObject_AsWriteBuffer(o, &buffer, &buffer_len) == 0) {
 195     return buffer_len;
 196   } else {
 197     assert(0);  // argument must be string or buffer.
 198     return 0;
 199   }
 200 }
 201
 202
 203 /************************************************************************/
 204
 205 CvMat *PyCvMat_AsCvMat(PyObject *o)
 206 {
 207   assert(0); // not yet implemented: reference counting for CvMat in Kalman is unclear...
 208   return NULL;
 209 }
 210
 211 #define cvReleaseIplConvKernel(x) cvReleaseStructuringElement(x)
 212 #include "generated3.i"
 213
 214 /* iplimage */
 215
 216 static void iplimage_dealloc(PyObject *self)
 217 {
 218   iplimage_t *pc = (iplimage_t*)self;
 219   cvReleaseImageHeader((IplImage**)&pc->a);
 220   Py_DECREF(pc->data);
 221   PyObject_Del(self);
 222 }
 223
 224 static PyObject *iplimage_repr(PyObject *self)
 225 {
 226   iplimage_t *cva = (iplimage_t*)self;
 227   IplImage* ipl = (IplImage*)(cva->a);
 228   char str[1000];
 229   sprintf(str, "<iplimage(");
 230   char *d = str + strlen(str);
 231   sprintf(d, "nChannels=%d ", ipl->nChannels);
 232   d += strlen(d);
 233   sprintf(d, "width=%d ", ipl->width);
 234   d += strlen(d);
 235   sprintf(d, "height=%d ", ipl->height);
 236   d += strlen(d);
 237   sprintf(d, "widthStep=%d ", ipl->widthStep);
 238   d += strlen(d);
 239   sprintf(d, ")>");
 240   return PyString_FromString(str);
 241 }
 242
 243 static PyObject *iplimage_tostring(PyObject *self, PyObject *args)
 244 {
 245   iplimage_t *pc = (iplimage_t*)self;
 246   IplImage *i;
 247   if (!convert_to_IplImage(self, &i, "self"))
 248     return NULL;
 249   if (i == NULL)
 250     return NULL;
 251   int bps;
 252   switch (i->depth) {
 253   case IPL_DEPTH_8U:
 254   case IPL_DEPTH_8S:
 255     bps = 1;
 256     break;
 257   case IPL_DEPTH_16U:
 258   case IPL_DEPTH_16S:
 259     bps = 2;
 260     break;
 261   case IPL_DEPTH_32S:
 262   case IPL_DEPTH_32F:
 263     bps = 4;
 264     break;
 265   case IPL_DEPTH_64F:
 266     bps = 8;
 267     break;
 268   default:
 269     return (PyObject*)failmsg("Unrecognised depth %d", i->depth);
 270   }
 271   int bpl = i->width * i->nChannels * bps;
 272   if (PyString_Check(pc->data) && bpl == i->widthStep && pc->offset == 0 && ((bpl * i->height) == what_size(pc->data))) {
 273     Py_INCREF(pc->data);
 274     return pc->data;
 275   } else {
 276     int l = bpl * i->height;
 277     char *s = new char[l];
 278     int y;
 279     for (y = 0; y < i->height; y++) {
 280       memcpy(s + y * bpl, i->imageData + y * i->widthStep, bpl);
 281     }
 282     PyObject *r = PyString_FromStringAndSize(s, l);
 283     delete s;
 284     return r;
 285   }
 286 }
 287
 288 static struct PyMethodDef iplimage_methods[] =
 289 {
 290   {"tostring", iplimage_tostring, METH_VARARGS},
 291   {NULL,          NULL}
 292 };
 293
 294 static PyObject *iplimage_getnChannels(iplimage_t *cva)
 295 {
 296   return PyInt_FromLong(((IplImage*)(cva->a))->nChannels);
 297 }
 298 static PyObject *iplimage_getwidth(iplimage_t *cva)
 299 {
 300   return PyInt_FromLong(((IplImage*)(cva->a))->width);
 301 }
 302 static PyObject *iplimage_getheight(iplimage_t *cva)
 303 {
 304   return PyInt_FromLong(((IplImage*)(cva->a))->height);
 305 }
 306 static PyObject *iplimage_getdepth(iplimage_t *cva)
 307 {
 308   return PyLong_FromUnsignedLong((unsigned)((IplImage*)(cva->a))->depth);
 309 }
 310 static PyObject *iplimage_getorigin(iplimage_t *cva)
 311 {
 312   return PyInt_FromLong(((IplImage*)(cva->a))->origin);
 313 }
 314 static void iplimage_setorigin(iplimage_t *cva, PyObject *v)
 315 {
 316   ((IplImage*)(cva->a))->origin = PyInt_AsLong(v);
 317 }
 318
 319 static PyGetSetDef iplimage_getseters[] = {
 320   {(char*)"nChannels", (getter)iplimage_getnChannels, (setter)NULL, (char*)"nChannels", NULL},
 321   {(char*)"width", (getter)iplimage_getwidth, (setter)NULL, (char*)"width", NULL},
 322   {(char*)"height", (getter)iplimage_getheight, (setter)NULL, (char*)"height", NULL},
 323   {(char*)"depth", (getter)iplimage_getdepth, (setter)NULL, (char*)"depth", NULL},
 324   {(char*)"origin", (getter)iplimage_getorigin, (setter)iplimage_setorigin, (char*)"origin", NULL},
 325   {NULL}  /* Sentinel */
 326 };
 327
 328 static PyMappingMethods iplimage_as_map = {
 329   NULL,
 330   &cvarr_GetItem,
 331   &cvarr_SetItem,
 332 };
 333
 334 static PyTypeObject iplimage_Type = {
 335   PyObject_HEAD_INIT(&PyType_Type)
 336   0,                                      /*size*/
 337   MODULESTR".iplimage",                          /*name*/
 338   sizeof(iplimage_t),                        /*basicsize*/
 339 };
 340
 341 static void iplimage_specials(void)
 342 {
 343   iplimage_Type.tp_dealloc = iplimage_dealloc;
 344   iplimage_Type.tp_as_mapping = &iplimage_as_map;
 345   iplimage_Type.tp_repr = iplimage_repr;
 346   iplimage_Type.tp_methods = iplimage_methods;
 347   iplimage_Type.tp_getset = iplimage_getseters;
 348 }
 349
 350 static int is_iplimage(PyObject *o)
 351 {
 352   return PyType_IsSubtype(o->ob_type, &iplimage_Type);
 353 }
 354
 355 /************************************************************************/
 356
 357 /* cvmat */
 358
 359 static void cvmat_dealloc(PyObject *self)
 360 {
 361   cvmat_t *pc = (cvmat_t*)self;
 362   Py_DECREF(pc->data);
 363   cvFree(&pc->a);
 364   PyObject_Del(self);
 365 }
 366
 367 static PyObject *cvmat_repr(PyObject *self)
 368 {
 369   CvMat *m = ((cvmat_t*)self)->a;
 370   char str[1000];
 371   sprintf(str, "<cvmat(");
 372   char *d = str + strlen(str);
 373   sprintf(d, "type=%08x ", m->type);
 374   d += strlen(d);
 375   sprintf(d, "rows=%d ", m->rows);
 376   d += strlen(d);
 377   sprintf(d, "cols=%d ", m->cols);
 378   d += strlen(d);
 379   sprintf(d, "step=%d ", m->step);
 380   d += strlen(d);
 381   sprintf(d, ")>");
 382   return PyString_FromString(str);
 383 }
 384
 385 static PyObject *cvmat_tostring(PyObject *self, PyObject *args)
 386 {
 387   CvMat *m;
 388   if (!convert_to_CvMat(self, &m, "self"))
 389     return NULL;
 390
 391   int bps;                     // bytes per sample
 392
 393   switch (CV_MAT_DEPTH(m->type)) {
 394   case CV_8U:
 395   case CV_8S:
 396     bps = CV_MAT_CN(m->type) * 1;
 397     break;
 398   case CV_16U:
 399   case CV_16S:
 400     bps = CV_MAT_CN(m->type) * 2;
 401     break;
 402   case CV_32S:
 403   case CV_32F:
 404     bps = CV_MAT_CN(m->type) * 4;
 405     break;
 406   case CV_64F:
 407     bps = CV_MAT_CN(m->type) * 8;
 408     break;
 409   default:
 410     return (PyObject*)failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type));
 411   }
 412
 413   int bpl = m->cols * bps; // bytes per line
 414   cvmat_t *pc = (cvmat_t*)self;
 415   if (PyString_Check(pc->data) && bpl == m->step && pc->offset == 0 && ((bpl * m->rows) == what_size(pc->data))) {
 416     Py_INCREF(pc->data);
 417     return pc->data;
 418   } else {
 419     int l = bpl * m->rows;
 420     char *s = new char[l];
 421     int y;
 422     for (y = 0; y < m->rows; y++) {
 423       memcpy(s + y * bpl, m->data.ptr + y * m->step, bpl);
 424     }
 425     PyObject *r = PyString_FromStringAndSize(s, l);
 426     delete s;
 427     return r;
 428   }
 429 }
 430
 431 static struct PyMethodDef cvmat_methods[] =
 432 {
 433   {"tostring", cvmat_tostring, METH_VARARGS},
 434   {NULL,          NULL}
 435 };
 436
 437 static PyObject *cvmat_gettype(cvmat_t *cva)
 438 {
 439   return PyInt_FromLong(cvGetElemType(cva->a));
 440 }
 441
 442 static PyObject *cvmat_getstep(cvmat_t *cva)
 443 {
 444   return PyInt_FromLong(cva->a->step);
 445 }
 446
 447 static PyObject *cvmat_getrows(cvmat_t *cva)
 448 {
 449   return PyInt_FromLong(cva->a->rows);
 450 }
 451
 452 static PyObject *cvmat_getcols(cvmat_t *cva)
 453 {
 454   return PyInt_FromLong(cva->a->cols);
 455 }
 456
 457 #if PYTHON_USE_NUMPY
 458 #include "numpy/ndarrayobject.h"
 459
 460 // A PyArrayInterface, with an associated python object that should be DECREF'ed on release
 461 struct arrayTrack {
 462   PyArrayInterface s;
 463   PyObject *o;
 464 };
 465
 466 static void arrayTrackDtor(void *p)
 467 {
 468   struct arrayTrack *at = (struct arrayTrack *)p;
 469   delete at->s.shape;
 470   delete at->s.strides;
 471   if (at->s.descr)
 472     Py_DECREF(at->s.descr);
 473   Py_DECREF(at->o);
 474 }
 475
 476 // Fill in fields of PyArrayInterface s using mtype.  This code is common
 477 // to cvmat and cvmatnd
 478
 479 static void arrayinterface_common(PyArrayInterface *s, int mtype)
 480 {
 481   s->two = 2;
 482
 483   switch (CV_MAT_DEPTH(mtype)) {
 484   case CV_8U:
 485     s->typekind = 'u';
 486     s->itemsize = 1;
 487     break;
 488   case CV_8S:
 489     s->typekind = 'i';
 490     s->itemsize = 1;
 491     break;
 492   case CV_16U:
 493     s->typekind = 'u';
 494     s->itemsize = 2;
 495     break;
 496   case CV_16S:
 497     s->typekind = 'i';
 498     s->itemsize = 2;
 499     break;
 500   case CV_32S:
 501     s->typekind = 'i';
 502     s->itemsize = 4;
 503     break;
 504   case CV_32F:
 505     s->typekind = 'f';
 506     s->itemsize = 4;
 507     break;
 508   case CV_64F:
 509     s->typekind = 'f';
 510     s->itemsize = 8;
 511     break;
 512   default:
 513     assert(0);
 514   }
 515
 516   s->flags = NPY_WRITEABLE | NPY_NOTSWAPPED;
 517 }
 518
 519 static PyObject *cvmat_array_struct(cvmat_t *cva)
 520 {
 521   CvMat *m;
 522   convert_to_CvMat((PyObject *)cva, &m, "");
 523
 524   arrayTrack *at = new arrayTrack;
 525   PyArrayInterface *s = &at->s;
 526
 527   at->o = cva->data;
 528   Py_INCREF(at->o);
 529
 530   arrayinterface_common(s, m->type);
 531
 532   if (CV_MAT_CN(m->type) == 1) {
 533     s->nd = 2;
 534     s->shape = new npy_intp[2];
 535     s->shape[0] = m->rows;
 536     s->shape[1] = m->cols;
 537     s->strides = new npy_intp[2];
 538     s->strides[0] = m->step;
 539     s->strides[1] = s->itemsize;
 540   } else {
 541     s->nd = 3;
 542     s->shape = new npy_intp[3];
 543     s->shape[0] = m->rows;
 544     s->shape[1] = m->cols;
 545     s->shape[2] = CV_MAT_CN(m->type);
 546     s->strides = new npy_intp[3];
 547     s->strides[0] = m->step;
 548     s->strides[1] = s->itemsize * CV_MAT_CN(m->type);
 549     s->strides[2] = s->itemsize;
 550   }
 551   s->data = (void*)(m->data.ptr);
 552   s->descr = PyList_New(1);
 553   char typestr[10];
 554   sprintf(typestr, "<%c%d", s->typekind, s->itemsize);
 555   PyList_SetItem(s->descr, 0, Py_BuildValue("(ss)", "x", typestr));
 556
 557   return PyCObject_FromVoidPtr(s, arrayTrackDtor);
 558 }
 559
 560 static PyObject *cvmatnd_array_struct(cvmatnd_t *cva)
 561 {
 562   CvMatND *m;
 563   convert_to_CvMatND((PyObject *)cva, &m, "");
 564
 565   arrayTrack *at = new arrayTrack;
 566   PyArrayInterface *s = &at->s;
 567
 568   at->o = cva->data;
 569   Py_INCREF(at->o);
 570
 571   arrayinterface_common(s, m->type);
 572
 573   int i;
 574   if (CV_MAT_CN(m->type) == 1) {
 575     s->nd = m->dims;
 576     s->shape = new npy_intp[s->nd];
 577     for (i = 0; i < s->nd; i++)
 578       s->shape[i] = m->dim[i].size;
 579     s->strides = new npy_intp[s->nd];
 580     for (i = 0; i < (s->nd - 1); i++)
 581       s->strides[i] = m->dim[i].step;
 582     s->strides[s->nd - 1] = s->itemsize;
 583   } else {
 584     s->nd = m->dims + 1;
 585     s->shape = new npy_intp[s->nd];
 586     for (i = 0; i < (s->nd - 1); i++)
 587       s->shape[i] = m->dim[i].size;
 588     s->shape[s->nd - 1] = CV_MAT_CN(m->type);
 589
 590     s->strides = new npy_intp[s->nd];
 591     for (i = 0; i < (s->nd - 2); i++)
 592       s->strides[i] = m->dim[i].step;
 593     s->strides[s->nd - 2] = s->itemsize * CV_MAT_CN(m->type);
 594     s->strides[s->nd - 1] = s->itemsize;
 595   }
 596   s->data = (void*)(m->data.ptr);
 597   s->descr = PyList_New(1);
 598   char typestr[10];
 599   sprintf(typestr, "<%c%d", s->typekind, s->itemsize);
 600   PyList_SetItem(s->descr, 0, Py_BuildValue("(ss)", "x", typestr));
 601
 602   return PyCObject_FromVoidPtr(s, arrayTrackDtor);
 603 }
 604 #endif
 605
 606 static PyGetSetDef cvmat_getseters[] = {
 607   {(char*)"type",   (getter)cvmat_gettype, (setter)NULL, (char*)"type",   NULL},
 608   {(char*)"step",   (getter)cvmat_getstep, (setter)NULL, (char*)"step",   NULL},
 609   {(char*)"rows",   (getter)cvmat_getrows, (setter)NULL, (char*)"rows",   NULL},
 610   {(char*)"cols",   (getter)cvmat_getcols, (setter)NULL, (char*)"cols",   NULL},
 611   {(char*)"width",  (getter)cvmat_getcols, (setter)NULL, (char*)"width",  NULL},
 612   {(char*)"height", (getter)cvmat_getrows, (setter)NULL, (char*)"height", NULL},
 613 #if PYTHON_USE_NUMPY
 614   {(char*)"__array_struct__", (getter)cvmat_array_struct, (setter)NULL, (char*)"__array_struct__", NULL},
 615 #endif
 616   {NULL}  /* Sentinel */
 617 };
 618
 619 static PyMappingMethods cvmat_as_map = {
 620   NULL,
 621   &cvarr_GetItem,
 622   &cvarr_SetItem,
 623 };
 624
 625 static PyTypeObject cvmat_Type = {
 626   PyObject_HEAD_INIT(&PyType_Type)
 627   0,                                      /*size*/
 628   MODULESTR".cvmat",                      /*name*/
 629   sizeof(cvmat_t),                        /*basicsize*/
 630 };
 631
 632 static void cvmat_specials(void)
 633 {
 634   cvmat_Type.tp_dealloc = cvmat_dealloc;
 635   cvmat_Type.tp_as_mapping = &cvmat_as_map;
 636   cvmat_Type.tp_repr = cvmat_repr;
 637   cvmat_Type.tp_methods = cvmat_methods;
 638   cvmat_Type.tp_getset = cvmat_getseters;
 639 }
 640
 641 static int is_cvmat(PyObject *o)
 642 {
 643   return PyType_IsSubtype(o->ob_type, &cvmat_Type);
 644 }
 645
 646 /************************************************************************/
 647
 648 /* cvmatnd */
 649
 650 static void cvmatnd_dealloc(PyObject *self)
 651 {
 652   cvmatnd_t *pc = (cvmatnd_t*)self;
 653   Py_DECREF(pc->data);
 654   PyObject_Del(self);
 655 }
 656
 657 static PyObject *cvmatnd_repr(PyObject *self)
 658 {
 659   CvMatND *m = ((cvmatnd_t*)self)->a;
 660   char str[1000];
 661   sprintf(str, "<cvmatnd(");
 662   char *d = str + strlen(str);
 663   sprintf(d, "type=%08x ", m->type);
 664   d += strlen(d);
 665   sprintf(d, ")>");
 666   return PyString_FromString(str);
 667 }
 668
 669 static size_t cvmatnd_size(CvMatND *m)
 670 {
 671   int bps = 1;
 672   switch (CV_MAT_DEPTH(m->type)) {
 673   case CV_8U:
 674   case CV_8S:
 675     bps = CV_MAT_CN(m->type) * 1;
 676     break;
 677   case CV_16U:
 678   case CV_16S:
 679     bps = CV_MAT_CN(m->type) * 2;
 680     break;
 681   case CV_32S:
 682   case CV_32F:
 683     bps = CV_MAT_CN(m->type) * 4;
 684     break;
 685   case CV_64F:
 686     bps = CV_MAT_CN(m->type) * 8;
 687     break;
 688   default:
 689     assert(0);
 690   }
 691   size_t l = bps;
 692   for (int d = 0; d < m->dims; d++) {
 693     l *= m->dim[d].size;
 694   }
 695   return l;
 696 }
 697
 698 static PyObject *cvmatnd_tostring(PyObject *self, PyObject *args)
 699 {
 700   CvMatND *m;
 701   if (!convert_to_CvMatND(self, &m, "self"))
 702     return NULL;
 703
 704   int bps;
 705   switch (CV_MAT_DEPTH(m->type)) {
 706   case CV_8U:
 707   case CV_8S:
 708     bps = CV_MAT_CN(m->type) * 1;
 709     break;
 710   case CV_16U:
 711   case CV_16S:
 712     bps = CV_MAT_CN(m->type) * 2;
 713     break;
 714   case CV_32S:
 715   case CV_32F:
 716     bps = CV_MAT_CN(m->type) * 4;
 717     break;
 718   case CV_64F:
 719     bps = CV_MAT_CN(m->type) * 8;
 720     break;
 721   default:
 722     return (PyObject*)failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type));
 723   }
 724
 725   int l = bps;
 726   for (int d = 0; d < m->dims; d++) {
 727     l *= m->dim[d].size;
 728   }
 729   int i[CV_MAX_DIM];
 730   int d;
 731   for (d = 0; d < m->dims; d++) {
 732     i[d] = 0;
 733   }
 734   int rowsize = m->dim[m->dims-1].size * bps;
 735   char *s = new char[l];
 736   char *ps = s;
 737
 738   int finished = 0;
 739   while (!finished) {
 740     memcpy(ps, cvPtrND(m, i), rowsize);
 741     ps += rowsize;
 742     for (d = m->dims - 2; 0 <= d; d--) {
 743       if (++i[d] < cvGetDimSize(m, d)) {
 744         break;
 745       } else {
 746         i[d] = 0;
 747       }
 748     }
 749     if (d < 0)
 750       finished = 1;
 751   }
 752
 753   return PyString_FromStringAndSize(s, ps - s);
 754 }
 755
 756 static struct PyMethodDef cvmatnd_methods[] =
 757 {
 758   {"tostring", cvmatnd_tostring, METH_VARARGS},
 759   {NULL,          NULL}
 760 };
 761
 762 static PyGetSetDef cvmatnd_getseters[] = {
 763 #if PYTHON_USE_NUMPY
 764   {(char*)"__array_struct__", (getter)cvmatnd_array_struct, (setter)NULL, (char*)"__array_struct__", NULL},
 765 #endif
 766   {NULL}  /* Sentinel */
 767 };
 768
 769 static PyMappingMethods cvmatnd_as_map = {
 770   NULL,
 771   &cvarr_GetItem,
 772   &cvarr_SetItem,
 773 };
 774
 775 static PyTypeObject cvmatnd_Type = {
 776   PyObject_HEAD_INIT(&PyType_Type)
 777   0,                                      /*size*/
 778   MODULESTR".cvmatnd",                          /*name*/
 779   sizeof(cvmatnd_t),                        /*basicsize*/
 780 };
 781
 782 static void cvmatnd_specials(void)
 783 {
 784   cvmatnd_Type.tp_dealloc = cvmatnd_dealloc;
 785   cvmatnd_Type.tp_as_mapping = &cvmatnd_as_map;
 786   cvmatnd_Type.tp_repr = cvmatnd_repr;
 787   cvmatnd_Type.tp_methods = cvmatnd_methods;
 788   cvmatnd_Type.tp_getset = cvmatnd_getseters;
 789 }
 790
 791 static int is_cvmatnd(PyObject *o)
 792 {
 793   return PyType_IsSubtype(o->ob_type, &cvmatnd_Type);
 794 }
 795
 796 /************************************************************************/
 797
 798 /* cvhistogram */
 799
 800 static void cvhistogram_dealloc(PyObject *self)
 801 {
 802   cvhistogram_t *cvh = (cvhistogram_t*)self;
 803   Py_DECREF(cvh->bins);
 804   PyObject_Del(self);
 805 }
 806
 807 static PyTypeObject cvhistogram_Type = {
 808   PyObject_HEAD_INIT(&PyType_Type)
 809   0,                                      /*size*/
 810   MODULESTR".cvhistogram",                /*name*/
 811   sizeof(cvhistogram_t),                  /*basicsize*/
 812 };
 813
 814 static PyObject *cvhistogram_getbins(cvhistogram_t *cvh)
 815 {
 816   Py_INCREF(cvh->bins);
 817   return cvh->bins;
 818 }
 819
 820 static PyGetSetDef cvhistogram_getseters[] = {
 821   {(char*)"bins", (getter)cvhistogram_getbins, (setter)NULL, (char*)"bins", NULL},
 822   {NULL}  /* Sentinel */
 823 };
 824
 825 static void cvhistogram_specials(void)
 826 {
 827   cvhistogram_Type.tp_dealloc = cvhistogram_dealloc;
 828   cvhistogram_Type.tp_getset = cvhistogram_getseters;
 829 }
 830
 831 /************************************************************************/
 832
 833 /* cvlineiterator */
 834
 835 static PyObject *cvlineiterator_iter(PyObject *o)
 836 {
 837   Py_INCREF(o);
 838   return o;
 839 }
 840
 841 static PyObject *cvlineiterator_next(PyObject *o)
 842 {
 843   cvlineiterator_t *pi = (cvlineiterator_t*)o;
 844
 845   if (pi->count) {
 846       pi->count--;
 847
 848       CvScalar r;
 849       cvRawDataToScalar( (void*)(pi->iter.ptr), pi->type, &r);
 850       PyObject *pr = PyObject_FromCvScalar(r, pi->type);
 851
 852       CV_NEXT_LINE_POINT(pi->iter);
 853
 854       return pr;
 855   } else {
 856     return NULL;
 857   }
 858 }
 859
 860 static PyTypeObject cvlineiterator_Type = {
 861   PyObject_HEAD_INIT(&PyType_Type)
 862   0,                                      /*size*/
 863   MODULESTR".cvlineiterator",             /*name*/
 864   sizeof(cvlineiterator_t),               /*basicsize*/
 865 };
 866
 867 static void cvlineiterator_specials(void)
 868 {
 869   cvlineiterator_Type.tp_iter = cvlineiterator_iter;
 870   cvlineiterator_Type.tp_iternext = cvlineiterator_next;
 871 }
 872
 873 /************************************************************************/
 874
 875 /* memtrack */
 876
 877 static void memtrack_dealloc(PyObject *self)
 878 {
 879   memtrack_t *pi = (memtrack_t*)self;
 880   // printf("===> memtrack_dealloc %p!\n", pi->ptr);
 881   cvFree(&pi->ptr);
 882   PyObject_Del(self);
 883 }
 884
 885 static PyTypeObject memtrack_Type = {
 886   PyObject_HEAD_INIT(&PyType_Type)
 887   0,                                      /*size*/
 888   MODULESTR".memtrack",                          /*name*/
 889   sizeof(memtrack_t),                        /*basicsize*/
 890 };
 891
 892 Py_ssize_t memtrack_getreadbuffer(PyObject *self, Py_ssize_t segment, void **ptrptr)
 893 {
 894   *ptrptr = &((memtrack_t*)self)->ptr;
 895   return ((memtrack_t*)self)->size;
 896 }
 897
 898 Py_ssize_t memtrack_getwritebuffer(PyObject *self, Py_ssize_t segment, void **ptrptr)
 899 {
 900   *ptrptr = ((memtrack_t*)self)->ptr;
 901   return ((memtrack_t*)self)->size;
 902 }
 903
 904 Py_ssize_t memtrack_getsegcount(PyObject *self, Py_ssize_t *lenp)
 905 {
 906   return (Py_ssize_t)1;
 907 }
 908
 909 PyBufferProcs memtrack_as_buffer = {
 910   memtrack_getreadbuffer,
 911   memtrack_getwritebuffer,
 912   memtrack_getsegcount
 913 };
 914
 915 static void memtrack_specials(void)
 916 {
 917   memtrack_Type.tp_dealloc = memtrack_dealloc;
 918   memtrack_Type.tp_as_buffer = &memtrack_as_buffer;
 919 }
 920
 921 /************************************************************************/
 922
 923 /* cvmoments */
 924
 925 static PyTypeObject cvmoments_Type = {
 926   PyObject_HEAD_INIT(&PyType_Type)
 927   0,                                      /*size*/
 928   MODULESTR".cvmoments",                          /*name*/
 929   sizeof(cvmoments_t),                        /*basicsize*/
 930 };
 931
 932 static void cvmoments_specials(void)
 933 {
 934 }
 935
 936 /************************************************************************/
 937
 938 /* cvmemstorage */
 939
 940 static void cvmemstorage_dealloc(PyObject *self)
 941 {
 942   cvmemstorage_t *ps = (cvmemstorage_t*)self;
 943   cvReleaseMemStorage(&(ps->a));
 944   PyObject_Del(self);
 945 }
 946
 947 static PyTypeObject cvmemstorage_Type = {
 948   PyObject_HEAD_INIT(&PyType_Type)
 949   0,                                      /*size*/
 950   MODULESTR".cvmemstorage",               /*name*/
 951   sizeof(cvmemstorage_t),                 /*basicsize*/
 952 };
 953
 954 static void cvmemstorage_specials(void)
 955 {
 956   cvmemstorage_Type.tp_dealloc = cvmemstorage_dealloc;
 957 }
 958
 959 /************************************************************************/
 960
 961 /* cvfont */
 962
 963 static PyTypeObject cvfont_Type = {
 964   PyObject_HEAD_INIT(&PyType_Type)
 965   0,                                      /*size*/
 966   MODULESTR".cvfont",                     /*name*/
 967   sizeof(cvfont_t),                       /*basicsize*/
 968 };
 969
 970 static void cvfont_specials(void) { }
 971
 972 /************************************************************************/
 973
 974 /* cvrng */
 975
 976 static PyTypeObject cvrng_Type = {
 977   PyObject_HEAD_INIT(&PyType_Type)
 978   0,                                      /*size*/
 979   MODULESTR".cvrng",                     /*name*/
 980   sizeof(cvrng_t),                       /*basicsize*/
 981 };
 982
 983 static void cvrng_specials(void)
 984 {
 985 }
 986
 987 /************************************************************************/
 988
 989 /* cvhaarclassifiercascade */
 990
 991 static PyTypeObject cvhaarclassifiercascade_Type = {
 992   PyObject_HEAD_INIT(&PyType_Type)
 993   0,                                      /*size*/
 994   MODULESTR".cvhaarclassifiercascade",                     /*name*/
 995   sizeof(cvhaarclassifiercascade_t),                       /*basicsize*/
 996 };
 997
 998 static void cvhaarclassifiercascade_specials(void) { }
 999
1000 /************************************************************************/
1001
1002 /* cvcontourtree */
1003
1004 static PyTypeObject cvcontourtree_Type = {
1005   PyObject_HEAD_INIT(&PyType_Type)
1006   0,                                      /*size*/
1007   MODULESTR".cvcontourtree",                     /*name*/
1008   sizeof(cvcontourtree_t),                       /*basicsize*/
1009 };
1010
1011 static void cvcontourtree_specials(void) { }
1012
1013
1014 /************************************************************************/
1015
1016 /* cvsubdiv2dedge */
1017
1018 static PyTypeObject cvsubdiv2dedge_Type = {
1019   PyObject_HEAD_INIT(&PyType_Type)
1020   0,                                      /*size*/
1021   MODULESTR".cvsubdiv2dedge",                     /*name*/
1022   sizeof(cvsubdiv2dedge_t),                       /*basicsize*/
1023 };
1024
1025 static int cvsubdiv2dedge_compare(PyObject *o1, PyObject *o2)
1026 {
1027   cvsubdiv2dedge_t *e1 = (cvsubdiv2dedge_t*)o1;
1028   cvsubdiv2dedge_t *e2 = (cvsubdiv2dedge_t*)o2;
1029   if (e1->a < e2->a)
1030     return -1;
1031   else if (e1->a > e2->a)
1032     return 1;
1033   else
1034     return 0;
1035 }
1036
1037 static PyObject *cvquadedge_repr(PyObject *self)
1038 {
1039   CvSubdiv2DEdge m = ((cvsubdiv2dedge_t*)self)->a;
1040   char str[1000];
1041   sprintf(str, "<cvsubdiv2dedge(");
1042   char *d = str + strlen(str);
1043   sprintf(d, "%zx.%d", m & ~3, (int)(m & 3));
1044   d += strlen(d);
1045   sprintf(d, ")>");
1046   return PyString_FromString(str);
1047 }
1048
1049 static void cvsubdiv2dedge_specials(void) {
1050   cvsubdiv2dedge_Type.tp_compare = cvsubdiv2dedge_compare;
1051   cvsubdiv2dedge_Type.tp_repr = cvquadedge_repr;
1052 }
1053
1054 /************************************************************************/
1055
1056 /* cvseq */
1057
1058 static void cvseq_dealloc(PyObject *self)
1059 {
1060   cvseq_t *ps = (cvseq_t*)self;
1061   Py_DECREF(ps->container);
1062   PyObject_Del(self);
1063 }
1064
1065 static PyObject *cvseq_h_next(PyObject *self, PyObject *args);
1066 static PyObject *cvseq_h_prev(PyObject *self, PyObject *args);
1067 static PyObject *cvseq_v_next(PyObject *self, PyObject *args);
1068 static PyObject *cvseq_v_prev(PyObject *self, PyObject *args);
1069
1070 static struct PyMethodDef cvseq_methods[] =
1071 {
1072   {"h_next", cvseq_h_next, METH_VARARGS},
1073   {"h_prev", cvseq_h_prev, METH_VARARGS},
1074   {"v_next", cvseq_v_next, METH_VARARGS},
1075   {"v_prev", cvseq_v_prev, METH_VARARGS},
1076   {NULL,          NULL}
1077 };
1078
1079 static Py_ssize_t cvseq_seq_length(PyObject *o)
1080 {
1081   cvseq_t *ps = (cvseq_t*)o;
1082   if (ps->a == NULL)
1083     return (Py_ssize_t)0;
1084   else
1085     return (Py_ssize_t)(ps->a->total);
1086 }
1087
1088 static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
1089 {
1090   cvseq_t *ps = (cvseq_t*)o;
1091   CvPoint *pt;
1092   struct pointpair{
1093     CvPoint a, b;
1094   } *pp;
1095   CvPoint2D32f *pt2;
1096   CvPoint3D32f *pt3;
1097
1098   if (i < cvseq_seq_length(o)) {
1099     switch (CV_SEQ_ELTYPE(ps->a)) {
1100
1101     case CV_SEQ_ELTYPE_POINT:
1102       pt = CV_GET_SEQ_ELEM(CvPoint, ps->a, i);
1103       return Py_BuildValue("ii", pt->x, pt->y);
1104
1105     case CV_SEQ_ELTYPE_GENERIC:
1106       switch (ps->a->elem_size) {
1107       case sizeof(CvQuadEdge2D):
1108         {
1109           cvsubdiv2dedge_t *r = PyObject_NEW(cvsubdiv2dedge_t, &cvsubdiv2dedge_Type);
1110           r->a = (CvSubdiv2DEdge)CV_GET_SEQ_ELEM(CvQuadEdge2D, ps->a, i);
1111           r->container = ps->container;
1112           Py_INCREF(r->container);
1113           return (PyObject*)r;
1114         }
1115       default:
1116         printf("seq elem size is %d\n", ps->a->elem_size);
1117         printf("KIND %d\n", CV_SEQ_KIND(ps->a));
1118         assert(0);
1119       }
1120       return PyInt_FromLong(*CV_GET_SEQ_ELEM(unsigned char, ps->a, i));
1121
1122     case CV_SEQ_ELTYPE_PTR:
1123     case CV_SEQ_ELTYPE_INDEX:
1124       return PyInt_FromLong(*CV_GET_SEQ_ELEM(int, ps->a, i));
1125
1126     case CV_32SC4:
1127       pp = CV_GET_SEQ_ELEM(pointpair, ps->a, i);
1128       return Py_BuildValue("(ii),(ii)", pp->a.x, pp->a.y, pp->b.x, pp->b.y);
1129
1130     case CV_32FC2:
1131       pt2 = CV_GET_SEQ_ELEM(CvPoint2D32f, ps->a, i);
1132       return Py_BuildValue("ff", pt2->x, pt2->y);
1133
1134     case CV_SEQ_ELTYPE_POINT3D:
1135       pt3 = CV_GET_SEQ_ELEM(CvPoint3D32f, ps->a, i);
1136       return Py_BuildValue("fff", pt3->x, pt3->y, pt3->z);
1137
1138     default:
1139       printf("Unknown element type %08x\n", CV_SEQ_ELTYPE(ps->a));
1140       assert(0);
1141       return NULL;
1142     }
1143   } else
1144     return NULL;
1145 }
1146
1147 static PyObject* cvseq_map_getitem(PyObject *o, PyObject *item)
1148 {
1149   if (PyInt_Check(item)) {
1150     long i = PyInt_AS_LONG(item);
1151     if (i < 0)
1152       i += cvseq_seq_length(o);
1153     return cvseq_seq_getitem(o, i);
1154   } else if (PySlice_Check(item)) {
1155     Py_ssize_t start, stop, step, slicelength, cur, i;
1156     PyObject* result;
1157
1158     if (PySlice_GetIndicesEx((PySliceObject*)item, cvseq_seq_length(o),
1159          &start, &stop, &step, &slicelength) < 0) {
1160       return NULL;
1161     }
1162
1163     if (slicelength <= 0) {
1164       return PyList_New(0);
1165     } else {
1166       result = PyList_New(slicelength);
1167       if (!result) return NULL;
1168
1169       for (cur = start, i = 0; i < slicelength;
1170            cur += step, i++) {
1171         PyList_SET_ITEM(result, i, cvseq_seq_getitem(o, cur));
1172       }
1173
1174       return result;
1175     }
1176   } else {
1177     PyErr_SetString(PyExc_TypeError, "CvSeq indices must be integers");
1178     return NULL;
1179   }
1180 }
1181
1182 static
1183 PySequenceMethods cvseq_sequence = {
1184   cvseq_seq_length,
1185   NULL,
1186   NULL,
1187   cvseq_seq_getitem
1188 };
1189
1190 static PyMappingMethods cvseq_mapping = {
1191   cvseq_seq_length,
1192   cvseq_map_getitem,
1193   NULL,
1194 };
1195
1196 static PyTypeObject cvseq_Type = {
1197   PyObject_HEAD_INIT(&PyType_Type)
1198   0,                                      /*size*/
1199   MODULESTR".cvseq",                          /*name*/
1200   sizeof(cvseq_t),                        /*basicsize*/
1201 };
1202
1203 static void cvseq_specials(void)
1204 {
1205   cvseq_Type.tp_dealloc = cvseq_dealloc;
1206   cvseq_Type.tp_as_sequence = &cvseq_sequence;
1207   cvseq_Type.tp_as_mapping = &cvseq_mapping;
1208   cvseq_Type.tp_methods = cvseq_methods;
1209 }
1210
1211 #define MK_ACCESSOR(FIELD) \
1212 static PyObject *cvseq_##FIELD(PyObject *self, PyObject *args) \
1213 { \
1214   cvseq_t *ps = (cvseq_t*)self; \
1215   CvSeq *s = ps->a; \
1216   if (s->FIELD == NULL) { \
1217     Py_RETURN_NONE; \
1218   } else { \
1219     cvseq_t *r = PyObject_NEW(cvseq_t, &cvseq_Type); \
1220     r->a = s->FIELD; \
1221     r->container = ps->container; \
1222     Py_INCREF(r->container); \
1223     return (PyObject*)r; \
1224   } \
1225 }
1226
1227 MK_ACCESSOR(h_next)
1228 MK_ACCESSOR(h_prev)
1229 MK_ACCESSOR(v_next)
1230 MK_ACCESSOR(v_prev)
1231 #undef MK_ACCESSOR
1232
1233 /************************************************************************/
1234
1235 /* cvset */
1236
1237 static void cvset_dealloc(PyObject *self)
1238 {
1239   cvset_t *ps = (cvset_t*)self;
1240   Py_DECREF(ps->container);
1241   PyObject_Del(self);
1242 }
1243
1244 static PyTypeObject cvset_Type = {
1245   PyObject_HEAD_INIT(&PyType_Type)
1246   0,                                      /*size*/
1247   MODULESTR".cvset",                          /*name*/
1248   sizeof(cvset_t),                        /*basicsize*/
1249 };
1250
1251 static PyObject *cvset_iter(PyObject *o)
1252 {
1253   Py_INCREF(o);
1254   cvset_t *ps = (cvset_t*)o;
1255   ps->i = 0;
1256   return o;
1257 }
1258
1259 static PyObject *cvset_next(PyObject *o)
1260 {
1261   cvset_t *ps = (cvset_t*)o;
1262
1263   while (ps->i < ps->a->total) {
1264     CvSetElem *e = cvGetSetElem(ps->a, ps->i);
1265     int prev_i = ps->i++;
1266     if (e != NULL) {
1267       return cvseq_seq_getitem(o, prev_i);
1268     }
1269   }
1270   return NULL;
1271 }
1272
1273 static void cvset_specials(void)
1274 {
1275   cvset_Type.tp_dealloc = cvset_dealloc;
1276   cvset_Type.tp_iter = cvset_iter;
1277   cvset_Type.tp_iternext = cvset_next;
1278 }
1279
1280 /************************************************************************/
1281
1282 /* cvsubdiv2d */
1283
1284 static PyTypeObject cvsubdiv2d_Type = {
1285   PyObject_HEAD_INIT(&PyType_Type)
1286   0,                                      /*size*/
1287   MODULESTR".cvsubdiv2d",                     /*name*/
1288   sizeof(cvsubdiv2d_t),                       /*basicsize*/
1289 };
1290
1291 static PyObject *cvsubdiv2d_getattro(PyObject *o, PyObject *name)
1292 {
1293   cvsubdiv2d_t *p = (cvsubdiv2d_t*)o;
1294   if (strcmp(PyString_AsString(name), "edges") == 0) {
1295     cvset_t *r = PyObject_NEW(cvset_t, &cvset_Type);
1296     r->a = p->a->edges;
1297     r->container = p->container;
1298     Py_INCREF(r->container);
1299     return (PyObject*)r;
1300   } else {
1301     PyErr_SetString(PyExc_TypeError, "cvsubdiv2d has no such attribute");
1302     return NULL;
1303   }
1304 }
1305
1306 static void cvsubdiv2d_specials(void)
1307 {
1308   cvsubdiv2d_Type.tp_getattro = cvsubdiv2d_getattro;
1309 }
1310
1311 /************************************************************************/
1312
1313 /* cvsubdiv2dpoint */
1314
1315 static PyTypeObject cvsubdiv2dpoint_Type = {
1316   PyObject_HEAD_INIT(&PyType_Type)
1317   0,                                      /*size*/
1318   MODULESTR".cvsubdiv2dpoint",                     /*name*/
1319   sizeof(cvsubdiv2dpoint_t),                       /*basicsize*/
1320 };
1321
1322 static PyObject *cvsubdiv2dpoint_getattro(PyObject *o, PyObject *name)
1323 {
1324   cvsubdiv2dpoint_t *p = (cvsubdiv2dpoint_t*)o;
1325   if (strcmp(PyString_AsString(name), "first") == 0) {
1326     cvsubdiv2dedge_t *r = PyObject_NEW(cvsubdiv2dedge_t, &cvsubdiv2dedge_Type);
1327     r->a = p->a->first;
1328     r->container = p->container;
1329     Py_INCREF(r->container);
1330     return (PyObject*)r;
1331   } else if (strcmp(PyString_AsString(name), "pt") == 0) {
1332     return Py_BuildValue("(ff)", p->a->pt.x, p->a->pt.y);
1333   } else {
1334     PyErr_SetString(PyExc_TypeError, "cvsubdiv2dpoint has no such attribute");
1335     return NULL;
1336   }
1337 }
1338
1339 static void cvsubdiv2dpoint_specials(void)
1340 {
1341   cvsubdiv2dpoint_Type.tp_getattro = cvsubdiv2dpoint_getattro;
1342 }
1343
1344 /************************************************************************/
1345 /* convert_to_X: used after PyArg_ParseTuple in the generated code  */
1346
1347 static int convert_to_char(PyObject *o, char *dst, const char *name = "no_name")
1348 {
1349   if (PyString_Check(o) && PyString_Size(o) == 1) {
1350     *dst = PyString_AsString(o)[0];
1351     return 1;
1352   } else {
1353     (*dst) = 0;
1354     return failmsg("Expected single character string for argument '%s'", name);
1355   }
1356 }
1357
1358 static int convert_to_CvMemStorage(PyObject *o, CvMemStorage **dst, const char *name = "no_name")
1359 {
1360   if (PyType_IsSubtype(o->ob_type, &cvmemstorage_Type)) {
1361     (*dst) = (((cvmemstorage_t*)o)->a);
1362     return 1;
1363   } else {
1364     (*dst) = (CvMemStorage*)NULL;
1365     return failmsg("Expected CvMemStorage for argument '%s'", name);
1366   }
1367 }
1368
1369 static int convert_to_CvSeq(PyObject *o, CvSeq **dst, const char *name = "no_name")
1370 {
1371   if (PyType_IsSubtype(o->ob_type, &cvseq_Type)) {
1372     (*dst) = (((cvseq_t*)o)->a);
1373     return 1;
1374   } else {
1375     (*dst) = (CvSeq*)NULL;
1376     return failmsg("Expected CvSeq for argument '%s'", name);
1377   }
1378 }
1379
1380 static int convert_to_CvSize(PyObject *o, CvSize *dst, const char *name = "no_name")
1381 {
1382   if (!PyArg_ParseTuple(o, "ii", &dst->width, &dst->height))
1383     return failmsg("CvSize argument '%s' expects two integers", name);
1384   else
1385     return 1;
1386 }
1387
1388 static int convert_to_CvScalar(PyObject *o, CvScalar *s, const char *name = "no_name")
1389 {
1390   if (PySequence_Check(o)) {
1391     PyObject *fi = PySequence_Fast(o, name);
1392     if (fi == NULL)
1393       return 0;
1394     if (4 < PySequence_Fast_GET_SIZE(fi))
1395         return failmsg("CvScalar value for argument '%s' is longer than 4", name);
1396     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1397       PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1398       if (PyFloat_Check(item) || PyInt_Check(item)) {
1399         s->val[i] = PyFloat_AsDouble(item);
1400       } else {
1401         return failmsg("CvScalar value for argument '%s' is not numeric", name);
1402       }
1403     }
1404     Py_DECREF(fi);
1405   } else {
1406     if (PyFloat_Check(o) || PyInt_Check(o)) {
1407       s->val[0] = PyFloat_AsDouble(o);
1408     } else {
1409       return failmsg("CvScalar value for argument '%s' is not numeric", name);
1410     }
1411   }
1412   return 1;
1413 }
1414
1415 static int convert_to_CvPointPTR(PyObject *o, CvPoint **p, const char *name = "no_name")
1416 {
1417   if (!PySequence_Check(o))
1418     return failmsg("Expected sequence for point list argument '%s'", name);
1419   PyObject *fi = PySequence_Fast(o, name);
1420   if (fi == NULL)
1421     return 0;
1422   *p = new CvPoint[PySequence_Fast_GET_SIZE(fi)];
1423   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1424     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1425     if (!PyTuple_Check(item))
1426       return failmsg("Expected tuple for element in point list argument '%s'", name);
1427     if (!PyArg_ParseTuple(item, "ii", &((*p)[i].x), &((*p)[i].y))) {
1428       return 0;
1429     }
1430   }
1431   Py_DECREF(fi);
1432   return 1;
1433 }
1434
1435 static int convert_to_CvPoint2D32fPTR(PyObject *o, CvPoint2D32f **p, const char *name = "no_name")
1436 {
1437   PyObject *fi = PySequence_Fast(o, name);
1438   if (fi == NULL)
1439     return 0;
1440   *p = new CvPoint2D32f[PySequence_Fast_GET_SIZE(fi)];
1441   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1442     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1443     if (!PyTuple_Check(item))
1444       return failmsg("Expected tuple for CvPoint2D32f argument '%s'", name);
1445     if (!PyArg_ParseTuple(item, "ff", &((*p)[i].x), &((*p)[i].y))) {
1446       return 0;
1447     }
1448   }
1449   Py_DECREF(fi);
1450   return 1;
1451 }
1452
1453 #if 0 // not used
1454 static int convert_to_CvPoint3D32fPTR(PyObject *o, CvPoint3D32f **p, const char *name = "no_name")
1455 {
1456   PyObject *fi = PySequence_Fast(o, name);
1457   if (fi == NULL)
1458     return 0;
1459   *p = new CvPoint3D32f[PySequence_Fast_GET_SIZE(fi)];
1460   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1461     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1462     if (!PyTuple_Check(item))
1463       return failmsg("Expected tuple for CvPoint3D32f argument '%s'", name);
1464     if (!PyArg_ParseTuple(item, "fff", &((*p)[i].x), &((*p)[i].y), &((*p)[i].z))) {
1465       return 0;
1466     }
1467   }
1468   Py_DECREF(fi);
1469   return 1;
1470 }
1471 #endif
1472
1473 static int convert_to_CvStarDetectorParams(PyObject *o, CvStarDetectorParams *dst, const char *name = "no_name")
1474 {
1475   if (!PyArg_ParseTuple(o,
1476                         "iiiii",
1477                         &dst->maxSize,
1478                         &dst->responseThreshold,
1479                         &dst->lineThresholdProjected,
1480                         &dst->lineThresholdBinarized,
1481                         &dst->suppressNonmaxSize))
1482     return failmsg("CvRect argument '%s' expects four integers", name);
1483   else
1484     return 1;
1485 }
1486
1487 static int convert_to_CvRect(PyObject *o, CvRect *dst, const char *name = "no_name")
1488 {
1489   if (!PyArg_ParseTuple(o, "iiii", &dst->x, &dst->y, &dst->width, &dst->height))
1490     return failmsg("CvRect argument '%s' expects four integers", name);
1491   else
1492     return 1;
1493 }
1494
1495 static int convert_to_CvRectPTR(PyObject *o, CvRect **dst, const char *name = "no_name")
1496 {
1497   *dst = new CvRect;
1498   if (!PyArg_ParseTuple(o, "iiii", &(*dst)->x, &(*dst)->y, &(*dst)->width, &(*dst)->height))
1499     return failmsg("CvRect argument '%s' expects four integers", name);
1500   else
1501     return 1;
1502 }
1503
1504 static int convert_to_CvSlice(PyObject *o, CvSlice *dst, const char *name = "no_name")
1505 {
1506   if (!PyArg_ParseTuple(o, "ii", &dst->start_index, &dst->end_index))
1507     return failmsg("CvSlice argument '%s' expects two integers", name);
1508   else
1509     return 1;
1510 }
1511
1512 static int convert_to_CvPoint(PyObject *o, CvPoint *dst, const char *name = "no_name")
1513 {
1514   if (!PyArg_ParseTuple(o, "ii", &dst->x, &dst->y))
1515     return failmsg("CvPoint argument '%s' expects two integers", name);
1516   else
1517     return 1;
1518 }
1519
1520 static int convert_to_CvPoint2D32f(PyObject *o, CvPoint2D32f *dst, const char *name = "no_name")
1521 {
1522   if (!PyArg_ParseTuple(o, "ff", &dst->x, &dst->y))
1523     return failmsg("CvPoint2D32f argument '%s' expects two floats", name);
1524   else
1525     return 1;
1526 }
1527
1528 static int convert_to_CvPoint3D32f(PyObject *o, CvPoint3D32f *dst, const char *name = "no_name")
1529 {
1530   if (!PyArg_ParseTuple(o, "fff", &dst->x, &dst->y, &dst->z))
1531     return failmsg("CvPoint3D32f argument '%s' expects three floats", name);
1532   else
1533     return 1;
1534 }
1535
1536 static int convert_to_IplImage(PyObject *o, IplImage **dst, const char *name)
1537 {
1538   iplimage_t *ipl = (iplimage_t*)o;
1539   void *buffer;
1540   Py_ssize_t buffer_len;
1541
1542   if (!is_iplimage(o)) {
1543     return failmsg("Argument '%s' must be IplImage", name);
1544   } else if (PyString_Check(ipl->data)) {
1545     cvSetData(ipl->a, PyString_AsString(ipl->data) + ipl->offset, ipl->a->widthStep);
1546     assert(cvGetErrStatus() == 0);
1547     *dst = ipl->a;
1548     return 1;
1549   } else if (ipl->data && PyObject_AsWriteBuffer(ipl->data, &buffer, &buffer_len) == 0) {
1550     cvSetData(ipl->a, (void*)((char*)buffer + ipl->offset), ipl->a->widthStep);
1551     assert(cvGetErrStatus() == 0);
1552     *dst = ipl->a;
1553     return 1;
1554   } else {
1555     return failmsg("IplImage argument '%s' has no data", name);
1556   }
1557 }
1558
1559 static int convert_to_CvMat(PyObject *o, CvMat **dst, const char *name)
1560 {
1561   cvmat_t *m = (cvmat_t*)o;
1562   void *buffer;
1563   Py_ssize_t buffer_len;
1564
1565   if (!is_cvmat(o)) {
1566     return failmsg("Argument '%s' must be CvMat", name);
1567   } else {
1568     m->a->refcount = NULL;
1569     if (m->data && PyString_Check(m->data)) {
1570       assert(cvGetErrStatus() == 0);
1571       char *ptr = PyString_AsString(m->data) + m->offset;
1572       cvSetData(m->a, ptr, m->a->step);
1573       assert(cvGetErrStatus() == 0);
1574       *dst = m->a;
1575       return 1;
1576     } else if (m->data && PyObject_AsWriteBuffer(m->data, &buffer, &buffer_len) == 0) {
1577       cvSetData(m->a, (void*)((char*)buffer + m->offset), m->a->step);
1578       assert(cvGetErrStatus() == 0);
1579       *dst = m->a;
1580       return 1;
1581     } else {
1582       return failmsg("CvMat argument '%s' has no data", name);
1583     }
1584   }
1585 }
1586
1587 static int convert_to_CvMatND(PyObject *o, CvMatND **dst, const char *name)
1588 {
1589   cvmatnd_t *m = (cvmatnd_t*)o;
1590   void *buffer;
1591   Py_ssize_t buffer_len;
1592
1593   if (!is_cvmatnd(o)) {
1594     return failmsg("Argument '%s' must be CvMatND", name);
1595   } else if (m->data && PyString_Check(m->data)) {
1596     m->a->data.ptr = ((uchar*)PyString_AsString(m->data)) + m->offset;
1597     *dst = m->a;
1598     return 1;
1599   } else if (m->data && PyObject_AsWriteBuffer(m->data, &buffer, &buffer_len) == 0) {
1600     m->a->data.ptr = ((uchar*)buffer + m->offset);
1601     *dst = m->a;
1602     return 1;
1603   } else {
1604     return failmsg("CvMatND argument '%s' has no data", name);
1605   }
1606 }
1607
1608 static int convert_to_CvArr(PyObject *o, CvArr **dst, const char *name)
1609 {
1610   if (o == Py_None) {
1611     *dst = (void*)NULL;
1612     return 1;
1613   } else if (is_iplimage(o)) {
1614     return convert_to_IplImage(o, (IplImage**)dst, name);
1615   } else if (is_cvmat(o)) {
1616     return convert_to_CvMat(o, (CvMat**)dst, name);
1617   } else if (is_cvmatnd(o)) {
1618     return convert_to_CvMatND(o, (CvMatND**)dst, name);
1619   } else {
1620     return failmsg("CvArr argument '%s' must be IplImage, CvMat or CvMatND", name);
1621   }
1622 }
1623
1624 static int convert_to_CvHistogram(PyObject *o, CvHistogram **dst, const char *name = "no_name")
1625 {
1626   if (PyType_IsSubtype(o->ob_type, &cvhistogram_Type)) {
1627     cvhistogram_t *ht = (cvhistogram_t*)o;
1628     *dst = &ht->h;
1629     return convert_to_CvArr(ht->bins, &(ht->h.bins), "bins");
1630   } else {
1631     *dst = (CvHistogram *)NULL;
1632     return failmsg("Expected CvHistogram for argument '%s'", name);
1633   }
1634 }
1635
1636 // Used by FillPoly, FillConvexPoly, PolyLine
1637 struct pts_npts_contours {
1638   CvPoint** pts;
1639   int* npts;
1640   int contours;
1641 };
1642
1643 static int convert_to_pts_npts_contours(PyObject *o, pts_npts_contours *dst, const char *name = "no_name")
1644 {
1645   PyObject *fi = PySequence_Fast(o, name);
1646   if (fi == NULL)
1647     return 0;
1648   dst->contours = PySequence_Fast_GET_SIZE(fi);
1649   dst->pts = new CvPoint*[dst->contours];
1650   dst->npts = new int[dst->contours];
1651   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1652     if (!convert_to_CvPointPTR(PySequence_Fast_GET_ITEM(fi, i), &dst->pts[i], name))
1653       return 0;
1654     dst->npts[i] = PySequence_Size(PySequence_Fast_GET_ITEM(fi, i)); // safe because convert_ just succeeded
1655   }
1656   Py_DECREF(fi);
1657   return 1;
1658 }
1659
1660 struct cvarrseq {
1661   union {
1662     CvSeq *seq;
1663     CvArr *mat;
1664   };
1665 };
1666
1667 static int convert_to_cvarrseq(PyObject *o, cvarrseq *dst, const char *name = "no_name")
1668 {
1669   if (PyType_IsSubtype(o->ob_type, &cvseq_Type)) {
1670     return convert_to_CvSeq(o, &(dst->seq), name);
1671   } else if (PySequence_Check(o)) {
1672     PyObject *fi = PySequence_Fast(o, name);
1673     if (fi == NULL)
1674       return 0;
1675     Py_ssize_t size = -1;
1676     // Make a pass through the sequence, checking that each element is
1677     // a sequence and that they are all the same size
1678     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1679       PyObject *e = PySequence_Fast_GET_ITEM(fi, i);
1680
1681       if (!PySequence_Check(e))
1682         return failmsg("Sequence '%s' must contain sequences", name);
1683       if (i == 0)
1684         size = (int)PySequence_Size(e);
1685       else if (size != PySequence_Size(e))
1686         return failmsg("All elements of sequence '%s' must be same size", name);
1687     }
1688     assert(size != -1);
1689     CvMat *mt = cvCreateMat((int)PySequence_Fast_GET_SIZE(fi), 1, CV_32SC(size));
1690     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1691       PyObject *e = PySequence_Fast_GET_ITEM(fi, i);
1692       PyObject *fe = PySequence_Fast(e, name);
1693       assert(fe != NULL);
1694       int *pdst = (int*)cvPtr2D(mt, i, 0);
1695       for (Py_ssize_t j = 0; j < size; j++) {
1696         *pdst++ = PyInt_AsLong(PySequence_Fast_GET_ITEM(fe, j));
1697       }
1698       Py_DECREF(fe);
1699     }
1700     Py_DECREF(fi);
1701     dst->mat = mt;
1702     return 1;
1703   } else {
1704     return convert_to_CvArr(o, &(dst->mat), name);
1705   }
1706 }
1707
1708 struct cvarr_count {
1709   CvArr **cvarr;
1710   int count;
1711 };
1712
1713 static int convert_to_cvarr_count(PyObject *o, cvarr_count *dst, const char *name = "no_name")
1714 {
1715   PyObject *fi = PySequence_Fast(o, name);
1716   if (fi == NULL)
1717     return 0;
1718   dst->count = PySequence_Fast_GET_SIZE(fi);
1719   dst->cvarr = new CvArr*[dst->count];
1720   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1721     if (!convert_to_CvArr(PySequence_Fast_GET_ITEM(fi, i), &dst->cvarr[i], name))
1722       return 0;
1723   }
1724   Py_DECREF(fi);
1725   return 1;
1726 }
1727
1728 struct intpair
1729 {
1730   int *pairs;
1731   int count;
1732 };
1733
1734 static int convert_to_intpair(PyObject *o, intpair *dst, const char *name = "no_name")
1735 {
1736   PyObject *fi = PySequence_Fast(o, name);
1737   if (fi == NULL)
1738     return 0;
1739   dst->count = PySequence_Fast_GET_SIZE(fi);
1740   dst->pairs = new int[2 * dst->count];
1741   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1742     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1743     if (!PyArg_ParseTuple(item, "ii", &dst->pairs[2 * i], &dst->pairs[2 * i + 1])) {
1744       return 0;
1745     }
1746   }
1747   Py_DECREF(fi);
1748   return 1;
1749 }
1750
1751 struct cvpoint2d32f_count {
1752   CvPoint2D32f* points;
1753   int count;
1754 };
1755
1756 static int convert_to_cvpoint2d32f_count(PyObject *o, cvpoint2d32f_count *dst, const char *name = "no_name")
1757 {
1758   if (PyInt_Check(o)) {
1759     dst->count = PyInt_AsLong(o);
1760     dst->points = new CvPoint2D32f[dst->count];
1761     return 1;
1762   } else {
1763     return failmsg("Expected integer for CvPoint2D32f count");
1764   }
1765 }
1766
1767 struct floats {
1768   float *f;
1769   int count;
1770 };
1771 static int convert_to_floats(PyObject *o, floats *dst, const char *name = "no_name")
1772 {
1773   PyObject *fi = PySequence_Fast(o, name);
1774   if (fi == NULL)
1775     return 0;
1776   dst->count = PySequence_Fast_GET_SIZE(fi);
1777   dst->f = new float[dst->count];
1778   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1779     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1780     dst->f[i] = (float)PyFloat_AsDouble(item);
1781   }
1782   Py_DECREF(fi);
1783   return 1;
1784 }
1785
1786 struct chars {
1787   char *f;
1788   int count;
1789 };
1790 /// convert_to_chars not used
1791
1792 struct CvPoints {
1793   CvPoint *p;
1794   int count;
1795 };
1796 static int convert_to_CvPoints(PyObject *o, CvPoints *dst, const char *name = "no_name")
1797 {
1798   PyObject *fi = PySequence_Fast(o, name);
1799   if (fi == NULL)
1800     return 0;
1801   dst->count = PySequence_Fast_GET_SIZE(fi);
1802   dst->p = new CvPoint[dst->count];
1803   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1804     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1805     convert_to_CvPoint(item, &dst->p[i], name);
1806   }
1807   Py_DECREF(fi);
1808   return 1;
1809 }
1810
1811 struct CvPoint3D32fs {
1812   CvPoint3D32f *p;
1813   int count;
1814 };
1815 static int convert_to_CvPoint3D32fs(PyObject *o, CvPoint3D32fs *dst, const char *name = "no_name")
1816 {
1817   PyObject *fi = PySequence_Fast(o, name);
1818   if (fi == NULL)
1819     return 0;
1820   dst->count = PySequence_Fast_GET_SIZE(fi);
1821   dst->p = new CvPoint3D32f[dst->count];
1822   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1823     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1824     convert_to_CvPoint3D32f(item, &dst->p[i], name);
1825   }
1826   Py_DECREF(fi);
1827   return 1;
1828 }
1829
1830 struct CvPoint2D32fs {
1831   CvPoint2D32f *p;
1832   int count;
1833 };
1834 static int convert_to_CvPoint2D32fs(PyObject *o, CvPoint2D32fs *dst, const char *name = "no_name")
1835 {
1836   PyObject *fi = PySequence_Fast(o, name);
1837   if (fi == NULL)
1838     return 0;
1839   dst->count = PySequence_Fast_GET_SIZE(fi);
1840   dst->p = new CvPoint2D32f[dst->count];
1841   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1842     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1843     convert_to_CvPoint2D32f(item, &dst->p[i], name);
1844   }
1845   Py_DECREF(fi);
1846   return 1;
1847 }
1848
1849 struct ints {
1850   int *i;
1851   int count;
1852 };
1853 static int convert_to_ints(PyObject *o, ints *dst, const char *name = "no_name")
1854 {
1855   PyObject *fi = PySequence_Fast(o, name);
1856   if (fi == NULL)
1857     return 0;
1858   dst->count = PySequence_Fast_GET_SIZE(fi);
1859   dst->i = new int[dst->count];
1860   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1861     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1862     dst->i[i] = PyInt_AsLong(item);
1863   }
1864   Py_DECREF(fi);
1865   return 1;
1866 }
1867
1868 struct ints0 {
1869   int *i;
1870   int count;
1871 };
1872 static int convert_to_ints0(PyObject *o, ints0 *dst, const char *name = "no_name")
1873 {
1874   PyObject *fi = PySequence_Fast(o, name);
1875   if (fi == NULL)
1876     return 0;
1877   dst->count = PySequence_Fast_GET_SIZE(fi);
1878   dst->i = new int[dst->count + 1];
1879   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1880     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1881     dst->i[i] = PyInt_AsLong(item);
1882   }
1883   dst->i[dst->count] = 0;
1884   Py_DECREF(fi);
1885   return 1;
1886 }
1887
1888 struct dims
1889 {
1890   int count;
1891   int i[CV_MAX_DIM];
1892   int step[CV_MAX_DIM];
1893   int length[CV_MAX_DIM];
1894 };
1895
1896 static int convert_to_dim(PyObject *item, int i, dims *dst, CvArr *cva, const char *name = "no_name")
1897 {
1898   if (PySlice_Check(item)) {
1899     Py_ssize_t start, stop, step, slicelength;
1900     PySlice_GetIndicesEx((PySliceObject*)item, cvGetDimSize(cva, i), &start, &stop, &step, &slicelength);
1901     dst->i[i] = start;
1902     dst->step[i] = step;
1903     dst->length[i] = slicelength;
1904   } else {
1905     int index = PyInt_AsLong(item);
1906     if (0 <= index)
1907       dst->i[i] = index;
1908     else
1909       dst->i[i] = cvGetDimSize(cva, i) + index;
1910     dst->step[i] = 0;
1911     dst->length[i] = 1;
1912   }
1913   return 1;
1914 }
1915
1916 static int convert_to_dims(PyObject *o, dims *dst, CvArr *cva, const char *name = "no_name")
1917 {
1918   if (!PyTuple_Check(o)) {
1919     dst->count = 1;
1920     return convert_to_dim(o, 0, dst, cva, name);
1921   } else {
1922     PyObject *fi = PySequence_Fast(o, name);
1923     if (fi == NULL) {
1924       PyErr_SetString(PyExc_TypeError, "Expected tuple for index");
1925       return 0;
1926     }
1927     dst->count = PySequence_Fast_GET_SIZE(fi);
1928     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1929       if (i >= cvGetDims(cva)) {
1930         return failmsg("Access specifies %d dimensions, but array only has %d", PySequence_Fast_GET_SIZE(fi), cvGetDims(cva));
1931       }
1932       PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1933       if (!convert_to_dim(item, i, dst, cva, name))
1934         return 0;
1935     }
1936     Py_DECREF(fi);
1937     return 1;
1938   }
1939 }
1940
1941 struct IplImages {
1942   IplImage **ims;
1943   int count;
1944 };
1945 static int convert_to_IplImages(PyObject *o, IplImages *dst, const char *name = "no_name")
1946 {
1947   PyObject *fi = PySequence_Fast(o, name);
1948   if (fi == NULL)
1949     return 0;
1950   dst->count = PySequence_Fast_GET_SIZE(fi);
1951   dst->ims = new IplImage*[dst->count];
1952   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1953     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1954     if (!convert_to_IplImage(item, &dst->ims[i]))
1955       return 0;
1956   }
1957   Py_DECREF(fi);
1958   return 1;
1959 }
1960
1961 struct CvArrs {
1962   CvArr **ims;
1963   int count;
1964 };
1965 static int convert_to_CvArrs(PyObject *o, CvArrs *dst, const char *name = "no_name")
1966 {
1967   PyObject *fi = PySequence_Fast(o, name);
1968   if (fi == NULL)
1969     return 0;
1970   dst->count = PySequence_Fast_GET_SIZE(fi);
1971   dst->ims = new CvArr*[dst->count];
1972   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1973     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1974     if (!convert_to_CvArr(item, &dst->ims[i]))
1975       return 0;
1976   }
1977   Py_DECREF(fi);
1978   return 1;
1979 }
1980
1981 static int convert_to_floatPTRPTR(PyObject *o, float*** dst, const char *name = "no_name")
1982 {
1983   PyObject *fi = PySequence_Fast(o, name);
1984   if (fi == NULL)
1985     return 0;
1986   Py_ssize_t sz = PySequence_Fast_GET_SIZE(fi);
1987   float **r = new float*[sz];
1988   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
1989     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
1990     floats ff;
1991     if (!convert_to_floats(item, &ff))
1992       return 0;
1993     r[i] = ff.f;
1994   }
1995   *dst = r;
1996   return 1;
1997 }
1998
1999 static int convert_to_CvMomentsPTR(PyObject *o, CvMoments** dst, const char *name = "no_name")
2000 {
2001   if (PyType_IsSubtype(o->ob_type, &cvmoments_Type)) {
2002     (*dst) = &(((cvmoments_t*)o)->a);
2003     return 1;
2004   } else {
2005     (*dst) = (CvMoments*)NULL;
2006     return failmsg("Expected CvMoments for argument '%s'", name);
2007   }
2008 }
2009
2010 static int convert_to_CvFontPTR(PyObject *o, CvFont** dst, const char *name = "no_name")
2011 {
2012   if (PyType_IsSubtype(o->ob_type, &cvfont_Type)) {
2013     (*dst) = &(((cvfont_t*)o)->a);
2014     return 1;
2015   } else {
2016     (*dst) = (CvFont*)NULL;
2017     return failmsg("Expected CvFont for argument '%s'", name);
2018   }
2019 }
2020
2021 static int convert_to_CvHaarClassifierCascadePTR(PyObject *o, CvHaarClassifierCascade** dst, const char *name = "no_name")
2022 {
2023   if (PyType_IsSubtype(o->ob_type, &cvhaarclassifiercascade_Type)) {
2024     (*dst) = ((cvhaarclassifiercascade_t*)o)->a;
2025     return 1;
2026   } else {
2027     (*dst) = (CvHaarClassifierCascade*)NULL;
2028     return failmsg("Expected CvHaarClassifierCascade for argument '%s'", name);
2029   }
2030 }
2031
2032 static int convert_to_CvContourTreePTR(PyObject *o, CvContourTree** dst, const char *name = "no_name")
2033 {
2034   if (PyType_IsSubtype(o->ob_type, &cvcontourtree_Type)) {
2035     (*dst) = ((cvcontourtree_t*)o)->a;
2036     return 1;
2037   } else {
2038     (*dst) = NULL;
2039     return failmsg("Expected CvContourTree for argument '%s'", name);
2040   }
2041 }
2042
2043 static int convert_to_CvRNGPTR(PyObject *o, CvRNG** dst, const char *name = "no_name")
2044 {
2045   if (PyType_IsSubtype(o->ob_type, &cvrng_Type)) {
2046     (*dst) = &(((cvrng_t*)o)->a);
2047     return 1;
2048   } else {
2049     (*dst) = (CvRNG*)NULL;
2050     return failmsg("Expected CvRNG for argument '%s'", name);
2051   }
2052 }
2053
2054 typedef void* generic;
2055 static int convert_to_generic(PyObject *o, generic *dst, const char *name = "no_name")
2056 {
2057   if (PyType_IsSubtype(o->ob_type, &iplimage_Type))
2058     return convert_to_IplImage(o, (IplImage**)dst, name);
2059   else if (PyType_IsSubtype(o->ob_type, &cvmat_Type))
2060     return convert_to_CvMat(o, (CvMat**)dst, name);
2061   else if (PyType_IsSubtype(o->ob_type, &cvmatnd_Type))
2062     return convert_to_CvMatND(o, (CvMatND**)dst, name);
2063   else {
2064     return failmsg("Cannot identify type of '%s'", name);
2065   }
2066 }
2067
2068 static int convert_to_CvTermCriteria(PyObject *o, CvTermCriteria* dst, const char *name = "no_name")
2069 {
2070   if (!PyArg_ParseTuple(o, "iid", &dst->type, &dst->max_iter, &dst->epsilon))
2071     return 0;
2072   return 1;
2073 }
2074
2075 static int convert_to_CvBox2D(PyObject *o, CvBox2D* dst, const char *name = "no_name")
2076 {
2077   if (!PyArg_ParseTuple(o, "(ff)(ff)f", &dst->center.x, &dst->center.y, &dst->size.width, &dst->size.height, &dst->angle))
2078     return 0;
2079   return 1;
2080 }
2081
2082 static int convert_to_CvSubdiv2DPTR(PyObject *o, CvSubdiv2D** dst, const char *name = "no_name")
2083 {
2084   if (PyType_IsSubtype(o->ob_type, &cvsubdiv2d_Type)) {
2085     (*dst) = (((cvsubdiv2d_t*)o)->a);
2086     return 1;
2087   } else {
2088     (*dst) = (CvSubdiv2D*)NULL;
2089     return failmsg("Expected CvSubdiv2D for argument '%s'", name);
2090   }
2091 }
2092
2093 static int convert_to_CvNextEdgeType(PyObject *o, CvNextEdgeType *dst, const char *name = "no_name")
2094 {
2095   if (!PyInt_Check(o)) {
2096     *dst = (CvNextEdgeType)NULL;
2097     return failmsg("Expected number for CvNextEdgeType argument '%s'", name);
2098   } else {
2099     *dst = (CvNextEdgeType)PyInt_AsLong(o);
2100     return 1;
2101   }
2102 }
2103
2104 static int convert_to_CvSubdiv2DEdge(PyObject *o, CvSubdiv2DEdge *dst, const char *name = "no_name")
2105 {
2106   if (PyType_IsSubtype(o->ob_type, &cvsubdiv2dedge_Type)) {
2107     (*dst) = (((cvsubdiv2dedge_t*)o)->a);
2108     return 1;
2109   } else {
2110     *dst = 0L;
2111     return failmsg("Expected CvSubdiv2DEdge for argument '%s'", name);
2112   }
2113 }
2114
2115 /************************************************************************/
2116
2117 static PyObject *pythonize_CvMat(cvmat_t *m)
2118 {
2119   // Need to make this CvMat look like any other, with a Python
2120   // buffer object as its data.
2121   // So copy the image data into a Python string object, then release
2122   // the original.
2123   CvMat *mat = m->a;
2124   assert(mat->step != 0);
2125 #if 0
2126   PyObject *data = PyString_FromStringAndSize((char*)(mat->data.ptr), mat->rows * mat->step);
2127 #else
2128   memtrack_t *o = PyObject_NEW(memtrack_t, &memtrack_Type);
2129   size_t gap = mat->data.ptr - (uchar*)mat->refcount;
2130   o->ptr = mat->refcount;
2131   o->size = gap + mat->rows * mat->step;
2132   PyObject *data = PyBuffer_FromReadWriteObject((PyObject*)o, (size_t)gap, mat->rows * mat->step);
2133   if (data == NULL)
2134     return NULL;
2135 #endif
2136   m->data = data;
2137   m->offset = 0;
2138   Py_DECREF(o);
2139
2140   // Now m has a reference to data, which has a reference to o.
2141
2142   return (PyObject*)m;
2143 }
2144
2145 static PyObject *pythonize_IplImage(iplimage_t *cva)
2146 {
2147   // Need to make this iplimage look like any other, with a Python
2148   // string as its data.
2149   // So copy the image data into a Python string object, then release
2150   // it.
2151
2152   IplImage *ipl = (IplImage*)(cva->a);
2153   // PyObject *data = PyString_FromStringAndSize(ipl->imageData, ipl->imageSize);
2154
2155   memtrack_t *o = PyObject_NEW(memtrack_t, &memtrack_Type);
2156   assert(ipl->imageDataOrigin == ipl->imageData);
2157   o->ptr = ipl->imageDataOrigin;
2158   o->size = ipl->height * ipl->widthStep;
2159   PyObject *data = PyBuffer_FromReadWriteObject((PyObject*)o, (size_t)0, o->size);
2160   if (data == NULL)
2161     return NULL;
2162   Py_DECREF(o);
2163   cva->data = data;
2164   cva->offset = 0;
2165
2166   return (PyObject*)cva;
2167 }
2168
2169 static PyObject *pythonize_CvMatND(cvmatnd_t *m)
2170 {
2171   //
2172   // Need to make this CvMatND look like any other, with a Python
2173   // string as its data.
2174   // So copy the image data into a Python string object, then release
2175   // it.
2176   //
2177
2178   CvMatND *mat = m->a;
2179   assert(mat->dim[0].step != 0);
2180 #if 0
2181   PyObject *data = PyString_FromStringAndSize((char*)(mat->data.ptr), mat->dim[0].size * mat->dim[0].step);
2182 #else
2183   memtrack_t *o = PyObject_NEW(memtrack_t, &memtrack_Type);
2184   o->ptr = cvPtr1D(mat, 0);
2185   o->size = cvmatnd_size(mat);
2186   PyObject *data = PyBuffer_FromReadWriteObject((PyObject*)o, (size_t)0, o->size);
2187   if (data == NULL)
2188     return NULL;
2189 #endif
2190   m->data = data;
2191   m->offset = 0;
2192   // cvDecRefData(mat); // Ref count should be zero here, so this is a release
2193
2194   return (PyObject*)m;
2195 }
2196
2197 /************************************************************************/
2198 /* FROM_xxx:   C -> Python converters.
2199  *
2200  * Turn various OpenCV types (and some aggregate types above)
2201  * into Python objects.  Used by the generated code.
2202  *
2203  * All these functions and macros return a new reference.
2204  */
2205
2206 #define FROM_double(r)  PyFloat_FromDouble(r)
2207 #define FROM_float(r)  PyFloat_FromDouble(r)
2208 #define FROM_int(r)  PyInt_FromLong(r)
2209 #define FROM_int64(r)  PyLong_FromLongLong(r)
2210 #define FROM_unsigned(r)  PyLong_FromUnsignedLong(r)
2211 #define FROM_CvBox2D(r) Py_BuildValue("(ff)(ff)f", r.center.x, r.center.y, r.size.width, r.size.height, r.angle)
2212 #define FROM_CvScalar(r)  Py_BuildValue("(ffff)", r.val[0], r.val[1], r.val[2], r.val[3])
2213 #define FROM_CvPoint(r)  Py_BuildValue("(ii)", r.x, r.y)
2214 #define FROM_CvConnectedComp(r) Py_BuildValue("(fNN)", r.area, FROM_CvScalar(r.value), FROM_CvRect(r.rect))
2215 #define FROM_CvPoint2D32f(r) Py_BuildValue("(ff)", r.x, r.y)
2216 #define FROM_CvSize(r) Py_BuildValue("(ii)", r.width, r.height)
2217 #define FROM_CvRect(r) Py_BuildValue("(iiii)", r.x, r.y, r.width, r.height)
2218 #define FROM_CvSeqPTR(r) _FROM_CvSeqPTR(r, pyobj_storage)
2219 #define FROM_CvSubdiv2DPTR(r) _FROM_CvSubdiv2DPTR(r, pyobj_storage)
2220 #define FROM_CvPoint2D64f(r) Py_BuildValue("(ff)", r.x, r.y)
2221
2222 static PyObject *_FROM_CvSeqPTR(CvSeq *s, PyObject *storage)
2223 {
2224   cvseq_t *ps = PyObject_NEW(cvseq_t, &cvseq_Type);
2225   ps->a = s;
2226   ps->container = storage;
2227   Py_INCREF(ps->container);
2228   return (PyObject*)ps;
2229 }
2230
2231 static PyObject *_FROM_CvSubdiv2DPTR(CvSubdiv2D *s, PyObject *storage)
2232 {
2233   cvsubdiv2d_t *ps = PyObject_NEW(cvsubdiv2d_t, &cvsubdiv2d_Type);
2234   ps->a = s;
2235   ps->container = storage;
2236   Py_INCREF(ps->container);
2237   return (PyObject*)ps;
2238 }
2239
2240 static PyObject *FROM_floats(floats r)
2241 {
2242   PyObject *pr;
2243
2244   pr = PyList_New(r.count);
2245   for (Py_ssize_t i = 0; i < (Py_ssize_t)r.count; i++) {
2246     PyList_SetItem(pr, i, PyFloat_FromDouble(r.f[i]));
2247   }
2248   return pr;
2249 }
2250
2251 static PyObject *FROM_chars(chars r)
2252 {
2253   PyObject *pr;
2254
2255   pr = PyList_New(r.count);
2256   for (Py_ssize_t i = 0; i < (Py_ssize_t)r.count; i++) {
2257     PyList_SetItem(pr, i, PyInt_FromLong(r.f[i]));
2258   }
2259   return pr;
2260 }
2261
2262 static PyObject *FROM_cvpoint2d32f_count(cvpoint2d32f_count r)
2263 {
2264   PyObject *pr;
2265
2266   pr = PyList_New(r.count);
2267   for (Py_ssize_t i = 0; i < (Py_ssize_t)r.count; i++) {
2268     PyList_SetItem(pr, i, FROM_CvPoint2D32f(r.points[i]));
2269   }
2270   return pr;
2271 }
2272
2273 static PyObject *FROM_CvPoint2D32fs(CvPoint2D32fs r)
2274 {
2275   PyObject *pr;
2276
2277   pr = PyList_New(r.count);
2278   for (Py_ssize_t i = 0; i < (Py_ssize_t)r.count; i++) {
2279     PyList_SetItem(pr, i, FROM_CvPoint2D32f(r.p[i]));
2280   }
2281   return pr;
2282 }
2283
2284 typedef CvSeq CvSeqOfCvConvexityDefect;
2285 static PyObject *FROM_CvSeqOfCvConvexityDefectPTR(CvSeqOfCvConvexityDefect *r)
2286 {
2287   PyObject *pr;
2288   pr = PyList_New(r->total);
2289   for (int i = 0; i < r->total; i++) {
2290     CvConvexityDefect *pd = CV_GET_SEQ_ELEM(CvConvexityDefect, r, i);
2291     PyList_SetItem(pr, i, Py_BuildValue("(ii)(ii)(ii)f",
2292                                         pd->start->x, pd->start->y,
2293                                         pd->end->x, pd->end->y,
2294                                         pd->depth_point->x, pd->depth_point->y,
2295                                         pd->depth));
2296   }
2297   // This function has copied the CvSeq data into a list.  Hence the
2298   // CvSeq is not being returned to the caller.  Hence, no reference
2299   // count increase for the storage, unlike _FROM_CvSeqPTR.
2300   return pr;
2301 }
2302
2303 typedef CvSeq CvSeqOfCvAvgComp;
2304 static PyObject *FROM_CvSeqOfCvAvgCompPTR(CvSeqOfCvAvgComp *r)
2305 {
2306   PyObject *pr;
2307   pr = PyList_New(r->total);
2308   for (int i = 0; i < r->total; i++) {
2309     CvAvgComp *pd = CV_GET_SEQ_ELEM(CvAvgComp, r, i);
2310     PyList_SetItem(pr, i, Py_BuildValue("(iiii)i",
2311                                         pd->rect.x, pd->rect.y,
2312                                         pd->rect.width, pd->rect.height,
2313                                         pd->neighbors));
2314   }
2315   // This function has copied the CvSeq data into a list.  Hence the
2316   // CvSeq is not being returned to the caller.  Hence, no reference
2317   // count increase for the storage, unlike _FROM_CvSeqPTR.
2318   return pr;
2319 }
2320
2321 typedef CvSeq CvSeqOfCvStarKeypoint;
2322 static PyObject *FROM_CvSeqOfCvStarKeypointPTR(CvSeqOfCvStarKeypoint *r)
2323 {
2324   PyObject *pr;
2325   pr = PyList_New(r->total);
2326   for (int i = 0; i < r->total; i++) {
2327     CvStarKeypoint *pd = CV_GET_SEQ_ELEM(CvStarKeypoint, r, i);
2328     PyList_SetItem(pr, i, Py_BuildValue("(ii)if",
2329                                         pd->pt.x, pd->pt.y,
2330                                         pd->size,
2331                                         pd->response));
2332   }
2333   // This function has copied the CvSeq data into a list.  Hence the
2334   // CvSeq is not being returned to the caller.  Hence, no reference
2335   // count increase for the storage, unlike _FROM_CvSeqPTR.
2336   return pr;
2337 }
2338
2339 typedef CvSeq CvSeqOfCvSURFPoint;
2340 static PyObject *FROM_CvSeqOfCvSURFPointPTR(CvSeqOfCvSURFPoint *r)
2341 {
2342   PyObject *pr;
2343   pr = PyList_New(r->total);
2344   for (int i = 0; i < r->total; i++) {
2345     CvSURFPoint *pd = CV_GET_SEQ_ELEM(CvSURFPoint, r, i);
2346     PyList_SetItem(pr, i, Py_BuildValue("(ff)iiff",
2347                                         pd->pt.x, pd->pt.y,
2348                                         pd->laplacian,
2349                                         pd->size,
2350                                         pd->dir,
2351                                         pd->hessian));
2352   }
2353   // This function has copied the CvSeq data into a list.  Hence the
2354   // CvSeq is not being returned to the caller.  Hence, no reference
2355   // count increase for the storage, unlike _FROM_CvSeqPTR.
2356   return pr;
2357 }
2358
2359 typedef CvSeq CvSeqOfCvSURFDescriptor;
2360 static PyObject *FROM_CvSeqOfCvSURFDescriptorPTR(CvSeqOfCvSURFDescriptor *r)
2361 {
2362   PyObject *pr;
2363   pr = PyList_New(r->total);
2364   for (int i = 0; i < r->total; i++) {
2365     float *pd = (float*)cvGetSeqElem(r, i);
2366     int count = r->elem_size / sizeof(float);
2367     PyObject *oi = PyList_New(count);
2368     for (int j = 0; j < count; j++) {
2369       PyList_SetItem(oi, j, PyFloat_FromDouble(pd[j]));
2370     }
2371     PyList_SetItem(pr, i, oi);
2372   }
2373   // This function has copied the CvSeq data into a list.  Hence the
2374   // CvSeq is not being returned to the caller.  Hence, no reference
2375   // count increase for the storage, unlike _FROM_CvSeqPTR.
2376   return pr;
2377 }
2378
2379 typedef CvPoint2D32f CvPoint2D32f_4[4];
2380 static PyObject *FROM_CvPoint2D32f_4(CvPoint2D32f* r)
2381 {
2382   return Py_BuildValue("(ff)(ff)(ff)(ff)",
2383                        r[0].x, r[0].y,
2384                        r[1].x, r[1].y,
2385                        r[2].x, r[2].y,
2386                        r[3].x, r[3].y);
2387 }
2388
2389 typedef float CvMatr32f_i[9];
2390
2391 static PyObject *FROM_CvMatr32f_i(CvMatr32f_i r)
2392 {
2393   return Py_BuildValue("(fff)(fff)(fff)",
2394     r[0], r[1], r[2],
2395     r[3], r[4], r[5],
2396     r[6], r[7], r[8]);
2397 }
2398
2399 typedef float CvVect32f_i[3];
2400 static PyObject *FROM_CvVect32f_i(CvVect32f_i r)
2401 {
2402   return Py_BuildValue("fff",
2403     r[0], r[1], r[2]);
2404 }
2405
2406 static PyObject *FROM_CvFont(CvFont r)
2407 {
2408   cvfont_t *cf = PyObject_NEW(cvfont_t, &cvfont_Type);
2409   cf->a = r;
2410   return (PyObject*)cf;
2411 }
2412
2413 static PyObject *FROM_CvSubdiv2DPointPTR(CvSubdiv2DPoint* r)
2414 {
2415   if (r != NULL) {
2416     cvsubdiv2dpoint_t *cf = PyObject_NEW(cvsubdiv2dpoint_t, &cvsubdiv2dpoint_Type);
2417     cf->a = r;
2418     return (PyObject*)cf;
2419   } else {
2420     Py_INCREF(Py_None);
2421     return Py_None;
2422   }
2423 }
2424
2425 static PyObject *FROM_IplImagePTR(IplImage *r)
2426 {
2427   iplimage_t *cva = PyObject_NEW(iplimage_t, &iplimage_Type);
2428   cva->a = r;
2429   return pythonize_IplImage(cva);
2430 }
2431
2432 static PyObject *FROM_ROIplImagePTR(ROIplImage *r)
2433 {
2434   if (r != NULL) {
2435     iplimage_t *cva = PyObject_NEW(iplimage_t, &iplimage_Type);
2436     cva->a = cvCreateImageHeader(cvSize(100,100), 8, 1);
2437     *(cva->a) = *r;
2438     cva->data = PyBuffer_FromReadWriteMemory(r->imageData, r->height * r->widthStep);
2439     cva->offset = 0;
2440     return (PyObject*)cva;
2441   } else {
2442     Py_RETURN_NONE;
2443   }
2444 }
2445
2446 static PyObject *FROM_CvMatPTR(CvMat *r)
2447 {
2448   cvmat_t *cvm = PyObject_NEW(cvmat_t, &cvmat_Type);
2449   cvm->a = r;
2450
2451   return pythonize_CvMat(cvm);
2452 }
2453
2454 static PyObject *FROM_CvMat(CvMat *r)
2455 {
2456   cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
2457   m->a = r;
2458   return pythonize_CvMat(m);
2459 }
2460
2461 static PyObject *FROM_CvMatNDPTR(CvMatND *r)
2462 {
2463   cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
2464   m->a = r;
2465   return pythonize_CvMatND(m);
2466 }
2467
2468 static PyObject *FROM_CvRNG(CvRNG r)
2469 {
2470   cvrng_t *m = PyObject_NEW(cvrng_t, &cvrng_Type);
2471   m->a = r;
2472   return (PyObject*)m;
2473 }
2474
2475 static PyObject *FROM_CvHaarClassifierCascade(CvHaarClassifierCascade *r)
2476 {
2477   cvhaarclassifiercascade_t *m = PyObject_NEW(cvhaarclassifiercascade_t, &cvhaarclassifiercascade_Type);
2478   m->a = r;
2479   return (PyObject*)m;
2480 }
2481
2482 static PyObject *FROM_CvMoments(CvMoments r)
2483 {
2484   cvmoments_t *m = PyObject_NEW(cvmoments_t, &cvmoments_Type);
2485   m->a = r;
2486   return (PyObject*)m;
2487 }
2488
2489 static PyObject *FROM_CvContourTreePTR(CvContourTree *r)
2490 {
2491   cvcontourtree_t *m = PyObject_NEW(cvcontourtree_t, &cvcontourtree_Type);
2492   m->a = r;
2493   return (PyObject*)m;
2494 }
2495
2496 static PyObject *FROM_generic(generic r)
2497 {
2498   CvTypeInfo* t = cvTypeOf(r);
2499   if (r == NULL) {
2500     failmsg("OpenCV returned NULL");
2501     return NULL;
2502   } if (strcmp(t->type_name, "opencv-image") == 0)
2503     return FROM_IplImagePTR((IplImage*)r);
2504   else if (strcmp(t->type_name, "opencv-matrix") == 0)
2505     return FROM_CvMat((CvMat*)r);
2506   else if (strcmp(t->type_name, "opencv-haar-classifier") == 0)
2507     return FROM_CvHaarClassifierCascade((CvHaarClassifierCascade*)r);
2508   else {
2509     failmsg("Unknown OpenCV type '%s'", t->type_name);
2510     return NULL;
2511   }
2512 }
2513
2514 static PyObject *FROM_CvSubdiv2DEdge(CvSubdiv2DEdge r)
2515 {
2516   cvsubdiv2dedge_t *m = PyObject_NEW(cvsubdiv2dedge_t, &cvsubdiv2dedge_Type);
2517   m->a = r;
2518   m->container = Py_None; // XXX
2519   Py_INCREF(m->container);
2520   return (PyObject*)m;
2521 }
2522
2523 /************************************************************************/
2524
2525 /* A few functions are too odd to be generated,
2526  * so are handwritten here */
2527
2528 static PyObject *pycvWaitKey(PyObject *self, PyObject *args, PyObject *kw)
2529 {
2530   int delay = 0;
2531
2532   const char *keywords[] = { "delay", NULL };
2533   if (!PyArg_ParseTupleAndKeywords(args, kw, "|i", (char**)keywords, &delay))
2534     return NULL;
2535   int r;
2536   Py_BEGIN_ALLOW_THREADS
2537   r = cvWaitKey(delay);
2538   Py_END_ALLOW_THREADS
2539   return FROM_int(r);
2540 }
2541
2542 static PyObject *pycvLoadImage(PyObject *self, PyObject *args, PyObject *kw)
2543 {
2544   const char *keywords[] = { "filename", "iscolor", NULL };
2545   char *filename;
2546   int iscolor = CV_LOAD_IMAGE_COLOR;
2547
2548   if (!PyArg_ParseTupleAndKeywords(args, kw, "s|i", (char**)keywords, &filename, &iscolor))
2549     return NULL;
2550
2551   // Inside ALLOW_THREADS, must not reference 'filename' because it might move.
2552   // So make a local copy 'filename_copy'.
2553   char filename_copy[2048];
2554   strncpy(filename_copy, filename, sizeof(filename_copy));
2555
2556   IplImage *r;
2557   Py_BEGIN_ALLOW_THREADS
2558   r = cvLoadImage(filename_copy, iscolor);
2559   Py_END_ALLOW_THREADS
2560
2561   if (r == NULL) {
2562     PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
2563     return NULL;
2564   } else {
2565     return FROM_IplImagePTR(r);
2566   }
2567 }
2568
2569 static PyObject *pycvCreateImageHeader(PyObject *self, PyObject *args)
2570 {
2571   int w, h, depth, channels;
2572   if (!PyArg_ParseTuple(args, "(ii)Ii", &w, &h, &depth, &channels))
2573     return NULL;
2574   iplimage_t *cva = PyObject_NEW(iplimage_t, &iplimage_Type);
2575   cva->a = cvCreateImageHeader(cvSize(w, h), depth, channels);
2576   if (cva->a == NULL) {
2577     PyErr_SetString(PyExc_TypeError, "CreateImage failed");
2578     return NULL;
2579   } else {
2580     cva->data = Py_None;
2581     Py_INCREF(cva->data);
2582     cva->offset = 0;
2583
2584     return (PyObject*)cva;
2585   }
2586 }
2587
2588 static PyObject *pycvCreateImage(PyObject *self, PyObject *args)
2589 {
2590   int w, h, depth, channels;
2591   if (!PyArg_ParseTuple(args, "(ii)Ii:CreateImage", &w, &h, &depth, &channels))
2592     return NULL;
2593   iplimage_t *cva = PyObject_NEW(iplimage_t, &iplimage_Type);
2594   ERRWRAP(cva->a = cvCreateImage(cvSize(w, h), depth, channels));
2595   if (cva->a == NULL) {
2596     PyErr_SetString(PyExc_TypeError, "CreateImage failed");
2597     return NULL;
2598   } else {
2599     return pythonize_IplImage(cva);
2600   }
2601 }
2602
2603 static PyObject *pycvCreateMatHeader(PyObject *self, PyObject *args)
2604 {
2605   int rows, cols, type;
2606   if (!PyArg_ParseTuple(args, "iii", &rows, &cols, &type))
2607     return NULL;
2608   cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
2609   ERRWRAP(m->a = cvCreateMatHeader(rows, cols, type));
2610   if (m->a == NULL) {
2611     PyErr_SetString(PyExc_TypeError, "CreateMat failed");
2612     return NULL;
2613   } else {
2614     m->data = Py_None;
2615     Py_INCREF(m->data);
2616     m->offset = 0;
2617     return (PyObject*)m;
2618   }
2619 }
2620
2621 static PyObject *pycvCreateMat(PyObject *self, PyObject *args)
2622 {
2623   int rows, cols, type;
2624   if (!PyArg_ParseTuple(args, "iii", &rows, &cols, &type))
2625     return NULL;
2626   cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
2627   ERRWRAP(m->a = cvCreateMat(rows, cols, type));
2628   if (m->a == NULL) {
2629     PyErr_SetString(PyExc_TypeError, "CreateMat failed");
2630     return NULL;
2631   } else {
2632     return pythonize_CvMat(m);
2633   }
2634 }
2635
2636 static PyObject *pycvCreateMatNDHeader(PyObject *self, PyObject *args)
2637 {
2638   ints dims;
2639   int type;
2640
2641   if (!PyArg_ParseTuple(args, "O&i", convert_to_ints, (void*)&dims, &type))
2642     return NULL;
2643   cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
2644   ERRWRAP(m->a = cvCreateMatNDHeader(dims.count, dims.i, type));
2645
2646   m->data = Py_None;
2647   Py_INCREF(m->data);
2648   return (PyObject*)m;
2649 }
2650
2651
2652 static PyObject *pycvCreateMatND(PyObject *self, PyObject *args)
2653 {
2654   ints dims;
2655   int type;
2656
2657   if (!PyArg_ParseTuple(args, "O&i", convert_to_ints, (void*)&dims, &type))
2658     return NULL;
2659   cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
2660   ERRWRAP(m->a = cvCreateMatND(dims.count, dims.i, type));
2661   return pythonize_CvMatND(m);
2662 }
2663
2664 #if PYTHON_USE_NUMPY
2665 static PyObject *pycvfromarray(PyObject *self, PyObject *args)
2666 {
2667   PyObject *o;
2668   if (!PyArg_ParseTuple(args, "O", &o)) {
2669     return NULL;
2670   }
2671
2672   PyObject *ao = PyObject_GetAttrString(o, "__array_struct__");
2673   if ((ao == NULL) || !PyCObject_Check(ao)) {
2674     PyErr_SetString(PyExc_TypeError, "object does not have array interface");
2675     return NULL;
2676   }
2677   PyArrayInterface *pai = (PyArrayInterface*)PyCObject_AsVoidPtr(ao);
2678   if (pai->two != 2) {
2679     PyErr_SetString(PyExc_TypeError, "object does not have array interface");
2680     return NULL;
2681   }
2682
2683   cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
2684   int type = -1;
2685
2686   switch (pai->typekind) {
2687   case 'i':
2688     if (pai->itemsize == 1)
2689       type = CV_8SC1;
2690     else if (pai->itemsize == 2)
2691       type = CV_16SC1;
2692     else if (pai->itemsize == 4)
2693       type = CV_32SC1;
2694     break;
2695
2696   case 'u':
2697     if (pai->itemsize == 1)
2698       type = CV_8UC1;
2699     else if (pai->itemsize == 2)
2700       type = CV_16UC1;
2701     break;
2702
2703   case 'f':
2704     if (pai->itemsize == 4)
2705       type = CV_32FC1;
2706     else if (pai->itemsize == 8)
2707       type = CV_64FC1;
2708     break;
2709   }
2710   int dims[CV_MAX_DIM];
2711   int i;
2712   for (i = 0; i < pai->nd; i++)
2713     dims[i] = pai->shape[i];
2714   ERRWRAP(m->a = cvCreateMatND(pai->nd, dims, type));
2715   m->a->data.ptr = (uchar*)pai->data;
2716   return pythonize_CvMatND(m);
2717 }
2718 #endif
2719
2720 static PyObject *pycvCreateHist(PyObject *self, PyObject *args)
2721 {
2722   PyObject *dims;
2723   int type;
2724   float **ranges = NULL;
2725   int uniform = 1;
2726
2727   if (!PyArg_ParseTuple(args, "Oi|O&i", &dims, &type, convert_to_floatPTRPTR, (void*)&ranges, &uniform)) {
2728     return NULL;
2729   }
2730   cvhistogram_t *h = PyObject_NEW(cvhistogram_t, &cvhistogram_Type);
2731   args = Py_BuildValue("Oi", dims, CV_32FC1);
2732   h->bins = pycvCreateMatND(self, args);
2733   Py_DECREF(args);
2734   if (h->bins == NULL) {
2735     return NULL;
2736   }
2737   h->h.type = CV_HIST_MAGIC_VAL;
2738   if (!convert_to_CvArr(h->bins, &(h->h.bins), "bins"))
2739     return NULL;
2740
2741   ERRWRAP(cvSetHistBinRanges(&(h->h), ranges, uniform));
2742
2743   return (PyObject*)h;
2744 }
2745
2746 static PyObject *pycvInitLineIterator(PyObject *self, PyObject *args)
2747 {
2748   CvArr *image;
2749   CvPoint pt1;
2750   CvPoint pt2;
2751   int connectivity = 8;
2752   int left_to_right = 0;
2753
2754   if (!PyArg_ParseTuple(args, "O&O&O&|ii",
2755                         convert_to_CvArr, &image,
2756                         convert_to_CvPoint, &pt1,
2757                         convert_to_CvPoint, &pt2,
2758                         &connectivity,
2759                         &left_to_right))
2760     return NULL;
2761
2762   cvlineiterator_t *pi = PyObject_NEW(cvlineiterator_t, &cvlineiterator_Type);
2763   pi->count = cvInitLineIterator(image, pt1, pt2, &pi->iter, connectivity, left_to_right);
2764   ERRWRAP(pi->type = cvGetElemType(image));
2765   return (PyObject*)pi;
2766 }
2767
2768 static PyObject *pycvCreateMemStorage(PyObject *self, PyObject *args)
2769 {
2770   int block_size = 0;
2771   if (!PyArg_ParseTuple(args, "|i", &block_size))
2772     return NULL;
2773   cvmemstorage_t *pm = PyObject_NEW(cvmemstorage_t, &cvmemstorage_Type);
2774   pm->a = cvCreateMemStorage(block_size);
2775   return (PyObject*)pm;
2776 }
2777
2778 // single index: return row
2779 // 2 indices: row, column
2780 // both row and column can be slices.  column slice must have a step of 1.
2781 //
2782 // returns a scalar when all dimensions are specified and all are integers.  Otherwise returns a CvMat.
2783 //
2784 static PyObject *cvarr_GetItem(PyObject *o, PyObject *key)
2785 {
2786   dims dd;
2787
2788   CvArr *cva;
2789   if (!convert_to_CvArr(o, &cva, "src"))
2790     return NULL;
2791
2792   if (!convert_to_dims(key, &dd, cva, "key")) {
2793     return NULL;
2794   }
2795
2796   // Figure out if all supplied indices have a stride of zero - means they are not slices
2797   // and if all indices are positive
2798   int all0 = 1;
2799   for (int i = 0; i < dd.count; i++) {
2800     all0 &= (dd.step[i] == 0) && (0 <= dd.i[i]);
2801   }
2802
2803   // if every dimension supplied, and none are slices, return the scalar
2804   if ((cvGetDims(cva) == dd.count) && all0) {
2805     CvScalar s;
2806     ERRWRAP(s = cvGetND(cva, dd.i));
2807     return PyObject_FromCvScalar(s, cvGetElemType(cva));
2808   } else {
2809     // pad missing dimensions
2810     for (int i = dd.count; i < cvGetDims(cva); i++) {
2811       dd.i[i] = 0;
2812       dd.step[i] = 1;
2813       dd.length[i] = cvGetDimSize(cva, i);
2814     }
2815     dd.count = cvGetDims(cva);
2816
2817     // negative steps are illegal for OpenCV
2818     for (int i = 0; i < dd.count; i++) {
2819       if (dd.step[i] < 0)
2820         return (PyObject*)failmsg("Negative step is illegal");
2821     }
2822
2823     // zero length illegal for OpenCV
2824     for (int i = 0; i < dd.count; i++) {
2825       if (dd.length[i] == 0)
2826         return (PyObject*)failmsg("Zero sized dimension is illegal");
2827     }
2828
2829     // column step can only be 0 or 1
2830     if ((dd.step[dd.count-1] != 0) && (dd.step[dd.count-1] != 1))
2831         return (PyObject*)failmsg("Column step is illegal");
2832
2833     if (is_cvmat(o) || is_iplimage(o)) {
2834       cvmat_t *sub = PyObject_NEW(cvmat_t, &cvmat_Type);
2835       sub->a = cvCreateMatHeader(dd.length[0], dd.length[1], cvGetElemType(cva));
2836       uchar *old0;  // pointer to first element in old mat
2837       int oldstep;
2838       cvGetRawData(cva, &old0, &oldstep);
2839       uchar *new0;  // pointer to first element in new mat
2840       ERRWRAP(new0 = cvPtrND(cva, dd.i));
2841
2842       sub->a->step = oldstep * dd.step[0];
2843       sub->data = what_data(o);
2844       Py_INCREF(sub->data);
2845       sub->offset = new0 - old0;
2846       return (PyObject*)sub;
2847     } else {
2848       cvmatnd_t *sub = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
2849       sub->a = cvCreateMatNDHeader(dd.count, dd.length, cvGetElemType(cva));
2850       uchar *old0;  // pointer to first element in old mat
2851       cvGetRawData(cva, &old0);
2852       uchar *new0;  // pointer to first element in new mat
2853       ERRWRAP(new0 = cvPtrND(cva, dd.i));
2854
2855       for (int d = 0; d < dd.count; d++) {
2856         int stp = dd.step[d];
2857         sub->a->dim[d].step = ((CvMatND*)cva)->dim[d].step * ((stp == 0) ? 1 : stp);
2858         sub->a->dim[d].size = dd.length[d];
2859       }
2860       sub->data = what_data(o);
2861       Py_INCREF(sub->data);
2862       sub->offset = new0 - old0;
2863       return (PyObject*)sub;
2864     }
2865   }
2866 }
2867
2868 static int cvarr_SetItem(PyObject *o, PyObject *key, PyObject *v)
2869 {
2870   dims dd;
2871
2872   CvArr *cva;
2873   if (!convert_to_CvArr(o, &cva, "src"))
2874     return -1;
2875
2876   if (!convert_to_dims(key, &dd, cva, "key")) {
2877     return -1;
2878   }
2879
2880   if (cvGetDims(cva) != dd.count) {
2881     PyErr_SetString(PyExc_TypeError, "key length does not match array dimension");
2882     return -1;
2883   }
2884
2885   CvScalar s;
2886   if (PySequence_Check(v)) {
2887     PyObject *fi = PySequence_Fast(v, "v");
2888     if (fi == NULL)
2889       return -1;
2890     if (PySequence_Fast_GET_SIZE(fi) != CV_MAT_CN(cvGetElemType(cva))) {
2891       PyErr_SetString(PyExc_TypeError, "sequence size must be same as channel count");
2892       return -1;
2893     }
2894     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++)
2895       s.val[i] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(fi, i));
2896     Py_DECREF(fi);
2897   } else {
2898     if (1 != CV_MAT_CN(cvGetElemType(cva))) {
2899       PyErr_SetString(PyExc_TypeError, "scalar supplied but channel count does not equal 1");
2900       return -1;
2901     }
2902     s.val[0] = PyFloat_AsDouble(v);
2903   }
2904   switch (dd.count) {
2905   case 1:
2906     cvSet1D(cva, dd.i[0], s);
2907     break;
2908   case 2:
2909     cvSet2D(cva, dd.i[0], dd.i[1], s);
2910     break;
2911   case 3:
2912     cvSet3D(cva, dd.i[0], dd.i[1], dd.i[2], s);
2913     break;
2914   default:
2915     cvSetND(cva, dd.i, s);
2916     // XXX - OpenCV bug? - seems as if an error in cvSetND does not set error status?
2917     break;
2918   }
2919   if (cvGetErrStatus() != 0) {
2920     translate_error_to_exception();
2921     return -1;
2922   }
2923
2924   return 0;
2925 }
2926
2927
2928 static PyObject *pycvSetData(PyObject *self, PyObject *args)
2929 {
2930   PyObject *o, *s;
2931   int step = -1;
2932
2933   if (!PyArg_ParseTuple(args, "OOi", &o, &s, &step))
2934     return NULL;
2935   if (is_iplimage(o)) {
2936     iplimage_t *ipl = (iplimage_t*)o;
2937     ipl->a->widthStep = step;
2938     Py_DECREF(ipl->data);
2939     ipl->data = s;
2940     Py_INCREF(ipl->data);
2941   } else if (is_cvmat(o)) {
2942     cvmat_t *m = (cvmat_t*)o;
2943     m->a->step = step;
2944     Py_DECREF(m->data);
2945     m->data = s;
2946     Py_INCREF(m->data);
2947   } else if (is_cvmatnd(o)) {
2948     cvmatnd_t *m = (cvmatnd_t*)o;
2949     Py_DECREF(m->data);
2950     m->data = s;
2951     Py_INCREF(m->data);
2952   } else {
2953     PyErr_SetString(PyExc_TypeError, "SetData argument must be either IplImage, CvMat or CvMatND");
2954     return NULL;
2955   }
2956
2957   Py_RETURN_NONE;
2958 }
2959
2960 static PyObject *what_data(PyObject *o)
2961 {
2962   if (is_iplimage(o)) {
2963     iplimage_t *ipl = (iplimage_t*)o;
2964     return ipl->data;
2965   } else if (is_cvmat(o)) {
2966     cvmat_t *m = (cvmat_t*)o;
2967     return m->data;
2968   } else if (is_cvmatnd(o)) {
2969     cvmatnd_t *m = (cvmatnd_t*)o;
2970     return m->data;
2971   } else {
2972     assert(0);
2973     return NULL;
2974   }
2975 }
2976
2977 static PyObject *pycvCreateData(PyObject *self, PyObject *args)
2978 {
2979   PyObject *o;
2980
2981   if (!PyArg_ParseTuple(args, "O", &o))
2982     return NULL;
2983
2984   CvArr *a;
2985   if (!convert_to_CvArr(o, &a, "arr"))
2986     return NULL;
2987   ERRWRAP(cvCreateData(a));
2988
2989   Py_DECREF(what_data(o));
2990   if (is_iplimage(o)) {
2991     iplimage_t *ipl = (iplimage_t*)o;
2992     pythonize_IplImage(ipl);
2993   } else if (is_cvmat(o)) {
2994     cvmat_t *m = (cvmat_t*)o;
2995     pythonize_CvMat(m);
2996   } else if (is_cvmatnd(o)) {
2997     cvmatnd_t *m = (cvmatnd_t*)o;
2998     pythonize_CvMatND(m);
2999   } else {
3000     PyErr_SetString(PyExc_TypeError, "CreateData argument must be either IplImage, CvMat or CvMatND");
3001     return NULL;
3002   }
3003
3004   Py_RETURN_NONE;
3005 }
3006
3007 static PyObject *pycvGetDims(PyObject *self, PyObject *args)
3008 {
3009   PyObject *o;
3010
3011   if (!PyArg_ParseTuple(args, "O", &o))
3012     return NULL;
3013   CvArr *cva;
3014   if (!convert_to_CvArr(o, &cva, "src"))
3015     return NULL;
3016
3017   int i, nd;
3018   ERRWRAP(nd = cvGetDims(cva));
3019   PyObject *r = PyTuple_New(nd);
3020   for (i = 0; i < nd; i++)
3021     PyTuple_SetItem(r, i, PyInt_FromLong(cvGetDimSize(cva, i)));
3022   return r;
3023 }
3024
3025 static PyObject *pycvGetImage(PyObject *self, PyObject *args)
3026 {
3027   PyObject *o, *r;
3028
3029   if (!PyArg_ParseTuple(args, "O", &o))
3030     return NULL;
3031   if (is_iplimage(o)) {
3032     r = o;
3033     Py_INCREF(o);
3034   } else {
3035     IplImage *ipl = cvCreateImageHeader(cvSize(100,100), 8, 1); // these args do not matter, because overwritten
3036     CvArr *cva;
3037     if (!convert_to_CvArr(o, &cva, "src"))
3038       return NULL;
3039     ERRWRAP(cvGetImage(cva, ipl));
3040
3041     iplimage_t *oipl = PyObject_NEW(iplimage_t, &iplimage_Type);
3042     oipl->a = ipl;
3043     oipl->data = what_data(o);
3044     Py_INCREF(oipl->data);
3045     oipl->offset = 0;
3046
3047     r = (PyObject*)oipl;
3048   }
3049   return r;
3050 }
3051
3052 static PyObject *pycvGetMat(PyObject *self, PyObject *args, PyObject *kw)
3053 {
3054   const char *keywords[] = { "arr", "allowND", NULL };
3055   PyObject *o, *r;
3056   int allowND = 0;
3057
3058   if (!PyArg_ParseTupleAndKeywords(args, kw, "O|i", (char**)keywords, &o, &allowND))
3059     return NULL;
3060   if (is_cvmat(o)) {
3061     r = o;
3062     Py_INCREF(o);
3063   } else {
3064     CvMat *m = cvCreateMatHeader(100,100, 1); // these args do not matter, because overwritten
3065     CvArr *cva;
3066     if (!convert_to_CvArr(o, &cva, "src"))
3067       return NULL;
3068     ERRWRAP(cvGetMat(cva, m, NULL, allowND));
3069
3070     cvmat_t *om = PyObject_NEW(cvmat_t, &cvmat_Type);
3071     om->a = m;
3072     om->data = what_data(o);
3073     Py_INCREF(om->data);
3074     om->offset = 0;
3075
3076     r = (PyObject*)om;
3077   }
3078   return r;
3079 }
3080
3081 static PyObject *pycvReshape(PyObject *self, PyObject *args)
3082 {
3083   PyObject *o;
3084   int new_cn;
3085   int new_rows = 0;
3086
3087   if (!PyArg_ParseTuple(args, "Oi|i", &o, &new_cn, &new_rows))
3088     return NULL;
3089
3090   CvMat *m = cvCreateMatHeader(100,100, 1); // these args do not matter, because overwritten
3091   CvArr *cva;
3092   if (!convert_to_CvArr(o, &cva, "src"))
3093     return NULL;
3094   ERRWRAP(cvReshape(cva, m, new_cn, new_rows));
3095
3096   cvmat_t *om = PyObject_NEW(cvmat_t, &cvmat_Type);
3097   om->a = m;
3098   om->data = what_data(o);
3099   Py_INCREF(om->data);
3100   om->offset = 0;
3101
3102   return (PyObject*)om;
3103 }
3104
3105 static PyObject *pycvReshapeMatND(PyObject *self, PyObject *args)
3106 {
3107   PyObject *o;
3108   int new_cn;
3109   PyObject *new_dims;
3110
3111   if (!PyArg_ParseTuple(args, "OiO", &o, &new_cn, &new_dims))
3112     return NULL;
3113
3114   CvMatND *cva;
3115   if (!convert_to_CvMatND(o, &cva, "src"))
3116     return NULL;
3117   ints dims;
3118   if (!convert_to_ints(new_dims, &dims, "new_dims"))
3119     return NULL;
3120
3121 #if 0
3122   int dummy[1] = { 1 };
3123   CvMatND *m = cvCreateMatNDHeader(1, dummy, 1); // these args do not matter, because overwritten
3124   ERRWRAP(cvReshapeND(cva, m, new_cn, dims.count + 1, dims.i));
3125
3126   cvmatnd_t *om = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
3127   om->a = m;
3128   om->data = what_data(o);
3129   Py_INCREF(om->data);
3130   om->offset = 0;
3131   return (PyObject*)om;
3132 #endif
3133 #if 0
3134   CvMat *m = cvCreateMatHeader(100, 100, 1); // these args do not matter, because overwritten
3135   ERRWRAP(cvReshapeND(cva, m, 0, 1, 0)); // new_cn, dims.count + 1, dims.i));
3136
3137   cvmat_t *om = PyObject_NEW(cvmat_t, &cvmat_Type);
3138   om->a = m;
3139   om->data = what_data(o);
3140   Py_INCREF(om->data);
3141   om->offset = 0;
3142   return (PyObject*)om;
3143 #endif
3144 #if 1
3145   {
3146     int size[] = { 2, 2, 2 };
3147     CvMatND* mat = cvCreateMatND(3, size, CV_32F);
3148     CvMat row_header;
3149     CvArr *row;
3150     row = cvReshapeND(mat, &row_header, 0, 1, 0);
3151   }
3152   Py_RETURN_NONE;
3153 #endif
3154 }
3155
3156 static void OnMouse(int event, int x, int y, int flags, void* param)
3157 {
3158   PyGILState_STATE gstate;
3159   gstate = PyGILState_Ensure();
3160
3161   PyObject *o = (PyObject*)param;
3162   PyObject *args = Py_BuildValue("iiiiO", event, x, y, flags, PyTuple_GetItem(o, 1));
3163
3164   PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
3165   if (r == NULL)
3166     PyErr_Print();
3167   else
3168     Py_DECREF(r);
3169   Py_DECREF(args);
3170   PyGILState_Release(gstate);
3171 }
3172
3173 static PyObject *pycvSetMouseCallback(PyObject *self, PyObject *args, PyObject *kw)
3174 {
3175   const char *keywords[] = { "window_name", "on_mouse", "param", NULL };
3176   char* name;
3177   PyObject *on_mouse;
3178   PyObject *param = NULL;
3179
3180   if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|O", (char**)keywords, &name, &on_mouse, &param))
3181     return NULL;
3182   if (!PyCallable_Check(on_mouse)) {
3183     PyErr_SetString(PyExc_TypeError, "on_mouse must be callable");
3184     return NULL;
3185   }
3186   if (param == NULL) {
3187     param = Py_None;
3188   }
3189   ERRWRAP(cvSetMouseCallback(name, OnMouse, Py_BuildValue("OO", on_mouse, param)));
3190   Py_RETURN_NONE;
3191 }
3192
3193 void OnChange(int pos, void *param)
3194 {
3195   PyGILState_STATE gstate;
3196   gstate = PyGILState_Ensure();
3197
3198   PyObject *o = (PyObject*)param;
3199   PyObject *args = Py_BuildValue("(i)", pos);
3200   PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
3201   if (r == NULL)
3202     PyErr_Print();
3203   Py_DECREF(args);
3204   PyGILState_Release(gstate);
3205 }
3206
3207 static PyObject *pycvCreateTrackbar(PyObject *self, PyObject *args, PyObject *kw)
3208 {
3209   const char *keywords[] = { "trackbar_name", "window_name", "value", "count", "on_change", NULL };
3210   PyObject *on_change;
3211   char* trackbar_name;
3212   char* window_name;
3213   int *value = new int;
3214   int count;
3215
3216   if (!PyArg_ParseTupleAndKeywords(args, kw, "ssiiO", (char**)keywords, &trackbar_name, &window_name, value, &count, &on_change))
3217     return NULL;
3218   if (!PyCallable_Check(on_change)) {
3219     PyErr_SetString(PyExc_TypeError, "on_change must be callable");
3220     return NULL;
3221   }
3222   ERRWRAP(cvCreateTrackbar2(trackbar_name, window_name, value, count, OnChange, Py_BuildValue("OO", on_change, Py_None)));
3223   Py_RETURN_NONE;
3224 }
3225
3226 static PyObject *pycvFindContours(PyObject *self, PyObject *args, PyObject *kw)
3227 {
3228   CvArr* image;
3229   PyObject *pyobj_image = NULL;
3230   CvMemStorage* storage;
3231   PyObject *pyobj_storage = NULL;
3232   CvSeq* first_contour;
3233   int header_size = sizeof(CvContour);
3234   int mode = CV_RETR_LIST;
3235   int method = CV_CHAIN_APPROX_SIMPLE;
3236   CvPoint offset = cvPoint(0,0);
3237   PyObject *pyobj_offset = NULL;
3238
3239   const char *keywords[] = { "image", "storage", "mode", "method", "offset", NULL };
3240   if (!PyArg_ParseTupleAndKeywords(args, kw, "OO|iiO", (char**)keywords, &pyobj_image, &pyobj_storage, &mode, &method, &pyobj_offset))
3241     return NULL;
3242   if (!convert_to_CvArr(pyobj_image, &image, "image")) return NULL;
3243   if (!convert_to_CvMemStorage(pyobj_storage, &storage, "storage")) return NULL;
3244   if ((pyobj_offset != NULL) && !convert_to_CvPoint(pyobj_offset, &offset, "offset")) return NULL;
3245   ERRWRAP(cvFindContours(image, storage, &first_contour, header_size, mode, method, offset));
3246   cvseq_t *ps = PyObject_NEW(cvseq_t, &cvseq_Type);
3247   ps->a = first_contour;
3248   ps->container = PyTuple_GetItem(args, 1); // storage
3249   Py_INCREF(ps->container);
3250   return (PyObject*)ps;
3251 }
3252
3253 static PyObject *pycvApproxPoly(PyObject *self, PyObject *args, PyObject *kw)
3254 {
3255   cvarrseq src_seq;
3256   PyObject *pyobj_src_seq = NULL;
3257   int header_size = sizeof(CvContour);
3258   CvMemStorage* storage;
3259   PyObject *pyobj_storage = NULL;
3260   int method;
3261   double parameter = 0;
3262   int parameter2 = 0;
3263
3264   const char *keywords[] = { "src_seq", "storage", "method", "parameter", "parameter2", NULL };
3265   if (!PyArg_ParseTupleAndKeywords(args, kw, "OOi|di", (char**)keywords, &pyobj_src_seq, &pyobj_storage, &method, &parameter, &parameter2))
3266     return NULL;
3267   if (!convert_to_cvarrseq(pyobj_src_seq, &src_seq, "src_seq")) return NULL;
3268   if (!convert_to_CvMemStorage(pyobj_storage, &storage, "storage")) return NULL;
3269   CvSeq* r;
3270   ERRWRAP(r = cvApproxPoly(src_seq.mat, header_size, storage, method, parameter, parameter2));
3271   return FROM_CvSeqPTR(r);
3272 }
3273
3274 static float distance_function_glue( const float* a, const float* b, void* user_param )
3275 {
3276   PyObject *o = (PyObject*)user_param;
3277   PyObject *args = Py_BuildValue("(ff)(ff)O", a[0], a[1], b[0], b[1], PyTuple_GetItem(o, 1));
3278   PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
3279   Py_DECREF(args);
3280   return (float)PyFloat_AsDouble(r);
3281 }
3282
3283 static PyObject *pycvCalcEMD2(PyObject *self, PyObject *args, PyObject *kw)
3284 {
3285   const char *keywords[] = { "signature1", "signature2", "distance_type", "distance_func", "cost_matrix", "flow", "lower_bound", "userdata", NULL };
3286   CvArr* signature1;
3287   PyObject *pyobj_signature1;
3288   CvArr* signature2;
3289   PyObject *pyobj_signature2;
3290   int distance_type;
3291   PyObject *distance_func = NULL;
3292   CvArr* cost_matrix=NULL;
3293   PyObject *pyobj_cost_matrix = NULL;
3294   CvArr* flow=NULL;
3295   PyObject *pyobj_flow = NULL;
3296   float lower_bound = 0.0;
3297   PyObject *userdata = NULL;
3298
3299   if (!PyArg_ParseTupleAndKeywords(args, kw, "OOi|OOOfO", (char**)keywords,
3300                                    &pyobj_signature1,
3301                                    &pyobj_signature2,
3302                                    &distance_type,
3303                                    &distance_func,
3304                                    &pyobj_cost_matrix,
3305                                    &pyobj_flow,
3306                                    &lower_bound,
3307                                    &userdata))
3308     return NULL;
3309   if (!convert_to_CvArr(pyobj_signature1, &signature1, "signature1")) return NULL;
3310   if (!convert_to_CvArr(pyobj_signature2, &signature2, "signature2")) return NULL;
3311   if (pyobj_cost_matrix && !convert_to_CvArr(pyobj_cost_matrix, &cost_matrix, "cost_matrix")) return NULL;
3312   if (pyobj_flow && !convert_to_CvArr(pyobj_flow, &flow, "flow")) return NULL;
3313
3314   if (distance_func == NULL) {
3315     distance_func = Py_None;
3316   }
3317   if (userdata == NULL) {
3318     userdata = Py_None;
3319   }
3320
3321   PyObject *ud = Py_BuildValue("OO", distance_func, userdata);
3322   float r;
3323   ERRWRAP(r = cvCalcEMD2(signature1, signature2, distance_type, distance_function_glue, cost_matrix, flow, &lower_bound, (void*)ud));
3324   Py_DECREF(ud);
3325
3326   return PyFloat_FromDouble(r);
3327 }
3328
3329 static PyObject *pycvSubdiv2DLocate(PyObject *self, PyObject *args)
3330 {
3331   PyObject *pyobj_subdiv;
3332   PyObject *pyobj_pt;
3333   CvSubdiv2D *subdiv;
3334   CvPoint2D32f pt;
3335   CvSubdiv2DEdge edge;
3336   CvSubdiv2DPoint* vertex;
3337
3338   if (!PyArg_ParseTuple(args, "OO", &pyobj_subdiv, &pyobj_pt))
3339     return NULL;
3340   if (!convert_to_CvSubdiv2DPTR(pyobj_subdiv, &subdiv, "subdiv"))
3341     return NULL;
3342   if (!convert_to_CvPoint2D32f(pyobj_pt, &pt, "pt"))
3343     return NULL;
3344
3345   CvSubdiv2DPointLocation loc = cvSubdiv2DLocate(subdiv, pt, &edge, &vertex);
3346   PyObject *r;
3347   switch (loc) {
3348   case CV_PTLOC_INSIDE:
3349   case CV_PTLOC_ON_EDGE:
3350     r = FROM_CvSubdiv2DEdge(edge);
3351     break;
3352   case CV_PTLOC_VERTEX:
3353     r = FROM_CvSubdiv2DPointPTR(vertex);
3354     break;
3355   case CV_PTLOC_OUTSIDE_RECT:
3356     r = Py_None;
3357     Py_INCREF(Py_None);
3358     break;
3359   default:
3360     return (PyObject*)failmsg("Unexpected loc from cvSubdiv2DLocate");
3361   }
3362   return Py_BuildValue("iO", (int)loc, r);;
3363 }
3364
3365 static PyObject *pycvCalcOpticalFlowPyrLK(PyObject *self, PyObject *args)
3366 {
3367   CvArr* prev;
3368   PyObject *pyobj_prev = NULL;
3369   CvArr* curr;
3370   PyObject *pyobj_curr = NULL;
3371   CvArr* prev_pyr;
3372   PyObject *pyobj_prev_pyr = NULL;
3373   CvArr* curr_pyr;
3374   PyObject *pyobj_curr_pyr = NULL;
3375   CvPoint2D32f* prev_features;
3376   PyObject *pyobj_prev_features = NULL;
3377   PyObject *pyobj_curr_features = NULL;
3378   CvPoint2D32f* curr_features;
3379   CvSize win_size;
3380   int level;
3381   CvTermCriteria criteria;
3382   int flags;
3383
3384   if (!PyArg_ParseTuple(args, "OOOOO(ii)i(iif)i|O",
3385     &pyobj_prev, &pyobj_curr, &pyobj_prev_pyr, &pyobj_curr_pyr,
3386     &pyobj_prev_features,
3387     &win_size.width, &win_size.height, &level,
3388     &criteria.type, &criteria.max_iter, &criteria.epsilon,
3389     &flags,
3390     &pyobj_curr_features))
3391     return NULL;
3392   if (!convert_to_CvArr(pyobj_prev, &prev, "prev")) return NULL;
3393   if (!convert_to_CvArr(pyobj_curr, &curr, "curr")) return NULL;
3394   if (!convert_to_CvArr(pyobj_prev_pyr, &prev_pyr, "prev_pyr")) return NULL;
3395   if (!convert_to_CvArr(pyobj_curr_pyr, &curr_pyr, "curr_pyr")) return NULL;
3396   if (!convert_to_CvPoint2D32fPTR(pyobj_prev_features, &prev_features, "prev_features")) return NULL;
3397   int count = (int)PySequence_Length(pyobj_prev_features);
3398   if (flags & CV_LKFLOW_INITIAL_GUESSES) {
3399     failmsg("flag CV_LKFLOW_INITIAL_GUESSES is determined automatically from function arguments - it is not required");
3400     return NULL;
3401   }
3402   if (!pyobj_curr_features) {
3403     curr_features = new CvPoint2D32f[count];
3404   } else {
3405     if (PySequence_Length(pyobj_curr_features) != count) {
3406       failmsg("curr_features must have same length as prev_features");
3407       return NULL;
3408     }
3409     if (!convert_to_CvPoint2D32fPTR(pyobj_curr_features, &curr_features, "curr_features")) return NULL;
3410     flags |= CV_LKFLOW_INITIAL_GUESSES;
3411   }
3412   float *track_error = new float[count];
3413   char* status = new char[count];
3414   ERRWRAP(cvCalcOpticalFlowPyrLK(prev, curr, prev_pyr, curr_pyr, prev_features, curr_features, count, win_size, level, status, track_error, criteria, flags));
3415
3416   cvpoint2d32f_count r0;
3417   r0.points = curr_features;
3418   r0.count = count;
3419
3420   chars r1;
3421   r1.f = status;
3422   r1.count = count;
3423
3424   floats r2;
3425   r2.f = track_error;
3426   r2.count = count;
3427
3428   return Py_BuildValue("NNN", FROM_cvpoint2d32f_count(r0), FROM_chars(r1), FROM_floats(r2));
3429 }
3430
3431 static PyObject *pycvClipLine(PyObject *self, PyObject *args, PyObject *kw)
3432 {
3433   CvSize img_size;
3434   PyObject *pyobj_img_size = NULL;
3435   CvPoint pt1;
3436   PyObject *pyobj_pt1 = NULL;
3437   CvPoint pt2;
3438   PyObject *pyobj_pt2 = NULL;
3439
3440   if (!PyArg_ParseTuple(args, "OOO", &pyobj_img_size, &pyobj_pt1, &pyobj_pt2))
3441     return NULL;
3442   if (!convert_to_CvSize(pyobj_img_size, &img_size, "img_size")) return NULL;
3443   if (!convert_to_CvPoint(pyobj_pt1, &pt1, "pt1")) return NULL;
3444   if (!convert_to_CvPoint(pyobj_pt2, &pt2, "pt2")) return NULL;
3445   int r;
3446   ERRWRAP(r = cvClipLine(img_size, &pt1, &pt2));
3447   if (r == 0) {
3448     Py_RETURN_NONE;
3449   } else {
3450     return Py_BuildValue("NN", FROM_CvPoint(pt1), FROM_CvPoint(pt2));
3451   }
3452 }
3453
3454 static PyObject *temp_test(PyObject *self, PyObject *args)
3455 {
3456 #if 0
3457   CvArr *im = cvLoadImage("../samples/c/lena.jpg", 0);
3458   printf("im=%p\n", im);
3459   CvMat *m = cvEncodeImage(".jpeg", im);
3460 #endif
3461 #if 0
3462   CvArr *im = cvLoadImage("lena.jpg", 0);
3463   float r0[] = { 0, 255 };
3464   float *ranges[] = { r0 };
3465   int hist_size[] = { 256 };
3466   CvHistogram *hist = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
3467   cvCalcHist(im, hist, 0, 0);
3468 #endif
3469
3470 #if 0
3471   CvMat* mat = cvCreateMat( 3, 3, CV_32F );
3472   CvMat row_header, *row;
3473   row = cvReshape( mat, &row_header, 0, 1 );
3474   printf("%d,%d\n", row_header.rows, row_header.cols);
3475   printf("ge %08x\n", cvGetElemType(mat));
3476 #endif
3477
3478 #if 0
3479   CvMat *m = cvCreateMat(1, 10, CV_8UC1);
3480   printf("CvMat stride ===> %d\n", m->step);
3481 #endif
3482
3483 #if 0
3484   CvPoint2D32f src[3] = { { 0,0 }, { 1,0 }, { 0,1 } };
3485   CvPoint2D32f dst[3] = { { 0,0 }, { 17,0 }, { 0,17 } };
3486
3487   CvMat* mapping = cvCreateMat(2, 3, CV_32FC1);
3488   cvGetAffineTransform(src, dst, mapping);
3489   printf("===> %f\n", cvGetReal2D(mapping, 0, 0));
3490 #endif
3491
3492 #if 0
3493   CvArr *im = cvLoadImage("checker77.png");
3494   CvPoint2D32f corners[49];
3495   int count;
3496   cvFindChessboardCorners(im, cvSize(7,7), corners, &count, 0);
3497   printf("count=%d\n", count);
3498 #endif
3499
3500   return PyFloat_FromDouble(0.0);
3501 }
3502
3503 static PyObject *pycvFindChessboardCorners(PyObject *self, PyObject *args, PyObject *kw)
3504 {
3505   CvArr* image;
3506   PyObject *pyobj_image = NULL;
3507   CvSize pattern_size;
3508   PyObject *pyobj_pattern_size = NULL;
3509   cvpoint2d32f_count corners;
3510   int flags = CV_CALIB_CB_ADAPTIVE_THRESH;
3511
3512   const char *keywords[] = { "image", "pattern_size", "flags", NULL };
3513   if (!PyArg_ParseTupleAndKeywords(args, kw, "OO|i", (char**)keywords, &pyobj_image, &pyobj_pattern_size, &flags))
3514     return NULL;
3515   if (!convert_to_CvArr(pyobj_image, &image, "image")) return NULL;
3516   if (!convert_to_CvSize(pyobj_pattern_size, &pattern_size, "pattern_size")) return NULL;
3517   int r;
3518   corners.points = new CvPoint2D32f[pattern_size.width * pattern_size.height];
3519   ERRWRAP(r = cvFindChessboardCorners(image, pattern_size, corners.points,&corners.count, flags));
3520   return Py_BuildValue("NN", FROM_int(r), FROM_cvpoint2d32f_count(corners));
3521 }
3522
3523 // For functions GetSubRect, GetRow, GetCol.
3524 // recipient has a view into donor's data, and needs to share it.
3525 // make recipient use the donor's data, compute the offset,
3526 // and manage reference counts.
3527
3528 static void preShareData(CvArr *donor, CvMat **recipient)
3529 {
3530   *recipient = cvCreateMatHeader(4, 4, cvGetElemType(donor));
3531 }
3532
3533 static PyObject *shareData(PyObject *donor, CvArr *pdonor, CvMat *precipient)
3534 {
3535   PyObject *recipient = (PyObject*)PyObject_NEW(cvmat_t, &cvmat_Type);
3536   ((cvmat_t*)recipient)->a = precipient;
3537   ((cvmat_t*)recipient)->offset = cvPtr1D(precipient, 0) - cvPtr1D(pdonor, 0);
3538
3539   PyObject *arr_data;
3540   if (is_cvmat(donor)) {
3541     arr_data = ((cvmat_t*)donor)->data;
3542   } else if (is_iplimage(donor)) {
3543     arr_data = ((iplimage_t*)donor)->data;
3544   } else {
3545     return (PyObject*)failmsg("Argument 'mat' must be either IplImage or CvMat");
3546   }
3547   ((cvmat_t*)recipient)->data = arr_data;
3548   Py_INCREF(arr_data);
3549   return recipient;
3550 }
3551
3552 static PyObject *pycvGetHuMoments(PyObject *self, PyObject *args, PyObject *kw)
3553 {
3554   CvMoments* moments;
3555   PyObject *pyobj_moments = NULL;
3556
3557   if (!PyArg_ParseTuple(args, "O", &pyobj_moments))
3558     return NULL;
3559   if (!convert_to_CvMomentsPTR(pyobj_moments, &moments, "moments")) return NULL;
3560   CvHuMoments r;
3561   ERRWRAP(cvGetHuMoments(moments, &r));
3562   return Py_BuildValue("ddddddd", r.hu1, r.hu2, r.hu3, r.hu4, r.hu5, r.hu6, r.hu7);
3563 }
3564
3565 static PyObject *pycvFitLine(PyObject *self, PyObject *args, PyObject *kw)
3566 {
3567   cvarrseq points;
3568   PyObject *pyobj_points = NULL;
3569   int dist_type;
3570   float param;
3571   float reps;
3572   float aeps;
3573   float r[6];
3574
3575   if (!PyArg_ParseTuple(args, "Oifff", &pyobj_points, &dist_type, &param, &reps, &aeps))
3576     return NULL;
3577   if (!convert_to_cvarrseq(pyobj_points, &points, "points")) return NULL;
3578   ERRWRAP(cvFitLine(points.mat, dist_type, param, reps, aeps, r));
3579   int dimension;
3580   if (strcmp("opencv-matrix", cvTypeOf(points.mat)->type_name) == 0)
3581     dimension = CV_MAT_CN(cvGetElemType(points.mat));
3582   else {
3583     // sequence case... don't think there is a sequence of 3d points,
3584     // so assume 2D
3585     dimension = 2;
3586   }
3587   if (dimension == 2)
3588     return Py_BuildValue("dddd", r[0], r[1], r[2], r[3]);
3589   else
3590     return Py_BuildValue("dddddd", r[0], r[1], r[2], r[3], r[4], r[5]);
3591 }
3592
3593 static PyObject *pycvGetMinMaxHistValue(PyObject *self, PyObject *args, PyObject *kw)
3594 {
3595   CvHistogram* hist;
3596   PyObject *pyobj_hist = NULL;
3597   float min_val;
3598   float max_val;
3599   int min_loc[CV_MAX_DIM];
3600   int max_loc[CV_MAX_DIM];
3601
3602   if (!PyArg_ParseTuple(args, "O", &pyobj_hist))
3603     return NULL;
3604   if (!convert_to_CvHistogram(pyobj_hist, &hist, "hist")) return NULL;
3605   ERRWRAP(cvGetMinMaxHistValue(hist, &min_val, &max_val, min_loc, max_loc));
3606   int d = cvGetDims(hist->bins);
3607   PyObject *pminloc = PyTuple_New(d), *pmaxloc = PyTuple_New(d);
3608   for (int i = 0; i < d; i++) {
3609     PyTuple_SetItem(pminloc, i, PyInt_FromLong(min_loc[i]));
3610     PyTuple_SetItem(pmaxloc, i, PyInt_FromLong(max_loc[i]));
3611   }
3612   return Py_BuildValue("ffNN", min_val, max_val, pminloc, pmaxloc);
3613 }
3614
3615 static CvSeq* cvHOGDetectMultiScale( const CvArr* image, CvMemStorage* storage,
3616   const CvArr* svm_classifier=NULL, CvSize win_stride=cvSize(0,0),
3617   double hit_threshold=0, double scale=1.05,
3618   int group_threshold=2, CvSize padding=cvSize(0,0),
3619   CvSize win_size=cvSize(64,128), CvSize block_size=cvSize(16,16),
3620   CvSize block_stride=cvSize(8,8), CvSize cell_size=cvSize(8,8),
3621   int nbins=9, int gammaCorrection=1 )
3622 {
3623     cv::HOGDescriptor hog(win_size, block_size, block_stride, cell_size, nbins, 1, -1, cv::HOGDescriptor::L2Hys, 0.2, gammaCorrection!=0);
3624     if(win_stride.width == 0 && win_stride.height == 0)
3625         win_stride = block_stride;
3626     cv::Mat img = cv::cvarrToMat(image);
3627     std::vector<cv::Rect> found;
3628     if(svm_classifier)
3629     {
3630         CvMat stub, *m = cvGetMat(svm_classifier, &stub);
3631         int sz = m->cols*m->rows;
3632         CV_Assert(CV_IS_MAT_CONT(m->type) && (m->cols == 1 || m->rows == 1) && CV_MAT_TYPE(m->type) == CV_32FC1);
3633         std::vector<float> w(sz);
3634         std::copy(m->data.fl, m->data.fl + sz, w.begin());
3635         hog.setSVMDetector(w);
3636     }
3637     else
3638         hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector());
3639     hog.detectMultiScale(img, found, hit_threshold, win_stride, padding, scale, group_threshold);
3640     CvSeq* seq = cvCreateSeq(cv::DataType<cv::Rect>::type, sizeof(CvSeq), sizeof(cv::Rect), storage);
3641     if(found.size())
3642         cvSeqPushMulti(seq, &found[0], (int)found.size());
3643     return seq;
3644 }
3645
3646 static int zero = 0;
3647
3648 /************************************************************************/
3649 /* Custom Validators */
3650
3651 #define CVPY_VALIDATE_DrawChessboardCorners() do { \
3652   if ((pattern_size.width * pattern_size.height) != corners.count) \
3653     return (PyObject*)failmsg("Size is %dx%d, but corner list is length %d", pattern_size.width, pattern_size.height, corners.count); \
3654   } while (0)
3655
3656 #define cvGetRotationMatrix2D cv2DRotationMatrix
3657
3658 /************************************************************************/
3659 /* Generated functions */
3660
3661 #define constCvMat const CvMat
3662 #define FROM_constCvMatPTR(x) FROM_CvMatPTR((CvMat*)x)
3663
3664
3665 #include "generated0.i"
3666
3667 static PyMethodDef methods[] = {
3668
3669 #if PYTHON_USE_NUMPY
3670   {"fromarray", pycvfromarray, METH_VARARGS, "fromarray(array) -> cvmatnd"},
3671 #endif
3672
3673   {"CreateHist", pycvCreateHist, METH_VARARGS, "CreateHist(dims, type, ranges, uniform = 1) -> hist"},
3674   {"CreateImage", pycvCreateImage, METH_VARARGS, "CreateImage(size, depth, channels) -> image"},
3675   {"CreateImageHeader", pycvCreateImageHeader, METH_VARARGS, "CreateImageHeader(size, depth, channels) -> image"},
3676   {"CreateMat", pycvCreateMat, METH_VARARGS, "CreateMat(row, cols, type) -> mat"},
3677   {"CreateMatHeader", pycvCreateMatHeader, METH_VARARGS, "CreateMatHeader(rows, cols, type) -> mat"},
3678   {"CreateMatND", pycvCreateMatND, METH_VARARGS, "CreateMatND(dims, type) -> matnd"},
3679   {"CreateMatNDHeader", pycvCreateMatNDHeader, METH_VARARGS, "CreateMatNDHeader(dims, type) -> matnd"},
3680   {"CreateMemStorage", pycvCreateMemStorage, METH_VARARGS, "CreateMemStorage(block_size) -> memstorage"},
3681   {"FindContours", (PyCFunction)pycvFindContours, METH_KEYWORDS, "FindContours(image, storage, mode=CV_RETR_LIST, method=CV_CHAIN_APPROX_SIMPLE, offset=(0, 0)) -> cvseq"},
3682   {"ApproxPoly", (PyCFunction)pycvApproxPoly, METH_KEYWORDS, "ApproxPoly(src_seq, storage, method, parameter=0, parameter2=0) -> None"},
3683   {"CreateData", pycvCreateData, METH_VARARGS, "CreateData(arr) -> None"},
3684   {"GetDims", pycvGetDims, METH_VARARGS, "GetDims(arr) -> dims"},
3685   {"GetImage", pycvGetImage, METH_VARARGS, "GetImage(cvmat) -> image"},
3686   {"GetMat", (PyCFunction)pycvGetMat, METH_KEYWORDS, "GetMat(image, allowND=0) -> cvmat"},
3687   {"Reshape", pycvReshape, METH_VARARGS, "Reshape(arr, new_cn, new_rows=0) -> cvmat"},
3688   {"ReshapeMatND", pycvReshapeMatND, METH_VARARGS, "Reshape(arr, new_cn, new_dims) -> matnd"},
3689   {"InitLineIterator", pycvInitLineIterator, METH_VARARGS, "InitLineIterator(image, pt1, pt2, connectivity=8, left_to_right=0) -> None"},
3690   {"LoadImage", (PyCFunction)pycvLoadImage, METH_KEYWORDS, "LoadImage(filename, iscolor=CV_LOAD_IMAGE_COLOR)"},
3691   {"SetData", pycvSetData, METH_VARARGS, "SetData(arr, data, step)"},
3692   {"SetMouseCallback", (PyCFunction)pycvSetMouseCallback, METH_KEYWORDS, "SetMouseCallback(window_name, on_mouse, param) -> None"},
3693   {"CreateTrackbar", (PyCFunction)pycvCreateTrackbar, METH_KEYWORDS, "CreateTrackbar(trackbar_name, window_name, value, count, on_change) -> None"},
3694   {"CalcEMD2", (PyCFunction)pycvCalcEMD2, METH_KEYWORDS, "CalcEMD2(signature1, signature2, distance_type, distance_func = None, cost_matrix=None, flow=None, lower_bound=None, userdata = None) -> float"},
3695   {"FindChessboardCorners", (PyCFunction)pycvFindChessboardCorners, METH_KEYWORDS, "FindChessboardCorners(image, pattern_size, flags=CV_CALIB_CB_ADAPTIVE_THRESH) -> success,corners"},
3696   {"FitLine", (PyCFunction)pycvFitLine, METH_KEYWORDS, "FitLine(points, dist_type, param, reps, aeps) -> line"},
3697   {"Subdiv2DLocate", pycvSubdiv2DLocate, METH_VARARGS, "Subdiv2DLocate(subdiv, pt) -> (loc, where)"},
3698   {"CalcOpticalFlowPyrLK", pycvCalcOpticalFlowPyrLK, METH_VARARGS, "CalcOpticalFlowPyrLK(prev, curr, prev_pyr, curr_pyr, prev_features, CvSize win_size, int level, criteria, flags, guesses = None) -> (curr_features, status, track_error)"},
3699   {"ClipLine", (PyCFunction)pycvClipLine, METH_KEYWORDS, "ClipLine(img, pt1, pt2) -> (clipped_pt1, clipped_pt2)"},
3700   {"GetHuMoments", (PyCFunction)pycvGetHuMoments, METH_KEYWORDS, "GetHuMoments(cvmoments) -> (h1, h2, h3, h4, h5, h5, h7)"},
3701   {"GetMinMaxHistValue", (PyCFunction)pycvGetMinMaxHistValue, METH_KEYWORDS, "GetMinMaxHistValue(hist) -> min_val,max_val,min_loc,max_loc"},
3702   {"WaitKey", (PyCFunction)pycvWaitKey, METH_KEYWORDS, "WaitKey(delay=0) -> int"},
3703   //{"CalcOpticalFlowFarneback", (PyCFunction)pycvCalcOpticalFlowFarneback, METH_KEYWORDS, "CalcOpticalFlowFarneback(prev, next, flow, pyr_scale=0.5, levels=3, win_size=15, iterations=3, poly_n=7, poly_sigma=1.5, flags=0) -> None"},
3704   //{"_HOGComputeDescriptors", (PyCFunction)pycvHOGComputeDescriptors, METH_KEYWORDS, "_HOGComputeDescriptors(image, win_stride=block_stride, locations=None, padding=(0,0), win_size=(64,128), block_size=(16,16), block_stride=(8,8), cell_size=(8,8), nbins=9, gammaCorrection=true) -> list_of_descriptors"},
3705   //{"_HOGDetect", (PyCFunction)pycvHOGDetect, METH_KEYWORDS, "_HOGDetect(image, svm_classifier, win_stride=block_stride, locations=None, padding=(0,0), win_size=(64,128), block_size=(16,16), block_stride=(8,8), cell_size=(8,8), nbins=9, gammaCorrection=true) -> list_of_points"},
3706   //{"_HOGDetectMultiScale", (PyCFunction)pycvHOGDetectMultiScale, METH_KEYWORDS, "_HOGDetectMultiScale(image, svm_classifier, win_stride=block_stride, scale=1.05, group_threshold=2, padding=(0,0), win_size=(64,128), block_size=(16,16), block_stride=(8,8), cell_size=(8,8), nbins=9, gammaCorrection=true) -> list_of_points"},
3707
3708   {"temp_test", temp_test, METH_VARARGS},
3709
3710 #include "generated1.i"
3711
3712   {NULL, NULL},
3713 };
3714
3715 /************************************************************************/
3716 /* Module init */
3717
3718 static int to_ok(PyTypeObject *to)
3719 {
3720   to->tp_alloc = PyType_GenericAlloc;
3721   to->tp_new = PyType_GenericNew;
3722   to->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
3723   return (PyType_Ready(to) == 0);
3724 }
3725
3726 #define MKTYPE(NAME)  do { NAME##_specials(); if (!to_ok(&NAME##_Type)) return; } while (0)
3727
3728 extern "C"
3729 #if defined WIN32 || defined _WIN32
3730 __declspec(dllexport)
3731 #endif
3732 void initcv()
3733 {
3734   PyObject *m, *d;
3735
3736   cvSetErrMode(CV_ErrModeParent);
3737
3738   MKTYPE(cvcontourtree);
3739   MKTYPE(cvfont);
3740   MKTYPE(cvhaarclassifiercascade);
3741   MKTYPE(cvhistogram);
3742   MKTYPE(cvlineiterator);
3743   MKTYPE(cvmat);
3744   MKTYPE(cvmatnd);
3745   MKTYPE(cvmemstorage);
3746   MKTYPE(cvmoments);
3747   MKTYPE(cvsubdiv2dedge);
3748   MKTYPE(cvrng);
3749   MKTYPE(cvseq);
3750   MKTYPE(cvset);
3751   MKTYPE(cvsubdiv2d);
3752   MKTYPE(cvsubdiv2dpoint);
3753   MKTYPE(iplimage);
3754   MKTYPE(memtrack);
3755
3756 #include "generated4.i"
3757
3758   m = Py_InitModule(MODULESTR"", methods);
3759   d = PyModule_GetDict(m);
3760
3761   opencv_error = PyErr_NewException((char*)MODULESTR".error", NULL, NULL);
3762   PyDict_SetItemString(d, "error", opencv_error);
3763
3764   // Couple of warnings about strict aliasing here.  Not clear how to fix.
3765   union {
3766     PyObject *o;
3767     PyTypeObject *to;
3768   } convert;
3769   convert.to = &iplimage_Type;
3770   PyDict_SetItemString(d, "iplimage", convert.o);
3771   convert.to = &cvmat_Type;
3772   PyDict_SetItemString(d, "cvmat", convert.o);
3773
3774 #define PUBLISH(I) PyDict_SetItemString(d, #I, PyInt_FromLong(I))
3775 #define PUBLISHU(I) PyDict_SetItemString(d, #I, PyLong_FromUnsignedLong(I))
3776
3777   PUBLISHU(IPL_DEPTH_8U);
3778   PUBLISHU(IPL_DEPTH_8S);
3779   PUBLISHU(IPL_DEPTH_16U);
3780   PUBLISHU(IPL_DEPTH_16S);
3781   PUBLISHU(IPL_DEPTH_32S);
3782   PUBLISHU(IPL_DEPTH_32F);
3783   PUBLISHU(IPL_DEPTH_64F);
3784
3785   PUBLISH(CV_LOAD_IMAGE_COLOR);
3786   PUBLISH(CV_LOAD_IMAGE_GRAYSCALE);
3787   PUBLISH(CV_LOAD_IMAGE_UNCHANGED);
3788   PUBLISH(CV_HIST_ARRAY);
3789   PUBLISH(CV_HIST_SPARSE);
3790   PUBLISH(CV_8U);
3791   PUBLISH(CV_8UC1);
3792   PUBLISH(CV_8UC2);
3793   PUBLISH(CV_8UC3);
3794   PUBLISH(CV_8UC4);
3795   PUBLISH(CV_8S);
3796   PUBLISH(CV_8SC1);
3797   PUBLISH(CV_8SC2);
3798   PUBLISH(CV_8SC3);
3799   PUBLISH(CV_8SC4);
3800   PUBLISH(CV_16U);
3801   PUBLISH(CV_16UC1);
3802   PUBLISH(CV_16UC2);
3803   PUBLISH(CV_16UC3);
3804   PUBLISH(CV_16UC4);
3805   PUBLISH(CV_16S);
3806   PUBLISH(CV_16SC1);
3807   PUBLISH(CV_16SC2);
3808   PUBLISH(CV_16SC3);
3809   PUBLISH(CV_16SC4);
3810   PUBLISH(CV_32S);
3811   PUBLISH(CV_32SC1);
3812   PUBLISH(CV_32SC2);
3813   PUBLISH(CV_32SC3);
3814   PUBLISH(CV_32SC4);
3815   PUBLISH(CV_32F);
3816   PUBLISH(CV_32FC1);
3817   PUBLISH(CV_32FC2);
3818   PUBLISH(CV_32FC3);
3819   PUBLISH(CV_32FC4);
3820   PUBLISH(CV_64F);
3821   PUBLISH(CV_64FC1);
3822   PUBLISH(CV_64FC2);
3823   PUBLISH(CV_64FC3);
3824   PUBLISH(CV_64FC4);
3825   PUBLISH(CV_NEXT_AROUND_ORG);
3826   PUBLISH(CV_NEXT_AROUND_DST);
3827   PUBLISH(CV_PREV_AROUND_ORG);
3828   PUBLISH(CV_PREV_AROUND_DST);
3829   PUBLISH(CV_NEXT_AROUND_LEFT);
3830   PUBLISH(CV_NEXT_AROUND_RIGHT);
3831   PUBLISH(CV_PREV_AROUND_LEFT);
3832   PUBLISH(CV_PREV_AROUND_RIGHT);
3833
3834   PUBLISH(CV_WINDOW_AUTOSIZE);
3835
3836   PUBLISH(CV_PTLOC_INSIDE);
3837   PUBLISH(CV_PTLOC_ON_EDGE);
3838   PUBLISH(CV_PTLOC_VERTEX);
3839   PUBLISH(CV_PTLOC_OUTSIDE_RECT);
3840
3841 #include "generated2.i"
3842
3843 #if 0
3844   {
3845     int sizes[] = { 10 } ;
3846     float ranges[] = { 0.0, 1.0 };
3847     // CvHistogram*h = cvCreateHist(1, sizes, CV_HIST_ARRAY);
3848     CvHistogram H;
3849     float data[10];
3850     CvHistogram*h = cvMakeHistHeaderForArray(1, sizes, &H, data);
3851     printf("h->type = %08x\n", h->type);
3852     printf("h->bins = %p\n", h->bins);
3853     printf("h->mat = %p\n", &(h->mat));
3854   }
3855 #endif
3856 }
3857