opencv/interfaces/python/cv.cpp

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