OpenCV - cv.cpp - OpenCV DevZone

cv.cpp

Matthew Baker, 2011-04-11 01:49 am

 #include <Python.h>
 #include <assert.h>
 #include <opencv/cxcore.h>
 #include <opencv/cv.h>
 #include <opencv/cvaux.h>
 #include <opencv/cvwimage.h>
 #include <opencv/highgui.h>
 #define MODULESTR "cv"
 static PyObject *opencv_error;
 struct memtrack_t {
   PyObject_HEAD
   void *ptr;
   Py_ssize_t size;
 };
 struct iplimage_t {
   PyObject_HEAD
   IplImage *a;
   PyObject *data;
   size_t offset;
 };
 struct cvmat_t {
   PyObject_HEAD
   CvMat *a;
   PyObject *data;
   size_t offset;
 };
 struct cvmatnd_t {
   PyObject_HEAD
   CvMatND *a;
   PyObject *data;
   size_t offset;
 };
 struct cvhistogram_t {
   PyObject_HEAD
   CvHistogram h;
   PyObject *bins;
 };
 struct cvmemstorage_t {
   PyObject_HEAD
   CvMemStorage *a;
 };
 struct cvseq_t {
   PyObject_HEAD
   CvSeq *a;
   PyObject *container;  // Containing cvmemstorage_t
 };
 struct cvset_t {
   PyObject_HEAD
   CvSet *a;
   PyObject *container;  // Containing cvmemstorage_t
   int i;
 };
 struct cvsubdiv2d_t {
   PyObject_HEAD
   CvSubdiv2D *a;
   PyObject *container;  // Containing cvmemstorage_t
 };
 struct cvsubdiv2dpoint_t {
   PyObject_HEAD
   CvSubdiv2DPoint *a;
   PyObject *container;  // Containing cvmemstorage_t
 };
 struct cvsubdiv2dedge_t {
   PyObject_HEAD
   CvSubdiv2DEdge a;
   PyObject *container;  // Containing cvmemstorage_t
 };
 struct cvlineiterator_t {
   PyObject_HEAD
   CvLineIterator iter;
   int count;
   int type;
 };
 typedef IplImage ROIplImage;
 typedef const CvMat ROCvMat;
 typedef PyObject PyCallableObject;
 struct cvfont_t {
   PyObject_HEAD
   CvFont a;
 };
 struct cvcontourtree_t {
   PyObject_HEAD
   CvContourTree *a;
 };
 struct cvrng_t {
   PyObject_HEAD
   CvRNG a;
 };
 static int is_iplimage(PyObject *o);
 static int is_cvmat(PyObject *o);
 static int is_cvmatnd(PyObject *o);
 static int convert_to_CvArr(PyObject *o, CvArr **dst, const char *name = "no_name");
 static int convert_to_IplImage(PyObject *o, IplImage **dst, const char *name = "no_name");
 static int convert_to_CvMat(PyObject *o, CvMat **dst, const char *name = "no_name");
 static int convert_to_CvMatND(PyObject *o, CvMatND **dst, const char *name = "no_name");
 static PyObject *what_data(PyObject *o);
 static PyObject *FROM_CvMat(CvMat *r);
 static PyObject *FROM_ROCvMatPTR(ROCvMat *r);
 static PyObject *shareDataND(PyObject *donor, CvMatND *pdonor, CvMatND *precipient);
 #define FROM_double(r)  PyFloat_FromDouble(r)
 #define FROM_float(r)  PyFloat_FromDouble(r)
 #define FROM_int(r)  PyInt_FromLong(r)
 #define FROM_int64(r)  PyLong_FromLongLong(r)
 #define FROM_unsigned(r)  PyLong_FromUnsignedLong(r)
 #define FROM_CvBox2D(r) Py_BuildValue("(ff)(ff)f", r.center.x, r.center.y, r.size.width, r.size.height, r.angle)
 #define FROM_CvScalar(r)  Py_BuildValue("(ffff)", r.val[0], r.val[1], r.val[2], r.val[3])
 #define FROM_CvPoint(r)  Py_BuildValue("(ii)", r.x, r.y)
 #define FROM_CvPoint2D32f(r) Py_BuildValue("(ff)", r.x, r.y)
 #define FROM_CvPoint3D64f(r) Py_BuildValue("(fff)", r.x, r.y, r.z)
 #define FROM_CvSize(r) Py_BuildValue("(ii)", r.width, r.height)
 #define FROM_CvRect(r) Py_BuildValue("(iiii)", r.x, r.y, r.width, r.height)
 #define FROM_CvSeqPTR(r) _FROM_CvSeqPTR(r, pyobj_storage)
 #define FROM_CvSubdiv2DPTR(r) _FROM_CvSubdiv2DPTR(r, pyobj_storage)
 #define FROM_CvPoint2D64f(r) Py_BuildValue("(ff)", r.x, r.y)
 #define FROM_CvConnectedComp(r) Py_BuildValue("(fNN)", (r).area, FROM_CvScalar((r).value), FROM_CvRect((r).rect))
 #if PYTHON_USE_NUMPY
 static PyObject *fromarray(PyObject *o, int allowND);
 #endif
 static void translate_error_to_exception(void)
+{
   PyErr_SetString(opencv_error, cvErrorStr(cvGetErrStatus()));
   cvSetErrStatus(0);
+}
 #define ERRCHK do { if (cvGetErrStatus() != 0) { translate_error_to_exception(); return NULL; } } while (0)
 #define ERRWRAP(F) \
     do { \
         try \
         { \
             F; \
         } \
         catch (const cv::Exception &e) \
         { \
            PyErr_SetString(opencv_error, e.err.c_str()); \
            return NULL; \
         } \
         ERRCHK; \
     } while(0)
 /************************************************************************/
 static int failmsg(const char *fmt, ...)
+{
   char str[1000];
   va_list ap;
   va_start(ap, fmt);
   vsnprintf(str, sizeof(str), fmt, ap);
   va_end(ap);
   PyErr_SetString(PyExc_TypeError, str);
   return 0;
+}
 /************************************************************************/
 /* These get/setters are polymorphic, used in both iplimage and cvmat */
 static PyObject *PyObject_FromCvScalar(CvScalar s, int type)
+{
   int i, spe = CV_MAT_CN(type);
   PyObject *r;
   if (spe > 1) {
     r = PyTuple_New(spe);
     for (i = 0; i < spe; i++)
       PyTuple_SET_ITEM(r, i, PyFloat_FromDouble(s.val[i]));
   } else {
     r = PyFloat_FromDouble(s.val[0]);
+  }
   return r;
+}
 static PyObject *cvarr_GetItem(PyObject *o, PyObject *key);
 static int cvarr_SetItem(PyObject *o, PyObject *key, PyObject *v);
 // o is a Python string or buffer object.  Return its size.
 static Py_ssize_t what_size(PyObject *o)
+{
   void *buffer;
   Py_ssize_t buffer_len;
   if (PyString_Check(o)) {
     return PyString_Size(o);
   } else if (PyObject_AsWriteBuffer(o, &buffer, &buffer_len) == 0) {
     return buffer_len;
   } else {
     assert(0);  // argument must be string or buffer.
     return 0;
+  }
+}
 /************************************************************************/
 CvMat *PyCvMat_AsCvMat(PyObject *o)
+{
   assert(0); // not yet implemented: reference counting for CvMat in Kalman is unclear...
   return NULL;
+}
 #define cvReleaseIplConvKernel(x) cvReleaseStructuringElement(x)
 #include "generated3.i"
 /* iplimage */
 static void iplimage_dealloc(PyObject *self)
+{
   iplimage_t *pc = (iplimage_t*)self;
   cvReleaseImageHeader((IplImage**)&pc->a);
   Py_DECREF(pc->data);
   PyObject_Del(self);
+}
 static PyObject *iplimage_repr(PyObject *self)
+{
   iplimage_t *cva = (iplimage_t*)self;
   IplImage* ipl = (IplImage*)(cva->a);
   char str[1000];
   sprintf(str, "<iplimage(");
   char *d = str + strlen(str);
   sprintf(d, "nChannels=%d ", ipl->nChannels);
   d += strlen(d);
   sprintf(d, "width=%d ", ipl->width);
   d += strlen(d);
   sprintf(d, "height=%d ", ipl->height);
   d += strlen(d);
   sprintf(d, "widthStep=%d ", ipl->widthStep);
   d += strlen(d);
   sprintf(d, ")>");
   return PyString_FromString(str);
+}
 static PyObject *iplimage_tostring(PyObject *self, PyObject *args)
+{
   iplimage_t *pc = (iplimage_t*)self;
   IplImage *i;
   if (!convert_to_IplImage(self, &i, "self"))
     return NULL;
   if (i == NULL)
     return NULL;
   int bps;
   switch (i->depth) {
   case IPL_DEPTH_8U:
   case IPL_DEPTH_8S:
     bps = 1;
     break;
   case IPL_DEPTH_16U:
   case IPL_DEPTH_16S:
     bps = 2;
     break;
   case IPL_DEPTH_32S:
   case IPL_DEPTH_32F:
     bps = 4;
     break;
   case IPL_DEPTH_64F:
     bps = 8;
     break;
   default:
     return (PyObject*)failmsg("Unrecognised depth %d", i->depth);
+  }
   int bpl = i->width * i->nChannels * bps;
   if (PyString_Check(pc->data) && bpl == i->widthStep && pc->offset == 0 && ((bpl * i->height) == what_size(pc->data))) {
     Py_INCREF(pc->data);
     return pc->data;
   } else {
     int l = bpl * i->height;
     char *s = new char[l];
     int y;
     for (y = 0; y < i->height; y++) {
       memcpy(s + y * bpl, i->imageData + y * i->widthStep, bpl);
+    }
     PyObject *r = PyString_FromStringAndSize(s, l);
     delete s;
     return r;
+  }
+}
 static struct PyMethodDef iplimage_methods[] =
+{
   {"tostring", iplimage_tostring, METH_VARARGS},
   {NULL,          NULL}
 };
 static PyObject *iplimage_getnChannels(iplimage_t *cva)
+{
   return PyInt_FromLong(((IplImage*)(cva->a))->nChannels);
+}
 static PyObject *iplimage_getwidth(iplimage_t *cva)
+{
   return PyInt_FromLong(((IplImage*)(cva->a))->width);
+}
 static PyObject *iplimage_getheight(iplimage_t *cva)
+{
   return PyInt_FromLong(((IplImage*)(cva->a))->height);
+}
 static PyObject *iplimage_getdepth(iplimage_t *cva)
+{
   return PyLong_FromUnsignedLong((unsigned)((IplImage*)(cva->a))->depth);
+}
 static PyObject *iplimage_getorigin(iplimage_t *cva)
+{
   return PyInt_FromLong(((IplImage*)(cva->a))->origin);
+}
 static void iplimage_setorigin(iplimage_t *cva, PyObject *v)
+{
   ((IplImage*)(cva->a))->origin = PyInt_AsLong(v);
+}
 static PyGetSetDef iplimage_getseters[] = {
   {(char*)"nChannels", (getter)iplimage_getnChannels, (setter)NULL, (char*)"nChannels", NULL},
   {(char*)"channels", (getter)iplimage_getnChannels, (setter)NULL, (char*)"nChannels", NULL},
   {(char*)"width", (getter)iplimage_getwidth, (setter)NULL, (char*)"width", NULL},
   {(char*)"height", (getter)iplimage_getheight, (setter)NULL, (char*)"height", NULL},
   {(char*)"depth", (getter)iplimage_getdepth, (setter)NULL, (char*)"depth", NULL},
   {(char*)"origin", (getter)iplimage_getorigin, (setter)iplimage_setorigin, (char*)"origin", NULL},
   {NULL}  /* Sentinel */
 };
 static PyMappingMethods iplimage_as_map = {
   NULL,
   &cvarr_GetItem,
   &cvarr_SetItem,
 };
 static PyTypeObject iplimage_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".iplimage",                          /*name*/
   sizeof(iplimage_t),                        /*basicsize*/
 };
 static void iplimage_specials(void)
+{
   iplimage_Type.tp_dealloc = iplimage_dealloc;
   iplimage_Type.tp_as_mapping = &iplimage_as_map;
   iplimage_Type.tp_repr = iplimage_repr;
   iplimage_Type.tp_methods = iplimage_methods;
   iplimage_Type.tp_getset = iplimage_getseters;
+}
 static int is_iplimage(PyObject *o)
+{
   return PyType_IsSubtype(o->ob_type, &iplimage_Type);
+}
 /************************************************************************/
 /* cvmat */
 static void cvmat_dealloc(PyObject *self)
+{
   cvmat_t *pc = (cvmat_t*)self;
   if (pc->data) {
     Py_DECREF(pc->data);
+  }
   cvFree(&pc->a);
   PyObject_Del(self);
+}
 static PyObject *cvmat_repr(PyObject *self)
+{
   CvMat *m = ((cvmat_t*)self)->a;
   char str[1000];
   sprintf(str, "<cvmat(");
   char *d = str + strlen(str);
   sprintf(d, "type=%08x ", m->type);
   d += strlen(d);
   switch (CV_MAT_DEPTH(m->type)) {
   case CV_8U: strcpy(d, "8U"); break;
   case CV_8S: strcpy(d, "8S"); break;
   case CV_16U: strcpy(d, "16U"); break;
   case CV_16S: strcpy(d, "16S"); break;
   case CV_32S: strcpy(d, "32S"); break;
   case CV_32F: strcpy(d, "32F"); break;
   case CV_64F: strcpy(d, "64F"); break;
+  }
   d += strlen(d);
   sprintf(d, "C%d ", CV_MAT_CN(m->type));
   d += strlen(d);
   sprintf(d, "rows=%d ", m->rows);
   d += strlen(d);
   sprintf(d, "cols=%d ", m->cols);
   d += strlen(d);
   sprintf(d, "step=%d ", m->step);
   d += strlen(d);
   sprintf(d, ")>");
   return PyString_FromString(str);
+}
 static PyObject *cvmat_tostring(PyObject *self, PyObject *args)
+{
   CvMat *m;
   if (!convert_to_CvMat(self, &m, "self"))
     return NULL;
   int bps;                     // bytes per sample
   switch (CV_MAT_DEPTH(m->type)) {
   case CV_8U:
   case CV_8S:
     bps = CV_MAT_CN(m->type) * 1;
     break;
   case CV_16U:
   case CV_16S:
     bps = CV_MAT_CN(m->type) * 2;
     break;
   case CV_32S:
   case CV_32F:
     bps = CV_MAT_CN(m->type) * 4;
     break;
   case CV_64F:
     bps = CV_MAT_CN(m->type) * 8;
     break;
   default:
     return (PyObject*)failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type));
+  }
   int bpl = m->cols * bps; // bytes per line
   cvmat_t *pc = (cvmat_t*)self;
   if (PyString_Check(pc->data) && bpl == m->step && pc->offset == 0 && ((bpl * m->rows) == what_size(pc->data))) {
     Py_INCREF(pc->data);
     return pc->data;
   } else {
     int l = bpl * m->rows;
     char *s = new char[l];
     int y;
     for (y = 0; y < m->rows; y++) {
       memcpy(s + y * bpl, m->data.ptr + y * m->step, bpl);
+    }
     PyObject *r = PyString_FromStringAndSize(s, l);
     delete s;
     return r;
+  }
+}
 static struct PyMethodDef cvmat_methods[] =
+{
   {"tostring", cvmat_tostring, METH_VARARGS},
   {NULL,          NULL}
 };
 static PyObject *cvmat_gettype(cvmat_t *cva)
+{
   return PyInt_FromLong(cvGetElemType(cva->a));
+}
 static PyObject *cvmat_getstep(cvmat_t *cva)
+{
   return PyInt_FromLong(cva->a->step);
+}
 static PyObject *cvmat_getrows(cvmat_t *cva)
+{
   return PyInt_FromLong(cva->a->rows);
+}
 static PyObject *cvmat_getcols(cvmat_t *cva)
+{
   return PyInt_FromLong(cva->a->cols);
+}
 static PyObject *cvmat_getchannels(cvmat_t *cva)
+{
   return PyInt_FromLong(CV_MAT_CN(cva->a->type));
+}
 #if PYTHON_USE_NUMPY
 #include "numpy/ndarrayobject.h"
 // A PyArrayInterface, with an associated python object that should be DECREF'ed on release
 struct arrayTrack {
   PyArrayInterface s;
   PyObject *o;
 };
 static void arrayTrackDtor(void *p)
+{
   struct arrayTrack *at = (struct arrayTrack *)p;
   delete at->s.shape;
   delete at->s.strides;
   if (at->s.descr)
     Py_DECREF(at->s.descr);
   Py_DECREF(at->o);
+}
 // Fill in fields of PyArrayInterface s using mtype.  This code is common
 // to cvmat and cvmatnd
 static void arrayinterface_common(PyArrayInterface *s, int mtype)
+{
   s->two = 2;
   switch (CV_MAT_DEPTH(mtype)) {
   case CV_8U:
     s->typekind = 'u';
     s->itemsize = 1;
     break;
   case CV_8S:
     s->typekind = 'i';
     s->itemsize = 1;
     break;
   case CV_16U:
     s->typekind = 'u';
     s->itemsize = 2;
     break;
   case CV_16S:
     s->typekind = 'i';
     s->itemsize = 2;
     break;
   case CV_32S:
     s->typekind = 'i';
     s->itemsize = 4;
     break;
   case CV_32F:
     s->typekind = 'f';
     s->itemsize = 4;
     break;
   case CV_64F:
     s->typekind = 'f';
     s->itemsize = 8;
     break;
   default:
     assert(0);
+  }
   s->flags = NPY_WRITEABLE | NPY_NOTSWAPPED;
+}
 static PyObject *cvmat_array_struct(cvmat_t *cva)
+{
   CvMat *m;
   convert_to_CvMat((PyObject *)cva, &m, "");
   arrayTrack *at = new arrayTrack;
   PyArrayInterface *s = &at->s;
   at->o = cva->data;
   Py_INCREF(at->o);
   arrayinterface_common(s, m->type);
   if (CV_MAT_CN(m->type) == 1) {
     s->nd = 2;
     s->shape = new npy_intp[2];
     s->shape[0] = m->rows;
     s->shape[1] = m->cols;
     s->strides = new npy_intp[2];
     s->strides[0] = m->step;
     s->strides[1] = s->itemsize;
   } else {
     s->nd = 3;
     s->shape = new npy_intp[3];
     s->shape[0] = m->rows;
     s->shape[1] = m->cols;
     s->shape[2] = CV_MAT_CN(m->type);
     s->strides = new npy_intp[3];
     s->strides[0] = m->step;
     s->strides[1] = s->itemsize * CV_MAT_CN(m->type);
     s->strides[2] = s->itemsize;
+  }
   s->data = (void*)(m->data.ptr);
   s->descr = PyList_New(1);
   char typestr[10];
   sprintf(typestr, "<%c%d", s->typekind, s->itemsize);
   PyList_SetItem(s->descr, 0, Py_BuildValue("(ss)", "x", typestr));
   return PyCObject_FromVoidPtr(s, arrayTrackDtor);
+}
 static PyObject *cvmatnd_array_struct(cvmatnd_t *cva)
+{
   CvMatND *m;
   convert_to_CvMatND((PyObject *)cva, &m, "");
   arrayTrack *at = new arrayTrack;
   PyArrayInterface *s = &at->s;
   at->o = cva->data;
   Py_INCREF(at->o);
   arrayinterface_common(s, m->type);
   int i;
   if (CV_MAT_CN(m->type) == 1) {
     s->nd = m->dims;
     s->shape = new npy_intp[s->nd];
     for (i = 0; i < s->nd; i++)
       s->shape[i] = m->dim[i].size;
     s->strides = new npy_intp[s->nd];
     for (i = 0; i < (s->nd - 1); i++)
       s->strides[i] = m->dim[i].step;
     s->strides[s->nd - 1] = s->itemsize;
   } else {
     s->nd = m->dims + 1;
     s->shape = new npy_intp[s->nd];
     for (i = 0; i < (s->nd - 1); i++)
       s->shape[i] = m->dim[i].size;
     s->shape[s->nd - 1] = CV_MAT_CN(m->type);
     s->strides = new npy_intp[s->nd];
     for (i = 0; i < (s->nd - 2); i++)
       s->strides[i] = m->dim[i].step;
     s->strides[s->nd - 2] = s->itemsize * CV_MAT_CN(m->type);
     s->strides[s->nd - 1] = s->itemsize;
+  }
   s->data = (void*)(m->data.ptr);
   s->descr = PyList_New(1);
   char typestr[10];
   sprintf(typestr, "<%c%d", s->typekind, s->itemsize);
   PyList_SetItem(s->descr, 0, Py_BuildValue("(ss)", "x", typestr));
   return PyCObject_FromVoidPtr(s, arrayTrackDtor);
+}
 #endif
 static PyGetSetDef cvmat_getseters[] = {
   {(char*)"type",   (getter)cvmat_gettype, (setter)NULL, (char*)"type",   NULL},
   {(char*)"step",   (getter)cvmat_getstep, (setter)NULL, (char*)"step",   NULL},
   {(char*)"rows",   (getter)cvmat_getrows, (setter)NULL, (char*)"rows",   NULL},
   {(char*)"cols",   (getter)cvmat_getcols, (setter)NULL, (char*)"cols",   NULL},
   {(char*)"channels",(getter)cvmat_getchannels, (setter)NULL, (char*)"channels",   NULL},
   {(char*)"width",  (getter)cvmat_getcols, (setter)NULL, (char*)"width",  NULL},
   {(char*)"height", (getter)cvmat_getrows, (setter)NULL, (char*)"height", NULL},
 #if PYTHON_USE_NUMPY
   {(char*)"__array_struct__", (getter)cvmat_array_struct, (setter)NULL, (char*)"__array_struct__", NULL},
 #endif
   {NULL}  /* Sentinel */
 };
 static PyMappingMethods cvmat_as_map = {
   NULL,
   &cvarr_GetItem,
   &cvarr_SetItem,
 };
 static PyTypeObject cvmat_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvmat",                      /*name*/
   sizeof(cvmat_t),                        /*basicsize*/
 };
 static int illegal_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
   PyErr_SetString(opencv_error, "Cannot create cvmat directly; use CreateMat() instead");
   return -1;
+}
 static void cvmat_specials(void)
+{
   cvmat_Type.tp_dealloc = cvmat_dealloc;
   cvmat_Type.tp_as_mapping = &cvmat_as_map;
   cvmat_Type.tp_repr = cvmat_repr;
   cvmat_Type.tp_methods = cvmat_methods;
   cvmat_Type.tp_getset = cvmat_getseters;
   cvmat_Type.tp_init = illegal_init;
+}
 static int is_cvmat(PyObject *o)
+{
   return PyType_IsSubtype(o->ob_type, &cvmat_Type);
+}
 /************************************************************************/
 /* cvmatnd */
 static void cvmatnd_dealloc(PyObject *self)
+{
   cvmatnd_t *pc = (cvmatnd_t*)self;
   Py_DECREF(pc->data);
   cvDecRefData(pc->a);
   cvFree(&pc->a);
   PyObject_Del(self);
+}
 static PyObject *cvmatnd_repr(PyObject *self)
+{
   CvMatND *m = ((cvmatnd_t*)self)->a;
   char str[1000];
   sprintf(str, "<cvmatnd(");
   char *d = str + strlen(str);
   sprintf(d, "type=%08x ", m->type);
   d += strlen(d);
   sprintf(d, ")>");
   return PyString_FromString(str);
+}
 static size_t cvmatnd_size(CvMatND *m)
+{
   int bps = 1;
   switch (CV_MAT_DEPTH(m->type)) {
   case CV_8U:
   case CV_8S:
     bps = CV_MAT_CN(m->type) * 1;
     break;
   case CV_16U:
   case CV_16S:
     bps = CV_MAT_CN(m->type) * 2;
     break;
   case CV_32S:
   case CV_32F:
     bps = CV_MAT_CN(m->type) * 4;
     break;
   case CV_64F:
     bps = CV_MAT_CN(m->type) * 8;
     break;
   default:
     assert(0);
+  }
   size_t l = bps;
   for (int d = 0; d < m->dims; d++) {
     l *= m->dim[d].size;
+  }
   return l;
+}
 static PyObject *cvmatnd_tostring(PyObject *self, PyObject *args)
+{
   CvMatND *m;
   if (!convert_to_CvMatND(self, &m, "self"))
     return NULL;
   int bps;
   switch (CV_MAT_DEPTH(m->type)) {
   case CV_8U:
   case CV_8S:
     bps = CV_MAT_CN(m->type) * 1;
     break;
   case CV_16U:
   case CV_16S:
     bps = CV_MAT_CN(m->type) * 2;
     break;
   case CV_32S:
   case CV_32F:
     bps = CV_MAT_CN(m->type) * 4;
     break;
   case CV_64F:
     bps = CV_MAT_CN(m->type) * 8;
     break;
   default:
     return (PyObject*)failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type));
+  }
   int l = bps;
   for (int d = 0; d < m->dims; d++) {
     l *= m->dim[d].size;
+  }
   int i[CV_MAX_DIM];
   int d;
   for (d = 0; d < m->dims; d++) {
     i[d] = 0;
+  }
   int rowsize = m->dim[m->dims-1].size * bps;
   char *s = new char[l];
   char *ps = s;
   int finished = 0;
   while (!finished) {
     memcpy(ps, cvPtrND(m, i), rowsize);
     ps += rowsize;
     for (d = m->dims - 2; 0 <= d; d--) {
       if (++i[d] < cvGetDimSize(m, d)) {
         break;
       } else {
         i[d] = 0;
+      }
+    }
     if (d < 0)
       finished = 1;
+  }
   return PyString_FromStringAndSize(s, ps - s);
+}
 static struct PyMethodDef cvmatnd_methods[] =
+{
   {"tostring", cvmatnd_tostring, METH_VARARGS},
   {NULL,          NULL}
 };
 static PyObject *cvmatnd_getchannels(cvmatnd_t *cva)
+{
   return PyInt_FromLong(CV_MAT_CN(cva->a->type));
+}
 static PyGetSetDef cvmatnd_getseters[] = {
 #if PYTHON_USE_NUMPY
   {(char*)"__array_struct__", (getter)cvmatnd_array_struct, (setter)NULL, (char*)"__array_struct__", NULL},
 #endif
   {(char*)"channels",(getter)cvmatnd_getchannels, (setter)NULL, (char*)"channels",   NULL},
   {NULL}  /* Sentinel */
 };
 static PyMappingMethods cvmatnd_as_map = {
   NULL,
   &cvarr_GetItem,
   &cvarr_SetItem,
 };
 static PyTypeObject cvmatnd_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvmatnd",                          /*name*/
   sizeof(cvmatnd_t),                        /*basicsize*/
 };
 static void cvmatnd_specials(void)
+{
   cvmatnd_Type.tp_dealloc = cvmatnd_dealloc;
   cvmatnd_Type.tp_as_mapping = &cvmatnd_as_map;
   cvmatnd_Type.tp_repr = cvmatnd_repr;
   cvmatnd_Type.tp_methods = cvmatnd_methods;
   cvmatnd_Type.tp_getset = cvmatnd_getseters;
+}
 static int is_cvmatnd(PyObject *o)
+{
   return PyType_IsSubtype(o->ob_type, &cvmatnd_Type);
+}
 /************************************************************************/
 /* cvhistogram */
 static void cvhistogram_dealloc(PyObject *self)
+{
   cvhistogram_t *cvh = (cvhistogram_t*)self;
   Py_DECREF(cvh->bins);
   PyObject_Del(self);
+}
 static PyTypeObject cvhistogram_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvhistogram",                /*name*/
   sizeof(cvhistogram_t),                  /*basicsize*/
 };
 static PyObject *cvhistogram_getbins(cvhistogram_t *cvh)
+{
   Py_INCREF(cvh->bins);
   return cvh->bins;
+}
 static PyGetSetDef cvhistogram_getseters[] = {
   {(char*)"bins", (getter)cvhistogram_getbins, (setter)NULL, (char*)"bins", NULL},
   {NULL}  /* Sentinel */
 };
 static void cvhistogram_specials(void)
+{
   cvhistogram_Type.tp_dealloc = cvhistogram_dealloc;
   cvhistogram_Type.tp_getset = cvhistogram_getseters;
+}
 /************************************************************************/
 /* cvlineiterator */
 static PyObject *cvlineiterator_iter(PyObject *o)
+{
   Py_INCREF(o);
   return o;
+}
 static PyObject *cvlineiterator_next(PyObject *o)
+{
   cvlineiterator_t *pi = (cvlineiterator_t*)o;
   if (pi->count) {
       pi->count--;
       CvScalar r;
       cvRawDataToScalar( (void*)(pi->iter.ptr), pi->type, &r);
       PyObject *pr = PyObject_FromCvScalar(r, pi->type);
       CV_NEXT_LINE_POINT(pi->iter);
       return pr;
   } else {
     return NULL;
+  }
+}
 static PyTypeObject cvlineiterator_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvlineiterator",             /*name*/
   sizeof(cvlineiterator_t),               /*basicsize*/
 };
 static void cvlineiterator_specials(void)
+{
   cvlineiterator_Type.tp_iter = cvlineiterator_iter;
   cvlineiterator_Type.tp_iternext = cvlineiterator_next;
+}
 /************************************************************************/
 /* memtrack */
 static void memtrack_dealloc(PyObject *self)
+{
   memtrack_t *pi = (memtrack_t*)self;
   // printf("===> memtrack_dealloc %p!\n", pi->ptr);
   cvFree(&pi->ptr);
   PyObject_Del(self);
+}
 static PyTypeObject memtrack_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".memtrack",                          /*name*/
   sizeof(memtrack_t),                        /*basicsize*/
 };
 Py_ssize_t memtrack_getreadbuffer(PyObject *self, Py_ssize_t segment, void **ptrptr)
+{
   *ptrptr = &((memtrack_t*)self)->ptr;
   return ((memtrack_t*)self)->size;
+}
 Py_ssize_t memtrack_getwritebuffer(PyObject *self, Py_ssize_t segment, void **ptrptr)
+{
   *ptrptr = ((memtrack_t*)self)->ptr;
   return ((memtrack_t*)self)->size;
+}
 Py_ssize_t memtrack_getsegcount(PyObject *self, Py_ssize_t *lenp)
+{
   return (Py_ssize_t)1;
+}
 PyBufferProcs memtrack_as_buffer = {
   memtrack_getreadbuffer,
   memtrack_getwritebuffer,
   memtrack_getsegcount
 };
 static void memtrack_specials(void)
+{
   memtrack_Type.tp_dealloc = memtrack_dealloc;
   memtrack_Type.tp_as_buffer = &memtrack_as_buffer;
+}
 /************************************************************************/
 /* cvmemstorage */
 static void cvmemstorage_dealloc(PyObject *self)
+{
   cvmemstorage_t *ps = (cvmemstorage_t*)self;
   cvReleaseMemStorage(&(ps->a));
   PyObject_Del(self);
+}
 static PyTypeObject cvmemstorage_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvmemstorage",               /*name*/
   sizeof(cvmemstorage_t),                 /*basicsize*/
 };
 static void cvmemstorage_specials(void)
+{
   cvmemstorage_Type.tp_dealloc = cvmemstorage_dealloc;
+}
 /************************************************************************/
 /* cvfont */
 static PyTypeObject cvfont_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvfont",                     /*name*/
   sizeof(cvfont_t),                       /*basicsize*/
 };
 static void cvfont_specials(void) { }
 /************************************************************************/
 /* cvrng */
 static PyTypeObject cvrng_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvrng",                     /*name*/
   sizeof(cvrng_t),                       /*basicsize*/
 };
 static void cvrng_specials(void)
+{
+}
 /************************************************************************/
 /* cvcontourtree */
 static PyTypeObject cvcontourtree_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvcontourtree",                     /*name*/
   sizeof(cvcontourtree_t),                       /*basicsize*/
 };
 static void cvcontourtree_specials(void) { }
 /************************************************************************/
 /* cvsubdiv2dedge */
 static PyTypeObject cvsubdiv2dedge_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvsubdiv2dedge",                     /*name*/
   sizeof(cvsubdiv2dedge_t),                       /*basicsize*/
 };
 static int cvsubdiv2dedge_compare(PyObject *o1, PyObject *o2)
+{
   cvsubdiv2dedge_t *e1 = (cvsubdiv2dedge_t*)o1;
   cvsubdiv2dedge_t *e2 = (cvsubdiv2dedge_t*)o2;
   if (e1->a < e2->a)
     return -1;
   else if (e1->a > e2->a)
     return 1;
   else
     return 0;
+}
 static PyObject *cvquadedge_repr(PyObject *self)
+{
   CvSubdiv2DEdge m = ((cvsubdiv2dedge_t*)self)->a;
   char str[1000];
   sprintf(str, "<cvsubdiv2dedge(");
   char *d = str + strlen(str);
   sprintf(d, "%zx.%d", m & ~3, (int)(m & 3));
   d += strlen(d);
   sprintf(d, ")>");
   return PyString_FromString(str);
+}
 static void cvsubdiv2dedge_specials(void) {
   cvsubdiv2dedge_Type.tp_compare = cvsubdiv2dedge_compare;
   cvsubdiv2dedge_Type.tp_repr = cvquadedge_repr;
+}
 /************************************************************************/
 /* cvseq */
 static void cvseq_dealloc(PyObject *self)
+{
   cvseq_t *ps = (cvseq_t*)self;
   Py_DECREF(ps->container);
   PyObject_Del(self);
+}
 static PyObject *cvseq_h_next(PyObject *self, PyObject *args);
 static PyObject *cvseq_h_prev(PyObject *self, PyObject *args);
 static PyObject *cvseq_v_next(PyObject *self, PyObject *args);
 static PyObject *cvseq_v_prev(PyObject *self, PyObject *args);
 static struct PyMethodDef cvseq_methods[] =
+{
   {"h_next", cvseq_h_next, METH_VARARGS},
   {"h_prev", cvseq_h_prev, METH_VARARGS},
   {"v_next", cvseq_v_next, METH_VARARGS},
   {"v_prev", cvseq_v_prev, METH_VARARGS},
   {NULL,          NULL}
 };
 static Py_ssize_t cvseq_seq_length(PyObject *o)
+{
   cvseq_t *ps = (cvseq_t*)o;
   if (ps->a == NULL)
     return (Py_ssize_t)0;
   else
     return (Py_ssize_t)(ps->a->total);
+}
 static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
+{
   cvseq_t *ps = (cvseq_t*)o;
   CvPoint *pt;
   struct pointpair{
     CvPoint a, b;
   } *pp;
   CvPoint2D32f *pt2;
   CvPoint3D32f *pt3;
   if (i < cvseq_seq_length(o)) {
     switch (CV_SEQ_ELTYPE(ps->a)) {
     case CV_SEQ_ELTYPE_POINT:
       pt = CV_GET_SEQ_ELEM(CvPoint, ps->a, i);
       return Py_BuildValue("ii", pt->x, pt->y);
     case CV_SEQ_ELTYPE_GENERIC:
       switch (ps->a->elem_size) {
       case sizeof(CvQuadEdge2D):
+        {
           cvsubdiv2dedge_t *r = PyObject_NEW(cvsubdiv2dedge_t, &cvsubdiv2dedge_Type);
           r->a = (CvSubdiv2DEdge)CV_GET_SEQ_ELEM(CvQuadEdge2D, ps->a, i);
           r->container = ps->container;
           Py_INCREF(r->container);
           return (PyObject*)r;
+        }
       case sizeof(CvConnectedComp):
+        {
           CvConnectedComp *cc = CV_GET_SEQ_ELEM(CvConnectedComp, ps->a, i);
           return FROM_CvConnectedComp(*cc);
+        }
       default:
         printf("seq elem size is %d\n", ps->a->elem_size);
         printf("KIND %d\n", CV_SEQ_KIND(ps->a));
         assert(0);
+      }
       return PyInt_FromLong(*CV_GET_SEQ_ELEM(unsigned char, ps->a, i));
     case CV_SEQ_ELTYPE_PTR:
     case CV_SEQ_ELTYPE_INDEX:
       return PyInt_FromLong(*CV_GET_SEQ_ELEM(int, ps->a, i));
     case CV_32SC4:
       pp = CV_GET_SEQ_ELEM(pointpair, ps->a, i);
       return Py_BuildValue("(ii),(ii)", pp->a.x, pp->a.y, pp->b.x, pp->b.y);
     case CV_32FC2:
       pt2 = CV_GET_SEQ_ELEM(CvPoint2D32f, ps->a, i);
       return Py_BuildValue("ff", pt2->x, pt2->y);
     case CV_SEQ_ELTYPE_POINT3D:
       pt3 = CV_GET_SEQ_ELEM(CvPoint3D32f, ps->a, i);
       return Py_BuildValue("fff", pt3->x, pt3->y, pt3->z);
     default:
       printf("Unknown element type %08x\n", CV_SEQ_ELTYPE(ps->a));
       assert(0);
       return NULL;
+    }
   } else
     return NULL;
+}
 static PyObject* cvseq_map_getitem(PyObject *o, PyObject *item)
+{
   if (PyInt_Check(item)) {
     long i = PyInt_AS_LONG(item);
     if (i < 0)
       i += cvseq_seq_length(o);
     return cvseq_seq_getitem(o, i);
   } else if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength, cur, i;
     PyObject* result;
     if (PySlice_GetIndicesEx((PySliceObject*)item, cvseq_seq_length(o),
          &start, &stop, &step, &slicelength) < 0) {
       return NULL;
+    }
     if (slicelength <= 0) {
       return PyList_New(0);
     } else {
       result = PyList_New(slicelength);
       if (!result) return NULL;
       for (cur = start, i = 0; i < slicelength;
            cur += step, i++) {
         PyList_SET_ITEM(result, i, cvseq_seq_getitem(o, cur));
+      }
       return result;
+    }
   } else {
     PyErr_SetString(PyExc_TypeError, "CvSeq indices must be integers");
     return NULL;
+  }
+}
 static
 PySequenceMethods cvseq_sequence = {
   cvseq_seq_length,
   NULL,
   NULL,
   cvseq_seq_getitem
 };
 static PyMappingMethods cvseq_mapping = {
   cvseq_seq_length,
   cvseq_map_getitem,
   NULL,
 };
 static PyTypeObject cvseq_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvseq",                          /*name*/
   sizeof(cvseq_t),                        /*basicsize*/
 };
 static void cvseq_specials(void)
+{
   cvseq_Type.tp_dealloc = cvseq_dealloc;
   cvseq_Type.tp_as_sequence = &cvseq_sequence;
   cvseq_Type.tp_as_mapping = &cvseq_mapping;
   cvseq_Type.tp_methods = cvseq_methods;
+}
 #define MK_ACCESSOR(FIELD) \
 static PyObject *cvseq_##FIELD(PyObject *self, PyObject *args) \
 { \
   cvseq_t *ps = (cvseq_t*)self; \
   CvSeq *s = ps->a; \
   if (s->FIELD == NULL) { \
     Py_RETURN_NONE; \
   } else { \
     cvseq_t *r = PyObject_NEW(cvseq_t, &cvseq_Type); \
     r->a = s->FIELD; \
     r->container = ps->container; \
     Py_INCREF(r->container); \
     return (PyObject*)r; \
   } \
+}
 MK_ACCESSOR(h_next)
 MK_ACCESSOR(h_prev)
 MK_ACCESSOR(v_next)
 MK_ACCESSOR(v_prev)
 #undef MK_ACCESSOR
 /************************************************************************/
 /* cvset */
 static void cvset_dealloc(PyObject *self)
+{
   cvset_t *ps = (cvset_t*)self;
   Py_DECREF(ps->container);
   PyObject_Del(self);
+}
 static PyTypeObject cvset_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvset",                          /*name*/
   sizeof(cvset_t),                        /*basicsize*/
 };
 static PyObject *cvset_iter(PyObject *o)
+{
   Py_INCREF(o);
   cvset_t *ps = (cvset_t*)o;
   ps->i = 0;
   return o;
+}
 static PyObject *cvset_next(PyObject *o)
+{
   cvset_t *ps = (cvset_t*)o;
   while (ps->i < ps->a->total) {
     CvSetElem *e = cvGetSetElem(ps->a, ps->i);
     int prev_i = ps->i++;
     if (e != NULL) {
       return cvseq_seq_getitem(o, prev_i);
+    }
+  }
   return NULL;
+}
 static void cvset_specials(void)
+{
   cvset_Type.tp_dealloc = cvset_dealloc;
   cvset_Type.tp_iter = cvset_iter;
   cvset_Type.tp_iternext = cvset_next;
+}
 /************************************************************************/
 /* cvsubdiv2d */
 static PyTypeObject cvsubdiv2d_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                          /*size*/
   MODULESTR".cvsubdiv2d",                     /*name*/
   sizeof(cvsubdiv2d_t),                       /*basicsize*/
 };
 static PyObject *cvsubdiv2d_getattro(PyObject *o, PyObject *name)
+{
   cvsubdiv2d_t *p = (cvsubdiv2d_t*)o;
   if (strcmp(PyString_AsString(name), "edges") == 0) {
     cvset_t *r = PyObject_NEW(cvset_t, &cvset_Type);
     r->a = p->a->edges;
     r->container = p->container;
     Py_INCREF(r->container);
     return (PyObject*)r;
   } else {
     PyErr_SetString(PyExc_TypeError, "cvsubdiv2d has no such attribute");
     return NULL;
+  }
+}
 static void cvsubdiv2d_specials(void)
+{
   cvsubdiv2d_Type.tp_getattro = cvsubdiv2d_getattro;
+}
 /************************************************************************/
 /* cvsubdiv2dpoint */
 static PyTypeObject cvsubdiv2dpoint_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
 ,                                      /*size*/
   MODULESTR".cvsubdiv2dpoint",                     /*name*/
   sizeof(cvsubdiv2dpoint_t),                       /*basicsize*/
 };
 static PyObject *cvsubdiv2dpoint_getattro(PyObject *o, PyObject *name)
+{
   cvsubdiv2dpoint_t *p = (cvsubdiv2dpoint_t*)o;
   if (strcmp(PyString_AsString(name), "first") == 0) {
     cvsubdiv2dedge_t *r = PyObject_NEW(cvsubdiv2dedge_t, &cvsubdiv2dedge_Type);
     r->a = p->a->first;
     r->container = p->container;
     Py_INCREF(r->container);
     return (PyObject*)r;
   } else if (strcmp(PyString_AsString(name), "pt") == 0) {
     return Py_BuildValue("(ff)", p->a->pt.x, p->a->pt.y);
   } else {
     PyErr_SetString(PyExc_TypeError, "cvsubdiv2dpoint has no such attribute");
     return NULL;
+  }
+}
 static void cvsubdiv2dpoint_specials(void)
+{
   cvsubdiv2dpoint_Type.tp_getattro = cvsubdiv2dpoint_getattro;
+}
 /************************************************************************/
 /* convert_to_X: used after PyArg_ParseTuple in the generated code  */
 static int convert_to_PyObjectPTR(PyObject *o, PyObject **dst, const char *name = "no_name")
+{
   *dst = o;
   return 1;
+}
 static int convert_to_PyCallableObjectPTR(PyObject *o, PyObject **dst, const char *name = "no_name")
+{
   *dst = o;
   return 1;
+}
 static int convert_to_char(PyObject *o, char *dst, const char *name = "no_name")
+{
   if (PyString_Check(o) && PyString_Size(o) == 1) {
     *dst = PyString_AsString(o)[0];
     return 1;
   } else {
     (*dst) = 0;
     return failmsg("Expected single character string for argument '%s'", name);
+  }
+}
 static int convert_to_CvMemStorage(PyObject *o, CvMemStorage **dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvmemstorage_Type)) {
     (*dst) = (((cvmemstorage_t*)o)->a);
     return 1;
   } else {
     (*dst) = (CvMemStorage*)NULL;
     return failmsg("Expected CvMemStorage for argument '%s'", name);
+  }
+}
 static int convert_to_CvSeq(PyObject *o, CvSeq **dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvseq_Type)) {
     (*dst) = (((cvseq_t*)o)->a);
     return 1;
   } else {
     (*dst) = (CvSeq*)NULL;
     return failmsg("Expected CvSeq for argument '%s'", name);
+  }
+}
 static int convert_to_CvSize(PyObject *o, CvSize *dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o, "ii", &dst->width, &dst->height))
     return failmsg("CvSize argument '%s' expects two integers", name);
   else
     return 1;
+}
 static int convert_to_CvScalar(PyObject *o, CvScalar *s, const char *name = "no_name")
+{
   if (PySequence_Check(o)) {
     PyObject *fi = PySequence_Fast(o, name);
     if (fi == NULL)
       return 0;
     if (4 < PySequence_Fast_GET_SIZE(fi))
         return failmsg("CvScalar value for argument '%s' is longer than 4", name);
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
       PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
       if (PyFloat_Check(item) || PyInt_Check(item)) {
         s->val[i] = PyFloat_AsDouble(item);
       } else {
         return failmsg("CvScalar value for argument '%s' is not numeric", name);
+      }
+    }
     Py_DECREF(fi);
   } else {
     if (PyFloat_Check(o) || PyInt_Check(o)) {
       s->val[0] = PyFloat_AsDouble(o);
     } else {
       return failmsg("CvScalar value for argument '%s' is not numeric", name);
+    }
+  }
   return 1;
+}
 static int convert_to_CvPointPTR(PyObject *o, CvPoint **p, const char *name = "no_name")
+{
   if (!PySequence_Check(o))
     return failmsg("Expected sequence for point list argument '%s'", name);
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   *p = new CvPoint[PySequence_Fast_GET_SIZE(fi)];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     if (!PyTuple_Check(item))
       return failmsg("Expected tuple for element in point list argument '%s'", name);
     if (!PyArg_ParseTuple(item, "ii", &((*p)[i].x), &((*p)[i].y))) {
       return 0;
+    }
+  }
   Py_DECREF(fi);
   return 1;
+}
 static int convert_to_CvPoint2D32fPTR(PyObject *o, CvPoint2D32f **p, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   *p = new CvPoint2D32f[PySequence_Fast_GET_SIZE(fi)];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     if (!PyTuple_Check(item))
       return failmsg("Expected tuple for CvPoint2D32f argument '%s'", name);
     if (!PyArg_ParseTuple(item, "ff", &((*p)[i].x), &((*p)[i].y))) {
       return 0;
+    }
+  }
   Py_DECREF(fi);
   return 1;
+}
 #if 0 // not used
 static int convert_to_CvPoint3D32fPTR(PyObject *o, CvPoint3D32f **p, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   *p = new CvPoint3D32f[PySequence_Fast_GET_SIZE(fi)];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     if (!PyTuple_Check(item))
       return failmsg("Expected tuple for CvPoint3D32f argument '%s'", name);
     if (!PyArg_ParseTuple(item, "fff", &((*p)[i].x), &((*p)[i].y), &((*p)[i].z))) {
       return 0;
+    }
+  }
   Py_DECREF(fi);
   return 1;
+}
 #endif
 static int convert_to_CvStarDetectorParams(PyObject *o, CvStarDetectorParams *dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o,
                         "iiiii",
                         &dst->maxSize,
                         &dst->responseThreshold,
                         &dst->lineThresholdProjected,
                         &dst->lineThresholdBinarized,
                         &dst->suppressNonmaxSize))
     return failmsg("CvRect argument '%s' expects four integers", name);
   else
     return 1;
+}
 static int convert_to_CvRect(PyObject *o, CvRect *dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o, "iiii", &dst->x, &dst->y, &dst->width, &dst->height))
     return failmsg("CvRect argument '%s' expects four integers", name);
   else
     return 1;
+}
 static int convert_to_CvRectPTR(PyObject *o, CvRect **dst, const char *name = "no_name")
+{
   *dst = new CvRect;
   if (!PyArg_ParseTuple(o, "iiii", &(*dst)->x, &(*dst)->y, &(*dst)->width, &(*dst)->height))
     return failmsg("CvRect argument '%s' expects four integers", name);
   else
     return 1;
+}
 static int convert_to_CvSlice(PyObject *o, CvSlice *dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o, "ii", &dst->start_index, &dst->end_index))
     return failmsg("CvSlice argument '%s' expects two integers", name);
   else
     return 1;
+}
 static int convert_to_CvPoint(PyObject *o, CvPoint *dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o, "ii", &dst->x, &dst->y))
     return failmsg("CvPoint argument '%s' expects two integers", name);
   else
     return 1;
+}
 static int convert_to_CvPoint2D32f(PyObject *o, CvPoint2D32f *dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o, "ff", &dst->x, &dst->y))
     return failmsg("CvPoint2D32f argument '%s' expects two floats", name);
   else
     return 1;
+}
 static int convert_to_CvPoint3D32f(PyObject *o, CvPoint3D32f *dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o, "fff", &dst->x, &dst->y, &dst->z))
     return failmsg("CvPoint3D32f argument '%s' expects three floats", name);
   else
     return 1;
+}
 static int convert_to_IplImage(PyObject *o, IplImage **dst, const char *name)
+{
   iplimage_t *ipl = (iplimage_t*)o;
   void *buffer;
   Py_ssize_t buffer_len;
   if (!is_iplimage(o)) {
     return failmsg("Argument '%s' must be IplImage", name);
   } else if (PyString_Check(ipl->data)) {
     cvSetData(ipl->a, PyString_AsString(ipl->data) + ipl->offset, ipl->a->widthStep);
     assert(cvGetErrStatus() == 0);
     *dst = ipl->a;
     return 1;
   } else if (ipl->data && PyObject_AsWriteBuffer(ipl->data, &buffer, &buffer_len) == 0) {
     cvSetData(ipl->a, (void*)((char*)buffer + ipl->offset), ipl->a->widthStep);
     assert(cvGetErrStatus() == 0);
     *dst = ipl->a;
     return 1;
   } else {
     return failmsg("IplImage argument '%s' has no data", name);
+  }
+}
 static int convert_to_CvMat(PyObject *o, CvMat **dst, const char *name)
+{
   cvmat_t *m = (cvmat_t*)o;
   void *buffer;
   Py_ssize_t buffer_len;
   if (!is_cvmat(o)) {
 #if !PYTHON_USE_NUMPY
     return failmsg("Argument '%s' must be CvMat", name);
 #else
     PyObject *asmat = fromarray(o, 0);
     if (asmat == NULL)
       return failmsg("Argument '%s' must be CvMat", name);
     // now have the array obect as a cvmat, can use regular conversion
     return convert_to_CvMat(asmat, dst, name);
 #endif
   } else {
     m->a->refcount = NULL;
     if (m->data && PyString_Check(m->data)) {
       assert(cvGetErrStatus() == 0);
       char *ptr = PyString_AsString(m->data) + m->offset;
       cvSetData(m->a, ptr, m->a->step);
       assert(cvGetErrStatus() == 0);
       *dst = m->a;
       return 1;
     } else if (m->data && PyObject_AsWriteBuffer(m->data, &buffer, &buffer_len) == 0) {
       cvSetData(m->a, (void*)((char*)buffer + m->offset), m->a->step);
       assert(cvGetErrStatus() == 0);
       *dst = m->a;
       return 1;
     } else {
       return failmsg("CvMat argument '%s' has no data", name);
+    }
+  }
+}
 static int convert_to_CvMatND(PyObject *o, CvMatND **dst, const char *name)
+{
   cvmatnd_t *m = (cvmatnd_t*)o;
   void *buffer;
   Py_ssize_t buffer_len;
   if (!is_cvmatnd(o)) {
     return failmsg("Argument '%s' must be CvMatND", name);
   } else if (m->data && PyString_Check(m->data)) {
     m->a->data.ptr = ((uchar*)PyString_AsString(m->data)) + m->offset;
     *dst = m->a;
     return 1;
   } else if (m->data && PyObject_AsWriteBuffer(m->data, &buffer, &buffer_len) == 0) {
     m->a->data.ptr = ((uchar*)buffer + m->offset);
     *dst = m->a;
     return 1;
   } else {
     return failmsg("CvMatND argument '%s' has no data", name);
+  }
+}
 static int convert_to_CvArr(PyObject *o, CvArr **dst, const char *name)
+{
   if (o == Py_None) {
     *dst = (void*)NULL;
     return 1;
   } else if (is_iplimage(o)) {
     return convert_to_IplImage(o, (IplImage**)dst, name);
   } else if (is_cvmat(o)) {
     return convert_to_CvMat(o, (CvMat**)dst, name);
   } else if (is_cvmatnd(o)) {
     return convert_to_CvMatND(o, (CvMatND**)dst, name);
   } else {
 #if !PYTHON_USE_NUMPY
     return failmsg("CvArr argument '%s' must be IplImage, CvMat or CvMatND", name);
 #else
     PyObject *asmat = fromarray(o, 0);
     if (asmat == NULL)
       return failmsg("CvArr argument '%s' must be IplImage, CvMat, CvMatND, or support the array interface", name);
     // now have the array obect as a cvmat, can use regular conversion
     return convert_to_CvArr(asmat, dst, name);
 #endif
+  }
+}
 static int convert_to_CvHistogram(PyObject *o, CvHistogram **dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvhistogram_Type)) {
     cvhistogram_t *ht = (cvhistogram_t*)o;
     *dst = &ht->h;
     return convert_to_CvArr(ht->bins, &(ht->h.bins), "bins");
   } else {
     *dst = (CvHistogram *)NULL;
     return failmsg("Expected CvHistogram for argument '%s'", name);
+  }
+}
 // Used by FillPoly, FillConvexPoly, PolyLine
 struct pts_npts_contours {
   CvPoint** pts;
   int* npts;
   int contours;
 };
 static int convert_to_pts_npts_contours(PyObject *o, pts_npts_contours *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->contours = PySequence_Fast_GET_SIZE(fi);
   dst->pts = new CvPoint*[dst->contours];
   dst->npts = new int[dst->contours];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     if (!convert_to_CvPointPTR(PySequence_Fast_GET_ITEM(fi, i), &dst->pts[i], name))
       return 0;
     dst->npts[i] = PySequence_Size(PySequence_Fast_GET_ITEM(fi, i)); // safe because convert_ just succeeded
+  }
   Py_DECREF(fi);
   return 1;
+}
 struct cvarrseq {
   union {
     CvSeq *seq;
     CvArr *mat;
   };
 };
 static int is_convertible_to_mat(PyObject *o)
+{
 #if PYTHON_USE_NUMPY
   if (PyObject_HasAttrString(o, "__array_struct__")) {
     PyObject *ao = PyObject_GetAttrString(o, "__array_struct__");
     if (ao != NULL &&
         PyCObject_Check(ao) &&
         ((PyArrayInterface*)PyCObject_AsVoidPtr(ao))->two == 2) {
       return 1;
+    }
+  }
 #endif
   return is_iplimage(o) && is_cvmat(o) && is_cvmatnd(o);
+}
 static int convert_to_cvarrseq(PyObject *o, cvarrseq *dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvseq_Type)) {
     return convert_to_CvSeq(o, &(dst->seq), name);
   } else if (is_convertible_to_mat(o)) {
     int r = convert_to_CvArr(o, &(dst->mat), name);
     return r;
   } else if (PySequence_Check(o)) {
     PyObject *fi = PySequence_Fast(o, name);
     if (fi == NULL)
       return 0;
     Py_ssize_t size = -1;
     // Make a pass through the sequence, checking that each element is
     // a sequence and that they are all the same size
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
       PyObject *e = PySequence_Fast_GET_ITEM(fi, i);
       if (!PySequence_Check(e))
         return failmsg("Sequence '%s' must contain sequences", name);
       if (i == 0)
         size = (int)PySequence_Size(e);
       else if (size != PySequence_Size(e))
         return failmsg("All elements of sequence '%s' must be same size", name);
+    }
     assert(size != -1);
     CvMat *mt = cvCreateMat((int)PySequence_Fast_GET_SIZE(fi), 1, CV_32SC(size));
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
       PyObject *e = PySequence_Fast_GET_ITEM(fi, i);
       PyObject *fe = PySequence_Fast(e, name);
       assert(fe != NULL);
       int *pdst = (int*)cvPtr2D(mt, i, 0);
       for (Py_ssize_t j = 0; j < size; j++) {
         PyObject *num = PySequence_Fast_GET_ITEM(fe, j);
         if (!PyNumber_Check(num)) {
           return failmsg("Sequence must contain numbers", name);
+        }
         *pdst++ = PyInt_AsLong(num);
+      }
       Py_DECREF(fe);
+    }
     Py_DECREF(fi);
     dst->mat = mt;
     return 1;
   } else {
     return failmsg("Argument '%s' must be CvSeq, CvArr, or a sequence of numbers");
+  }
+}
 struct cvarr_count {
   CvArr **cvarr;
   int count;
 };
 static int convert_to_cvarr_count(PyObject *o, cvarr_count *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->cvarr = new CvArr*[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     if (!convert_to_CvArr(PySequence_Fast_GET_ITEM(fi, i), &dst->cvarr[i], name))
       return 0;
+  }
   Py_DECREF(fi);
   return 1;
+}
 struct intpair
+{
   int *pairs;
   int count;
 };
 static int convert_to_intpair(PyObject *o, intpair *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->pairs = new int[2 * dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     if (!PyArg_ParseTuple(item, "ii", &dst->pairs[2 * i], &dst->pairs[2 * i + 1])) {
       return 0;
+    }
+  }
   Py_DECREF(fi);
   return 1;
+}
 struct cvpoint2d32f_count {
   CvPoint2D32f* points;
   int count;
 };
 static int convert_to_cvpoint2d32f_count(PyObject *o, cvpoint2d32f_count *dst, const char *name = "no_name")
+{
   if (PyInt_Check(o)) {
     dst->count = PyInt_AsLong(o);
     dst->points = new CvPoint2D32f[dst->count];
     return 1;
   } else {
     return failmsg("Expected integer for CvPoint2D32f count");
+  }
+}
 struct floats {
   float *f;
   int count;
 };
 static int convert_to_floats(PyObject *o, floats *dst, const char *name = "no_name")
+{
   if (PySequence_Check(o)) {
     PyObject *fi = PySequence_Fast(o, name);
     if (fi == NULL)
       return 0;
     dst->count = PySequence_Fast_GET_SIZE(fi);
     dst->f = new float[dst->count];
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
       PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
       dst->f[i] = (float)PyFloat_AsDouble(item);
+    }
     Py_DECREF(fi);
   } else if (PyNumber_Check(o)) {
     dst->count = 1;
     dst->f = new float[1];
     dst->f[0] = (float)PyFloat_AsDouble(o);
   } else {
     return failmsg("Expected list of floats, or float for argument '%s'", name);
+  }
   return 1;
+}
 struct chars {
   char *f;
   int count;
 };
 /// convert_to_chars not used
 struct CvPoints {
   CvPoint *p;
   int count;
 };
 static int convert_to_CvPoints(PyObject *o, CvPoints *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->p = new CvPoint[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     convert_to_CvPoint(item, &dst->p[i], name);
+  }
   Py_DECREF(fi);
   return 1;
+}
 struct CvPoint3D32fs {
   CvPoint3D32f *p;
   int count;
 };
 static int convert_to_CvPoint3D32fs(PyObject *o, CvPoint3D32fs *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->p = new CvPoint3D32f[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     convert_to_CvPoint3D32f(item, &dst->p[i], name);
+  }
   Py_DECREF(fi);
   return 1;
+}
 struct CvPoint2D32fs {
   CvPoint2D32f *p;
   int count;
 };
 static int convert_to_CvPoint2D32fs(PyObject *o, CvPoint2D32fs *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->p = new CvPoint2D32f[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     convert_to_CvPoint2D32f(item, &dst->p[i], name);
+  }
   Py_DECREF(fi);
   return 1;
+}
 struct ints {
   int *i;
   int count;
 };
 static int convert_to_ints(PyObject *o, ints *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->i = new int[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     dst->i[i] = PyInt_AsLong(item);
+  }
   Py_DECREF(fi);
   return 1;
+}
 struct ints0 {
   int *i;
   int count;
 };
 static int convert_to_ints0(PyObject *o, ints0 *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->i = new int[dst->count + 1];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     dst->i[i] = PyInt_AsLong(item);
+  }
   dst->i[dst->count] = 0;
   Py_DECREF(fi);
   return 1;
+}
 struct dims
+{
   int count;
   int i[CV_MAX_DIM];
   int step[CV_MAX_DIM];
   int length[CV_MAX_DIM];
 };
 static int convert_to_dim(PyObject *item, int i, dims *dst, CvArr *cva, const char *name = "no_name")
+{
   if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
     PySlice_GetIndicesEx((PySliceObject*)item, cvGetDimSize(cva, i), &start, &stop, &step, &slicelength);
     dst->i[i] = start;
     dst->step[i] = step;
     dst->length[i] = slicelength;
   } else {
     int index = PyInt_AsLong(item);
     if (0 <= index)
       dst->i[i] = index;
     else
       dst->i[i] = cvGetDimSize(cva, i) + index;
     dst->step[i] = 0;
     dst->length[i] = 1;
+  }
   return 1;
+}
 static int convert_to_dims(PyObject *o, dims *dst, CvArr *cva, const char *name = "no_name")
+{
   if (!PyTuple_Check(o)) {
     dst->count = 1;
     return convert_to_dim(o, 0, dst, cva, name);
   } else {
     PyObject *fi = PySequence_Fast(o, name);
     if (fi == NULL) {
       PyErr_SetString(PyExc_TypeError, "Expected tuple for index");
       return 0;
+    }
     dst->count = PySequence_Fast_GET_SIZE(fi);
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
       if (i >= cvGetDims(cva)) {
         return failmsg("Access specifies %d dimensions, but array only has %d", PySequence_Fast_GET_SIZE(fi), cvGetDims(cva));
+      }
       PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
       if (!convert_to_dim(item, i, dst, cva, name))
         return 0;
+    }
     Py_DECREF(fi);
     return 1;
+  }
+}
 struct IplImages {
   IplImage **ims;
   int count;
 };
 static int convert_to_IplImages(PyObject *o, IplImages *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->ims = new IplImage*[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     if (!convert_to_IplImage(item, &dst->ims[i]))
       return 0;
+  }
   Py_DECREF(fi);
   return 1;
+}
 struct CvArrs {
   CvArr **ims;
   int count;
 };
 static int convert_to_CvArrs(PyObject *o, CvArrs *dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   dst->count = PySequence_Fast_GET_SIZE(fi);
   dst->ims = new CvArr*[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     if (!convert_to_CvArr(item, &dst->ims[i]))
       return 0;
+  }
   Py_DECREF(fi);
   return 1;
+}
 static int convert_to_floatPTRPTR(PyObject *o, float*** dst, const char *name = "no_name")
+{
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
   Py_ssize_t sz = PySequence_Fast_GET_SIZE(fi);
   float **r = new float*[sz];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
     floats ff;
     if (!convert_to_floats(item, &ff))
       return 0;
     r[i] = ff.f;
+  }
   *dst = r;
   return 1;
+}
 static int convert_to_CvFontPTR(PyObject *o, CvFont** dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvfont_Type)) {
     (*dst) = &(((cvfont_t*)o)->a);
     return 1;
   } else {
     (*dst) = (CvFont*)NULL;
     return failmsg("Expected CvFont for argument '%s'", name);
+  }
+}
 static int convert_to_CvContourTreePTR(PyObject *o, CvContourTree** dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvcontourtree_Type)) {
     (*dst) = ((cvcontourtree_t*)o)->a;
     return 1;
   } else {
     (*dst) = NULL;
     return failmsg("Expected CvContourTree for argument '%s'", name);
+  }
+}
 static int convert_to_CvRNGPTR(PyObject *o, CvRNG** dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvrng_Type)) {
     (*dst) = &(((cvrng_t*)o)->a);
     return 1;
   } else {
     (*dst) = (CvRNG*)NULL;
     return failmsg("Expected CvRNG for argument '%s'", name);
+  }
+}
 typedef void* generic;
 static int convert_to_generic(PyObject *o, generic *dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &iplimage_Type))
     return convert_to_IplImage(o, (IplImage**)dst, name);
   else if (PyType_IsSubtype(o->ob_type, &cvmat_Type))
     return convert_to_CvMat(o, (CvMat**)dst, name);
   else if (PyType_IsSubtype(o->ob_type, &cvmatnd_Type))
     return convert_to_CvMatND(o, (CvMatND**)dst, name);
   else {
     return failmsg("Cannot identify type of '%s'", name);
+  }
+}
 static int convert_to_CvTermCriteria(PyObject *o, CvTermCriteria* dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o, "iid", &dst->type, &dst->max_iter, &dst->epsilon))
     return 0;
   return 1;
+}
 static int convert_to_CvBox2D(PyObject *o, CvBox2D* dst, const char *name = "no_name")
+{
   if (!PyArg_ParseTuple(o, "(ff)(ff)f", &dst->center.x, &dst->center.y, &dst->size.width, &dst->size.height, &dst->angle))
     return 0;
   return 1;
+}
 static int convert_to_CvSubdiv2DPTR(PyObject *o, CvSubdiv2D** dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvsubdiv2d_Type)) {
     (*dst) = (((cvsubdiv2d_t*)o)->a);
     return 1;
   } else {
     (*dst) = (CvSubdiv2D*)NULL;
     return failmsg("Expected CvSubdiv2D for argument '%s'", name);
+  }
+}
 static int convert_to_CvNextEdgeType(PyObject *o, CvNextEdgeType *dst, const char *name = "no_name")
+{
   if (!PyInt_Check(o)) {
     *dst = (CvNextEdgeType)NULL;
     return failmsg("Expected number for CvNextEdgeType argument '%s'", name);
   } else {
     *dst = (CvNextEdgeType)PyInt_AsLong(o);
     return 1;
+  }
+}
 static int convert_to_CvSubdiv2DEdge(PyObject *o, CvSubdiv2DEdge *dst, const char *name = "no_name")
+{
   if (PyType_IsSubtype(o->ob_type, &cvsubdiv2dedge_Type)) {
     (*dst) = (((cvsubdiv2dedge_t*)o)->a);
     return 1;
   } else {
     *dst = 0L;
     return failmsg("Expected CvSubdiv2DEdge for argument '%s'", name);
+  }
+}
 /************************************************************************/
 static PyObject *pythonize_CvMat(cvmat_t *m)
+{
   // Need to make this CvMat look like any other, with a Python
   // buffer object as its data.
   CvMat *mat = m->a;
   assert(mat->step != 0);
 #if 0
   PyObject *data = PyString_FromStringAndSize((char*)(mat->data.ptr), mat->rows * mat->step);
 #else
   memtrack_t *o = PyObject_NEW(memtrack_t, &memtrack_Type);
   size_t gap = mat->data.ptr - (uchar*)mat->refcount;
   o->ptr = mat->refcount;
   o->size = gap + mat->rows * mat->step;
   PyObject *data = PyBuffer_FromReadWriteObject((PyObject*)o, (size_t)gap, mat->rows * mat->step);
   if (data == NULL)
     return NULL;
 #endif
   m->data = data;
   m->offset = 0;
   Py_DECREF(o);
   // Now m has a reference to data, which has a reference to o.
   return (PyObject*)m;
+}
 static PyObject *pythonize_foreign_CvMat(cvmat_t *m)
+{
   // Need to make this CvMat look like any other, with a Python
   // buffer object as its data.
   // Difference here is that the buffer is 'foreign' (from NumPy, for example)
   CvMat *mat = m->a;
   assert(mat->step != 0);
 #if 0
   PyObject *data = PyString_FromStringAndSize((char*)(mat->data.ptr), mat->rows * mat->step);
 #else
   memtrack_t *o = PyObject_NEW(memtrack_t, &memtrack_Type);
   o->ptr = mat->data.ptr;
   o->size = mat->rows * mat->step;
   PyObject *data = PyBuffer_FromReadWriteObject((PyObject*)o, (size_t)0, mat->rows * mat->step);
   if (data == NULL)
     return NULL;
   Py_INCREF(o);   // XXX - hack to prevent free of this foreign memory
 #endif
   m->data = data;
   m->offset = 0;
   Py_DECREF(o);
   // Now m has a reference to data, which has a reference to o.
   return (PyObject*)m;
+}
 static PyObject *pythonize_IplImage(iplimage_t *cva)
+{
   // Need to make this iplimage look like any other, with a Python
   // string as its data.
   // So copy the image data into a Python string object, then release
   // it.
   IplImage *ipl = (IplImage*)(cva->a);
   // PyObject *data = PyString_FromStringAndSize(ipl->imageData, ipl->imageSize);
   memtrack_t *o = PyObject_NEW(memtrack_t, &memtrack_Type);
   assert(ipl->imageDataOrigin == ipl->imageData);
   o->ptr = ipl->imageDataOrigin;
   o->size = ipl->height * ipl->widthStep;
   PyObject *data = PyBuffer_FromReadWriteObject((PyObject*)o, (size_t)0, o->size);
   if (data == NULL)
     return NULL;
   Py_DECREF(o);
   cva->data = data;
   cva->offset = 0;
   return (PyObject*)cva;
+}
 static PyObject *pythonize_CvMatND(cvmatnd_t *m)
+{
   //
   // Need to make this CvMatND look like any other, with a Python
   // string as its data.
   // So copy the image data into a Python string object, then release
   // it.
   //
   CvMatND *mat = m->a;
   assert(mat->dim[0].step != 0);
 #if 0
   PyObject *data = PyString_FromStringAndSize((char*)(mat->data.ptr), mat->dim[0].size * mat->dim[0].step);
 #else
   memtrack_t *o = PyObject_NEW(memtrack_t, &memtrack_Type);
   o->ptr = cvPtr1D(mat, 0);
   o->size = cvmatnd_size(mat);
   PyObject *data = PyBuffer_FromReadWriteObject((PyObject*)o, (size_t)0, o->size);
   if (data == NULL)
     return NULL;
 #endif
   m->data = data;
   m->offset = 0;
   // cvDecRefData(mat); // Ref count should be zero here, so this is a release
   return (PyObject*)m;
+}
 /************************************************************************/
 /* FROM_xxx:   C -> Python converters.
+ *
  * Turn various OpenCV types (and some aggregate types above)
  * into Python objects.  Used by the generated code.
+ *
  * All these functions and macros return a new reference.
  */
 static PyObject *_FROM_CvSeqPTR(CvSeq *s, PyObject *storage)
+{
   cvseq_t *ps = PyObject_NEW(cvseq_t, &cvseq_Type);
   ps->a = s;
   ps->container = storage;
   Py_INCREF(ps->container);
   return (PyObject*)ps;
+}
 static PyObject *_FROM_CvSubdiv2DPTR(CvSubdiv2D *s, PyObject *storage)
+{
   cvsubdiv2d_t *ps = PyObject_NEW(cvsubdiv2d_t, &cvsubdiv2d_Type);
   ps->a = s;
   ps->container = storage;
   Py_INCREF(ps->container);
   return (PyObject*)ps;
+}
 static PyObject *FROM_floats(floats r)
+{
   PyObject *pr;
   pr = PyList_New(r.count);
   for (Py_ssize_t i = 0; i < (Py_ssize_t)r.count; i++) {
     PyList_SetItem(pr, i, PyFloat_FromDouble(r.f[i]));
+  }
   return pr;
+}
 static PyObject *FROM_chars(chars r)
+{
   PyObject *pr;
   pr = PyList_New(r.count);
   for (Py_ssize_t i = 0; i < (Py_ssize_t)r.count; i++) {
     PyList_SetItem(pr, i, PyInt_FromLong(r.f[i]));
+  }
   return pr;
+}
 static PyObject *FROM_cvpoint2d32f_count(cvpoint2d32f_count r)
+{
   PyObject *pr;
   pr = PyList_New(r.count);
   for (Py_ssize_t i = 0; i < (Py_ssize_t)r.count; i++) {
     PyList_SetItem(pr, i, FROM_CvPoint2D32f(r.points[i]));
+  }
   return pr;
+}
 static PyObject *FROM_CvPoint2D32fs(CvPoint2D32fs r)
+{
   PyObject *pr;
   pr = PyList_New(r.count);
   for (Py_ssize_t i = 0; i < (Py_ssize_t)r.count; i++) {
     PyList_SetItem(pr, i, FROM_CvPoint2D32f(r.p[i]));
+  }
   return pr;
+}
 typedef CvSeq CvSeqOfCvConvexityDefect;
 static PyObject *FROM_CvSeqOfCvConvexityDefectPTR(CvSeqOfCvConvexityDefect *r)
+{
   PyObject *pr;
   pr = PyList_New(r->total);
   for (int i = 0; i < r->total; i++) {
     CvConvexityDefect *pd = CV_GET_SEQ_ELEM(CvConvexityDefect, r, i);
     PyList_SetItem(pr, i, Py_BuildValue("(ii)(ii)(ii)f",
                                         pd->start->x, pd->start->y,
                                         pd->end->x, pd->end->y,
                                         pd->depth_point->x, pd->depth_point->y,
                                         pd->depth));
+  }
   // This function has copied the CvSeq data into a list.  Hence the
   // CvSeq is not being returned to the caller.  Hence, no reference
   // count increase for the storage, unlike _FROM_CvSeqPTR.
   return pr;
+}
 typedef CvSeq CvSeqOfCvAvgComp;
 static PyObject *FROM_CvSeqOfCvAvgCompPTR(CvSeqOfCvAvgComp *r)
+{
   PyObject *pr;
   pr = PyList_New(r->total);
   for (int i = 0; i < r->total; i++) {
     CvAvgComp *pd = CV_GET_SEQ_ELEM(CvAvgComp, r, i);
     PyList_SetItem(pr, i, Py_BuildValue("(iiii)i",
                                         pd->rect.x, pd->rect.y,
                                         pd->rect.width, pd->rect.height,
                                         pd->neighbors));
+  }
   // This function has copied the CvSeq data into a list.  Hence the
   // CvSeq is not being returned to the caller.  Hence, no reference
   // count increase for the storage, unlike _FROM_CvSeqPTR.
   return pr;
+}
 typedef CvSeq CvSeqOfCvStarKeypoint;
 static PyObject *FROM_CvSeqOfCvStarKeypointPTR(CvSeqOfCvStarKeypoint *r)
+{
   PyObject *pr;
   pr = PyList_New(r->total);
   for (int i = 0; i < r->total; i++) {
     CvStarKeypoint *pd = CV_GET_SEQ_ELEM(CvStarKeypoint, r, i);
     PyList_SetItem(pr, i, Py_BuildValue("(ii)if",
                                         pd->pt.x, pd->pt.y,
                                         pd->size,
                                         pd->response));
+  }
   // This function has copied the CvSeq data into a list.  Hence the
   // CvSeq is not being returned to the caller.  Hence, no reference
   // count increase for the storage, unlike _FROM_CvSeqPTR.
   return pr;
+}
 typedef CvSeq CvSeqOfCvSURFPoint;
 static PyObject *FROM_CvSeqOfCvSURFPointPTR(CvSeqOfCvSURFPoint *r)
+{
   PyObject *pr;
   pr = PyList_New(r->total);
   for (int i = 0; i < r->total; i++) {
     CvSURFPoint *pd = CV_GET_SEQ_ELEM(CvSURFPoint, r, i);
     PyList_SetItem(pr, i, Py_BuildValue("(ff)iiff",
                                         pd->pt.x, pd->pt.y,
                                         pd->laplacian,
                                         pd->size,
                                         pd->dir,
                                         pd->hessian));
+  }
   // This function has copied the CvSeq data into a list.  Hence the
   // CvSeq is not being returned to the caller.  Hence, no reference
   // count increase for the storage, unlike _FROM_CvSeqPTR.
   return pr;
+}
 typedef CvSeq CvSeqOfCvSURFDescriptor;
 static PyObject *FROM_CvSeqOfCvSURFDescriptorPTR(CvSeqOfCvSURFDescriptor *r)
+{
   PyObject *pr;
   pr = PyList_New(r->total);
   for (int i = 0; i < r->total; i++) {
     float *pd = (float*)cvGetSeqElem(r, i);
     int count = r->elem_size / sizeof(float);
     PyObject *oi = PyList_New(count);
     for (int j = 0; j < count; j++) {
       PyList_SetItem(oi, j, PyFloat_FromDouble(pd[j]));
+    }
     PyList_SetItem(pr, i, oi);
+  }
   // This function has copied the CvSeq data into a list.  Hence the
   // CvSeq is not being returned to the caller.  Hence, no reference
   // count increase for the storage, unlike _FROM_CvSeqPTR.
   return pr;
+}
 typedef CvPoint2D32f CvPoint2D32f_4[4];
 static PyObject *FROM_CvPoint2D32f_4(CvPoint2D32f* r)
+{
   return Py_BuildValue("(ff)(ff)(ff)(ff)",
                        r[0].x, r[0].y,
                        r[1].x, r[1].y,
                        r[2].x, r[2].y,
                        r[3].x, r[3].y);
+}
 typedef float CvMatr32f_i[9];
 static PyObject *FROM_CvMatr32f_i(CvMatr32f_i r)
+{
   return Py_BuildValue("(fff)(fff)(fff)",
     r[0], r[1], r[2],
     r[3], r[4], r[5],
     r[6], r[7], r[8]);
+}
 typedef float CvVect32f_i[3];
 static PyObject *FROM_CvVect32f_i(CvVect32f_i r)
+{
   return Py_BuildValue("fff",
     r[0], r[1], r[2]);
+}
 static PyObject *FROM_CvFont(CvFont r)
+{
   cvfont_t *cf = PyObject_NEW(cvfont_t, &cvfont_Type);
   cf->a = r;
   return (PyObject*)cf;
+}
 static PyObject *FROM_CvSubdiv2DPointPTR(CvSubdiv2DPoint* r)
+{
   if (r != NULL) {
     cvsubdiv2dpoint_t *cf = PyObject_NEW(cvsubdiv2dpoint_t, &cvsubdiv2dpoint_Type);
     cf->a = r;
     return (PyObject*)cf;
   } else {
     Py_INCREF(Py_None);
     return Py_None;
+  }
+}
 static PyObject *FROM_IplImagePTR(IplImage *r)
+{
   iplimage_t *cva = PyObject_NEW(iplimage_t, &iplimage_Type);
   cva->a = r;
   return pythonize_IplImage(cva);
+}
 static PyObject *FROM_ROIplImagePTR(ROIplImage *r)
+{
   if (r != NULL) {
     iplimage_t *cva = PyObject_NEW(iplimage_t, &iplimage_Type);
     cva->a = cvCreateImageHeader(cvSize(100,100), 8, 1);
     *(cva->a) = *r;
     cva->data = PyBuffer_FromReadWriteMemory(r->imageData, r->height * r->widthStep);
     cva->offset = 0;
     return (PyObject*)cva;
   } else {
     Py_RETURN_NONE;
+  }
+}
 static PyObject *FROM_ROCvMatPTR(ROCvMat *r)
+{
   if (r != NULL) {
     cvmat_t *cva = PyObject_NEW(cvmat_t, &cvmat_Type);
     cva->a = cvCreateMatHeader(100, 100, CV_8U);
     *(cva->a) = *r;
     cva->data = PyBuffer_FromReadWriteMemory(r->data.ptr, r->rows * r->step);
     cva->offset = 0;
     return (PyObject*)cva;
   } else {
     Py_RETURN_NONE;
+  }
+}
 static PyObject *FROM_CvMatPTR(CvMat *r)
+{
   cvmat_t *cvm = PyObject_NEW(cvmat_t, &cvmat_Type);
   cvm->a = r;
   return pythonize_CvMat(cvm);
+}
 static PyObject *FROM_CvMat(CvMat *r)
+{
   cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
   m->a = r;
   return pythonize_CvMat(m);
+}
 static PyObject *FROM_CvMatNDPTR(CvMatND *r)
+{
   cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
   m->a = r;
   return pythonize_CvMatND(m);
+}
 static PyObject *FROM_CvRNG(CvRNG r)
+{
   cvrng_t *m = PyObject_NEW(cvrng_t, &cvrng_Type);
   m->a = r;
   return (PyObject*)m;
+}
 static PyObject *FROM_CvContourTreePTR(CvContourTree *r)
+{
   cvcontourtree_t *m = PyObject_NEW(cvcontourtree_t, &cvcontourtree_Type);
   m->a = r;
   return (PyObject*)m;
+}
 static PyObject *FROM_generic(generic r)
+{
   CvTypeInfo* t = cvTypeOf(r);
   if (r == NULL) {
     failmsg("OpenCV returned NULL");
     return NULL;
   } if (strcmp(t->type_name, "opencv-image") == 0)
     return FROM_IplImagePTR((IplImage*)r);
   else if (strcmp(t->type_name, "opencv-matrix") == 0)
     return FROM_CvMat((CvMat*)r);
   else if (strcmp(t->type_name, "opencv-nd-matrix") == 0)
     return FROM_CvMatNDPTR((CvMatND*)r);
   else if (strcmp(t->type_name, "opencv-haar-classifier") == 0)
     return FROM_CvHaarClassifierCascadePTR((CvHaarClassifierCascade*)r);
   else {
     failmsg("Unknown OpenCV type '%s'", t->type_name);
     return NULL;
+  }
+}
 static PyObject *FROM_CvSubdiv2DEdge(CvSubdiv2DEdge r)
+{
   cvsubdiv2dedge_t *m = PyObject_NEW(cvsubdiv2dedge_t, &cvsubdiv2dedge_Type);
   m->a = r;
   m->container = Py_None; // XXX
   Py_INCREF(m->container);
   return (PyObject*)m;
+}
 static PyObject *FROM_CvPoints(CvPoints src)
+{
   PyObject *pr;
   pr = PyList_New(src.count);
   for (int i = 0; i < src.count; i++) {
     PyList_SetItem(pr, i, FROM_CvPoint(src.p[i]));
+  }
   return pr;
+}
 /************************************************************************/
 /* A few functions are too odd to be generated,
  * so are handwritten here */
 static PyObject *pycvWaitKey(PyObject *self, PyObject *args, PyObject *kw)
+{
   int delay = 0;
   const char *keywords[] = { "delay", NULL };
   if (!PyArg_ParseTupleAndKeywords(args, kw, "|i", (char**)keywords, &delay))
     return NULL;
   int r;
   Py_BEGIN_ALLOW_THREADS
   r = cvWaitKey(delay);
   Py_END_ALLOW_THREADS
   return FROM_int(r);
+}
 static PyObject *pycvLoadImage(PyObject *self, PyObject *args, PyObject *kw)
+{
   const char *keywords[] = { "filename", "iscolor", NULL };
   char *filename;
   int iscolor = CV_LOAD_IMAGE_COLOR;
   if (!PyArg_ParseTupleAndKeywords(args, kw, "s|i", (char**)keywords, &filename, &iscolor))
     return NULL;
   // Inside ALLOW_THREADS, must not reference 'filename' because it might move.
   // So make a local copy 'filename_copy'.
   char filename_copy[2048];
   strncpy(filename_copy, filename, sizeof(filename_copy));
   IplImage *r;
   Py_BEGIN_ALLOW_THREADS
   r = cvLoadImage(filename_copy, iscolor);
   Py_END_ALLOW_THREADS
   if (r == NULL) {
     PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
     return NULL;
   } else {
     return FROM_IplImagePTR(r);
+  }
+}
 static PyObject *pycvLoadImageM(PyObject *self, PyObject *args, PyObject *kw)
+{
   const char *keywords[] = { "filename", "iscolor", NULL };
   char *filename;
   int iscolor = CV_LOAD_IMAGE_COLOR;
   if (!PyArg_ParseTupleAndKeywords(args, kw, "s|i", (char**)keywords, &filename, &iscolor))
     return NULL;
   // Inside ALLOW_THREADS, must not reference 'filename' because it might move.
   // So make a local copy 'filename_copy'.
   char filename_copy[2048];
   strncpy(filename_copy, filename, sizeof(filename_copy));
   CvMat *r;
   Py_BEGIN_ALLOW_THREADS
   r = cvLoadImageM(filename_copy, iscolor);
   Py_END_ALLOW_THREADS
   if (r == NULL) {
     PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
     return NULL;
   } else {
     return FROM_CvMatPTR(r);
+  }
+}
 static PyObject *pycvCreateImageHeader(PyObject *self, PyObject *args)
+{
   int w, h, depth, channels;
   if (!PyArg_ParseTuple(args, "(ii)Ii", &w, &h, &depth, &channels))
     return NULL;
   iplimage_t *cva = PyObject_NEW(iplimage_t, &iplimage_Type);
   cva->a = cvCreateImageHeader(cvSize(w, h), depth, channels);
   if (cva->a == NULL) {
     PyErr_SetString(PyExc_TypeError, "CreateImage failed");
     return NULL;
   } else {
     cva->data = Py_None;
     Py_INCREF(cva->data);
     cva->offset = 0;
     return (PyObject*)cva;
+  }
+}
 static PyObject *pycvCreateImage(PyObject *self, PyObject *args)
+{
   int w, h, depth, channels;
   if (!PyArg_ParseTuple(args, "(ii)Ii:CreateImage", &w, &h, &depth, &channels))
     return NULL;
   iplimage_t *cva = PyObject_NEW(iplimage_t, &iplimage_Type);
   ERRWRAP(cva->a = cvCreateImage(cvSize(w, h), depth, channels));
   if (cva->a == NULL) {
     PyErr_SetString(PyExc_TypeError, "CreateImage failed");
     return NULL;
   } else {
     return pythonize_IplImage(cva);
+  }
+}
 static PyObject *pycvCreateMatHeader(PyObject *self, PyObject *args)
+{
   int rows, cols, type;
   if (!PyArg_ParseTuple(args, "iii", &rows, &cols, &type))
     return NULL;
   cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
   ERRWRAP(m->a = cvCreateMatHeader(rows, cols, type));
   if (m->a == NULL) {
     PyErr_SetString(PyExc_TypeError, "CreateMat failed");
     return NULL;
   } else {
     m->data = Py_None;
     Py_INCREF(m->data);
     m->offset = 0;
     return (PyObject*)m;
+  }
+}
 static PyObject *pycvCreateMat(PyObject *self, PyObject *args)
+{
   int rows, cols, type;
   if (!PyArg_ParseTuple(args, "iii", &rows, &cols, &type))
     return NULL;
   cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
   ERRWRAP(m->a = cvCreateMat(rows, cols, type));
   if (m->a == NULL) {
     PyErr_SetString(PyExc_TypeError, "CreateMat failed");
     return NULL;
   } else {
     return pythonize_CvMat(m);
+  }
+}
 static PyObject *pycvCreateMatNDHeader(PyObject *self, PyObject *args)
+{
   ints dims;
   int type;
   if (!PyArg_ParseTuple(args, "O&i", convert_to_ints, (void*)&dims, &type))
     return NULL;
   cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
   ERRWRAP(m->a = cvCreateMatNDHeader(dims.count, dims.i, type));
   m->data = Py_None;
   Py_INCREF(m->data);
   return (PyObject*)m;
+}
 static PyObject *pycvCreateMatND(PyObject *self, PyObject *args)
+{
   ints dims;
   int type;
   if (!PyArg_ParseTuple(args, "O&i", convert_to_ints, (void*)&dims, &type))
     return NULL;
   cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
   ERRWRAP(m->a = cvCreateMatND(dims.count, dims.i, type));
   return pythonize_CvMatND(m);
+}
 #if PYTHON_USE_NUMPY
 static PyObject *pycvfromarray(PyObject *self, PyObject *args, PyObject *kw)
+{
   const char *keywords[] = { "arr", "allowND", NULL };
   PyObject *o;
   int allowND = 0;
   if (!PyArg_ParseTupleAndKeywords(args, kw, "O|i", (char**)keywords, &o, &allowND))
     return NULL;
   return fromarray(o, allowND);
+}
 static PyObject *fromarray(PyObject *o, int allowND)
+{
   PyObject *retval;
   PyObject *ao = PyObject_GetAttrString(o, "__array_struct__");
   if ((ao == NULL) || !PyCObject_Check(ao)) {
     PyErr_SetString(PyExc_TypeError, "object does not have array interface");
     return NULL;
+  }
   PyArrayInterface *pai = (PyArrayInterface*)PyCObject_AsVoidPtr(ao);
   if (pai->two != 2) {
     PyErr_SetString(PyExc_TypeError, "object does not have array interface");
     Py_DECREF(ao);
         return NULL;
+  }
   int type = -1;
   switch (pai->typekind) {
   case 'i':
     if (pai->itemsize == 1)
       type = CV_8SC1;
     else if (pai->itemsize == 2)
       type = CV_16SC1;
     else if (pai->itemsize == 4)
       type = CV_32SC1;
     else if (pai->itemsize == 8) {
       PyErr_SetString(PyExc_TypeError, "OpenCV cannot handle 64-bit integer arrays");
       Py_DECREF(ao);
           return NULL;
+    }
     break;
   case 'u':
     if (pai->itemsize == 1)
       type = CV_8UC1;
     else if (pai->itemsize == 2)
       type = CV_16UC1;
     break;
   case 'f':
     if (pai->itemsize == 4)
       type = CV_32FC1;
     else if (pai->itemsize == 8)
       type = CV_64FC1;
     break;
+  }
   assert(type != -1);
   if (!allowND) {
     cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
     if (pai->nd == 2) {
       if (pai->strides[1] != pai->itemsize) {
             Py_DECREF(ao);
         return (PyObject*)failmsg("cv.fromarray array can only accept arrays with contiguous data");
+      }
       ERRWRAP(m->a = cvCreateMatHeader(pai->shape[0], pai->shape[1], type));
       m->a->step = pai->strides[0];
     } else if (pai->nd == 3) {
                 if (pai->shape[2] > CV_CN_MAX){
                         Py_DECREF(ao);
                         return (PyObject*)failmsg("cv.fromarray too many channels, see allowND argument");
+                }
       ERRWRAP(m->a = cvCreateMatHeader(pai->shape[0], pai->shape[1], type + ((pai->shape[2] - 1) << CV_CN_SHIFT)));
       m->a->step = pai->strides[0];
     } else {
           Py_DECREF(ao);
       return (PyObject*)failmsg("cv.fromarray array can be 2D or 3D only, see allowND argument");
+    }
     m->a->data.ptr = (uchar*)pai->data;
     m->data = o;
     m->offset = 0;
     retval = (PyObject*) m;
   } else {
     int dims[CV_MAX_DIM];
     int i;
     for (i = 0; i < pai->nd; i++)
       dims[i] = pai->shape[i];
     cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
     ERRWRAP(m->a = cvCreateMatND(pai->nd, dims, type));
     m->a->data.ptr = (uchar*)pai->data;
         m->data = o;
         m->offset = 0;
     retval = (PyObject*) m;
+  }
   Py_DECREF(ao);
   Py_INCREF(o);
   return retval;
+}
 #endif
 static PyObject *pycvCreateHist(PyObject *self, PyObject *args, PyObject *kw)
+{
   const char *keywords[] = { "dims", "type", "ranges", "uniform", NULL };
   PyObject *dims;
   int type;
   float **ranges = NULL;
   int uniform = 1;
   if (!PyArg_ParseTupleAndKeywords(args, kw, "Oi|O&i", (char**)keywords, &dims, &type, convert_to_floatPTRPTR, (void*)&ranges, &uniform)) {
     return NULL;
+  }
   cvhistogram_t *h = PyObject_NEW(cvhistogram_t, &cvhistogram_Type);
   args = Py_BuildValue("Oi", dims, CV_32FC1);
   h->bins = pycvCreateMatND(self, args);
   Py_DECREF(args);
   if (h->bins == NULL) {
     return NULL;
+  }
   h->h.type = CV_HIST_MAGIC_VAL;
   if (!convert_to_CvArr(h->bins, &(h->h.bins), "bins"))
     return NULL;
   ERRWRAP(cvSetHistBinRanges(&(h->h), ranges, uniform));
   return (PyObject*)h;
+}
 static PyObject *pycvInitLineIterator(PyObject *self, PyObject *args, PyObject *kw)
+{
   const char *keywords[] = { "image", "pt1", "pt2", "connectivity", "left_to_right", NULL };
   CvArr *image;
   CvPoint pt1;
   CvPoint pt2;
   int connectivity = 8;
   int left_to_right = 0;
   if (!PyArg_ParseTupleAndKeywords(args, kw, "O&O&O&|ii", (char**)keywords,
                         convert_to_CvArr, &image,
                         convert_to_CvPoint, &pt1,
                         convert_to_CvPoint, &pt2,
                         &connectivity,
                         &left_to_right))
     return NULL;
   cvlineiterator_t *pi = PyObject_NEW(cvlineiterator_t, &cvlineiterator_Type);
   pi->count = cvInitLineIterator(image, pt1, pt2, &pi->iter, connectivity, left_to_right);
   ERRWRAP(pi->type = cvGetElemType(image));
   return (PyObject*)pi;
+}
 static PyObject *pycvCreateMemStorage(PyObject *self, PyObject *args)
+{
   int block_size = 0;
   if (!PyArg_ParseTuple(args, "|i", &block_size))
     return NULL;
   cvmemstorage_t *pm = PyObject_NEW(cvmemstorage_t, &cvmemstorage_Type);
   pm->a = cvCreateMemStorage(block_size);
   return (PyObject*)pm;
+}
 // single index: return row
 // 2 indices: row, column
 // both row and column can be slices.  column slice must have a step of 1.
 //
 // returns a scalar when all dimensions are specified and all are integers.  Otherwise returns a CvMat.
 //
 static PyObject *cvarr_GetItem(PyObject *o, PyObject *key)
+{
   dims dd;
   CvArr *cva;
   if (!convert_to_CvArr(o, &cva, "src"))
     return NULL;
   if (!convert_to_dims(key, &dd, cva, "key")) {
     return NULL;
+  }
   // Figure out if all supplied indices have a stride of zero - means they are not slices
   // and if all indices are positive
   int all0 = 1;
   for (int i = 0; i < dd.count; i++) {
     all0 &= (dd.step[i] == 0) && (0 <= dd.i[i]);
+  }
   // if every dimension supplied, and none are slices, return the scalar
   if ((cvGetDims(cva) == dd.count) && all0) {
     CvScalar s;
     ERRWRAP(s = cvGetND(cva, dd.i));
     return PyObject_FromCvScalar(s, cvGetElemType(cva));
   } else {
     // pad missing dimensions
     for (int i = dd.count; i < cvGetDims(cva); i++) {
       dd.i[i] = 0;
       dd.step[i] = 1;
       dd.length[i] = cvGetDimSize(cva, i);
+    }
     dd.count = cvGetDims(cva);
     // negative steps are illegal for OpenCV
     for (int i = 0; i < dd.count; i++) {
       if (dd.step[i] < 0)
         return (PyObject*)failmsg("Negative step is illegal");
+    }
     // zero length illegal for OpenCV
     for (int i = 0; i < dd.count; i++) {
       if (dd.length[i] == 0)
         return (PyObject*)failmsg("Zero sized dimension is illegal");
+    }
     // column step can only be 0 or 1
     if ((dd.step[dd.count-1] != 0) && (dd.step[dd.count-1] != 1))
         return (PyObject*)failmsg("Column step is illegal");
     if (is_cvmat(o) || is_iplimage(o)) {
       cvmat_t *sub = PyObject_NEW(cvmat_t, &cvmat_Type);
       sub->a = cvCreateMatHeader(dd.length[0], dd.length[1], cvGetElemType(cva));
       uchar *old0;  // pointer to first element in old mat
       int oldstep;
       cvGetRawData(cva, &old0, &oldstep);
       uchar *new0;  // pointer to first element in new mat
       ERRWRAP(new0 = cvPtrND(cva, dd.i));
       sub->a->step = oldstep * dd.step[0];
       sub->data = what_data(o);
       Py_INCREF(sub->data);
       sub->offset = new0 - old0;
       return (PyObject*)sub;
     } else {
       cvmatnd_t *sub = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
       sub->a = cvCreateMatNDHeader(dd.count, dd.length, cvGetElemType(cva));
       uchar *old0;  // pointer to first element in old mat
       cvGetRawData(cva, &old0);
       uchar *new0;  // pointer to first element in new mat
       ERRWRAP(new0 = cvPtrND(cva, dd.i));
       for (int d = 0; d < dd.count; d++) {
         int stp = dd.step[d];
         sub->a->dim[d].step = ((CvMatND*)cva)->dim[d].step * ((stp == 0) ? 1 : stp);
         sub->a->dim[d].size = dd.length[d];
+      }
       sub->data = what_data(o);
       Py_INCREF(sub->data);
       sub->offset = new0 - old0;
       return (PyObject*)sub;
+    }
+  }
+}
 static int cvarr_SetItem(PyObject *o, PyObject *key, PyObject *v)
+{
   dims dd;
   CvArr *cva;
   if (!convert_to_CvArr(o, &cva, "src"))
     return -1;
   if (!convert_to_dims(key, &dd, cva, "key")) {
     return -1;
+  }
   if (cvGetDims(cva) != dd.count) {
     PyErr_SetString(PyExc_TypeError, "key length does not match array dimension");
     return -1;
+  }
   CvScalar s;
   if (PySequence_Check(v)) {
     PyObject *fi = PySequence_Fast(v, "v");
     if (fi == NULL)
       return -1;
     if (PySequence_Fast_GET_SIZE(fi) != CV_MAT_CN(cvGetElemType(cva))) {
       PyErr_SetString(PyExc_TypeError, "sequence size must be same as channel count");
       return -1;
+    }
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++)
       s.val[i] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(fi, i));
     Py_DECREF(fi);
   } else {
     if (1 != CV_MAT_CN(cvGetElemType(cva))) {
       PyErr_SetString(PyExc_TypeError, "scalar supplied but channel count does not equal 1");
       return -1;
+    }
     s.val[0] = PyFloat_AsDouble(v);
+  }
   switch (dd.count) {
   case 1:
     cvSet1D(cva, dd.i[0], s);
     break;
   case 2:
     cvSet2D(cva, dd.i[0], dd.i[1], s);
     break;
   case 3:
     cvSet3D(cva, dd.i[0], dd.i[1], dd.i[2], s);
     break;
   default:
     cvSetND(cva, dd.i, s);
     // XXX - OpenCV bug? - seems as if an error in cvSetND does not set error status?
     break;
+  }
   if (cvGetErrStatus() != 0) {
     translate_error_to_exception();
     return -1;
+  }
   return 0;
+}
 static PyObject *pycvSetData(PyObject *self, PyObject *args)
+{
   PyObject *o, *s;
   int step = CV_AUTO_STEP;
   if (!PyArg_ParseTuple(args, "OO|i", &o, &s, &step))
     return NULL;
   if (is_iplimage(o)) {
     iplimage_t *ipl = (iplimage_t*)o;
     ipl->a->widthStep = step;
     Py_DECREF(ipl->data);
     ipl->data = s;
     Py_INCREF(ipl->data);
   } else if (is_cvmat(o)) {
     cvmat_t *m = (cvmat_t*)o;
     m->a->step = step;
     Py_DECREF(m->data);
     m->data = s;
     Py_INCREF(m->data);
   } else if (is_cvmatnd(o)) {
     cvmatnd_t *m = (cvmatnd_t*)o;
     Py_DECREF(m->data);
     m->data = s;
     Py_INCREF(m->data);
   } else {
     PyErr_SetString(PyExc_TypeError, "SetData argument must be either IplImage, CvMat or CvMatND");
     return NULL;
+  }
   Py_RETURN_NONE;
+}
 static PyObject *what_data(PyObject *o)
+{
   if (is_iplimage(o)) {
     iplimage_t *ipl = (iplimage_t*)o;
     return ipl->data;
   } else if (is_cvmat(o)) {
     cvmat_t *m = (cvmat_t*)o;
     return m->data;
   } else if (is_cvmatnd(o)) {
     cvmatnd_t *m = (cvmatnd_t*)o;
     return m->data;
   } else {
     assert(0);
     return NULL;
+  }
+}
 static PyObject *pycvCreateData(PyObject *self, PyObject *args)
+{
   PyObject *o;
   if (!PyArg_ParseTuple(args, "O", &o))
     return NULL;
   CvArr *a;
   if (!convert_to_CvArr(o, &a, "arr"))
     return NULL;
   ERRWRAP(cvCreateData(a));
   Py_DECREF(what_data(o));
   if (is_iplimage(o)) {
     iplimage_t *ipl = (iplimage_t*)o;
     pythonize_IplImage(ipl);
   } else if (is_cvmat(o)) {
     cvmat_t *m = (cvmat_t*)o;
     pythonize_CvMat(m);
   } else if (is_cvmatnd(o)) {
     cvmatnd_t *m = (cvmatnd_t*)o;
     pythonize_CvMatND(m);
   } else {
     PyErr_SetString(PyExc_TypeError, "CreateData argument must be either IplImage, CvMat or CvMatND");
     return NULL;
+  }
   Py_RETURN_NONE;
+}
 static PyObject *pycvGetDims(PyObject *self, PyObject *args)
+{
   PyObject *o;
   if (!PyArg_ParseTuple(args, "O", &o))
     return NULL;
   CvArr *cva;
   if (!convert_to_CvArr(o, &cva, "src"))
     return NULL;
   int i, nd;
   ERRWRAP(nd = cvGetDims(cva));
   PyObject *r = PyTuple_New(nd);
   for (i = 0; i < nd; i++)
     PyTuple_SetItem(r, i, PyInt_FromLong(cvGetDimSize(cva, i)));
   return r;
+}
 static PyObject *pycvGetImage(PyObject *self, PyObject *args)
+{
   PyObject *o, *r;
   if (!PyArg_ParseTuple(args, "O", &o))
     return NULL;
   if (is_iplimage(o)) {
     r = o;
     Py_INCREF(o);
   } else {
     IplImage *ipl = cvCreateImageHeader(cvSize(100,100), 8, 1); // these args do not matter, because overwritten
     CvArr *cva;
     if (!convert_to_CvArr(o, &cva, "src"))
       return NULL;
     ERRWRAP(cvGetImage(cva, ipl));
     iplimage_t *oipl = PyObject_NEW(iplimage_t, &iplimage_Type);
     oipl->a = ipl;
     oipl->data = what_data(o);
     Py_INCREF(oipl->data);
     oipl->offset = 0;
     r = (PyObject*)oipl;
+  }
   return r;
+}
 static PyObject *pycvGetMat(PyObject *self, PyObject *args, PyObject *kw)
+{
   const char *keywords[] = { "arr", "allowND", NULL };
   PyObject *o, *r;
   int allowND = 0;
   if (!PyArg_ParseTupleAndKeywords(args, kw, "O|i", (char**)keywords, &o, &allowND))
     return NULL;
   if (is_cvmat(o)) {
     r = o;
     Py_INCREF(o);
   } else {
     CvMat *m = cvCreateMatHeader(100,100, 1); // these args do not matter, because overwritten
     CvArr *cva;
     if (!convert_to_CvArr(o, &cva, "src"))
       return NULL;
     ERRWRAP(cvGetMat(cva, m, NULL, allowND));
     cvmat_t *om = PyObject_NEW(cvmat_t, &cvmat_Type);
     om->a = m;
     om->data = what_data(o);
     Py_INCREF(om->data);
     om->offset = 0;
     r = (PyObject*)om;
+  }
   return r;
+}
 static PyObject *pycvReshape(PyObject *self, PyObject *args)
+{
   PyObject *o;
   int new_cn;
   int new_rows = 0;
   if (!PyArg_ParseTuple(args, "Oi|i", &o, &new_cn, &new_rows))
     return NULL;
   CvMat *m = cvCreateMatHeader(100,100, 1); // these args do not matter, because overwritten
   CvArr *cva;
   if (!convert_to_CvArr(o, &cva, "src"))
     return NULL;
   ERRWRAP(cvReshape(cva, m, new_cn, new_rows));
   cvmat_t *om = PyObject_NEW(cvmat_t, &cvmat_Type);
   om->a = m;
   om->data = what_data(o);
   Py_INCREF(om->data);
   om->offset = 0;
   return (PyObject*)om;
+}
 static PyObject *pycvReshapeMatND(PyObject *self, PyObject *args)
+{
   PyObject *o;
   int new_cn = 0;
   PyObject *new_dims = NULL;
   if (!PyArg_ParseTuple(args, "OiO", &o, &new_cn, &new_dims))
     return NULL;
   CvMatND *cva;
   if (!convert_to_CvMatND(o, &cva, "src"))
     return NULL;
   ints dims;
   if (new_dims != NULL) {
     if (!convert_to_ints(new_dims, &dims, "new_dims"))
       return NULL;
+  }
   if (new_cn == 0)
     new_cn = CV_MAT_CN(cvGetElemType(cva));
   int i;
   int count = CV_MAT_CN(cvGetElemType(cva));
   for (i = 0; i < cva->dims; i++)
     count *= cva->dim[i].size;
   int newcount = new_cn;
   for (i = 0; i < dims.count; i++)
     newcount *= dims.i[i];
   if (count != newcount) {
     PyErr_SetString(PyExc_TypeError, "Total number of elements must be unchanged");
     return NULL;
+  }
   CvMatND *pn = cvCreateMatNDHeader(dims.count, dims.i, CV_MAKETYPE(CV_MAT_TYPE(cva->type), new_cn));
   return shareDataND(o, cva, pn);
+}
 static void OnMouse(int event, int x, int y, int flags, void* param)
+{
   PyGILState_STATE gstate;
   gstate = PyGILState_Ensure();
   PyObject *o = (PyObject*)param;
   PyObject *args = Py_BuildValue("iiiiO", event, x, y, flags, PyTuple_GetItem(o, 1));
   PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
   if (r == NULL)
     PyErr_Print();
   else
     Py_DECREF(r);
   Py_DECREF(args);
   PyGILState_Release(gstate);
+}
 static PyObject *pycvSetMouseCallback(PyObject *self, PyObject *args, PyObject *kw)
+{
   const char *keywords[] = { "window_name", "on_mouse", "param", NULL };
   char* name;
   PyObject *on_mouse;
   PyObject *param = NULL;
   if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|O", (char**)keywords, &name, &on_mouse, &param))
     return NULL;
   if (!PyCallable_Check(on_mouse)) {
     PyErr_SetString(PyExc_TypeError, "on_mouse must be callable");
     return NULL;
+  }
   if (param == NULL) {
     param = Py_None;
+  }
   ERRWRAP(cvSetMouseCallback(name, OnMouse, Py_BuildValue("OO", on_mouse, param)));
   Py_RETURN_NONE;
+}
 void OnChange(int pos, void *param)
+{
   PyGILState_STATE gstate;
   gstate = PyGILState_Ensure();
   PyObject *o = (PyObject*)param;
   PyObject *args = Py_BuildValue("(i)", pos);
   PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
   if (r == NULL)
     PyErr_Print();
   Py_DECREF(args);
   PyGILState_Release(gstate);
+}
 static PyObject *pycvCreateTrackbar(PyObject *self, PyObject *args)
+{
   PyObject *on_change;
   char* trackbar_name;
   char* window_name;
   int *value = new int;
   int count;
   if (!PyArg_ParseTuple(args, "ssiiO", &trackbar_name, &window_name, value, &count, &on_change))
     return NULL;
   if (!PyCallable_Check(on_change)) {
     PyErr_SetString(PyExc_TypeError, "on_change must be callable");
     return NULL;
+  }
   ERRWRAP(cvCreateTrackbar2(trackbar_name, window_name, value, count, OnChange, Py_BuildValue("OO", on_change, Py_None)));
   Py_RETURN_NONE;
+}
 static PyObject *pycvFindContours(PyObject *self, PyObject *args, PyObject *kw)
+{
   CvArr* image;
   PyObject *pyobj_image = NULL;
   CvMemStorage* storage;
   PyObject *pyobj_storage = NULL;
   CvSeq* first_contour;
   int header_size = sizeof(CvContour);
   int mode = CV_RETR_LIST;
   int method = CV_CHAIN_APPROX_SIMPLE;
   CvPoint offset = cvPoint(0,0);
   PyObject *pyobj_offset = NULL;
   const char *keywords[] = { "image", "storage", "mode", "method", "offset", NULL };
   if (!PyArg_ParseTupleAndKeywords(args, kw, "OO|iiO", (char**)keywords, &pyobj_image, &pyobj_storage, &mode, &method, &pyobj_offset))
     return NULL;
   if (!convert_to_CvArr(pyobj_image, &image, "image")) return NULL;
   if (!convert_to_CvMemStorage(pyobj_storage, &storage, "storage")) return NULL;
   if ((pyobj_offset != NULL) && !convert_to_CvPoint(pyobj_offset, &offset, "offset")) return NULL;
   ERRWRAP(cvFindContours(image, storage, &first_contour, header_size, mode, method, offset));
   cvseq_t *ps = PyObject_NEW(cvseq_t, &cvseq_Type);
   ps->a = first_contour;
   ps->container = PyTuple_GetItem(args, 1); // storage
   Py_INCREF(ps->container);
   return (PyObject*)ps;
+}
 static PyObject *pycvApproxPoly(PyObject *self, PyObject *args, PyObject *kw)
+{
   cvarrseq src_seq;
   PyObject *pyobj_src_seq = NULL;
   int header_size = sizeof(CvContour);
   CvMemStorage* storage;
   PyObject *pyobj_storage = NULL;
   int method;
   double parameter = 0;
   int parameter2 = 0;
   const char *keywords[] = { "src_seq", "storage", "method", "parameter", "parameter2", NULL };
   if (!PyArg_ParseTupleAndKeywords(args, kw, "OOi|di", (char**)keywords, &pyobj_src_seq, &pyobj_storage, &method, &parameter, &parameter2))
     return NULL;
   if (!convert_to_cvarrseq(pyobj_src_seq, &src_seq, "src_seq")) return NULL;
   if (!convert_to_CvMemStorage(pyobj_storage, &storage, "storage")) return NULL;
   CvSeq* r;
   ERRWRAP(r = cvApproxPoly(src_seq.mat, header_size, storage, method, parameter, parameter2));
   return FROM_CvSeqPTR(r);
+}
 static float distance_function_glue( const float* a, const float* b, void* user_param )
+{
   PyObject *o = (PyObject*)user_param;
   PyObject *args = Py_BuildValue("(ff)(ff)O", a[0], a[1], b[0], b[1], PyTuple_GetItem(o, 1));
   PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
   Py_DECREF(args);
   return (float)PyFloat_AsDouble(r);
+}
 static PyObject *pycvCalcEMD2(PyObject *self, PyObject *args, PyObject *kw)
+{
   const char *keywords[] = { "signature1", "signature2", "distance_type", "distance_func", "cost_matrix", "flow", "lower_bound", "userdata", NULL };
   CvArr* signature1;
   PyObject *pyobj_signature1;
   CvArr* signature2;
   PyObject *pyobj_signature2;
   int distance_type;
   PyObject *distance_func = NULL;
   CvArr* cost_matrix=NULL;
   PyObject *pyobj_cost_matrix = NULL;
   CvArr* flow=NULL;
   PyObject *pyobj_flow = NULL;
   float lower_bound = 0.0;
   PyObject *userdata = NULL;
   if (!PyArg_ParseTupleAndKeywords(args, kw, "OOi|OOOfO", (char**)keywords,
                                    &pyobj_signature1,
                                    &pyobj_signature2,
                                    &distance_type,
                                    &distance_func,
                                    &pyobj_cost_matrix,
                                    &pyobj_flow,
                                    &lower_bound,
                                    &userdata))
     return NULL;
   if (!convert_to_CvArr(pyobj_signature1, &signature1, "signature1")) return NULL;
   if (!convert_to_CvArr(pyobj_signature2, &signature2, "signature2")) return NULL;
   if (pyobj_cost_matrix && !convert_to_CvArr(pyobj_cost_matrix, &cost_matrix, "cost_matrix")) return NULL;
   if (pyobj_flow && !convert_to_CvArr(pyobj_flow, &flow, "flow")) return NULL;
   if (distance_func == NULL) {
     distance_func = Py_None;
+  }
   if (userdata == NULL) {
     userdata = Py_None;
+  }
   PyObject *ud = Py_BuildValue("OO", distance_func, userdata);
   float r;
   ERRWRAP(r = cvCalcEMD2(signature1, signature2, distance_type, distance_function_glue, cost_matrix, flow, &lower_bound, (void*)ud));
   Py_DECREF(ud);
   return PyFloat_FromDouble(r);
+}
 static PyObject *pycvSubdiv2DLocate(PyObject *self, PyObject *args)
+{
   PyObject *pyobj_subdiv;
   PyObject *pyobj_pt;
   CvSubdiv2D *subdiv;
   CvPoint2D32f pt;
   CvSubdiv2DEdge edge;
   CvSubdiv2DPoint* vertex;
   if (!PyArg_ParseTuple(args, "OO", &pyobj_subdiv, &pyobj_pt))
     return NULL;
   if (!convert_to_CvSubdiv2DPTR(pyobj_subdiv, &subdiv, "subdiv"))
     return NULL;
   if (!convert_to_CvPoint2D32f(pyobj_pt, &pt, "pt"))
     return NULL;
   CvSubdiv2DPointLocation loc = cvSubdiv2DLocate(subdiv, pt, &edge, &vertex);
   PyObject *r;
   switch (loc) {
   case CV_PTLOC_INSIDE:
   case CV_PTLOC_ON_EDGE:
     r = FROM_CvSubdiv2DEdge(edge);
     break;
   case CV_PTLOC_VERTEX:
     r = FROM_CvSubdiv2DPointPTR(vertex);
     break;
   case CV_PTLOC_OUTSIDE_RECT:
     r = Py_None;
     Py_INCREF(Py_None);
     break;
   default:
     return (PyObject*)failmsg("Unexpected loc from cvSubdiv2DLocate");
+  }
   return Py_BuildValue("iO", (int)loc, r);
+}
 static PyObject *pycvCalcOpticalFlowPyrLK(PyObject *self, PyObject *args)
+{
   CvArr* prev;
   PyObject *pyobj_prev = NULL;
   CvArr* curr;
   PyObject *pyobj_curr = NULL;
   CvArr* prev_pyr;
   PyObject *pyobj_prev_pyr = NULL;
   CvArr* curr_pyr;
   PyObject *pyobj_curr_pyr = NULL;
   CvPoint2D32f* prev_features;
   PyObject *pyobj_prev_features = NULL;
   PyObject *pyobj_curr_features = NULL;
   CvPoint2D32f* curr_features;
   CvSize win_size;
   int level;
   CvTermCriteria criteria;
   int flags;
   if (!PyArg_ParseTuple(args, "OOOOO(ii)i(iif)i|O",
     &pyobj_prev, &pyobj_curr, &pyobj_prev_pyr, &pyobj_curr_pyr,
     &pyobj_prev_features,
     &win_size.width, &win_size.height, &level,
     &criteria.type, &criteria.max_iter, &criteria.epsilon,
     &flags,
     &pyobj_curr_features))
     return NULL;
   if (!convert_to_CvArr(pyobj_prev, &prev, "prev")) return NULL;
   if (!convert_to_CvArr(pyobj_curr, &curr, "curr")) return NULL;
   if (!convert_to_CvArr(pyobj_prev_pyr, &prev_pyr, "prev_pyr")) return NULL;
   if (!convert_to_CvArr(pyobj_curr_pyr, &curr_pyr, "curr_pyr")) return NULL;
   if (!convert_to_CvPoint2D32fPTR(pyobj_prev_features, &prev_features, "prev_features")) return NULL;
   int count = (int)PySequence_Length(pyobj_prev_features);
   if (flags & CV_LKFLOW_INITIAL_GUESSES) {
     failmsg("flag CV_LKFLOW_INITIAL_GUESSES is determined automatically from function arguments - it is not required");
     return NULL;
+  }
   if (!pyobj_curr_features) {
     curr_features = new CvPoint2D32f[count];
   } else {
     if (PySequence_Length(pyobj_curr_features) != count) {
       failmsg("curr_features must have same length as prev_features");
       return NULL;
+    }
     if (!convert_to_CvPoint2D32fPTR(pyobj_curr_features, &curr_features, "curr_features")) return NULL;
     flags |= CV_LKFLOW_INITIAL_GUESSES;
+  }
   float *track_error = new float[count];
   char* status = new char[count];
   ERRWRAP(cvCalcOpticalFlowPyrLK(prev, curr, prev_pyr, curr_pyr, prev_features, curr_features, count, win_size, level, status, track_error, criteria, flags));
   cvpoint2d32f_count r0;
   r0.points = curr_features;
   r0.count = count;
   chars r1;
   r1.f = status;
   r1.count = count;
   floats r2;
   r2.f = track_error;
   r2.count = count;
   return Py_BuildValue("NNN", FROM_cvpoint2d32f_count(r0), FROM_chars(r1), FROM_floats(r2));
+}
 // pt1,pt2 are input and output arguments here
 static PyObject *pycvClipLine(PyObject *self, PyObject *args)
+{
   CvSize img_size;
   PyObject *pyobj_img_size = NULL;
   CvPoint pt1;
   PyObject *pyobj_pt1 = NULL;
   CvPoint pt2;
   PyObject *pyobj_pt2 = NULL;
   if (!PyArg_ParseTuple(args, "OOO", &pyobj_img_size, &pyobj_pt1, &pyobj_pt2))
     return NULL;
   if (!convert_to_CvSize(pyobj_img_size, &img_size, "img_size")) return NULL;
   if (!convert_to_CvPoint(pyobj_pt1, &pt1, "pt1")) return NULL;
   if (!convert_to_CvPoint(pyobj_pt2, &pt2, "pt2")) return NULL;
   int r;
   ERRWRAP(r = cvClipLine(img_size, &pt1, &pt2));
   if (r == 0) {
     Py_RETURN_NONE;
   } else {
     return Py_BuildValue("NN", FROM_CvPoint(pt1), FROM_CvPoint(pt2));
+  }
+}
 static PyObject *temp_test(PyObject *self, PyObject *args)
+{
 #if 0
   CvArr *im = cvLoadImage("../samples/c/lena.jpg", 0);
   printf("im=%p\n", im);
   CvMat *m = cvEncodeImage(".jpeg", im);
 #endif
 #if 0
   CvArr *im = cvLoadImage("lena.jpg", 0);
   float r0[] = { 0, 255 };
   float *ranges[] = { r0 };
   int hist_size[] = { 256 };
   CvHistogram *hist = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
   cvCalcHist(im, hist, 0, 0);
 #endif
 #if 0
   CvMat* mat = cvCreateMat( 3, 3, CV_32F );
   CvMat row_header, *row;
   row = cvReshape( mat, &row_header, 0, 1 );
   printf("%d,%d\n", row_header.rows, row_header.cols);
   printf("ge %08x\n", cvGetElemType(mat));
 #endif
 #if 0
   CvMat *m = cvCreateMat(1, 10, CV_8UC1);
   printf("CvMat stride ===> %d\n", m->step);
 #endif
 #if 0
   CvPoint2D32f src[3] = { { 0,0 }, { 1,0 }, { 0,1 } };
   CvPoint2D32f dst[3] = { { 0,0 }, { 17,0 }, { 0,17 } };
   CvMat* mapping = cvCreateMat(2, 3, CV_32FC1);
   cvGetAffineTransform(src, dst, mapping);
   printf("===> %f\n", cvGetReal2D(mapping, 0, 0));
 #endif
 #if 0
   CvArr *im = cvLoadImage("checker77.png");
   CvPoint2D32f corners[49];
   int count;
   cvFindChessboardCorners(im, cvSize(7,7), corners, &count, 0);
   printf("count=%d\n", count);
 #endif
 #if 0
   CvMat *src = cvCreateMat(512, 512, CV_8UC3);
   CvMat *dst = cvCreateMat(512, 512, CV_8UC3);
   cvPyrMeanShiftFiltering(src, dst, 5, 5);
   return FROM_CvMat(src);
 #endif
   return PyFloat_FromDouble(0.0);
+}
 static PyObject *pycvFindChessboardCorners(PyObject *self, PyObject *args, PyObject *kw)
+{
   CvArr* image;
   PyObject *pyobj_image = NULL;
   CvSize pattern_size;
   PyObject *pyobj_pattern_size = NULL;
   cvpoint2d32f_count corners;
   int flags = CV_CALIB_CB_ADAPTIVE_THRESH;
   const char *keywords[] = { "image", "pattern_size", "flags", NULL };
   if (!PyArg_ParseTupleAndKeywords(args, kw, "OO|i", (char**)keywords, &pyobj_image, &pyobj_pattern_size, &flags))
     return NULL;
   if (!convert_to_CvArr(pyobj_image, &image, "image")) return NULL;
   if (!convert_to_CvSize(pyobj_pattern_size, &pattern_size, "pattern_size")) return NULL;
   int r;
   corners.points = new CvPoint2D32f[pattern_size.width * pattern_size.height];
   ERRWRAP(r = cvFindChessboardCorners(image, pattern_size, corners.points,&corners.count, flags));
   return Py_BuildValue("NN", FROM_int(r), FROM_cvpoint2d32f_count(corners));
+}
 // For functions GetSubRect, GetRow, GetCol.
 // recipient has a view into donor's data, and needs to share it.
 // make recipient use the donor's data, compute the offset,
 // and manage reference counts.
 static void preShareData(CvArr *donor, CvMat **recipient)
+{
   *recipient = cvCreateMatHeader(4, 4, cvGetElemType(donor));
+}
 static PyObject *shareData(PyObject *donor, CvArr *pdonor, CvMat *precipient)
+{
   PyObject *recipient = (PyObject*)PyObject_NEW(cvmat_t, &cvmat_Type);
   ((cvmat_t*)recipient)->a = precipient;
   ((cvmat_t*)recipient)->offset = cvPtr1D(precipient, 0) - cvPtr1D(pdonor, 0);
   PyObject *arr_data;
   if (is_cvmat(donor)) {
     arr_data = ((cvmat_t*)donor)->data;
     ((cvmat_t*)recipient)->offset += ((cvmat_t*)donor)->offset;
   } else if (is_iplimage(donor)) {
     arr_data = ((iplimage_t*)donor)->data;
     ((cvmat_t*)recipient)->offset += ((iplimage_t*)donor)->offset;
   } else {
     return (PyObject*)failmsg("Argument 'mat' must be either IplImage or CvMat");
+  }
   ((cvmat_t*)recipient)->data = arr_data;
   Py_INCREF(arr_data);
   return recipient;
+}
 static PyObject *shareDataND(PyObject *donor, CvMatND *pdonor, CvMatND *precipient)
+{
   PyObject *recipient = (PyObject*)PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
   ((cvmatnd_t*)recipient)->a = precipient;
   ((cvmatnd_t*)recipient)->offset = 0;
   PyObject *arr_data;
   arr_data = ((cvmatnd_t*)donor)->data;
   ((cvmatnd_t*)recipient)->data = arr_data;
   Py_INCREF(arr_data);
   return recipient;
+}
 static PyObject *pycvGetHuMoments(PyObject *self, PyObject *args)
+{
   CvMoments* moments;
   PyObject *pyobj_moments = NULL;
   if (!PyArg_ParseTuple(args, "O", &pyobj_moments))
     return NULL;
   if (!convert_to_CvMomentsPTR(pyobj_moments, &moments, "moments")) return NULL;
   CvHuMoments r;
   ERRWRAP(cvGetHuMoments(moments, &r));
   return Py_BuildValue("ddddddd", r.hu1, r.hu2, r.hu3, r.hu4, r.hu5, r.hu6, r.hu7);
+}
 static PyObject *pycvFitLine(PyObject *self, PyObject *args)
+{
   cvarrseq points;
   PyObject *pyobj_points = NULL;
   int dist_type;
   float param;
   float reps;
   float aeps;
   float r[6];
   if (!PyArg_ParseTuple(args, "Oifff", &pyobj_points, &dist_type, &param, &reps, &aeps))
     return NULL;
   if (!convert_to_cvarrseq(pyobj_points, &points, "points")) return NULL;
   ERRWRAP(cvFitLine(points.mat, dist_type, param, reps, aeps, r));
   int dimension;
   if (strcmp("opencv-matrix", cvTypeOf(points.mat)->type_name) == 0)
     dimension = CV_MAT_CN(cvGetElemType(points.mat));
   else {
     // sequence case... don't think there is a sequence of 3d points,
     // so assume 2D
     dimension = 2;
+  }
   if (dimension == 2)
     return Py_BuildValue("dddd", r[0], r[1], r[2], r[3]);
   else
     return Py_BuildValue("dddddd", r[0], r[1], r[2], r[3], r[4], r[5]);
+}
 static PyObject *pycvGetMinMaxHistValue(PyObject *self, PyObject *args)
+{
   CvHistogram* hist;
   PyObject *pyobj_hist = NULL;
   float min_val;
   float max_val;
   int min_loc[CV_MAX_DIM];
   int max_loc[CV_MAX_DIM];
   if (!PyArg_ParseTuple(args, "O", &pyobj_hist))
     return NULL;
   if (!convert_to_CvHistogram(pyobj_hist, &hist, "hist")) return NULL;
   ERRWRAP(cvGetMinMaxHistValue(hist, &min_val, &max_val, min_loc, max_loc));
   int d = cvGetDims(hist->bins);
   PyObject *pminloc = PyTuple_New(d), *pmaxloc = PyTuple_New(d);
   for (int i = 0; i < d; i++) {
     PyTuple_SetItem(pminloc, i, PyInt_FromLong(min_loc[i]));
     PyTuple_SetItem(pmaxloc, i, PyInt_FromLong(max_loc[i]));
+  }
   return Py_BuildValue("ffNN", min_val, max_val, pminloc, pmaxloc);
+}
 static CvSeq* cvHOGDetectMultiScale( const CvArr* image, CvMemStorage* storage,
   const CvArr* svm_classifier=NULL, CvSize win_stride=cvSize(0,0),
   double hit_threshold=0, double scale=1.05,
   int group_threshold=2, CvSize padding=cvSize(0,0),
   CvSize win_size=cvSize(64,128), CvSize block_size=cvSize(16,16),
   CvSize block_stride=cvSize(8,8), CvSize cell_size=cvSize(8,8),
   int nbins=9, int gammaCorrection=1 )
+{
     cv::HOGDescriptor hog(win_size, block_size, block_stride, cell_size, nbins, 1, -1, cv::HOGDescriptor::L2Hys, 0.2, gammaCorrection!=0);
     if(win_stride.width == 0 && win_stride.height == 0)
         win_stride = block_stride;
     cv::Mat img = cv::cvarrToMat(image);
     std::vector<cv::Rect> found;
     if(svm_classifier)
+    {
         CvMat stub, *m = cvGetMat(svm_classifier, &stub);
         int sz = m->cols*m->rows;
         CV_Assert(CV_IS_MAT_CONT(m->type) && (m->cols == 1 || m->rows == 1) && CV_MAT_TYPE(m->type) == CV_32FC1);
         std::vector<float> w(sz);
         std::copy(m->data.fl, m->data.fl + sz, w.begin());
         hog.setSVMDetector(w);
+    }
     else
         hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector());
     hog.detectMultiScale(img, found, hit_threshold, win_stride, padding, scale, group_threshold);
     CvSeq* seq = cvCreateSeq(cv::DataType<cv::Rect>::type, sizeof(CvSeq), sizeof(cv::Rect), storage);
     if(found.size())
         cvSeqPushMulti(seq, &found[0], (int)found.size());
     return seq;
+}
 static void cvGrabCut(CvArr *image,
                       CvArr *mask,
                       CvRect rect,
                       CvArr *bgdModel,
                       CvArr *fgdModel,
                       int iterCount,
                       int mode)
+{
   cv::Mat _image = cv::cvarrToMat(image);
   cv::Mat _mask = cv::cvarrToMat(mask);
   cv::Mat _bgdModel = cv::cvarrToMat(bgdModel);
   cv::Mat _fgdModel = cv::cvarrToMat(fgdModel);
   grabCut(_image, _mask, rect, _bgdModel, _fgdModel, iterCount, mode);
+}
 static int zero = 0;
 /************************************************************************/
 /* Custom Validators */
 #define CVPY_VALIDATE_DrawChessboardCorners() do { \
   if ((patternSize.width * patternSize.height) != corners.count) \
     return (PyObject*)failmsg("Size is %dx%d, but corner list is length %d", patternSize.width, patternSize.height, corners.count); \
   } while (0)
 #define cvGetRotationMatrix2D cv2DRotationMatrix
 /************************************************************************/
 /* Generated functions */
 #define constCvMat const CvMat
 #define FROM_constCvMatPTR(x) FROM_CvMatPTR((CvMat*)x)
 #define cvSnakeImage(image, points, length, a, b, g, win, criteria, calc_gradient) \
   do { \
     int coeff_usage; \
     if ((alpha.count == 1) && (beta.count == 1) && (gamma.count == 1)) \
       coeff_usage = CV_VALUE; \
     else if ((length == alpha.count) && (alpha.count == beta.count) && (beta.count == gamma.count)) \
       coeff_usage = CV_ARRAY; \
     else \
       return (PyObject*)failmsg("SnakeImage weights invalid"); \
     cvSnakeImage(image, points, length, a, b, g, coeff_usage, win, criteria, calc_gradient); \
   } while (0)
 static double cppKMeans(const CvArr* _samples, int cluster_count, CvArr* _labels,
            CvTermCriteria termcrit, int attempts, int flags, CvArr* _centers)
+{
     cv::Mat data = cv::cvarrToMat(_samples), labels = cv::cvarrToMat(_labels), centers;
     if( _centers )
         centers = cv::cvarrToMat(_centers);
     CV_Assert( labels.isContinuous() && labels.type() == CV_32S &&
         (labels.cols == 1 || labels.rows == 1) &&
         labels.cols + labels.rows - 1 == data.rows );
     return cv::kmeans(data, cluster_count, labels, termcrit, attempts,
                                     flags, _centers ? &centers : 0 );
+}
 #define cvKMeans2(samples, nclusters, labels, termcrit, attempts, flags, centers) \
     cppKMeans(samples, nclusters, labels, termcrit, attempts, flags, centers)
 #include "generated0.i"
 #if PYTHON_USE_NUMPY
 #include "opencv2x.h"
 #include "pyopencv_generated_types.h"
 #include "pyopencv_generated_funcs.h"
 #endif
 static PyMethodDef methods[] = {
 #if PYTHON_USE_NUMPY
     {"fromarray", (PyCFunction)pycvfromarray, METH_KEYWORDS, "fromarray(array) -> cvmatnd"},
 #endif
   //{"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"},
   //{"_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"},
   //{"_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"},
   //{"_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"},
   {"temp_test", temp_test, METH_VARARGS},
 #include "generated1.i"
 #if PYTHON_USE_NUMPY
 #include "pyopencv_generated_func_tab.h"
 #endif
   {NULL, NULL},
 };
 /************************************************************************/
 /* Module init */
 static int to_ok(PyTypeObject *to)
+{
   to->tp_alloc = PyType_GenericAlloc;
   to->tp_new = PyType_GenericNew;
   to->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
   return (PyType_Ready(to) == 0);
+}
 #define MKTYPE(NAME)  NAME##_specials(); if (!to_ok(&NAME##_Type)) return
 #define MKTYPE2(NAME) pyopencv_##NAME##_specials(); if (!to_ok(&pyopencv_##NAME##_Type)) return
 using namespace cv;
 extern "C"
 #if defined WIN32 || defined _WIN32
 __declspec(dllexport)
 #endif
 void initcv()
+{
 #if PYTHON_USE_NUMPY
     import_array();
 #endif
   PyObject *m, *d;
   cvSetErrMode(CV_ErrModeParent);
   MKTYPE(cvcontourtree);
   MKTYPE(cvfont);
   MKTYPE(cvhistogram);
   MKTYPE(cvlineiterator);
   MKTYPE(cvmat);
   MKTYPE(cvmatnd);
   MKTYPE(cvmemstorage);
   MKTYPE(cvsubdiv2dedge);
   MKTYPE(cvrng);
   MKTYPE(cvseq);
   MKTYPE(cvset);
   MKTYPE(cvsubdiv2d);
   MKTYPE(cvsubdiv2dpoint);
   MKTYPE(iplimage);
   MKTYPE(memtrack);
 #include "generated4.i"
 #if PYTHON_USE_NUMPY
 #include "pyopencv_generated_type_reg.h"
 #endif
   m = Py_InitModule(MODULESTR"", methods);
   d = PyModule_GetDict(m);
   PyDict_SetItemString(d, "__version__", PyString_FromString("$Rev: 3057 $"));
   opencv_error = PyErr_NewException((char*)MODULESTR".error", NULL, NULL);
   PyDict_SetItemString(d, "error", opencv_error);
   // Couple of warnings about strict aliasing here.  Not clear how to fix.
   union {
     PyObject *o;
     PyTypeObject *to;
   } convert;
   convert.to = &iplimage_Type;
   PyDict_SetItemString(d, "iplimage", convert.o);
   convert.to = &cvmat_Type;
   PyDict_SetItemString(d, "cvmat", convert.o);
 #define PUBLISH(I) PyDict_SetItemString(d, #I, PyInt_FromLong(I))
 #define PUBLISHU(I) PyDict_SetItemString(d, #I, PyLong_FromUnsignedLong(I))
 #define PUBLISH2(I, value) PyDict_SetItemString(d, #I, PyLong_FromLong(value))
   PUBLISHU(IPL_DEPTH_8U);
   PUBLISHU(IPL_DEPTH_8S);
   PUBLISHU(IPL_DEPTH_16U);
   PUBLISHU(IPL_DEPTH_16S);
   PUBLISHU(IPL_DEPTH_32S);
   PUBLISHU(IPL_DEPTH_32F);
   PUBLISHU(IPL_DEPTH_64F);
   PUBLISH(CV_LOAD_IMAGE_COLOR);
   PUBLISH(CV_LOAD_IMAGE_GRAYSCALE);
   PUBLISH(CV_LOAD_IMAGE_UNCHANGED);
   PUBLISH(CV_HIST_ARRAY);
   PUBLISH(CV_HIST_SPARSE);
   PUBLISH(CV_8U);
   PUBLISH(CV_8UC1);
   PUBLISH(CV_8UC2);
   PUBLISH(CV_8UC3);
   PUBLISH(CV_8UC4);
   PUBLISH(CV_8S);
   PUBLISH(CV_8SC1);
   PUBLISH(CV_8SC2);
   PUBLISH(CV_8SC3);
   PUBLISH(CV_8SC4);
   PUBLISH(CV_16U);
   PUBLISH(CV_16UC1);
   PUBLISH(CV_16UC2);
   PUBLISH(CV_16UC3);
   PUBLISH(CV_16UC4);
   PUBLISH(CV_16S);
   PUBLISH(CV_16SC1);
   PUBLISH(CV_16SC2);
   PUBLISH(CV_16SC3);
   PUBLISH(CV_16SC4);
   PUBLISH(CV_32S);
   PUBLISH(CV_32SC1);
   PUBLISH(CV_32SC2);
   PUBLISH(CV_32SC3);
   PUBLISH(CV_32SC4);
   PUBLISH(CV_32F);
   PUBLISH(CV_32FC1);
   PUBLISH(CV_32FC2);
   PUBLISH(CV_32FC3);
   PUBLISH(CV_32FC4);
   PUBLISH(CV_64F);
   PUBLISH(CV_64FC1);
   PUBLISH(CV_64FC2);
   PUBLISH(CV_64FC3);
   PUBLISH(CV_64FC4);
   PUBLISH(CV_NEXT_AROUND_ORG);
   PUBLISH(CV_NEXT_AROUND_DST);
   PUBLISH(CV_PREV_AROUND_ORG);
   PUBLISH(CV_PREV_AROUND_DST);
   PUBLISH(CV_NEXT_AROUND_LEFT);
   PUBLISH(CV_NEXT_AROUND_RIGHT);
   PUBLISH(CV_PREV_AROUND_LEFT);
   PUBLISH(CV_PREV_AROUND_RIGHT);
   PUBLISH(CV_WINDOW_AUTOSIZE);
   PUBLISH(CV_PTLOC_INSIDE);
   PUBLISH(CV_PTLOC_ON_EDGE);
   PUBLISH(CV_PTLOC_VERTEX);
   PUBLISH(CV_PTLOC_OUTSIDE_RECT);
   PUBLISH(GC_BGD);
   PUBLISH(GC_FGD);
   PUBLISH(GC_PR_BGD);
   PUBLISH(GC_PR_FGD);
   PUBLISH(GC_INIT_WITH_RECT);
   PUBLISH(GC_INIT_WITH_MASK);
   PUBLISH(GC_EVAL);
 #include "generated2.i"
 #if PYTHON_USE_NUMPY
 #include "pyopencv_generated_const_reg.h"
 #endif
 #if 0
+  {
     int sizes[] = { 10 } ;
     float ranges[] = { 0.0, 1.0 };
     // CvHistogram*h = cvCreateHist(1, sizes, CV_HIST_ARRAY);
     CvHistogram H;
     float data[10];
     CvHistogram*h = cvMakeHistHeaderForArray(1, sizes, &H, data);
     printf("h->type = %08x\n", h->type);
     printf("h->bins = %p\n", h->bins);
     printf("h->mat = %p\n", &(h->mat));
+  }
 #endif
+}

Login	Password