logo标签列表

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

pythonc++opencvnumpycython
7

我正在尝试为使用OpenCV的cv::Mat类的C++库创建Python/Cython包装器。在官方Python包装器中，所有函数都使用NumPy的ndarray而不是cv::Mat，这非常方便。但是在我的包装器中，我该如何进行这样的转换呢？也就是说，我如何从np.ndarray创建cv::Mat？

5个回答
4
如kyamagu所建议的，你可以使用OpenCV官方的Python封装代码，特别是pyopencv_to和pyopencv_from。
我像你一样一直苦苦挣扎于所有依赖项和生成的头文件。然而，通过“清理”cv2.cpp来减少复杂性是可能的，就像lightalchemist在这里所做的那样，只保留必要的内容。你需要根据你的需求和使用的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指出的那样导致分段错误。
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)

注意：在Fedora 20上编译NumPy 1.8.0时，由于import_array宏中存在一个奇怪的返回语句，我遇到了一个错误。我不得不手动删除它才能使其正常工作，但是我找不到这个返回语句在NumPy 1.8.0 GitHub源代码中的位置。
我现在无法测试它，但它看起来比我使用的方法更好，所以我接受它而不进行验证。 - ffriend
查看 https://github.com/numpy/numpy/blob/c90d7c94fd2077d0beca48fa89a423da2b0bb663/numpy/core/code_generators/generate_numpy_api.py 如果您使用Python3，则该宏将返回NULL值。当使用Python 3时，您可以修改init函数以返回void指针而不是什么都不返回。您可以检查我的答案，获取此Python3 / OpenCV3兼容版本。 - Thibaut Mattio
3
原来，将（任何）np.ndarray转换为相应的cv :: Mat 没有简单的方法。 基本上，只需要做两件事：

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

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

因此，我决定不尝试解决通用问题，而是使用适合我的需求并且可以轻松修改的简单代码。

以下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）可以通过类似的方式实现。

额外福利：还有一个很好的博客文章描述了RGB / BGR图像的同类转换。

2

我猜你可以直接使用或从官方python包装器的转换器中获取一些逻辑。这个模块没有太多文档，但也许包装器生成器的输出有助于理解如何使用它。

感谢您的回答，很抱歉回复晚了。我花了几天时间尝试整合这个转换器，但不幸的是它与其他文件密切相关，而这些文件又依赖于整个OpenCV基础设施，包括项目布局、生成的文件等等。我会尝试更多的方法，但如果您知道其他的转换器，我会很高兴看到它们。谢谢。 - ffriend
2
如果有帮助的话，我写了一个包装器来实现这一点。它是一个方便的库，注册了一个boost::python转换器来隐式地在OpenCV流行的cv::Mat数据类型和NumPy流行的np.array()数据类型之间进行转换。这使开发人员可以轻松地在使用NumPy编写的Python API中在OpenCV C++ API和Python API之间来回切换，避免编写额外的包装器来处理传递或返回的PyObjects。你可以看看这个：https://github.com/spillai/numpy-opencv-converter
0
4
链接无法访问，你能否更新一个新的链接？ - Alvar
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接