added Martin's rectangle selector widget

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

Author: jdh2358

CHANGELOG

@@ -1,5 +1,8 @@
 New entries should be added at the top
 
+2005-09-06 Added Martin's rectangle selector widget
+2005-09-04 Fixed a logic err in text.py that was preventing rgxsuper
+           from matching - JDH
 
 2005-08-29 Committed Ken's wx blit patch #1275002
 

examples/widgets/rectangle_selector.py

@@ -0,0 +1,33 @@
+"""
+Do a mouseclick somewhere, move the mouse to some destination, release
+the button.  This class gives click- and release-events and also draws
+a line or a box from the click-point to the actual mouseposition
+(within the same axes) until the button is released.  Within the
+method 'self.ignore()' it is checked wether the button from eventpress
+and eventrelease are the same.
+
+"""
+from matplotlib.widgets import RectangleSelector
+from pylab import subplot, arange, plot, sin, cos, pi, show
+def line_select_callback(event1, event2):
+    'event1 and event2 are the press and release events'
+    x1, y1 = event1.xdata, event1.ydata
+    x2, y2 = event2.xdata, event2.ydata
+    print "(%3.2f, %3.2f) --> (%3.2f, %3.2f)"%(x1,y1,x2,y2)
+    print " The button you used were: ",event1.button, event2.button
+
+
+current_ax=subplot(111)                    # make a new plotingrange
+N=100000                                   # If N is large one can see improvement
+x=10.0*arange(N)/(N-1)                     # by use blitting! 
+
+plot(x,sin(.2*pi*x),lw=3,c='b',alpha=.7)   # plot something
+plot(x,cos(.2*pi*x),lw=3.5,c='r',alpha=.5)
+plot(x,-sin(.2*pi*x),lw=3.5,c='g',alpha=.3)    
+
+print "\n      click  -->  release"
+
+# drawtype is 'box' or 'line' or 'none'
+LS = RectangleSelector(current_ax, line_select_callback,
+                      drawtype='box',useblit=True)
+show()

lib/matplotlib/axes.py

@@ -1,3 +1,4 @@
+'jdh'
 from __future__ import division, generators
 
 import math, sys

lib/matplotlib/text.py

@@ -297,9 +297,9 @@ def draw(self, renderer):
         ismath = self.is_math_text()
 
         if angle==0:
-            if ismath!='TeX': m = None
+            if ismath=='TeX': m = None
             else: m = self._rgxsuper.match(self._text)
-            if m is not None and not rcParams['text.usetex']:
+            if m is not None:
                 bbox, info = self._get_layout_super(self._renderer, m)
                 base, xt, yt = info[0]
                 renderer.draw_text(gc, xt, yt, base,

lib/matplotlib/widgets.py

@@ -795,3 +795,191 @@ def onmove(self, event):
         self.rect.set_width(maxx-minx)            
         self.update()
         return False
+
+
+class RectangleSelector:
+    """
+    Select a min/max range of the x axes for a matplotlib Axes
+
+    Example usage:
+
+      ax = subplot(111)
+      ax.plot(x,y)
+
+      def onselect(eclick, erelease):
+          'eclick and erelease are matplotlib events at press and release'
+          print 'startposition : (%f,%f)'%(eclick.xdata, eclick.ydata)
+          print 'endposition   : (%f,%f)'%(erelease.xdata, erelease.ydata)
+          print 'used button   : ', eclick.button
+
+      span = Selector(ax, onselect,drawtype='box')
+      show()
+
+    """
+    def __init__(self, ax, onselect, drawtype='box', 
+                 minspanx=None, minspany=None, useblit=False,
+                 lineprops=None, rectprops=None):
+
+        """
+        Create a selector in ax.  When a selection is made, clear
+        the span and call onselect with
+
+          onselect(pos_1, pos_2)
+
+        and clear the drawn box/line. There pos_i are arrays of length 2
+        containing the x- and y-coordinate.
+
+        If minspanx is not None then events smaller than minspanx
+        in x direction are ignored(it's the same for y).
+
+        The rect is drawn with rectprops; default
+          rectprops = dict(facecolor='red', edgecolor = 'black',
+                           alpha=0.5, fill=False)
+
+        The line is drawn with lineprops; default
+          lineprops = dict(color='black', linestyle='-',
+                           linewidth = 2, alpha=0.5)
+
+        Use type if you want the mouse to draw a line, a box or nothing
+        between click and actual position ny setting
+        drawtype = 'line', drawtype='box' or drawtype = 'none'.
+
+
+        """
+        self.ax = ax
+        self.visible = True
+        self.canvas = ax.figure.canvas
+        self.canvas.mpl_connect('motion_notify_event', self.onmove)
+        self.canvas.mpl_connect('button_press_event', self.press)
+        self.canvas.mpl_connect('button_release_event', self.release)
+        self.canvas.mpl_connect('draw_event', self.update_background)
+
+        self.to_draw = None
+        self.background = None
+
+        if drawtype == 'none':
+            drawtype = 'line'                        # draw a line but make it 
+            self.visible = False                     # invisible
+
+        if drawtype == 'box':
+            if rectprops is None:
+                rectprops = dict(facecolor='white', edgecolor = 'black',
+                                 alpha=0.5, fill=False)
+            self.rectprops = rectprops
+            self.to_draw = Rectangle((0,0), 0, 1,visible=False,**self.rectprops)
+            self.ax.add_patch(self.to_draw)
+        if drawtype == 'line':
+            if lineprops is None:
+                lineprops = dict(color='black', linestyle='-',
+                                 linewidth = 2, alpha=0.5)
+            self.lineprops = lineprops
+            self.to_draw = Line2D([0,0],[0,0],visible=False,**self.lineprops)
+            self.ax.add_line(self.to_draw)
+
+        self.onselect = onselect
+        self.useblit = useblit
+        self.minspanx = minspanx
+        self.minspany = minspany
+        self.drawtype = drawtype
+        # will save the data (position at mouseclick)
+        self.eventpress = None            
+        # will save the data (pos. at mouserelease)
+        self.eventrelease = None          
+
+    def update_background(self, event):
+        'force an update of the background'
+        if self.useblit:
+            self.background = self.canvas.copy_from_bbox(self.ax.bbox)
+
+        
+    def ignore(self, event):
+        'return True if event should be ignored'
+        # If no button was pressed yet ignore the event if it was out
+        # of the axes
+        if self.eventpress == None:
+            return event.inaxes!= self.ax       
+
+        # If a button was pressed, check if the release-button is the
+        # same.
+        return  (event.inaxes!=self.ax or
+                 event.button != self.eventpress.button)
+      
+    def press(self, event):
+        'on button press event'
+        # Is the correct button pressed within the correct axes?
+        if self.ignore(event): return         
+
+
+        # make the drawed box/line visible get the click-coordinates,
+        # button, ...
+        self.to_draw.set_visible(self.visible)
+        self.eventpress = event               
+        return False
+
+
+    def release(self, event):
+        'on button release event'
+        if self.eventpress is None or self.ignore(event): return
+        # make the box/line invisible again
+        self.to_draw.set_visible(False)       
+        self.canvas.draw()
+        # release coordinates, button, ...
+        self.eventrelease = event             
+        xmin, ymin = self.eventpress.xdata, self.eventpress.ydata
+        xmax, ymax = self.eventrelease.xdata, self.eventrelease.ydata
+        # calculate dimensions of box or line get values in the right
+        # order
+        if xmin>xmax: xmin, xmax = xmax, xmin        
+        if ymin>ymax: ymin, ymax = ymax, ymin
+
+
+
+        spanx = xmax - xmin                  
+        spany = ymax - ymin
+        xproblems = self.minspanx is not None and spanx<self.minspanx
+        yproblems = self.minspany is not None and spany<self.minspany
+        if (self.drawtype=='box')  and (xproblems or  yproblems):
+            """Box to small"""     # check if drawed distance (if it exists) is
+            return                 # not to small in neither x nor y-direction
+        if (self.drawtype=='line') and (xproblems and yproblems):
+            """Line to small"""    # check if drawed distance (if it exists) is
+            return                 # not to small in neither x nor y-direction
+        self.onselect(self.eventpress, self.eventrelease)
+                                              # call desired function
+        self.eventpress = None                # reset the variables to their
+        self.eventrelease = None              #   inital values
+        return False
+
+    def update(self):
+        'draw using newfangled blit or oldfangled draw depending on useblit'
+        if self.useblit:
+            if self.background is not None:
+                self.canvas.restore_region(self.background)
+            self.ax.draw_artist(self.to_draw)
+            self.canvas.blit(self.ax.bbox)
+        else:
+            self.canvas.draw_idle()
+        return False
+
+
+    def onmove(self, event):
+        'on motion notify event if box/line is wanted'
+        if self.eventpress is None or self.ignore(event): return
+        x,y = event.xdata, event.ydata            # actual position (with
+                                                  #   (button still pressed)
+        if self.drawtype == 'box':
+            minx, maxx = self.eventpress.xdata, x # click-x and actual mouse-x
+            miny, maxy = self.eventpress.ydata, y # click-y and actual mouse-y
+            if minx>maxx: minx, maxx = maxx, minx # get them in the right order
+            if miny>maxy: miny, maxy = maxy, miny
+            self.to_draw.xy[0] = minx             # set lower left of box
+            self.to_draw.xy[1] = miny
+            self.to_draw.set_width(maxx-minx)     # set width and height of box
+            self.to_draw.set_height(maxy-miny)
+            self.update()
+            return False
+        if self.drawtype == 'line':
+            self.to_draw.set_data([self.eventpress.xdata, x],
+                                  [self.eventpress.ydata, y])
+            self.update()
+            return False

matplotlibrc

@@ -104,7 +104,10 @@ font.style          : normal
 font.variant        : normal
 font.weight         : medium
 font.stretch        : normal
-font.size           : medium
+# note that font.size controls default text sizes.  To configure
+# special text sizes tick labels, axes, labels, title, etc, see the rc
+# settings for axes and ticks
+font.size           : medium  
 font.serif          : New Century Schoolbook, Century Schoolbook L, Utopia, ITC Bookman, Bookman, Bitstream Vera Serif, Nimbus Roman No9 L, Times New Roman, Times, Palatino, Charter, serif
 font.sans-serif     : Lucida Grande, Verdana, Geneva, Lucida, Bitstream Vera Sans, Arial, Helvetica, sans-serif
 font.cursive        : Apple Chancery, Textile, Zapf Chancery, Sand, cursive