将ndarray转换为cv :: Mat的最简单方法是什么？

Question

我正在尝试创建Python/Cython封装的C++库，使用OpenCV中的cv::Mat类。在官方的Python包装中，所有功能都采用NumPy的ndarray而不是cv::Mat，这非常方便。但在我自己的包装中，我该如何做这种转换？也就是说，我如何创建cv::Mat从np.ndarray？

Answer 1

正如kyamagu所建议的那样，您可以使用OpenCV的官方python包装代码，特别是pyopencv_to和pyopencv_from。

我一直在努力，因为你对所有的依赖和生成的头文件做了。尽管如此，通过将cv2.cpp“清理”为lightalchemist did here以便仅保留必要的内容，可以降低其复杂性。您需要根据您的需要和您使用的OpenCV版本进行调整，但其基本上与我使用的代码基本相同。

#include <Python.h> 
#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 = "<unknown>", 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<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", 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 。

from cpython.ref cimport PyObject 

# Declares OpenCV's cv::Mat class 
cdef extern from "opencv2/core/core.hpp": 
    cdef cppclass Mat: 
     pass 

# Declares the official wrapper conversion functions + NumPy's import_array() function 
cdef extern from "cv2.cpp": 
    void import_array() 
    PyObject* pyopencv_from(const _Mat&) 
    int pyopencv_to(PyObject*, _Mat&) 


# Function to be called at initialization 
cdef void init(): 
    import_array() 

# Python to C++ conversion 
cdef Mat nparrayToMat(object array): 
    cdef Mat mat 
    cdef PyObject* pyobject = <PyObject*> array 
    pyopencv_to(pyobject, mat) 
    return <Mat> mat 

# C++ to Python conversion 
cdef object matToNparray(Mat mat): 
    return <object> pyopencv_from(mat) 

注：不知何故，我与NumPy的1.8.0在Fedora 20得到一个错误，而在import_array宏编译由于陌生return语句，我不得不手动删除它，使其工作，但我不能发现在与NumPy的1.8.0 GitHub的源代码

Answer 2

我想你可以直接使用或从the converter from the official python wrapper采取一些逻辑。这个模块没有太多的文档，但是可能包装生成器的输出有助于理解如何使用它。

Answer 3

事实证明，没有简单的方法将（任何）np.ndarray转换为相应的cv::Mat。基本上，只需要做两件事：

1. 创建相应大小和类型的空cv::Mat。
2. 复制数据。

但是，魔鬼隐藏在细节中。 ndarray和Mat都可以保存相当不同的数据格式。例如，NumPy数组中的数据可能是C语言或Fortran语句的顺序，数组对象可能拥有其数据或保留对另一个数组的视图，通道可能按不同的顺序排列（OpenCV中的NumPy与BGR中的RGB）等。

因此，不是试图解决通用问题，而是决定留下符合我需求的简单代码，并且可能会被任何感兴趣的人轻松修改。

继用Cython代码与float32/CV_32FC1图像默认的字节顺序：

cdef void array2mat(np.ndarray arr, Mat& mat): 
    cdef int r = arr.shape[0] 
    cdef int c = arr.shape[1] 
    cdef int mat_type = CV_32FC1   # or CV_64FC1, or CV_8UC3, or whatever 
    mat.create(r, c, mat_type) 
    cdef unsigned int px_size = 4   # 8 for single-channel double image or 
              # 1*3 for three-channel uint8 image 
    memcpy(mat.data, arr.data, r*c*px_size) 

要在用Cython一个使用此代码也需要声明一些类型和常量，例如像这样：

import numpy as np 
# Cython makes it simple to import NumPy 
cimport numpy as np 


# OpenCV's matrix class 
cdef extern from "opencv2/opencv.hpp" namespace "cv": 

    cdef cppclass Mat: 
     Mat() except + 
     Mat(int, int, int, void*) except + 
    void create(int, int, int) 
     void* data 
     int type() const 
     int cols 
     int rows 
     int channels() 
     Mat clone() const 

# some OpenCV matrix types 
cdef extern from "opencv2/opencv.hpp":   
    cdef int CV_8UC3 
    cdef int CV_8UC1 
    cdef int CV_32FC1 
    cdef int CV_64FC1 

相反的转换（从cv::Mat到np.ndarray）可以以类似的方式来实现。

奖励：还有很好的blog post描述RGB/BGR图像的相同种类的转换。

Answer 4

这个return语句，如果有帮助，我写了一个包装，正是这样做的。这是一个方便的库，它注册了一个boost :: python转换器，以便在OpenCV的流行的cv :: Mat数据类型和NumPy流行的np.array（）数据类型之间进行隐式转换。这使得开发人员可以相对容易地在OpenCV C++ API和使用NumPy编写的Python API之间来回切换，避免了编写额外的处理PyObjects的包装器的需求。

请看： https://github.com/spillai/numpy-opencv-converter

Answer 5

基于tlorieul的答案，这里是我用来建造一个Python/C++模块的代码：

https://gist.github.com/des0ps/88f1332319867a678a74bdbc0e7401c2

这已经Python3和OpenCV3测试。