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