def colormap_figure():
""" Generate a figure demonstrating the colormap() function.
"""
fig, ax = plt.subplots(cmsize=(20.0, 4.0))
fig.subplots_adjust(leftm=1.5, rightm=1.5, topm=0, bottomm=2)
colors = palettes['muted']
cmcolors = [
colors['red'],
lighter(colors['orange'], 0.85),
lighter(colors['yellow'], 0.2),
lighter(colors['lightblue'], 0.8), colors['blue']
]
cmvalues = [0.0, 0.25, 0.5, 0.8, 1.0]
colormap('RYB', cmcolors, cmvalues)
plot_colormap(ax, 'RYB', False)
fig.savefig('colors-colormap.png')
def lighter_figure():
""" Generate figures demonstrating the lighter() function.
"""
color = palettes['muted']['blue']
n = 10
fig, ax = plt.subplots(cmsize=(1 + 2.2 * (n + 1), 3))
fig.subplots_adjust(leftm=0, rightm=0, topm=0, bottomm=0)
ax.show_spines('')
rectx = np.array([0.0, 1.0, 1.0, 0.0, 0.0])
recty = np.array([0.0, 0.0, 1.0, 1.0, 0.0])
for k in range(n + 1):
fac = 1.0 - k / float(n)
ax.fill(rectx + 1.2 * k, recty, color=lighter(color, fac))
ax.text(0.5 + 1.2 * k, -0.3, '%.0f%%' % (100 * fac), ha='center')
ax.set_xlim(-0.1, (n + 1) * 1.2 - 0.1)
ax.set_ylim(-0.4, 1.02)
fig.savefig('colors-lighter.png')
def lighter_darker_styles(style, n):
""" Duplicate style with a range of lighter and darker colors.
Parameters
----------
style: dict
A dictionary holding plot style parameter like `linewidth` and `color` or `facecolor`.
n: int
Number of modified colors to be generated (`n>1`).
Returns
-------
styles: list of dict
`n` copies of `style` with `color` or `facecolor` starting from a lighter color,
traversing over the original color to darker colors.
The central style has the original color if `n` is odd.
Example
-------
Suppose you have a style for blue lines in a plot like
```py
lsBlue = dict(color=colors['blue'], lw=2)
```
Now you need 5 variants of this plot style with lighter and darker colors.
Just call
```py
lsBlues = lighter_darker_styles(lsBlue, 5)
```
and you can do something like
```py
for k, ls in enumerate(lsBlues):
ax.plot(x, y+0.5*k, **ls)
```
"""
for ck in ['color', 'facecolor']:
if ck in style:
c = style[ck]
styles = []
for k in range(n):
sd = dict(**style)
sd[ck] = lighter(c, 1 + (k - (n - 1) / 2) / ((n + 1) // 2))
styles.append(sd)
return styles
return [style] * n
def lighter_styles(style, n):
""" Duplicate style with a range of lighter colors.
Parameters
----------
style: dict
A dictionary holding plot style parameter like `linewidth` and `color` or `facecolor`.
n: int
Number of lighter colors to be generated (`n>1`).
Returns
-------
styles: list of dict
`n` copies of `style` with increasingly lighter `color` or `facecolor`.
The first style is the original one.
Example
-------
Suppose you have a style for blue lines in a plot like
```py
lsBlue = dict(color=colors['blue'], lw=2)
```
Now you need 5 variants of this plot style with increasingly lighter colors.
Just call
```py
lsBlues = lighter_styles(lsBlue, 5)
```
and you can do something like
```py
for k, ls in enumerate(lsBlues):
ax.plot(x, y+0.5*k, **ls)
```
"""
for ck in ['color', 'facecolor']:
if ck in style:
c = style[ck]
styles = []
for k in range(n):
sd = dict(**style)
sd[ck] = lighter(c, 1.0 - k / n)
styles.append(sd)
return styles
return [style] * n
def make_fillstyles(prefix,
names,
suffixes,
colors,
edgecolors,
edgewidths,
fillalphas,
namespace=None,
**kwargs):
""" Generate fill styles.
The generated dictionaries can be passed as key-word arguments
to `ax.fill_between()` commands.
For each corresponding name, color, edge color, edge width and alpha
a dictionary is generated holding these attributes.
The generated dictionaries are named `prefix + name + suffix`,
and are additionally added to the `prefix + suffix` dictionary in the given namespace.
`name` is also added to the `style_names` list in the namespace.
For example
```py
make_fillstyles('fs', 'PSD', ['', 's', 'a'], [#00FF00], 2.0, 0.5, 0.4)
```
generates the dictionaries named `fsPSD`, `fsPSDs`, `fsPSDa` defining a green fill color.
The first, `fsPSD` gets a black edge color with edge width set to 0.5.
The second, `fsPSDs` is without edge.
The third, `fsPSDa` is without edge and has alpha set to 0.4.
Further, `PSD` is added to `style_names`, and the three dictionaries are added
to the `fs`, `fss` and `fsa` dictionaries under the key `PSD`.
Simply throw the dictionaries into a `fill_between()` command:
```py
plt.fill_between(x, y0, y1, **fsPSD)
```
or like this (here for a transparent fill style):
```py
plt.plot(x, y, **fsa['PSD'])
```
Parameters
----------
prefix: string
Prefix prepended to all fill style names.
names: string or list of strings
Names of the line styles.
If string and a '%' is contained, then formats like '%d' are replaced
by the index of the line style plus one.
suffixes: list of strings or None
Sufffixes appended to all fill style names. The first is for a
fill style with edge color, the second for a solid fill style
without edge, and the third for a transparent fill style without
edge. If None the corresponding style is not generated.
colors: matplotlib color or list of matplotlib colors
Fill colors.
edgecolors: float or list of floats
Defines edge colors for the first fill style.
It is passed as the lightness argument to `lighter()`
using the face color from `colors`. That is, 0 results in a white edge color,
1 in an edge with the same color as the face color, and 2 in a black edge color.
edgewidth: float or list of floats
Widths for the edge color of the first fill style.
fillalphas: float or list of floats
Alpha values for the transparent (third) fill style.
namespace: dict or None
Namespace to which the generated fill styles are added.
If None add fill styles to the __main__ module.
kwargs: dict
Key-word arguments with further fill properties, e.g. zorder.
"""
# prepare dictionaries:
if namespace is None:
namespace = __main__
if not hasattr(namespace, 'style_names'):
namespace.style_names = []
for suffix in suffixes:
if suffix is not None:
ln = prefix + suffix
if not hasattr(namespace, ln):
setattr(namespace, ln, {})
# number of line styles to be generated:
n = 1
for x in (names, colors, edgecolors, edgewidths, fillalphas):
if isinstance(x, (tuple, list)) and len(x) > n:
n = len(x)
# generate styles:
for k in range(n):
if isinstance(names, (tuple, list)):
name = names[k]
else:
if '%' in names:
name = names % (k + 1)
else:
name = names
if name not in namespace.style_names:
namespace.style_names.append(name)
for j, suffix in enumerate(suffixes):
if suffix is not None:
sn = prefix + name + suffix
c = colors[k] if isinstance(colors, (tuple, list)) else colors
ec = edgecolors[k] if isinstance(edgecolors,
(tuple, list)) else edgecolors
ew = edgewidths[k] if isinstance(edgewidths,
(tuple, list)) else edgewidths
fa = fillalphas[k] if isinstance(fillalphas,
(tuple, list)) else fillalphas
filldict = dict(facecolor=c, **kwargs)
if j == 0: # fill with edge:
filldict.update(
dict(edgecolor=lighter(c, ec), linewidth=ew))
elif j == 1: # fill without edge:
filldict.update(dict(edgecolor='none'))
elif j == 2: # fill without edge, with alpha:
filldict.update(dict(edgecolor='none', alpha=fa))
setattr(namespace, sn, filldict)
getattr(namespace, prefix + suffix)[name] = filldict
def make_pointstyles(prefix,
names,
suffix,
colors,
dashes='none',
lws=0,
markers=('o', 1.0),
markersizes=5.0,
markeredgecolors=0.0,
markeredgewidths=1.0,
namespace=None,
**kwargs):
""" Generate point styles.
The generated dictionaries can be passed as key-word arguments to `ax.plot()` commands.
For each corresponding name, color, line style, line width, marker, marker size,
marker edge color and marker edge width a dictionary is generated holding these attributes.
The generated dictionaries are named `prefix + name + suffix`,
and are additionally added to the `prefix + suffix` dictionary in the given namespace.
`name` is also added to the `style_names` list in the namespace.
For example
```py
make_pointstyles('ps', 'Female', '', 'red', '-', 1, ('o', 1.0), 8, 0.5, 1, alpha=0.5)
```
generates a dictionary named `psFemale` defining transparent red filled markers
with a lighter edge, adds `Female` to `style_names`,
and adds the dictionary to `ps` under the key `Female`.
Simply throw the dictionary into a `plot()` command:
```py
plt.plot(x, y, **psFemale)
```
this is the same as:
```py
plt.plot(x, y, **ps['Female'])
```
This
```py
make_pointstyles('ps', 'Reds%d', 'c', ['red', 'orange', 'yellow'], 'none', 0, ('o', 1.0), 8, 1, 0)
```
generates 'psReds1', 'psReds2', 'psReds3' for plotting
filled circels with colors red, orange, and yellow, respectively.
Parameters
----------
prefix: string
Prefix prepended to all point style names.
names: string or list of strings
Names of the line styles.
If string and a '%' is contained, then formats like '%d' are replaced
by the index of the line style plus one.
suffix: string or list of strings
Sufffix appended to all point style names.
colors: matplotlib color or list of matplotlib colors
For each color in the list a point style is generated.
dashes: matplotlib linestyle or list of matplotlib linestyles
Dash styles of the connecting lines. If points are not to be connected, set to 'none'.
lws: float or list of floats
Widths of the connecting lines.
markers: 2-tuple or list of 2-tuples
For each point style a marker. The first element of the inner tuple is
the marker symbol, the second one is a factor that is used to scale
the marker's size.
markersizes: float or list of floats
For each point style a marker size. The marker size is multiplied with a factor
of the corresponding marker.
medgecolors: float or list of floats
Defines the edge color for each point style.
It is passed as the lightness argument to `lighter()`
using the face color form `colors`. That is, 0 results in a white edge color,
1 in an edge with the same color as the face color, and 2 in a black edge color.
markersizes: float, list of floats
For each point style a marker edge width.
namespace: dict or None
Namespace to which the generated point styles are added.
If None add point styles to the __main__ module.
kwargs: dict
Key-word arguments with further marker properties, e.g. alpha, zorder.
"""
# prepare dictionaries:
if namespace is None:
namespace = __main__
if not hasattr(namespace, 'style_names'):
namespace.style_names = []
if not isinstance(suffix, (tuple, list)):
suffix = [suffix]
for sf in suffix:
ln = prefix + sf
if not hasattr(namespace, ln):
setattr(namespace, ln, {})
# number of markers:
n_markers = 1
if len(markers) >= 2 and isinstance(markers[1], (tuple, list)):
n_markers = len(markers)
# number of line styles to be generated:
n = 1
for x in (names, suffix, colors, dashes, lws, markersizes,
markeredgecolors, markeredgewidths):
if isinstance(x, (tuple, list)) and len(x) > n:
n = len(x)
if n < n_markers:
n = n_markers
# generate styles:
for k in range(n):
if isinstance(names, (tuple, list)):
name = names[k]
else:
if '%' in names:
name = names % (k + 1)
else:
name = names
if name not in namespace.style_names:
namespace.style_names.append(name)
sf = suffix[k % len(suffix)]
c = colors[k] if isinstance(colors, (tuple, list)) else colors
ds = dashes[k] if isinstance(dashes, (tuple, list)) else dashes
lw = lws[k] if isinstance(lws, (tuple, list)) else lws
mk = markers[k] if n_markers > 1 else markers
ms = markersizes[k] if isinstance(markersizes,
(tuple, list)) else markersizes
mc = markeredgecolors[k] if isinstance(markeredgecolors,
(tuple,
list)) else markeredgecolors
mw = markeredgewidths[k] if isinstance(markeredgewidths,
(tuple,
list)) else markeredgewidths
pd = dict(color=c,
linestyle=ds,
linewidth=lw,
marker=mk[0],
markersize=mk[1] * ms,
markeredgecolor=lighter(c, mc),
markeredgewidth=mw,
**kwargs)
setattr(namespace, prefix + name + sf, pd)
getattr(namespace, ln)[prefix + sf] = pd