Hi Zach

Attached is some code for removing radial distortion from images. It shows how to draw lines based on user input using matplotlib. It is not suited for a big application, but useful for demonstrations.

Try it on

http://mentat.za.net/results/window.jpg

Regards Stéfan

On Thu, Nov 29, 2007 at 11:59:05PM -0500, Zachary Pincus wrote:

Thanks for the suggestions, everyone! All very informative and most helpful.

For what it's worth, here's my application: I'm building a tool for image processing which needs some manual input in a few places (e.g. user draws a few lines). The images are greyscale images with 12-14 bits of dynamic range (from a microscope), so I need to have some basic brightness/contrast/gamma controls, as well as allowing basic drawing on the image to get the needed user input. It looks like GL or wx will be best suited here, I think? (I presume that python/numpy/ [GL|wx] can keep up with things like dragging a slider to change brightness/contrast/other LUT changes, as long as I code reasonably.)

Anyhow, thanks for all the input,

Zach

On Dec 3, 2007 12:00 PM, Zachary Pincus zpincus@stanford.edu wrote:

Thanks -- I hadn't realized matplotlib's user-interaction abilities were that sophisticated! I'll definitely give that route a shot.

Here is another example which will help you understand how to do interaction. You can drag the vertices of the polygon around, click 'd' to delete a vertex, 'i' to insert a new vertex. Because it uses mouse clicks, mouse drags and key presses, it introduces many of the common things you want to do when building in interaction. All of matplotlib's cross GUI panning, zooming, zoom-to-rect, etc are built using matplotlib's internal event model, so it is pretty stable and robust. Paul has recently done some nice work on the picking infrastructure, with support for hover highlighting and more. Maybe Paul you an post an example ?

The example below is also attached to avoid possible line breaks, etc...

""" This is an example to show how to build cross-GUI applications using matplotlib event handling to interact with objects on the canvas

""" from matplotlib.artist import Artist from matplotlib.patches import Polygon, CirclePolygon from numpy import sqrt, nonzero, equal, asarray, dot, amin from matplotlib.mlab import dist_point_to_segment

class PolygonInteractor: """ An polygon editor.

Key-bindings

't' toggle vertex markers on and off. When vertex markers are on, you can move them, delete them

'd' delete the vertex under point

'i' insert a vertex at point. You must be within epsilon of the line connecting two existing vertices

"""

showverts = True epsilon = 5 # max pixel distance to count as a vertex hit

def __init__(self, ax, poly): if poly.figure is None: raise RuntimeError('You must first add the polygon to a figure or canvas before defining the interactor') self.ax = ax canvas = poly.figure.canvas self.poly = poly

x, y = zip(*self.poly.xy) self.line = Line2D(x,y,marker='o', markerfacecolor='r', animated=True) #self._update_line(poly)

cid = self.poly.add_callback(self.poly_changed) self._ind = None # the active vert

canvas.mpl_connect('draw_event', self.draw_callback) canvas.mpl_connect('button_press_event', self.button_press_callback) canvas.mpl_connect('key_press_event', self.key_press_callback) canvas.mpl_connect('button_release_event', self.button_release_callback) canvas.mpl_connect('motion_notify_event', self.motion_notify_callback) self.canvas = canvas

def draw_callback(self, event): self.background = self.canvas.copy_from_bbox(self.ax.bbox) self.ax.draw_artist(self.poly) self.ax.draw_artist(self.line) self.canvas.blit(self.ax.bbox)

def poly_changed(self, poly): 'this method is called whenever the polygon object is called' # only copy the artist props to the line (except visibility) vis = self.line.get_visible() Artist.update_from(self.line, poly) self.line.set_visible(vis) # don't use the poly visibility state

def get_ind_under_point(self, event): 'get the index of the vertex under point if within epsilon tolerance' x, y = zip(*self.poly.xy)

# display coords xt, yt = self.poly.get_transform().numerix_x_y(x, y) d = sqrt((xt-event.x)**2 + (yt-event.y)**2) indseq = nonzero(equal(d, amin(d)))[0] ind = indseq[0]

if d[ind]>=self.epsilon: ind = None

return ind

def button_press_callback(self, event): 'whenever a mouse button is pressed' if not self.showverts: return if event.inaxes==None: return if event.button != 1: return self._ind = self.get_ind_under_point(event)

def button_release_callback(self, event): 'whenever a mouse button is released' if not self.showverts: return if event.button != 1: return self._ind = None

def key_press_callback(self, event): 'whenever a key is pressed' if not event.inaxes: return if event.key=='t': self.showverts = not self.showverts self.line.set_visible(self.showverts) if not self.showverts: self._ind = None elif event.key=='d': ind = self.get_ind_under_point(event) if ind is not None: self.poly.xy = [tup for i,tup in enumerate(self.poly.xy) if i!=ind] self.line.set_data(zip(*self.poly.xy)) elif event.key=='i': xys = self.poly.get_transform().seq_xy_tups(self.poly.xy) p = event.x, event.y # display coords for i in range(len(xys)-1): s0 = xys[i] s1 = xys[i+1] d = dist_point_to_segment(p, s0, s1) if d<=self.epsilon: self.poly.xy.insert(i+1, (event.xdata, event.ydata)) self.line.set_data(zip(*self.poly.xy)) break

self.canvas.draw()

def motion_notify_callback(self, event): 'on mouse movement' if not self.showverts: return if self._ind is None: return if event.inaxes is None: return if event.button != 1: return x,y = event.xdata, event.ydata

self.poly.xy[self._ind] = x,y self.line.set_data(zip(*self.poly.xy))

self.canvas.restore_region(self.background) self.ax.draw_artist(self.poly) self.ax.draw_artist(self.line) self.canvas.blit(self.ax.bbox)

from pylab import *

fig = figure() theta = arange(0, 2*pi, 0.1) r = 1.5

xs = r*npy.cos(theta) ys = r*npy.sin(theta)

poly = Polygon(zip(xs, ys,), animated=True)

ax = subplot(111) ax.add_patch(poly) p = PolygonInteractor( ax, poly)

ax.add_line(p.line) ax.set_title('Click and drag a point to move it') ax.set_xlim((-2,2)) ax.set_ylim((-2,2)) show()