Получение буфера данных в C ++ с boost :: python - PullRequest
Новая
       8

Получение буфера данных в C ++ с boost :: python

0 голосов
/ 11 мая 2018

Я хотел бы иметь возможность передавать буфер (то есть что-то, реализующее протокол буфера, такой как пустой массив) числовых данных в c ++ из Python: 

>>> import mymod
>>> import numpy
>>> mymod.some_func(numpy.array([1,2,3]))

и каким-то образом получите его в c ++: 

void some_func([something] array) {
    for (int ii : array) {
       cout << ii << endl;
    }
}

печать 

1 
2
3

Мне все равно, что это [что-то] (указатель, std :: vector, что угодно). Кто-нибудь знает как это сделать? На удивление мало информации об этом ...

1 Ответ

0 голосов
/ 11 мая 2018

OK <get_ready_for_this.mp3> вот что я сделал, чтобы решить эту проблему.

Сначала я создал тип, представляющий требуемый буфер, наряду с некоторыми вспомогательными функциями для приведения буфера данных в целевой формат.Вы можете легко изменить это, чтобы сделать его более гибким, но я просто хочу массив комплексных значений с плавающей запятой. 

// vector of complex values
typedef vector<cfloat> cbuffer;


// helper to copy data
template<typename T>
void cbuffer_copy_from(cbuffer& cbuf, void *ptr, ssize_t len, ssize_t stride) {
    cbuf.reserve(len);

    // convert elements into buffer
    char* cptr = (char*)ptr;
    for (ssize_t ii=0; ii < len; ii++) {
        cbuf.emplace_back(*reinterpret_cast<T*>(cptr));
        cptr += stride;
    }
};


// populate vector from source
template<typename T>
void cbuffer_from(cbuffer& cbuf, void *ptr, ssize_t len, ssize_t stride) {
    cbuffer_copy_from<T>(cbuf, ptr, len, stride);
}


// fast path for data that's already cfloat
template <>
void cbuffer_from<cfloat>(cbuffer& cbuf, void *ptr, ssize_t len, ssize_t stride) {
    // if stride is right, we can just copy the data
    if (stride == sizeof(cfloat)) {
        cbuf.resize(len);
        memcpy(&cbuf[0], ptr, len*sizeof(cfloat));
    } else {
        cbuffer_copy_from<cfloat>(cbuf, ptr, len, stride);
    }
}

Затем я создал собственный преобразователь из python в тип моего cbuffer: 

// python -> cbuffer conversion
struct python_to_cbuffer {
    // register converter 
    python_to_cbuffer() {
        converter::registry::push_back(
            &convertible,
            &construct,
            type_id<cbuffer>()
        );
    }

    // does python object implement buffer protocol?
    static void* convertible(PyObject* object) {
        return PyObject_CheckBuffer(object) ? object : nullptr;
    }

    // convert object into a complex number
    static void construct(
        PyObject* object,
        converter::rvalue_from_python_stage1_data* data
    ) {
        // grab pointer to memory into which to construct the new value
        void* storage = ((converter::rvalue_from_python_storage<cbuffer>*)data)->storage.bytes;

        // create buffer object from export source, require format
        Py_buffer view;
        if (PyObject_GetBuffer(object, &view, PyBUF_FORMAT | PyBUF_STRIDES) < 0) {
            return;
        }

        // make sure it's a one dimensional array
        if (view.ndim != 1) {
            PyBuffer_Release(&view);
            throw std::runtime_error("Array object is not one dimensional");
        }

        // build new cbuffer to store data
        new (storage) cbuffer;
        cbuffer* buffer = static_cast<cbuffer*>(storage);

        // try to convert view data into cfloat format
        string type(view.format);
             if (type == "f")  cbuffer_from<float>  (*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "d")  cbuffer_from<double> (*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "Zf") cbuffer_from<cfloat> (*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "Zd") cbuffer_from<cdouble>(*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "b")  cbuffer_from<int8_t> (*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "h")  cbuffer_from<int16_t>(*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "i")  cbuffer_from<int32_t>(*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "l")  cbuffer_from<int32_t>(*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "q")  cbuffer_from<int32_t>(*buffer, view.buf, view.shape[0], view.strides[0]);
        else if (type == "n")  cbuffer_from<ssize_t>(*buffer, view.buf, view.shape[0], view.strides[0]);
        else {
            buffer->~cbuffer();
            throw std::runtime_error("Unable to marshall '" + string(view.format) + "' data format");
        }

        // Stash the memory chunk pointer for later use by boost.python
        data->convertible = storage;
    }
};

Функция convertible() проверяет, что объект Python реализует буферный протокол.Затем функция construct() фактически извлекает буфер из объекта и преобразует его в нужный формат с помощью вышеуказанных вспомогательных функций.Если мы потерпим неудачу на каком-либо этапе, очистим и сгенерируем исключение времени выполнения.

Наконец, мы создаем экземпляр преобразователя в модуле: 

// define python module
BOOST_PYTHON_MODULE(module) {
    // register python -> c++ converters
    python_to_cbuffer();

    def("test", test);
}

И, если мы создаем тестовую функцию: 

void test(cbuffer buf) {
    for (cfloat val : buf) {
        printf("(%f, %f)\n", val.re, val.im);
    }
}

Тогда в python: 

>>> module.test(numpy.array([1+2j,3+4j],dtype=numpy.complex64))
(1.000000, 2.000000)
(3.000000, 4.000000)
>>> module.test(numpy.array([1,2],'b'))
(1.000000, 0.000000)
(2.000000, 0.000000)
>>> module.test(numpy.array([1,2],'i'))
(1.000000, 0.000000)
(2.000000, 0.000000)
>>> module.test(numpy.array([1,2],'l'))
(1.000000, 0.000000)
(2.000000, 0.000000)

Наслаждайтесь!

...