Index: CHANGELOG
===================================================================
--- CHANGELOG	(revision 6445)
+++ CHANGELOG	(working copy)
@@ -1,3 +1,8 @@
+2008-11-24 Added alpha capability for ListedColormap and 
+           LinearSegmentedColormap. Changed default Colormap.__call__
+           alpha value to None. Collections.set_alpha accepts None
+           See 
+           examples/pylab/plot_scatter.py - PI
 2008-11-24 Fix crash in log ticking. - MGD
 
 2008-11-20 Added static helper method BrokenHBarCollection.span_where
Index: doc/api/api_changes.rst
===================================================================
--- doc/api/api_changes.rst	(revision 6445)
+++ doc/api/api_changes.rst	(working copy)
@@ -8,6 +8,10 @@
 
 Changes for 0.98.x
 ==================
+* Changed :meth:`matplotlib.colors.Colormap.__call__` default ``alpha=None``
+  :meth:`matplotlib.colors.LinearSegmentedColormap.__init__` ``segmentdata`` 
+  supports optional ``"alpha"`` key
+  :meth:`matplotlib.collections.Collection.set_alpha` now also accepts ``None``
 
 * Font lookup now uses a nearest-neighbor approach rather than an
   exact match.  Some fonts may be different in plots, but should be
Index: lib/matplotlib/colors.py
===================================================================
--- lib/matplotlib/colors.py	(revision 6445)
+++ lib/matplotlib/colors.py	(working copy)
@@ -452,7 +452,7 @@
         self._isinit = False
 
 
-    def __call__(self, X, alpha=1.0, bytes=False):
+    def __call__(self, X, alpha=None, bytes=False):
         """
         *X* is either a scalar or an array (of any dimension).
         If scalar, a tuple of rgba values is returned, otherwise
@@ -460,15 +460,16 @@
         are integers, then they are used as indices into the array.
         If they are floating point, then they must be in the
         interval (0.0, 1.0).
-        Alpha must be a scalar.
+        Alpha must be a scalar between 0 and 1 or None.
         If bytes is False, the rgba values will be floats on a
         0-1 scale; if True, they will be uint8, 0-255.
         """
 
         if not self._isinit: self._init()
-        alpha = min(alpha, 1.0) # alpha must be between 0 and 1
-        alpha = max(alpha, 0.0)
-        self._lut[:-3, -1] = alpha
+        if alpha is not None:
+            if alpha < 0.0 or alpha > 1.0:
+                raise ValueError("alpha must be in range 0-1")
+            self._lut[:-3, -1] = alpha
         mask_bad = None
         if not cbook.iterable(X):
             vtype = 'scalar'
@@ -558,9 +559,10 @@
     def __init__(self, name, segmentdata, N=256):
         """Create color map from linear mapping segments
 
-        segmentdata argument is a dictionary with a red, green and blue
-        entries. Each entry should be a list of *x*, *y0*, *y1* tuples,
-        forming rows in a table.
+        segmentdata argument is a dictionary with red, green and blue
+        keys. An optional alpha key is also supported. Each value
+        should be a list of *x*, *y0*, *y1* tuples, forming rows in a
+        table. 
 
         Example: suppose you want red to increase from 0 to 1 over
         the bottom half, green to do the same over the middle half,
@@ -606,6 +608,9 @@
         self._lut[:-3, 0] = makeMappingArray(self.N, self._segmentdata['red'])
         self._lut[:-3, 1] = makeMappingArray(self.N, self._segmentdata['green'])
         self._lut[:-3, 2] = makeMappingArray(self.N, self._segmentdata['blue'])
+        if self._segmentdata.has_key('alpha'):
+            self._lut[:-3, 3] = makeMappingArray(self.N,
+                                                 self._segmentdata['alpha'])
         self._isinit = True
         self._set_extremes()
 
@@ -664,11 +669,10 @@
 
 
     def _init(self):
-        rgb = np.array([colorConverter.to_rgb(c)
+        rgba = np.array([colorConverter.to_rgba(c)
                     for c in self.colors], np.float)
         self._lut = np.zeros((self.N + 3, 4), np.float)
-        self._lut[:-3, :-1] = rgb
-        self._lut[:-3, -1] = 1
+        self._lut[:-3] = rgba
         self._isinit = True
         self._set_extremes()
 
Index: lib/matplotlib/collections.py
===================================================================
--- lib/matplotlib/collections.py	(revision 6445)
+++ lib/matplotlib/collections.py	(working copy)
@@ -414,12 +414,12 @@
     def set_alpha(self, alpha):
         """
         Set the alpha tranparencies of the collection.  *alpha* must be
-        a float.
+        a float or None.
 
-        ACCEPTS: float
+        ACCEPTS: float or None
         """
-        try: float(alpha)
-        except TypeError: raise TypeError('alpha must be a float')
+        try: alpha==None or float(alpha)
+        except TypeError: raise TypeError('alpha must be a float or None')
         else:
             artist.Artist.set_alpha(self, alpha)
             try:
Index: examples/pylab_examples/polar_scatter.py
===================================================================
--- examples/pylab_examples/polar_scatter.py	(revision 6445)
+++ examples/pylab_examples/polar_scatter.py	(working copy)
@@ -1,18 +1,46 @@
 #!/usr/bin/env python
 # a polar scatter plot; size increases radially in this example and
 # color increases with angle (just to verify the symbols are being
-# scattered correctlu).  In a real example, this would be wasting
-# dimensionlaity of the plot
-from pylab import *
+# scattered correctly).  In a real example, this would be wasting
+# dimensionality of the plot
+import numpy as np
+from matplotlib.colors import ListedColormap
+from matplotlib.pyplot import figure, show, scatter, subplot, title
 
+figure(1)
 N = 150
-r = 2*rand(N)
-theta = 2*pi*rand(N)
-area = 200*r**2*rand(N)
+r = 2*np.random.rand(N)
+theta = 2*np.pi*np.random.rand(N)
+area = 200*r**2*np.random.rand(N)
 colors = theta
 ax = subplot(111, polar=True)
 c = scatter(theta, r, c=colors, s=area)
 c.set_alpha(0.75)
 
+figure(2)
+# this is an all black colormap, with varying transparency
+# the plot should have points with colors from white: completely 
+# transparent; to gray: semi-transparent, to black: completely opaque.
+my_rgba_array= np.array( [
+    [ 0., 0., 0., 0.0],
+    [ 0., 0., 0., 0.25],
+    [ 0., 0., 0., 0.5],
+    [ 0., 0., 0., 0.75], 
+    [ 0., 0., 0., 1.0]])
+myColormap = ListedColormap(my_rgba_array)
+ax = subplot(111, polar=True)
+title("""black colormap, with varying transparency,
+      there should be levels of gray, not just black and white""",
+      color='red', verticalalignment='top',)
+# N.B. alpha=None is required to use the colormap alpha values,
+# not passing alpha=None will reset the colormap alpha values to 1.0
+c = scatter(theta, r, c=colors,s=area,cmap=myColormap, alpha=None)
+
+# FIXME: uncommenting this will break the transparency on the plot above.
+#figure(3)
+#ax = subplot(111, polar=True)
+#d = scatter(theta, r, c=colors, s=area,cmap=myColormap)
+##c.cmap._init()    #fixes figure(2) only until redraw in figure(3)
+
 #savefig('polar_test2')
 show()
