set_xlim, set_ylim: turn off autoscaling; added autoscale method

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

Author: efiring

boilerplate.py

@@ -109,6 +109,7 @@ def %(func)s(%(argspec)s):
     'locator_params',
     'tick_params',
     'margins',
+    'autoscale',
     )
 
 cmappable = {

lib/matplotlib/axes.py

@@ -1715,6 +1715,45 @@ def get_rasterization_zorder(self):
         """
         return self._rasterization_zorder
 
+    def autoscale(self, enable=True, axis='both', tight=None):
+        """
+        Convenience method for simple axis view autoscaling.
+        It turns autoscaling on or off, and then,
+        if autoscaling for either axis is on, it performs
+        the autoscaling on the specified axis or axes.
+
+        *enable*: [True | False | None]
+            True (default) turns autoscaling on, False turns it off.
+            None leaves the autoscaling state unchanged.
+
+        *axis*: ['x' | 'y' | 'both']
+            which axis to operate on; default is 'both'
+
+        *tight*: [True | False | None]
+            If True, set view limits to data limits;
+            if False, let the locator and margins expand the view limits;
+            if None, use tight scaling if the only artist is an image,
+            otherwise treat *tight* as False.
+            The *tight* setting is retained for future autoscaling
+            until it is explicitly changed.
+
+
+        Returns None.
+        """
+        if enable is None:
+            scalex = True
+            scaley = True
+        else:
+            scalex = False
+            scaley = False
+            if axis in ['x', 'both']:
+                self._autoscaleXon = bool(enable)
+                scalex = self._autoscaleXon
+            if axis in ['y', 'both']:
+                self._autoscaleYon = bool(enable)
+                scaley = self._autoscaleYon
+        self.autoscale_view(tight=tight, scalex=scalex, scaley=scaley)
+
 
     def autoscale_view(self, tight=None, scalex=True, scaley=True):
         """
@@ -2209,7 +2248,7 @@ def set_axis_bgcolor(self, color):
     def invert_xaxis(self):
         "Invert the x-axis."
         left, right = self.get_xlim()
-        self.set_xlim(right, left)
+        self.viewLim.intervalx = (right, left)
 
     def xaxis_inverted(self):
         'Returns True if the x-axis is inverted.'
@@ -2233,6 +2272,7 @@ def set_xbound(self, lower=None, upper=None):
         """
         Set the lower and upper numerical bounds of the x-axis.
         This method will honor axes inversion regardless of parameter order.
+        It will not change the _autoscaleXon attribute.
         """
         if upper is None and iterable(lower):
             lower,upper = lower
@@ -2244,46 +2284,59 @@ def set_xbound(self, lower=None, upper=None):
 
         if self.xaxis_inverted():
             if lower < upper:
-                self.set_xlim(upper, lower)
+                self.set_xlim(upper, lower, auto=None)
             else:
-                self.set_xlim(lower, upper)
+                self.set_xlim(lower, upper, auto=None)
         else:
             if lower < upper:
-                self.set_xlim(lower, upper)
+                self.set_xlim(lower, upper, auto=None)
             else:
-                self.set_xlim(upper, lower)
+                self.set_xlim(upper, lower, auto=None)
 
     def get_xlim(self):
         """
         Get the x-axis range [*xmin*, *xmax*]
         """
         return tuple(self.viewLim.intervalx)
 
-    def set_xlim(self, xmin=None, xmax=None, emit=True, **kwargs):
+    def set_xlim(self, xmin=None, xmax=None, emit=True, auto=False):
         """
         call signature::
 
-          set_xlim(self, *args, **kwargs)
-
-        Set the limits for the xaxis
+          set_xlim(self, *args, **kwargs):
 
-        Returns the current xlimits as a length 2 tuple: [*xmin*, *xmax*]
+        Set the data limits for the xaxis
 
         Examples::
 
-          set_xlim((valmin, valmax))
-          set_xlim(valmin, valmax)
-          set_xlim(xmin=1) # xmax unchanged
-          set_xlim(xmax=1) # xmin unchanged
+          set_xlim((left, right))
+          set_xlim(left, right)
+          set_xlim(xmin=1) # right unchanged
+          set_xlim(xmax=1) # left unchanged
 
         Keyword arguments:
 
           *xmin*: scalar
-            the min of the ylim
+            the left xlim
           *xmax*: scalar
-            the max of the ylim
+            the right xlim
           *emit*: [ True | False ]
             notify observers of lim change
+          *auto*: [ True | False | None ]
+            turn *x* autoscaling on (True), off (False; default),
+            or leave unchanged (None)
+
+        Note: the kwarg terminology may be confusing.  The first value,
+        *xmin*, is the left, and the second, *xmax*, is the right.
+        For example, suppose *x* is years before present.
+        Then one might use::
+
+          set_ylim(5000, 0)
+
+        so 5000 years ago is on the left of the plot and the
+        present is on the right.
+
+        Returns the current xlimits as a length 2 tuple
 
         ACCEPTS: len(2) sequence of floats
         """
@@ -2307,6 +2360,8 @@ def set_xlim(self, xmin=None, xmax=None, emit=True, **kwargs):
         xmin, xmax = self.xaxis.limit_range_for_scale(xmin, xmax)
 
         self.viewLim.intervalx = (xmin, xmax)
+        if auto is not None:
+            self._autoscaleXon = bool(auto)
 
         if emit:
             self.callbacks.process('xlim_changed', self)
@@ -2391,25 +2446,26 @@ def set_xticklabels(self, labels, fontdict=None, minor=False, **kwargs):
 
     def invert_yaxis(self):
         "Invert the y-axis."
-        left, right = self.get_ylim()
-        self.set_ylim(right, left)
+        bottom, top = self.get_ylim()
+        self.viewLim.intervaly = (top, bottom)
 
     def yaxis_inverted(self):
         'Returns True if the y-axis is inverted.'
-        left, right = self.get_ylim()
-        return right < left
+        bottom, top = self.get_ylim()
+        return top < bottom
 
     def get_ybound(self):
         "Return y-axis numerical bounds in the form of lowerBound < upperBound"
-        left, right = self.get_ylim()
-        if left < right:
-            return left, right
+        bottom, top = self.get_ylim()
+        if bottom < top:
+            return bottom, top
         else:
-            return right, left
+            return top, bottom
 
     def set_ybound(self, lower=None, upper=None):
         """Set the lower and upper numerical bounds of the y-axis.
            This method will honor axes inversion regardless of parameter order.
+           It will not change the _autoscaleYon attribute.
         """
         if upper is None and iterable(lower):
             lower,upper = lower
@@ -2421,42 +2477,57 @@ def set_ybound(self, lower=None, upper=None):
 
         if self.yaxis_inverted():
             if lower < upper:
-                self.set_ylim(upper, lower)
+                self.set_ylim(upper, lower, auto=None)
             else:
-                self.set_ylim(lower, upper)
+                self.set_ylim(lower, upper, auto=None)
         else:
             if lower < upper:
-                self.set_ylim(lower, upper)
+                self.set_ylim(lower, upper, auto=None)
             else:
-                self.set_ylim(upper, lower)
+                self.set_ylim(upper, lower, auto=None)
 
     def get_ylim(self):
         """
         Get the y-axis range [*ymin*, *ymax*]
         """
         return tuple(self.viewLim.intervaly)
 
-    def set_ylim(self, ymin=None, ymax=None, emit=True, **kwargs):
+    def set_ylim(self, ymin=None, ymax=None, emit=True, auto=False):
         """
         call signature::
 
           set_ylim(self, *args, **kwargs):
 
-        Set the limits for the yaxis; v = [ymin, ymax]::
+        Set the data limits for the yaxis
+
+        Examples::
 
-          set_ylim((valmin, valmax))
-          set_ylim(valmin, valmax)
-          set_ylim(ymin=1) # ymax unchanged
-          set_ylim(ymax=1) # ymin unchanged
+          set_ylim((bottom, top))
+          set_ylim(bottom, top)
+          set_ylim(ymin=1) # top unchanged
+          set_ylim(ymax=1) # bottom unchanged
 
         Keyword arguments:
 
           *ymin*: scalar
-            the min of the ylim
+            the bottom ylim
           *ymax*: scalar
-            the max of the ylim
+            the top ylim
           *emit*: [ True | False ]
             notify observers of lim change
+          *auto*: [ True | False | None ]
+            turn *y* autoscaling on (True), off (False; default),
+            or leave unchanged (None)
+
+        Note: the kwarg terminology may be confusing.  The first value,
+        *ymin*, is the bottom, and the second, *ymax*, is the top.
+        For example, suppose *y* is depth in the ocean.
+        Then one might use::
+
+          set_ylim(5000, 0)
+
+        so 5000 m depth is at the bottom of the plot and the
+        surface, 0 m, is at the top.
 
         Returns the current ylimits as a length 2 tuple
 
@@ -2480,7 +2551,10 @@ def set_ylim(self, ymin=None, ymax=None, emit=True, **kwargs):
 
         ymin, ymax = mtransforms.nonsingular(ymin, ymax, increasing=False)
         ymin, ymax = self.yaxis.limit_range_for_scale(ymin, ymax)
+
         self.viewLim.intervaly = (ymin, ymax)
+        if auto is not None:
+            self._autoscaleYon = bool(auto)
 
         if emit:
             self.callbacks.process('ylim_changed', self)
@@ -6647,14 +6721,10 @@ def imshow(self, X, cmap=None, norm=None, aspect=None,
             im.autoscale_None()
         im.set_url(url)
 
-        xmin, xmax, ymin, ymax = im.get_extent()
+        # update ax.dataLim, and, if autoscaling, set viewLim
+        # to tightly fit the image, regardless of dataLim.
+        im.set_extent(im.get_extent())
 
-        corners = (xmin, ymin), (xmax, ymax)
-        self.update_datalim(corners)
-        if self._autoscaleXon:
-            self.set_xlim((xmin, xmax))
-        if self._autoscaleYon:
-            self.set_ylim((ymin, ymax))
         self.images.append(im)
         im._remove_method = lambda h: self.images.remove(h)
 

lib/matplotlib/blocking_input.py

@@ -19,6 +19,7 @@
 
 from matplotlib import path, verbose
 from matplotlib.cbook import is_sequence_of_strings
+import matplotlib.lines as mlines
 
 class BlockingInput(object):
     """
@@ -222,18 +223,10 @@ def add_click(self,event):
 
         # If desired plot up click
         if self.show_clicks:
-
-            # make sure we don't mess with the axes zoom
-            xlim = event.inaxes.get_xlim()
-            ylim = event.inaxes.get_ylim()
-
-            # plot the clicks
-            self.marks.extend(
-                event.inaxes.plot([event.xdata,], [event.ydata,], 'r+') )
-
-            # before we draw, make sure to reset the limits
-            event.inaxes.set_xlim(xlim)
-            event.inaxes.set_ylim(ylim)
+            line = mlines.Line2D([event.xdata], [event.ydata],
+                                 marker='+', color='r')
+            event.inaxes.add_line(line)
+            self.marks.append(line)
             self.fig.canvas.draw()
 
 
@@ -247,16 +240,9 @@ def pop_click(self,event,index=-1):
 
         if self.show_clicks:
 
-            # make sure we don't mess with the axes zoom
-            xlim = event.inaxes.get_xlim()
-            ylim = event.inaxes.get_ylim()
-
             mark = self.marks.pop(index)
             mark.remove()
 
-            # before we draw, make sure to reset the limits
-            event.inaxes.set_xlim(xlim)
-            event.inaxes.set_ylim(ylim)
             self.fig.canvas.draw()
             # NOTE: I do NOT understand why the above 3 lines does not work
             # for the keyboard backspace event on windows XP wxAgg.
@@ -275,20 +261,11 @@ def pop(self,event,index=-1):
     def cleanup(self,event=None):
         # clean the figure
         if self.show_clicks:
-            if event:
-                # make sure we don't mess with the axes zoom
-                xlim = event.inaxes.get_xlim()
-                ylim = event.inaxes.get_ylim()
 
             for mark in self.marks:
                 mark.remove()
             self.marks = []
 
-            if event:
-                # before we draw, make sure to reset the limits
-                event.inaxes.set_xlim(xlim)
-                event.inaxes.set_ylim(ylim)
-
             self.fig.canvas.draw()
 
         # Call base class to remove callbacks

lib/matplotlib/image.py

@@ -605,16 +605,22 @@ def _check_unsampled_image(self, renderer):
     def set_extent(self, extent):
         """
         extent is data axes (left, right, bottom, top) for making image plots
+
+        This updates ax.dataLim, and, if autoscaling, sets viewLim
+        to tightly fit the image, regardless of dataLim.  Autoscaling
+        state is not changed, so following this with ax.autoscale_view
+        will redo the autoscaling in accord with dataLim.
+
         """
         self._extent = extent
 
         xmin, xmax, ymin, ymax = extent
         corners = (xmin, ymin), (xmax, ymax)
         self.axes.update_datalim(corners)
         if self.axes._autoscaleXon:
-            self.axes.set_xlim((xmin, xmax))
+            self.axes.set_xlim((xmin, xmax), auto=None)
         if self.axes._autoscaleYon:
-            self.axes.set_ylim((ymin, ymax))
+            self.axes.set_ylim((ymin, ymax), auto=None)
 
     def get_extent(self):
         'get the image extent: left, right, bottom, top'