Ticket #6893: plot.patch

sage/plot/axes.py

@@ -24 +24 @@
 #
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
-from math import floor, log
-from sage.structure.sage_object import SageObject
-import sage.misc.misc
-from copy import copy
-
-class Axes(SageObject):
-    """
-    Axes for SAGE 2D Graphics.
-
-    Set all axis properties and then add one of 
-    the following axes to the current (matplotlib) subplot:
-    add_xy__axes
-    add_xy_frame_axes
-    add_xy_matrix_frame_axes
-
-    """
-    def __init__(self, color=(0,0,0), fontsize=8, linewidth=0.6,axes_labels=None, 
-                 axes_label_color=(0,0,0), tick_label_color=(0,0,0)):
-        self.__color = color
-        self.__tick_label_color = tick_label_color
-        self.__axes_labels = axes_labels
-        self.__axes_label_color = axes_label_color
-        self.__fontsize = fontsize
-        self.__linewidth = linewidth
-        self.__draw_x_axis = True
-        self.__draw_y_axis = True
-        
-    def _tasteful_ticks(self, minval, maxval):
-        """
-        This function finds spacing for axes tick marks that are well spaced.
-        Were 'well spaced' means for any given min and max values
-        the tick spacing should look even and visually nice (tasteful).
-        
-        """
-        minval, maxval = float(minval), float(maxval)
-        absmin, absmax = abs(minval), abs(maxval)
-        # Initialize the domain flags:
-        onlyneg, domneg, onlypos, dompos = False, False, False, False
-
-        # Is the range: *only or dominantly* and  *negative or positive*?
-        if absmin > absmax:
-            if maxval < 0:
-                onlyneg = True
-            else:
-                domneg  = True
-
-            # Is the stepsize going to be < 1?
-            if absmin < 1:
-                n = 0
-                s = str(absmin).split('.')[1]
-                for c in s:
-                    n+=1
-                    if c != '0':
-                        break
-                p = -(n-1)
-                d0 = eval(s[n-1])
-                #string may be of length 1
-                try:
-                    d1 = eval(s[n])
-                except IndexError:
-                    d1 = 0
-
-            #the stepsize will be 1 or greater:
-            else:
-                if absmin >= 10:
-                    sl = [s for s in str(int(absmin))]
-                    d0 = eval(sl[0])
-                    d1 = eval(sl[1])
-                    p = len(sl)
-                else:
-                    sl = str(absmin).split('.')
-                    d0 = eval(sl[0])
-                    d1 = eval(sl[1][0])
-                    p = 1
-
-        else: #this means: abs(minval) < abs(maxval)
-            if minval > 0:
-                 onlypos = True
-            else:
-                 dompos = True
-            #is the stepsize going to be < 1?
-            if absmax < 1:
-                n = 0
-                s = str(absmax).split('.')[1]
-                for c in s:
-                    n+=1
-                    if c != '0':
-                        break
-                p = -(n-1)
-                d0 = eval(s[n-1])
-                try:
-                    sn = s[n]
-                except IndexError:
-                    sn = "0"
-                d1 = eval(sn)
-            #the stepsize will be 1 or greater:
-            else:
-                if maxval >= 10:
-                    sl = [s for s in str(int(absmax))]
-                    d0 = eval(sl[0])
-                    d1 = eval(sl[1])
-                    p = len(sl)
-                else:
-                    sl = str(absmax).split('.')
-                    d0 = eval(sl[0])
-                    d1 = eval(sl[1][0])
-                    p = 1
-        
-        #choose a step size depending on either
-        #1st or 2nd digits, d0 and d1, of given maxval or minval
-        o0 = 10**(p-1)
-        o1 = 10**(p-2)
-        #fundamental step sizes: [1,2,2.5,5,10]
-        # 'fundamental' means that we split the x and y
-        # ranges into widths from the above step sizes
-        if d0 == 1:
-            if d1 > 5 and p!=1:
-                funda = 2.5
-                step = funda*o1
-            elif d1 < 5 and p==1:
-                funda = 2.5
-                step = funda*o1
-            elif d1 < 5 and p>1:
-                funda = 2.5
-                step = funda*o1
-            else:
-                funda = 5
-                step = funda*o1
-        elif d0 == 2 or (d0 == 3 and p > 1):
-            funda = 5
-            step = funda*o1
-        elif d0 in [3, 4, 5, 6]:
-            funda = 1
-            step = funda*o0
-        else:
-            funda = 2
-            step = funda*o0
-
-        #the 'fundamental' range
-        fundrange = sage.misc.misc.srange(0, d0*o0 + d1*o1 + step, step)
-        
-        #Now find the tick step list for major ticks (tslmajor)
-        #'oppaxis' is the positioning value of the other axis.
-        if onlyneg:
-            tslmajor = self._in_range([-x for x in fundrange], minval, maxval)
-            tslmajor.sort()
-            oppaxis = tslmajor[-1]
-
-        elif domneg or dompos:
-            tslmajor = self._in_range([-x for x in fundrange] + fundrange, minval, maxval)
-            tslmajor.sort()
-            oppaxis = 0
-
-        else: #onlypos
-            tslmajor = self._in_range(fundrange, minval, maxval)
-            tslmajor.sort()
-            oppaxis = tslmajor[0]
-        
-        return tslmajor, oppaxis, step
-
-    def _in_range(self, v, minval, maxval):
-        "find axis values set in a given range"
-        return list(set([x for x in v if x >= minval and x <= maxval]))
-
-    def _trunc(self, x, digits_before_the_decimal):
-        s = '%f'%float(x)
-        i = s.find('.')
-        t = s[:i - digits_before_the_decimal]
-        if digits_before_the_decimal > 0:
-            t += '0'* digits_before_the_decimal
-        return float(eval(t))
-        
-    def _format_tick_string(self, s):
-        s = str(s)
-        if s[-2:] == '.0':
-            return s[:-2]
-        return s
-
-    def _tasteless_ticks(self, minval, maxval, num_pieces):
-        minval0 = minval
-        maxval0 = maxval
-        rnd   = int(floor(log(maxval - minval)/log(10)))
-        if rnd < 0:
-            rnd -= 1
-
-        step  = (maxval - minval)/float(num_pieces)
-        minval = self._trunc(minval, rnd)
-        maxval = self._trunc(maxval + step, rnd)
-
-        step  = (maxval - minval)/float(num_pieces)
-        tslmajor = sage.misc.misc.srange(minval, minval+(num_pieces+1)*step, step)
-        tslmajor = self._in_range(tslmajor, minval0, maxval0)
-
-        oppaxis = 0
-        if maxval <= 0:  # only negative
-            oppaxis = tslmajor[-1]
-        elif minval >= 0:
-            oppaxis = tslmajor[0]
-            
-        return tslmajor, oppaxis, step
-
-    def _find_axes(self, minval, maxval):
-        """
-        Try to find axis tick positions that are well spaced
-        """
-        if minval >= maxval:
-            raise ValueError, "maxval >= minval is required"
-
-        # If there is a small differences between max and min values 
-        # compared to the size of the largest of (abs(maxval), abs(minval))
-        # the function 'tasteless_ticks' is used, which in common usage is rare.
-        if (abs((maxval - minval)/float(max(abs(maxval),abs(minval)))) < 0.2):
-            tslmajor, oppaxis, step = self._tasteless_ticks(minval, maxval, 10)
-        else:
-            tslmajor, oppaxis, step = self._tasteful_ticks(minval, maxval)
-        min = tslmajor[0] - step
-        tslminor = sage.misc.misc.srange(min, maxval + 0.2*step, 0.2*step)
-        tslminor = self._in_range(tslminor, minval, maxval)
-        return oppaxis, step, tslminor, tslmajor 
-
-    def _draw_axes(self, subplot, axes, xmin, xmax, ymin, ymax, x_axis_ypos, y_axis_xpos):
-        from matplotlib import lines
-        if isinstance(axes, (list, tuple)) and len(axes) == 2 and \
-        (axes[0] in [True, False]) and (axes[1] in [True, False]): 
-            self.__draw_x_axis = axes[0]
-            self.__draw_y_axis = axes[1]
-            #draw the x-axes?
-            if self.__draw_x_axis:
-                subplot.add_line(lines.Line2D([xmin, xmax], [x_axis_ypos, x_axis_ypos],
-                                 color=self.__color, linewidth=float(self.__linewidth)))
-            #draw y axis line?
-            if self.__draw_y_axis:
-                subplot.add_line(lines.Line2D([y_axis_xpos, y_axis_xpos],[ymin, ymax],
-                                  color=self.__color, linewidth=float(self.__linewidth)))
-        else: #draw them both
-            subplot.add_line(lines.Line2D([xmin, xmax], [x_axis_ypos, x_axis_ypos],
-                             color=self.__color, linewidth=float(self.__linewidth)))
-            subplot.add_line(lines.Line2D([y_axis_xpos, y_axis_xpos],[ymin, ymax],
-                              color=self.__color, linewidth=float(self.__linewidth)))
-
-    def _draw_axes_labels(self, subplot, axes_labels, xmin, xmax, ymin, ymax, xstep, ystep, x_axis_ypos, y_axis_xpos, pad=0.2):
-        al = axes_labels
-        if not isinstance(al, (list,tuple)) or len(al) != 2:
-            raise TypeError, "axes_labels must be a list of two strings."
-        #draw x-axis label if there is a x-axis: 
-        fontsize = int(self.__fontsize)
-        if self.__draw_x_axis:
-            s = str(al[0])
-            subplot.text(xmax + pad*xstep, x_axis_ypos, s,
-                         fontsize = fontsize,
-                         color = self.__axes_label_color, horizontalalignment="left",
-                         verticalalignment="center", family="monospace")
-            xmax += 0.0025*(xmax-xmin)*len(s) * fontsize
-            
-        #draw y-axis label if there is a y-axis
-        if self.__draw_y_axis:
-            subplot.text(y_axis_xpos, ymax + 2*pad*ystep, str(al[1]),
-                         fontsize = fontsize,
-                         color = self.__axes_label_color,
-                         horizontalalignment="left", verticalalignment="center", family="monospace")
-            ymax += 0.075*(ymax-ymin)
-        return xmin, xmax, ymin, ymax
-            
-
-    def add_xy_axes(self, subplot, xmin, xmax, ymin, ymax, axes=True, 
-                    ticks="automatic", axesstyle="automatic", axes_labels=None):
-        r"""
-        \code{_add_xy_axes} is used when the 'save' method
-        of any Graphics object is called.
-
-        Additionally this function uses the function '_find_axes' 
-        from axis.py which attempts to find aesthetically pleasing
-        tick and label spacing values.
-
-        Some definitons of the parameters:
-
-        y_axis_xpos : "where on the x-axis to draw the y-axis"
-        xstep : "the spacing between major tick marks"
-        xtslminor : "x-axis minor tick step list" 
-        xtslmajor : "x-axis major tick step list" 
-        yltheight : "where the top of the major ticks go" 
-        ystheight : "where the top of the minor ticks go" 
-        ylabel : "where the ylabel is drawn" 
-        xlabel : "where the xlabel is drawn" 
-
-        """
-        from matplotlib import lines
-        xmin = float(xmin); xmax=float(xmax); ymin=float(ymin); ymax=float(ymax)
-        yspan = ymax - ymin
-        xspan = xmax - xmin
-
-        #evalute find_axes for x values and y ticks
-        y_axis_xpos, xstep, xtslminor, xtslmajor = self._find_axes(xmin, xmax)
-        yltheight = 0.015*xspan     
-        ystheight = 0.25*yltheight
-        ylabel = y_axis_xpos - 2*ystheight
-        
-        #evalute find_axes for y values and x ticks
-        x_axis_ypos, ystep, ytslminor, ytslmajor = self._find_axes(ymin, ymax)
-        xltheight = 0.015*yspan
-        xstheight = 0.25*xltheight
-        xlabel = x_axis_ypos - xltheight 
-
-        if axes: 
-            self._draw_axes(subplot, axes, xmin, xmax, ymin, ymax, x_axis_ypos, y_axis_xpos)
-
-        #the x-axis ticks and labels
-        #first draw major tick marks and their corresponding values
-        for x in xtslmajor:
-            if x == y_axis_xpos:
-                continue
-            s = self._format_tick_string(x)
-            subplot.text(x, xlabel, s, fontsize=int(self.__fontsize), horizontalalignment="center", 
-                        color=self.__tick_label_color, verticalalignment="top")
-            subplot.add_line(lines.Line2D([x, x], [x_axis_ypos, x_axis_ypos + xltheight],
-                        color=self.__color, linewidth=float(self.__linewidth)))
-
-        #now draw the x-axis minor tick marks
-        for x in xtslminor:
-            subplot.add_line(lines.Line2D([x, x], [x_axis_ypos, x_axis_ypos + xstheight],
-                        color=self.__color, linewidth=float(self.__linewidth)))
-
-        #the y-axis ticks and labels
-        #first draw major tick marks and their corresponding values
-        for y in ytslmajor:
-            if y == x_axis_ypos:
-                continue
-            s = self._format_tick_string(y)
-            subplot.text(ylabel, y, s, fontsize=int(self.__fontsize), verticalalignment="center",
-                        color=self.__tick_label_color, horizontalalignment="right")
-            subplot.add_line(lines.Line2D([y_axis_xpos, y_axis_xpos + yltheight], [y, y],
-                    color=self.__color, linewidth=float(self.__linewidth)))
-            
-        #now draw the x-axis minor tick marks
-        for y in ytslminor:
-            subplot.add_line(lines.Line2D([y_axis_xpos, y_axis_xpos + ystheight], [y, y],
-                color=self.__color, linewidth=float(self.__linewidth)))
-
-        # now draw the x and y axis labels
-        if self.__axes_labels:
-            xmin, xmax, ymin, ymax = self._draw_axes_labels(subplot, self.__axes_labels, xmin, xmax, ymin, ymax, xstep, ystep, 
-                                   x_axis_ypos, y_axis_xpos, pad=0.2)
-
-        return xmin, xmax, ymin, ymax
-                                 
-
-    def _draw_frame(self, subplot, xmins, xmaxs, ymins, ymaxs):        
-        """
-        Draw a frame around a graphic at the given
-        (scaled out) x and y min and max values.
-        """
-        from matplotlib import lines
-        #border horizontal axis:
-        #bottom:
-        subplot.add_line(lines.Line2D([xmins, xmaxs], [ymins, ymins],
-                                        color=self.__color, linewidth=float(self.__linewidth)))
-        #top:
-        subplot.add_line(lines.Line2D([xmins, xmaxs], [ymaxs, ymaxs],
-                                        color=self.__color, linewidth=float(self.__linewidth)))
-        #border vertical axis:
-        #left:
-        subplot.add_line(lines.Line2D([xmins, xmins], [ymins, ymaxs],
-                                        color=self.__color, linewidth=float(self.__linewidth)))
-        #right:
-        subplot.add_line(lines.Line2D([xmaxs, xmaxs], [ymins, ymaxs],
-                                        color=self.__color, linewidth=float(self.__linewidth)))
-
-
-    def add_xy_frame_axes(self, subplot, xmin, xmax, ymin, ymax, 
-                          axes_with_no_ticks=False, axes_labels=None):
-        r"""
-        Draw a frame around the perimeter of a graphic.
-
-        Only major tick marks are drawn on a frame axes.
-
-        If \code{axes_with_no_ticks} is true, then also draw 
-        centered axes with no tick marks.
-
-        """
-        from matplotlib import lines
-        xmin = float(xmin); xmax=float(xmax); ymin=float(ymin); ymax=float(ymax)
-        yspan = ymax - ymin
-        xspan = xmax - xmin
-
-        #evalute find_axes for x values and y ticks
-        y_axis_xpos, xstep, xtslminor, xtslmajor = self._find_axes(xmin, xmax)
-        yltheight = 0.015 * xspan     
-        ystheight = 0.25  * yltheight
-        #ylabel    = y_axis_xpos - 2*ystheight
-        ylabel    = -2*ystheight
-        
-        #evalute find_axes for y values and x ticks
-        x_axis_ypos, ystep, ytslminor, ytslmajor = self._find_axes(ymin, ymax)
-        xltheight = 0.015 * yspan
-        xstheight = 0.25  * xltheight
-        #xlabel    = x_axis_ypos - xltheight 
-        xlabel    = -xltheight 
-
-        #scale the axes out from the actual plot
-        xmins, xmaxs, ymins, ymaxs = self._adjustments_for_frame(xmin, xmax, ymin, ymax)
-        
-        #now draw the frame border:
-        self._draw_frame(subplot, xmins, xmaxs, ymins, ymaxs)
-
-        #these are the centered axes, like in regular plot, but with no ticks
-        if axes_with_no_ticks:
-            #the x axis line
-            subplot.add_line(lines.Line2D([xmins, xmaxs], [x_axis_ypos, x_axis_ypos],
-                                            color=self.__color, linewidth=float(self.__linewidth)))
-
-            #the y axis line
-            subplot.add_line(lines.Line2D([y_axis_xpos, y_axis_xpos],[ymins, ymaxs],
-                                            color=self.__color, linewidth=float(self.__linewidth)))
-           
-        #the x-axis ticks and labels
-        #first draw major tick marks and their corresponding values
-        for x in xtslmajor:
-            s = self._format_tick_string(x)
-            subplot.text(x, xlabel + ymins, s, fontsize=int(self.__fontsize),
-                         horizontalalignment="center", verticalalignment="top")
-
-        #now draw the x-axis minor tick marks
-        for x in xtslminor:
-            subplot.add_line(lines.Line2D([x, x], [ymins, xstheight + ymins],
-                        color=self.__color, linewidth=float(self.__linewidth)))
-            subplot.add_line(lines.Line2D([x, x], [ymaxs, ymaxs - xstheight],
-                        color=self.__color, linewidth=float(self.__linewidth)))
-
-
-        #the y-axis ticks and labels
-        #first draw major tick marks and their corresponding values
-        for y in ytslmajor:
-            s = self._format_tick_string(y)
-            subplot.text(ylabel + xmins, y, s, fontsize=int(self.__fontsize), 
-                         verticalalignment="center", horizontalalignment="right")
-            
-        #now draw the x-axis minor tick marks
-        for y in ytslminor:
-            subplot.add_line(lines.Line2D([xmins, ystheight + xmins], [y, y],
-                color=self.__color, linewidth=float(self.__linewidth)))
-            subplot.add_line(lines.Line2D([xmaxs, xmaxs - ystheight], [y, y],
-                color=self.__color, linewidth=float(self.__linewidth)))
-
-    def _adjustments_for_frame(self, xmin, xmax, ymin, ymax):
-        r"""
-        Scale the axes out from the actual plot to accommodate a frame.
-
-        INPUT:
-            xmin, xmax, ymin, ymax -- numbers
-
-        OUTPUT:
-            xmin, xmax, ymin, ymax -- numbers
-
-        TESTS:
-            sage: from sage.plot.axes import Axes
-            sage: Axes()._adjustments_for_frame(-10,40,10,35)
-            (-11.0, 41.0, 9.5, 35.5)
-        """
-        xmin = float(xmin); xmax=float(xmax); ymin=float(ymin); ymax=float(ymax)
-        yspan = ymax - ymin
-        xspan = xmax - xmin
-        ys = 0.02*yspan
-        xs = 0.02*xspan
-        ymin -= ys
-        ymax += ys
-        xmin -= xs
-        xmax += xs
-        return xmin, xmax, ymin, ymax
-
-    def add_xy_matrix_frame_axes(self, subplot, xmin, xmax, ymin, ymax): 
-        """
-        Draw a frame around a \code{matrix_plot}.
-
-        The tick marks drawn on the frame correspond to
-        the ith row and jth column of the matrix.
-
-        """
-        from matplotlib import lines
-        xmax = int(xmax)
-        ymax = int(ymax)
-
-        #evalute find_axes for x values and y ticks
-        # the > 14 is just for appearance improvement
-        if xmax > 19:
-            #get nice tick spacing and assure we get largest point
-            tl, opax, step = self._tasteful_ticks(0, xmax)
-            #print tl, opax, step
-            xtl = self._tasteful_ticks(0, xmax)[0] + [xmax-1]
-            xrm = [float(x+0.5) for x in xtl]
-            xtslmajor = [int(n) for n in xtl] 
-        else:
-            xtl = sage.misc.misc.srange(0, xmax)
-            xrm = [float(x+0.5) for x in xtl]
-            xtslmajor = [int(n) for n in xtl] 
-        yltheight = 0.015*xmax     
-        ystheight = 0.25*yltheight
-        ylabel = -2*ystheight
-        
-        #evalute find_axes for y values and x ticks
-        # the > 14 is just for appearance improvement
-        if ymax > 19:
-            #get nice tick spacing and assure we get largest point
-            tl, opax, step = self._tasteful_ticks(0, ymax)
-            yrm = [0.5]+[float(y+0.5+1) for y in tl[1:-1]]+[ymax-0.5]
-            yrm.reverse()
-            ytslmajor = [0] + tl[1:-1] + [ymax-1] 
-        else:
-            ytl = sage.misc.misc.srange(0, ymax)
-            ytslmajor = [int(n) for n in ytl] 
-            yrm = [float(y+0.5) for y in ytslmajor]
-            yrm.reverse()
-        xltheight = 0.015*ymax
-        xstheight = 0.25*xltheight
-        xlabel = -xltheight 
-
-        #scale the axes out from the actual plot
-        xs = 0.02*xmax
-        ys = 0.02*ymax
-        xmins = -xs
-        xmaxs = xmax + xs
-        ymins = -ys
-        ymaxs = ymax + ys
-        
-        #now draw the frame border:
-        self._draw_frame(subplot, xmins, xmaxs, ymins, ymaxs)
-
-        #the x-axis ticks and labels
-        #first draw major tick marks and their corresponding values
-        for xr, x in zip(xrm, xtslmajor):
-            s = self._format_tick_string(x)
-            subplot.text(xr, xlabel + ymins, s, fontsize=int(self.__fontsize),
-                         horizontalalignment="center", verticalalignment="top")
-            subplot.text(xr, -2*xlabel + ymaxs, s, fontsize=int(self.__fontsize),
-                         horizontalalignment="center", verticalalignment="top")
-            subplot.add_line(lines.Line2D([xr, xr], [ymins, xstheight + ymins],
-                        color=self.__color, linewidth=float(self.__linewidth)))
-            subplot.add_line(lines.Line2D([xr, xr], [ymaxs, ymaxs - xstheight],
-                        color=self.__color, linewidth=float(self.__linewidth)))
-                    
-        #the y-axis ticks and labels
-        #first draw major tick marks and their corresponding values
-        for yr, y in zip(yrm, ytslmajor):
-            s = self._format_tick_string(y)
-            subplot.text(ylabel + xmins, yr, s, fontsize=int(self.__fontsize), 
-                         verticalalignment="center", horizontalalignment="right")
-            subplot.text(-2*ylabel + xmaxs, yr, s, fontsize=int(self.__fontsize), 
-                         verticalalignment="center", horizontalalignment="left")
-            subplot.add_line(lines.Line2D([xmins, ystheight + xmins], [yr, yr],
-                color=self.__color, linewidth=float(self.__linewidth)))
-            subplot.add_line(lines.Line2D([xmaxs, xmaxs - ystheight], [yr, yr],
-                color=self.__color, linewidth=float(self.__linewidth)))
-
-class GridLines(SageObject):
-    """
-    Grid lines for SAGE 2D Graphics.
-
-    See the docstring for Graphics.show for examples.
-    """
-    def __init__(self, gridlines=None, gridlinesstyle=None,
-            vgridlinesstyle=None, hgridlinesstyle=None):
-        r"""
-        Add horizontal and vertical grid lines to a Graphics object.
-
-        INPUT:
-            gridlines    -- (default: None) can be any of the following:
-                            1. None, False: do not add grid lines.
-                            2. True, "automatic", "major": add grid lines
-                               at major ticks of the axes.
-                            3. "minor": add grid at major and minor ticks.
-                            4. [xlist,ylist]: a tuple or list containing
-                               two elements, where xlist (or ylist) can be
-                               any of the following.
-                               4a. None, False: don't add horizontal (or
-                                   vertical) lines.
-                               4b. True, "automatic", "major": add
-                                   horizontal (or vertical) grid lines at
-                                   the major ticks of the axes.
-                               4c. "minor": add horizontal (or vertical)
-                                   grid lines at major and minor ticks of
-                                   axes.
-                               4d. an iterable yielding numbers n or pairs
-                                   (n,opts), where n is the coordinate of
-                                   the line and opt is a dictionary of
-                                   MATPLOTLIB options for rendering the
-                                   line.
-            gridlinesstyle,
-            hgridlinesstyle,
-            vgridlinesstyle 
-                         -- (default: None) a dictionary of MATPLOTLIB
-                            options for the rendering of the grid lines,
-                            the horizontal grid lines or the vertical grid
-                            lines, respectively.
-
-        TESTS:
-            sage: from sage.plot.axes import GridLines
-            sage: GridLines()
-            <class 'sage.plot.axes.GridLines'>
-            sage: gl = GridLines(False)
-            sage: gl = GridLines(True)
-            sage: gl = GridLines("automatic")
-            sage: gl = GridLines("major")
-            sage: gl = GridLines("minor")
-            sage: gl = GridLines([True,False])
-            sage: gl = GridLines(["minor","major"])
-            sage: gl = GridLines(["automatic",None])
-            sage: gl = GridLines([range(-10,10,2), lambda x,y:srange(x,y,0.5)])
-            sage: gl = GridLines(None, dict(color="red"),
-            ...     dict(linestyle=":"), dict(color="blue"))
-            sage: gl = GridLines(None, dict(rgbcolor="red"),
-            ...     dict(linestyle=":"), dict(color="blue"))
-        """
-        self.__gridlines = gridlines
-
-        defaultstyle = dict(color=(0.3,0.3,0.3),linewidth=0.4)
-        if gridlinesstyle is not None:
-            rgbcolor_keyword_support(gridlinesstyle)
-            defaultstyle.update(gridlinesstyle)
-        self.__gridlinesstyle = [copy(defaultstyle),copy(defaultstyle)]
-        if vgridlinesstyle is not None:
-            rgbcolor_keyword_support(vgridlinesstyle)
-            self.__gridlinesstyle[0].update(vgridlinesstyle)
-        if hgridlinesstyle is not None:
-            rgbcolor_keyword_support(hgridlinesstyle)
-            self.__gridlinesstyle[1].update(hgridlinesstyle)
-
-    def add_gridlines(self, subplot, xmin, xmax, ymin, ymax, frame=False):
-        # Process the input to get valid gridline data.
-        r"""
-        Add the grid lines to a subplot object.
-
-        INPUT:
-            subplot     -- an instance of matplotlib.axes.Subplot
-            xmin, xmax  -- $x$ range of the Graphics object containing subplot
-            ymin, ymax  -- $y$ range of the Graphics object containing subplot
-            frame       -- (default: False) if True, then adjust the lengths of
-                           the grid lines to touch connect to the frame.
-
-        OUTPUT:
-            None (modifies subplot)
-
-        TESTS:
-            sage: from sage.plot.axes import GridLines
-            sage: from matplotlib.figure import Figure
-            sage: subplot = Figure().add_subplot(111)
-            sage: lims = [-10,20,10,35]
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines().add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            0
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines(False).add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            0
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines(True).add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            13
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines("automatic").add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            13
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines("major").add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            13
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines("minor").add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            57
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines([True,False]).add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            7
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines(["minor","major"]).add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            37
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines(["automatic",None]).add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            7
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines([range(-10,10,2), lambda x,y:srange(x,y,0.5)]).add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            60
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines("automatic", dict(color="red"),
-            ...     dict(linestyle=":"), 
-            ...     dict(color="blue")).add_gridlines(subplot,*lims)
-            sage: len(subplot.lines)
-            13
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines([1,2,3]).add_gridlines(subplot,*lims)
-            Traceback (most recent call last):
-            ...
-            TypeError: gridlines is not a list or tuple of length 2
-
-            sage: subplot = Figure().add_subplot(111)
-            sage: GridLines([1,2]).add_gridlines(subplot,*lims)
-            Traceback (most recent call last):
-            ...
-            TypeError: elements of gridlines need to be iterable: [1, 2]
-        """
-        points = [[xmin, xmax], [ymin, ymax]]
-        if self.__gridlines is None or self.__gridlines is False:
-            return
-        elif self.__gridlines in ["major", "automatic"] or self.__gridlines is True:
-            self.__gridlines = [
-                    self._get_ticks_locations(points[0]),
-                    self._get_ticks_locations(points[1])
-                    ]
-        elif self.__gridlines == "minor":
-            self.__gridlines = [
-                    self._get_ticks_locations(points[0], self.__gridlines),
-                    self._get_ticks_locations(points[1], self.__gridlines)
-                    ]
-        else:
-            try:
-                gridlines = [None]*2
-                gridlines[0], gridlines[1] = self.__gridlines
-            except ValueError:
-                raise TypeError, "gridlines is not a list or tuple of length 2"
-
-            for i in range(2):
-                if gridlines[i] is None or gridlines[i] is False:
-                    gridlines[i] = []
-                elif gridlines[i] in ["major", "automatic"] or gridlines[i] is True:
-                    gridlines[i] = self._get_ticks_locations(points[i])
-                elif gridlines[i] == "minor":
-                    gridlines[i] = self._get_ticks_locations(points[i],gridlines[i])
-                elif callable(gridlines[i]):
-                    gridlines[i] = gridlines[i](*points[i])
-
-            if not (hasattr(gridlines[0],'__iter__') and
-                    hasattr(gridlines[1],'__iter__')):
-                raise TypeError, "elements of gridlines need to be iterable: %s" \
-                    % gridlines
-            self.__gridlines = gridlines
-
-        # add the gridlines to subplot.
-        if frame is True:
-            xmin, xmax, ymin, ymax = \
-                    self._get_adjustments_for_frame(*points)
-            points = [[xmin, xmax], [ymin, ymax]]
-
-        new_gridlines = []
-        for i in range(2):
-            new_list = []
-            for entry in self.__gridlines[i]:
-                kwds = copy(self.__gridlinesstyle[i])
-                if hasattr(entry,'__len__'):
-                    if len(entry) == 2:
-                        val = entry[0]
-                        rgbcolor_keyword_support(entry[1])
-                        kwds.update(entry[1])
-                else:
-                    val = entry
-                    kwds = copy(self.__gridlinesstyle[i])
-                new_list.append([val,kwds])
-            new_gridlines.append(new_list)
-        xlines, ylines = new_gridlines
-
-        # draw the grid lines
-        from matplotlib import lines
-        # horizontal lines
-        for (yval, ykwds) in ylines:
-            subplot.add_line(
-                    lines.Line2D(points[0],[yval,yval],**ykwds)
-                    )
-        # vertical lines
-        for (xval, xkwds) in xlines:
-            subplot.add_line(
-                    lines.Line2D([xval,xval],points[1],**xkwds)
-                    )
-
-    def _get_ticks_locations(self, interval, ticks="major"):
-        r"""
-        Find the locations of the major and/or minor ticks of the axes
-        in the interval.
-
-        INPUT:
-            interval -- an interval as a pair of numbers
-            ticks -- "major" or "minor". If "minor", then return also
-                the locations of the minor ticks.
-
-        OUTPUT:
-            list -- the locations of the ticks on the axes
-
-        TESTS:
-            sage: from sage.plot.axes import GridLines
-            sage: GridLines()._get_ticks_locations([-10,20])
-            [-10, -5, 0, 5, 10, 15, 20]
-            sage: GridLines()._get_ticks_locations([10,35],"minor")
-            [10.0, 11.0, 12.0, 13.0, ..., 32.0, 33.0, 34.0, 35.0]
-
-        """
-        # Axes._find_axes[2] returns locations of minor ticks
-        # Axes._find_axes[3] returns locations of major ticks
-        if ticks == "minor":
-            minorticks = True
-        else:
-            minorticks = False
-        return Axes()._find_axes(*interval)[2 if minorticks else 3]
-
-    def _get_adjustments_for_frame(self, xinterval, yinterval):
-        r"""
-        Returns new limits for axes to accommodate a frame drawn around the
-        plot.
-
-        INPUT:
-            xinterval -- x-axis interval as pairs of numbers
-            yinterval -- y-axis interval as pairs of numbers
-
-        OUTPUT:
-            xmin, xmax, ymin, ymax -- numbers
-
-        TESTS:
-            sage: from sage.plot.axes import GridLines
-            sage: GridLines()._get_adjustments_for_frame([-10,40],[10,35])
-            (-11.0, 41.0, 9.5, 35.5)
-        """
-        return Axes()._adjustments_for_frame(*(xinterval+yinterval))
-
 def rgbcolor_keyword_support(d):
     r"""
     Change the rgbcolor key to color. 
@@ -904 +69 @@
         else:
             d["color"] = d["rgbcolor"]
             del d["rgbcolor"]
+    return d

sage/plot/contour_plot.py

@@ -157 +157 @@
 
     g = Graphics()
     g.add_primitive(ContourPlot(xy_data_array, xrange, yrange, options))
+    g.axes(False)
     return g        
 
 @options(contours=(0,0), fill=False)

sage/plot/matrix_plot.py

@@ -140 +140 @@
 
     g = Graphics()
     g.add_primitive(MatrixPlot(xy_data_array, xrange, yrange, options))
+    g.axes(False)
     return g

sage/plot/plot.py

@@ -314 +314 @@
         return SHOW_DEFAULT
     SHOW_DEFAULT = bool(default)
 
-do_verify = True
-
 from sage.misc.randstate import current_randstate #for plot adaptive refinement
 import os #for viewing and writing images
 from colorsys import hsv_to_rgb #for the hue function
@@ -327 +325 @@
 import sage.misc.misc
 
 from misc import rgbcolor, Color, options, rename_keyword, to_mpl_color
-
+from sage.misc.cachefunc import cached_method
 import operator
 
 ############### WARNING ###
@@ -337 +335 @@
 # Sage startup times are much improved.)  - William
 ###############
 
-#Sage 2D Graphics Axes class:
-from axes import Axes
-from axes import GridLines
-
 def is_Graphics(x):
     """
     Return True if `x` is a Graphics object.
@@ -388 +382 @@
         
             sage: G = Graphics()
         """
-        self.__aspect_ratio = None
-        self.__fontsize = 10
-        self.__show_axes = True
-        self.__axes_color = (0, 0, 0)
-        self.__axes_label_color = (0, 0, 0)
-        self.__tick_label_color = (0, 0, 0)
-        self.__axes_width = 0.8
         self.__objects = []
 
+    def get_saved_options(self):
+        try:
+            return self.__saved_options
+        except AttributeError:
+            self.__saved_options = {}
+            return self.__saved_options
+
+    def get_saved_option(self, option, default=None):
+        return self.get_saved_options().get(option, default)
+
+    def set_saved_option(self, option, value):
+        options = self.get_saved_options()
+        options[option] = value
+    
     def set_aspect_ratio(self, ratio):
         """
         Set the aspect ratio.
@@ -433 +434 @@
         ratio = float(ratio)
         if ratio <= 0:
             raise ValueError, "the aspect ratio must be positive"
-        self.__aspect_ratio = ratio
+        self.set_saved_option('aspect_ratio', ratio)
 
     def aspect_ratio(self):
         """
@@ -451 +452 @@
             sage: P.aspect_ratio()
             2.0
         """
-        return self.__aspect_ratio
+        return self.get_saved_option('aspect_ratio')
 
     def get_axes_range(self):
         """
@@ -475 +476 @@
             [('xmax', 3.0), ('xmin', -1.0), ('ymax', 5.0), ('ymin', -4.0)]
         """
         axes_range = self.get_minmax_data()
-        axes_range.update(self._get_axes_range_dict())
+        for name in ['xmin', 'xmax', 'ymin', 'ymax']:
+            value = self.get_saved_option(name, None)
+            if value is not None:
+                axes_range[name] = value
         return axes_range
 
     def set_axes_range(self, xmin=None, xmax=None, ymin=None, ymax=None):
@@ -484 +488 @@
         
         INPUT:
         
-        
         -  ``xmin, xmax, ymin, ymax`` - floats
         
-        
         EXAMPLES::
         
             sage: L = line([(1,2), (3,-4), (2, 5), (1,2)])
@@ -497 +499 @@
             (-1.0, 20.0, 0.0, 2.0)
         """
         l = locals()
-        axes_range = self._get_axes_range_dict()
         for name in ['xmin', 'xmax', 'ymin', 'ymax']:
             if l[name] is not None:
-                axes_range[name] = float(l[name])
+                self.set_saved_option(name, float(l[name]))
 
     axes_range = set_axes_range
 
-    def _get_axes_range_dict(self):
-        """
-        Returns the underlying dictionary used to store the user's
-        custom ranges for the axes on this object.
-
-        EXAMPLES::
-
-            sage: L = line([(1,2), (3,-4), (2, 5), (1,2)])
-            sage: L._get_axes_range_dict()
-            {}
-            sage: L.set_axes_range(xmin=-1)
-            sage: L._get_axes_range_dict()
-            {'xmin': -1.0}
-        """
-        try:
-            return self.__axes_range
-        except AttributeError:
-            self.__axes_range = {}
-            return self.__axes_range
-
     def fontsize(self, s=None):
         """
-        Set the font size of axes labels and tick marks.
+        DEPRECATED:
+        
+        Set the font size of axes labels.
         
         INPUT:
-        
-        
         -  ``s`` - integer, a font size in points.
         
-        
         If called with no input, return the current fontsize.
         
         EXAMPLES::
@@ -549 +529 @@
         
             sage: L
         """
+        
         if s is None:
-            try:
-                return self.__fontsize
-            except AttributeError:
-                self.__fontsize = 10
-                return self.__fontsize
-        self.__fontsize = int(s)
+            return self.get_saved_option('fontsize', 10)
+        else:
+            return self.set_saved_option('fontsize', int(s))
 
     def axes(self, show=None):
         """
@@ -564 +542 @@
         
         INPUT:
         
-        
         -  ``show`` - bool
         
-        
         If called with no input, return the current axes setting.
         
         EXAMPLES::
@@ -596 +572 @@
             sage: L
         """
         if show is None:
-            try:
-                return self.__show_axes
-            except AttributeError:
-                self.__show_axes = True
-                return self.__show_axes
-        self.__show_axes = bool(show)
+            return self.get_saved_option('show_axes', True)
+        else:
+            return self.set_saved_option('show_axes', bool(show))
 
     def axes_color(self, c=None):
         """
@@ -641 +614 @@
             sage: L
         """
         if c is None:
-            try:
-                return self.__axes_color
-            
-            except AttributeError:
-                self.__axes_color = (0.0, 0.0, 0.0)
-                return self.__axes_color
-        self.__axes_color = rgbcolor(c)
+            return self.get_saved_option('axes_color', (0, 0, 0))
+        else:
+            return self.set_saved_option('axes_color', rgbcolor(c))
 
     def axes_labels(self, l=None):
         """
@@ -680 +649 @@
             sage: p
         """
         if l is None:
-            try:
-                return self.__axes_labels
-            except AttributeError:
-                self.__axes_labels = None
-                return self.__axes_labels
-        if not isinstance(l, (list, tuple)):
-            raise TypeError, "l must be a list or tuple"
-        if len(l) != 2:
-            raise ValueError, "l must have length 2"
-        self.__axes_labels = (str(l[0]), str(l[1]))
+            return self.get_saved_option('axes_labels', None)
+        else:
+            if not isinstance(l, (list, tuple)):
+                raise TypeError, "l must be a list or tuple"
+            if len(l) != 2:
+                raise ValueError, "l must have length 2"
+            self.set_saved_option('axes_labels', tuple(str(i) for i in l))
 
     def axes_label_color(self, c=None):
         r"""
@@ -735 +701 @@
             sage: p
         """
         if c is None:
-            try:
-                return self.__axes_label_color
-            except AttributeError:
-                self.__axes_label_color = (0, 0, 0)
-                return self.__axes_label_color
-        self.__axes_label_color = rgbcolor(c)
-
+            return self.get_saved_option('axes_label_color', (0, 0, 0))
+        else:
+            self.set_saved_option('axes_label_color', rgbcolor(c))
 
     def axes_width(self, w=None):
         r"""
@@ -776 +738 @@
             sage: p
         """
         if w is None:
-            try:
-                return self.__axes_width
-            except AttributeError:
-                self.__axes_width = True
-                return self.__axes_width
-        self.__axes_width = float(w)
+            return self.get_saved_option('axes_label_width', 0.8)
+        else:
+            self.set_saved_option('axes_label_width', float(w))
 
     def tick_label_color(self, c=None):
         """
@@ -807 +766 @@
             sage: p
         """
         if c is None:
-            try:
-                return self.__tick_label_color
-            except AttributeError:
-                self.__tick_label_color = (0, 0, 0)
-                return self.__tick_label_color
-        self.__tick_label_color = rgbcolor(c)
+            return self.get_saved_option('tick_label_color', (0, 0, 0))
+        else:
+            self.set_saved_option('tick_label_color', rgbcolor(c))
 
     def _repr_(self):
         r"""
@@ -987 +943 @@
         
         This only works when other is a Python int equal to 0. In all other
         cases a TypeError is raised. The main reason for this function is
-        to make suming a list of graphics objects easier.
+        to make summing a list of graphics objects easier.
         
         EXAMPLES::
         
@@ -1033 +989 @@
             raise TypeError, "other (=%s) must be a Graphics objects"%other
         g = Graphics()
         g.__objects = self.__objects + other.__objects
-        g.__aspect_ratio = max(self.__aspect_ratio, other.__aspect_ratio)
+        g.set_saved_option('aspect_ratio',
+                           max(self.get_saved_option('aspect_ratio'),
+                               other.get_saved_option('aspect_ratio')))
         return g
   
     def add_primitive(self, primitive):
@@ -1071 +1029 @@
             g = g.translate(0,0,z)
         return g
         
-    def show(self, xmin=None, xmax=None, ymin=None, ymax=None,
-             figsize=DEFAULT_FIGSIZE, filename=None,
-             dpi=DEFAULT_DPI, axes=None, axes_labels=None,frame=False,
-             fontsize=None, aspect_ratio=None,
-             gridlines=None, gridlinesstyle=None,
-             vgridlinesstyle=None, hgridlinesstyle=None):
+    def show(self, **options):
         """
         Show this graphics image with the default image viewer.
 
@@ -1269 +1222 @@
             sage: matrix_plot(M).show(gridlines=True)
         """
         if DOCTEST_MODE:
-            self.save(DOCTEST_MODE_FILE,
-                      xmin, xmax, ymin, ymax, figsize, 
-                      dpi=dpi, axes=axes, axes_labels=axes_labels,frame=frame,
-                      aspect_ratio=aspect_ratio, gridlines=gridlines,
-                      gridlinesstyle=gridlinesstyle,
-                      vgridlinesstyle=vgridlinesstyle,
-                      hgridlinesstyle=hgridlinesstyle)
-            return
-        if EMBEDDED_MODE:
-            self.save(filename, xmin, xmax, ymin, ymax, figsize, 
-                      dpi=dpi, axes=axes, axes_labels=axes_labels,frame=frame,
-                      aspect_ratio=aspect_ratio, gridlines=gridlines,
-                      gridlinesstyle=gridlinesstyle,
-                      vgridlinesstyle=vgridlinesstyle,
-                      hgridlinesstyle=hgridlinesstyle)
-            return
-        if filename is None:
-            filename = sage.misc.misc.tmp_filename() + '.png'
-        self.save(filename, xmin, xmax, ymin, ymax, figsize, dpi=dpi, axes=axes,
-                  axes_labels=axes_labels,
-                  frame=frame, fontsize=fontsize,
-                  aspect_ratio=aspect_ratio, 
-                  gridlines=gridlines, 
-                  gridlinesstyle=gridlinesstyle,
-                  vgridlinesstyle=vgridlinesstyle,
-                  hgridlinesstyle=hgridlinesstyle)
-        os.system('%s %s 2>/dev/null 1>/dev/null &'%(sage.misc.viewer.browser(), filename))
+            options['filename'] = DOCTEST_MODE_FILE
+        if options.get('filename', None) is None:
+            options['filename'] = sage.misc.misc.tmp_filename() + '.png'
+
+        self.save(**options)
+        
+        if not EMBEDDED_MODE:
+            os.system('%s %s 2>/dev/null 1>/dev/null &'%(sage.misc.viewer.browser(),
+                                                         options['filename']))
 
     def xmin(self, xmin=None):
         """
@@ -1404 +1339 @@
             ymin -= 1
             ymax += 1
         return {'xmin':xmin, 'xmax':xmax, 'ymin':ymin, 'ymax':ymax}
+
+    def get_filename_and_extension(self, **options):
+        """
         
-    def save(self, filename=None,
-             xmin=None, xmax=None, ymin=None, ymax=None, 
-             figsize=DEFAULT_FIGSIZE, figure=None, sub=None, savenow=True, 
-             dpi=DEFAULT_DPI, axes=None, axes_labels=None, fontsize=None,
-             frame=False, verify=True, aspect_ratio = None,
-             gridlines=None, gridlinesstyle=None,
-             vgridlinesstyle=None, hgridlinesstyle=None):
+        """
+        filename = options.get('filename', sage.misc.misc.graphics_filename())
+
+        #Check the extension for the filename
+        try:
+            ext = os.path.splitext(filename)[1].lower()
+        except IndexError:
+            ext = ''
+
+        if ext.lstrip('.') not in ['', 'png', 'ps', 'eps', 'pdf', 'svg', 'sobj']:
+            raise ValueError, "file extension must be either 'png', 'ps, 'eps', 'pdf, 'svg' or 'sobj'"
+
+        return filename, ext
+
+    def _mpl_figsize_and_range(self, options):
+        """
+        TESTS::
+
+            sage: p = plot(sin(x),-10,10)
+
+
+        We test to see that the
+        
+            sage: options = {}
+            sage: p._mpl_start(options)
+            
+            sage: p._mpl_figsize_and_range(options)
+            sage: options['subplot'].get_xlim()
+            (-10.0, 10.0)
+            sage: options['subplot'].get_ylim()
+            (-0.99..., 0.99...)
+            
+            sage: options['ymin'] = -0.5; options['ymax'] = 0.5
+            sage: p._mpl_figsize_and_range(options)
+            sage: options['subplot'].get_ylim()
+            (-0.5, 0.5)
+
+            sage: p.xmin(-2)
+            sage: options = {}
+            sage: p._mpl_start(options)
+            sage: p._mpl_figsize_and_range(options)
+            sage: options['subplot'].get_xlim()
+            (-2.0, 10.0)
+
+p         """
+        figure = options['figure']
+        subplot = options['subplot']
+        figsize = options.get('figsize', DEFAULT_FIGSIZE)
+        aspect_ratio = options.get('aspect_ratio', self.aspect_ratio())
+        
+        #Get the range of the axes and calculate the figure size
+        self.set_axes_range(options.get('xmin', None),
+                            options.get('xmax', None),
+                            options.get('ymin', None),
+                            options.get('ymax', None))
+        options.update(self.get_axes_range())
+
+        # adjust the figsize in case the user also specifies an aspect ratio
+        width, height = adjust_figsize_for_aspect_ratio(figsize, aspect_ratio,
+                                                        xmin=options['xmin'],
+                                                        xmax=options['xmax'],
+                                                        ymin=options['ymin'],
+                                                        ymax=options['ymax'])
+        figure.set_figwidth(float(width))
+        figure.set_figheight(float(height))
+
+        #Set the range of the axes
+        subplot.set_xlim(options['xmin'], options['xmax'])
+        subplot.set_ylim(options['ymin'], options['ymax'])
+
+    def _mpl_axes(self, options):
+        frame = options.get('frame', True)
+
+        subplot = options['subplot']
+        xmin = options['xmin']; xmax = options['xmax']
+        ymin = options['ymin']; ymax = options['ymax']
+
+        #################
+        #  Axes Labels  #
+        #################
+        labels = options.get('axes_labels', self.axes_labels())
+        if labels is not None:
+            xlabel, ylabel = labels
+            if xlabel:
+                subplot.set_xlabel(xlabel)
+            if ylabel:
+                subplot.set_ylabel(ylabel)
+
+        ####################
+        #  x=0, y=0 Lines  #
+        ####################
+        show_axes  = options.get('show_axes', self.axes())
+        axes_color = options.get('axes_color',
+                                 self.axes_color())
+        axes_width = options.get('axes_width',
+                                 self.axes_width())
+        if show_axes:
+            from matplotlib import lines
+            if xmin < 0 and xmax > 0:
+                subplot.axvline(color=axes_color, linewidth=axes_width)
+            if ymin < 0 and ymax > 0:
+                subplot.axhline(color=axes_color, linewidth=axes_width)
+
+        ###########
+        #  Frame  #
+        ###########
+        show_frame = options.get('frame', True)
+        if not show_frame:
+            subplot.set_axis_off()        
+
+
+        ###########
+        #  Title  #
+        ###########
+        subplot.set_title(options.get('title',
+                                      self.get_saved_option('title',
+                                                            '')))
+
+    def _mpl_grid(self, options):
+        from axes import rgbcolor_keyword_support
+
+        gridlines = options.get('gridlines', None)
+        if gridlines is None or gridlines is False:
+            return
+        
+        if gridlines in [True, 'major', 'automatic', 'minor']:
+            hlines = gridlines
+            vlines = gridlines
+        else:
+            try:
+                hlines, vlines = gridlines
+            except ValueError:
+                raise TypeError, "gridlines is not a list or tuple of length 2"
+
+        ############
+        #  Styles  #
+        ############
+        import copy
+        style = rgbcolor_keyword_support(options.get('gridlinesstyle', {}))
+        hstyle = copy.copy(style)
+        hstyle.update(rgbcolor_keyword_support(options.get('hgridlinesstyle', {})))
+        vstyle = copy.copy(style)
+        vstyle.update(rgbcolor_keyword_support(options.get('vgridlinesstyle', {})))
+
+        ############
+        #  Render  #
+        ############
+        subplot = options['subplot']
+        for (lines, axis, add_line, style) in [(hlines, subplot.get_yaxis(), subplot.axhline, hstyle),
+                                               (vlines, subplot.get_xaxis(), subplot.axvline, vstyle)]:
+            if not lines:
+                continue
+
+            if isinstance(lines, (str, bool, type(None))):
+                axis.grid(True, **style)
+                if lines == 'minor':
+                    axis.grid(True, which='minor', **style)
+                continue
+
+            #Handle the case where we are given an iterable
+            for entry in lines:
+                if hasattr(entry, '__len__') and len(entry) == 2:
+                    pos, new_line_style = entry
+                    line_style = copy.copy(style)
+                    line_style.update(rgbcolor_keyword_support(new_line_style))
+                else:
+                    pos = entry
+                    line_style = style
+
+                add_line(float(pos), **line_style)
+
+    def _mpl_primitives(self, options):
+        subplot = options['subplot']
+        for g in self.__objects:
+            g._render_on_subplot(subplot)
+
+
+    def _mpl_scales(self, options):
+        """
+        Sets the scales for the axes.
+        """
+        subplot = options['subplot']
+        subplot.set_xscale(options.get('xscale',
+                                       self.get_saved_option('xscale',
+                                                             'linear')))
+        subplot.set_yscale(options.get('yscale',
+                                       self.get_saved_option('yscale',
+                                                             'linear')))
+
+    def _mpl_final(self, options):       
+        dpi = options.get('dpi', DEFAULT_DPI)
+        filename = options['filename']
+        figure = options['figure']
+        subplot = options['subplot']
+
+        # You can output in PNG, PS, EPS, PDF, or SVG format,
+        # depending on the file extension.  matplotlib looks at the
+        # file extension to see what the renderer should be.  The
+        # default is FigureCanvasAgg for png's because this is by far
+        # the most common type of files rendered, like in the Notebook
+        # for example.  if the file extension is not '.png', then
+        # matplotlib will handle it.
+        from matplotlib.backends.backend_agg import FigureCanvasAgg
+        canvas = FigureCanvasAgg(figure)
+        default_dpi = {'.eps':72, '.ps':72, '.pdf':72, '.svg':80, '.png':100}
+        dpi = default_dpi[ext] if dpi is None else dpi
+        canvas.print_figure(filename, dpi=dpi)
+
+    def _mpl_start(self, options):
+        #Get the figure and subplot
+        from matplotlib.figure import Figure
+        figure = Figure(DEFAULT_FIGSIZE)
+        subplot = figure.add_subplot(111)
+        options['figure'] = figure 
+        options['subplot'] = subplot
+
+    def _save_mpl(self, options):
+        self._mpl_start(options)
+        self._mpl_figsize_and_range(options)
+        self._mpl_axes(options)
+        self._mpl_grid(options)
+        self._mpl_primitives(options)
+        self._mpl_scales(options)
+        self._mpl_final(options)
+                
+    def save(self, **options):
         r"""
         Save the graphics to an image file of type: PNG, PS, EPS, SVG,
         SOBJ, depending on the file extension you give the filename.
@@ -1435 +1592 @@
         
             sage: point((-1,1),pointsize=30, rgbcolor=(1,0,0))
         """
-        self.set_axes_range(xmin, xmax, ymin, ymax)
-        d = self.get_axes_range()
-        xmin = d['xmin']
-        xmax = d['xmax']
-        ymin = d['ymin']
-        ymax = d['ymax']
-
-        # adjust the figsize in case the user also specifies an aspect ratio
-        if aspect_ratio is None:
-            aspect_ratio = self.aspect_ratio()
-        figsize = adjust_figsize_for_aspect_ratio(figsize, aspect_ratio, xmin=xmin,
-                                                  xmax=xmax, ymin=ymin, ymax=ymax)
-        
-        global do_verify
-        do_verify = verify
-
-        if axes is None:
-            axes = self.__show_axes
-
-        from matplotlib.figure import Figure
-        if filename is None:
-            filename = sage.misc.misc.graphics_filename()
-        try:
-            ext = os.path.splitext(filename)[1].lower()
-        except IndexError:
-            raise ValueError, "file extension must be either 'png', 'eps', 'svg' or 'sobj'"
-        
+        filename, ext = self.get_filename_and_extension(**options)
         if ext == '' or ext == '.sobj':
             SageObject.save(self, filename)
             return
+        else:
+            options['filename'] = filename
 
-        self.fontsize(fontsize)
-        self.axes_labels(l=axes_labels)
-
-        if figure is None:
-            figure = Figure(figsize)
-
-        #The line below takes away the excessive whitespace around
-        #images.  ('figsize' and  'dpi' still work as expected):
-        figure.subplots_adjust(left=0.04, bottom=0.04, right=0.96, top=0.96)
-        
-        #the incoming subplot instance
-        subplot = sub
-        if not subplot:
-            subplot = figure.add_subplot(111)
-
-        #take away the matplotlib axes:
-        subplot.xaxis.set_visible(False)
-        subplot.yaxis.set_visible(False)
-        subplot.set_frame_on(False)
-
-        #add all the primitives to the subplot
-        #check if there are any ContourPlot instances
-        #in self._objects, and if so change the axes
-        #to be frame axes instead of centered axes
-        contour = False
-        plotfield = False
-        matrixplot = False
-        from contour_plot import ContourPlot
-        from matrix_plot import MatrixPlot
-        from plot_field import PlotField
-        for g in self.__objects:
-            if isinstance(g, ContourPlot):
-                contour = True
-            if isinstance(g, PlotField):
-                plotfield = True
-            if isinstance(g, MatrixPlot):
-                matrixplot = True
-            g._render_on_subplot(subplot)
-        
-        #adjust the xy limits and draw the axes:
-        if axes is None:
-            axes = self.__show_axes
-
-        #construct an Axes instance, see 'axes.py' for relevant code
-        sage_axes = Axes(color=self.__axes_color, fontsize=self.__fontsize,
-                         axes_labels=self.__axes_labels, 
-                         axes_label_color=self.__axes_label_color, 
-                         tick_label_color=self.__tick_label_color, linewidth=self.__axes_width)
-
-        # construct a GridLines instance, see 'axes.py' for relevant code
-        sage_gridlines = GridLines(gridlines=gridlines, gridlinesstyle=gridlinesstyle,
-                vgridlinesstyle=vgridlinesstyle, hgridlinesstyle=hgridlinesstyle)
-
-        #adjust the xy limits and draw the axes:
-        if not (contour or plotfield or matrixplot): #the plot is a 'regular' plot
-            xmin -= 0.1*(xmax-xmin)
-            xmax += 0.1*(xmax-xmin)
-            ymin -= 0.1*(ymax-ymin)
-            ymax += 0.1*(ymax-ymin)
-            if frame: #add the frame axes 
-                axmin, axmax = xmin - 0.04*abs(xmax - xmin), xmax + 0.04*abs(xmax - xmin)
-                aymin, aymax = ymin - 0.04*abs(ymax - ymin), ymax + 0.04*abs(ymax - ymin)
-                subplot.set_xlim([axmin, axmax])
-                subplot.set_ylim([aymin, aymax])
-                # draw the grid
-                sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, True)
-                #add a frame to the plot and possibly 'axes_with_no_ticks'
-                sage_axes.add_xy_frame_axes(subplot, xmin, xmax, ymin, ymax,
-                                        axes_with_no_ticks=axes)
-
-            elif not frame and axes: #regular plot with regular axes
-                # draw the grid
-                sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, False)
-                # draw the axes
-                xmin, xmax, ymin, ymax = sage_axes.add_xy_axes(subplot, xmin, xmax, ymin, ymax)
-                subplot.set_xlim(xmin, xmax)
-                subplot.set_ylim(ymin, ymax)
-                
-            else: #regular plot with no axes
-                subplot.set_xlim(xmin, xmax)
-                subplot.set_ylim(ymin, ymax)
-                # draw the grid
-                sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, False)
-                
-        elif (contour or plotfield): #contour or field plot in self.__objects, so adjust axes accordingly
-            subplot.set_xlim([xmin - 0.05*abs(xmax - xmin), xmax + 0.05*abs(xmax - xmin)])
-            subplot.set_ylim([ymin - 0.05*abs(ymax - ymin), ymax + 0.05*abs(ymax - ymin)])
-            # draw the grid
-            sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, True)
-            # draw the axes
-            if axes: #axes=True unless user specifies axes=False
-                sage_axes.add_xy_frame_axes(subplot, xmin, xmax, ymin, ymax)
-                
-        else: #we have a 'matrix_plot' in self.__objects, so adjust axes accordingly
-            subplot.set_xlim([xmin - 0.05*abs(xmax - xmin), xmax + 0.05*abs(xmax - xmin)])
-            subplot.set_ylim([ymin - 0.05*abs(ymax - ymin), ymax + 0.05*abs(ymax - ymin)])
-            # draw the grid
-            if gridlines in ["major", "automatic", True]:
-                gridlines = [sage.misc.misc.srange(-0.5,xmax+1,1),
-                        sage.misc.misc.srange(-0.5,ymax+1,1)]
-            sage_gridlines = GridLines(gridlines=gridlines,
-                    gridlinesstyle=gridlinesstyle,
-                    vgridlinesstyle=vgridlinesstyle,
-                    hgridlinesstyle=hgridlinesstyle)
-            sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, False)
-            # draw the axes
-            if axes: #axes=True unless user specifies axes=False
-                sage_axes.add_xy_matrix_frame_axes(subplot, xmin, xmax, ymin, ymax)
-
-        # You can output in PNG, PS, EPS, PDF, or SVG format, depending on the file extension. 
-        # matplotlib looks at the file extension to see what the renderer should be.
-        # The default is FigureCanvasAgg for png's because this is by far the most
-        # common type of files rendered, like in the Notebook for example.
-        # if the file extension is not '.png', then matplotlib will handle it.
-        if savenow:
-            from matplotlib.backends.backend_agg import FigureCanvasAgg
-            canvas = FigureCanvasAgg(figure)
-            if ext in ['.eps', '.ps', '.pdf']:
-                if dpi is None:
-                    dpi = 72
-            elif ext == '.svg':
-                if dpi is None:
-                    dpi = 80
-            elif ext == '.png':
-                if dpi is None:
-                    dpi = 100
-            else:
-                raise ValueError, "file extension must be either 'png', 'ps, 'eps', 'pdf, 'svg' or 'sobj'"
-            canvas.print_figure(filename, dpi=dpi)
+        self._save_mpl(options)
 
 def xydata_from_point_list(points):
     r""" 
@@ -2413 +2418 @@
         #make a blank matplotlib Figure:
         from matplotlib.figure import Figure
         figure = Figure(figsize)
-        global do_verify
-        do_verify = True
         for i,g in zip(range(1, dims+1), glist):
             subplot = figure.add_subplot(rows, cols, i)
-            g.save(filename, dpi=dpi, figure=figure, sub=subplot,
-                   savenow = (i==dims), verify=do_verify,
+            g.save(filename=filename, dpi=dpi, figure=figure, sub=subplot,
+                   savenow = (i==dims),
                    axes = axes,
                    **args)#only save if i==dims.
 
@@ -2432 +2435 @@
         self._render(filename, dpi=dpi, figsize=self._figsize, axes = axes, **args)
 
     def show(self, filename=None, dpi=DEFAULT_DPI, figsize=DEFAULT_FIGSIZE,
-             axes = None, **args):
+             axes = None, **kwds):
         r"""
         Show this graphics array using the default viewer.
         
@@ -2464 +2467 @@
         """
         if (figsize != DEFAULT_FIGSIZE): self.__set_figsize__(figsize) 
         if DOCTEST_MODE:
-            self.save(DOCTEST_MODE_FILE,
-                      dpi=dpi, figsize=self._figsize, axes = axes, **args)
+            self.save(filename=DOCTEST_MODE_FILE,
+                      dpi=dpi, figsize=self._figsize, axes = axes, **kwds)
             return
         if EMBEDDED_MODE:
-            self.save(filename, dpi=dpi, figsize=self._figsize, axes = axes, **args)
+            self.save(filename=filename, dpi=dpi, figsize=self._figsize, axes = axes, **kwds)
             return
         if filename is None:
             filename = sage.misc.misc.tmp_filename() + '.png'
-        self._render(filename, dpi=dpi, figsize=self._figsize, axes = axes, **args)
+        self._render(filename=filename, dpi=dpi, figsize=self._figsize, axes = axes, **kwds)
         os.system('%s %s 2>/dev/null 1>/dev/null &'%(
                          sage.misc.viewer.browser(), filename))
 

sage/plot/primitive.py

@@ -65 +65 @@
         """
         Translate 2d plot options into 3d plot options. 
         """
-        if options == None:
+        if options is None:
             options = self.options()
         options_3d = {}
         if 'rgbcolor' in options:
-            options_3d['rgbcolor'] = options['rgbcolor']
-            del options['rgbcolor']
+            options_3d['rgbcolor'] = options.pop('rgbcolor')
         if 'alpha' in options:
-            options_3d['opacity'] = options['alpha']
-            del options['alpha']
+            options_3d['opacity'] = options.pop('alpha')
         if len(options) != 0:
             raise NotImplementedError, "Unknown plot3d equivalent for %s" % ", ".join(options.keys())
         return options_3d
@@ -93 +91 @@
             sage: GraphicPrimitive({}).options()
             {}
         """
-        from sage.plot.plot import do_verify, hue
+        from sage.plot.plot import hue
         O = dict(self.__options)
-        if do_verify:
-            A = self._allowed_options()
-            t = False
-            K = A.keys() + ['xmin', 'xmax', 'ymin', 'ymax', 'axes']
-            for k in O.keys():
-                if not k in K:
-                    do_verify = False
-                    verbose("WARNING: Ignoring option '%s'=%s"%(k,O[k]), level=0)
-                    t = True
-            if t:
-                s = "\nThe allowed options for %s are:\n"%self
-                K.sort()
-                for k in K:
-                    if A.has_key(k):
-                        s += "    %-15s%-60s\n"%(k,A[k])
-                verbose(s, level=0)
-
+        A = self._allowed_options()
+        t = False
+        K = A.keys() + ['xmin', 'xmax', 'ymin', 'ymax', 'axes']
+        for k in O.keys():
+            if not k in K:
+                verbose("WARNING: Ignoring option '%s'=%s"%(k,O[k]), level=0)
+                t = True
+        if t:
+            s = "\nThe allowed options for %s are:\n"%self
+            K.sort()
+            for k in K:
+                if A.has_key(k):
+                    s += "    %-15s%-60s\n"%(k,A[k])
+            verbose(s, level=0)
 
         if 'hue' in O:
             t = O['hue']