X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=interfaces%2Fswig%2Fpython%2Fpytypemaps.i;h=23d96a80f30b5d1e7418bbe3d526fc864a449397;hb=e4c14cdbdf2fe805e79cd96ded236f57e7b89060;hp=4f8014b9d604d93734e11eb82e823e8a71a795c3;hpb=454138ff8a20f6edb9b65a910101403d8b520643;p=opencv diff --git a/interfaces/swig/python/pytypemaps.i b/interfaces/swig/python/pytypemaps.i index 4f8014b..23d96a8 100644 --- a/interfaces/swig/python/pytypemaps.i +++ b/interfaces/swig/python/pytypemaps.i @@ -41,32 +41,35 @@ %include "exception.i" %include "./pyhelpers.i" -%typemap(in) (CvArr *) (bool freearg=false){ - $1 = PyObject_to_CvArr($input, &freearg); +%typemap(in) (CvArr *) (bool freearg=false) +{ + $1 = PyObject_to_CvArr($input, &freearg); } -%typemap(freearg) (CvArr *) { - if($1!=NULL && freearg$argnum){ - cvReleaseData( $1 ); - cvFree(&($1)); - } + +%typemap(freearg) (CvArr *) +{ + if($1!=NULL && freearg$argnum) + { + cvReleaseData( $1 ); + cvFree(&($1)); + } +} + +%typemap(in) CvMat* (bool freearg=false), const CvMat* (bool freearg=false) +{ + $1 = (CvMat*)PyObject_to_CvArr($input, &freearg); +} + +%typemap(freearg) CvMat*,const CvMat* { + if($1!=NULL && freearg$argnum){ + cvReleaseData( $1 ); + cvFree(&($1)); + } } /* typecheck typemaps */ %typecheck(SWIG_TYPECHECK_POINTER) CvArr * { - void *ptr; - if ($input == Py_None) { - $1 = 1; - } - if(PyList_Check($input) || PyTuple_Check($input)) { - $1 = 1; - } - else if (SWIG_ConvertPtr($input, &ptr, $descriptor(CvMat*), 0) != -1){ - $1 = 1; - } - else { - $1 = 0; - PyErr_Clear(); - } + $1 = CvArr_Check( $input ); } %typecheck(SWIG_TYPECHECK_POINTER) CvScalar { @@ -76,13 +79,26 @@ /* copy built-in swig typemaps for these types */ %typemap(typecheck) CvPoint = SWIGTYPE; %typemap(typecheck) CvPoint2D32f = SWIGTYPE; +%typemap(typecheck) CvPoint3D32f = SWIGTYPE; +%typemap(typecheck) CvPoint2D64f = SWIGTYPE; +%typemap(typecheck) CvPoint3D64f = SWIGTYPE; +%typemap(typecheck) CvRect = SWIGTYPE; +%typemap(typecheck) CvSize = SWIGTYPE; +%typemap(typecheck) CvSize2D32f = SWIGTYPE; +%typemap(typecheck) CvSlice = SWIGTYPE; +%typemap(typecheck) CvBox2D = SWIGTYPE; +%typemap(typecheck) CvTermCriteria = SWIGTYPE; // for cvReshape, cvGetRow, where header is passed, then filled in -%typemap(in, numinputs=0) CvMat * OUTPUT (CvMat * header) { +%typemap(in, numinputs=0) CvMat * OUTPUT (CvMat * header, bool freearg=false) { header = (CvMat *)cvAlloc(sizeof(CvMat)); $1 = header; } + +%apply CvMat * OUTPUT {CvMat * header}; +%apply CvMat * OUTPUT {CvMat * submat}; + %newobject cvReshape; %newobject cvGetRow; %newobject cvGetRows; @@ -91,9 +107,6 @@ %newobject cvGetSubRect; %newobject cvGetDiag; -%apply CvMat *OUTPUT {CvMat * header}; -%apply CvMat *OUTPUT {CvMat * submat}; - /** * In C, these functions assume input will always be around at least as long as header, * presumably because the most common usage is to pass in a reference to a stack object. @@ -111,26 +124,358 @@ * the header and data. The new header is left pointing to invalid data. To avoid this, need to add * refcount field to the returned header. */ -%typemap(argout) (const CvArr* arr, CvMat* header) { +%typemap(argout) (const CvArr* arr, CvMat* header) +{ $2->hdr_refcount = ((CvMat *)$1)->hdr_refcount; $2->refcount = ((CvMat *)$1)->refcount; cvIncRefData($2); } -%typemap(argout) (const CvArr* arr, CvMat* submat) { + +%typemap(argout) (const CvArr* arr, CvMat* submat) +{ $2->hdr_refcount = ((CvMat *)$1)->hdr_refcount; $2->refcount = ((CvMat *)$1)->refcount; cvIncRefData($2); } /* map scalar or sequence to CvScalar, CvPoint2D32f, CvPoint */ -%typemap(in) (CvScalar) { +%typemap(in) (CvScalar) +{ $1 = PyObject_to_CvScalar( $input ); } -%typemap(in) (CvPoint) { - $1 = PyObject_to_CvPoint($input); + +//%typemap(in) (CvPoint) { +// $1 = PyObject_to_CvPoint($input); +//} +//%typemap(in) (CvPoint2D32f) { +// $1 = PyObject_to_CvPoint2D32f($input); +//} + + +// ============================================================================================ + +%define TUPLE_OR_TYPE (item, destination, typename, number, description, ...) +{ + if (PySequence_Check(item) && PySequence_Length(item) == number) + { + PyObject * as_tuple = PySequence_Tuple (item); + if (!PyArg_ParseTuple (as_tuple, __VA_ARGS__)) + { + PyErr_SetString(PyExc_TypeError, "each entry must consist of " # number " values " # description); + Py_DECREF (as_tuple); + return NULL; + } + Py_DECREF (as_tuple); + } + else + { + typename * ptr; + if (SWIG_ConvertPtr (item, (void **) & ptr, $descriptor(typename *), SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError, "expected a sequence of " # number " values " # description " or a " # typename); + Py_DECREF (item); + return NULL; + } + destination = *ptr; + } } -%typemap(in) (CvPoint2D32f) { - $1 = PyObject_to_CvPoint2D32f($input); +%enddef + +%define INPUT_ARRAY_OF_TUPLES_OR_TYPES (typename, number, description, ...) +{ + if(! PySequence_Check ($input)) + { + PyErr_SetString(PyExc_TypeError, "Expected a list or tuple"); + return NULL; + } + + // TODO: will this ever be freed? + int count = PySequence_Size ($input); + int array = (typename *) malloc (count * sizeof (typename)); + + // extract all the points values from the list */ + typename * element = array; + for (int i = 0; i < count; i++, element++) + { + PyObject * item = PySequence_GetItem ($input, i); + + // use the macro we have to expand a single entry + TUPLE_OR_TYPE (item, *element, typename, number, description, __VA_ARGS__) + // *corner, "ff", & corner->x, & corner->y + } + + // these are the arguments passed to the OpenCV function + $1 = array; + $2 = count; +} +%enddef + + +// ============================================================================================ +// Tiny typemaps for tiny types ... + +%typemap(in) CvRect (CvRect temp) +//TUPLE_OR_TYPE ($input, $1, CvRect, 4, "(x,y,w,h)", "iiii", & temp.x, & temp.y, & temp.width, & temp.height) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"iiii", & temp.x, & temp.y, & temp.width, & temp.height)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 4 integers (x, y, width, height)"); + return NULL; + } + $1 = temp; + } + else + { + CvRect * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvRect, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvRect"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvTermCriteria (CvTermCriteria temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"iid", & temp.type, & temp.max_iter, & temp.epsilon)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 2 integers and a float (type, max_iter, epsilon)"); + return NULL; + } + $1 = temp; + } + else + { + CvTermCriteria * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvTermCriteria, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvTermCriteria"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvPoint (CvPoint temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"ii", & temp.x, & temp.y)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 2 integers (x, y)"); + return NULL; + } + $1 = temp; + } + else + { + CvPoint * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvPoint, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvPoint"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvPoint2D32f (CvPoint2D32f temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"ff", & temp.x, & temp.y)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 2 floats (x, y)"); + return NULL; + } + $1 = temp; + } + else + { + CvPoint2D32f * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvPoint2D32f"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvPoint3D32f (CvPoint3D32f temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"fff", & temp.x, & temp.y, &temp.z)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 3 floats (x, y, z)"); + return NULL; + } + $1 = temp; + } + else + { + CvPoint3D32f * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvPoint3D32f, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvPoint3D32f"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvPoint2D64f (CvPoint2D64f temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"dd", & temp.x, & temp.y)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 2 floats (x, y)"); + return NULL; + } + $1 = temp; + } + else + { + CvPoint2D64f * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvPoint2D64f, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvPoint2D64f"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvPoint3D64f (CvPoint3D64f temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"ddd", & temp.x, & temp.y, &temp.z)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 3 floats (x, y, z)"); + return NULL; + } + $1 = temp; + } + else + { + CvPoint3D64f * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvPoint3D64f, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvPoint3D64f"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvSize (CvSize temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"ii", & temp.width, & temp.height)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 2 integers (width, height)"); + return NULL; + } + $1 = temp; + } + else + { + CvSize * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvSize, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvSize"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvSize2D32f (CvSize2D32f temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"ff", & temp.width, & temp.height)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 2 floats (width, height)"); + return NULL; + } + $1 = temp; + } + else + { + CvSize2D32f * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvSize2D32f, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvSize2D32f"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvBox2D (CvBox2D temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"fffff", & temp.center.x, & temp.center.y, & temp.size.width, & temp.size.height, & temp.angle)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 5 floats (center_x, center_y, width, height, angle)"); + return NULL; + } + $1 = temp; + } + else + { + CvBox2D * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvBox2D, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvBox2D"); + return NULL; + } + $1 = *ptr; + } +} + + +%typemap(in) CvSlice (CvSlice temp) +{ + if (PyTuple_Check($input)) + { + if (!PyArg_ParseTuple($input,"ii", & temp.start_index, & temp.end_index)) + { + PyErr_SetString(PyExc_TypeError,"tuple must consist of 2 integers (start_index, end_index)"); + return NULL; + } + $1 = temp; + } + else + { + CvSlice * ptr; + if (SWIG_ConvertPtr ($input, (void **) & ptr, SWIGTYPE_p_CvSlice, SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a tuple or a CvSlice"); + return NULL; + } + $1 = *ptr; + } } @@ -322,11 +667,24 @@ free($2); } + +/** this typemap is meant to help cvCalcOpticalFlowPyrLK */ +%typemap(in, numinputs = 0) (int count, char* status, float* track_error) { + $1 [count] = (char *) malloc (count * sizeof (char)); + $2 [count] = (float *) malloc (count * sizeof (float)); +} + +%typemap(argout) float *track_error { + PyObject * to_add = SWIG_NewPointerObj ($1, $descriptor(float *), SWIG_POINTER_OWN); + $result = SWIG_AppendOutput( $result, to_add ); +} + /** Macro to define typemaps to convert a python list of CvPoints to a C array of CvPoints */ %define %typemap_CvPoint_CArr(points_arg, numpoints_arg) %typemap(in, numinputs=1) (CvPoint * points_arg, int numpoints_arg){ int i; + if(!PySequence_Check($input)){ SWIG_exception(SWIG_TypeError, "Expected a list for argument $argnum\n"); return NULL; @@ -357,7 +715,7 @@ } /** - * return the finded contours with all the others parametres + * return the contours with all the others parametres */ %typemap(argout) (CvSeq ** OUTPUT) { PyObject *to_add; @@ -564,122 +922,135 @@ /* map one list of points to the two parameters dimenssion/sizes for cvCalcOpticalFlowPyrLK */ -%typemap(in) (CvPoint2D32f* prev_features) { - int i; - int size; - - /* get the size of the input array */ - size = PyList_Size ($input); - - /* allocate the needed memory */ - $1 = (CvPoint2D32f *)malloc (size * sizeof (CvPoint2D32f)); - - /* extract all the points values from the list */ - for (i = 0; i < size; i++) { - PyObject *item = PyList_GetItem ($input, i); - - void * vptr; - SWIG_Python_ConvertPtr (item, &vptr, - $descriptor(CvPoint2D32f*), - SWIG_POINTER_EXCEPTION); - CvPoint2D32f *p = (CvPoint2D32f *)vptr; - $1 [i].x = p->x; - $1 [i].y = p->y; - } +%typemap(in) (CvPoint2D32f* prev_features) +{ + int i; + int size; + + /* get the size of the input array */ + size = PyList_Size ($input); + + /* allocate the needed memory */ + CvPoint2D32f * features = (CvPoint2D32f *) malloc (size * sizeof (CvPoint2D32f)); + + /* extract all the points values from the list */ + for (i = 0; i < size; i++) + { + PyObject *item = PyList_GetItem ($input, i); + + void * vptr; + SWIG_Python_ConvertPtr (item, &vptr, + $descriptor(CvPoint2D32f*), + SWIG_POINTER_EXCEPTION); + CvPoint2D32f *p = (CvPoint2D32f *)vptr; + features[i].x = p->x; + features[i].y = p->y; + } + + // these are the arguments passed to the OpenCV function + $1 = features; } /** * the corners returned by cvGoodFeaturesToTrack */ -%typemap (in, numinputs=1) (CvPoint2D32f* corners, int* corner_count) - (int tmpCount) { - /* as input, we still need the size of the corners array */ - - /* memorize the size of the status corners */ - tmpCount = (int)PyInt_AsLong ($input); - - /* create the corners array for the C call */ - $1 = (CvPoint2D32f *)malloc (tmpCount * sizeof (CvPoint2D32f)); - - /* the size of the array for the C call */ - $2 = &tmpCount; +%typemap (in, numinputs=1) (CvPoint2D32f* corners, int* corner_count) (int tmpCount) +{ + /* as input, we still need the size of the corners array */ + + /* memorize the size of the status corners */ + tmpCount = (int) PyInt_AsLong ($input); + + // these are the arguments passed to the OpenCV function + $1 = (CvPoint2D32f *) malloc (tmpCount * sizeof (CvPoint2D32f)); + $2 = &tmpCount; } /** * the corners returned by cvGoodFeaturesToTrack */ -%typemap(argout) (CvPoint2D32f* corners, int* corner_count) { - int i; - PyObject *to_add; - - /* create the list to return */ - to_add = PyList_New (tmpCount$argnum); - - /* extract all the integer values of the result, and add it to the - final resulting list */ - for (i = 0; i < tmpCount$argnum; i++) { - PyList_SetItem (to_add, i, - SWIG_NewPointerObj (&($1 [i]), - $descriptor(CvPoint2D32f *), 0)); - } - - $result = SWIG_AppendResult($result, &to_add, 1); +%typemap(argout) (CvPoint2D32f* corners, int* corner_count) +{ + int i; + PyObject *to_add; + + /* create the list to return */ + to_add = PyList_New (tmpCount$argnum); + + /* extract all the integer values of the result, and add it to the final resulting list */ + for (i = 0; i < tmpCount$argnum; i++) + PyList_SetItem (to_add, i, SWIG_NewPointerObj (&($1 [i]), $descriptor(CvPoint2D32f *), 0)); + + $result = SWIG_AppendResult($result, &to_add, 1); } -/* map one list of points to the two parameters dimension/sizes - for cvFindCornerSubPix */ -%typemap(in, numinputs=1) (CvPoint2D32f* corners, int count) - (int cornersCount, CvPoint2D32f* corners){ - int i; - - if(!PyList_Check($input)){ - PyErr_SetString(PyExc_TypeError, "Expected a list"); +/* map one list of points to the two parameters dimension/sizes for cvFindCornerSubPix */ +%typemap(in, numinputs=1) (CvPoint2D32f* corners, int count) (int cornersCount, CvPoint2D32f* corners) +{ + if(! PySequence_Check ($input)) + { + PyErr_SetString(PyExc_TypeError, "Expected a list or tuple"); return NULL; } - - /* get the size of the input array */ - cornersCount = PyList_Size ($input); - $2 = cornersCount; - - /* allocate the needed memory */ - corners = (CvPoint2D32f *)malloc ($2 * sizeof (CvPoint2D32f)); - $1 = corners; - - /* the size of the array for the C call */ - - /* extract all the points values from the list */ - for (i = 0; i < $2; i++) { - PyObject *item = PyList_GetItem ($input, i); - - void *vptr; - SWIG_Python_ConvertPtr (item, &vptr, - $descriptor(CvPoint2D32f*), - SWIG_POINTER_EXCEPTION); - CvPoint2D32f *p = (CvPoint2D32f *) vptr;; - $1 [i].x = p->x; - $1 [i].y = p->y; + + // TODO: will this ever be freed? + cornersCount = PySequence_Size ($input); + corners = (CvPoint2D32f *) malloc (cornersCount * sizeof (CvPoint2D32f)); + + // extract all the points values from the list */ + CvPoint2D32f * corner = corners; + for (int i = 0; i < cornersCount; i++, corner++) + { + PyObject * item = PySequence_GetItem ($input, i); + + if (PySequence_Check(item) && PySequence_Length(item) == 2) + { + PyObject * tuple = PySequence_Tuple (item); + if (!PyArg_ParseTuple (tuple, "ff", & corner->x, & corner->y)) + { + PyErr_SetString(PyExc_TypeError,"each entry must consist of 2 floats (x, y)"); + Py_DECREF (tuple); + Py_DECREF (item); + return NULL; + } + Py_DECREF (tuple); + } + else + { + CvPoint2D32f * ptr; + if (SWIG_ConvertPtr (item, (void **) & ptr, $descriptor(CvPoint2D32f *), SWIG_POINTER_EXCEPTION) == -1) + { + PyErr_SetString (PyExc_TypeError,"expected a sequence of 2 floats (x, y) or a CvPoint2D32f"); + Py_DECREF (item); + return NULL; + } + *corner = *ptr; } - + + Py_DECREF (item); + } + + // these are the arguments passed to the OpenCV function + $1 = corners; + $2 = cornersCount; } /** * the corners returned by cvFindCornerSubPix */ -%typemap(argout) (CvPoint2D32f* corners, int count) { - int i; - PyObject *to_add; - - /* create the list to return */ - to_add = PyList_New (cornersCount$argnum); - - /* extract all the corner values of the result, and add it to the - final resulting list */ - for (i = 0; i < cornersCount$argnum; i++) { - PyList_SetItem (to_add, i, - SWIG_NewPointerObj (&(corners$argnum [i]), - $descriptor(CvPoint2D32f *), 0)); - } - +%typemap(argout) (CvPoint2D32f* corners, int count) +{ + int i; + PyObject *to_add; + + /* create the list to return */ + to_add = PyList_New (cornersCount$argnum); + + /* extract all the corner values of the result, and add it to the + final resulting list */ + for (i = 0; i < cornersCount$argnum; i++) + PyList_SetItem (to_add, i, SWIG_NewPointerObj (&(corners$argnum [i]), $descriptor(CvPoint2D32f *), 0)); + $result = SWIG_AppendResult( $result, &to_add, 1); } @@ -929,3 +1300,179 @@ public: *$1 = PyInt_AsLong ($input); } + +/** + * take (query_points,k) and return (indices,dist) + * for cvLSHQuery, cvFindFeatures + */ +%typemap(in, noblock=1) (const CvMat* query_points) (bool freearg=false, int num_query_points) +{ + $1 = (CvMat*)PyObject_to_CvArr($input, &freearg); + num_query_points = $1->rows; +} +%typemap(freearg) (const CvMat* query_points) { + if($1!=NULL && freearg$argnum){ + cvReleaseData( $1 ); + cvFree(&($1)); + } +} +%typemap(in) (CvMat* indices, CvMat* dist, int k) +{ + $3 = (int)PyInt_AsLong($input); + $1 = cvCreateMat(num_query_points2, $3, CV_32SC1); + $2 = cvCreateMat(num_query_points2, $3, CV_64FC1); +} +%typemap(argout) (CvMat* indices, CvMat* dist, int k) +{ + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj($1, $descriptor(CvMat *), 1) ); + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj($2, $descriptor(CvMat *), 1) ); +} + +/** + * take (data) and return (indices) + * for cvLSHAdd + */ +%typemap(in) (const CvMat* data, CvMat* indices) (bool freearg=false) +{ + $1 = (CvMat*)PyObject_to_CvArr($input, &freearg); + CvMat* m = (CvMat*)$1; + $2 = cvCreateMat(m->rows, 1, CV_32SC1 ); +} +%typemap(argout) (const CvMat* data, CvMat* indices) +{ + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj($2, $descriptor(CvMat *), 1) ); +} +%typemap(freearg) (const CvMat* data, CvMat* indices) { + if($1!=NULL && freearg$argnum){ + cvReleaseData( $1 ); + cvFree(&($1)); + } +} + +/** + * take (max_out_indices) and return (indices) + * for cvFindFeaturesBoxed + */ +%typemap(in) (CvMat* out_indices) (bool freearg=false) +{ + int max_out_indices = (int)PyInt_AsLong($input); + $1 = cvCreateMat(max_out_indices, 1, CV_32SC1 ); +} +%typemap(argout) (CvMat* out_indices) +{ + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj($1, $descriptor(CvMat *), 1) ); +} + +/** + * suppress (CvSeq** keypoints, CvSeq** descriptors, CvMemStorage* storage) and return (keypoints, descriptors) + * for cvExtractSURF + */ +%typemap(in,numinputs=0) (CvSeq** keypoints, CvSeq** descriptors, CvMemStorage* storage) + (CvSeq* keypoints = 0, CvSeq* descriptors = 0,CvMemStorage* storage) +{ + storage = cvCreateMemStorage(); + $1 = &keypoints; + $2 = &descriptors; + $3 = storage; +} +%typemap(argout) (CvSeq** keypoints, CvSeq** descriptors, CvMemStorage* storage) +{ + const int n1 = 6; + int n2 = (*$2)->elem_size / sizeof(float); + assert((*$2)->elem_size == 64 * sizeof(float) || + (*$2)->elem_size == 128 * sizeof(float)); + assert((*$2)->total == (*$1)->total); + CvMat* m1 = cvCreateMat((*$2)->total,n1,CV_32FC1); + CvMat* m2 = cvCreateMat((*$2)->total,n2,CV_32FC1); + CvSeqReader r1; + cvStartReadSeq(*$1, &r1); + float* m1p = m1->data.fl; + for (int j=0;j<(*$2)->total;++j) { + CvSURFPoint* sp = (CvSURFPoint*)r1.ptr; + m1p[0] = sp->pt.x; + m1p[1] = sp->pt.y; + m1p[2] = sp->laplacian; + m1p[3] = sp->size; + m1p[4] = sp->dir; + m1p[5] = sp->hessian; + m1p += n1; + CV_NEXT_SEQ_ELEM((*$1)->elem_size, r1); + } + CvSeqReader r2; + cvStartReadSeq(*$2, &r2); + float* m2p = m2->data.fl; + for (int j=0;j<(*$2)->total;++j) { + memcpy(m2p,r2.ptr,n2*sizeof(float)); + m2p += n2; + CV_NEXT_SEQ_ELEM((*$2)->elem_size, r2); + } + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj(m1, $descriptor(CvMat *), 1) ); + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj(m2, $descriptor(CvMat *), 1) ); + cvReleaseMemStorage(&$3); +} + +/** + * suppress (CvMat* homography) and return (homography) + * for cvFindHomography + */ +%typemap(in,numinputs=0) (CvMat* homography) (bool freearg=false) +{ + $1 = cvCreateMat(3,3,CV_64FC1); +} +%typemap(argout) (CvMat* homography) +{ + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj($1, $descriptor(CvMat *), 1) ); +} + +/** + * take (coeffs) for (const CvMat* coeffs, CvMat *roots) and return (roots) + * for cvSolveCubic + */ +%typemap(in) (const CvMat* coeffs, CvMat *roots) (bool freearg=false) +{ + $1 = (CvMat*)PyObject_to_CvArr($input, &freearg); + int m = $1->rows * $1->cols; + if (m<2) { + PyErr_SetString (PyExc_TypeError,"must give at least 2 coefficients"); + return NULL; + } + $2 = cvCreateMat(m-1, 1, CV_MAKETYPE(CV_MAT_DEPTH($1->type),1)); +} +%typemap(argout) (const CvMat* coeffs, CvMat *roots) +{ + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj($2, $descriptor(CvMat *), 1) ); +} +%typemap(freearg) (const CvMat* coeffs, CvMat *roots) +{ + if($1!=NULL && freearg$argnum){ + cvReleaseData( $1 ); + cvFree(&($1)); + } +} + +/** + * take (coeffs) for (const CvMat* coeffs, CvMat *roots2) and return (roots2) + * for cvSolvePoly + */ +%typemap(in) (const CvMat* coeffs, CvMat *roots2) (bool freearg=false) +{ + $1 = (CvMat*)PyObject_to_CvArr($input, &freearg); + int m = $1->rows * $1->cols; + if (m<2) { + PyErr_SetString (PyExc_TypeError,"must give at least 2 coefficients"); + return NULL; + } + $2 = cvCreateMat(m-1, 1, CV_MAKETYPE(CV_MAT_DEPTH($1->type),2)); +} +%typemap(argout) (const CvMat* coeffs, CvMat *roots2) +{ + $result = SWIG_AppendOutput( $result, SWIG_NewPointerObj($2, $descriptor(CvMat *), 1) ); +} +%typemap(freearg) (const CvMat* coeffs, CvMat *roots2) +{ + if($1!=NULL && freearg$argnum){ + cvReleaseData( $1 ); + cvFree(&($1)); + } +} +