Getting data from ctypes array into numpy

问题:

I am using a Python (via ctypes) wrapped C library to run a series of computation. At different stages of the running, I want to get data into Python, and specifically numpy arrays.

The wrapping I am using does two different types of return for array data (which is of particular interest to me):

• ctypes Array: When I do type(x) (where x is the ctypes array, I get a in return. I know that this data is a copy of the internal data from the documentation and I am able to get it into a numpy array easily:

  >>> np.ctypeslib.as_array(x)

This returns a 1D numpy array of the data.

• ctype pointer to data: In this case from the library's documentation, I understand that I am getting a pointer to the data stored and used directly to the library. Whey I do type(y) (where y is the pointer) I get . With this case I am still able to index through the data like y[0][2], but I was only able to get it into numpy via a super awkward:

  >>> np.frombuffer(np.core.multiarray.int_asbuffer(     ctypes.addressof(y.contents), array_length*np.dtype(float).itemsize))

I found this in an old numpy mailing list thread from Travis Oliphant, but not in the numpy documentation. If instead of this approach I try as above I get the following:

>>> np.ctypeslib.as_array(y) ... ...  BUNCH OF STACK INFORMATION ... AttributeError: 'LP_c_double' object has no attribute '__array_interface__'

Is this np.frombuffer approach the best or only way to do this? I am open to other suggestions but must would still like to use numpy as I have a lot of other post-processing code that relies on numpy functionality that I want to use with this data.

回答1:

Creating NumPy arrays from a ctypes pointer object is a problematic operation. It is unclear who actually owns the memory the pointer is pointing to. When will it be freed again? How long is it valid? Whenever possible I would try to avoid this kind of construct. It is so much easier and safer to create arrays in the Python code and pass them to the C function than to use memory allocated by a Python-unaware C function. By doing the latter, you negate to some extent the advantages of having a high-level language taking care of the memory management.

If you are really sure that someone takes care of the memory, you can create an object exposing the Python "buffer protocol" and then create a NumPy array using this buffer object. You gave one way of creating the buffer object in your post, via the undocumented int_asbuffer() function:

buffer = numpy.core.multiarray.int_asbuffer(     ctypes.addressof(y.contents), 8*array_length)

(Note that I substituted 8 for np.dtype(float).itemsize. It's always 8, on any platform.) A different way to create the buffer object would be to call the PyBuffer_FromMemory() function from the Python C API via ctypes:

buffer_from_memory = ctypes.pythonapi.PyBuffer_FromMemory buffer_from_memory.restype = ctypes.py_object buffer = buffer_from_memory(y, 8*array_length)

For both these ways, you can create a NumPy array from buffer by

a = numpy.frombuffer(buffer, float)

(I actually do not understand why you use .astype() instead of a second parameter to frombuffer; furthermore, I wonder why you use np.int, while you said earlier that the array contains doubles.)

I'm afraid it won't get much easier than this, but it isn't that bad, don't you think? You could bury all the ugly details in a wrapper function and don't worry about it any more.

回答2:

Another possibility (which may require more recent versions of libraries than is available when the first answer was written -- I tested something similar with ctypes 1.1.0 and numpy 1.5.0b2) is to convert from the pointer to the array.

np.ctypeslib.as_array(     (ctypes.c_double * array_length).from_address(ctypes.addressof(y.contents)))

This seems to still have the shared ownership semantics, so you probably need to make sure that you free the underlying buffer eventually.

回答3:

Neither of these worked for me in Python 3. As a general solution for converting a ctypes pointer into a numpy ndarray in python 2 and 3 I found this worked (via getting a read-only buffer):

def make_nd_array(c_pointer, shape, dtype=np.float64, order='C', own_data=True):     arr_size = np.prod(shape[:]) * np.dtype(dtype).itemsize      if sys.version_info.major >= 3:         buf_from_mem = ctypes.pythonapi.PyMemoryView_FromMemory         buf_from_mem.restype = ctypes.py_object         buf_from_mem.argtypes = (ctypes.c_void_p, ctypes.c_int, ctypes.c_int)         buffer = buf_from_mem(c_pointer, arr_size, 0x100)     else:         buf_from_mem = ctypes.pythonapi.PyBuffer_FromMemory         buf_from_mem.restype = ctypes.py_object         buffer = buf_from_mem(c_pointer, arr_size)     arr = np.ndarray(tuple(shape[:]), dtype, buffer, order=order)     if own_data and not arr.flags.owndata:         return arr.copy()     else:         return arr

回答4:

If you are ok with creating arrays in python, the following example with 2d array works in python3:

import numpy as np import ctypes  OutType = (ctypes.c_float * 4) * 6 out = OutType() YourCfunction = ctypes.CDLL('./yourlib.so').voidreturningfunctionwithweirdname YourCfunction.argtypes = [ctypes.POINTER(ctypes.c_float)]*3, ctypes.POINTER(ctypes.c_float)]*5, OutType] YourCfunction(input1, input2, out) out = np.array(out) # convert it to numpy  print(out)

numpy and ctypes versions are 1.11.1 and 1.1.0

转载请标明出处:Getting data from ctypes array into numpy

文章来源: Getting data from ctypes array into numpy