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