{

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;

{

const char * name;

bool outputarg;

// more fields may be added if necessary

ArgInfo(const char * name_, bool outputarg_)

: name(name_)

, outputarg(outputarg_) {}

// to match with older pyopencv_to function signature

operator const char *() const { return name; }

{

PyAllowThreads() : _state(PyEval_SaveThread()) {}

~PyAllowThreads()

{

PyEval_RestoreThread(_state);

}

PyThreadState* _state;

{

PyEnsureGIL() : _state(PyGILState_Ensure()) {}

~PyEnsureGIL()

{

PyGILState_Release(_state);

}

PyGILState_STATE _state;

{

NumpyAllocator() { stdAllocator = Mat::getStdAllocator(); }

~NumpyAllocator() {}

UMatData* allocate(PyObject* o, int dims, const int* sizes, int type, size_t* step) const

{

UMatData* u = new UMatData(this);

u->data = u->origdata = (uchar*)PyArray_DATA((PyArrayObject*) o);

npy_intp* _strides = PyArray_STRIDES((PyArrayObject*) o);

for( int i = 0; i < dims - 1; i++ )

step[i] = (size_t)_strides[i];

step[dims-1] = CV_ELEM_SIZE(type);

u->size = sizes[0]*step[0];

u->userdata = o;

return u;

}

UMatData* allocate(int dims0, const int* sizes, int type, void* data, size_t* step, int flags, UMatUsageFlags usageFlags) const

{

if( data != 0 )

{

// issue #6969: CV_Error(Error::StsAssert, "The data should normally be NULL!");

// probably this is safe to do in such extreme case

return stdAllocator->allocate(dims0, sizes, type, data, step, flags, usageFlags);

}

PyEnsureGIL gil;

int depth = CV_MAT_DEPTH(type);

int cn = CV_MAT_CN(type);

const int f = (int)(sizeof(size_t)/8);

int typenum = depth == CV_8U ? NPY_UBYTE : depth == CV_8S ? NPY_BYTE :

depth == CV_16U ? NPY_USHORT : depth == CV_16S ? NPY_SHORT :

depth == CV_32S ? NPY_INT : depth == CV_32F ? NPY_FLOAT :

depth == CV_64F ? NPY_DOUBLE : f*NPY_ULONGLONG + (f^1)*NPY_UINT;

int i, dims = dims0;

cv::AutoBuffer<npy_intp> _sizes(dims + 1);

for( i = 0; i < dims; i++ )

_sizes[i] = sizes[i];

if( cn > 1 )

_sizes[dims++] = cn;

PyObject* o = PyArray_SimpleNew(dims, _sizes, typenum);

if(!o)

CV_Error_(Error::StsError, ("The numpy array of typenum=%d, ndims=%d can not be created", typenum, dims));

return allocate(o, dims0, sizes, type, step);

}

bool allocate(UMatData* u, int accessFlags, UMatUsageFlags usageFlags) const

{

return stdAllocator->allocate(u, accessFlags, usageFlags);

}

void deallocate(UMatData* u) const

{

if(!u)

return;

PyEnsureGIL gil;

CV_Assert(u->urefcount >= 0);

CV_Assert(u->refcount >= 0);

if(u->refcount == 0)

{

PyObject* o = (PyObject*)u->userdata;

Py_XDECREF(o);

delete u;

}

}

const MatAllocator* stdAllocator;

{

bool allowND = true;

if(!o || o == Py_None)

{

if( !m.data )

m.allocator = &g_numpyAllocator;

return true;

}

if( PyInt_Check(o) )

{

double v[] = {static_cast<double>(PyInt_AsLong((PyObject*)o)), 0., 0., 0.};

m = Mat(4, 1, CV_64F, v).clone();

return true;

}

if( PyFloat_Check(o) )

{

double v[] = {PyFloat_AsDouble((PyObject*)o), 0., 0., 0.};

m = Mat(4, 1, CV_64F, v).clone();

return true;

}

if( PyTuple_Check(o) )

{

int i, sz = (int)PyTuple_Size((PyObject*)o);

m = Mat(sz, 1, CV_64F);

for( i = 0; i < sz; i++ )

{

PyObject* oi = PyTuple_GET_ITEM(o, i);

if( PyInt_Check(oi) )

m.at<double>(i) = (double)PyInt_AsLong(oi);

else if( PyFloat_Check(oi) )

m.at<double>(i) = (double)PyFloat_AsDouble(oi);

else

{

failmsg("%s is not a numerical tuple", info.name);

m.release();

return false;

}

}

return true;

}

if( !PyArray_Check(o) )

{

failmsg("%s is not a numpy array, neither a scalar", info.name);

return false;

}

PyArrayObject* oarr = (PyArrayObject*) o;

bool needcopy = false, needcast = false;

int typenum = PyArray_TYPE(oarr), new_typenum = typenum;

int type = typenum == NPY_UBYTE ? CV_8U :

typenum == NPY_BYTE ? CV_8S :

typenum == NPY_USHORT ? CV_16U :

typenum == NPY_SHORT ? CV_16S :

typenum == NPY_INT ? CV_32S :

typenum == NPY_INT32 ? CV_32S :

typenum == NPY_FLOAT ? CV_32F :

typenum == NPY_DOUBLE ? CV_64F : -1;

if( type < 0 )

{

if( typenum == NPY_INT64 || typenum == NPY_UINT64 || typenum == NPY_LONG )

{

needcopy = needcast = true;

new_typenum = NPY_INT;

type = CV_32S;

}

else

{

failmsg("%s data type = %d is not supported", info.name, typenum);

return false;

}

}

#ifndef CV_MAX_DIM

const int CV_MAX_DIM = 32;

#endif

int ndims = PyArray_NDIM(oarr);

if(ndims >= CV_MAX_DIM)

{

failmsg("%s dimensionality (=%d) is too high", info.name, ndims);

return false;

}

int size[CV_MAX_DIM+1];

size_t step[CV_MAX_DIM+1];

size_t elemsize = CV_ELEM_SIZE1(type);

const npy_intp* _sizes = PyArray_DIMS(oarr);

const npy_intp* _strides = PyArray_STRIDES(oarr);

bool ismultichannel = ndims == 3 && _sizes[2] <= CV_CN_MAX;

for( int i = ndims-1; i >= 0 && !needcopy; i-- )

{

// these checks handle cases of

// a) multi-dimensional (ndims > 2) arrays, as well as simpler 1- and 2-dimensional cases

// b) transposed arrays, where _strides[] elements go in non-descending order

// c) flipped arrays, where some of _strides[] elements are negative

// the _sizes[i] > 1 is needed to avoid spurious copies when NPY_RELAXED_STRIDES is set

if( (i == ndims-1 && _sizes[i] > 1 && (size_t)_strides[i] != elemsize) ||

(i < ndims-1 && _sizes[i] > 1 && _strides[i] < _strides[i+1]) )

needcopy = true;

}

if( ismultichannel && _strides[1] != (npy_intp)elemsize*_sizes[2] )

needcopy = true;

if (needcopy)

{

if (info.outputarg)

{

failmsg("Layout of the output array %s is incompatible with cv::Mat (step[ndims-1] != elemsize or step[1] != elemsize*nchannels)", info.name);

return false;

}

if( needcast ) {

o = PyArray_Cast(oarr, new_typenum);

oarr = (PyArrayObject*) o;

}

else {

oarr = PyArray_GETCONTIGUOUS(oarr);

o = (PyObject*) oarr;

}

_strides = PyArray_STRIDES(oarr);

}

// Normalize strides in case NPY_RELAXED_STRIDES is set

size_t default_step = elemsize;

for ( int i = ndims - 1; i >= 0; --i )

{

size[i] = (int)_sizes[i];

if ( size[i] > 1 )

{

step[i] = (size_t)_strides[i];

default_step = step[i] * size[i];

}

else

{

step[i] = default_step;

default_step *= size[i];

}

}

// handle degenerate case

if( ndims == 0) {

size[ndims] = 1;

step[ndims] = elemsize;

ndims++;

}

if( ismultichannel )

{

ndims--;

type |= CV_MAKETYPE(0, size[2]);

}

if( ndims > 2 && !allowND )

{

failmsg("%s has more than 2 dimensions", info.name);

return false;

}

m = Mat(ndims, size, type, PyArray_DATA(oarr), step);

m.u = g_numpyAllocator.allocate(o, ndims, size, type, step);

m.addref();

if( !needcopy )

{

Py_INCREF(o);

}

m.allocator = &g_numpyAllocator;

return true;

{

if (!o || o == Py_None)

return true;

p = makePtr<T>();

return pyopencv_to(o, *p, name);

{

self->um = NULL;

{

// constructor ()

const char *kwlist[] = {NULL};

if (PyArg_ParseTupleAndKeywords(args, kwds, "", (char**) kwlist)) {

self->um = new UMat();

return 0;

}

PyErr_Clear();

}

{

// constructor (rows, cols, type)

const char *kwlist[] = {"rows", "cols", "type", NULL};

int rows, cols, type;

if (PyArg_ParseTupleAndKeywords(args, kwds, "iii", (char**) kwlist, &rows, &cols, &type)) {

self->um = new UMat(rows, cols, type);

return 0;

}

PyErr_Clear();

}

{

// constructor (m, rowRange, colRange)

const char *kwlist[] = {"m", "rowRange", "colRange", NULL};

PyObject *obj = NULL;

int y0 = -1, y1 = -1, x0 = -1, x1 = -1;

if (PyArg_ParseTupleAndKeywords(args, kwds, "O(ii)|(ii)", (char**) kwlist, &obj, &y0, &y1, &x0, &x1) && PyObject_IsUMat(obj)) {

UMat *um_other = ((cv2_UMatWrapperObject *) obj)->um;

Range rowRange(y0, y1);

Range colRange = (x0 >= 0 && x1 >= 0) ? Range(x0, x1) : Range::all();

self->um = new UMat(*um_other, rowRange, colRange);

return 0;

}

PyErr_Clear();

}

{

// constructor (m)

const char *kwlist[] = {"m", NULL};

PyObject *obj = NULL;

if (PyArg_ParseTupleAndKeywords(args, kwds, "O", (char**) kwlist, &obj)) {

// constructor (UMat m)

if (PyObject_IsUMat(obj)) {

UMat *um_other = ((cv2_UMatWrapperObject *) obj)->um;

self->um = new UMat(*um_other);

return 0;

}

// python specific constructor from array like object

Mat m;

if (pyopencv_to(obj, m, ArgInfo("UMatWrapper.np_mat", 0))) {

self->um = new UMat();

m.copyTo(*self->um);

return 0;

}

}

PyErr_Clear();

}

PyErr_SetString(PyExc_TypeError, "no matching UMat constructor found/supported");

return -1;

{

if (self->um)

delete self->um;

#if PY_MAJOR_VERSION >= 3

Py_TYPE(self)->tp_free((PyObject*)self);

#else

self->ob_type->tp_free((PyObject*)self);

#endif

if (PyObject_IsUMat(o)) {

um = *((cv2_UMatWrapperObject *) o)->um;

return true;

}

Mat m;

if (!pyopencv_to(o, m, info)) {

return false;

}

m.copyTo(um);

return true;

{

if(!o || o == Py_None)

return true;

if (PySequence_Check(o)) {

PyObject *fi = PySequence_Fast(o, name);

if (fi == NULL)

return false;

if (4 < PySequence_Fast_GET_SIZE(fi))

{

failmsg("Scalar value for argument '%s' is longer than 4", name);

return false;

}

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[(int)i] = PyFloat_AsDouble(item);

} else {

failmsg("Scalar value for argument '%s' is not numeric", name);

return false;

}

}

Py_DECREF(fi);

} else {

if (PyFloat_Check(o) || PyInt_Check(o)) {

s[0] = PyFloat_AsDouble(o);

} else {

failmsg("Scalar value for argument '%s' is not numeric", name);

return false;

}

}

return true;

{

(void)name;

if(!obj || obj == Py_None)

return true;

int _val = PyObject_IsTrue(obj);

if(_val < 0)

return false;

value = _val > 0;

return true;

{

(void)name;

if(!obj || obj == Py_None)

return true;

value = (int)PyLong_AsUnsignedLong(obj);

return value != (size_t)-1 || !PyErr_Occurred();

{

(void)name;

if(!obj || obj == Py_None)

return true;

if(PyInt_Check(obj))

value = (int)PyInt_AsLong(obj);

else if(PyLong_Check(obj))

value = (int)PyLong_AsLong(obj);

else

return false;

return value != -1 || !PyErr_Occurred();

{

(void)name;

if(!obj || obj == Py_None)

return true;

int ivalue = (int)PyInt_AsLong(obj);

value = cv::saturate_cast<uchar>(ivalue);

return ivalue != -1 || !PyErr_Occurred();

{

(void)name;

if(!obj || obj == Py_None)

return true;

if(!!PyInt_CheckExact(obj))

value = (double)PyInt_AS_LONG(obj);

else

value = PyFloat_AsDouble(obj);

return !PyErr_Occurred();

{

(void)name;

if(!obj || obj == Py_None)

return true;

if(!!PyInt_CheckExact(obj))

value = (float)PyInt_AS_LONG(obj);

else

value = (float)PyFloat_AsDouble(obj);

return !PyErr_Occurred();

{

(void)name;

if(!obj || obj == Py_None)

return true;

char* str = PyString_AsString(obj);

if(!str)

return false;

value = String(str);

return true;

{

(void)name;

if(!obj || obj == Py_None)

return true;

return PyArg_ParseTuple(obj, "ii", &sz.width, &sz.height) > 0;

{

(void)name;

if(!obj || obj == Py_None)

return true;

return PyArg_ParseTuple(obj, "ff", &sz.width, &sz.height) > 0;

{

(void)name;

if(!obj || obj == Py_None)

return true;

return PyArg_ParseTuple(obj, "iiii", &r.x, &r.y, &r.width, &r.height) > 0;

{

(void)name;

if(!obj || obj == Py_None)

return true;

return PyArg_ParseTuple(obj, "dddd", &r.x, &r.y, &r.width, &r.height) > 0;

{

(void)name;

if(!obj || obj == Py_None)

return true;

if(PyObject_Size(obj) == 0)

{

r = Range::all();

return true;

}

return PyArg_ParseTuple(obj, "ii", &r.start, &r.end) > 0;

{

(void)name;

if(!obj || obj == Py_None)

return true;

if(!!PyComplex_CheckExact(obj))

{

Py_complex c = PyComplex_AsCComplex(obj);

p.x = saturate_cast<int>(c.real);

p.y = saturate_cast<int>(c.imag);

return true;

}

return PyArg_ParseTuple(obj, "ii", &p.x, &p.y) > 0;

{

(void)name;

if(!obj || obj == Py_None)

return true;

if(!!PyComplex_CheckExact(obj))

{

Py_complex c = PyComplex_AsCComplex(obj);

p.x = saturate_cast<float>(c.real);

p.y = saturate_cast<float>(c.imag);

return true;

}

return PyArg_ParseTuple(obj, "ff", &p.x, &p.y) > 0;

{

(void)name;

if(!obj || obj == Py_None)

return true;

if(!!PyComplex_CheckExact(obj))

{

Py_complex c = PyComplex_AsCComplex(obj);

p.x = saturate_cast<double>(c.real);

p.y = saturate_cast<double>(c.imag);

return true;

}

return PyArg_ParseTuple(obj, "dd", &p.x, &p.y) > 0;

{

(void)name;

if(!obj || obj == Py_None)

return true;

return PyArg_ParseTuple(obj, "fff", &p.x, &p.y, &p.z) > 0;

{