Question

I’m working on a Computer Vision system with OpenCV in C++. I wrote a small GUI for it by using Boost::Python and PyQT4. Since I don’t want to introduce QT to the C++ project, I need a way to expose Mat::data (an unsigned char * member) to Python in order to create a QImage there.

First I tried it like this:

    class_<cv::Mat>("Mat", init<>())
          .add_property("data_", make_getter(&Mat::data))

but then I got this in Python: “TypeError: No to_python (by-value) converter found for C++ type: unsigned char*”

I couldn’t write a converter for it because a PyBuf of course needs to know its size.

So my next approach was trying to create a proxy object like this:

struct uchar_array {
  uchar *data;
  size_t size;
  bool copied;
  static const bool debug = true;

  // copy from byte array
  uchar_array(uchar *ptr, size_t size, bool copy) {
      this->size = size;
      this->copied = copy;
      if(copied) {
          data = new uchar[size];
          memcpy(data, ptr, size);
      } else {
          data = ptr;
      }
      if(debug) LOG_ERR("init %d bytes in @%p, mem @%p", size, this, data);
  }

  PyObject *py_ptr() {
      if(debug) LOG_ERR("py_ptr");
      return boost::python::incref(PyBuffer_FromMemory(data, size));
  }

  ~uchar_array() {
      if(debug)  LOG_ERR("~uchar_array @%p", this);
      if(copied) {
          if(debug) LOG_ERR("free @%p, mem @%p", this, data);
          delete [] data;
      }
  }
};

And exposing this via a non-member method:

uchar_array *getMatData(Mat &mat) {
  size_t size = mat.rows * mat.cols * mat.elemSize();
  uchar_array *arr = new uchar_array(mat.data, size, true);
  return arr;
}


class_<cv::Mat>("Mat", init<>())
        .def("data", getMatData, with_custodian_and_ward_postcall<1, 0, return_value_policy<manage_new_object> >())
class_<uchar_array, shared_ptr<uchar_array> >("uchar_array", no_init)
        .def("ptr", &uchar_array::py_ptr);

This works and gets me the buffer into Python, but there are two problems with this approach:

1. I now have to use mat.data().ptr(), it would be nicer to just do mat.data
2. When doing mat.data().ptr(), it seems the temporary uchar_array gets destructed immediately after calling ptr(), thus freeing the memory while I still want to use it

I did several experiments with custodian_and_ward and other stuff but got to a point where I stopped to understand this.

So, could anyone please tell me: What’s the preferred way to export an unsigned char * to a PyBuf? In two variants, if possible: allocated for Python so should be freed by Python or as internal pointer where C++ frees it.

Answer 1

char* buffers are not really python friendly. On my project (which is not performance sensitive) I would use a std::vector or std::string, depending on what it was intended to contain. Both of these are nicely python friendly.

If you are not able to alter the underlying data structure, you can use add_property and a couple of getter and setter functions to convert data to a more convenient structure.