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