added editable poly example

svn path=/trunk/matplotlib/; revision=1128

Author: jdh2358

CHANGELOG

@@ -1,5 +1,7 @@
 New entries should be added at the top
 
+2005-04-01 Added editable polygon example
+
 ==========================================================================
 
 2005-03-31 0.74 released

TODO

@@ -694,3 +694,7 @@ ZeroDivisionError: SeparableTransformation::eval_scalars yin interval is zero; c
 -- add a get description to axes which returns the args and kwargs to construct it 
 
 -- restore __all__ to pylab and add ArtistInspector
+
+
+-- create set_window_title in the figure manager interface expose this
+   in the figure command

examples/poly_editor.py

@@ -0,0 +1,133 @@
+"""
+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.patches import Polygon
+from matplotlib.numerix import sqrt, nonzero, equal, asarray, dot, Float
+from matplotlib.numerix.mlab import amin
+from matplotlib.mlab import dist_point_to_segment
+
+
+
+        
+class EditablePolygon(Polygon):
+    """
+    An editable polygon.
+
+    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, *args, **kwargs):
+        Polygon.__init__(self, *args, **kwargs)        
+        self.line = Line2D([],[],marker='o', markerfacecolor='r')
+        self._ind = None # the active vert
+
+        self.xy = list(self.xy)  # make sure it is editable
+        
+    def set_figure(self, fig):
+        Polygon.set_figure(self, fig)
+        self.line.set_figure(fig)
+        self.figure.canvas.mpl_connect('button_press_event', self.button_press_callback)
+        self.figure.canvas.mpl_connect('key_press_event', self.key_press_callback)        
+        self.figure.canvas.mpl_connect('button_release_event', self.button_release_callback)
+        self.figure.canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)                
+        
+        
+    def set_transform(self, trans):
+        Polygon.set_transform(self, trans)
+        self.line.set_transform(trans)
+
+    def set_clip_on(self, b):
+        Polygon.set_clip_on(self, b)
+        self.line.set_clip_on(b)
+
+    def set_clip_box(self, b):
+        Polygon.set_clip_box(self, b)
+        self.line.set_clip_box(b)
+
+
+    def draw(self, renderer):
+        if not self._visible: return 
+        Polygon.draw(self, renderer)
+        if self.showverts:            
+            self.line.set_data(zip(*self.xy))
+            self.line.draw(renderer)
+
+    def get_ind_under_point(self, event):
+        x, y = zip(*self.xy)
+        # display coords        
+        xt, yt = self._transform.numerix_x_y(x, y)
+        d = sqrt((xt-event.x)**2 + (yt-event.y)**2)
+        indseq = nonzero(equal(d, amin(d)))
+        ind = indseq[0]
+        if d[ind]>=self.epsilon:
+            ind = None
+
+        return ind
+        
+    def button_press_callback(self, event):
+        if not self.showverts: return 
+        if event.inaxes==None: return
+        self._ind = self.get_ind_under_point(event)
+        
+
+    def button_release_callback(self, event):
+        if not self.showverts: return 
+        self._ind = None
+
+    def key_press_callback(self, event):
+        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.xy = [tup for i,tup in enumerate(self.xy) if i!=ind]
+        elif event.key=='i':            
+            xys = self._transform.seq_xy_tups(self.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.xy.insert(i+1, (event.xdata, event.ydata))
+                    break
+                
+                
+
+
+        self.figure.canvas.draw()
+
+    def motion_notify_callback(self, event):
+        if not self.showverts: return 
+        if self._ind is None: return
+        if event.inaxes is None: return
+        x,y = event.xdata, event.ydata
+        self.xy[self._ind] = x,y
+        self.figure.canvas.draw_idle()
+
+
+from pylab import *
+verts = Circle((.5,.5),.5).get_verts()
+p = EditablePolygon(verts)
+
+fig = figure()
+ax = subplot(111)
+ax.add_patch(p)
+title('Click and drag a point to move it')
+axis([0,1,0,1])
+show()

lib/matplotlib/backend_bases.py

@@ -748,6 +748,12 @@ def draw(self, *args, **kwargs):
         """
         pass
 
+    def draw_idle(self, *args, **kwargs):
+        """
+        draw only if idle; defaults to draw but backends can overrride
+        """
+        self.draw(self, *args, **kwargs)
+
     def draw_cursor(self, event):
         """
         Draw a cursor in the event.axes if inaxes is not None.  Use

lib/matplotlib/backends/backend_gtk.py

@@ -203,6 +203,14 @@ def draw(self):
         self._draw_pixmap = True
         self.expose_event(self, None)
 
+    def draw_idle(self):
+        def idle_draw(*args):
+            self.draw()
+            self._idleID = 0
+            return False
+        if self._idleID==0:
+            self._idleID = gtk.idle_add(idle_draw)
+
 
     def _renderer_init(self):
         """Override by GTK backends to select a different renderer
@@ -461,13 +469,9 @@ def release(self, event):
         except AttributeError: pass
 
     def dynamic_update(self):
-        def idle_draw(*args):
-            self.canvas.draw()
-            self._idleId = 0
-            return False
-        if self._idleId==0:
-            self._idleId = gtk.idle_add(idle_draw)
-        
+        # legacy method; new method is canvas.draw_idle
+        self.canvas.draw_idle()
+            
     def draw_rubberband(self, event, x0, y0, x1, y1):
         'adapted from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/189744'
         drawable = self.canvas.window

lib/matplotlib/backends/backend_tkagg.py

@@ -98,6 +98,7 @@ class FigureCanvasTkAgg(FigureCanvasAgg):
 
     def __init__(self, figure, master=None, resize_callback=None):
         FigureCanvasAgg.__init__(self, figure)
+        self._idle = True
         t1,t2,w,h = self.figure.bbox.get_bounds()
         w, h = int(w), int(h)
         self._tkcanvas = Tk.Canvas(
@@ -146,6 +147,16 @@ def draw(self):
 
     show = draw
 
+    def draw_idle(self):
+        'update drawing area only if idle'
+        d = self._idle
+        self._idle = False
+        def idle_draw(*args):
+            self.draw()
+            self._idle = True
+
+        if d: self._tkcanvas.after_idle(idle_draw)
+
     def get_tk_widget(self):
         """returns the Tk widget used to implement FigureCanvasTkAgg.
         Although the initial implementation uses a Tk canvas,  this routine
@@ -613,14 +624,9 @@ def update(self):
 
     def dynamic_update(self):
         'update drawing area only if idle'
-        d = self._idle
-        self._idle = False
-        def idle_draw(*args):
-            self.canvas.draw()
-            self._idle = True
+        # legacy method; new method is canvas.draw_idle
+        self.canvas.draw_idle()
 
-        if d: self.canvas._tkcanvas.after_idle(idle_draw)
-            
 
 FigureManager = FigureManagerTkAgg
 

lib/matplotlib/backends/backend_wx.py

@@ -691,7 +691,7 @@ def __init__(self, parent, id, figure):
         l,b,w,h = figure.bbox.get_bounds()
         w = int(math.ceil(w))
         h = int(math.ceil(h))
-        
+        self._idle = True        
         wxPanel.__init__(self, parent, id, size=wxSize(w, h))
         # Create the drawing bitmap
         self.bitmap = wxEmptyBitmap(w, h)
@@ -847,6 +847,13 @@ def draw(self):
         self.figure.draw(self.renderer)
         self.gui_repaint()
 
+    def draw_idle(self):
+        d = self._idle
+        self._idle = False
+        if d:
+            self.draw()
+            self._idle = True
+
     def _get_imagesave_wildcards(self):
         'return the wildcard string for the filesave dialog'
         return "JPEG (*.jpg)|*.jpg|" \
@@ -1500,11 +1507,7 @@ def release(self, event):
         except AttributeError: pass
 
     def dynamic_update(self):
-        d = self._idle
-        self._idle = False
-        if d:
-            self.canvas.draw()
-            self._idle = True
+        self.canvas.draw_idle()
 
     def draw_rubberband(self, event, x0, y0, x1, y1):
         'adapted from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/189744'

lib/matplotlib/mlab.py

@@ -1186,6 +1186,38 @@ def get_sparse_matrix(M,N,frac=0.1):
         data[x,y] = rand()
     return data
 
+def dist(x,y):
+    'return the distance between two points'
+    d = x-y
+    return numerix.mlab.sqrt(dot(d,d))
+
+def dist_point_to_segment(p, s0, s1):
+    """
+    get the distance of a point to a segment.
+
+    p, s0, s1 are xy sequences
+
+    This algorithm from
+    http://softsurfer.com/Archive/algorithm_0102/algorithm_0102.htm#Distance%20to%20Ray%20or%20Segment
+    """
+    p = asarray(p, Float)
+    s0 = asarray(s0, Float)
+    s1 = asarray(s1, Float)    
+    v = s1 - s0
+    w = p - s0
+
+    c1 = dot(w,v);
+    if ( c1 <= 0 ):
+        return dist(p, s0);
+
+    c2 = dot(v,v)
+    if ( c2 <= c1 ):
+        return dist(p, s1);
+
+    b = c1 / c2
+    pb = s0 + b * v;
+    return dist(p, pb)
+
 
 ### the following code was written and submitted by Fernando Perez
 ### from the ipython numutils package under a BSD license