正在从numpy.uint8的数组中提取无符号字符
Extracting unsigned char from array of numpy.uint8
我有从python序列中提取数值的代码,它在大多数情况下都能很好地工作,但对于numpy数组则不然。
当我尝试提取一个无符号字符时,我会执行以下
unsigned char val = boost::python::extract<unsigned char>(sequence[n]);
其中sequence是任何python序列,n是索引。我得到以下错误:
TypeError: No registered converter was able to produce a C++ rvalue of type
unsigned char from this Python object of type numpy.uint8
如何在C++中成功提取无符号字符?我必须为numpy类型写入/注册特殊转换器吗?我宁愿使用与其他python序列相同的代码,而不必编写使用PyArrayObject*
的特殊代码。
可以使用Boost.python注册一个自定义的from python转换器,该转换器处理从NumPy数组标量(如numpy.uint8
)到C++标量(如unsigned char
)的转换。来自python转换器的自定义注册有三个部分:
- 一种检查
PyObject
是否可转换的函数。返回NULL
表示PyObject
不能使用注册的转换器 - 一个构造函数,用于从
PyObject
构造C++类型。只有当converter(PyObject)
没有返回NULL
时,才会调用此函数 - 将要构造的C++类型
从NumPy数组标量中提取值需要几个NumPy C API调用:
- 必须在将使用NumPy C API的扩展模块的初始化过程中调用
import_array()
。根据扩展使用NumPy C API的方式,可能需要执行其他导入要求 - CCD_ 11检查CCD_ 12是否是NumPy数组标量
PyArray_DescrFromScalar()
获取数组标量的数据类型描述符对象。数据类型描述符对象包含有关如何解释底层字节的信息。例如,其type_num
数据成员包含一个对应于C类型的枚举值- CCD_ 15可以用于从NumPy数组标量中提取C型值
下面是一个完整的示例,演示如何使用助手类enable_numpy_scalar_converter
将特定的NumPy数组标量注册到它们对应的C++类型。
#include <boost/cstdint.hpp>
#include <boost/python.hpp>
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include <numpy/arrayobject.h>
// Mockup functions.
/// @brief Mockup function that will explicitly extract a uint8_t
/// from the Boost.Python object.
boost::uint8_t test_generic_uint8(boost::python::object object)
{
return boost::python::extract<boost::uint8_t>(object)();
}
/// @brief Mockup function that uses automatic conversions for uint8_t.
boost::uint8_t test_specific_uint8(boost::uint8_t value) { return value; }
/// @brief Mokcup function that uses automatic conversions for int32_t.
boost::int32_t test_specific_int32(boost::int32_t value) { return value; }
/// @brief Converter type that enables automatic conversions between NumPy
/// scalars and C++ types.
template <typename T, NPY_TYPES NumPyScalarType>
struct enable_numpy_scalar_converter
{
enable_numpy_scalar_converter()
{
// Required NumPy call in order to use the NumPy C API within another
// extension module.
import_array();
boost::python::converter::registry::push_back(
&convertible,
&construct,
boost::python::type_id<T>());
}
static void* convertible(PyObject* object)
{
// The object is convertible if all of the following are true:
// - is a valid object.
// - is a numpy array scalar.
// - its descriptor type matches the type for this converter.
return (
object && // Valid
PyArray_CheckScalar(object) && // Scalar
PyArray_DescrFromScalar(object)->type_num == NumPyScalarType // Match
)
? object // The Python object can be converted.
: NULL;
}
static void construct(
PyObject* object,
boost::python::converter::rvalue_from_python_stage1_data* data)
{
// Obtain a handle to the memory block that the converter has allocated
// for the C++ type.
namespace python = boost::python;
typedef python::converter::rvalue_from_python_storage<T> storage_type;
void* storage = reinterpret_cast<storage_type*>(data)->storage.bytes;
// Extract the array scalar type directly into the storage.
PyArray_ScalarAsCtype(object, storage);
// Set convertible to indicate success.
data->convertible = storage;
}
};
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
// Enable numpy scalar conversions.
enable_numpy_scalar_converter<boost::uint8_t, NPY_UBYTE>();
enable_numpy_scalar_converter<boost::int32_t, NPY_INT>();
// Expose test functions.
python::def("test_generic_uint8", &test_generic_uint8);
python::def("test_specific_uint8", &test_specific_uint8);
python::def("test_specific_int32", &test_specific_int32);
}
交互式使用:
>>> import numpy
>>> import example
>>> assert(42 == example.test_generic_uint8(42))
>>> assert(42 == example.test_generic_uint8(numpy.uint8(42)))
>>> assert(42 == example.test_specific_uint8(42))
>>> assert(42 == example.test_specific_uint8(numpy.uint8(42)))
>>> assert(42 == example.test_specific_int32(numpy.int32(42)))
>>> example.test_specific_int32(numpy.int8(42))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
Boost.Python.ArgumentError: Python argument types in
example.test_specific_int32(numpy.int8)
did not match C++ signature:
test_specific_int32(int)
>>> example.test_generic_uint8(numpy.int8(42))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: No registered converter was able to produce a C++ rvalue of type
unsigned char from this Python object of type numpy.int8
交互式使用中需要注意的几点:
- Python能够从
numpy.uint8
和int
Python对象中提取boost::uint8_t
enable_numpy_scalar_converter
不支持促销。例如,test_specific_int32()
接受被提升为较大标量类型(如int
)的numpy.int8
对象应该是安全的。如果希望进行促销:convertible()
需要检查兼容的NPY_TYPES
- CCD_ 26应使用CCD_ 27将提取的数组标量值强制转换为所需的C++类型
以下是公认答案的一个更通用的版本:
https://github.com/stuarteberg/printnum
(转换器是从VIGRA C++/Python绑定复制的。)
公认的答案指出,它不支持标量类型之间的强制转换。此转换器将允许任何两种标量类型(甚至,例如,int32
到int8
,或float32
到uint8
)之间的隐式转换。我认为这总体上比较好,但这里有一点方便/安全的权衡。
#include <iostream>
#include <boost/python.hpp>
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
// http://docs.scipy.org/doc/numpy/reference/c-api.array.html#importing-the-api
#define PY_ARRAY_UNIQUE_SYMBOL printnum_cpp_module_PyArray_API
#include <numpy/arrayobject.h>
#include <numpy/arrayscalars.h>
/*
* Boost python converter for numpy scalars, e.g. numpy.uint32(123).
* Enables automatic conversion from numpy.intXX, floatXX
* in python to C++ char, short, int, float, etc.
* When casting from float to int (or wide int to narrow int),
* normal C++ casting rules apply.
*
* Like all boost::python converters, this enables automatic conversion for function args
* exposed via boost::python::def(), as well as values converted via boost::python::extract<>().
*
* Copied from the VIGRA C++ library source code (MIT license).
* http://ukoethe.github.io/vigra
* https://github.com/ukoethe/vigra
*/
template <typename ScalarType>
struct NumpyScalarConverter
{
NumpyScalarConverter()
{
using namespace boost::python;
converter::registry::push_back( &convertible, &construct, type_id<ScalarType>());
}
// Determine if obj_ptr is a supported numpy.number
static void* convertible(PyObject* obj_ptr)
{
if (PyArray_IsScalar(obj_ptr, Float32) ||
PyArray_IsScalar(obj_ptr, Float64) ||
PyArray_IsScalar(obj_ptr, Int8) ||
PyArray_IsScalar(obj_ptr, Int16) ||
PyArray_IsScalar(obj_ptr, Int32) ||
PyArray_IsScalar(obj_ptr, Int64) ||
PyArray_IsScalar(obj_ptr, UInt8) ||
PyArray_IsScalar(obj_ptr, UInt16) ||
PyArray_IsScalar(obj_ptr, UInt32) ||
PyArray_IsScalar(obj_ptr, UInt64))
{
return obj_ptr;
}
return 0;
}
static void construct( PyObject* obj_ptr, boost::python::converter::rvalue_from_python_stage1_data* data)
{
using namespace boost::python;
// Grab pointer to memory into which to construct the C++ scalar
void* storage = ((converter::rvalue_from_python_storage<ScalarType>*) data)->storage.bytes;
// in-place construct the new scalar value
ScalarType * scalar = new (storage) ScalarType;
if (PyArray_IsScalar(obj_ptr, Float32))
(*scalar) = PyArrayScalar_VAL(obj_ptr, Float32);
else if (PyArray_IsScalar(obj_ptr, Float64))
(*scalar) = PyArrayScalar_VAL(obj_ptr, Float64);
else if (PyArray_IsScalar(obj_ptr, Int8))
(*scalar) = PyArrayScalar_VAL(obj_ptr, Int8);
else if (PyArray_IsScalar(obj_ptr, Int16))
(*scalar) = PyArrayScalar_VAL(obj_ptr, Int16);
else if (PyArray_IsScalar(obj_ptr, Int32))
(*scalar) = PyArrayScalar_VAL(obj_ptr, Int32);
else if (PyArray_IsScalar(obj_ptr, Int64))
(*scalar) = PyArrayScalar_VAL(obj_ptr, Int64);
else if (PyArray_IsScalar(obj_ptr, UInt8))
(*scalar) = PyArrayScalar_VAL(obj_ptr, UInt8);
else if (PyArray_IsScalar(obj_ptr, UInt16))
(*scalar) = PyArrayScalar_VAL(obj_ptr, UInt16);
else if (PyArray_IsScalar(obj_ptr, UInt32))
(*scalar) = PyArrayScalar_VAL(obj_ptr, UInt32);
else if (PyArray_IsScalar(obj_ptr, UInt64))
(*scalar) = PyArrayScalar_VAL(obj_ptr, UInt64);
// Stash the memory chunk pointer for later use by boost.python
data->convertible = storage;
}
};
/*
* A silly function to test scalar conversion.
* The first arg tests automatic function argument conversion.
* The second arg is used to demonstrate explicit conversion via boost::python::extract<>()
*/
void print_number( uint32_t number, boost::python::object other_number )
{
using namespace boost::python;
std::cout << "The number is: " << number << std::endl;
std::cout << "The other number is: " << extract<int16_t>(other_number) << std::endl;
}
/*
* Instantiate the python extension module 'printnum'.
*
* Example Python usage:
*
* import numpy as np
* from printnum import print_number
* print_number( np.uint8(123), np.int64(-456) )
*
* ## That prints the following:
* # The number is: 123
* # The other number is: -456
*/
BOOST_PYTHON_MODULE(printnum)
{
using namespace boost::python;
// http://docs.scipy.org/doc/numpy/reference/c-api.array.html#importing-the-api
import_array();
// Register conversion for all scalar types.
NumpyScalarConverter<signed char>();
NumpyScalarConverter<short>();
NumpyScalarConverter<int>();
NumpyScalarConverter<long>();
NumpyScalarConverter<long long>();
NumpyScalarConverter<unsigned char>();
NumpyScalarConverter<unsigned short>();
NumpyScalarConverter<unsigned int>();
NumpyScalarConverter<unsigned long>();
NumpyScalarConverter<unsigned long long>();
NumpyScalarConverter<float>();
NumpyScalarConverter<double>();
// Expose our C++ function as a python function.
def("print_number", &print_number, (arg("number"), arg("other_number")));
}
相关文章:
- 在C++中,将大的无符号浮点数四舍五入为整数的最佳方法是什么
- 将无符号char*转换为std::istream*C++
- 如何在C++中将一个无符号的 int 转换为两个无符号的短裤?
- 从矢量<无符号字符>转换为字符* 包括垃圾数据
- 如何理解将半精度指针转换为无符号长指针和相关的内存对齐
- C++中无符号字符溢出
- 使用无符号字符数组有效存储内存
- 如何打印boost多精度128位无符号整数
- C++模板函数,用于比较任何无符号整数和有符号整数
- 在 std::无符号字符的向量处存储 int 的十六进制表示形式
- 获取隐式转换溢出从无符号到已签名的警告
- 如何在保持其值的同时将 c++ 无符号字符变量转换为 char 变量
- 从 std::vector<无符号字符>切片中提取 int?
- 是什么导致了这种使用三进制而不是短整型的有符号int到无符号int转换
- 无法在 Arduino 中uint8_t数组转换为无符号长整型数组
- 将无符号字符的向量存储在数组中会给我 std::bad_alloc
- 正在从numpy.uint8的数组中提取无符号字符
- 提取存储在无符号字符数组中的RSA公钥模数和指数
- 如何从匹配的字符串中提取无符号值
- 读取并提取32位无符号整数的特定位数