'BinNorm', 'CmapDict', 'ColorDict',

'LinearSegmentedNorm',

'LinearSegmentedColormap',

'ListedColormap',

'MidpointNorm', 'PerceptuallyUniformColormap',

'cmaps', 'colors', 'cycles', 'fonts',

'make_mapping_array',

'register_cmaps', 'register_colors', 'register_cycles', 'register_fonts',

'saturate', 'shade', 'show_cmaps', 'show_channels',

'show_colors', 'show_colorspaces', 'show_cycles', 'show_fonts',

'to_rgb', 'to_xyz',

'Colormap', 'Colors', 'Cycle', 'Norm',

'Matplotlib defaults': (

'default', 'classic',

),

'Matplotlib stylesheets': (

'colorblind', 'colorblind10', 'ggplot', 'bmh', 'solarized', '538',

),

'ColorBrewer2.0 qualitative': (

'Accent', 'Dark2',

'Paired', 'Pastel1', 'Pastel2',

'Set1', 'Set2', 'Set3',

),

'Other qualitative': (

'FlatUI', 'Qual1', 'Qual2',

),

# Assorted origin, but these belong together

'Grayscale': (

'Grays', 'Mono', 'GrayC', 'GrayCycle',

),

# Builtin

'Matplotlib sequential': (

'viridis', 'plasma', 'inferno', 'magma', 'cividis',

),

'Matplotlib cyclic': (

'twilight',

),

# Seaborn

'Seaborn sequential': (

'Rocket', 'Mako',

),

'Seaborn diverging': (

'IceFire', 'Vlag',

),

# PerceptuallyUniformColormap

'ProPlot sequential': (

'Fire',

'Stellar',

'Boreal',

'Marine',

'Dusk',

'Glacial',

'Sunrise',

'Sunset',

),

'ProPlot diverging': (

'Div', 'NegPos', 'DryWet',

),

# Nice diverging maps

'Other diverging': (

'ColdHot', 'CoolWarm', 'BR',

),

# cmOcean

'cmOcean sequential': (

'Oxy', 'Thermal', 'Dense', 'Ice', 'Haline',

'Deep', 'Algae', 'Tempo', 'Speed', 'Turbid', 'Solar', 'Matter',

'Amp',

),

'cmOcean diverging': (

'Balance', 'Delta', 'Curl',

),

'cmOcean cyclic': (

'Phase',

),

# Fabio Crameri

'Scientific colour maps sequential': (

'batlow', 'oleron',

'devon', 'davos', 'oslo', 'lapaz', 'acton',

'lajolla', 'bilbao', 'tokyo', 'turku', 'bamako', 'nuuk',

'hawaii', 'buda', 'imola',

),

'Scientific colour maps diverging': (

'roma', 'broc', 'cork', 'vik', 'berlin', 'lisbon', 'tofino',

),

'Scientific colour maps cyclic': (

'romaO', 'brocO', 'corkO', 'vikO',

),

# ColorBrewer

'ColorBrewer2.0 sequential': (

'Purples', 'Blues', 'Greens', 'Oranges', 'Reds',

'YlOrBr', 'YlOrRd', 'OrRd', 'PuRd', 'RdPu', 'BuPu',

'PuBu', 'PuBuGn', 'BuGn', 'GnBu', 'YlGnBu', 'YlGn'

),

'ColorBrewer2.0 diverging': (

'Spectral', 'PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdGY',

'RdBu', 'RdYlBu', 'RdYlGn',

),

# SciVisColor

'SciVisColor blues': (

'Blue0', 'Blue1', 'Blue2', 'Blue3', 'Blue4', 'Blue5',

'Blue6', 'Blue7', 'Blue8', 'Blue9', 'Blue10', 'Blue11',

),

'SciVisColor greens': (

'Green1', 'Green2', 'Green3', 'Green4', 'Green5',

'Green6', 'Green7', 'Green8',

),

'SciVisColor oranges': (

'Orange1', 'Orange2', 'Orange3', 'Orange4', 'Orange5',

'Orange6', 'Orange7', 'Orange8',

),

'SciVisColor browns': (

'Brown1', 'Brown2', 'Brown3', 'Brown4', 'Brown5',

'Brown6', 'Brown7', 'Brown8', 'Brown9',

),

'SciVisColor reds and purples': (

'RedPurple1', 'RedPurple2', 'RedPurple3', 'RedPurple4',

'RedPurple5', 'RedPurple6', 'RedPurple7', 'RedPurple8',

),

# Builtin maps that will be deleted; categories are taken from comments in

# matplotlib source code. Some of these are really bad, some are segmented

# maps when the should be color cycles, and some are just uninspiring.

'MATLAB': (

'bone', 'cool', 'copper', 'autumn', 'flag', 'prism',

'jet', 'hsv', 'hot', 'spring', 'summer', 'winter', 'pink', 'gray',

),

'GNUplot': (

'gnuplot', 'gnuplot2', 'ocean', 'afmhot', 'rainbow',

),

'GIST': (

'gist_earth', 'gist_gray', 'gist_heat', 'gist_ncar',

'gist_rainbow', 'gist_stern', 'gist_yarg',

),

'Other': (

'binary', 'bwr', 'brg', # appear to be custom matplotlib

'cubehelix', 'Wistia', 'CMRmap', # individually released

'seismic', 'terrain', 'nipy_spectral', # origin ambiguous

'tab10', 'tab20', 'tab20b', 'tab20c', # merged colormap cycles

)

(key1.lower(), key2.lower()) for key1, key2 in (

('PiYG', 'GYPi'),

('PRGn', 'GnRP'),

('BrBG', 'GBBr'),

('PuOr', 'OrPu'),

('RdGy', 'GyRd'),

('RdBu', 'BuRd'),

('RdYlBu', 'BuYlRd'),

('RdYlGn', 'GnYlRd'),

('BR', 'RB'),

('CoolWarm', 'WarmCool'),

('ColdHot', 'HotCold'),

('NegPos', 'PosNeg'),

('DryWet', 'WetDry')

('/', ' '),

('\'s', ''),

(r'\s?majesty', ''), # purple mountains majesty is too long

('reddish', 'red'), # remove 'ish'

('purplish', 'purple'),

('bluish', 'blue'),

(r'ish\b', ''),

('grey', 'gray'),

('pinky', 'pink'),

('greeny', 'green'),

('bluey', 'blue'),

('purply', 'purple'),

('purpley', 'purple'),

('yellowy', 'yellow'),

('robin egg', 'robins egg'),

('egg blue', 'egg'),

('bluegray', 'blue gray'),

('grayblue', 'gray blue'),

('lightblue', 'light blue'),

'charcoal', 'sky blue', 'eggshell', 'sea blue', 'coral', 'aqua',

'tomato red', 'brick red', 'crimson',

'red orange', 'yellow orange', 'yellow green', 'blue green',

'blue violet', 'red violet',

'red', 'pink', 'grape', 'violet',

'indigo', 'blue', 'cyan', 'teal',

'green', 'lime', 'yellow', 'orange', 'gray'

'blue': (0, 0, 1),

'green': (0, 0.5, 0),

'red': (1, 0, 0),

'cyan': (0, 0.75, 0.75),

'magenta': (0.75, 0, 0.75),

'yellow': (0.75, 0.75, 0),

'black': (0, 0, 0),

'white': (1, 1, 1),

"""

# Interpret channel

if callable(color) or isinstance(color, Number):

return color

if channel == 'hue':

channel = 0

elif channel in ('chroma', 'saturation'):

channel = 1

elif channel == 'luminance':

channel = 2

else:

raise ValueError(f'Unknown channel {channel!r}.')

# Interpret string or RGB tuple

offset = 0

if isinstance(color, str):

match = re.search('([-+][0-9.]+)$', color)

if match:

offset = float(match.group(0))

color = color[:match.start()]

"""

*color, alpha = to_rgb(color, alpha=True)

color = [*hsluv.rgb_to_hsl(*color)]

# multiply luminance by this value

color[2] = max(0, min(color[2] * scale, 100))

color = [*hsluv.hsl_to_rgb(*color)]

"""

*color, alpha = to_rgb(color, alpha=True)

color = [*hsluv.rgb_to_hsl(*color)]

# multiply luminance by this value

color[1] = max(0, min(color[1] * scale, 100))

color = [*hsluv.hsl_to_rgb(*color)]

"""

# Convert color cycle strings

if isinstance(color, str) and re.match('^C[0-9]$', color):

if isinstance(cycle, str):

try:

cycle = mcm.cmap_d[cycle].colors

except (KeyError, AttributeError):

cycles = sorted(

name for name, cmap in mcm.cmap_d.items()

if isinstance(cmap, ListedColormap)

)

raise ValueError(

f'Invalid cycle {cycle!r}. Options are: '

+ ', '.join(map(repr, cycles)) + '.'

)

elif cycle is None:

cycle = rcParams['axes.prop_cycle'].by_key()

if 'color' not in cycle:

cycle = ['k']

else:

cycle = cycle['color']

else:

raise ValueError(f'Invalid cycle {cycle!r}.')

color = cycle[int(color[-1]) % len(cycle)]

# Translate RGB strings and (cmap,index) tuples

opacity = 1

if isinstance(color, str) or (np.iterable(color) and len(color) == 2):

try:

*color, opacity = mcolors.to_rgba(color) # ensure is valid color

except (ValueError, TypeError):

raise ValueError(f'Invalid RGB argument {color!r}.')

# Pull out alpha channel

if len(color) == 4:

*color, opacity = color

elif len(color) != 3:

raise ValueError(f'Invalid RGB argument {color!r}.')

# Translate arbitrary colorspaces

if space == 'rgb':

try:

if any(c > 2 for c in color):

color = [c / 255 for c in color] # scale to within 0-1

color = tuple(color)

except (ValueError, TypeError):

raise ValueError(f'Invalid RGB argument {color!r}.')

elif space == 'hsv':

color = hsluv.hsl_to_rgb(*color)

elif space == 'hpl':

color = hsluv.hpluv_to_rgb(*color)

elif space == 'hsl':

color = hsluv.hsluv_to_rgb(*color)

elif space == 'hcl':

color = hsluv.hcl_to_rgb(*color)

else:

raise ValueError('Invalid color {color!r} for colorspace {space!r}.')

# Return RGB or RGBA

if alpha:

return (*color, opacity)

else:

"""

# Run tuple conversions

# NOTE: Don't pass color tuple, because we may want to permit

# out-of-bounds RGB values to invert conversion

*color, opacity = to_rgb(color, alpha=True)

if space == 'rgb':

pass

elif space == 'hsv':

color = hsluv.rgb_to_hsl(*color) # rgb_to_hsv would also work

elif space == 'hpl':

color = hsluv.rgb_to_hpluv(*color)

elif space == 'hsl':

color = hsluv.rgb_to_hsluv(*color)

elif space == 'hcl':

color = hsluv.rgb_to_hcl(*color)

else:

raise ValueError(f'Invalid colorspace {space}.')

if alpha:

return (*color, opacity)

else:

"""

# Clip colors

colors = np.array(colors)

over = (colors > 1)

under = (colors < 0)

if clip:

colors[under] = 0

colors[over] = 1

else:

colors[(under | over)] = gray

# Message

# NOTE: Never print warning because happens when using builtin maps

# message = 'Clipped' if clip else 'Invalid'

# for i,name in enumerate('rgb'):

# if under[:,i].any():

# _warn_proplot(f'{message} {name!r} channel ( < 0).')

# if over[:,i].any():

# _warn_proplot(f'{message} {name!r} channel ( > 1).')

"""

# Allow callables

if callable(values):

return values

values = np.atleast_1d(values)

if len(values) == 1:

value = values[0]

return [(0, value, value), (1, value, value)]

# Get coordinates

if not np.iterable(values):

raise TypeError('Colors must be iterable, got {values!r}.')

if coords is not None:

coords = np.atleast_1d(coords)

if ratios is not None:

_warn_proplot(

f'Segment coordinates were provided, ignoring '

f'ratios={ratios!r}.'

)

if len(coords) != len(values) or coords[0] != 0 or coords[-1] != 1:

raise ValueError(

f'Coordinates must range from 0 to 1, got {coords!r}.'

)

elif ratios is not None:

coords = np.atleast_1d(ratios)

if len(coords) != len(values) - 1:

raise ValueError(

f'Need {len(values)-1} ratios for {len(values)} colors, '

f'but got {len(ratios)} ratios.'

)

coords = np.concatenate(([0], np.cumsum(coords)))

coords = coords / np.max(coords) # normalize to 0-1

else:

coords = np.linspace(0, 1, len(values))

# Build segmentdata array

array = []

for c, value in zip(coords, values):

array.append((c, value, value))

r"""

# Allow for *callable* instead of linearly interpolating between segments

gammas = np.atleast_1d(gamma)

if (gammas < 0.01).any() or (gammas > 10).any():

raise ValueError('Gamma can only be in range [0.01,10].')

if callable(data):

if len(gammas) > 1:

raise ValueError(

'Only one gamma allowed for functional segmentdata.')

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

lut = np.array(data(x), dtype=float)

return lut

# Get array

data = np.array(data)

shape = data.shape

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

raise ValueError('Data must be nx3 format.')

if len(gammas) != 1 and len(gammas) != shape[0] - 1:

raise ValueError(

f'Need {shape[0]-1} gammas for {shape[0]}-level mapping array, '

f'but got {len(gamma)}.'

)

if len(gammas) == 1:

gammas = np.repeat(gammas, shape[:1])

# Get indices

x = data[:, 0]

y0 = data[:, 1]

y1 = data[:, 2]

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

raise ValueError(

'Data mapping points must start with x=0 and end with x=1.'

)

if (np.diff(x) < 0).any():

raise ValueError(

'Data mapping points must have x in increasing order.'

)

x = x * (N - 1)

# Get distances from the segmentdata entry to the *left* for each requested

# level, excluding ends at (0,1), which must exactly match segmentdata ends

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

# where xq[i] must be inserted so it is larger than x[ind[i]-1] but

# smaller than x[ind[i]]

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

distance = (xq[1:-1] - x[ind - 1]) / (x[ind] - x[ind - 1])

# Scale distances in each segment by input gamma

# The ui are starting-points, the ci are counts from that point

# over which segment applies (i.e. where to apply the gamma), the relevant

# 'segment' is to the *left* of index returned by searchsorted

_, uind, cind = np.unique(ind, return_index=True, return_counts=True)

for ui, ci in zip(uind, cind): # length should be N-1

# the relevant segment is to *left* of this number

gamma = gammas[ind[ui] - 1]

if gamma == 1:

continue

ireverse = False

if ci > 1: # i.e. more than 1 color in this 'segment'

# by default want to weight toward a *lower* channel value

ireverse = ((y0[ind[ui]] - y1[ind[ui] - 1]) < 0)

if inverse:

ireverse = (not ireverse)

if ireverse:

distance[ui:ui + ci] = 1 - (1 - distance[ui:ui + ci])**gamma

else:

distance[ui:ui + ci] **= gamma

# Perform successive linear interpolations all rolled up into one equation

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

lut[1:-1] = distance * (y0[ind] - y1[ind - 1]) + y1[ind - 1]

lut[0] = y1[0]

lut[-1] = y0[-1]

"""

def _get_data(self, ext, alpha=True):

"""

# Get lookup table colors and filter out bad ones

if not self._isinit:

self._init()

colors = self._lut[:-3, :]

# Get data string

if ext == 'hex':

data = ', '.join(mcolors.to_hex(color) for color in colors)

elif ext in ('txt', 'rgb'):

rgb = mcolors.to_rgba if alpha else mcolors.to_rgb

data = [rgb(color) for color in colors]

data = '\n'.join(

' '.join(f'{num:0.6f}' for num in line) for line in data

)

else:

raise ValueError(

f'Invalid extension {ext!r}. Options are: '

"'hex', 'txt', 'rgb', 'rgba'."

)

return data

def _parse_path(self, path, dirname='.', ext=''):

"""

path = os.path.expanduser(path or '')

dirname = os.path.expanduser(dirname or '')

if not path or os.path.isdir(path):

path = os.path.join(path or dirname, self.name) # default name

dirname, basename = os.path.split(path) # default to current directory

path = os.path.join(dirname or '.', basename)

if not os.path.splitext(path)[-1]:

path = path + '.' + ext # default file extension

r"""

def __str__(self):

return type(self).__name__ + f'(name={self.name!r})'

def __repr__(self):

string = f" 'name': {self.name!r},\n"

if hasattr(self, '_space'):

string += f" 'space': {self._space!r},\n"

if hasattr(self, '_cyclic'):

string += f" 'cyclic': {self._cyclic!r},\n"

for key, data in self._segmentdata.items():

if callable(data):

string += f' {key!r}: <function>,\n'

else:

string += (f' {key!r}: [{data[0][2]:.3f}, '

f'..., {data[-1][1]:.3f}],\n')

return type(self).__name__ + '({\n' + string + '})'

def __init__(self, *args, cyclic=False, alpha=None, **kwargs):

"""

super().__init__(*args, **kwargs)

self._cyclic = cyclic

if alpha is not None:

self.set_alpha(alpha)

def concatenate(self, *args, ratios=1, name=None, N=None, **kwargs):

"""

# Try making a simple copy

if not args:

raise ValueError(

f'Got zero positional args, you must provide at least one.'

)

if not all(isinstance(cmap, type(self)) for cmap in args):

raise ValueError(

f'Colormaps {cmap.name + ": " + repr(cmap) for cmap in args} '

f'must all belong to the same class.'

)

cmaps = (self, *args)

spaces = {cmap.name: getattr(cmap, '_space', None) for cmap in cmaps}

if len({*spaces.values(), }) > 1:

raise ValueError(

'Cannot merge PerceptuallyUniformColormaps that use '

'different colorspaces: '

+ ', '.join(map(repr, spaces)) + '.'

)

N = N or len(cmaps) * rcParams['image.lut']

if name is None:

name = '_'.join(cmap.name for cmap in cmaps)

# Combine the segmentdata, and use the y1/y2 slots at merge points so

# we never interpolate between end colors of different colormaps

segmentdata = {}

ratios = ratios or 1

if isinstance(ratios, Number):

ratios = [1] * len(cmaps)

ratios = np.array(ratios) / np.sum(ratios)

x0 = np.concatenate([[0], np.cumsum(ratios)]) # coordinates for edges

xw = x0[1:] - x0[:-1] # widths between edges

for key in self._segmentdata.keys():

# Callable segments

# WARNING: If just reference a global 'funcs' list from inside the

# 'data' function it can get overwritten in this loop. Must

# embed 'funcs' into the definition using a keyword argument.

callable_ = [callable(cmap._segmentdata[key]) for cmap in cmaps]

if all(callable_): # expand range from x-to-w to 0-1

funcs = [cmap._segmentdata[key] for cmap in cmaps]

def xyy(ix, funcs=funcs):

ix = np.atleast_1d(ix)

kx = np.empty(ix.shape)

for j, jx in enumerate(ix.flat):

idx = max(np.searchsorted(x0, jx) - 1, 0)

kx.flat[j] = funcs[idx]((jx - x0[idx]) / xw[idx])

return kx

# Concatenate segment arrays and make the transition at the

# seam instant so we *never interpolate* between end colors

# of different maps.

elif not any(callable_):

datas = []

for x, w, cmap in zip(x0[:-1], xw, cmaps):

xyy = np.array(cmap._segmentdata[key])

xyy[:, 0] = x + w * xyy[:, 0]

datas.append(xyy)

for i in range(len(datas) - 1):

datas[i][-1, 2] = datas[i + 1][0, 2]

datas[i + 1] = datas[i + 1][1:, :]

xyy = np.concatenate(datas, axis=0)

xyy[:, 0] = xyy[:, 0] / xyy[:, 0].max(axis=0) # fix fp errors

else:

raise ValueError(

'Mixed callable and non-callable colormap values.'

)

segmentdata[key] = xyy

# Handle gamma values

if key == 'saturation':

ikey = 'gamma1'

elif key == 'luminance':

ikey = 'gamma2'

else:

continue

if ikey in kwargs:

continue

gamma = []

for cmap in cmaps:

igamma = getattr(cmap, '_' + ikey)

if not np.iterable(igamma):

if all(callable_):

igamma = [igamma]

else:

igamma = (len(cmap._segmentdata[key]) - 1) * [igamma]

gamma.extend(igamma)

if all(callable_):

if any(igamma != gamma[0] for igamma in gamma[1:]):

_warn_proplot(

'Cannot use multiple segment gammas when '

'concatenating callable segments. Using the first '

f'gamma of {gamma[0]}.'

)

gamma = gamma[0]

kwargs[ikey] = gamma

# Return copy

return self.updated(name=name, segmentdata=segmentdata, **kwargs)

def punched(self, cut=None, name=None, **kwargs):

"""

cut = _notNone(cut, 0)

if cut == 0:

return self

if name is None:

name = self.name + '_punched'

# Decompose cut into two truncations followed by concatenation

left_center = 0.5 - cut / 2

right_center = 0.5 + cut / 2

cmap_left = self.truncated(0, left_center)

cmap_right = self.truncated(right_center, 1)

return cmap_left.concatenate(cmap_right, name=name, **kwargs)

def reversed(self, name=None, **kwargs):

"""

if name is None:

name = self.name + '_r'

def factory(dat):

def func_r(x):

return dat(1.0 - x)

return func_r

segmentdata = {key:

factory(data) if callable(data) else

[(1.0 - x, y1, y0) for x, y0, y1 in reversed(data)]

for key, data in self._segmentdata.items()}

for key in ('gamma1', 'gamma2'):

if key in kwargs:

continue

gamma = getattr(self, '_' + key, None)

if gamma is not None and np.iterable(gamma):