opencv/interfaces/python/cv.cpp

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