[Numpy-discussion] display numpy array as image

John Hunter jdh2358@gmail....
Mon Dec 3 12:48:11 CST 2007

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.


      '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)

        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)

    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
            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]
        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))


    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


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)
p = PolygonInteractor( ax, poly)

ax.set_title('Click and drag a point to move it')
-------------- next part --------------
A non-text attachment was scrubbed...
Name: poly_editor.py
Type: text/x-python
Size: 5091 bytes
Desc: not available
Url : http://projects.scipy.org/pipermail/numpy-discussion/attachments/20071203/d5333882/attachment.py 

More information about the Numpy-discussion mailing list