Updated some of the examples.

Author: pelson

examples/pylab_examples/legend_demo.py

@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 # Thanks to Charles Twardy for this example
 #
-#See http://matplotlib.sf.net/examples/legend_demo2.py for an example
-#controlling which lines the legend uses and the order
+#See http://matplotlib.org/examples/pylab_examples/legend_demo2.html
+# for an example controlling which lines the legend uses and the order
+# they are drawn in.
 
 import numpy as np
 import matplotlib.pyplot as plt

examples/pylab_examples/legend_demo2.py

@@ -1,24 +1,23 @@
-#!/usr/bin/env python
-#
 # Make a legend for specific lines.
-from pylab import *
+import matplotlib.pyplot as plt
+import numpy as np
 
-t1 = arange(0.0, 2.0, 0.1)
-t2 = arange(0.0, 2.0, 0.01)
+
+t1 = np.arange(0.0, 2.0, 0.1)
+t2 = np.arange(0.0, 2.0, 0.01)
 
 # note that plot returns a list of lines.  The "l1, = plot" usage
-# extracts the first element of the list inot l1 using tuple
+# extracts the first element of the list into l1 using tuple
 # unpacking.  So l1 is a Line2D instance, not a sequence of lines
-l1,    = plot(t2, exp(-t2))
-l2, l3 = plot(t2, sin(2*pi*t2), '--go', t1, log(1+t1), '.')
-l4,    = plot(t2, exp(-t2)*sin(2*pi*t2), 'rs-.')
+l1, = plt.plot(t2, np.exp(-t2))
+l2, l3 = plt.plot(t2, np.sin(2 * np.pi * t2), '--go', t1, np.log(1 + t1), '.')
+l4, = plt.plot(t2, np.exp(-t2) * np.sin(2 * np.pi * t2), 'rs-.')
 
-legend( (l2, l4), ('oscillatory', 'damped'), 'upper right', shadow=True)
-xlabel('time')
-ylabel('volts')
-title('Damped oscillation')
-#axis([0,2,-1,1])
-show()
+plt.legend( (l2, l4), ('oscillatory', 'damped'), 'upper right', shadow=True)
+plt.xlabel('time')
+plt.ylabel('volts')
+plt.title('Damped oscillation')
+plt.show()
 
 
 

examples/pylab_examples/pcolormesh_levels.py

@@ -0,0 +1,53 @@
+"""
+Shows how to combine Normalization and Colormap instances to draw
+"levels" in pcolor, pcolormesh and imshow type plots in a similar
+way to the levels keyword argument to contour/contourf.
+
+"""
+
+import matplotlib.pyplot as plt
+from matplotlib.colors import BoundaryNorm
+from matplotlib.ticker import MaxNLocator
+import numpy as np
+
+
+# make these smaller to increase the resolution
+dx, dy = 0.05, 0.05
+
+# generate 2 2d grids for the x & y bounds
+y, x = np.mgrid[slice(1, 5 + dy, dy),
+                slice(1, 5 + dx, dx)]
+
+z = np.sin(x) ** 10 + np.cos(10 + y * x) * np.cos(x)
+
+# x and y are bounds, so z should be the value *inside* those bounds.
+# Therefore, remove the last value from the z array.
+z = z[:-1, :-1]
+levels = MaxNLocator(nbins=15).tick_values(z.min(), z.max())
+
+
+# pick the desired colormap, sensible levels, and define a normalization
+# instance which takes data values and translates those into levels.
+cmap = plt.get_cmap('PiYG')
+norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)
+
+plt.subplot(2, 1, 1)
+im = plt.pcolormesh(x, y, z, cmap=cmap, norm=norm)
+plt.colorbar()
+# set the limits of the plot to the limits of the data
+plt.axis([x.min(), x.max(), y.min(), y.max()])
+plt.title('pcolormesh with levels')
+
+
+
+plt.subplot(2, 1, 2)
+# contours are *point* based plots, so convert our bound into point
+# centers
+plt.contourf(x[:-1, :-1] + dx / 2.,
+             y[:-1, :-1] + dy / 2., z, levels=levels,
+             cmap=cmap)
+plt.colorbar()
+plt.title('contourf with levels')
+
+
+plt.show()

examples/pylab_examples/poormans_contour.py

@@ -1,33 +1,30 @@
-#!/usr/bin/env python
 """
 You can use TeX to render all of your matplotlib text if the rc
 parameter text.usetex is set.  This works currently on the agg and ps
 backends, and requires that you have tex and the other dependencies
-described at http://matplotlib.sf.net/matplotlib.texmanager.html
+described at http://matplotlib.org/users/usetex.html
 properly installed on your system.  The first time you run a script
 you will see a lot of output from tex and associated tools.  The next
 time, the run may be silent, as a lot of the information is cached in
 ~/.tex.cache
 
 """
-from matplotlib import rc
-from numpy import arange, cos, pi
-from matplotlib.pyplot import figure, axes, plot, xlabel, ylabel, title, \
-     grid, savefig, show
+import numpy as np
+import matplotlib.pyplot as plt
 
 
-rc('text', usetex=True)
-rc('font', family='serif')
-figure(1, figsize=(6,4))
-ax = axes([0.1, 0.1, 0.8, 0.7])
-t = arange(0.0, 1.0+0.01, 0.01)
-s = cos(2*2*pi*t)+2
-plot(t, s)
+plt.rc('text', usetex=True)
+plt.rc('font', family='serif')
+plt.figure(1, figsize=(6,4))
+ax = plt.axes([0.1, 0.1, 0.8, 0.7])
+t = np.linspace(0.0, 1.0, 100)
+s = np.cos(4 * np.pi * t) + 2
+plt.plot(t, s)
 
-xlabel(r'\textbf{time (s)}')
-ylabel(r'\textit{voltage (mV)}',fontsize=16)
-title(r"\TeX\ is Number $\displaystyle\sum_{n=1}^\infty\frac{-e^{i\pi}}{2^n}$!",
-      fontsize=16, color='r')
-grid(True)
-savefig('tex_demo')
-show()
+plt.xlabel(r'\textbf{time (s)}')
+plt.ylabel(r'\textit{voltage (mV)}',fontsize=16)
+plt.title(r"\TeX\ is Number $\displaystyle\sum_{n=1}^\infty"
+          r"\frac{-e^{i\pi}}{2^n}$!", fontsize=16, color='r')
+plt.grid(True)
+plt.savefig('tex_demo')
+plt.show()

examples/pylab_examples/tex_demo.py

@@ -1,66 +1,59 @@
 #!/usr/bin/env python
 # -*- noplot -*-
-# This example shows how to use the agg backend directly to create
-# images, which may be of use to web application developers who want
-# full control over their code without using the pylab interface to
-# manage figures, figure closing etc.
-#
-# The rc command is used to create per-script default figure
-# customizations of the rc parameters; see
-# http://matplotlib.sf.net/matplotlibrc .  You may prefer to set the
-# rc parameters in the rc file itself.  Note that you can keep
-# directory level default configurations by placing different rc files
-# in the directory that the script runs in.
-#
-# I am making no effort here to make a figure that looks good --
-# rather I am just trying to show the various ways to use matplotlib
-# to customize your figure using the matplotlib API
+"""
+This example shows how to use the agg backend directly to create
+images, which may be of use to web application developers who want
+full control over their code without using the pyplot interface to
+manage figures, figure closing etc.
+
+.. note::
+
+    It is not necessary to avoid using the pyplot interface in order to
+    create figures without a graphical front-end - simply setting
+    the backend to "Agg" would be sufficient.
+
+
+It is also worth noting that, because matplotlib can save figures to file-like
+object, matplotlib can also be used inside a cgi-script *without* needing to
+write a figure to disk.
+
+"""
 
-import matplotlib
-matplotlib.use('Agg')  # force the antigrain backend
-from matplotlib import rc
 from matplotlib.backends.backend_agg import FigureCanvasAgg
 from matplotlib.figure import Figure
-from matplotlib.cbook import iterable
 import numpy as np
 
+
 def make_fig():
     """
-    make a figure
+    Make a figure and save it to "webagg.png".
 
-    No need to close figures or clean up since the objects will be
-    destroyed when they go out of scope
     """
     fig = Figure()
-    #ax = fig.add_subplot(111)  # add a standard subplot
-
-    # add an axes at left, bottom, width, height; by making the bottom
-    # at 0.3, we save some extra room for tick labels
-    ax = fig.add_axes([0.2, 0.3, 0.7, 0.6])
+    ax = fig.add_subplot(1, 1, 1)
 
-    line,  = ax.plot([1,2,3], 'ro--', markersize=12, markerfacecolor='g')
+    ax.plot([1, 2, 3], 'ro--', markersize=12, markerfacecolor='g')
 
     # make a translucent scatter collection
     x = np.random.rand(100)
     y = np.random.rand(100)
-    area = np.pi*(10 * np.random.rand(100))**2 # 0 to 10 point radiuses
-    c = ax.scatter(x,y,area)
+    area = np.pi * (10 * np.random.rand(100)) ** 2 # 0 to 10 point radiuses
+    c = ax.scatter(x, y, area)
     c.set_alpha(0.5)
 
     # add some text decoration
     ax.set_title('My first image')
     ax.set_ylabel('Some numbers')
-    ax.set_xticks( (.2,.4,.6,.8) )
+    ax.set_xticks((.2, .4, .6, .8))
     labels = ax.set_xticklabels(('Bill', 'Fred', 'Ted', 'Ed'))
 
     # To set object properties, you can either iterate over the
     # objects manually, or define you own set command, as in setapi
     # above.
-    for l in labels:
-        l.set_rotation(45)
-        l.set_fontsize(12)
+    for label in labels:
+        label.set_rotation(45)
+        label.set_fontsize(12)
 
-    canvas = FigureCanvasAgg(fig)
-    canvas.print_figure('webapp', dpi=150)
+    FigureCanvasAgg(fig).print_png('webapp.png', dpi=150)
 
-make_fig()
+make_fig()

examples/pylab_examples/webapp_demo.py

@@ -210,6 +210,7 @@
     'nan_test.py',
     'newscalarformatter_demo.py',
     'pcolor_demo.py',
+    'pcolor_demo2.py',
     'pcolor_log.py',
     'pcolor_small.py',
     'pie_demo2.py',

examples/tests/backend_driver.py

@@ -910,7 +910,8 @@ def view_limits(self, vmin, vmax):
         """
         select a scale for the range from vmin to vmax
 
-        Normally This will be overridden.
+        Normally this method is overridden by subclasses to
+        change locator behaviour.
         """
         return mtransforms.nonsingular(vmin, vmax)