"""

def __init__(self, colorbar):

"""

self._colorbar = colorbar

nbins = 'auto'

steps = [1, 2, 2.5, 5, 10]

super().__init__(nbins=nbins, steps=steps)

def tick_values(self, vmin, vmax):

# flip if needed:

if vmin > vmax:

vmin, vmax = vmax, vmin

vmin = max(vmin, self._colorbar.norm.vmin)

vmax = min(vmax, self._colorbar.norm.vmax)

ticks = super().tick_values(vmin, vmax)

rtol = (vmax - vmin) * 1e-10

"""

def __init__(self, colorbar, n=None):

"""

self._colorbar = colorbar

self.ndivs = n

super().__init__(n=None)

def __call__(self):

vmin = self._colorbar.norm.vmin

vmax = self._colorbar.norm.vmax

ticks = super().__call__()

rtol = (vmax - vmin) * 1e-10

"""

def __init__(self, colorbar, *args, **kwargs):

"""

self._colorbar = colorbar

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

def tick_values(self, vmin, vmax):

if vmin > vmax:

vmin, vmax = vmax, vmin

vmin = max(vmin, self._colorbar.norm.vmin)

vmax = min(vmax, self._colorbar.norm.vmax)

ticks = super().tick_values(vmin, vmax)

rtol = (np.log10(vmax) - np.log10(vmin)) * 1e-10

ticks = ticks[(np.log10(ticks) >= np.log10(vmin) - rtol) &

(np.log10(ticks) <= np.log10(vmax) + rtol)]

r"""

n_rasterize = 50 # rasterize solids if number of colors >= n_rasterize

@cbook._make_keyword_only("3.3", "cmap")

def __init__(self, ax, cmap=None,

norm=None,

alpha=None,

values=None,

boundaries=None,

orientation='vertical',

ticklocation='auto',

extend='neither',

spacing='uniform', # uniform or proportional

ticks=None,

format=None,

drawedges=False,

filled=True,

extendfrac=None,

extendrect=False,

label='',

):

cbook._check_isinstance([colors.Colormap, None], cmap=cmap)

cbook._check_in_list(

['vertical', 'horizontal'], orientation=orientation)

cbook._check_in_list(

['auto', 'left', 'right', 'top', 'bottom'],

ticklocation=ticklocation)

cbook._check_in_list(

['uniform', 'proportional'], spacing=spacing)

self.ax = ax

# Bind some methods to the axes to warn users against using them.

ax.set_xticks = ax.set_yticks = _set_ticks_on_axis_warn

ax.set(frame_on=False, navigate=False)

if cmap is None:

cmap = cm.get_cmap()

if norm is None:

norm = colors.Normalize()

self.alpha = alpha

self.cmap = cmap

self.norm = norm

self.values = values

self.boundaries = boundaries

self.extend = extend

self._inside = cbook._check_getitem(

{'neither': slice(0, None), 'both': slice(1, -1),

'min': slice(1, None), 'max': slice(0, -1)},

extend=extend)

self.spacing = spacing

self.orientation = orientation

self.drawedges = drawedges

self.filled = filled

self.extendfrac = extendfrac

self.extendrect = extendrect

self.solids = None

self.lines = []

self.outline = mpatches.Polygon(

np.empty((0, 2)),

edgecolor=mpl.rcParams['axes.edgecolor'], facecolor='none',

linewidth=mpl.rcParams['axes.linewidth'], closed=True, zorder=2)

ax.add_artist(self.outline)

self.outline.set(clip_box=None, clip_path=None)

self.patch = mpatches.Polygon(

np.empty((0, 2)),

color=mpl.rcParams['axes.facecolor'], linewidth=0.01, zorder=-1)

ax.add_artist(self.patch)

self.dividers = None

self.locator = None

self.formatter = None

self._manual_tick_data_values = None

self.__scale = None # linear, log10 for now. Hopefully more?

if ticklocation == 'auto':

ticklocation = 'bottom' if orientation == 'horizontal' else 'right'

self.ticklocation = ticklocation

self.set_label(label)

self._reset_locator_formatter_scale()

if np.iterable(ticks):

self.locator = ticker.FixedLocator(ticks, nbins=len(ticks))

else:

self.locator = ticks # Handle default in _ticker()

if isinstance(format, str):

self.formatter = ticker.FormatStrFormatter(format)

else:

self.formatter = format # Assume it is a Formatter or None

self.draw_all()

def _extend_lower(self):

"""Return whether the lower limit is open ended."""

return self.extend in ('both', 'min')

def _extend_upper(self):

"""Return whether the upper limit is open ended."""

return self.extend in ('both', 'max')

def draw_all(self):

"""

# sets self._boundaries and self._values in real data units.

# takes into account extend values:

self._process_values()

# sets self.vmin and vmax in data units, but just for the part of the

# colorbar that is not part of the extend patch:

self._find_range()

# returns the X and Y mesh, *but* this was/is in normalized units:

X, Y = self._mesh()

C = self._values[:, np.newaxis]

self._config_axis() # Inline it after deprecation elapses.

# Configure axes limits, patch, and outline.

xy = self._outline(X, Y)

xmin, ymin = xy.min(axis=0)

xmax, ymax = xy.max(axis=0)

self.ax.set(xlim=(xmin, xmax), ylim=(ymin, ymax))

self.outline.set_xy(xy)

self.patch.set_xy(xy)

self.update_ticks()

if self.filled:

self._add_solids(X, Y, C)

@cbook.deprecated("3.3")

def config_axis(self):

self._config_axis()

def _config_axis(self):

"""Set up long and short axis."""

ax = self.ax

if self.orientation == 'vertical':

long_axis, short_axis = ax.yaxis, ax.xaxis

if mpl.rcParams['ytick.minor.visible']:

self.minorticks_on()

else:

long_axis, short_axis = ax.xaxis, ax.yaxis

if mpl.rcParams['xtick.minor.visible']:

self.minorticks_on()

long_axis.set(label_position=self.ticklocation,

ticks_position=self.ticklocation)

short_axis.set_ticks([])

short_axis.set_ticks([], minor=True)

self._set_label()

def _get_ticker_locator_formatter(self):

"""

locator = self.locator

formatter = self.formatter

if locator is None:

if self.boundaries is None:

if isinstance(self.norm, colors.NoNorm):

nv = len(self._values)

base = 1 + int(nv / 10)

locator = ticker.IndexLocator(base=base, offset=0)

elif isinstance(self.norm, colors.BoundaryNorm):

b = self.norm.boundaries

locator = ticker.FixedLocator(b, nbins=10)

elif isinstance(self.norm, colors.LogNorm):

locator = _ColorbarLogLocator(self)

elif isinstance(self.norm, colors.SymLogNorm):

# The subs setting here should be replaced

# by logic in the locator.

locator = ticker.SymmetricalLogLocator(

subs=np.arange(1, 10),

linthresh=self.norm.linthresh,

base=10)

else:

if mpl.rcParams['_internal.classic_mode']:

locator = ticker.MaxNLocator()

else:

locator = _ColorbarAutoLocator(self)

else:

b = self._boundaries[self._inside]

locator = ticker.FixedLocator(b, nbins=10)

if formatter is None:

if isinstance(self.norm, colors.LogNorm):

formatter = ticker.LogFormatterSciNotation()

elif isinstance(self.norm, colors.SymLogNorm):

formatter = ticker.LogFormatterSciNotation(

linthresh=self.norm.linthresh)

else:

formatter = ticker.ScalarFormatter()

else:

formatter = self.formatter

self.locator = locator

self.formatter = formatter

_log.debug('locator: %r', locator)

return locator, formatter

def _use_auto_colorbar_locator(self):

"""

contouring = self.boundaries is not None and self.spacing == 'uniform'

return (type(self.norm) in [colors.Normalize, colors.LogNorm] and

not contouring)

def _reset_locator_formatter_scale(self):

"""

self.locator = None

self.formatter = None

if isinstance(self.norm, colors.LogNorm):

# *both* axes are made log so that determining the

# mid point is easier.

self.ax.set_xscale('log')

self.ax.set_yscale('log')

self.minorticks_on()

self.__scale = 'log'

else:

self.ax.set_xscale('linear')

self.ax.set_yscale('linear')

if type(self.norm) is colors.Normalize:

self.__scale = 'linear'

else:

self.__scale = 'manual'

def update_ticks(self):

"""

ax = self.ax

# Get the locator and formatter; defaults to self.locator if not None.

locator, formatter = self._get_ticker_locator_formatter()

long_axis = ax.yaxis if self.orientation == 'vertical' else ax.xaxis

if self._use_auto_colorbar_locator():

_log.debug('Using auto colorbar locator %r on colorbar', locator)

long_axis.set_major_locator(locator)

long_axis.set_major_formatter(formatter)

else:

_log.debug('Using fixed locator on colorbar')

ticks, ticklabels, offset_string = self._ticker(locator, formatter)

long_axis.set_ticks(ticks)

long_axis.set_ticklabels(ticklabels)

long_axis.get_major_formatter().set_offset_string(offset_string)

def set_ticks(self, ticks, update_ticks=True):

"""

if np.iterable(ticks):

self.locator = ticker.FixedLocator(ticks, nbins=len(ticks))

else:

self.locator = ticks

if update_ticks:

self.update_ticks()

self.stale = True

def get_ticks(self, minor=False):

"""Return the x ticks as a list of locations."""

if self._manual_tick_data_values is None:

ax = self.ax

long_axis = (

ax.yaxis if self.orientation == 'vertical' else ax.xaxis)

return long_axis.get_majorticklocs()

else:

# We made the axes manually, the old way, and the ylim is 0-1,

# so the majorticklocs are in those units, not data units.

return self._manual_tick_data_values

def set_ticklabels(self, ticklabels, update_ticks=True):

"""

if isinstance(self.locator, ticker.FixedLocator):

self.formatter = ticker.FixedFormatter(ticklabels)

if update_ticks:

self.update_ticks()

else:

cbook._warn_external("set_ticks() must have been called.")

self.stale = True

def minorticks_on(self):

"""

ax = self.ax

long_axis = ax.yaxis if self.orientation == 'vertical' else ax.xaxis

if long_axis.get_scale() == 'log':

long_axis.set_minor_locator(_ColorbarLogLocator(self, base=10.,

subs='auto'))

long_axis.set_minor_formatter(ticker.LogFormatterSciNotation())

else:

long_axis.set_minor_locator(_ColorbarAutoMinorLocator(self))

def minorticks_off(self):

"""Turn the minor ticks of the colorbar off."""

ax = self.ax

long_axis = ax.yaxis if self.orientation == 'vertical' else ax.xaxis

long_axis.set_minor_locator(ticker.NullLocator())

def _set_label(self):

if self.orientation == 'vertical':

self.ax.set_ylabel(self._label, **self._labelkw)

else:

self.ax.set_xlabel(self._label, **self._labelkw)

self.stale = True

def set_label(self, label, *, loc=None, **kwargs):

"""Add a label to the long axis of the colorbar."""

_pos_xy = 'y' if self.orientation == 'vertical' else 'x'

_protected_kw = [_pos_xy, 'horizontalalignment', 'ha']

if any([k in kwargs for k in _protected_kw]):

if loc is not None:

raise TypeError(f'Specifying *loc* is disallowed when any of '

f'its corresponding low level keyword '

f'arguments {_protected_kw} are also supplied')

loc = 'center'

else:

if loc is None:

loc = mpl.rcParams['%saxis.labellocation' % _pos_xy]

if self.orientation == 'vertical':

cbook._check_in_list(('bottom', 'center', 'top'), loc=loc)

else:

cbook._check_in_list(('left', 'center', 'right'), loc=loc)

if loc in ['right', 'top']:

kwargs[_pos_xy] = 1.

kwargs['horizontalalignment'] = 'right'

elif loc in ['left', 'bottom']:

kwargs[_pos_xy] = 0.

kwargs['horizontalalignment'] = 'left'

self._label = label

self._labelkw = kwargs

self._set_label()

def _outline(self, X, Y):

"""

N = X.shape[0]

ii = [0, 1, N - 2, N - 1, 2 * N - 1, 2 * N - 2, N + 1, N, 0]

x = X.T.reshape(-1)[ii]

y = Y.T.reshape(-1)[ii]

return (np.column_stack([y, x])

if self.orientation == 'horizontal' else

np.column_stack([x, y]))

def _edges(self, X, Y):

"""Return the separator line segments; helper for _add_solids."""

N = X.shape[0]

# Using the non-array form of these line segments is much

# simpler than making them into arrays.

if self.orientation == 'vertical':

return [list(zip(X[i], Y[i])) for i in range(1, N - 1)]

else:

return [list(zip(Y[i], X[i])) for i in range(1, N - 1)]

def _add_solids(self, X, Y, C):

"""

if self.orientation == 'vertical':

args = (X, Y, C)

else:

args = (np.transpose(Y), np.transpose(X), np.transpose(C))

kw = dict(cmap=self.cmap,

norm=self.norm,

alpha=self.alpha,

edgecolors='None')

_log.debug('Setting pcolormesh')

col = self.ax.pcolormesh(*args, **kw, shading='flat')

# self.add_observer(col) # We should observe, not be observed...

if self.solids is not None:

self.solids.remove()

self.solids = col

if self.dividers is not None:

self.dividers.remove()

self.dividers = None

if self.drawedges:

linewidths = (0.5 * mpl.rcParams['axes.linewidth'],)

self.dividers = collections.LineCollection(

self._edges(X, Y),

colors=(mpl.rcParams['axes.edgecolor'],),

linewidths=linewidths)

self.ax.add_collection(self.dividers)

elif len(self._y) >= self.n_rasterize:

self.solids.set_rasterized(True)

def add_lines(self, levels, colors, linewidths, erase=True):

"""

y = self._locate(levels)

rtol = (self._y[-1] - self._y[0]) * 1e-10

igood = (y < self._y[-1] + rtol) & (y > self._y[0] - rtol)

y = y[igood]

if np.iterable(colors):

colors = np.asarray(colors)[igood]

if np.iterable(linewidths):

linewidths = np.asarray(linewidths)[igood]

X, Y = np.meshgrid([self._y[0], self._y[-1]], y)

if self.orientation == 'vertical':

xy = np.stack([X, Y], axis=-1)

else:

xy = np.stack([Y, X], axis=-1)

col = collections.LineCollection(xy, linewidths=linewidths)

if erase and self.lines:

for lc in self.lines:

lc.remove()

self.lines = []

self.lines.append(col)

col.set_color(colors)

self.ax.add_collection(col)

self.stale = True

def _ticker(self, locator, formatter):

"""

if isinstance(self.norm, colors.NoNorm) and self.boundaries is None:

intv = self._values[0], self._values[-1]

else:

intv = self.vmin, self.vmax

locator.create_dummy_axis(minpos=intv[0])

formatter.create_dummy_axis(minpos=intv[0])

locator.set_view_interval(*intv)

locator.set_data_interval(*intv)

formatter.set_view_interval(*intv)

formatter.set_data_interval(*intv)

b = np.array(locator())

if isinstance(locator, ticker.LogLocator):

eps = 1e-10

b = b[(b <= intv[1] * (1 + eps)) & (b >= intv[0] * (1 - eps))]

else:

eps = (intv[1] - intv[0]) * 1e-10

b = b[(b <= intv[1] + eps) & (b >= intv[0] - eps)]

self._manual_tick_data_values = b

ticks = self._locate(b)

ticklabels = formatter.format_ticks(b)

offset_string = formatter.get_offset()

return ticks, ticklabels, offset_string

def _process_values(self, b=None):

"""

if b is None:

b = self.boundaries

if b is not None:

self._boundaries = np.asarray(b, dtype=float)

if self.values is None:

self._values = 0.5 * (self._boundaries[:-1]

+ self._boundaries[1:])

if isinstance(self.norm, colors.NoNorm):

self._values = (self._values + 0.00001).astype(np.int16)

else:

self._values = np.array(self.values)

return

if self.values is not None:

self._values = np.array(self.values)

if self.boundaries is None:

b = np.zeros(len(self.values) + 1)

b[1:-1] = 0.5 * (self._values[:-1] + self._values[1:])

b[0] = 2.0 * b[1] - b[2]

b[-1] = 2.0 * b[-2] - b[-3]

self._boundaries = b

return

self._boundaries = np.array(self.boundaries)

return

# Neither boundaries nor values are specified;

# make reasonable ones based on cmap and norm.

if isinstance(self.norm, colors.NoNorm):

b = self._uniform_y(self.cmap.N + 1) * self.cmap.N - 0.5

v = np.zeros(len(b) - 1, dtype=np.int16)

v[self._inside] = np.arange(self.cmap.N, dtype=np.int16)

if self._extend_lower():

v[0] = -1

if self._extend_upper():

v[-1] = self.cmap.N

self._boundaries = b

self._values = v

return

elif isinstance(self.norm, colors.BoundaryNorm):

b = list(self.norm.boundaries)

if self._extend_lower():

b = [b[0] - 1] + b

if self._extend_upper():

b = b + [b[-1] + 1]

b = np.array(b)

v = np.zeros(len(b) - 1)

bi = self.norm.boundaries

v[self._inside] = 0.5 * (bi[:-1] + bi[1:])

if self._extend_lower():

v[0] = b[0] - 1

if self._extend_upper():

v[-1] = b[-1] + 1

self._boundaries = b

self._values = v

return

else:

if not self.norm.scaled():

self.norm.vmin = 0

self.norm.vmax = 1

self.norm.vmin, self.norm.vmax = mtransforms.nonsingular(

self.norm.vmin,

self.norm.vmax,

expander=0.1)

b = self.norm.inverse(self._uniform_y(self.cmap.N + 1))

if isinstance(self.norm, (colors.PowerNorm, colors.LogNorm)):

# If using a lognorm or powernorm, ensure extensions don't

# go negative

if self._extend_lower():

b[0] = 0.9 * b[0]

if self._extend_upper():

b[-1] = 1.1 * b[-1]

else:

if self._extend_lower():

b[0] = b[0] - 1

if self._extend_upper():

b[-1] = b[-1] + 1

self._process_values(b)

def _find_range(self):

"""

b = self._boundaries[self._inside]

self.vmin = b[0]

self.vmax = b[-1]

def _central_N(self):

"""Return the number of boundaries excluding end extensions."""

nb = len(self._boundaries)

if self.extend == 'both':

nb -= 2

elif self.extend in ('min', 'max'):

nb -= 1

return nb

def _extended_N(self):

"""

N = self.cmap.N + 1

if self.extend == 'both':

N += 2

elif self.extend in ('min', 'max'):

N += 1

return N

def _get_extension_lengths(self, frac, automin, automax, default=0.05):