'aliceblue' : '#F0F8FF',

'antiquewhite' : '#FAEBD7',

'aqua' : '#00FFFF',

'aquamarine' : '#7FFFD4',

'azure' : '#F0FFFF',

'beige' : '#F5F5DC',

'bisque' : '#FFE4C4',

'black' : '#000000',

'blanchedalmond' : '#FFEBCD',

'blue' : '#0000FF',

'blueviolet' : '#8A2BE2',

'brown' : '#A52A2A',

'burlywood' : '#DEB887',

'cadetblue' : '#5F9EA0',

'chartreuse' : '#7FFF00',

'chocolate' : '#D2691E',

'coral' : '#FF7F50',

'cornflowerblue' : '#6495ED',

'cornsilk' : '#FFF8DC',

'crimson' : '#DC143C',

'cyan' : '#00FFFF',

'darkblue' : '#00008B',

'darkcyan' : '#008B8B',

'darkgoldenrod' : '#B8860B',

'darkgray' : '#A9A9A9',

'darkgreen' : '#006400',

'darkkhaki' : '#BDB76B',

'darkmagenta' : '#8B008B',

'darkolivegreen' : '#556B2F',

'darkorange' : '#FF8C00',

'darkorchid' : '#9932CC',

'darkred' : '#8B0000',

'darksalmon' : '#E9967A',

'darkseagreen' : '#8FBC8F',

'darkslateblue' : '#483D8B',

'darkslategray' : '#2F4F4F',

'darkturquoise' : '#00CED1',

'darkviolet' : '#9400D3',

'deeppink' : '#FF1493',

'deepskyblue' : '#00BFFF',

'dimgray' : '#696969',

'dodgerblue' : '#1E90FF',

'firebrick' : '#B22222',

'floralwhite' : '#FFFAF0',

'forestgreen' : '#228B22',

'fuchsia' : '#FF00FF',

'gainsboro' : '#DCDCDC',

'ghostwhite' : '#F8F8FF',

'gold' : '#FFD700',

'goldenrod' : '#DAA520',

'gray' : '#808080',

'green' : '#008000',

'greenyellow' : '#ADFF2F',

'honeydew' : '#F0FFF0',

'hotpink' : '#FF69B4',

'indianred' : '#CD5C5C',

'indigo' : '#4B0082',

'ivory' : '#FFFFF0',

'khaki' : '#F0E68C',

'lavender' : '#E6E6FA',

'lavenderblush' : '#FFF0F5',

'lawngreen' : '#7CFC00',

'lemonchiffon' : '#FFFACD',

'lightblue' : '#ADD8E6',

'lightcoral' : '#F08080',

'lightcyan' : '#E0FFFF',

'lightgoldenrodyellow' : '#FAFAD2',

'lightgreen' : '#90EE90',

'lightgray' : '#D3D3D3',

'lightpink' : '#FFB6C1',

'lightsalmon' : '#FFA07A',

'lightseagreen' : '#20B2AA',

'lightskyblue' : '#87CEFA',

'lightslategray' : '#778899',

'lightsteelblue' : '#B0C4DE',

'lightyellow' : '#FFFFE0',

'lime' : '#00FF00',

'limegreen' : '#32CD32',

'linen' : '#FAF0E6',

'magenta' : '#FF00FF',

'maroon' : '#800000',

'mediumaquamarine' : '#66CDAA',

'mediumblue' : '#0000CD',

'mediumorchid' : '#BA55D3',

'mediumpurple' : '#9370DB',

'mediumseagreen' : '#3CB371',

'mediumslateblue' : '#7B68EE',

'mediumspringgreen' : '#00FA9A',

'mediumturquoise' : '#48D1CC',

'mediumvioletred' : '#C71585',

'midnightblue' : '#191970',

'mintcream' : '#F5FFFA',

'mistyrose' : '#FFE4E1',

'moccasin' : '#FFE4B5',

'navajowhite' : '#FFDEAD',

'navy' : '#000080',

'oldlace' : '#FDF5E6',

'olive' : '#808000',

'olivedrab' : '#6B8E23',

'orange' : '#FFA500',

'orangered' : '#FF4500',

'orchid' : '#DA70D6',

'palegoldenrod' : '#EEE8AA',

'palegreen' : '#98FB98',

'palevioletred' : '#AFEEEE',

'papayawhip' : '#FFEFD5',

'peachpuff' : '#FFDAB9',

'peru' : '#CD853F',

'pink' : '#FFC0CB',

'plum' : '#DDA0DD',

'powderblue' : '#B0E0E6',

'purple' : '#800080',

'red' : '#FF0000',

'rosybrown' : '#BC8F8F',

'royalblue' : '#4169E1',

'saddlebrown' : '#8B4513',

'salmon' : '#FA8072',

'sandybrown' : '#FAA460',

'seagreen' : '#2E8B57',

'seashell' : '#FFF5EE',

'sienna' : '#A0522D',

'silver' : '#C0C0C0',

'skyblue' : '#87CEEB',

'slateblue' : '#6A5ACD',

'slategray' : '#708090',

'snow' : '#FFFAFA',

'springgreen' : '#00FF7F',

'steelblue' : '#4682B4',

'tan' : '#D2B48C',

'teal' : '#008080',

'thistle' : '#D8BFD8',

'tomato' : '#FF6347',

'turquoise' : '#40E0D0',

'violet' : '#EE82EE',

'wheat' : '#F5DEB3',

'white' : '#FFFFFF',

'whitesmoke' : '#F5F5F5',

'yellow' : '#FFFF00',

'yellowgreen' : '#9ACD32',

'Return *True* if *c* can be converted to *RGB*'

try:

colorConverter.to_rgb(c)

return True

except ValueError:

"""

if not isinstance(s, basestring):

raise TypeError('hex2color requires a string argument')

if hexColorPattern.match(s) is None:

raise ValueError('invalid hex color string "%s"' % s)

"""

colors = {

'b' : (0.0, 0.0, 1.0),

'g' : (0.0, 0.5, 0.0),

'r' : (1.0, 0.0, 0.0),

'c' : (0.0, 0.75, 0.75),

'm' : (0.75, 0, 0.75),

'y' : (0.75, 0.75, 0),

'k' : (0.0, 0.0, 0.0),

'w' : (1.0, 1.0, 1.0),

}

cache = {}

def to_rgb(self, arg):

"""

try: return self.cache[arg]

except KeyError: pass

except TypeError: # could be unhashable rgb seq

arg = tuple(arg)

try: return self.cache[arg]

except KeyError: pass

except TypeError:

raise ValueError(

'to_rgb: arg "%s" is unhashable even inside a tuple'

% (str(arg),))

try:

if cbook.is_string_like(arg):

argl = arg.lower()

color = self.colors.get(argl, None)

if color is None:

str1 = cnames.get(argl, argl)

if str1.startswith('#'):

color = hex2color(str1)

else:

fl = float(argl)

if fl < 0 or fl > 1:

raise ValueError(

'gray (string) must be in range 0-1')

color = tuple([fl]*3)

elif cbook.iterable(arg):

if len(arg) > 4 or len(arg) < 3:

raise ValueError(

'sequence length is %d; must be 3 or 4'%len(arg))

color = tuple(arg[:3])

if [x for x in color if (float(x) < 0) or (x > 1)]:

# This will raise TypeError if x is not a number.

raise ValueError('number in rbg sequence outside 0-1 range')

else:

raise ValueError('cannot convert argument to rgb sequence')

self.cache[arg] = color

except (KeyError, ValueError, TypeError) as exc:

raise ValueError('to_rgb: Invalid rgb arg "%s"\n%s' % (str(arg), exc))

# Error messages could be improved by handling TypeError

# separately; but this should be rare and not too hard

# for the user to figure out as-is.

return color

def to_rgba(self, arg, alpha=None):

"""

try:

if arg.lower() == 'none':

return (0.0, 0.0, 0.0, 0.0)

except AttributeError:

pass

try:

if not cbook.is_string_like(arg) and cbook.iterable(arg):

if len(arg) == 4:

if [x for x in arg if (float(x) < 0) or (x > 1)]:

# This will raise TypeError if x is not a number.

raise ValueError('number in rbga sequence outside 0-1 range')

if alpha is None:

return tuple(arg)

if alpha < 0.0 or alpha > 1.0:

raise ValueError("alpha must be in range 0-1")

return arg[0], arg[1], arg[2], alpha

r,g,b = arg[:3]

if [x for x in (r,g,b) if (float(x) < 0) or (x > 1)]:

raise ValueError('number in rbg sequence outside 0-1 range')

else:

r,g,b = self.to_rgb(arg)

if alpha is None:

alpha = 1.0

return r,g,b,alpha

except (TypeError, ValueError) as exc:

raise ValueError('to_rgba: Invalid rgba arg "%s"\n%s' % (str(arg), exc))

def to_rgba_array(self, c, alpha=None):

"""

try:

nc = len(c)

except TypeError:

raise ValueError(

"Cannot convert argument type %s to rgba array" % type(c))

try:

if nc == 0 or c.lower() == 'none':

return np.zeros((0,4), dtype=np.float)

except AttributeError:

pass

try:

# Single value? Put it in an array with a single row.

return np.array([self.to_rgba(c, alpha)], dtype=np.float)

except ValueError:

if isinstance(c, np.ndarray):

if c.ndim != 2 and c.dtype.kind not in 'SU':

raise ValueError("Color array must be two-dimensional")

if (c.ndim == 2 and c.shape[1] == 4 and c.dtype.kind == 'f'):

if (c.ravel() > 1).any() or (c.ravel() < 0).any():

raise ValueError(

"number in rgba sequence is outside 0-1 range")

result = np.asarray(c, np.float)

if alpha is not None:

if alpha > 1 or alpha < 0:

raise ValueError("alpha must be in 0-1 range")

result[:,3] = alpha

return result

# This alpha operation above is new, and depends

# on higher levels to refrain from setting alpha

# to values other than None unless there is

# intent to override any existing alpha values.

# It must be some other sequence of color specs.

result = np.zeros((nc, 4), dtype=np.float)

for i, cc in enumerate(c):

result[i] = self.to_rgba(cc, alpha)

"""Create an *N* -element 1-d lookup table

if callable(data):

xind = np.linspace(0, 1, N)**gamma

lut = np.clip(np.array(data(xind), dtype=np.float), 0, 1)

return lut

try:

adata = np.array(data)

except:

raise TypeError("data must be convertable to an array")

shape = adata.shape

if len(shape) != 2 and shape[1] != 3:

raise ValueError("data must be nx3 format")

x = adata[:,0]

y0 = adata[:,1]

y1 = adata[:,2]

if x[0] != 0. or x[-1] != 1.0:

raise ValueError(

"data mapping points must start with x=0. and end with x=1")

if np.sometrue(np.sort(x)-x):

raise ValueError(

"data mapping points must have x in increasing order")

# begin generation of lookup table

x = x * (N-1)

lut = np.zeros((N,), np.float)

xind = (N - 1) * np.linspace(0, 1, N)**gamma

ind = np.searchsorted(x, xind)[1:-1]

lut[1:-1] = ( ((xind[1:-1] - x[ind-1]) / (x[ind] - x[ind-1]))

* (y0[ind] - y1[ind-1]) + y1[ind-1])

lut[0] = y1[0]

lut[-1] = y0[-1]

# ensure that the lut is confined to values between 0 and 1 by clipping it

np.clip(lut, 0.0, 1.0)

#lut = where(lut > 1., 1., lut)

#lut = where(lut < 0., 0., lut)

"""Base class for all scalar to rgb mappings

def __init__(self, name, N=256):

"""

self.name = name

self.N = N

self._rgba_bad = (0.0, 0.0, 0.0, 0.0) # If bad, don't paint anything.

self._rgba_under = None

self._rgba_over = None

self._i_under = N

self._i_over = N+1

self._i_bad = N+2

self._isinit = False

def __call__(self, X, alpha=None, bytes=False):

"""

if not self._isinit: self._init()

mask_bad = None

if not cbook.iterable(X):

vtype = 'scalar'

xa = np.array([X])

else:

vtype = 'array'

xma = ma.array(X, copy=False)

mask_bad = xma.mask

xa = xma.data.copy() # Copy here to avoid side effects.

del xma

# masked values are substituted below; no need to fill them here

if xa.dtype.char in np.typecodes['Float']:

# Treat 1.0 as slightly less than 1.

cbook._putmask(xa, xa==1.0, np.nextafter(xa.dtype.type(1),

xa.dtype.type(0)))

# The following clip is fast, and prevents possible

# conversion of large positive values to negative integers.

xa *= self.N

if NP_CLIP_OUT:

np.clip(xa, -1, self.N, out=xa)

else:

xa = np.clip(xa, -1, self.N)

# ensure that all 'under' values will still have negative

# value after casting to int

cbook._putmask(xa, xa<0.0, -1)

xa = xa.astype(int)

# Set the over-range indices before the under-range;

# otherwise the under-range values get converted to over-range.

cbook._putmask(xa, xa>self.N-1, self._i_over)

cbook._putmask(xa, xa<0, self._i_under)

if mask_bad is not None:

if mask_bad.shape == xa.shape:

cbook._putmask(xa, mask_bad, self._i_bad)

elif mask_bad:

xa.fill(self._i_bad)

if bytes:

lut = (self._lut * 255).astype(np.uint8)

else:

lut = self._lut.copy() # Don't let alpha modify original _lut.

if alpha is not None:

alpha = min(alpha, 1.0) # alpha must be between 0 and 1

alpha = max(alpha, 0.0)

if bytes:

alpha = int(alpha * 255)

if (lut[-1] == 0).all():

lut[:-1, -1] = alpha

# All zeros is taken as a flag for the default bad

# color, which is no color--fully transparent. We

# don't want to override this.

else:

lut[:,-1] = alpha

# If the bad value is set to have a color, then we

# override its alpha just as for any other value.

rgba = np.empty(shape=xa.shape+(4,), dtype=lut.dtype)

lut.take(xa, axis=0, mode='clip', out=rgba)

# twice as fast as lut[xa];

# using the clip or wrap mode and providing an

# output array speeds it up a little more.

if vtype == 'scalar':

rgba = tuple(rgba[0,:])

return rgba

def set_bad(self, color = 'k', alpha = None):

'''Set color to be used for masked values.

self._rgba_bad = colorConverter.to_rgba(color, alpha)

if self._isinit: self._set_extremes()

def set_under(self, color = 'k', alpha = None):

'''Set color to be used for low out-of-range values.

self._rgba_under = colorConverter.to_rgba(color, alpha)

if self._isinit: self._set_extremes()

def set_over(self, color = 'k', alpha = None):

'''Set color to be used for high out-of-range values.

self._rgba_over = colorConverter.to_rgba(color, alpha)

if self._isinit: self._set_extremes()

def _set_extremes(self):

if self._rgba_under:

self._lut[self._i_under] = self._rgba_under

else:

self._lut[self._i_under] = self._lut[0]

if self._rgba_over:

self._lut[self._i_over] = self._rgba_over

else:

self._lut[self._i_over] = self._lut[self.N-1]

self._lut[self._i_bad] = self._rgba_bad

def _init(self):

'''Generate the lookup table, self._lut'''

raise NotImplementedError("Abstract class only")

def is_gray(self):

if not self._isinit: self._init()

return (np.alltrue(self._lut[:,0] == self._lut[:,1])

"""Colormap objects based on lookup tables using linear segments.

def __init__(self, name, segmentdata, N=256, gamma=1.0):

"""Create color map from linear mapping segments

self.monochrome = False # True only if all colors in map are identical;

# needed for contouring.

Colormap.__init__(self, name, N)

self._segmentdata = segmentdata

self._gamma = gamma

def _init(self):

self._lut = np.ones((self.N + 3, 4), np.float)

self._lut[:-3, 0] = makeMappingArray(self.N,

self._segmentdata['red'], self._gamma)

self._lut[:-3, 1] = makeMappingArray(self.N,

self._segmentdata['green'], self._gamma)

self._lut[:-3, 2] = makeMappingArray(self.N,

self._segmentdata['blue'], self._gamma)

if 'alpha' in self._segmentdata:

self._lut[:-3, 3] = makeMappingArray(self.N,

self._segmentdata['alpha'], 1)

self._isinit = True

self._set_extremes()

def set_gamma(self, gamma):

"""

self._gamma = gamma

self._init()

@staticmethod

def from_list(name, colors, N=256, gamma=1.0):

"""

if not cbook.iterable(colors):

raise ValueError('colors must be iterable')

if cbook.iterable(colors[0]) and len(colors[0]) == 2 and \

not cbook.is_string_like(colors[0]):

# List of value, color pairs

vals, colors = zip(*colors)

else:

vals = np.linspace(0., 1., len(colors))

cdict = dict(red=[], green=[], blue=[], alpha=[])

for val, color in zip(vals, colors):

r,g,b,a = colorConverter.to_rgba(color)

cdict['red'].append((val, r, r))

cdict['green'].append((val, g, g))

cdict['blue'].append((val, b, b))

cdict['alpha'].append((val, a, a))

"""Colormap object generated from a list of colors.

def __init__(self, colors, name = 'from_list', N = None):

"""

self.colors = colors

self.monochrome = False # True only if all colors in map are identical;

# needed for contouring.

if N is None:

N = len(self.colors)

else:

if cbook.is_string_like(self.colors):

self.colors = [self.colors] * N

self.monochrome = True

elif cbook.iterable(self.colors):

self.colors = list(self.colors) # in case it was a tuple

if len(self.colors) == 1:

self.monochrome = True

if len(self.colors) < N:

self.colors = list(self.colors) * N

del(self.colors[N:])

else:

try: gray = float(self.colors)

except TypeError: pass

else: self.colors = [gray] * N

self.monochrome = True

Colormap.__init__(self, name, N)

def _init(self):

rgba = colorConverter.to_rgba_array(self.colors)

self._lut = np.zeros((self.N + 3, 4), np.float)

self._lut[:-3] = rgba

self._isinit = True

"""

def __init__(self, vmin=None, vmax=None, clip=False):

"""

self.vmin = vmin

self.vmax = vmax

self.clip = clip

@staticmethod

def process_value(value):

"""

if cbook.iterable(value):

is_scalar = False

result = ma.asarray(value)

if result.dtype.kind == 'f':

if isinstance(value, np.ndarray):

result = result.copy()

elif result.dtype.itemsize > 2:

result = result.astype(np.float)

else:

result = result.astype(np.float32)

else:

is_scalar = True

result = ma.array([value]).astype(np.float)

return result, is_scalar

def __call__(self, value, clip=None):

if clip is None:

clip = self.clip

result, is_scalar = self.process_value(value)

self.autoscale_None(result)

vmin, vmax = self.vmin, self.vmax

if vmin > vmax:

raise ValueError("minvalue must be less than or equal to maxvalue")

elif vmin == vmax:

result.fill(0) # Or should it be all masked? Or 0.5?

else:

vmin = float(vmin)

vmax = float(vmax)

if clip:

mask = ma.getmask(result)

result = ma.array(np.clip(result.filled(vmax), vmin, vmax),

mask=mask)

# ma division is very slow; we can take a shortcut

resdat = result.data

resdat -= vmin

resdat /= (vmax - vmin)

result = np.ma.array(resdat, mask=result.mask, copy=False)

if is_scalar:

result = result[0]

return result

def inverse(self, value):

if not self.scaled():

raise ValueError("Not invertible until scaled")

vmin = float(self.vmin)

vmax = float(self.vmax)

if cbook.iterable(value):

val = ma.asarray(value)

return vmin + val * (vmax - vmin)

else:

return vmin + value * (vmax - vmin)

def autoscale(self, A):

'''

self.vmin = ma.min(A)

self.vmax = ma.max(A)

def autoscale_None(self, A):

' autoscale only None-valued vmin or vmax'

if self.vmin is None:

self.vmin = ma.min(A)

if self.vmax is None:

self.vmax = ma.max(A)

def scaled(self):

'return true if vmin and vmax set'

"""

def __call__(self, value, clip=None):

if clip is None:

clip = self.clip

result, is_scalar = self.process_value(value)

result = ma.masked_less_equal(result, 0, copy=False)

self.autoscale_None(result)

vmin, vmax = self.vmin, self.vmax

if vmin > vmax:

raise ValueError("minvalue must be less than or equal to maxvalue")

elif vmin<=0:

raise ValueError("values must all be positive")

elif vmin==vmax:

result.fill(0)

else:

if clip:

mask = ma.getmask(result)

val = ma.array(np.clip(result.filled(vmax), vmin, vmax),

mask=mask)

#result = (ma.log(result)-np.log(vmin))/(np.log(vmax)-np.log(vmin))

# in-place equivalent of above can be much faster

resdat = result.data

mask = result.mask

if mask is np.ma.nomask:

mask = (resdat <= 0)

else:

mask |= resdat <= 0

cbook._putmask(resdat, mask, 1)

np.log(resdat, resdat)

resdat -= np.log(vmin)

resdat /= (np.log(vmax) - np.log(vmin))

result = np.ma.array(resdat, mask=mask, copy=False)

if is_scalar:

result = result[0]

return result

def inverse(self, value):

if not self.scaled():

raise ValueError("Not invertible until scaled")

vmin, vmax = self.vmin, self.vmax

if cbook.iterable(value):

val = ma.asarray(value)

return vmin * ma.power((vmax/vmin), val)

else:

return vmin * pow((vmax/vmin), value)

def autoscale(self, A):

'''

A = ma.masked_less_equal(A, 0, copy=False)

self.vmin = ma.min(A)

self.vmax = ma.max(A)

def autoscale_None(self, A):

' autoscale only None-valued vmin or vmax'

if self.vmin is not None and self.vmax is not None:

return

A = ma.masked_less_equal(A, 0, copy=False)

if self.vmin is None:

self.vmin = ma.min(A)

if self.vmax is None:

'''

def __init__(self, boundaries, ncolors, clip=False):

'''