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