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