New Part2: Overview of plotting methods

Author: joferkington

AnatomyOfMatplotlib-Part2-Plotting_Methods_Overview.ipynb

@@ -0,0 +1,45 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+import example_utils
+
+def main():
+    fig, axes = example_utils.setup_axes()
+
+    basic_bar(axes[0])
+    tornado(axes[1])
+    general(axes[2])
+
+    example_utils.title(fig, '"ax.bar(...)": Plot rectangles')
+    fig.savefig('bar_example.png', facecolor='none')
+    plt.show()
+
+def basic_bar(ax):
+    y = [1, 3, 4, 5.5, 3, 2]
+    err = [0.2, 1, 2.5, 1, 1, 0.5]
+    x = np.arange(len(y))
+    ax.bar(x, y, yerr=err, color='lightblue', ecolor='black')
+    ax.margins(0.05)
+    ax.set_ylim(bottom=0)
+    example_utils.label(ax, 'bar(x, y, yerr=e)')
+
+def tornado(ax):
+    y = np.arange(8)
+    x1 = y + np.random.random(8) + 1
+    x2 = y + 3 * np.random.random(8) + 1
+    ax.barh(y, x1, color='lightblue')
+    ax.barh(y, -x2, color='salmon')
+    ax.margins(0.15)
+    example_utils.label(ax, 'barh(x, y)')
+
+def general(ax):
+    num = 10
+    left = np.random.randint(0, 10, num)
+    bottom = np.random.randint(0, 10, num)
+    width = np.random.random(num) + 0.5
+    height = np.random.random(num) + 0.5
+    ax.bar(left, height, width, bottom, color='salmon')
+    ax.margins(0.15)
+    example_utils.label(ax, 'bar(l, h, w, b)')
+
+main()

examples/.example_utils.py.swo

@@ -0,0 +1,26 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.cbook import get_sample_data
+
+import example_utils
+
+z = np.load(get_sample_data('axes_grid/bivariate_normal.npy'))
+
+fig, axes = example_utils.setup_axes()
+
+axes[0].contour(z, cmap='gist_earth')
+example_utils.label(axes[0], 'contour')
+
+axes[1].contourf(z, cmap='gist_earth')
+example_utils.label(axes[1], 'contourf')
+
+axes[2].contourf(z, cmap='gist_earth')
+cont = axes[2].contour(z, colors='black')
+axes[2].clabel(cont, fontsize=6)
+example_utils.label(axes[2], 'contourf + contour\n + clabel')
+
+example_utils.title(fig, '"contour, contourf, clabel": Contour/label 2D data',
+                    y=0.96)
+fig.savefig('contour_example.png', facecolor='none')
+
+plt.show()

examples/bar_example.py

@@ -0,0 +1,23 @@
+"""
+Just a few functions shared between all the examples. Ensures example plots are
+all the same size, etc.
+"""
+import matplotlib.pyplot as plt
+
+def setup_axes():
+    fig, axes = plt.subplots(ncols=3, figsize=(6.5,3))
+    for ax in fig.axes:
+        ax.set(xticks=[], yticks=[])
+    fig.subplots_adjust(wspace=0, left=0, right=0.93)
+    return fig, axes
+
+def title(fig, text, y=0.9):
+    fig.suptitle(text, size=14, y=y, weight='semibold', x=0.98, ha='right',
+                 bbox=dict(boxstyle='round', fc='floralwhite', ec='#8B7E66',
+                           lw=2))
+
+def label(ax, text, y=0):
+    ax.annotate(text, xy=(0.5, 0.00), xycoords='axes fraction', ha='center',
+                style='italic',
+                bbox=dict(boxstyle='round', facecolor='floralwhite',
+                          ec='#8B7E66'))

examples/contour_example.py

@@ -0,0 +1,77 @@
+"""
+Illustrate different ways of using the various fill functions.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+
+import example_utils
+
+def main():
+    fig, axes = example_utils.setup_axes()
+
+    fill_example(axes[0])
+    fill_between_example(axes[1])
+    stackplot_example(axes[2])
+
+    example_utils.title(fig, 'fill/fill_between/stackplot: Filled polygons',
+                        y=0.95)
+    fig.savefig('fill_example.png', facecolor='none')
+    plt.show()
+
+def fill_example(ax):
+    # Use fill when you want a simple filled polygon between vertices
+    x, y = fill_data()
+    ax.fill(x, y, color='lightblue')
+    ax.margins(0.1)
+    example_utils.label(ax, 'fill')
+
+def fill_between_example(ax):
+    # Fill between fills between two curves or a curve and a constant value
+    # It can be used in several ways. We'll illustrate a few below.
+    x, y1, y2 = sin_data()
+
+    # The most basic (and common) use of fill_between
+    err = np.random.rand(x.size)**2 + 0.1
+    y = 0.7 * x + 2
+    ax.fill_between(x, y + err, y - err, color='orange')
+
+    # Filling between two curves with different colors when they cross in
+    # different directions
+    ax.fill_between(x, y1, y2, where=y1>y2, color='lightblue')
+    ax.fill_between(x, y1, y2, where=y1<y2, color='forestgreen')
+
+    # Note that this is fillbetween*x*!
+    ax.fill_betweenx(x, -y1, where=y1>0, color='red', alpha=0.5)
+    ax.fill_betweenx(x, -y1, where=y1<0, color='blue', alpha=0.5)
+
+    ax.margins(0.15)
+    example_utils.label(ax, 'fill_between/x')
+
+def stackplot_example(ax):
+    # Stackplot is equivalent to a series of ax.fill_between calls
+    x, y = stackplot_data()
+    ax.stackplot(x, y.cumsum(axis=0), alpha=0.5)
+    example_utils.label(ax, 'stackplot')
+
+#-- Data generation ----------------------
+
+def stackplot_data():
+    x = np.linspace(0, 10, 100)
+    y = np.random.normal(0, 1, (5, 100))
+    y = y.cumsum(axis=1)
+    y -= y.min(axis=0, keepdims=True)
+    return x, y
+
+def sin_data():
+    x = np.linspace(0, 10, 100)
+    y = np.sin(x)
+    y2 = np.cos(x)
+    return x, y, y2
+
+def fill_data():
+    t = np.linspace(0, 2*np.pi, 100)
+    r = np.random.normal(0, 1, 100).cumsum()
+    r -= r.min()
+    return r * np.cos(t), r * np.sin(t)
+
+main()

examples/example_utils.py

@@ -0,0 +1,45 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.cbook import get_sample_data
+from mpl_toolkits import axes_grid1
+
+import example_utils
+
+def main():
+    fig, axes = setup_axes()
+    plot(axes, *load_data())
+    example_utils.title(fig, '"ax.imshow(data, ...)": Colormapped or RGB arrays')
+    fig.savefig('imshow_example.png', facecolor='none')
+    plt.show()
+
+def plot(axes, img_data, scalar_data, ny):
+    # Note: I'm defining the extent so I can cheat a bit when using ImageGrid
+    # to make all of the axes the same height...
+
+    # Default: Linear interpolation
+    axes[0].imshow(scalar_data, cmap='gist_earth', extent=[0, ny, ny, 0])
+
+    # Use nearest interpolation instead.
+    axes[1].imshow(scalar_data, cmap='gist_earth', interpolation='nearest',
+                   extent=[0, ny, ny, 0])
+
+    # Show RGB/RGBA data instead of colormapping a scalar.
+    axes[2].imshow(img_data)
+
+def load_data():
+    img_data = plt.imread(get_sample_data('grace_hopper.png'))
+    ny, nx, nbands = img_data.shape
+    scalar_data = np.load(get_sample_data('axes_grid/bivariate_normal.npy'))
+    return img_data, scalar_data, ny
+
+def setup_axes():
+    # We'll set up the axes a bit differently here so that they'll all be the
+    # same height even though the aspect will be set and adjustable is "box".
+    fig = plt.figure(figsize=(6,3))
+    axes = axes_grid1.ImageGrid(fig, [0, 0, .93, 1], (1, 3), axes_pad=0)
+
+    for ax in axes:
+        ax.set(xticks=[], yticks=[])
+    return fig, axes
+
+main()

examples/fill_example.py

@@ -0,0 +1,42 @@
+"""
+Shows the basics of pcolor/pcolormesh.
+One note: Use imshow if your data is on a rectangular grid, as it's much
+faster. This example shows a case that imshow can't handle.
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.cbook import get_sample_data
+
+import example_utils
+
+# Set up our data...
+z = np.load(get_sample_data('axes_grid/bivariate_normal.npy'))
+ny, nx = z.shape
+y, x = np.mgrid[:ny, :nx]
+y = (y - y.mean()) * (x + 10)**2
+
+mask = (z > -0.1) & (z < 0.1)
+z2 = np.ma.masked_where(mask, z)
+
+fig, axes = example_utils.setup_axes()
+
+# Either pcolor or pcolormesh would produce the same result here.
+# pcolormesh is faster, however.
+axes[0].pcolor(x, y, z, cmap='gist_earth')
+example_utils.label(axes[0], 'either')
+
+# The difference between the two will become clear as we turn on edges:
+
+# pcolor will completely avoid drawing masked cells...
+axes[1].pcolor(x, y, z2, cmap='gist_earth', edgecolor='black')
+example_utils.label(axes[1], 'pcolor(x,y,z)')
+
+# While pcolormesh will draw them as empty (but still present) cells.
+axes[2].pcolormesh(x, y, z2, cmap='gist_earth', edgecolor='black', lw=0.5,
+                   antialiased=True)
+example_utils.label(axes[2], 'pcolormesh(x,y,z)')
+
+example_utils.title(fig, 'pcolor/pcolormesh: Colormapped 2D arrays')
+fig.savefig('pcolor_example.png', facecolor='none')
+
+plt.show()

examples/imshow_example.py

@@ -0,0 +1,27 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+import example_utils
+
+x = np.linspace(0, 10, 100)
+
+fig, axes = example_utils.setup_axes()
+for ax in axes:
+    ax.margins(y=0.10)
+
+# Default plotting, colors will be determined by the axes' color_cycle
+for i in range(1, 6):
+    axes[0].plot(x, i * x)
+
+# Demonstrating different linestyles
+for i, ls in enumerate(['-', '--', ':', '-.']):
+    axes[1].plot(x, np.cos(x) + i, linestyle=ls)
+
+# Using linestyles and markers
+for i, (ls, mk) in enumerate(zip(['', '-', ':'], ['o', '^', 's'])):
+    axes[2].plot(x, np.cos(x) + i * x, linestyle=ls, marker=mk, markevery=10)
+
+example_utils.title(fig, '"ax.plot(x, y, ...)": Lines and/or markers', y=0.95)
+fig.savefig('plot_example.png', facecolor='none')
+
+plt.show()

examples/pcolor_example.py

@@ -0,0 +1,30 @@
+"""
+Illustrates the basics of using "scatter".
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+
+import example_utils
+
+# Generate some random data...
+np.random.seed(1874)
+x, y, z = np.random.normal(0, 1, (3, 100))
+t = np.arctan2(y, x)
+size = 50 * np.cos(2 * t)**2 + 10
+
+fig, axes = example_utils.setup_axes()
+
+axes[0].scatter(x, y, marker='o', facecolor='white', s=80)
+example_utils.label(axes[0], 'scatter(x, y)')
+
+axes[1].scatter(x, y, s=size, marker='s', color='darkblue')
+example_utils.label(axes[1], 'scatter(x, y, s)')
+
+axes[2].scatter(x, y, c=z, s=size, cmap='gist_ncar')
+example_utils.label(axes[2], 'scatter(x, y, s, c)')
+
+example_utils.title(fig,'"ax.scatter(...)": Colored/scaled markers',
+                    y=0.95)
+fig.savefig('scatter_example.png', facecolor='none')
+
+plt.show()