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

File trac-5448-matplotlib-axes-gridlines.patch, 33.8 KB (added by jason, 11 years ago)

apply instead of previous patch.

  • sage/plot/contour_plot.py

    # HG changeset patch
    # User Jason Grout <jason-sage@creativetrax.com>
    # Date 1250665286 18000
    # Node ID 3f382ef06a10bb95406cbcc9571715fde894fcde
    # Parent  684eea91ff224e5bc6259ca19f1576c4c082b9d3
    [mq]: new-matplotlib.patch
    
    diff -r 684eea91ff22 -r 3f382ef06a10 sage/plot/contour_plot.py
    a b  
    161161            else:
    162162                subplot.contour(self.xy_data_array, contours, cmap=cmap, extent=(x0,x1,y0,y1))
    163163
    164 @options(plot_points=25, fill=True, cmap='gray', contours=None)
     164@options(plot_points=25, fill=True, cmap='gray', contours=None,frame=True)
    165165def contour_plot(f, xrange, yrange, **options):
    166166    r"""   
    167167    ``contour_plot`` takes a function of two variables, `f(x,y)`
  • sage/plot/matrix_plot.py

    diff -r 684eea91ff22 -r 3f382ef06a10 sage/plot/matrix_plot.py
    a b  
    156156            subplot.imshow(self.xy_data_array, cmap=cmap, interpolation='nearest', extent=(0,self.xrange[1],0,self.yrange[1]))
    157157
    158158
    159 @options(cmap='gray',marker='.')
     159@options(cmap='gray',marker='.',frame=True)
    160160def matrix_plot(mat, **options):
    161161    r"""
    162162    A plot of a given matrix or 2D array.
  • sage/plot/plot.py

    diff -r 684eea91ff22 -r 3f382ef06a10 sage/plot/plot.py
    a b  
    157157Another graph::
    158158
    159159    sage: x = var('x')
    160     sage: P = plot(sin(x)/x, -4,4, rgbcolor=(0,0,1)) + \
    161     ...       plot(x*cos(x), -4,4, rgbcolor=(1,0,0)) + \
    162     ...       plot(tan(x),-4,4,rgbcolor=(0,1,0))
     160    sage: P = plot(sin(x)/x, -4,4, color='blue') + \
     161    ...       plot(x*cos(x), -4,4, color='red') + \
     162    ...       plot(tan(x),-4,4, color='green')
    163163    ...
    164164    sage: P.show(ymin=-pi,ymax=pi)
    165165
     
    198198    sage: P += plot(f, 1, 8.5, thickness=3)
    199199    sage: P    # show the result
    200200
     201
     202
    201203NUMERICAL PLOTTING:
    202204
    203205Sage also provides 2D plotting with an interface that is a likely
     
    376378   
    377379        sage: G = Graphics(); print G
    378380        Graphics object consisting of 0 graphics primitives
    379         sage: c = circle((1,1), 1)
     381        sage: c = circle((1,1), 1,aspect_ratio=1)
    380382        sage: G+=c; print G
    381383        Graphics object consisting of 1 graphics primitive
    382384   
    383385    Here we make a graphic of embedded isosceles triangles, coloring
    384386    each one with a different color as we go::
    385387   
    386         sage: h=10; c=0.4; p=0.1;
     388        sage: h=10; c=0.4; p=0.5;
    387389        sage: G = Graphics()
    388390        sage: for x in srange(1,h+1):
    389391        ...        l = [[0,x*sqrt(3)],[-x/2,-x*sqrt(3)/2],[x/2,-x*sqrt(3)/2],[0,x*sqrt(3)]]
     
    683685        ::
    684686       
    685687            sage: p = plot(sin(x), (x, 0, 10))
    686             sage: p.axes_labels(['x','y'])
     688            sage: p.axes_labels(['$x$','$y$'])
    687689            sage: p.axes_labels()
    688             ('x', 'y')
     690            ('$x$', '$y$')
    689691       
    690692        Now when you plot p, you see x and y axes labels::
    691693       
     
    11491151                        dpi=DEFAULT_DPI, axes=None, axes_labels=None,frame=False,
    11501152                        fontsize=None, aspect_ratio=None,
    11511153                        gridlines=None, gridlinesstyle=None,
    1152                         vgridlinesstyle=None, hgridlinesstyle=None)
     1154                        vgridlinesstyle=None, hgridlinesstyle=None,transparent=False)
    11531155
    11541156    def show(self, **kwds):
    11551157        """
     
    11841186
    11851187        - ``gridlines`` - (default: None) can be any of the following:
    11861188
    1187           -  None, False: do not add grid lines.
     1189          - None, False: do not add grid lines.
    11881190
    11891191          - True, "automatic", "major": add grid lines at major ticks of the axes.
    11901192
     
    12161218        - ``linkmode`` - (default: False) If True a string containing a link
    12171219            to the produced file is returned.
    12181220
     1221        - ``transparent`` - (default: False) If True, make the background transparent.
     1222
    12191223        EXAMPLES::
    12201224       
    12211225            sage: c = circle((1,1), 1, rgbcolor=(1,0,0))
    12221226            sage: c.show(xmin=-1, xmax=3, ymin=-1, ymax=3)
    12231227       
    1224         To correct the aspect ratio of certain graphics, it is necessary to
    1225         show with a '``figsize``' of square dimensions.
     1228        To correct the aspect ratio of certain graphics, you can
     1229        set the ``aspect_ratio`` to 1
    12261230       
    12271231        ::
    12281232       
    1229             sage: c.show(figsize=[5,5], xmin=-1, xmax=3, ymin=-1, ymax=3)
     1233            sage: c.show(aspect_ratio=1, xmin=-1, xmax=3, ymin=-1, ymax=3)
     1234
     1235        You could also just make the dimensions of the picture square
     1236        using ``figsize``
     1237
     1238        ::
     1239
     1240            sage: c.show(figsize=[5,5], xmin=-1, xmax=3, ymin=-1, ymax=3)       
    12301241       
    12311242        You can turn off the drawing of the axes::
    12321243       
    12331244            sage: show(plot(sin,-4,4), axes=False)
    12341245       
    1235         You can also label the axes::
     1246        You can also label the axes.  Putting something in dollar
     1247        signs formats it as a mathemtical expression::
    12361248       
    1237             sage: show(plot(sin,-4,4), axes_labels=('x','y'))
     1249            sage: show(plot(sin,-4,4), axes_labels=('$x$','$y$'))
    12381250       
    12391251        You can turn on the drawing of a frame around the plots::
    12401252       
    12411253            sage: show(plot(sin,-4,4), frame=True)
    12421254       
    1243         Add grid lines at the major ticks of the axes.
     1255        You can make the background transparent::
     1256
     1257            sage: plot(sin(x), (x, -4, 4), transparent=True)
     1258
     1259        Add grid lines at the major ticks of the axes.
    12441260       
    12451261        ::
    12461262       
     
    13241340            ...     (0,{"color":"blue","linestyle":"--"})
    13251341            ...    ],
    13261342            ...    [
    1327             ...     (-1,{"rgbcolor":"red","linestyle":":"}),
     1343            ...     (-1,{"color":"red","linestyle":":"}),
    13281344            ...     (0,{"color":"blue","linestyle":"--"}),
    1329             ...     (1,{"rgbcolor":"red","linestyle":":"}),
     1345            ...     (1,{"color":"red","linestyle":":"}),
    13301346            ...    ]
    13311347            ...    ),
    1332             ...    gridlinesstyle=dict(marker='x',rgbcolor="black"))
     1348            ...    gridlinesstyle=dict(marker='x',color="black"))
    13331349       
    13341350        Grid lines can be added to contour plots.
    13351351       
     
    13371353       
    13381354            sage: f = sin(x^2 + y^2)*cos(x)*sin(y)
    13391355            sage: c = contour_plot(f, (x, -4, 4), (y, -4, 4), plot_points=100)
    1340             sage: c.show(gridlines=True, gridlinesstyle={'linestyle':':','linewidth':1, 'rgbcolor':'red'})
     1356            sage: c.show(gridlines=True, gridlinesstyle={'linestyle':':','linewidth':1, 'color':'red'})
    13411357       
    13421358        Grid lines can be added to matrix plots.
    13431359       
     
    14911507            ymax += 1
    14921508        return {'xmin':xmin, 'xmax':xmax, 'ymin':ymin, 'ymax':ymax}
    14931509       
    1494     def save(self, filename=None,
     1510    def matplotlib(self, filename=None,
    14951511             xmin=None, xmax=None, ymin=None, ymax=None,
    1496              figsize=DEFAULT_FIGSIZE, figure=None, sub=None, savenow=True,
    1497              dpi=DEFAULT_DPI, axes=None, axes_labels=None, fontsize=None,
     1512             figsize=None, figure=None, sub=None,
     1513              axes=None, axes_labels=None, fontsize=None,
    14981514             frame=False, verify=True, aspect_ratio = None,
    14991515             gridlines=None, gridlinesstyle=None,
    15001516             vgridlinesstyle=None, hgridlinesstyle=None):
    15011517        r"""
     1518        Return a matplotlib figure object representing the graphic
     1519
    15021520        Save the graphics to an image file of type: PNG, PS, EPS, SVG,
    15031521        SOBJ, depending on the file extension you give the filename.
    15041522        Extension types can be: ``.png``, ``.ps``,
     
    15101528            sage: c = circle((1,1),1,rgbcolor=(1,0,0))
    15111529            sage: c.show(xmin=-1,xmax=3,ymin=-1,ymax=3)
    15121530       
    1513         To correct the aspect ratio of certain graphics, it is necessary to
    1514         show with a '``figsize``' of square dimensions.
     1531        To correct the aspect ratio of certain graphics, you can
     1532        set the ``aspect_ratio`` to 1
    15151533       
    15161534        ::
    15171535       
    1518             sage: c.show(figsize=[5,5],xmin=-1,xmax=3,ymin=-1,ymax=3)
     1536            sage: c.show(aspect_ratio=1, xmin=-1, xmax=3, ymin=-1, ymax=3)
     1537
     1538        You could also just make the dimensions of the picture square
     1539        using ``figsize``.
     1540
     1541        ::
     1542
     1543            sage: c.show(figsize=[5,5], xmin=-1, xmax=3, ymin=-1, ymax=3)
     1544
     1545
    15191546       
    15201547        ::
    15211548       
    15221549            sage: point((-1,1),pointsize=30, rgbcolor=(1,0,0))
     1550
     1551        By default, graphics expand to include all elements in the
     1552        picture, so the dimensions might be different than what is
     1553        explicitly specified.
    15231554        """
    15241555        self.set_axes_range(xmin, xmax, ymin, ymax)
    15251556        d = self.get_axes_range()
     
    15271558        xmax = d['xmax']
    15281559        ymin = d['ymin']
    15291560        ymax = d['ymax']
     1561       
     1562        yrange=ymax-ymin
     1563        snap=yrange*.01
    15301564
    1531         # adjust the figsize in case the user also specifies an aspect ratio
    1532         if aspect_ratio is None:
    1533             aspect_ratio = self.aspect_ratio()
    1534         figsize = adjust_figsize_for_aspect_ratio(figsize, aspect_ratio, xmin=xmin,
    1535                                                   xmax=xmax, ymin=ymin, ymax=ymax)
     1565        # include y=0 in the range if ymin or ymax is close enough to zero
     1566        if 0<ymin<snap:
     1567            ymin=0
     1568        if -snap<ymax<0:
     1569            ymax=0
     1570       
     1571        self.set_axes_range(xmin,xmax,ymin,ymax)
    15361572       
    15371573        global do_verify
    15381574        do_verify = verify
     
    15401576        if axes is None:
    15411577            axes = self.__show_axes
    15421578
    1543         from matplotlib.figure import Figure
     1579        from matplotlib.figure import Figure, figaspect
     1580        self.fontsize(fontsize)
     1581        self.axes_labels(l=axes_labels)
     1582
     1583        # adjust the figsize in case the user also specifies an aspect ratio
     1584        if aspect_ratio is None:
     1585            aspect_ratio = self.aspect_ratio()
     1586
     1587        # We try to accommodate both a demand for aspect ratio and
     1588        # for a figure size by adjusting the figure size to have
     1589        # the right aspect ratio.
     1590        if figsize is None:
     1591            figsize=DEFAULT_FIGSIZE
     1592        figsize=adjust_figsize_for_aspect_ratio(figsize, aspect_ratio,
     1593                                                xmin=xmin, xmax=xmax,
     1594                                                ymin=ymin, ymax=ymax)
     1595
     1596        if figure is None:
     1597            figure=Figure(figsize)
     1598       
     1599        #the incoming subplot instance
     1600        subplot = sub
     1601        if not subplot:
     1602            subplot = figure.add_subplot(111)
     1603            if aspect_ratio is not None:
     1604                subplot.set_aspect('auto')
     1605
     1606        #add all the primitives to the subplot
     1607        for g in self.__objects:
     1608            g._render_on_subplot(subplot)
     1609       
     1610           
     1611        subplot.set_xlim([xmin, xmax])
     1612        subplot.set_ylim([ymin,ymax])
     1613
     1614        if axes is None:
     1615            axes = self.__show_axes
     1616
     1617        for spine in subplot.spines.values():
     1618            spine.set_color(self.__axes_color)
     1619            spine.set_linewidth(self.__axes_width)
     1620       
     1621
     1622        if frame:
     1623            # For now, set the formatter to the old one, since that is
     1624            # sort of what we are used to.  We should eventually look at
     1625            # the default one to see if we like it better.
     1626            from matplotlib.ticker import OldScalarFormatter
     1627            subplot.xaxis.set_major_formatter(OldScalarFormatter())
     1628            subplot.yaxis.set_major_formatter(OldScalarFormatter())
     1629           
     1630            subplot.set_frame_on(True)
     1631            if axes:
     1632                if ymin<=0 and ymax>=0:
     1633                    subplot.axhline(color=self.__axes_color,
     1634                                    linewidth=self.__axes_width)
     1635                if xmin<=0 and xmax>=0:
     1636                    subplot.axvline(color=self.__axes_color,
     1637                                    linewidth=self.__axes_width)
     1638           
     1639        elif axes:
     1640            ymiddle=False
     1641            xmiddle=False
     1642            if xmin>0:
     1643                subplot.spines['right'].set_visible(False)
     1644                subplot.spines['left'].set_position(('outward',10))
     1645                subplot.yaxis.set_ticks_position('left')
     1646                subplot.yaxis.set_label_position('left')
     1647                yaxis='left'
     1648            elif xmax<0:
     1649                subplot.spines['left'].set_visible(False)
     1650                subplot.spines['right'].set_position(('outward',10))
     1651                subplot.yaxis.set_ticks_position('right')
     1652                subplot.yaxis.set_label_position('right')
     1653                yaxis='right'
     1654            else:
     1655                subplot.spines['left'].set_position('zero')
     1656                subplot.yaxis.set_ticks_position('left')
     1657                subplot.yaxis.set_label_position('left')
     1658                subplot.spines['right'].set_visible(False)
     1659                ymiddle=True
     1660                yaxis='left'
     1661
     1662            if ymin>0:
     1663                subplot.spines['top'].set_visible(False)
     1664                subplot.spines['bottom'].set_position(('outward',10))
     1665                subplot.xaxis.set_ticks_position('bottom')
     1666                subplot.xaxis.set_label_position('bottom')
     1667                xaxis='bottom'
     1668            elif ymax<0:
     1669                subplot.spines['bottom'].set_visible(False)
     1670                subplot.spines['top'].set_position(('outward',10))
     1671                subplot.xaxis.set_ticks_position('top')
     1672                subplot.xaxis.set_label_position('top')
     1673                xaxis='top'
     1674            else:
     1675                subplot.spines['bottom'].set_position('zero')
     1676                subplot.xaxis.set_ticks_position('bottom')
     1677                subplot.xaxis.set_label_position('bottom')
     1678                subplot.spines['top'].set_visible(False)
     1679                xmiddle=True
     1680                xaxis='bottom'
     1681           
     1682            # For now, set the formatter to the old one, since that is
     1683            # sort of what we are used to.  We should eventually look at
     1684            # the default one to see if we like it better.
     1685            from matplotlib.ticker import OldScalarFormatter
     1686            subplot.xaxis.set_major_formatter(OldScalarFormatter())
     1687            subplot.yaxis.set_major_formatter(OldScalarFormatter())
     1688
     1689
     1690            # Make ticklines go on both sides of the axes
     1691            #             if xmiddle:
     1692            #                 for t in subplot.xaxis.get_majorticklines():
     1693            #                     t.set_marker("|")
     1694            #                     t.set_markersize(8)
     1695            #                 for t in subplot.xaxis.get_minorticklines():
     1696            #                     t.set_marker("|")
     1697            #                     t.set_markersize(4)
     1698           
     1699            #             if ymiddle:
     1700            #                 for t in subplot.yaxis.get_majorticklines():
     1701            #                     t.set_marker("|")
     1702            #                     t.set_markersize(8)
     1703            #                 for t in subplot.yaxis.get_minorticklines():
     1704            #                     t.set_marker("|")
     1705            #                     t.set_markersize(4)
     1706           
     1707            # Make the zero tick labels disappear if the axes cross
     1708            # inside the picture
     1709            if xmiddle and ymiddle:
     1710                subplot.yaxis.set_major_formatter(SelectiveFormatter(subplot.yaxis.get_major_formatter(),skip_values=[0]))
     1711                subplot.xaxis.set_major_formatter(SelectiveFormatter(subplot.xaxis.get_major_formatter(),skip_values=[0]))
     1712
     1713        else:
     1714            for spine in subplot.spines.values():
     1715                spine.set_visible(False)
     1716            from matplotlib.ticker import NullFormatter, NullLocator
     1717            subplot.xaxis.set_major_formatter(NullFormatter())
     1718            subplot.yaxis.set_major_formatter(NullFormatter())
     1719            subplot.xaxis.set_major_locator(NullLocator())
     1720            subplot.yaxis.set_major_locator(NullLocator())
     1721
     1722        if frame or axes:
     1723            # Make minor tickmarks
     1724            from matplotlib.ticker import AutoMinorLocator
     1725            subplot.xaxis.set_minor_locator(AutoMinorLocator())
     1726            subplot.yaxis.set_minor_locator(AutoMinorLocator())
     1727
     1728            label_options={}
     1729            label_options['color']=self.__axes_label_color
     1730            label_options['size']=self.__fontsize
     1731            if self.__axes_labels is not None:
     1732                subplot.set_xlabel(self.__axes_labels[0], **label_options)
     1733                subplot.set_ylabel(self.__axes_labels[1], **label_options)
     1734               
     1735            ticklabels=subplot.xaxis.get_majorticklabels() + \
     1736                subplot.xaxis.get_minorticklabels() + \
     1737                subplot.yaxis.get_majorticklabels() + \
     1738                subplot.yaxis.get_minorticklabels()
     1739            for ticklabel in ticklabels:
     1740                ticklabel.set_fontsize(self.__fontsize)
     1741                ticklabel.set_color(self.__tick_label_color)
     1742
     1743            ticklines=subplot.xaxis.get_majorticklines() + \
     1744                subplot.xaxis.get_minorticklines() + \
     1745                subplot.yaxis.get_majorticklines() + \
     1746                subplot.yaxis.get_minorticklines()
     1747            for tickline in ticklines:
     1748                tickline.set_color(self.__axes_color)
     1749               
     1750           
     1751        if gridlines is not None:
     1752            if isinstance(gridlines, (list, tuple)):
     1753                vgridlines,hgridlines=gridlines
     1754            else:
     1755                hgridlines=gridlines
     1756                vgridlines=gridlines
     1757
     1758            if gridlinesstyle is None:
     1759                # Set up the default grid style
     1760                gridlinesstyle=dict(color='black',linestyle=':',linewidth=0.5)
     1761
     1762            vgridstyle=gridlinesstyle.copy()
     1763            if vgridlinesstyle is not None:
     1764                vgridstyle.update(vgridlinesstyle)
     1765
     1766            hgridstyle=gridlinesstyle.copy()
     1767            if hgridlinesstyle is not None:
     1768                hgridstyle.update(hgridlinesstyle)
     1769
     1770            if hgridlines=="minor":
     1771                hgridstyle['which']="minor"
     1772            if vgridlines=="minor":
     1773                vgridstyle['which']="minor"
     1774
     1775            if hasattr(hgridlines, '__iter__'):
     1776                hlines=iter(hgridlines)
     1777                hgridstyle.pop("minor",None)
     1778                for hline in hlines:
     1779                    if isinstance(hline, (list, tuple)):
     1780                        hl, style=hline
     1781                        st=hgridstyle.copy()
     1782                        st.update(style)
     1783                    else:
     1784                        hl=hline
     1785                        st=hgridstyle
     1786                    subplot.axhline(hl,**st)
     1787            else:
     1788                if hgridlines not in (None, False):
     1789                    subplot.yaxis.grid(True, **hgridstyle)
     1790
     1791            if hasattr(vgridlines, '__iter__'):
     1792                vlines=iter(vgridlines)
     1793                vgridstyle.pop("minor",None)
     1794                for vline in vlines:
     1795                    if isinstance(vline, (list, tuple)):
     1796                        vl, style=vline
     1797                        st=vgridstyle.copy()
     1798                        st.update(style)
     1799                    else:
     1800                        vl=vline
     1801                        st=vgridstyle
     1802                    subplot.axvline(vl,**st)
     1803            else:
     1804                if vgridlines not in (None, False):
     1805                    subplot.xaxis.grid(True, **vgridstyle)
     1806
     1807        if aspect_ratio is not None:
     1808            subplot.set_aspect(aspect_ratio)
     1809
     1810
     1811        if axes is True and frame is False:
     1812            # Get the axis labels right where we want them,
     1813            # right off the end of the positive axes
     1814
     1815            from matplotlib.transforms import offset_copy
     1816            xlabel=subplot.xaxis.get_label()
     1817            xlabel.set_horizontalalignment('left')
     1818            xlabel.set_verticalalignment('baseline')
     1819            trans=subplot.spines[xaxis].get_transform()
     1820            labeltrans=offset_copy(trans, figure, x=8, y=0, units='points')
     1821            subplot.xaxis.set_label_coords(x=1,y=0,transform=labeltrans)
     1822
     1823            ylabel=subplot.yaxis.get_label()
     1824            ylabel.set_horizontalalignment('center')
     1825            ylabel.set_verticalalignment('center')
     1826            ylabel.set_rotation('horizontal')
     1827            trans=subplot.spines[yaxis].get_transform()
     1828            labeltrans=offset_copy(trans, figure, x=0, y=12, units='points')
     1829            subplot.yaxis.set_label_coords(x=0,y=1,transform=labeltrans)
     1830
     1831        #subplot.autoscale_view(tight=True)
     1832        return figure
     1833
     1834    def save(self, filename=None, dpi=DEFAULT_DPI, savenow=True, *args, **kwds):
     1835        r"""
     1836        Save the graphics to an image file of type: PNG, PS, EPS, SVG,
     1837        SOBJ, depending on the file extension you give the filename.
     1838        Extension types can be: ``.png``, ``.ps``,
     1839        ``.eps``, ``.svg``, and
     1840        ``.sobj`` (for a Sage object you can load later).
     1841       
     1842
     1843        EXAMPLES::
     1844       
     1845            sage: c = circle((1,1),1,rgbcolor=(1,0,0))
     1846            sage: c.show(xmin=-1,xmax=3,ymin=-1,ymax=3)
     1847       
     1848        To correct the aspect ratio of certain graphics, you can
     1849        set the ``aspect_ratio`` to 1
     1850       
     1851        ::
     1852       
     1853            sage: c.show(aspect_ratio=1, xmin=-1, xmax=3, ymin=-1, ymax=3)
     1854
     1855        You could also just make the dimensions of the picture square
     1856        using ``figsize``
     1857
     1858        ::
     1859
     1860            sage: c.show(figsize=[5,5], xmin=-1, xmax=3, ymin=-1, ymax=3)       
     1861
     1862
     1863       
     1864        ::
     1865       
     1866            sage: point((-1,1),pointsize=30, rgbcolor=(1,0,0))
     1867
     1868        By default, the figure grows to include all of the graphics
     1869        and text, so the final image may not be exactly the figure
     1870        size you specified.
     1871        """
    15441872        if filename is None:
    15451873            filename = sage.misc.misc.graphics_filename()
    15461874        try:
     
    15521880            SageObject.save(self, filename)
    15531881            return
    15541882
    1555         self.fontsize(fontsize)
    1556         self.axes_labels(l=axes_labels)
     1883        if savenow:
     1884            options=dict()
     1885            options['transparent']=kwds.pop('transparent',False)
     1886            figure=self.matplotlib(*args, **kwds)
     1887            # You can output in PNG, PS, EPS, PDF, or SVG format, depending on the file extension.
     1888            # matplotlib looks at the file extension to see what the renderer should be.
     1889            # The default is FigureCanvasAgg for PNG's because this is by far the most
     1890            # common type of files rendered, like in the notebook, for example.
     1891            # if the file extension is not '.png', then matplotlib will handle it.
     1892            from matplotlib.backends.backend_agg import FigureCanvasAgg
     1893            figure.set_canvas(FigureCanvasAgg(figure))
    15571894
    1558         if figure is None:
    1559             figure = Figure(figsize)
    1560 
    1561         #The line below takes away the excessive whitespace around
    1562         #images.  ('figsize' and  'dpi' still work as expected):
    1563         figure.subplots_adjust(left=0.04, bottom=0.04, right=0.96, top=0.96)
    1564        
    1565         #the incoming subplot instance
    1566         subplot = sub
    1567         if not subplot:
    1568             subplot = figure.add_subplot(111)
    1569 
    1570         #take away the matplotlib axes:
    1571         subplot.xaxis.set_visible(False)
    1572         subplot.yaxis.set_visible(False)
    1573         subplot.set_frame_on(False)
    1574 
    1575         #add all the primitives to the subplot
    1576         #check if there are any ContourPlot instances
    1577         #in self._objects, and if so change the axes
    1578         #to be frame axes instead of centered axes
    1579         contour = False
    1580         plotfield = False
    1581         matrixplot = False
    1582         from contour_plot import ContourPlot
    1583         from matrix_plot import MatrixPlot
    1584         from plot_field import PlotField
    1585         for g in self.__objects:
    1586             if isinstance(g, ContourPlot):
    1587                 contour = True
    1588             if isinstance(g, PlotField):
    1589                 plotfield = True
    1590             if isinstance(g, MatrixPlot):
    1591                 matrixplot = True
    1592             g._render_on_subplot(subplot)
    1593        
    1594         #adjust the xy limits and draw the axes:
    1595         if axes is None:
    1596             axes = self.__show_axes
    1597 
    1598         #construct an Axes instance, see 'axes.py' for relevant code
    1599         sage_axes = Axes(color=self.__axes_color, fontsize=self.__fontsize,
    1600                          axes_labels=self.__axes_labels,
    1601                          axes_label_color=self.__axes_label_color,
    1602                          tick_label_color=self.__tick_label_color, linewidth=self.__axes_width)
    1603 
    1604         # construct a GridLines instance, see 'axes.py' for relevant code
    1605         sage_gridlines = GridLines(gridlines=gridlines, gridlinesstyle=gridlinesstyle,
    1606                 vgridlinesstyle=vgridlinesstyle, hgridlinesstyle=hgridlinesstyle)
    1607 
    1608         #adjust the xy limits and draw the axes:
    1609         if not (contour or plotfield or matrixplot): #the plot is a 'regular' plot
    1610             xmin -= 0.1*(xmax-xmin)
    1611             xmax += 0.1*(xmax-xmin)
    1612             ymin -= 0.1*(ymax-ymin)
    1613             ymax += 0.1*(ymax-ymin)
    1614             if frame: #add the frame axes
    1615                 axmin, axmax = xmin - 0.04*abs(xmax - xmin), xmax + 0.04*abs(xmax - xmin)
    1616                 aymin, aymax = ymin - 0.04*abs(ymax - ymin), ymax + 0.04*abs(ymax - ymin)
    1617                 subplot.set_xlim([axmin, axmax])
    1618                 subplot.set_ylim([aymin, aymax])
    1619                 # draw the grid
    1620                 sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, True)
    1621                 #add a frame to the plot and possibly 'axes_with_no_ticks'
    1622                 sage_axes.add_xy_frame_axes(subplot, xmin, xmax, ymin, ymax,
    1623                                         axes_with_no_ticks=axes)
    1624 
    1625             elif not frame and axes: #regular plot with regular axes
    1626                 # draw the grid
    1627                 sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, False)
    1628                 # draw the axes
    1629                 xmin, xmax, ymin, ymax = sage_axes.add_xy_axes(subplot, xmin, xmax, ymin, ymax)
    1630                 subplot.set_xlim(xmin, xmax)
    1631                 subplot.set_ylim(ymin, ymax)
    1632                
    1633             else: #regular plot with no axes
    1634                 subplot.set_xlim(xmin, xmax)
    1635                 subplot.set_ylim(ymin, ymax)
    1636                 # draw the grid
    1637                 sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, False)
    1638                
    1639         elif (contour or plotfield): #contour or field plot in self.__objects, so adjust axes accordingly
    1640             subplot.set_xlim([xmin - 0.05*abs(xmax - xmin), xmax + 0.05*abs(xmax - xmin)])
    1641             subplot.set_ylim([ymin - 0.05*abs(ymax - ymin), ymax + 0.05*abs(ymax - ymin)])
    1642             # draw the grid
    1643             sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, True)
    1644             # draw the axes
    1645             if axes: #axes=True unless user specifies axes=False
    1646                 sage_axes.add_xy_frame_axes(subplot, xmin, xmax, ymin, ymax)
    1647                
    1648         else: #we have a 'matrix_plot' in self.__objects, so adjust axes accordingly
    1649             subplot.set_xlim([xmin - 0.05*abs(xmax - xmin), xmax + 0.05*abs(xmax - xmin)])
    1650             subplot.set_ylim([ymin - 0.05*abs(ymax - ymin), ymax + 0.05*abs(ymax - ymin)])
    1651             # draw the grid
    1652             if gridlines in ["major", "automatic", True]:
    1653                 gridlines = [sage.misc.misc.srange(-0.5,xmax+1,1),
    1654                         sage.misc.misc.srange(-0.5,ymax+1,1)]
    1655             sage_gridlines = GridLines(gridlines=gridlines,
    1656                     gridlinesstyle=gridlinesstyle,
    1657                     vgridlinesstyle=vgridlinesstyle,
    1658                     hgridlinesstyle=hgridlinesstyle)
    1659             sage_gridlines.add_gridlines(subplot, xmin, xmax, ymin, ymax, False)
    1660             # draw the axes
    1661             if axes: #axes=True unless user specifies axes=False
    1662                 sage_axes.add_xy_matrix_frame_axes(subplot, xmin, xmax, ymin, ymax)
    1663 
    1664         # You can output in PNG, PS, EPS, PDF, or SVG format, depending on the file extension.
    1665         # matplotlib looks at the file extension to see what the renderer should be.
    1666         # The default is FigureCanvasAgg for PNG's because this is by far the most
    1667         # common type of files rendered, like in the Notebook for example.
    1668         # if the file extension is not '.png', then matplotlib will handle it.
    1669         if savenow:
    1670             from matplotlib.backends.backend_agg import FigureCanvasAgg
    1671             canvas = FigureCanvasAgg(figure)
    16721895            if ext in ['.eps', '.ps', '.pdf']:
    16731896                if dpi is None:
    16741897                    dpi = 72
     
    16801903                    dpi = 100
    16811904            else:
    16821905                raise ValueError, "file extension must be either 'png', 'ps, 'eps', 'pdf, 'svg' or 'sobj'"
    1683             canvas.print_figure(filename, dpi=dpi)
     1906            #if kwds['bbox'] is not None:
     1907            #    options['bbox_inches']=kwds['bbox']
     1908            #else:
     1909            #    canvas.mpl_connect('draw_event', on_draw)
     1910                #options['bbox_inches']=figure.get_size_inches()
     1911            figure.savefig(filename,dpi=dpi,bbox_inches='tight')
     1912            #canvas.print_figure(filename, dpi=dpi,**options)
     1913
     1914
     1915
     1916from matplotlib.ticker import Formatter
     1917
     1918class SelectiveFormatter(Formatter):
     1919    """TODO: write documentation for each function"""
     1920    def __init__(self, formatter,skip_values):
     1921        self.formatter=formatter
     1922        self.skip_values=skip_values
     1923    def set_locs(self, locs):
     1924        self.formatter.set_locs([l for l in locs if l not in self.skip_values])
     1925    def __call__(self, x, *args, **kwds):
     1926        """Return the format for tick val *x* at position *pos*"""
     1927        if x in self.skip_values:
     1928            return ''
     1929        else:
     1930            return self.formatter(x, *args, **kwds)
     1931
     1932def on_draw(event):
     1933    """
     1934    TODO: write documentation
     1935    """
     1936    import matplotlib.transforms as mtransforms
     1937    figure=event.canvas.figure
     1938    bboxes = []
     1939    for ax in figure.axes:
     1940        bbox = ax.xaxis.get_label().get_window_extent()
     1941        # the figure transform goes from relative coords->pixels and we
     1942        # want the inverse of that
     1943        bboxi = bbox.inverse_transformed(figure.transFigure)
     1944        bboxes.append(bboxi)
     1945
     1946        bbox = ax.yaxis.get_label().get_window_extent()
     1947        bboxi = bbox.inverse_transformed(figure.transFigure)
     1948        bboxes.append(bboxi)
     1949        for label in (ax.get_xticklabels()+ax.get_yticklabels() \
     1950                          + ax.get_xticklabels(minor=True) \
     1951                          +ax.get_yticklabels(minor=True)):
     1952            bbox = label.get_window_extent()
     1953            bboxi = bbox.inverse_transformed(figure.transFigure)
     1954            bboxes.append(bboxi)
     1955   
     1956    # this is the bbox that bounds all the bboxes, again in relative
     1957    # figure coords
     1958    bbox = mtransforms.Bbox.union(bboxes)
     1959    adjusted=adjust_figure_to_contain_bbox(figure,bbox)
     1960   
     1961    if adjusted:
     1962        figure.canvas.draw()
     1963    return False
     1964
     1965def adjust_figure_to_contain_bbox(fig, bbox):
     1966    """
     1967    TODO: write documentation
     1968    """
     1969    adjusted=False
     1970    if bbox.xmin<0:
     1971        fig.subplots_adjust(left=fig.subplotpars.left-bbox.xmin)
     1972        adjusted=True
     1973    if bbox.ymin<0:
     1974        fig.subplots_adjust(bottom=fig.subplotpars.bottom-bbox.ymin)
     1975        adjusted=True
     1976    if bbox.xmax>1:
     1977        fig.subplots_adjust(right=fig.subplotpars.right-(bbox.xmax-1))
     1978        adjusted=True
     1979    if bbox.ymax>1:
     1980        fig.subplots_adjust(top=fig.subplotpars.top-(bbox.ymax-1))
     1981        adjusted=True
     1982    return adjusted
    16841983
    16851984def xydata_from_point_list(points):
    16861985    r"""
     
    18632162    Some colored functions::
    18642163   
    18652164        sage: plot(sin, 0, 10, rgbcolor='#ff00ff')
    1866         sage: plot(sin, 0, 10, rgbcolor='purple')
     2165        sage: plot(sin, 0, 10, color='purple')
    18672166   
    18682167    We plot several functions together by passing a list of functions
    18692168    as input::
     
    21602459    fillcolor = options.pop('fillcolor', 'automatic')
    21612460    fillalpha = options.pop('fillalpha', 0.5)
    21622461
     2462    # TODO: Use matplotlib's fill and fill_between commands.
    21632463    if fill is not None:
    21642464        if parametric or polar:
    21652465            filldata = data
     
    25392839        do_verify = True
    25402840        for i,g in zip(range(1, dims+1), glist):
    25412841            subplot = figure.add_subplot(rows, cols, i)
    2542             g.save(filename, dpi=dpi, figure=figure, sub=subplot,
    2543                    savenow = (i==dims), verify=do_verify,
    2544                    axes = axes,
    2545                    **args)#only save if i==dims.
     2842            g.matplotlib(filename, figure=figure, sub=subplot,
     2843                         verify=do_verify, axes = axes, **args)
     2844        g.save(filename, dpi=dpi, figure=figure, sub=subplot,
     2845               verify=do_verify, axes = axes, **args)
    25462846
    25472847    def save(self, filename=None, dpi=DEFAULT_DPI, figsize=DEFAULT_FIGSIZE,
    25482848             axes = None, **args):
  • sage/plot/plot_field.py

    diff -r 684eea91ff22 -r 3f382ef06a10 sage/plot/plot_field.py
    a b  
    126126        quiver_options.pop('plot_points')
    127127        subplot.quiver(self.xpos_array, self.ypos_array, self.xvec_array, self.yvec_array, angles='xy', **quiver_options)
    128128 
    129 @options(plot_points=20)
     129@options(plot_points=20,frame=True)
    130130def plot_vector_field((f, g), xrange, yrange, **options):
    131131    r"""
    132132    ``plot_vector_field`` takes two functions of two variables xvar and yvar
  • sage/plot/point.py

    diff -r 684eea91ff22 -r 3f382ef06a10 sage/plot/point.py
    a b  
    268268        faceted = options['faceted'] #faceted=True colors the edge of point
    269269        scatteroptions={}
    270270        if not faceted: scatteroptions['edgecolors'] = 'none'
    271 
    272271        subplot.scatter(self.xdata, self.ydata, s=s, c=c, alpha=a, **scatteroptions)
     272       
    273273
    274274def point(points, **kwds):
    275275    """