def __init__(self, axes):

self._ax = axes

super().__init__(axes, 'colorbar', mpath.Path(np.empty((0, 2))))

mpatches.Patch.set_transform(self, axes.transAxes)

def get_window_extent(self, renderer=None):

# This Spine has no Axis associated with it, and doesn't need to adjust

# its location, so we can directly get the window extent from the

# super-super-class.

return mpatches.Patch.get_window_extent(self, renderer=renderer)

def set_xy(self, xy):

self._path = mpath.Path(xy, closed=True)

self._xy = xy

self.stale = True

def draw(self, renderer):

ret = mpatches.Patch.draw(self, renderer)

self.stale = False

"""

def __init__(self, cbar):

self._cbar = cbar

self._orig_locator = cbar.ax._axes_locator

def __call__(self, ax, renderer):

if self._orig_locator is not None:

pos = self._orig_locator(ax, renderer)

else:

pos = ax.get_position(original=True)

if self._cbar.extend == 'neither':

return pos

y, extendlen = self._cbar._proportional_y()

if not self._cbar._extend_lower():

extendlen[0] = 0

if not self._cbar._extend_upper():

extendlen[1] = 0

len = sum(extendlen) + 1

shrink = 1 / len

offset = extendlen[0] / len

# we need to reset the aspect ratio of the axes to account

# of the extends...

if hasattr(ax, '_colorbar_info'):

aspect = ax._colorbar_info['aspect']

else:

aspect = False

# now shrink and/or offset to take into account the

# extend tri/rectangles.

if self._cbar.orientation == 'vertical':

if aspect:

self._cbar.ax.set_box_aspect(aspect*shrink)

pos = pos.shrunk(1, shrink).translated(0, offset * pos.height)

else:

if aspect:

self._cbar.ax.set_box_aspect(1/(aspect * shrink))

pos = pos.shrunk(shrink, 1).translated(offset * pos.width, 0)

return pos

def get_subplotspec(self):

# make tight_layout happy..

return (

self._cbar.ax.get_subplotspec()

r"""

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

def __init__(

self, ax, mappable=None, *,

alpha=None,

location=None,

extend=None,

extendfrac=None,

extendrect=False,

ticks=None,

format=None,

values=None,

boundaries=None,

spacing='uniform',

drawedges=False,

label='',

cmap=None, norm=None, # redundant with *mappable*

orientation=None, ticklocation='auto', # redundant with *location*

):

"""

if mappable is None:

mappable = cm.ScalarMappable(norm=norm, cmap=cmap)

self.mappable = mappable

cmap = mappable.cmap

norm = mappable.norm

filled = True

if isinstance(mappable, contour.ContourSet):

cs = mappable

alpha = cs.get_alpha()

boundaries = cs._levels

values = cs.cvalues

extend = cs.extend

filled = cs.filled

if ticks is None:

ticks = ticker.FixedLocator(cs.levels, nbins=10)

elif isinstance(mappable, martist.Artist):

alpha = mappable.get_alpha()

mappable.colorbar = self

mappable.colorbar_cid = mappable.callbacks.connect(

'changed', self.update_normal)

location_orientation = _get_orientation_from_location(location)

_api.check_in_list(

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

_api.check_in_list(

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

ticklocation=ticklocation)

_api.check_in_list(

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

if location_orientation is not None and orientation is not None:

if location_orientation != orientation:

raise TypeError(

"location and orientation are mutually exclusive")

else:

orientation = orientation or location_orientation or "vertical"

self.ax = ax

self.ax._axes_locator = _ColorbarAxesLocator(self)

if extend is None:

if (not isinstance(mappable, contour.ContourSet)

and getattr(cmap, 'colorbar_extend', False) is not False):

extend = cmap.colorbar_extend

elif hasattr(norm, 'extend'):

extend = norm.extend

else:

extend = 'neither'

self.alpha = None

# Call set_alpha to handle array-like alphas properly

self.set_alpha(alpha)

self.cmap = cmap

self.norm = norm

self.values = values

self.boundaries = boundaries

self.extend = extend

self._inside = _api.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._extend_patches = []

self.solids = None

self.solids_patches = []

self.lines = []

for spine in self.ax.spines.values():

spine.set_visible(False)

self.outline = self.ax.spines['outline'] = _ColorbarSpine(self.ax)

self.dividers = collections.LineCollection(

[],

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

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

clip_on=False)

self.ax.add_collection(self.dividers)

self._locator = None

self._minorlocator = None

self._formatter = None

self._minorformatter = None

if ticklocation == 'auto':

ticklocation = _get_ticklocation_from_orientation(

orientation) if location is None else location

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

if isinstance(format, str):

# Check format between FormatStrFormatter and StrMethodFormatter

try:

self._formatter = ticker.FormatStrFormatter(format)

_ = self._formatter(0)

except (TypeError, ValueError):

self._formatter = ticker.StrMethodFormatter(format)

else:

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

self._draw_all()

if isinstance(mappable, contour.ContourSet) and not mappable.filled:

self.add_lines(mappable)

# Link the Axes and Colorbar for interactive use

self.ax._colorbar = self

# Don't navigate on any of these types of mappables

if (isinstance(self.norm, (colors.BoundaryNorm, colors.NoNorm)) or

isinstance(self.mappable, contour.ContourSet)):

self.ax.set_navigate(False)

# These are the functions that set up interactivity on this colorbar

self._interactive_funcs = ["_get_view", "_set_view",

"_set_view_from_bbox", "drag_pan"]

for x in self._interactive_funcs:

setattr(self.ax, x, getattr(self, x))

# Set the cla function to the cbar's method to override it

self.ax.cla = self._cbar_cla

# Callbacks for the extend calculations to handle inverting the axis

self._extend_cid1 = self.ax.callbacks.connect(

"xlim_changed", self._do_extends)

self._extend_cid2 = self.ax.callbacks.connect(

"ylim_changed", self._do_extends)

@property

def long_axis(self):

"""Axis that has decorations (ticks, etc) on it."""

if self.orientation == 'vertical':

return self.ax.yaxis

return self.ax.xaxis

@property

def locator(self):

"""Major tick `.Locator` for the colorbar."""

return self.long_axis.get_major_locator()

@locator.setter

def locator(self, loc):

self.long_axis.set_major_locator(loc)

self._locator = loc

@property

def minorlocator(self):

"""Minor tick `.Locator` for the colorbar."""

return self.long_axis.get_minor_locator()

@minorlocator.setter

def minorlocator(self, loc):

self.long_axis.set_minor_locator(loc)

self._minorlocator = loc

@property

def formatter(self):

"""Major tick label `.Formatter` for the colorbar."""

return self.long_axis.get_major_formatter()

@formatter.setter

def formatter(self, fmt):

self.long_axis.set_major_formatter(fmt)

self._formatter = fmt

@property

def minorformatter(self):

"""Minor tick `.Formatter` for the colorbar."""

return self.long_axis.get_minor_formatter()

@minorformatter.setter

def minorformatter(self, fmt):

self.long_axis.set_minor_formatter(fmt)

self._minorformatter = fmt

def _cbar_cla(self):

"""Function to clear the interactive colorbar state."""

for x in self._interactive_funcs:

delattr(self.ax, x)

# We now restore the old cla() back and can call it directly

del self.ax.cla

self.ax.cla()

def update_normal(self, mappable=None):

"""

if mappable:

# The mappable keyword argument exists because

# ScalarMappable.changed() emits self.callbacks.process('changed', self)

# in contrast, ColorizingArtist (and Colorizer) does not use this keyword.

# [ColorizingArtist.changed() emits self.callbacks.process('changed')]

# Also, there is no test where self.mappable == mappable is not True

# and possibly no use case.

# Therefore, the mappable keyword can be deprecated if cm.ScalarMappable

# is removed.

self.mappable = mappable

_log.debug('colorbar update normal %r %r', self.mappable.norm, self.norm)

self.set_alpha(self.mappable.get_alpha())

self.cmap = self.mappable.cmap

if self.mappable.norm != self.norm:

self.norm = self.mappable.norm

self._reset_locator_formatter_scale()

self._draw_all()

if isinstance(self.mappable, contour.ContourSet):

CS = self.mappable

if not CS.filled:

self.add_lines(CS)

self.stale = True

def _draw_all(self):

"""

if self.orientation == 'vertical':

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

self.minorticks_on()

else:

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

self.minorticks_on()

self.long_axis.set(label_position=self.ticklocation,

ticks_position=self.ticklocation)

self._short_axis().set_ticks([])

self._short_axis().set_ticks([], minor=True)

# Set self._boundaries and self._values, including extensions.

# self._boundaries are the edges of each square of color, and

# self._values are the value to map into the norm to get the

# color:

self._process_values()

# Set self.vmin and self.vmax to first and last boundary, excluding

# extensions:

self.vmin, self.vmax = self._boundaries[self._inside][[0, -1]]

# Compute the X/Y mesh.

X, Y = self._mesh()

# draw the extend triangles, and shrink the inner Axes to accommodate.

# also adds the outline path to self.outline spine:

self._do_extends()

lower, upper = self.vmin, self.vmax

if self.long_axis.get_inverted():

# If the axis is inverted, we need to swap the vmin/vmax

lower, upper = upper, lower

if self.orientation == 'vertical':

self.ax.set_xlim(0, 1)

self.ax.set_ylim(lower, upper)

else:

self.ax.set_ylim(0, 1)

self.ax.set_xlim(lower, upper)

# set up the tick locators and formatters. A bit complicated because

# boundary norms + uniform spacing requires a manual locator.

self.update_ticks()

if self._filled:

ind = np.arange(len(self._values))

if self._extend_lower():

ind = ind[1:]

if self._extend_upper():

ind = ind[:-1]

self._add_solids(X, Y, self._values[ind, np.newaxis])

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

"""Draw the colors; optionally add separators."""

# Cleanup previously set artists.

if self.solids is not None:

self.solids.remove()

for solid in self.solids_patches:

solid.remove()

# Add new artist(s), based on mappable type. Use individual patches if

# hatching is needed, pcolormesh otherwise.

mappable = getattr(self, 'mappable', None)

if (isinstance(mappable, contour.ContourSet)

and any(hatch is not None for hatch in mappable.hatches)):

self._add_solids_patches(X, Y, C, mappable)

else:

self.solids = self.ax.pcolormesh(

X, Y, C, cmap=self.cmap, norm=self.norm, alpha=self.alpha,

edgecolors='none', shading='flat')

if not self.drawedges:

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

self.solids.set_rasterized(True)

self._update_dividers()

def _update_dividers(self):

if not self.drawedges:

self.dividers.set_segments([])

return

# Place all *internal* dividers.

if self.orientation == 'vertical':

lims = self.ax.get_ylim()

bounds = (lims[0] < self._y) & (self._y < lims[1])

else:

lims = self.ax.get_xlim()

bounds = (lims[0] < self._y) & (self._y < lims[1])

y = self._y[bounds]

# And then add outer dividers if extensions are on.

if self._extend_lower():

y = np.insert(y, 0, lims[0])

if self._extend_upper():

y = np.append(y, lims[1])

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

if self.orientation == 'vertical':

segments = np.dstack([X, Y])

else:

segments = np.dstack([Y, X])

self.dividers.set_segments(segments)

def _add_solids_patches(self, X, Y, C, mappable):

hatches = mappable.hatches * (len(C) + 1) # Have enough hatches.

if self._extend_lower():

# remove first hatch that goes into the extend patch

hatches = hatches[1:]

patches = []

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

xy = np.array([[X[i, 0], Y[i, 1]],

[X[i, 1], Y[i, 0]],

[X[i + 1, 1], Y[i + 1, 0]],

[X[i + 1, 0], Y[i + 1, 1]]])

patch = mpatches.PathPatch(mpath.Path(xy),

facecolor=self.cmap(self.norm(C[i][0])),

hatch=hatches[i], linewidth=0,

antialiased=False, alpha=self.alpha)

self.ax.add_patch(patch)

patches.append(patch)

self.solids_patches = patches

def _do_extends(self, ax=None):

"""

# Clean up any previous extend patches

for patch in self._extend_patches:

patch.remove()

self._extend_patches = []

# extend lengths are fraction of the *inner* part of colorbar,

# not the total colorbar:

_, extendlen = self._proportional_y()

bot = 0 - (extendlen[0] if self._extend_lower() else 0)

top = 1 + (extendlen[1] if self._extend_upper() else 0)

# xyout is the outline of the colorbar including the extend patches:

if not self.extendrect:

# triangle:

xyout = np.array([[0, 0], [0.5, bot], [1, 0],

[1, 1], [0.5, top], [0, 1], [0, 0]])

else:

# rectangle:

xyout = np.array([[0, 0], [0, bot], [1, bot], [1, 0],

[1, 1], [1, top], [0, top], [0, 1],

[0, 0]])

if self.orientation == 'horizontal':

xyout = xyout[:, ::-1]

# xyout is the path for the spine:

self.outline.set_xy(xyout)

if not self._filled:

return

# Make extend triangles or rectangles filled patches. These are

# defined in the outer parent axes' coordinates:

mappable = getattr(self, 'mappable', None)

if (isinstance(mappable, contour.ContourSet)

and any(hatch is not None for hatch in mappable.hatches)):

hatches = mappable.hatches * (len(self._y) + 1)

else:

hatches = [None] * (len(self._y) + 1)

if self._extend_lower():

if not self.extendrect:

# triangle

xy = np.array([[0, 0], [0.5, bot], [1, 0]])

else:

# rectangle

xy = np.array([[0, 0], [0, bot], [1., bot], [1, 0]])

if self.orientation == 'horizontal':

xy = xy[:, ::-1]

# add the patch

val = -1 if self.long_axis.get_inverted() else 0

color = self.cmap(self.norm(self._values[val]))

patch = mpatches.PathPatch(

mpath.Path(xy), facecolor=color, alpha=self.alpha,

linewidth=0, antialiased=False,

transform=self.ax.transAxes,

hatch=hatches[0], clip_on=False,

# Place it right behind the standard patches, which is

# needed if we updated the extends

zorder=np.nextafter(self.ax.patch.zorder, -np.inf))

self.ax.add_patch(patch)

self._extend_patches.append(patch)

# remove first hatch that goes into the extend patch

hatches = hatches[1:]

if self._extend_upper():

if not self.extendrect:

# triangle

xy = np.array([[0, 1], [0.5, top], [1, 1]])

else:

# rectangle

xy = np.array([[0, 1], [0, top], [1, top], [1, 1]])

if self.orientation == 'horizontal':

xy = xy[:, ::-1]

# add the patch

val = 0 if self.long_axis.get_inverted() else -1

color = self.cmap(self.norm(self._values[val]))

hatch_idx = len(self._y) - 1

patch = mpatches.PathPatch(

mpath.Path(xy), facecolor=color, alpha=self.alpha,

linewidth=0, antialiased=False,

transform=self.ax.transAxes, hatch=hatches[hatch_idx],

clip_on=False,

# Place it right behind the standard patches, which is

# needed if we updated the extends

zorder=np.nextafter(self.ax.patch.zorder, -np.inf))

self.ax.add_patch(patch)

self._extend_patches.append(patch)

self._update_dividers()

def add_lines(self, *args, **kwargs):

"""

params = _api.select_matching_signature(

[lambda self, CS, erase=True: locals(),

lambda self, levels, colors, linewidths, erase=True: locals()],

self, *args, **kwargs)

if "CS" in params:

self, cs, erase = params.values()

if not isinstance(cs, contour.ContourSet) or cs.filled:

raise ValueError("If a single artist is passed to add_lines, "

"it must be a ContourSet of lines")

# TODO: Make colorbar lines auto-follow changes in contour lines.

return self.add_lines(

cs.levels,

cs.to_rgba(cs.cvalues, cs.alpha),

cs.get_linewidths(),

erase=erase)

else:

self, levels, colors, linewidths, erase = params.values()

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([0, 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,

colors=colors)

if erase and self.lines:

for lc in self.lines:

lc.remove()

self.lines = []

self.lines.append(col)

# make a clip path that is just a linewidth bigger than the Axes...

fac = np.max(linewidths) / 72

xy = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]])

inches = self.ax.get_figure().dpi_scale_trans

# do in inches:

xy = inches.inverted().transform(self.ax.transAxes.transform(xy))

xy[[0, 1, 4], 1] -= fac

xy[[2, 3], 1] += fac

# back to axes units...

xy = self.ax.transAxes.inverted().transform(inches.transform(xy))

col.set_clip_path(mpath.Path(xy, closed=True),

self.ax.transAxes)

self.ax.add_collection(col)

self.stale = True

def update_ticks(self):

"""

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

self._get_ticker_locator_formatter()

self.long_axis.set_major_locator(self._locator)

self.long_axis.set_minor_locator(self._minorlocator)

self.long_axis.set_major_formatter(self._formatter)

def _get_ticker_locator_formatter(self):

"""

locator = self._locator

formatter = self._formatter

minorlocator = self._minorlocator

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

b = self.norm.boundaries

if locator is None:

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

if minorlocator is None:

minorlocator = ticker.FixedLocator(b)

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

if locator is None:

# put ticks on integers between the boundaries of NoNorm

nv = len(self._values)

base = 1 + int(nv / 10)

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

elif self.boundaries is not None:

b = self._boundaries[self._inside]

if locator is None:

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

else: # most cases:

if locator is None:

# we haven't set the locator explicitly, so use the default

# for this axis:

locator = self.long_axis.get_major_locator()

if minorlocator is None:

minorlocator = self.long_axis.get_minor_locator()

if minorlocator is None:

minorlocator = ticker.NullLocator()

if formatter is None:

formatter = self.long_axis.get_major_formatter()

self._locator = locator

self._formatter = formatter

self._minorlocator = minorlocator

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

def set_ticks(self, ticks, *, labels=None, minor=False, **kwargs):

"""

if np.iterable(ticks):

self.long_axis.set_ticks(ticks, labels=labels, minor=minor,

**kwargs)

self._locator = self.long_axis.get_major_locator()

else:

self._locator = ticks

self.long_axis.set_major_locator(self._locator)

self.stale = True

def get_ticks(self, minor=False):

"""

if minor:

return self.long_axis.get_minorticklocs()

else:

return self.long_axis.get_majorticklocs()

def set_ticklabels(self, ticklabels, *, minor=False, **kwargs):

"""

self.long_axis.set_ticklabels(ticklabels, minor=minor, **kwargs)

def minorticks_on(self):

"""

self.ax.minorticks_on()

self._short_axis().set_minor_locator(ticker.NullLocator())

def minorticks_off(self):

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

self._minorlocator = ticker.NullLocator()

self.long_axis.set_minor_locator(self._minorlocator)

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

"""

if self.orientation == "vertical":

self.ax.set_ylabel(label, loc=loc, **kwargs)

else:

self.ax.set_xlabel(label, loc=loc, **kwargs)

self.stale = True

def set_alpha(self, alpha):

"""

self.alpha = None if isinstance(alpha, np.ndarray) else alpha

def _set_scale(self, scale, **kwargs):

"""