issue_comments

Yeah, I guess we would only want a legend if we're truly plotting categorical values (e.g., from pandas.cut)

On Thu, Jul 30, 2015 at 5:31 PM, Clark Fitzgerald notifications@github.com wrote:

The legend definitely looks better than the color bar in the seaborn PR.

Reply to this email directly or view it on GitHub: https://github.com/xray/xray/issues/500#issuecomment-126530340

The legend definitely looks better than the color bar in the seaborn PR.

Also worth taking a look at for possible API and/or code inspiration: https://github.com/mwaskom/seaborn/pull/629

Do we want a color bar or a legend for discrete colormaps?

Instead of adding a separate argument cmap_intervals, it might make sense to call the argument levels -- which is the name of the existing contour/contourf argument. Then, it could work consistently between imshow/pcolormesh/contour/contourf.

@jhamman take a look at pandas.cut: http://pandas.pydata.org/pandas-docs/stable/generated/pandas.cut.html

I have this mostly working on my branch now. A few questions before I issue a PR.

@clarkfitzg - do you happen to have any example code that creates intervals from a list? I also think it would be better to only use ticks defined by the user, so your case would need to be: myarray.plot_imshow(cmap_intervals=[-np.inf, -1, 1, np.inf]).

So the user would write something like myarray.plot_imshow(cmap_intervals=5) and see the colors discretized into 5 bins? Sounds nice.

We could also allow a sequence for cmap_intervals so that myarray.plot_imshow(cmap_intervals=[-1, 1]) uses three bins: (-inf, -1], (-1, 1], (1, inf)

Exactly.

I've used something like this to generate the discrete colormap:

``` python def cmap_discretize(cmap, n_colors): """Return a discrete colormap from the continuous colormap cmap.

Parameters
----------
cmap : str or colormap object
    Colormap to discretize.
n_colors : int
    Number of discrete colors to divide `cmap` into.

Returns
----------
discrete_cmap : LinearSegmentedColormap
    Discretized colormap.
"""
from matplotlib.colors import LinearSegmentedColormap
import matplotlib.pyplot as plt

if type(cmap) == basestring:
    cmap = plt.get_cmap(cmap)
colors_i = np.concatenate((np.linspace(0, 1., n_colors), (0., 0., 0., 0.)))
colors_rgba = cmap(colors_i)
indices = np.linspace(0, 1., n_colors + 1)
cdict = {}
for ki, key in enumerate(('red', 'green', 'blue')):
    cdict[key] = [(indices[i], colors_rgba[i - 1, ki], colors_rgba[i, ki])
                  for i in range(n_colors + 1)]
# Return colormap object.
return LinearSegmentedColormap(cmap.name + "_%d" % n_colors, cdict, 1024)

```

Typically, I've manually constructed the colorbar by hand with the discrete colormap:

``` python cmap = cmap_discretize(cmap, n_colors=10) cnorm = mpl.colors.Normalize(vmin=vmin, vmax=vmax) cticks = np.linspace(vmin, vmax, num=cn + 1)

cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=cnorm, orientation='vertical', extend=cbar_extend, ticks=cticks) ```

I'm sure this later part can be improved. Possibly by using matplotlib.ticker.MaxNLocator to find/set the ticks and intervals.

This is also something I often find useful, so +1 from me. contourf does something similar, but it also involves plotting contour lines.