Runtime binding

"""
I have the following situation: I have an 'iplimage' object that can't be accessed via index (like so: 'image[0][0]'). The only method I can use is image.tostring(), which returns the image data - in a string. And I want to be able to get a specific pixel from the image. So, let's see what my options are.


1. Create a function get_pixel(img, x, y)

This takes the image object as a first argument, and returns the pixel values at (x,y). What I don't like about this approach is that the function, which logicaly belongs to the 'iplimage' class, is defined outside.

The method would look something like:
"""

def get(im, x, y):
    row = map(ord, im.tostring())
    return [row[i::self.nChannels][self.width * x + y] for i in range(self.nChannels)]

"""
2. Make a class which inherits from 'iplimage'

Well, that's perfect. I'll define my class:
"""

class implimage_with_index(object):
    def get(self, x, y):
        row = map(ord, self.tostring)
        # ... etc

"""
The thing is, what do I do with 'iplimage' objects returned by other functions? Like cv.LoadImage("path/to/image.png")? One way would be to somehow modify the 'cv.LoadImage' class, at runtime, so it returns *my* type of object. This looked needlessly complicated, so I didn't go further.

3. Attach the "get()" method to the "img" object

It turns out, you can't do this in Python. Or rather, you can, by only to your own classes, and not for built-ins (and 'iplimage', as we'll see.) So this:
"""

class MyClass(object):
    pass

MyClass.get = lambda self, x,y: return # whatever..

my_obj = MyClass()
my_obj.get(0,0)

"""
works. But if I try to modify the 'iplimage' class this way, it throws an TypeException:

TypeError: can't set attributes of built-in/extension type 'cv2.cv.iplimage'

From what I know, this limitation is due to the CPython implementation. The last thing I though of (or rather found by googling) is:

4. Use types.MethodType to bind "get()" to the "iplimage" object

This approach exploits the way Python binds methods to objects behind the scene. So I can write:
"""

import types

def get(self, x, y):
    return self.whatever

img = cv.LoadImage("path/to/image.png")

# the signature of the method is: MethodType(function, instance, class)
# and it binds the function to the instance with type 'class'
get_bound = types.MethodType(get, img, cv.iplimage)

# so when I call:
print get_bound()
# it returns the 'whatever' property of 'img' (self works as expected)

"""
And this is where I run out of ideas. This last approach gives me no benefit, becase at the and I'm still calling get(x,y) outside of the object, with the difference of an implicit 'img' argument. It seems that there's no elegant way to dynamically add methods to random imported classes implemented in C. So I'll just use the first approach, def get(img, x, y).
"""