Ticket #5448: trac-5448-matplotlib-axes-gridlines.3.patch

sage/plot/contour_plot.py

@@ -161 +161 @@
             else:
                 subplot.contour(self.xy_data_array, contours, cmap=cmap, extent=(x0,x1,y0,y1))
 
-@options(plot_points=25, fill=True, cmap='gray', contours=None)
+@options(plot_points=25, fill=True, cmap='gray', contours=None,frame=True)
 def contour_plot(f, xrange, yrange, **options):
     r"""    
     ``contour_plot`` takes a function of two variables, `f(x,y)`

sage/plot/matrix_plot.py

@@ -156 +156 @@
             subplot.imshow(self.xy_data_array, cmap=cmap, interpolation='nearest', extent=(0,self.xrange[1],0,self.yrange[1]))
 
 
-@options(cmap='gray',marker='.')
+@options(cmap='gray',marker='.',frame=True)
 def matrix_plot(mat, **options):
     r"""
     A plot of a given matrix or 2D array.

sage/plot/plot.py

@@ -157 +157 @@
 Another graph::
 
     sage: x = var('x')
-    sage: P = plot(sin(x)/x, -4,4, rgbcolor=(0,0,1)) + \
-    ...       plot(x*cos(x), -4,4, rgbcolor=(1,0,0)) + \
-    ...       plot(tan(x),-4,4,rgbcolor=(0,1,0))
+    sage: P = plot(sin(x)/x, -4,4, color='blue') + \
+    ...       plot(x*cos(x), -4,4, color='red') + \
+    ...       plot(tan(x),-4,4, color='green')
     ...
     sage: P.show(ymin=-pi,ymax=pi)
 
@@ -198 +198 @@
     sage: P += plot(f, 1, 8.5, thickness=3)
     sage: P    # show the result
 
+
+
 NUMERICAL PLOTTING:
 
 Sage also provides 2D plotting with an interface that is a likely
@@ -376 +378 @@
     
         sage: G = Graphics(); print G
         Graphics object consisting of 0 graphics primitives
-        sage: c = circle((1,1), 1)
+        sage: c = circle((1,1), 1,aspect_ratio=1)
         sage: G+=c; print G
         Graphics object consisting of 1 graphics primitive
     
     Here we make a graphic of embedded isosceles triangles, coloring
     each one with a different color as we go::
     
-        sage: h=10; c=0.4; p=0.1;
+        sage: h=10; c=0.4; p=0.5;
         sage: G = Graphics()
         sage: for x in srange(1,h+1):
         ...        l = [[0,x*sqrt(3)],[-x/2,-x*sqrt(3)/2],[x/2,-x*sqrt(3)/2],[0,x*sqrt(3)]]
@@ -683 +685 @@
         ::
         
             sage: p = plot(sin(x), (x, 0, 10))
-            sage: p.axes_labels(['x','y'])
+            sage: p.axes_labels(['$x$','$y$'])
             sage: p.axes_labels()
-            ('x', 'y')
+            ('$x$', '$y$')
         
         Now when you plot p, you see x and y axes labels::
         
@@ -1149 +1151 @@
                         dpi=DEFAULT_DPI, axes=None, axes_labels=None,frame=False,
                         fontsize=None, aspect_ratio=None,
                         gridlines=None, gridlinesstyle=None,
-                        vgridlinesstyle=None, hgridlinesstyle=None)
+                        vgridlinesstyle=None, hgridlinesstyle=None,transparent=False)
 
     def show(self, **kwds):
         """
@@ -1184 +1186 @@
 
         - ``gridlines`` - (default: None) can be any of the following:
 
-          -  None, False: do not add grid lines.
+          - None, False: do not add grid lines.
 
           - True, "automatic", "major": add grid lines at major ticks of the axes.
 
@@ -1216 +1218 @@
         - ``linkmode`` - (default: False) If True a string containing a link
             to the produced file is returned.
 
+        - ``transparent`` - (default: False) If True, make the background transparent.
+
         EXAMPLES::
         
             sage: c = circle((1,1), 1, rgbcolor=(1,0,0))
             sage: c.show(xmin=-1, xmax=3, ymin=-1, ymax=3)
         
-        To correct the aspect ratio of certain graphics, it is necessary to
-        show with a '``figsize``' of square dimensions.
+        To correct the aspect ratio of certain graphics, you can 
+        set the ``aspect_ratio`` to 1
         
         ::
         
-            sage: c.show(figsize=[5,5], xmin=-1, xmax=3, ymin=-1, ymax=3)
+            sage: c.show(aspect_ratio=1, xmin=-1, xmax=3, ymin=-1, ymax=3)
+
+        You could also just make the dimensions of the picture square
+        using ``figsize``
+
+        ::
+
+            sage: c.show(figsize=[5,5], xmin=-1, xmax=3, ymin=-1, ymax=3)        
         
         You can turn off the drawing of the axes::
         
             sage: show(plot(sin,-4,4), axes=False)
         
-        You can also label the axes::
+        You can also label the axes.  Putting something in dollar
+        signs formats it as a mathemtical expression::
         
-            sage: show(plot(sin,-4,4), axes_labels=('x','y'))
+            sage: show(plot(sin,-4,4), axes_labels=('$x$','$y$'))
         
         You can turn on the drawing of a frame around the plots::
         
             sage: show(plot(sin,-4,4), frame=True)
         
-        Add grid lines at the major ticks of the axes.
+        You can make the background transparent::
+
+            sage: plot(sin(x), (x, -4, 4), transparent=True)
+
+        Add grid lines at the major ticks of the axes. 
         
         ::
         
@@ -1324 +1340 @@
             ...     (0,{"color":"blue","linestyle":"--"})
             ...    ],
             ...    [
-            ...     (-1,{"rgbcolor":"red","linestyle":":"}),
+            ...     (-1,{"color":"red","linestyle":":"}),
             ...     (0,{"color":"blue","linestyle":"--"}),
-            ...     (1,{"rgbcolor":"red","linestyle":":"}),
+            ...     (1,{"color":"red","linestyle":":"}),
             ...    ]
             ...    ),
-            ...    gridlinesstyle=dict(marker='x',rgbcolor="black"))
+            ...    gridlinesstyle=dict(marker='x',color="black"))
         
         Grid lines can be added to contour plots.
         
@@ -1337 +1353 @@
         
             sage: f = sin(x^2 + y^2)*cos(x)*sin(y)
             sage: c = contour_plot(f, (x, -4, 4), (y, -4, 4), plot_points=100)
-            sage: c.show(gridlines=True, gridlinesstyle={'linestyle':':','linewidth':1, 'rgbcolor':'red'})
+            sage: c.show(gridlines=True, gridlinesstyle={'linestyle':':','linewidth':1, 'color':'red'})
         
         Grid lines can be added to matrix plots.
         
@@ -1491 +1507 @@
             ymax += 1
         return {'xmin':xmin, 'xmax':xmax, 'ymin':ymin, 'ymax':ymax}
         
-    def save(self, filename=None,
+    def matplotlib(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,
+             figsize=None, figure=None, sub=None, 
+              axes=None, axes_labels=None, fontsize=None,
              frame=False, verify=True, aspect_ratio = None,
              gridlines=None, gridlinesstyle=None,
              vgridlinesstyle=None, hgridlinesstyle=None):
         r"""
+        Return a matplotlib figure object representing the graphic
+
         Save the graphics to an image file of type: PNG, PS, EPS, SVG,
         SOBJ, depending on the file extension you give the filename.
         Extension types can be: ``.png``, ``.ps``,
@@ -1510 +1528 @@
             sage: c = circle((1,1),1,rgbcolor=(1,0,0))
             sage: c.show(xmin=-1,xmax=3,ymin=-1,ymax=3)
         
-        To correct the aspect ratio of certain graphics, it is necessary to
-        show with a '``figsize``' of square dimensions.
+        To correct the aspect ratio of certain graphics, you can 
+        set the ``aspect_ratio`` to 1
         
         ::
         
-            sage: c.show(figsize=[5,5],xmin=-1,xmax=3,ymin=-1,ymax=3)
+            sage: c.show(aspect_ratio=1, xmin=-1, xmax=3, ymin=-1, ymax=3)
+
+        You could also just make the dimensions of the picture square
+        using ``figsize``.
+
+        ::
+
+            sage: c.show(figsize=[5,5], xmin=-1, xmax=3, ymin=-1, ymax=3)
+
+
         
         ::
         
             sage: point((-1,1),pointsize=30, rgbcolor=(1,0,0))
+
+        By default, graphics expand to include all elements in the
+        picture, so the dimensions might be different than what is
+        explicitly specified.
         """
         self.set_axes_range(xmin, xmax, ymin, ymax)
         d = self.get_axes_range()
@@ -1527 +1558 @@
         xmax = d['xmax']
         ymin = d['ymin']
         ymax = d['ymax']
+        
+        yrange=ymax-ymin
+        snap=yrange*.01
 
-        # 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)
+        # include y=0 in the range if ymin or ymax is close enough to zero
+        if 0<ymin<snap:
+            ymin=0
+        if -snap<ymax<0:
+            ymax=0
+        
+        self.set_axes_range(xmin,xmax,ymin,ymax)
         
         global do_verify
         do_verify = verify
@@ -1540 +1576 @@
         if axes is None:
             axes = self.__show_axes
 
-        from matplotlib.figure import Figure
+        from matplotlib.figure import Figure, figaspect
+        self.fontsize(fontsize)
+        self.axes_labels(l=axes_labels)
+
+        # adjust the figsize in case the user also specifies an aspect ratio
+        if aspect_ratio is None:
+            aspect_ratio = self.aspect_ratio()
+
+        # We try to accommodate both a demand for aspect ratio and
+        # for a figure size by adjusting the figure size to have
+        # the right aspect ratio.
+        if figsize is None:
+            figsize=DEFAULT_FIGSIZE
+        figsize=adjust_figsize_for_aspect_ratio(figsize, aspect_ratio, 
+                                                xmin=xmin, xmax=xmax, 
+                                                ymin=ymin, ymax=ymax)
+
+        if figure is None:
+            figure=Figure(figsize)
+        
+        #the incoming subplot instance
+        subplot = sub
+        if not subplot:
+            subplot = figure.add_subplot(111)
+            if aspect_ratio is not None:
+                subplot.set_aspect('auto')
+
+        #add all the primitives to the subplot
+        for g in self.__objects:
+            g._render_on_subplot(subplot)
+        
+            
+        subplot.set_xlim([xmin, xmax])
+        subplot.set_ylim([ymin,ymax])
+
+        if axes is None:
+            axes = self.__show_axes
+
+        for spine in subplot.spines.values():
+            spine.set_color(self.__axes_color)
+            spine.set_linewidth(self.__axes_width)
+        
+
+        if frame:
+            # For now, set the formatter to the old one, since that is
+            # sort of what we are used to.  We should eventually look at
+            # the default one to see if we like it better.
+            from matplotlib.ticker import OldScalarFormatter
+            subplot.xaxis.set_major_formatter(OldScalarFormatter())
+            subplot.yaxis.set_major_formatter(OldScalarFormatter())
+            
+            subplot.set_frame_on(True)
+            if axes:
+                if ymin<=0 and ymax>=0:
+                    subplot.axhline(color=self.__axes_color,
+                                    linewidth=self.__axes_width)
+                if xmin<=0 and xmax>=0:
+                    subplot.axvline(color=self.__axes_color,
+                                    linewidth=self.__axes_width)
+            
+        elif axes:
+            ymiddle=False
+            xmiddle=False
+            if xmin>0:
+                subplot.spines['right'].set_visible(False)
+                subplot.spines['left'].set_position(('outward',10))
+                subplot.yaxis.set_ticks_position('left')
+                subplot.yaxis.set_label_position('left')
+                yaxis='left'
+            elif xmax<0:
+                subplot.spines['left'].set_visible(False)
+                subplot.spines['right'].set_position(('outward',10))
+                subplot.yaxis.set_ticks_position('right')
+                subplot.yaxis.set_label_position('right')
+                yaxis='right'
+            else:
+                subplot.spines['left'].set_position('zero')
+                subplot.yaxis.set_ticks_position('left')
+                subplot.yaxis.set_label_position('left')
+                subplot.spines['right'].set_visible(False)
+                ymiddle=True
+                yaxis='left'
+
+            if ymin>0:
+                subplot.spines['top'].set_visible(False)
+                subplot.spines['bottom'].set_position(('outward',10))
+                subplot.xaxis.set_ticks_position('bottom')
+                subplot.xaxis.set_label_position('bottom')
+                xaxis='bottom'
+            elif ymax<0:
+                subplot.spines['bottom'].set_visible(False)
+                subplot.spines['top'].set_position(('outward',10))
+                subplot.xaxis.set_ticks_position('top')
+                subplot.xaxis.set_label_position('top')
+                xaxis='top'
+            else:
+                subplot.spines['bottom'].set_position('zero')
+                subplot.xaxis.set_ticks_position('bottom')
+                subplot.xaxis.set_label_position('bottom')
+                subplot.spines['top'].set_visible(False)
+                xmiddle=True
+                xaxis='bottom'
+            
+            # For now, set the formatter to the old one, since that is
+            # sort of what we are used to.  We should eventually look at
+            # the default one to see if we like it better.
+            from matplotlib.ticker import OldScalarFormatter
+            subplot.xaxis.set_major_formatter(OldScalarFormatter())
+            subplot.yaxis.set_major_formatter(OldScalarFormatter())
+
+
+            # Make ticklines go on both sides of the axes
+            #             if xmiddle:
+            #                 for t in subplot.xaxis.get_majorticklines():
+            #                     t.set_marker("|")
+            #                     t.set_markersize(8)
+            #                 for t in subplot.xaxis.get_minorticklines():
+            #                     t.set_marker("|")
+            #                     t.set_markersize(4)
+            
+            #             if ymiddle:
+            #                 for t in subplot.yaxis.get_majorticklines():
+            #                     t.set_marker("|")
+            #                     t.set_markersize(8)
+            #                 for t in subplot.yaxis.get_minorticklines():
+            #                     t.set_marker("|")
+            #                     t.set_markersize(4)
+            
+            # Make the zero tick labels disappear if the axes cross
+            # inside the picture
+            if xmiddle and ymiddle:
+                subplot.yaxis.set_major_formatter(SelectiveFormatter(subplot.yaxis.get_major_formatter(),skip_values=[0]))
+                subplot.xaxis.set_major_formatter(SelectiveFormatter(subplot.xaxis.get_major_formatter(),skip_values=[0]))
+
+        else:
+            for spine in subplot.spines.values():
+                spine.set_visible(False)
+            from matplotlib.ticker import NullFormatter, NullLocator
+            subplot.xaxis.set_major_formatter(NullFormatter())
+            subplot.yaxis.set_major_formatter(NullFormatter())
+            subplot.xaxis.set_major_locator(NullLocator())
+            subplot.yaxis.set_major_locator(NullLocator())
+
+        if frame or axes:
+            # Make minor tickmarks
+            from matplotlib.ticker import AutoMinorLocator
+            subplot.xaxis.set_minor_locator(AutoMinorLocator())
+            subplot.yaxis.set_minor_locator(AutoMinorLocator())
+
+            ticklabels=subplot.xaxis.get_majorticklabels() + \
+                subplot.xaxis.get_minorticklabels() + \
+                subplot.yaxis.get_majorticklabels() + \
+                subplot.yaxis.get_minorticklabels()
+            for ticklabel in ticklabels:
+                ticklabel.set_fontsize(self.__fontsize)
+                ticklabel.set_color(self.__tick_label_color)
+
+            ticklines=subplot.xaxis.get_majorticklines() + \
+                subplot.xaxis.get_minorticklines() + \
+                subplot.yaxis.get_majorticklines() + \
+                subplot.yaxis.get_minorticklines()
+            for tickline in ticklines:
+                tickline.set_color(self.__axes_color)
+                
+            
+        if gridlines is not None:
+            if isinstance(gridlines, (list, tuple)):
+                vgridlines,hgridlines=gridlines
+            else:
+                hgridlines=gridlines
+                vgridlines=gridlines
+
+            if gridlinesstyle is None:
+                # Set up the default grid style
+                gridlinesstyle=dict(color='black',linestyle=':',linewidth=0.5)
+
+            vgridstyle=gridlinesstyle.copy()
+            if vgridlinesstyle is not None:
+                vgridstyle.update(vgridlinesstyle)
+
+            hgridstyle=gridlinesstyle.copy()
+            if hgridlinesstyle is not None:
+                hgridstyle.update(hgridlinesstyle)
+
+            if hgridlines=="minor":
+                hgridstyle['which']="minor"
+            if vgridlines=="minor":
+                vgridstyle['which']="minor"
+
+            if hasattr(hgridlines, '__iter__'):
+                hlines=iter(hgridlines)
+                hgridstyle.pop("minor",None)
+                for hline in hlines:
+                    if isinstance(hline, (list, tuple)):
+                        hl, style=hline
+                        st=hgridstyle.copy()
+                        st.update(style)
+                    else:
+                        hl=hline
+                        st=hgridstyle
+                    subplot.axhline(hl,**st)
+            else:
+                if hgridlines not in (None, False):
+                    subplot.yaxis.grid(True, **hgridstyle)
+
+            if hasattr(vgridlines, '__iter__'):
+                vlines=iter(vgridlines)
+                vgridstyle.pop("minor",None)
+                for vline in vlines:
+                    if isinstance(vline, (list, tuple)):
+                        vl, style=vline
+                        st=vgridstyle.copy()
+                        st.update(style)
+                    else:
+                        vl=vline
+                        st=vgridstyle
+                    subplot.axvline(vl,**st)
+            else:
+                if vgridlines not in (None, False):
+                    subplot.xaxis.grid(True, **vgridstyle)
+
+        if aspect_ratio is not None:
+            subplot.set_aspect(aspect_ratio)
+
+
+        if self.__axes_labels is not None:
+            label_options={}
+            label_options['color']=self.__axes_label_color
+            label_options['size']=self.__fontsize
+            subplot.set_xlabel(self.__axes_labels[0], **label_options)
+            subplot.set_ylabel(self.__axes_labels[1], **label_options)
+                
+
+            if axes is True and frame is False:
+                # We set the label positions according to how we are
+                # drawing the axes.
+                if xaxis=='bottom':
+                    yaxis_labely=1
+                    yaxis_labeloffset=8
+                    yaxis_vert='bottom'
+                    xaxis_labely=0
+                    xaxis_vert='baseline'
+                else:
+                    yaxis_labely=0
+                    yaxis_labeloffset=-8
+                    yaxis_vert='top'
+                    xaxis_labely=1
+                    xaxis_vert='top'
+
+                if yaxis=='left':
+                    xaxis_labelx=1
+                    xaxis_labeloffset=8
+                    xaxis_horiz='left'
+                    yaxis_labelx=0
+                else:
+                    xaxis_labelx=0
+                    xaxis_labeloffset=-8
+                    xaxis_horiz='right'
+                    yaxis_labelx=1
+
+                from matplotlib.transforms import offset_copy
+                xlabel=subplot.xaxis.get_label()
+                xlabel.set_horizontalalignment(xaxis_horiz)
+                xlabel.set_verticalalignment(xaxis_vert)
+                trans=subplot.spines[xaxis].get_transform()
+                labeltrans=offset_copy(trans, figure, x=xaxis_labeloffset, y=0, units='points')
+                subplot.xaxis.set_label_coords(x=xaxis_labelx,y=xaxis_labely,transform=labeltrans)
+
+                ylabel=subplot.yaxis.get_label()
+                ylabel.set_horizontalalignment('center')
+                ylabel.set_verticalalignment(yaxis_vert)
+                ylabel.set_rotation('horizontal')
+                trans=subplot.spines[yaxis].get_transform()
+                labeltrans=offset_copy(trans, figure, x=0, y=yaxis_labeloffset, units='points')
+                subplot.yaxis.set_label_coords(x=yaxis_labelx,y=yaxis_labely,transform=labeltrans)
+
+        #subplot.autoscale_view(tight=True) 
+        return figure
+
+    def save(self, filename=None, dpi=DEFAULT_DPI, savenow=True, *args, **kwds):
+        r"""
+        Save the graphics to an image file of type: PNG, PS, EPS, SVG,
+        SOBJ, depending on the file extension you give the filename.
+        Extension types can be: ``.png``, ``.ps``,
+        ``.eps``, ``.svg``, and
+        ``.sobj`` (for a Sage object you can load later).
+        
+
+        EXAMPLES::
+        
+            sage: c = circle((1,1),1,rgbcolor=(1,0,0))
+            sage: c.show(xmin=-1,xmax=3,ymin=-1,ymax=3)
+        
+        To correct the aspect ratio of certain graphics, you can 
+        set the ``aspect_ratio`` to 1
+        
+        ::
+        
+            sage: c.show(aspect_ratio=1, xmin=-1, xmax=3, ymin=-1, ymax=3)
+
+        You could also just make the dimensions of the picture square
+        using ``figsize``
+
+        ::
+
+            sage: c.show(figsize=[5,5], xmin=-1, xmax=3, ymin=-1, ymax=3)        
+
+
+        
+        ::
+        
+            sage: point((-1,1),pointsize=30, rgbcolor=(1,0,0))
+
+        By default, the figure grows to include all of the graphics
+        and text, so the final image may not be exactly the figure
+        size you specified.
+        """
         if filename is None:
             filename = sage.misc.misc.graphics_filename()
         try:
@@ -1552 +1904 @@
             SageObject.save(self, filename)
             return
 
-        self.fontsize(fontsize)
-        self.axes_labels(l=axes_labels)
+        if savenow:
+            options=dict()
+            options['transparent']=kwds.pop('transparent',False)
+            figure=self.matplotlib(*args, **kwds)
+            # 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
+            figure.set_canvas(FigureCanvasAgg(figure))
 
-        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
@@ -1680 +1927 @@
                     dpi = 100
             else:
                 raise ValueError, "file extension must be either 'png', 'ps, 'eps', 'pdf, 'svg' or 'sobj'"
-            canvas.print_figure(filename, dpi=dpi)
+            #if kwds['bbox'] is not None:
+            #    options['bbox_inches']=kwds['bbox']
+            #else:
+            #    canvas.mpl_connect('draw_event', on_draw)
+                #options['bbox_inches']=figure.get_size_inches()
+            figure.savefig(filename,dpi=dpi,bbox_inches='tight',**options)
+            #canvas.print_figure(filename, dpi=dpi,**options)
+
+
+
+from matplotlib.ticker import Formatter
+
+class SelectiveFormatter(Formatter):
+    """TODO: write documentation for each function"""
+    def __init__(self, formatter,skip_values):
+        self.formatter=formatter
+        self.skip_values=skip_values
+    def set_locs(self, locs):
+        self.formatter.set_locs([l for l in locs if l not in self.skip_values])
+    def __call__(self, x, *args, **kwds):
+        """Return the format for tick val *x* at position *pos*"""
+        if x in self.skip_values:
+            return ''
+        else:
+            return self.formatter(x, *args, **kwds)
+
+def on_draw(event):
+    """
+    TODO: write documentation
+    """
+    import matplotlib.transforms as mtransforms
+    figure=event.canvas.figure
+    bboxes = []
+    for ax in figure.axes:
+        bbox = ax.xaxis.get_label().get_window_extent()
+        # the figure transform goes from relative coords->pixels and we
+        # want the inverse of that
+        bboxi = bbox.inverse_transformed(figure.transFigure)
+        bboxes.append(bboxi)
+
+        bbox = ax.yaxis.get_label().get_window_extent()
+        bboxi = bbox.inverse_transformed(figure.transFigure)
+        bboxes.append(bboxi)
+        for label in (ax.get_xticklabels()+ax.get_yticklabels() \
+                          + ax.get_xticklabels(minor=True) \
+                          +ax.get_yticklabels(minor=True)):
+            bbox = label.get_window_extent()
+            bboxi = bbox.inverse_transformed(figure.transFigure)
+            bboxes.append(bboxi)
+    
+    # this is the bbox that bounds all the bboxes, again in relative
+    # figure coords
+    bbox = mtransforms.Bbox.union(bboxes)
+    adjusted=adjust_figure_to_contain_bbox(figure,bbox)
+    
+    if adjusted:
+        figure.canvas.draw()
+    return False
+
+def adjust_figure_to_contain_bbox(fig, bbox):
+    """
+    TODO: write documentation
+    """
+    adjusted=False
+    if bbox.xmin<0:
+        fig.subplots_adjust(left=fig.subplotpars.left-bbox.xmin)
+        adjusted=True
+    if bbox.ymin<0:
+        fig.subplots_adjust(bottom=fig.subplotpars.bottom-bbox.ymin)
+        adjusted=True
+    if bbox.xmax>1:
+        fig.subplots_adjust(right=fig.subplotpars.right-(bbox.xmax-1))
+        adjusted=True
+    if bbox.ymax>1:
+        fig.subplots_adjust(top=fig.subplotpars.top-(bbox.ymax-1))
+        adjusted=True
+    return adjusted
 
 def xydata_from_point_list(points):
     r""" 
@@ -1863 +2186 @@
     Some colored functions::
     
         sage: plot(sin, 0, 10, rgbcolor='#ff00ff')
-        sage: plot(sin, 0, 10, rgbcolor='purple')
+        sage: plot(sin, 0, 10, color='purple')
     
     We plot several functions together by passing a list of functions
     as input::
@@ -2160 +2483 @@
     fillcolor = options.pop('fillcolor', 'automatic')
     fillalpha = options.pop('fillalpha', 0.5)
 
+    # TODO: Use matplotlib's fill and fill_between commands.
     if fill is not None:
         if parametric or polar:
             filldata = data
@@ -2539 +2863 @@
         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,
-                   axes = axes,
-                   **args)#only save if i==dims.
+            g.matplotlib(filename, figure=figure, sub=subplot,
+                         verify=do_verify, axes = axes, **args)
+        g.save(filename, dpi=dpi, figure=figure, sub=subplot,
+               verify=do_verify, axes = axes, **args)
 
     def save(self, filename=None, dpi=DEFAULT_DPI, figsize=DEFAULT_FIGSIZE,
              axes = None, **args):

sage/plot/plot_field.py

@@ -126 +126 @@
         quiver_options.pop('plot_points')
         subplot.quiver(self.xpos_array, self.ypos_array, self.xvec_array, self.yvec_array, angles='xy', **quiver_options)
  
-@options(plot_points=20)
+@options(plot_points=20,frame=True)
 def plot_vector_field((f, g), xrange, yrange, **options):
     r"""
     ``plot_vector_field`` takes two functions of two variables xvar and yvar

sage/plot/point.py

@@ -268 +268 @@
         faceted = options['faceted'] #faceted=True colors the edge of point
         scatteroptions={}
         if not faceted: scatteroptions['edgecolors'] = 'none'
-
         subplot.scatter(self.xdata, self.ydata, s=s, c=c, alpha=a, **scatteroptions)
+        
 
 def point(points, **kwds):
     """