为使用OpenCV的C代码编写Python绑定

3 回答

• 0

  我解决了这个问题，所以我想我会在这里与可能遇到同样问题的其他人分享 .

  基本上，为了摆脱分段错误，我需要调用numpy的import_array（）函数 .

  从python运行C代码的“高级”视图是这样的：

  假设你在python中有一个函数 foo(arg) ，它是某个C函数的绑定 . 当你调用 foo(myObj) 时，必须有一些代码将python对象"myObj"转换为你的C代码可以作用的形式 . 此代码通常使用SWIG或Boost :: Python等工具半自动创建 . （我在下面的例子中使用了Boost :: Python . ）

  现在， foo(arg) 是一些C函数的python绑定 . 此C函数将接收通用 PyObject 指针作为参数 . 您需要使用C代码将此 PyObject 指针转换为"equivalent" C对象 . 在我的例子中，我的python代码将OpenCV numpy数组作为函数的参数传递给OpenCV图像 . C中的"equivalent"表单是OpenCV C Mat对象 . OpenCV在cv2.cpp中提供了一些代码（下面再现），将 PyObject 指针（代表numpy数组）转换为C Mat . 更简单的数据类型（如int和string）不需要用户编写这些转换函数，因为它们由Boost :: Python自动转换 .

  将 PyObject 指针转换为合适的C形式后，C代码可以对其进行操作 . 当数据必须从C返回到python时，会出现类似的情况，需要C代码将数据的C表示转换为某种形式的 PyObject . Boost :: Python将把 PyObject 转换为相应的python表单 . 当 foo(arg) 在python中返回结果时，它是python可用的形式 . 而已 .

  下面的代码展示了如何包装C类“ABC”并公开其方法“doSomething”，它从python中获取一个numpy数组（用于图像），将其转换为OpenCV的C Mat，进行一些处理，将结果转换为PyObject *，并将其返回给python解释器 . 您可以公开任意数量的函数/方法（请参阅下面代码中的注释） .

  abc.hpp：

  #ifndef ABC_HPP
  #define ABC_HPP
  
  #include <Python.h>
  #include <string>
  
  class ABC
  {
    // Other declarations 
      ABC();
      ABC(const std::string& someConfigFile);
      virtual ~ABC();
      PyObject* doSomething(PyObject* image); // We want our python code to be able to call this function to do some processing using OpenCV and return the result.
    // Other declarations
  };
  
  #endif
  

  abc.cpp：

  #include "abc.hpp"
  #include "my_cpp_library.h" // This is what we want to make available in python. It uses OpenCV to perform some processing.
  
  #include "numpy/ndarrayobject.h"
  #include "opencv2/core/core.hpp"
  
  // The following conversion functions are taken from OpenCV's cv2.cpp file inside modules/python/src2 folder.
  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)
  {
      //NumpyAllocator g_numpyAllocator;
      if(!o || o == Py_None)
      {
          if( !m.data )
              m.allocator = &g_numpyAllocator;
          return true;
      }
  
      if( !PyArray_Check(o) )
      {
          failmsg("%s is not a numpy array", name);
          return false;
      }
  
      int typenum = PyArray_TYPE(o);
      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 || typenum == NPY_LONG ? CV_32S :
                 typenum == NPY_FLOAT ? CV_32F :
                 typenum == NPY_DOUBLE ? CV_64F : -1;
  
      if( type < 0 )
      {
          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 transposed = false;
  
      for(int i = 0; i < ndims; i++)
      {
          size[i] = (int)_sizes[i];
          step[i] = (size_t)_strides[i];
      }
  
      if( ndims == 0 || step[ndims-1] > elemsize ) {
          size[ndims] = 1;
          step[ndims] = elemsize;
          ndims++;
      }
  
      if( ndims >= 2 && step[0] < step[1] )
      {
          std::swap(size[0], size[1]);
          std::swap(step[0], step[1]);
          transposed = true;
      }
  
      if( ndims == 3 && size[2] <= CV_CN_MAX && step[1] == elemsize*size[2] )
      {
          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);
          m.addref(); // protect the original numpy array from deallocation
                      // (since Mat destructor will decrement the reference counter)
      };
      m.allocator = &g_numpyAllocator;
  
      if( transposed )
      {
          Mat tmp;
          tmp.allocator = &g_numpyAllocator;
          transpose(m, tmp);
          m = tmp;
      }
      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;
          m.copyTo(temp);
          p = &temp;
      }
      p->addref();
      return pyObjectFromRefcount(p->refcount);
  }
  
  ABC::ABC() {}
  ABC::~ABC() {}
  // Note the import_array() from NumPy must be called else you will experience segmentation faults.
  ABC::ABC(const std::string &someConfigFile)
  {
    // Initialization code. Possibly store someConfigFile etc.
    import_array(); // This is a function from NumPy that MUST be called.
    // Do other stuff
  }
  
  // The conversions functions above are taken from OpenCV. The following function is 
  // what we define to access the C++ code we are interested in.
  PyObject* ABC::doSomething(PyObject* image)
  {
      cv::Mat cvImage;
      pyopencv_to(image, cvImage); // From OpenCV's source
  
      MyCPPClass obj; // Some object from the C++ library.
      cv::Mat processedImage = obj.process(cvImage);
  
      return pyopencv_from(processedImage); // From OpenCV's source
  }
  

  使用Boost Python创建python模块的代码 . 我从http://jayrambhia.wordpress.com/tag/boost/获取了这个以及下面的Makefile：

  pysomemodule.cpp：

  #include <string>    
  #include<boost/python.hpp>
  #include "abc.hpp"
  
  using namespace boost::python;
  
  BOOST_PYTHON_MODULE(pysomemodule)
  {
      class_<ABC>("ABC", init<const std::string &>())
        .def(init<const std::string &>())
        .def("doSomething", &ABC::doSomething) // doSomething is the method in class ABC you wish to expose. One line for each method (or function depending on how you structure your code). Note: You don't have to expose everything in the library, just the ones you wish to make available to python.
      ;
  }
  

  最后，Makefile（在Ubuntu上成功编译但是应该在其他地方工作，可能只需要很少的调整） .

  PYTHON_VERSION = 2.7
  PYTHON_INCLUDE = /usr/include/python$(PYTHON_VERSION)
  
  # location of the Boost Python include files and library
  BOOST_INC = /usr/local/include/boost
  BOOST_LIB = /usr/local/lib
  
  OPENCV_LIB = `pkg-config --libs opencv`
  OPENCV_CFLAGS = `pkg-config --cflags opencv`
  
  MY_CPP_LIB = lib_my_cpp_library.so
  
  TARGET = pysomemodule
  SRC = pysomemodule.cpp abc.cpp
  OBJ = pysomemodule.o abc.o
  
  $(TARGET).so: $(OBJ)
      g++ -shared $(OBJ) -L$(BOOST_LIB) -lboost_python -L/usr/lib/python$(PYTHON_VERSION)/config -lpython$(PYTHON_VERSION) -o $(TARGET).so $(OPENCV_LIB) $(MY_CPP_LIB)
  
  $(OBJ): $(SRC)
      g++ -I$(PYTHON_INCLUDE) -I$(BOOST_INC) $(OPENCV_CFLAGS) -fPIC -c $(SRC)
  
  clean:
      rm -f $(OBJ)
      rm -f $(TARGET).so
  

  成功编译库后，目录中应该有一个文件“pysomemodule.so” . 将此lib文件放在python解释器可访问的位置 . 然后，您可以导入此模块并在上面创建类“ABC”的实例，如下所示：

  import pysomemodule
  
  foo = pysomemodule.ABC("config.txt") # This will create an instance of ABC
  

  现在，给定一个OpenCV numpy数组图像，我们可以使用以下命令调用C函数：

  processedImage = foo.doSomething(image) # Where the argument "image" is a OpenCV numpy image.
  

  请注意，您将需要Boost Python，Numpy dev以及Python dev库来创建绑定 .

  以下两个链接中的NumPy文档在帮助理解转换代码中使用的方法以及必须调用import_array（）的原因方面特别有用 . 特别是，官方numpy文档有助于理解OpenCV的python绑定代码 .

  http://dsnra.jpl.nasa.gov/software/Python/numpydoc/numpy-13.html http://docs.scipy.org/doc/numpy/user/c-info.how-to-extend.html

  希望这可以帮助 .

  回复于 2024-04-27T17:27:38+08:00
• 32

  我希望这可以帮助人们寻找快速简便的方法 .

  这是github repo使用我用OpenCV的Mat类公开代码的开放C代码尽可能少的痛苦 .

  [更新]此代码现在适用于 OpenCV 2.X 和 OpenCV 3.X . 现在还提供对Python 3.X的CMake和实验支持 .

  回复于 2024-04-27T17:27:38+08:00
• 8

  一种选择是将代码直接实现到modules / python / src2 / cv2.cpp中作为python绑定的自定义分支 .

  'OpenCV构建系统将它捆绑成单个"cv2" . 贡献模块的示例是here . ' https://github.com/opencv/opencv/issues/8872#issuecomment-307136942

  回复于 2024-04-27T17:27:38+08:00