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