added poly_netween and updated fill_between

jdh2358 · jdh2358 · commit 2db768e9d4b2 · 2007-07-14T17:45:34.000Z
svn path=/trunk/matplotlib/; revision=3527
diff --git a/examples/fill_between.py b/examples/fill_between.py
@@ -1,15 +1,29 @@
 #!/usr/bin/env python
+import matplotlib.mlab as mlab
+from pylab import figure, show
+import numpy as npy
 
-from pylab import *
+x = npy.arange(0, 2, 0.01)
+y1 = npy.sin(2*npy.pi*x)
+y2 = npy.sin(4*npy.pi*x) + 2
 
-x1 = arange(0, 2, 0.01)
-y1 = sin(2*pi*x1)
-y2 = sin(4*pi*x1) + 2
+fig = figure()
+ax = fig.add_subplot(311)
+ax2 = fig.add_subplot(312)
+ax3 = fig.add_subplot(313)
 
-# reverse x and y2 so the polygon fills in order
-x = concatenate( (x1,x1[::-1]) )
-y = concatenate( (y1,y2[::-1]) )
 
-p = fill(x, y, facecolor='g', alpha=0.5)
+xs, ys = mlab.poly_between(x, 0, y1)
+ax.fill(xs, ys)
+ax.set_ylabel('between y1 and 0')
+
+xs, ys = mlab.poly_between(x, y1, 1)
+ax2.fill(xs, ys)
+ax2.set_ylabel('between y1 and 1')
+
+xs, ys = mlab.poly_between(x, y1, y2)
+ax3.fill(xs, ys)
+ax3.set_ylabel('between y1 and y2')
+ax3.set_xlabel('x')
 show()
 
diff --git a/lib/matplotlib/axes.py b/lib/matplotlib/axes.py
@@ -4236,6 +4236,14 @@ def fill(self, *args, **kwargs):
         The same color strings that plot supports are supported by the fill
         format string.
 
+        If you would like to fill below a curve, eg shade a region
+        between 0 and y along x, use mlab.poly_between, eg
+
+          xs, ys = poly_between(x, 0, y)
+          axes.fill(xs, ys, facecolor='red', alpha=0.5)
+
+        See examples/fill_between.py for more examples.
+        
         kwargs control the Polygon properties:
         %(Polygon)s
         """
diff --git a/lib/matplotlib/cbook.py b/lib/matplotlib/cbook.py
@@ -472,6 +472,19 @@ def enumerate(seq):
             yield i, seq[i]
 
 
+# use reversed builtin if available, else use python version
+try:
+    import __builtin__
+    reversed = __builtin__.reversed
+except:
+    def reversed(seq):
+        """Python equivalent to the enumerate builtin function
+        enumerate() is new in Python 2.3
+        """
+        for i in range(len(seq)-1,-1,-1):
+            yield i, seq[i]
+
+
 # use itertools.izip if available, else use python version
 try:
     import itertools
diff --git a/lib/matplotlib/mlab.py b/lib/matplotlib/mlab.py
@@ -57,6 +57,7 @@
 from __future__ import division
 import sys, random, datetime, csv
 
+import numpy as npy
 
 from matplotlib import verbose
 import numpy as npy
@@ -77,7 +78,7 @@
 from numerix.mlab import hanning, cov, diff, svd, rand, std
 from numerix.fft import fft, inverse_fft
 
-from cbook import iterable, is_string_like, to_filehandle
+from cbook import iterable, is_string_like, to_filehandle, reversed
 
 try: set
 except NameError:
@@ -1680,6 +1681,7 @@ def angle(x1, y1, x2, y2):
         angles += a
     return nx.nonzero(nx.greater_equal(nx.absolute(angles), nx.pi))
 
+
 def inside_poly(points, verts):
     """
     points is a sequence of x,y points
@@ -1690,6 +1692,48 @@ def inside_poly(points, verts):
     """
     return nx.nonzero(nxutils.points_inside_poly(points, verts))
 
+def poly_below(xmin, xs, ys):
+    """
+    given a sequence of xs and ys, return the vertices of a polygon
+    that has a horzontal base at xmin and an upper bound at the ys.
+    xmin is a scalar.
+
+    intended for use with Axes.fill, eg
+    xv, yv = poly_below(0, x, y)
+    ax.fill(xv, yv)
+    """
+    xs = npy.asarray(xs)
+    ys = npy.asarray(ys)
+    Nx = len(xs)
+    Ny = len(ys)
+    assert(Nx==Ny)
+    x = xmin*npy.ones(2*Nx)
+    y = npy.ones(2*Nx)
+    x[:Nx] = xs
+    y[:Nx] = ys
+    y[Nx:] = ys[::-1]
+    return x, y
+
+
+def poly_between(x, ylower, yupper):
+    """
+    given a sequence of x, ylower and yupper, return the polygon that
+    fills the regions between them.  ylower or yupper can be scalar or
+    iterable.  If they are iterable, they must be equal in length to x
+
+    return value is x, y arrays for use with Axes.fill
+    """
+    Nx = len(x)
+    if not iterable(ylower):
+        ylower = ylower*npy.ones(Nx)
+    
+    if not iterable(yupper):
+        yupper = yupper*npy.ones(Nx)
+
+    x = npy.concatenate( (x, x[::-1]) )
+    y = npy.concatenate( (yupper, ylower[::-1]) )
+    return x,y
+
 ### the following code was written and submitted by Fernando Perez
 ### from the ipython numutils package under a BSD license
 # begin fperez functions
diff --git a/lib/matplotlib/pylab.py b/lib/matplotlib/pylab.py
@@ -1,5 +1,5 @@
 """
-This is a matlab(TM) style interface to matplotlib.
+This is a procedural interface to matplotlib.
 
 The following plotting commands are provided; some of these do not
 exist in matlab(TM) but have proven themselves to be useful nonetheless.
