正如kyamagu建议的那样，您可以使用OpenCV的官方python包装器代码，尤其是pyopencv_to和{}。在

我一直在为所有依赖项和生成的头文件而挣扎。然而，可以通过将^{}作为lightalchemist did here进行“清理”来降低复杂性，以便只保留必要的内容。你需要根据你的需要和你正在使用的OpenCV版本来调整它，但它基本上与我使用的代码相同。在#include

#include "numpy/ndarrayobject.h"

#include "opencv2/core/core.hpp"

static PyObject* opencv_error = 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;

}

class PyAllowThreads

{

public:

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

~PyAllowThreads()

{

PyEval_RestoreThread(_state);

}

private:

PyThreadState* _state;

};

class PyEnsureGIL

{

public:

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

~PyEnsureGIL()

{

PyGILState_Release(_state);

}

private:

PyGILState_STATE _state;

};

#define ERRWRAP2(expr) \

try \

{ \

PyAllowThreads allowThreads; \

expr; \

} \

catch (const cv::Exception &e) \

{ \

PyErr_SetString(opencv_error, e.what()); \

return 0; \

}

using namespace cv;

static PyObject* failmsgp(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;

}

static size_t REFCOUNT_OFFSET = (size_t)&(((PyObject*)0)->ob_refcnt) +

(0x12345678 != *(const size_t*)"\x78\x56\x34\x12\0\0\0\0\0")*sizeof(int);

static inline PyObject* pyObjectFromRefcount(const int* refcount)

{

return (PyObject*)((size_t)refcount - REFCOUNT_OFFSET);

}

static inline int* refcountFromPyObject(const PyObject* obj)

{

return (int*)((size_t)obj + REFCOUNT_OFFSET);

}

class NumpyAllocator : public MatAllocator

{

public:

NumpyAllocator() {}

~NumpyAllocator() {}

void allocate(int dims, const int* sizes, int type, int*& refcount,

uchar*& datastart, uchar*& data, size_t* step)

{

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;

npy_intp _sizes[CV_MAX_DIM+1];

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

_sizes[i] = sizes[i];

if( cn > 1 )

{

/*if( _sizes[dims-1] == 1 )

_sizes[dims-1] = cn;

else*/

_sizes[dims++] = cn;

}

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

if(!o)

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

refcount = refcountFromPyObject(o);

npy_intp* _strides = PyArray_STRIDES(o);

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

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

datastart = data = (uchar*)PyArray_DATA(o);

}

void deallocate(int* refcount, uchar*, uchar*)

{

PyEnsureGIL gil;

if( !refcount )

return;

PyObject* o = pyObjectFromRefcount(refcount);

Py_INCREF(o);

Py_DECREF(o);

}

};

NumpyAllocator g_numpyAllocator;

enum { ARG_NONE = 0, ARG_MAT = 1, ARG_SCALAR = 2 };

static int pyopencv_to(const PyObject* o, Mat& m, const char* name = "", bool allowND=true)

{

if(!o || o == Py_None)

{

if( !m.data )

m.allocator = &g_numpyAllocator;

return true;

}

if( PyInt_Check(o) )

{

double v[] = {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(i) = (double)PyInt_AsLong(oi);

else if( PyFloat_Check(oi) )

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

else

{

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

m.release();

return false;

}

}

return true;

}

if( !PyArray_Check(o) )

{

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

return false;

}

bool needcopy = false, needcast = false;

int typenum = PyArray_TYPE(o), 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 || type == NPY_LONG )

{

needcopy = needcast = true;

new_typenum = NPY_INT;

type = CV_32S;

}

else

{

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

return false;

}

}

int ndims = PyArray_NDIM(o);

if(ndims >= CV_MAX_DIM)

{

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

return false;

}

int size[CV_MAX_DIM+1];

size_t step[CV_MAX_DIM+1], elemsize = CV_ELEM_SIZE1(type);

const npy_intp* _sizes = PyArray_DIMS(o);

const npy_intp* _strides = PyArray_STRIDES(o);

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

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

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

needcopy = true;

}

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

needcopy = true;

if (needcopy)

{

if( needcast )

o = (PyObject*)PyArray_Cast((PyArrayObject*)o, new_typenum);

else

o = (PyObject*)PyArray_GETCONTIGUOUS((PyArrayObject*)o);

_strides = PyArray_STRIDES(o);

}

for(int i = 0; i < ndims; i++)

{

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

step[i] = (size_t)_strides[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", name);

return false;

}

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

if( m.data )

{

m.refcount = refcountFromPyObject(o);

if (!needcopy)

{

m.addref(); // protect the original numpy array from deallocation

// (since Mat destructor will decrement the reference counter)

}

};

m.allocator = &g_numpyAllocator;

return true;

}

static PyObject* pyopencv_from(const Mat& m)

{

if( !m.data )

Py_RETURN_NONE;

Mat temp, *p = (Mat*)&m;

if(!p->refcount || p->allocator != &g_numpyAllocator)

{

temp.allocator = &g_numpyAllocator;

ERRWRAP2(m.copyTo(temp));

p = &temp;

}

p->addref();

return pyObjectFromRefcount(p->refcount);

}

一旦您有了一个清理后的cv2.cpp文件，下面是一些Cython代码来处理转换。请注意import_array()函数的定义和调用(它是在cv2.cpp中包含的头中定义的NumPy函数)，这对于定义pyopencv_to使用的某些宏是必需的，如果不调用它，则会得到lightalchemist pointed out的分段错误。在

^{pr2}$

注意：我在编译Fedora20上的NumPy 1.8.0时遇到了一个错误，因为import_array宏中有一个奇怪的return语句，我不得不手动删除它才能使它正常工作，但在NumPy的1.8.0github源代码中找不到这个return语句