minor docstring, formatting, cleanup changes in contour, colorbar, collections

efiring · efiring · commit ec1cd2567521 · 2012-04-15T13:59:02.000-10:00
diff --git a/examples/pylab_examples/contourf_hatching.py b/examples/pylab_examples/contourf_hatching.py
@@ -1,12 +1,12 @@
 import matplotlib.pyplot as plt
-import numpy
+import numpy as np
 
 
 # invent some numbers, turning the x and y arrays into simple
-# 2d arrays, which make combining them together easier. 
-x = numpy.linspace(-3, 5, 150).reshape(1, -1)
-y = numpy.linspace(-3, 5, 120).reshape(-1, 1)
-z = numpy.cos(x) + numpy.sin(y)
+# 2d arrays, which make combining them together easier.
+x = np.linspace(-3, 5, 150).reshape(1, -1)
+y = np.linspace(-3, 5, 120).reshape(-1, 1)
+z = np.cos(x) + np.sin(y)
 
 # we no longer need x and y to be 2 dimensional, so flatten them.
 x, y = x.flatten(), y.flatten()
@@ -17,7 +17,7 @@
 # ---------------------------------------------
 # the simplest hatched plot with a colorbar
 fig = plt.figure()
-cs = plt.contourf(x, y, z, hatches=['-', '/', '\\', '//'], 
+cs = plt.contourf(x, y, z, hatches=['-', '/', '\\', '//'],
                   cmap=plt.get_cmap('gray'),
                   extend='both', alpha=0.5
                   )
@@ -31,15 +31,15 @@
 plt.figure()
 n_levels = 6
 plt.contour(x, y, z, n_levels, colors='black', linestyles='-')
-cs = plt.contourf(x, y, z, n_levels, colors='none', 
-                  hatches=['.', '/', '\\', None, '\\\\', '*'], 
+cs = plt.contourf(x, y, z, n_levels, colors='none',
+                  hatches=['.', '/', '\\', None, '\\\\', '*'],
                   extend='lower'
                   )
 
-# create a legend for the contour set 
+# create a legend for the contour set
 artists, labels = cs.legend_elements()
 plt.legend(artists, labels, handleheight=2)
 
 
 
-plt.show()
+plt.show()
diff --git a/lib/matplotlib/collections.py b/lib/matplotlib/collections.py
@@ -235,10 +235,10 @@ def draw(self, renderer):
         gc = renderer.new_gc()
         self._set_gc_clip(gc)
         gc.set_snap(self.get_snap())
-        
+
         if self._hatch:
             gc.set_hatch(self._hatch)
-        
+
         renderer.draw_path_collection(
             gc, transform.frozen(), paths, self.get_transforms(),
             offsets, transOffset, self.get_facecolor(), self.get_edgecolor(),
@@ -322,6 +322,10 @@ def set_hatch(self, hatch):
         Hatching is supported in the PostScript, PDF, SVG and Agg
         backends only.
 
+        Unlike other properties such as linewidth and colors, hatching
+        can only be specified for the collection as a whole, not separately
+        for each member.
+
         ACCEPTS: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ]
         """
         self._hatch = hatch
diff --git a/lib/matplotlib/colorbar.py b/lib/matplotlib/colorbar.py
@@ -135,7 +135,7 @@
     False | If *cax* is None, a new *cax* is created as an instance of
     Axes. If *ax* is an instance of Subplot and *use_gridspec* is True,
     *cax* is created as an instance of Subplot using the
-    grid_spec module. 
+    grid_spec module.
 
 
 Additional keyword arguments are of two kinds:
@@ -756,11 +756,11 @@ def __init__(self, ax, mappable, **kw):
     def on_mappable_changed(self, mappable):
         """
         Updates this colorbar to match the mappable's properties.
-        
+
         Typically this is automatically registered as an event handler
         by :func:`colorbar_factory` and should not be called manually.
-        
-        """        
+
+        """
         self.set_cmap(mappable.get_cmap())
         self.set_clim(mappable.get_clim())
         self.update_normal(mappable)
@@ -892,7 +892,7 @@ def make_axes_gridspec(parent, **kw):
 
      * *make_axes* creates an instance of Axes. *make_axes_gridspec*
         creates an instance of Subplot.
-       
+
      * *make_axes* updates the position of the
         parent. *make_axes_gridspec* replaces the grid_spec attribute
         of the parent with a new one.
@@ -979,96 +979,97 @@ class ColorbarPatch(Colorbar):
     """
     A Colorbar which is created using :class:`~matplotlib.patches.Patch`
     rather than the default :func:`~matplotlib.axes.pcolor`.
-    
+
+    It uses a list of Patch instances instead of a
+    :class:`~matplotlib.collections.PatchCollection` because the
+    latter does not allow the hatch pattern to vary among the
+    members of the collection.
     """
     def __init__(self, ax, mappable, **kw):
         # we do not want to override the behaviour of solids
         # so add a new attribute which will be a list of the
-        # colored patches in the colorbar  
+        # colored patches in the colorbar
         self.solids_patches = []
         Colorbar.__init__(self, ax, mappable, **kw)
-    
+
     def _add_solids(self, X, Y, C):
-        '''
+        """
         Draw the colors using :class:`~matplotlib.patches.Patch`;
         optionally add separators.
-        '''
+        """
         # Save, set, and restore hold state to keep pcolor from
         # clearing the axes. Ordinarily this will not be needed,
         # since the axes object should already have hold set.
         _hold = self.ax.ishold()
         self.ax.hold(True)
-        
+
         kw = {'alpha':self.alpha,}
-        
+
         n_segments = len(C)
-        
+
         # ensure there are sufficent hatches
         hatches = self.mappable.hatches * n_segments
-        
+
         patches = []
         for i in xrange(len(X)-1):
             val = C[i][0]
             hatch = hatches[i]
-            
-            xy = np.array([[X[i][0], Y[i][0]], [X[i][1], Y[i][0]], 
+
+            xy = np.array([[X[i][0], Y[i][0]], [X[i][1], Y[i][0]],
                           [X[i+1][1], Y[i+1][0]], [X[i+1][0], Y[i+1][1]]])
-            
+
             if self.orientation == 'horizontal':
                 # if horizontal swap the xs and ys
                 xy = xy[..., ::-1]
-            
+
             patch = mpatches.PathPatch(mpath.Path(xy),
                                        facecolor=self.cmap(self.norm(val)),
                                        hatch=hatch,
-                                       edgecolor='none', linewidth=0, 
+                                       edgecolor='none', linewidth=0,
                                        antialiased=False, **kw
                                        )
-            c = self.mappable.collections[i]
-            
+
             self.ax.add_patch(patch)
             patches.append(patch)
-        
+
         if self.solids_patches:
             for solid in self.solids_patches:
                 solid.remove()
-            
+
         self.solids_patches = patches
 
-        # for compatibility with Colorbar, we will implement edge drawing as a 
-        # seperate line collection, even though we could have put a line on
-        # the patches in self.solids_patches.
         if self.dividers is not None:
             self.dividers.remove()
             self.dividers = None
-            
+
         if self.drawedges:
             self.dividers = collections.LineCollection(self._edges(X,Y),
                               colors=(mpl.rcParams['axes.edgecolor'],),
                               linewidths=(0.5*mpl.rcParams['axes.linewidth'],)
                               )
             self.ax.add_collection(self.dividers)
-        
+
         self.ax.hold(_hold)
-        
-            
+
+
 def colorbar_factory(cax, mappable, **kwargs):
     """
     Creates a colorbar on the given axes for the given mappable.
-    
+
     Typically, for automatic colorbar placement given only a mappable use
     :meth:`~matplotlib.figure.Figure.colorbar`.
-    
+
     """
-    # if the given mappable is a contourset with any hatching, use 
+    # if the given mappable is a contourset with any hatching, use
     # ColorbarPatch else use Colorbar
     if (isinstance(mappable, contour.ContourSet) \
             and any([hatch is not None for hatch in mappable.hatches])):
         cb = ColorbarPatch(cax, mappable, **kwargs)
     else:
         cb = Colorbar(cax, mappable, **kwargs)
-    
+
     mappable.callbacksSM.connect('changed', cb.on_mappable_changed)
     mappable.set_colorbar(cb, cax)
-        
-    return cb            
+
+    return cb
+
diff --git a/lib/matplotlib/contour.py b/lib/matplotlib/contour.py
@@ -844,33 +844,33 @@ def legend_elements(self, variable_name='x', str_format=str):
         """
         Return a list of artist and labels suitable for passing through
         to :func:`plt.legend` which represent this ContourSet.
-         
+
         Args:
-        
-            *variable_name*: the string used inside the innequality used 
+
+            *variable_name*: the string used inside the inequality used
               on the labels
-            
+
             *str_format*: function used to format the numbers in the labels
         """
         artists = []
         labels = []
-                
+
         if self.filled:
             lowers, uppers = self._get_lowers_and_uppers()
             n_levels = len(self.collections)
-            
+
             for i, (collection, lower, upper) in enumerate(zip(self.collections,
                                                                lowers, uppers)):
-                    patch = mpatches.Rectangle((0, 0), 1, 1, 
+                    patch = mpatches.Rectangle((0, 0), 1, 1,
                                                facecolor=collection.get_facecolor()[0],
                                                hatch=collection.get_hatch(),
                                                alpha=collection.get_alpha(),
                                                )
                     artists.append(patch)
-                    
+
                     lower = str_format(lower)
                     upper = str_format(upper)
-                    
+
                     if i == 0 and self.extend in ('lower', 'both'):
                         labels.append(r'$%s \leq %s$' % (variable_name, upper, ))
                     elif i == n_levels-1 and self.extend in ('upper', 'both'):
@@ -879,16 +879,16 @@ def legend_elements(self, variable_name='x', str_format=str):
                         labels.append(r'$%s < %s \leq %s$' % (lower, variable_name, upper))
         else:
             for collection, level in zip(self.collections, self.levels):
-                
+
                 patch = mcoll.LineCollection(None)
                 patch.update_from(collection)
-                    
+
                 artists.append(patch)
                 # format the level for insertion into the labels
                 level = str_format(level)
                 labels.append(r'$%s = %s$' % (variable_name, level))
-                
-        return artists, labels        
+
+        return artists, labels
 
     def _process_args(self, *args, **kwargs):
         """
@@ -1542,11 +1542,13 @@ def _initialize_x_y(self, z):
             points. This may never actually be advantageous, so this option may
             be removed. Chunking introduces artifacts at the chunk boundaries
             unless *antialiased* is *False*.
-            
-          *hatches*: 
+
+          *hatches*:
             A list of cross hatch patterns to use on the filled areas.
             If None, no hatching will be added to the contour.
-            Currently only supported on a few backends.
+            Hatching is supported in the PostScript, PDF, SVG and Agg
+            backends only.
+
 
         Note: contourf fills intervals that are closed at the top; that
         is, for boundaries *z1* and *z2*, the filled region is::
