Move images, contours and fields from pylab_examples and clean

dstansby · dstansby · commit c897f19363eb · 2017-07-10T10:58:07.000+01:00
diff --git a/examples/images_contours_and_fields/contour_demo.py b/examples/images_contours_and_fields/contour_demo.py
diff --git a/examples/images_contours_and_fields/contour_image.py b/examples/images_contours_and_fields/contour_image.py
@@ -28,7 +28,8 @@
 Z2 = mlab.bivariate_normal(X, Y, 1.5, 0.5, 1, 1)
 Z = (Z1 - Z2) * 10
 
-levels = np.arange(-2.0, 1.601, 0.4)  # Boost the upper limit to avoid truncation errors.
+# Boost the upper limit to avoid truncation errors.
+levels = np.arange(-2.0, 1.601, 0.4)
 
 norm = cm.colors.Normalize(vmax=abs(Z).max(), vmin=-abs(Z).max())
 cmap = cm.PRGn
@@ -40,9 +41,7 @@
 plt.subplot(2, 2, 1)
 
 cset1 = plt.contourf(X, Y, Z, levels,
-                 cmap=cm.get_cmap(cmap, len(levels) - 1),
-                 norm=norm,
-                 )
+                     cmap=cm.get_cmap(cmap, len(levels) - 1), norm=norm)
 # It is not necessary, but for the colormap, we need only the
 # number of levels minus 1.  To avoid discretization error, use
 # either this number or a large number such as the default (256).
@@ -94,7 +93,8 @@
 # This is intentional. The Z values are defined at the center of each
 # image pixel (each color block on the following subplot), so the
 # domain that is contoured does not extend beyond these pixel centers.
-im = plt.imshow(Z, interpolation='nearest', extent=extent, cmap=cmap, norm=norm)
+im = plt.imshow(Z, interpolation='nearest', extent=extent,
+                cmap=cmap, norm=norm)
 v = plt.axis()
 plt.contour(Z, levels, colors='k', origin='image', extent=extent)
 plt.axis(v)
diff --git a/examples/images_contours_and_fields/contour_label_demo.py b/examples/images_contours_and_fields/contour_label_demo.py
@@ -48,6 +48,7 @@ def __repr__(self):
         else:
             return '%.1f' % self.__float__()
 
+
 # Recast levels to new class
 CS.levels = [nf(val) for val in CS.levels]
 
diff --git a/examples/images_contours_and_fields/contourf_demo.py b/examples/images_contours_and_fields/contourf_demo.py
@@ -8,7 +8,6 @@
 import matplotlib.pyplot as plt
 
 origin = 'lower'
-#origin = 'upper'
 
 delta = 0.025
 
@@ -21,13 +20,13 @@
 nr, nc = Z.shape
 
 # put NaNs in one corner:
-Z[-nr//6:, -nc//6:] = np.nan
+Z[-nr // 6:, -nc // 6:] = np.nan
 # contourf will convert these to masked
 
 
 Z = np.ma.array(Z)
 # mask another corner:
-Z[:nr//6, :nc//6] = np.ma.masked
+Z[:nr // 6, :nc // 6] = np.ma.masked
 
 # mask a circle in the middle:
 interior = np.sqrt((X**2) + (Y**2)) < 0.5
@@ -37,20 +36,14 @@
 # this is usually not such a good idea, because they don't
 # occur on nice boundaries, but we do it here for purposes
 # of illustration.
-CS = plt.contourf(X, Y, Z, 10,
-                  #[-1, -0.1, 0, 0.1],
-                  #alpha=0.5,
-                  cmap=plt.cm.bone,
-                  origin=origin)
+CS = plt.contourf(X, Y, Z, 10, cmap=plt.cm.bone, origin=origin)
 
 # Note that in the following, we explicitly pass in a subset of
 # the contour levels used for the filled contours.  Alternatively,
 # We could pass in additional levels to provide extra resolution,
 # or leave out the levels kwarg to use all of the original levels.
 
-CS2 = plt.contour(CS, levels=CS.levels[::2],
-                  colors='r',
-                  origin=origin)
+CS2 = plt.contour(CS, levels=CS.levels[::2], colors='r', origin=origin)
 
 plt.title('Nonsense (3 masked regions)')
 plt.xlabel('word length anomaly')
diff --git a/examples/images_contours_and_fields/contourf_hatching.py b/examples/images_contours_and_fields/contourf_hatching.py
diff --git a/examples/images_contours_and_fields/figimage_demo.py b/examples/images_contours_and_fields/figimage_demo.py
diff --git a/examples/images_contours_and_fields/griddata_demo.py b/examples/images_contours_and_fields/griddata_demo.py
diff --git a/examples/images_contours_and_fields/layer_images.py b/examples/images_contours_and_fields/layer_images.py
@@ -11,7 +11,8 @@
 
 
 def func3(x, y):
-    return (1 - x/2 + x**5 + y**3)*np.exp(-(x**2 + y**2))
+    return (1 - x / 2 + x**5 + y**3) * np.exp(-(x**2 + y**2))
+
 
 # make these smaller to increase the resolution
 dx, dy = 0.05, 0.05
diff --git a/examples/images_contours_and_fields/multi_image.py b/examples/images_contours_and_fields/multi_image.py
@@ -34,7 +34,7 @@
 vmax = -1e40
 for i in range(Nr):
     for j in range(Nc):
-        pos = [0.075 + j*1.1*w, 0.18 + i*1.2*h, w, h]
+        pos = [0.075 + j * 1.1 * w, 0.18 + i * 1.2 * h, w, h]
         a = fig.add_axes(pos)
         if i > 0:
             a.set_xticklabels([])
@@ -64,6 +64,7 @@ def __call__(self, leader):
         self.follower.set_cmap(leader.get_cmap())
         self.follower.set_clim(leader.get_clim())
 
+
 norm = colors.Normalize(vmin=vmin, vmax=vmax)
 for i, im in enumerate(images):
     im.set_norm(norm)
diff --git a/examples/images_contours_and_fields/pcolor_demo.py b/examples/images_contours_and_fields/pcolor_demo.py
@@ -28,6 +28,7 @@
 c = ax1.pcolor(Z, edgecolors='k', linewidths=4)
 ax1.set_title('thick edges')
 
+fig.tight_layout()
 plt.show()
 
 ###############################################################################
@@ -94,7 +95,8 @@
 # A low hump with a spike coming out of the top right.
 # Needs to have z/colour axis on a log scale so we see both hump and spike.
 # linear scale only shows the spike.
-Z1 = bivariate_normal(X, Y, 0.1, 0.2, 1.0, 1.0) + 0.1 * bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)
+Z1 = (bivariate_normal(X, Y, 0.1, 0.2, 1.0, 1.0) +
+      0.1 * bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0))
 
 fig, (ax0, ax1) = plt.subplots(2, 1)
 
diff --git a/examples/images_contours_and_fields/quadmesh_demo.py b/examples/images_contours_and_fields/quadmesh_demo.py
@@ -16,12 +16,12 @@
 
 n = 12
 x = np.linspace(-1.5, 1.5, n)
-y = np.linspace(-1.5, 1.5, n*2)
+y = np.linspace(-1.5, 1.5, n * 2)
 X, Y = np.meshgrid(x, y)
 Qx = np.cos(Y) - np.cos(X)
 Qz = np.sin(Y) + np.sin(X)
 Qx = (Qx + 1.1)
-Z = np.sqrt(X**2 + Y**2)/5
+Z = np.sqrt(X**2 + Y**2) / 5
 Z = (Z - Z.min()) / (Z.max() - Z.min())
 
 # The color array can include masked values:
diff --git a/examples/images_contours_and_fields/quiver_demo.py b/examples/images_contours_and_fields/quiver_demo.py
diff --git a/examples/images_contours_and_fields/quiver_simple_demo.py b/examples/images_contours_and_fields/quiver_simple_demo.py
diff --git a/examples/images_contours_and_fields/shading_example.py b/examples/images_contours_and_fields/shading_example.py
@@ -59,5 +59,6 @@ def compare(z, cmap, ve=1):
 
     return fig
 
+
 if __name__ == '__main__':
     main()
diff --git a/examples/images_contours_and_fields/tricontour_demo.py b/examples/images_contours_and_fields/tricontour_demo.py
@@ -19,21 +19,21 @@
 min_radius = 0.25
 radii = np.linspace(min_radius, 0.95, n_radii)
 
-angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi/n_angles
+angles[:, 1::2] += math.pi / n_angles
 
-x = (radii*np.cos(angles)).flatten()
-y = (radii*np.sin(angles)).flatten()
-z = (np.cos(radii)*np.cos(angles*3.0)).flatten()
+x = (radii * np.cos(angles)).flatten()
+y = (radii * np.sin(angles)).flatten()
+z = (np.cos(radii) * np.cos(angles * 3.0)).flatten()
 
 # Create the Triangulation; no triangles so Delaunay triangulation created.
 triang = tri.Triangulation(x, y)
 
 # Mask off unwanted triangles.
 xmid = x[triang.triangles].mean(axis=1)
 ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
+mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
 triang.set_mask(mask)
 
 # pcolor plot.
@@ -73,7 +73,7 @@
 y = np.degrees(xy[:, 1])
 x0 = -5
 y0 = 52
-z = np.exp(-0.01*((x - x0)*(x - x0) + (y - y0)*(y - y0)))
+z = np.exp(-0.01 * ((x - x0) * (x - x0) + (y - y0) * (y - y0)))
 
 triangles = np.asarray([
     [67, 66,  1], [65,  2, 66], [ 1, 66,  2], [64,  2, 65], [63,  3, 64],
diff --git a/examples/images_contours_and_fields/tricontour_smooth_delaunay.py b/examples/images_contours_and_fields/tricontour_smooth_delaunay.py
@@ -35,15 +35,15 @@
 #-----------------------------------------------------------------------------
 def experiment_res(x, y):
     """ An analytic function representing experiment results """
-    x = 2.*x
+    x = 2. * x
     r1 = np.sqrt((0.5 - x)**2 + (0.5 - y)**2)
     theta1 = np.arctan2(0.5 - x, 0.5 - y)
     r2 = np.sqrt((-x - 0.2)**2 + (-y - 0.2)**2)
     theta2 = np.arctan2(-x - 0.2, -y - 0.2)
-    z = (4*(np.exp((r1/10)**2) - 1)*30. * np.cos(3*theta1) +
-         (np.exp((r2/10)**2) - 1)*30. * np.cos(5*theta2) +
-         2*(x**2 + y**2))
-    return (np.max(z) - z)/(np.max(z) - np.min(z))
+    z = (4 * (np.exp((r1 / 10)**2) - 1) * 30. * np.cos(3 * theta1) +
+         (np.exp((r2 / 10)**2) - 1) * 30. * np.cos(5 * theta2) +
+         2 * (x**2 + y**2))
+    return (np.max(z) - z) / (np.max(z) - np.min(z))
 
 #-----------------------------------------------------------------------------
 # Generating the initial data test points and triangulation for the demo
@@ -76,7 +76,7 @@ def experiment_res(x, y):
 
 # Some invalid data are masked out
 mask_init = np.zeros(ntri, dtype=np.bool)
-masked_tri = random_gen.randint(0, ntri, int(ntri*init_mask_frac))
+masked_tri = random_gen.randint(0, ntri, int(ntri * init_mask_frac))
 mask_init[masked_tri] = True
 tri.set_mask(mask_init)
 
diff --git a/examples/images_contours_and_fields/tricontour_smooth_user.py b/examples/images_contours_and_fields/tricontour_smooth_user.py
@@ -22,10 +22,10 @@ def function_z(x, y):
     theta1 = np.arctan2(0.5 - x, 0.5 - y)
     r2 = np.sqrt((-x - 0.2)**2 + (-y - 0.2)**2)
     theta2 = np.arctan2(-x - 0.2, -y - 0.2)
-    z = -(2*(np.exp((r1/10)**2) - 1)*30. * np.cos(7.*theta1) +
-          (np.exp((r2/10)**2) - 1)*30. * np.cos(11.*theta2) +
-          0.7*(x**2 + y**2))
-    return (np.max(z) - z)/(np.max(z) - np.min(z))
+    z = -(2 * (np.exp((r1 / 10)**2) - 1) * 30. * np.cos(7. * theta1) +
+          (np.exp((r2 / 10)**2) - 1) * 30. * np.cos(11. * theta2) +
+          0.7 * (x**2 + y**2))
+    return (np.max(z) - z) / (np.max(z) - np.min(z))
 
 #-----------------------------------------------------------------------------
 # Creating a Triangulation
@@ -36,12 +36,12 @@ def function_z(x, y):
 min_radius = 0.15
 radii = np.linspace(min_radius, 0.95, n_radii)
 
-angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi/n_angles
+angles[:, 1::2] += math.pi / n_angles
 
-x = (radii*np.cos(angles)).flatten()
-y = (radii*np.sin(angles)).flatten()
+x = (radii * np.cos(angles)).flatten()
+y = (radii * np.sin(angles)).flatten()
 z = function_z(x, y)
 
 # Now create the Triangulation.
@@ -52,7 +52,7 @@ def function_z(x, y):
 # Mask off unwanted triangles.
 xmid = x[triang.triangles].mean(axis=1)
 ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
+mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
 triang.set_mask(mask)
 
 #-----------------------------------------------------------------------------
diff --git a/examples/images_contours_and_fields/tricontour_vs_griddata.py b/examples/images_contours_and_fields/tricontour_vs_griddata.py
@@ -18,7 +18,7 @@
 ngridy = 200
 x = np.random.uniform(-2, 2, npts)
 y = np.random.uniform(-2, 2, npts)
-z = x*np.exp(-x**2 - y**2)
+z = x * np.exp(-x**2 - y**2)
 
 # griddata and contour.
 start = time.clock()
@@ -34,8 +34,8 @@
 plt.xlim(-2, 2)
 plt.ylim(-2, 2)
 plt.title('griddata and contour (%d points, %d grid points)' %
-          (npts, ngridx*ngridy))
-print('griddata and contour seconds: %f' % (time.clock() - start))
+          (npts, ngridx * ngridy))
+print('griddata and contour: %f seconds' % (time.clock() - start))
 
 # tricontour.
 start = time.clock()
@@ -49,7 +49,7 @@
 plt.xlim(-2, 2)
 plt.ylim(-2, 2)
 plt.title('tricontour (%d points)' % npts)
-print('tricontour seconds: %f' % (time.clock() - start))
+print('tricontour: %f seconds' % (time.clock() - start))
 
 plt.subplots_adjust(hspace=0.5)
 
diff --git a/examples/images_contours_and_fields/trigradient_demo.py b/examples/images_contours_and_fields/trigradient_demo.py
diff --git a/examples/images_contours_and_fields/triinterp_demo.py b/examples/images_contours_and_fields/triinterp_demo.py
@@ -17,7 +17,7 @@
 triang = mtri.Triangulation(x, y, triangles)
 
 # Interpolate to regularly-spaced quad grid.
-z = np.cos(1.5*x)*np.cos(1.5*y)
+z = np.cos(1.5 * x) * np.cos(1.5 * y)
 xi, yi = np.meshgrid(np.linspace(0, 3, 20), np.linspace(0, 3, 20))
 
 interp_lin = mtri.LinearTriInterpolator(triang, z)
diff --git a/examples/images_contours_and_fields/tripcolor_demo.py b/examples/images_contours_and_fields/tripcolor_demo.py
@@ -19,21 +19,21 @@
 min_radius = 0.25
 radii = np.linspace(min_radius, 0.95, n_radii)
 
-angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi/n_angles
+angles[:, 1::2] += math.pi / n_angles
 
-x = (radii*np.cos(angles)).flatten()
-y = (radii*np.sin(angles)).flatten()
-z = (np.cos(radii)*np.cos(angles*3.0)).flatten()
+x = (radii * np.cos(angles)).flatten()
+y = (radii * np.sin(angles)).flatten()
+z = (np.cos(radii) * np.cos(angles * 3.0)).flatten()
 
 # Create the Triangulation; no triangles so Delaunay triangulation created.
 triang = tri.Triangulation(x, y)
 
 # Mask off unwanted triangles.
 xmid = x[triang.triangles].mean(axis=1)
 ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
+mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
 triang.set_mask(mask)
 
 # tripcolor plot.
@@ -100,7 +100,8 @@
 ymid = y[triangles].mean(axis=1)
 x0 = -5
 y0 = 52
-zfaces = np.exp(-0.01*((xmid - x0)*(xmid - x0) + (ymid - y0)*(ymid - y0)))
+zfaces = np.exp(-0.01 * ((xmid - x0) * (xmid - x0) +
+                         (ymid - y0) * (ymid - y0)))
 
 # Rather than create a Triangulation object, can simply pass x, y and triangles
 # arrays to tripcolor directly.  It would be better to use a Triangulation
diff --git a/examples/images_contours_and_fields/triplot_demo.py b/examples/images_contours_and_fields/triplot_demo.py
@@ -19,20 +19,20 @@
 min_radius = 0.25
 radii = np.linspace(min_radius, 0.95, n_radii)
 
-angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi/n_angles
+angles[:, 1::2] += math.pi / n_angles
 
-x = (radii*np.cos(angles)).flatten()
-y = (radii*np.sin(angles)).flatten()
+x = (radii * np.cos(angles)).flatten()
+y = (radii * np.sin(angles)).flatten()
 
 # Create the Triangulation; no triangles so Delaunay triangulation created.
 triang = tri.Triangulation(x, y)
 
 # Mask off unwanted triangles.
 xmid = x[triang.triangles].mean(axis=1)
 ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
+mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
 triang.set_mask(mask)
 
 # Plot the triangulation.
