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