ctypes tricks

| tags: programming

A few tricks I learned using ctypes to wrap OpenCV.

Easy function prototypes

ctypes allows declaration of foreign function arguments and results using a very power prototype capability. Unfortunately the parameters have to be specified in two separate lists. This little helper function cleans that up into one list:

# make function prototypes a bit easier to declare
def cfunc(name, dll, result, *args):
    '''build and apply a ctypes prototype complete with parameter flags'''
    atypes = []
    aflags = []
    for arg in args:
        aflags.append((arg[2], arg[0]) + arg[3:])
    return CFUNCTYPE(result, *atypes)((name, dll), tuple(aflags))

Arguments: name is a string specifying the function name in the dll, dll is the dll object, result is the type of the result, *args is a list of tuples with 3 or 4 elements each like (argname, argtype, in/out, default) where argname is the name of the argument, argtype is the type, in/out is 1 for input and 2 for output, and default is an optional default value.

For example:

cvMinMaxLoc = cfunc('cvMinMaxLoc', _cxDLL, None,
                       ('image', POINTER(IplImage), 1),
                       ('min_val', POINTER(double), 2),
                       ('max_val', POINTER(double), 2),
                       ('min_loc', POINTER(CvPoint), 2),
                       ('max_loc', POINTER(CvPoint), 2),
                       ('mask', POINTER(IplImage), 1, None))

means locate cvMinMaxLoc in dll _cxDLL, it returns nothing. The first argument is an input image. The next 4 arguments are output, and the last argument is input with an optional value. A typical call might look like:

min_val,max_val,min_loc,max_loc = cvMinMaxLoc(img)

Array arguments from lists

The from_param feature of ctypes is a very powerful way to insert code into the process of preparing arguments to pass to foreign functions. For example, using this class:

class ListPOINTER(object):
    '''Just like a POINTER but accept a list of ctype as an argument'''
    def __init__(self, etype):
        self.etype = etype

    def from_param(self, param):
        if isinstance(param, (list,tuple)):
            return (self.etype * len(param))(*param)

Suppose I have a foreign function foo that expects an array of ints. I could say:

ary = (c_int * 3)()
ary[0] = 1
ary[1] = 2
ary[2] = 3

I can replace an argument of type POINTER(c_int) with LIstPOINTER(c_int). Now I can call foo like:


Arrays of pointers to arrays from nested lists

The idea above can easily be extended to replace an int** with a nested list.

class ListPOINTER2(object):
    '''Just like POINTER(POINTER(ctype)) but accept a list of lists of ctype'''
    def __init__(self, etype):
        self.etype = etype

    def from_param(self, param):
        if isinstance(param, (list,tuple)):
            val = (POINTER(self.etype) * len(param))()
            for i,v in enumerate(param):
                if isinstance(v, (list,tuple)):
                    val[i] = (self.etype * len(v))(*v)
                    raise TypeError, 'nested list or tuple required at %d' % i
            return val
            raise TypeError, 'list or tuple required'

Implicit byref arguments

class ByRefArg(object):
    '''Just like a POINTER but accept an argument and pass it byref'''
    def __init__(self, atype):
        self.atype = atype

    def from_param(self, param):
        return byref(self.atype(param))

Structures that can print themselves and magically accept tuples as arguments

# hack the ctypes.Structure class to include printing the fields
class _Structure(Structure):
    def __repr__(self):
        '''Print the fields'''
        res = []
        for field in self._fields_:
            res.append('%s=%s' % (field[0], repr(getattr(self, field[0]))))
        return self.__class__.__name__ + '(' + ','.join(res) + ')'
    def from_param(cls, obj):
        '''Magically construct from a tuple'''
        if isinstance(obj, cls):
            return obj
        if isinstance(obj, tuple):
            return cls(*obj)
        raise TypeError