""" Colorbars are a visualization of the mapping from scalar values to colors. In Matplotlib they are drawn into a dedicated `~.axes.Axes`. .. note:: Colorbars are typically created through `.Figure.colorbar` or its pyplot wrapper `.pyplot.colorbar`, which internally use `.Colorbar` together with `.make_axes_gridspec` (for `.GridSpec`-positioned axes) or `.make_axes` (for non-`.GridSpec`-positioned axes). End-users most likely won't need to directly use this module's API. """ import copy import logging import textwrap import numpy as np import matplotlib as mpl from matplotlib import _api, collections, cm, colors, contour, ticker import matplotlib.artist as martist import matplotlib.patches as mpatches import matplotlib.path as mpath import matplotlib.scale as mscale import matplotlib.spines as mspines import matplotlib.transforms as mtransforms from matplotlib import docstring _log = logging.getLogger(__name__) _make_axes_param_doc = """ location : None or {'left', 'right', 'top', 'bottom'} The location, relative to the parent axes, where the colorbar axes is created. It also determines the *orientation* of the colorbar (colorbars on the left and right are vertical, colorbars at the top and bottom are horizontal). If None, the location will come from the *orientation* if it is set (vertical colorbars on the right, horizontal ones at the bottom), or default to 'right' if *orientation* is unset. orientation : None or {'vertical', 'horizontal'} The orientation of the colorbar. It is preferable to set the *location* of the colorbar, as that also determines the *orientation*; passing incompatible values for *location* and *orientation* raises an exception. fraction : float, default: 0.15 Fraction of original axes to use for colorbar. shrink : float, default: 1.0 Fraction by which to multiply the size of the colorbar. aspect : float, default: 20 Ratio of long to short dimensions. """ _make_axes_other_param_doc = """ pad : float, default: 0.05 if vertical, 0.15 if horizontal Fraction of original axes between colorbar and new image axes. anchor : (float, float), optional The anchor point of the colorbar axes. Defaults to (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal. panchor : (float, float), or *False*, optional The anchor point of the colorbar parent axes. If *False*, the parent axes' anchor will be unchanged. Defaults to (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal. """ _colormap_kw_doc = """ ============ ==================================================== Property Description ============ ==================================================== *extend* {'neither', 'both', 'min', 'max'} If not 'neither', make pointed end(s) for out-of- range values. These are set for a given colormap using the colormap set_under and set_over methods. *extendfrac* {*None*, 'auto', length, lengths} If set to *None*, both the minimum and maximum triangular colorbar extensions with have a length of 5% of the interior colorbar length (this is the default setting). If set to 'auto', makes the triangular colorbar extensions the same lengths as the interior boxes (when *spacing* is set to 'uniform') or the same lengths as the respective adjacent interior boxes (when *spacing* is set to 'proportional'). If a scalar, indicates the length of both the minimum and maximum triangular colorbar extensions as a fraction of the interior colorbar length. A two-element sequence of fractions may also be given, indicating the lengths of the minimum and maximum colorbar extensions respectively as a fraction of the interior colorbar length. *extendrect* bool If *False* the minimum and maximum colorbar extensions will be triangular (the default). If *True* the extensions will be rectangular. *spacing* {'uniform', 'proportional'} Uniform spacing gives each discrete color the same space; proportional makes the space proportional to the data interval. *ticks* *None* or list of ticks or Locator If None, ticks are determined automatically from the input. *format* None or str or Formatter If None, `~.ticker.ScalarFormatter` is used. If a format string is given, e.g., '%.3f', that is used. An alternative `~.ticker.Formatter` may be given instead. *drawedges* bool Whether to draw lines at color boundaries. *label* str The label on the colorbar's long axis. ============ ==================================================== The following will probably be useful only in the context of indexed colors (that is, when the mappable has norm=NoNorm()), or other unusual circumstances. ============ =================================================== Property Description ============ =================================================== *boundaries* None or a sequence *values* None or a sequence which must be of length 1 less than the sequence of *boundaries*. For each region delimited by adjacent entries in *boundaries*, the colormapped to the corresponding value in values will be used. ============ =================================================== """ docstring.interpd.update(colorbar_doc=""" Add a colorbar to a plot. Parameters ---------- mappable The `matplotlib.cm.ScalarMappable` (i.e., `~matplotlib.image.AxesImage`, `~matplotlib.contour.ContourSet`, etc.) described by this colorbar. This argument is mandatory for the `.Figure.colorbar` method but optional for the `.pyplot.colorbar` function, which sets the default to the current image. Note that one can create a `.ScalarMappable` "on-the-fly" to generate colorbars not attached to a previously drawn artist, e.g. :: fig.colorbar(cm.ScalarMappable(norm=norm, cmap=cmap), ax=ax) cax : `~matplotlib.axes.Axes`, optional Axes into which the colorbar will be drawn. ax : `~matplotlib.axes.Axes`, list of Axes, optional One or more parent axes from which space for a new colorbar axes will be stolen, if *cax* is None. This has no effect if *cax* is set. use_gridspec : bool, optional If *cax* is ``None``, a new *cax* is created as an instance of Axes. If *ax* is an instance of Subplot and *use_gridspec* is ``True``, *cax* is created as an instance of Subplot using the :mod:`.gridspec` module. Returns ------- colorbar : `~matplotlib.colorbar.Colorbar` Notes ----- Additional keyword arguments are of two kinds: axes properties: %s %s colorbar properties: %s If *mappable* is a `~.contour.ContourSet`, its *extend* kwarg is included automatically. The *shrink* kwarg provides a simple way to scale the colorbar with respect to the axes. Note that if *cax* is specified, it determines the size of the colorbar and *shrink* and *aspect* kwargs are ignored. For more precise control, you can manually specify the positions of the axes objects in which the mappable and the colorbar are drawn. In this case, do not use any of the axes properties kwargs. It is known that some vector graphics viewers (svg and pdf) renders white gaps between segments of the colorbar. This is due to bugs in the viewers, not Matplotlib. As a workaround, the colorbar can be rendered with overlapping segments:: cbar = colorbar() cbar.solids.set_edgecolor("face") draw() However this has negative consequences in other circumstances, e.g. with semi-transparent images (alpha < 1) and colorbar extensions; therefore, this workaround is not used by default (see issue #1188). """ % (textwrap.indent(_make_axes_param_doc, " "), textwrap.indent(_make_axes_other_param_doc, " "), _colormap_kw_doc)) @_api.caching_module_getattr # module-level deprecations class __getattr__: colorbar_doc = _api.deprecated("3.4", obj_type="")(property( lambda self: docstring.interpd.params["colorbar_doc"])) colorbar_kw_doc = _api.deprecated("3.4", obj_type="")(property( lambda self: _colormap_kw_doc)) make_axes_kw_doc = _api.deprecated("3.4", obj_type="")(property( lambda self: _make_axes_param_doc + _make_axes_other_param_doc)) def _set_ticks_on_axis_warn(*args, **kw): # a top level function which gets put in at the axes' # set_xticks and set_yticks by Colorbar.__init__. _api.warn_external("Use the colorbar set_ticks() method instead.") class _ColorbarSpine(mspines.Spine): def __init__(self, axes): self._ax = axes super().__init__(axes, 'colorbar', mpath.Path(np.empty((0, 2)), closed=True)) 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 return ret class _ColorbarAxesLocator: """ Shrink the axes if there are triangular or rectangular extends. """ 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.. ss = getattr(self._cbar.ax, 'get_subplotspec', None) if ss is None: if self._orig_locator is None: return None ss = self._orig_locator.get_subplotspec() else: ss = ss() return ss class Colorbar: r""" Draw a colorbar in an existing axes. Typically, colorbars are created using `.Figure.colorbar` or `.pyplot.colorbar` and associated with `.ScalarMappable`\s (such as an `.AxesImage` generated via `~.axes.Axes.imshow`). In order to draw a colorbar not associated with other elements in the figure, e.g. when showing a colormap by itself, one can create an empty `.ScalarMappable`, or directly pass *cmap* and *norm* instead of *mappable* to `Colorbar`. Useful public methods are :meth:`set_label` and :meth:`add_lines`. Attributes ---------- ax : `~matplotlib.axes.Axes` The `~.axes.Axes` instance in which the colorbar is drawn. lines : list A list of `.LineCollection` (empty if no lines were drawn). dividers : `.LineCollection` A LineCollection (empty if *drawedges* is ``False``). Parameters ---------- ax : `~matplotlib.axes.Axes` The `~.axes.Axes` instance in which the colorbar is drawn. mappable : `.ScalarMappable` The mappable whose colormap and norm will be used. To show the under- and over- value colors, the mappable's norm should be specified as :: norm = colors.Normalize(clip=False) To show the colors versus index instead of on a 0-1 scale, use:: norm=colors.NoNorm() cmap : `~matplotlib.colors.Colormap`, default: :rc:`image.cmap` The colormap to use. This parameter is ignored, unless *mappable* is None. norm : `~matplotlib.colors.Normalize` The normalization to use. This parameter is ignored, unless *mappable* is None. alpha : float The colorbar transparency between 0 (transparent) and 1 (opaque). values, boundaries If unset, the colormap will be displayed on a 0-1 scale. orientation : {'vertical', 'horizontal'} ticklocation : {'auto', 'left', 'right', 'top', 'bottom'} extend : {'neither', 'both', 'min', 'max'} spacing : {'uniform', 'proportional'} ticks : `~matplotlib.ticker.Locator` or array-like of float format : str or `~matplotlib.ticker.Formatter` drawedges : bool filled : bool extendfrac extendrec label : str """ n_rasterize = 50 # rasterize solids if number of colors >= n_rasterize def __init__(self, ax, mappable=None, *, cmap=None, norm=None, alpha=None, values=None, boundaries=None, orientation='vertical', ticklocation='auto', extend=None, spacing='uniform', # uniform or proportional ticks=None, format=None, drawedges=False, filled=True, extendfrac=None, extendrect=False, label='', ): if mappable is None: mappable = cm.ScalarMappable(norm=norm, cmap=cmap) # Ensure the given mappable's norm has appropriate vmin and vmax # set even if mappable.draw has not yet been called. if mappable.get_array() is not None: mappable.autoscale_None() self.mappable = mappable cmap = mappable.cmap norm = mappable.norm 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) _api.check_in_list( ['vertical', 'horizontal'], orientation=orientation) _api.check_in_list( ['auto', 'left', 'right', 'top', 'bottom'], ticklocation=ticklocation) _api.check_in_list( ['uniform', 'proportional'], spacing=spacing) 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.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._short_axis().set_visible(False) # Only kept for backcompat; remove after deprecation of .patch elapses. 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 = collections.LineCollection( [], colors=[mpl.rcParams['axes.edgecolor']], linewidths=[0.5 * mpl.rcParams['axes.linewidth']]) self.ax.add_collection(self.dividers) self.locator = None self.minorlocator = None self.formatter = 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() 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 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() # Also remove ._patch after deprecation elapses. patch = _api.deprecate_privatize_attribute("3.5", alternative="ax") def update_normal(self, mappable): """ Update solid patches, lines, etc. This is meant to be called when the norm of the image or contour plot to which this colorbar belongs changes. If the norm on the mappable is different than before, this resets the locator and formatter for the axis, so if these have been customized, they will need to be customized again. However, if the norm only changes values of *vmin*, *vmax* or *cmap* then the old formatter and locator will be preserved. """ _log.debug('colorbar update normal %r %r', mappable.norm, self.norm) self.mappable = mappable self.set_alpha(mappable.get_alpha()) self.cmap = mappable.cmap if mappable.norm != self.norm: self.norm = 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): """ Calculate any free parameters based on the current cmap and norm, and do all the drawing. """ 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, extendlen = 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(extendlen) if self.orientation == 'vertical': self.ax.set_xlim(0, 1) self.ax.set_ylim(self.vmin, self.vmax) else: self.ax.set_ylim(0, 1) self.ax.set_xlim(self.vmin, self.vmax) # 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.dividers.set_segments( np.dstack([X, Y])[1:-1] if self.drawedges else []) def _add_solids_patches(self, X, Y, C, mappable): hatches = mappable.hatches * len(C) # Have enough hatches. patches = [] for i in range(len(X) - 1): xy = np.array([[X[i, 0], Y[i, 0]], [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, extendlen): """ Add the extend tri/rectangles on the outside of the axes. """ # extend lengths are fraction of the *inner* part of colorbar, # not the total colorbar: 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 else: hatches = [None] 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 color = self.cmap(self.norm(self._values[0])) patch = mpatches.PathPatch( mpath.Path(xy), facecolor=color, linewidth=0, antialiased=False, transform=self.ax.transAxes, hatch=hatches[0], clip_on=False) self.ax.add_patch(patch) 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 color = self.cmap(self.norm(self._values[-1])) patch = mpatches.PathPatch( mpath.Path(xy), facecolor=color, linewidth=0, antialiased=False, transform=self.ax.transAxes, hatch=hatches[-1], clip_on=False) self.ax.add_patch(patch) return def add_lines(self, *args, **kwargs): """ Draw lines on the colorbar. The lines are appended to the list :attr:`lines`. Parameters ---------- levels : array-like The positions of the lines. colors : color or list of colors Either a single color applying to all lines or one color value for each line. linewidths : float or array-like Either a single linewidth applying to all lines or one linewidth for each line. erase : bool, default: True Whether to remove any previously added lines. Notes ----- Alternatively, this method can also be called with the signature ``colorbar.add_lines(contour_set, erase=True)``, in which case *levels*, *colors*, and *linewidths* are taken from *contour_set*. """ 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, [c[0] for c in CS.tcolors], [t[0] for t in CS.tlinewidths], 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): """ Setup the ticks and ticklabels. This should not be needed by users. """ # 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): """ Return the ``locator`` and ``formatter`` of the colorbar. If they have not been defined (i.e. are *None*), the formatter and locator are retrieved from the axis, or from the value of the boundaries for a boundary norm. Called by update_ticks... """ 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) 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) @_api.delete_parameter("3.5", "update_ticks") def set_ticks(self, ticks, update_ticks=True, labels=None, *, minor=False, **kwargs): """ Set tick locations. Parameters ---------- ticks : list of floats List of tick locations. labels : list of str, optional List of tick labels. If not set, the labels show the data value. minor : bool, default: False If ``False``, set the major ticks; if ``True``, the minor ticks. **kwargs `.Text` properties for the labels. These take effect only if you pass *labels*. In other cases, please use `~.Axes.tick_params`. """ 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): """ Return the ticks as a list of locations. Parameters ---------- minor : boolean, default: False if True return the minor ticks. """ if minor: return self._long_axis().get_minorticklocs() else: return self._long_axis().get_majorticklocs() @_api.delete_parameter("3.5", "update_ticks") def set_ticklabels(self, ticklabels, update_ticks=True, *, minor=False, **kwargs): """ Set tick labels. .. admonition:: Discouraged The use of this method is discouraged, because of the dependency on tick positions. In most cases, you'll want to use ``set_ticks(positions, labels=labels)`` instead. If you are using this method, you should always fix the tick positions before, e.g. by using `.Colorbar.set_ticks` or by explicitly setting a `~.ticker.FixedLocator` on the long axis of the colorbar. Otherwise, ticks are free to move and the labels may end up in unexpected positions. Parameters ---------- ticklabels : sequence of str or of `.Text` Texts for labeling each tick location in the sequence set by `.Colorbar.set_ticks`; the number of labels must match the number of locations. update_ticks : bool, default: True This keyword argument is ignored and will be be removed. Deprecated minor : bool If True, set minor ticks instead of major ticks. **kwargs `.Text` properties for the labels. """ self._long_axis().set_ticklabels(ticklabels, minor=minor, **kwargs) def minorticks_on(self): """ Turn on colorbar minor ticks. """ self.ax.minorticks_on() self.minorlocator = self._long_axis().get_minor_locator() 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): """ Add a label to the long axis of the colorbar. Parameters ---------- label : str The label text. loc : str, optional The location of the label. - For horizontal orientation one of {'left', 'center', 'right'} - For vertical orientation one of {'bottom', 'center', 'top'} Defaults to :rc:`xaxis.labellocation` or :rc:`yaxis.labellocation` depending on the orientation. **kwargs Keyword arguments are passed to `~.Axes.set_xlabel` / `~.Axes.set_ylabel`. Supported keywords are *labelpad* and `.Text` properties. """ 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): """ Set the transparency between 0 (transparent) and 1 (opaque). If an array is provided, *alpha* will be set to None to use the transparency values associated with the colormap. """ self.alpha = None if isinstance(alpha, np.ndarray) else alpha def _set_scale(self, scale, **kwargs): """ Set the colorbar long axis scale. Parameters ---------- value : {"linear", "log", "symlog", "logit", ...} or `.ScaleBase` The axis scale type to apply. **kwargs Different keyword arguments are accepted, depending on the scale. See the respective class keyword arguments: - `matplotlib.scale.LinearScale` - `matplotlib.scale.LogScale` - `matplotlib.scale.SymmetricalLogScale` - `matplotlib.scale.LogitScale` - `matplotlib.scale.FuncScale` Notes ----- By default, Matplotlib supports the above mentioned scales. Additionally, custom scales may be registered using `matplotlib.scale.register_scale`. These scales can then also be used here. """ if self.orientation == 'vertical': self.ax.set_yscale(scale, **kwargs) else: self.ax.set_xscale(scale, **kwargs) if isinstance(scale, mscale.ScaleBase): self.__scale = scale.name else: self.__scale = scale def remove(self): """ Remove this colorbar from the figure. If the colorbar was created with ``use_gridspec=True`` the previous gridspec is restored. """ if hasattr(self.ax, '_colorbar_info'): parents = self.ax._colorbar_info['parents'] for a in parents: if self.ax in a._colorbars: a._colorbars.remove(self.ax) self.ax.remove() self.mappable.callbacks.disconnect(self.mappable.colorbar_cid) self.mappable.colorbar = None self.mappable.colorbar_cid = None try: ax = self.mappable.axes except AttributeError: return try: gs = ax.get_subplotspec().get_gridspec() subplotspec = gs.get_topmost_subplotspec() except AttributeError: # use_gridspec was False pos = ax.get_position(original=True) ax._set_position(pos) else: # use_gridspec was True ax.set_subplotspec(subplotspec) def _ticker(self, locator, formatter): """ Return the sequence of ticks (colorbar data locations), ticklabels (strings), and the corresponding offset string. """ 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]) locator.axis.set_view_interval(*intv) locator.axis.set_data_interval(*intv) formatter.set_axis(locator.axis) 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)] ticks = self._locate(b) ticklabels = formatter.format_ticks(b) offset_string = formatter.get_offset() return ticks, ticklabels, offset_string def _process_values(self): """ Set `_boundaries` and `_values` based on the self.boundaries and self.values if not None, or based on the size of the colormap and the vmin/vmax of the norm. """ if self.values is not None: # set self._boundaries from the values... self._values = np.array(self.values) if self.boundaries is None: # bracket values by 1/2 dv: 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 # otherwise values are set from the boundaries if isinstance(self.norm, colors.BoundaryNorm): b = self.norm.boundaries elif isinstance(self.norm, colors.NoNorm): # NoNorm has N blocks, so N+1 boundaries, centered on integers: b = np.arange(self.cmap.N + 1) - .5 elif self.boundaries is not None: b = self.boundaries else: # otherwise make the boundaries from the size of the cmap: N = self.cmap.N + 1 b, _ = self._uniform_y(N) # add extra boundaries if needed: if self._extend_lower(): b = np.hstack((b[0] - 1, b)) if self._extend_upper(): b = np.hstack((b, b[-1] + 1)) # transform from 0-1 to vmin-vmax: 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) if (not isinstance(self.norm, colors.BoundaryNorm) and (self.boundaries is None)): b = self.norm.inverse(b) self._boundaries = np.asarray(b, dtype=float) 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) def _mesh(self): """ Return the coordinate arrays for the colorbar pcolormesh/patches. These are scaled between vmin and vmax, and already handle colorbar orientation. """ # copy the norm and change the vmin and vmax to the vmin and # vmax of the colorbar, not the norm. This allows the situation # where the colormap has a narrower range than the colorbar, to # accommodate extra contours: norm = copy.deepcopy(self.norm) norm.vmin = self.vmin norm.vmax = self.vmax y, extendlen = self._proportional_y() # invert: if (isinstance(norm, (colors.BoundaryNorm, colors.NoNorm)) or self.boundaries is not None): y = y * (self.vmax - self.vmin) + self.vmin # not using a norm. else: y = norm.inverse(y) self._y = y X, Y = np.meshgrid([0., 1.], y) if self.orientation == 'vertical': return (X, Y, extendlen) else: return (Y, X, extendlen) def _forward_boundaries(self, x): # map boundaries equally between 0 and 1... b = self._boundaries y = np.interp(x, b, np.linspace(0, 1, len(b))) # the following avoids ticks in the extends: eps = (b[-1] - b[0]) * 1e-6 # map these _well_ out of bounds to keep any ticks out # of the extends region... y[x < b[0]-eps] = -1 y[x > b[-1]+eps] = 2 return y def _inverse_boundaries(self, x): # invert the above... b = self._boundaries return np.interp(x, np.linspace(0, 1, len(b)), b) def _reset_locator_formatter_scale(self): """ Reset the locator et al to defaults. Any user-hardcoded changes need to be re-entered if this gets called (either at init, or when the mappable normal gets changed: Colorbar.update_normal) """ self._process_values() self.locator = None self.minorlocator = None self.formatter = None if (self.boundaries is not None or isinstance(self.norm, colors.BoundaryNorm)): if self.spacing == 'uniform': funcs = (self._forward_boundaries, self._inverse_boundaries) self._set_scale('function', functions=funcs) elif self.spacing == 'proportional': self._set_scale('linear') elif getattr(self.norm, '_scale', None): # use the norm's scale (if it exists and is not None): self._set_scale(self.norm._scale) elif type(self.norm) is colors.Normalize: # plain Normalize: self._set_scale('linear') else: # norm._scale is None or not an attr: derive the scale from # the Norm: funcs = (self.norm, self.norm.inverse) self._set_scale('function', functions=funcs) def _locate(self, x): """ Given a set of color data values, return their corresponding colorbar data coordinates. """ if isinstance(self.norm, (colors.NoNorm, colors.BoundaryNorm)): b = self._boundaries xn = x else: # Do calculations using normalized coordinates so # as to make the interpolation more accurate. b = self.norm(self._boundaries, clip=False).filled() xn = self.norm(x, clip=False).filled() bunique = b[self._inside] yunique = self._y z = np.interp(xn, bunique, yunique) return z # trivial helpers def _uniform_y(self, N): """ Return colorbar data coordinates for *N* uniformly spaced boundaries, plus extension lengths if required. """ automin = automax = 1. / (N - 1.) extendlength = self._get_extension_lengths(self.extendfrac, automin, automax, default=0.05) y = np.linspace(0, 1, N) return y, extendlength def _proportional_y(self): """ Return colorbar data coordinates for the boundaries of a proportional colorbar, plus extension lengths if required: """ if (isinstance(self.norm, colors.BoundaryNorm) or self.boundaries is not None): y = (self._boundaries - self._boundaries[self._inside][0]) y = y / (self._boundaries[self._inside][-1] - self._boundaries[self._inside][0]) # need yscaled the same as the axes scale to get # the extend lengths. if self.spacing == 'uniform': yscaled = self._forward_boundaries(self._boundaries) else: yscaled = y else: y = self.norm(self._boundaries.copy()) y = np.ma.filled(y, np.nan) # the norm and the scale should be the same... yscaled = y y = y[self._inside] yscaled = yscaled[self._inside] # normalize from 0..1: norm = colors.Normalize(y[0], y[-1]) y = np.ma.filled(norm(y), np.nan) norm = colors.Normalize(yscaled[0], yscaled[-1]) yscaled = np.ma.filled(norm(yscaled), np.nan) # make the lower and upper extend lengths proportional to the lengths # of the first and last boundary spacing (if extendfrac='auto'): automin = yscaled[1] - yscaled[0] automax = yscaled[-1] - yscaled[-2] extendlength = [0, 0] if self._extend_lower() or self._extend_upper(): extendlength = self._get_extension_lengths( self.extendfrac, automin, automax, default=0.05) return y, extendlength def _get_extension_lengths(self, frac, automin, automax, default=0.05): """ Return the lengths of colorbar extensions. This is a helper method for _uniform_y and _proportional_y. """ # Set the default value. extendlength = np.array([default, default]) if isinstance(frac, str): _api.check_in_list(['auto'], extendfrac=frac.lower()) # Use the provided values when 'auto' is required. extendlength[:] = [automin, automax] elif frac is not None: try: # Try to set min and max extension fractions directly. extendlength[:] = frac # If frac is a sequence containing None then NaN may # be encountered. This is an error. if np.isnan(extendlength).any(): raise ValueError() except (TypeError, ValueError) as err: # Raise an error on encountering an invalid value for frac. raise ValueError('invalid value for extendfrac') from err return extendlength 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 _long_axis(self): """Return the long axis""" if self.orientation == 'vertical': return self.ax.yaxis return self.ax.xaxis def _short_axis(self): """Return the short axis""" if self.orientation == 'vertical': return self.ax.xaxis return self.ax.yaxis def _get_view(self): # docstring inherited # An interactive view for a colorbar is the norm's vmin/vmax return self.norm.vmin, self.norm.vmax def _set_view(self, view): # docstring inherited # An interactive view for a colorbar is the norm's vmin/vmax self.norm.vmin, self.norm.vmax = view def _set_view_from_bbox(self, bbox, direction='in', mode=None, twinx=False, twiny=False): # docstring inherited # For colorbars, we use the zoom bbox to scale the norm's vmin/vmax new_xbound, new_ybound = self.ax._prepare_view_from_bbox( bbox, direction=direction, mode=mode, twinx=twinx, twiny=twiny) if self.orientation == 'horizontal': self.norm.vmin, self.norm.vmax = new_xbound elif self.orientation == 'vertical': self.norm.vmin, self.norm.vmax = new_ybound def drag_pan(self, button, key, x, y): # docstring inherited points = self.ax._get_pan_points(button, key, x, y) if points is not None: if self.orientation == 'horizontal': self.norm.vmin, self.norm.vmax = points[:, 0] elif self.orientation == 'vertical': self.norm.vmin, self.norm.vmax = points[:, 1] ColorbarBase = Colorbar # Backcompat API def _normalize_location_orientation(location, orientation): if location is None: location = _api.check_getitem( {None: "right", "vertical": "right", "horizontal": "bottom"}, orientation=orientation) loc_settings = _api.check_getitem({ "left": {"location": "left", "orientation": "vertical", "anchor": (1.0, 0.5), "panchor": (0.0, 0.5), "pad": 0.10}, "right": {"location": "right", "orientation": "vertical", "anchor": (0.0, 0.5), "panchor": (1.0, 0.5), "pad": 0.05}, "top": {"location": "top", "orientation": "horizontal", "anchor": (0.5, 0.0), "panchor": (0.5, 1.0), "pad": 0.05}, "bottom": {"location": "bottom", "orientation": "horizontal", "anchor": (0.5, 1.0), "panchor": (0.5, 0.0), "pad": 0.15}, }, location=location) if orientation is not None and orientation != loc_settings["orientation"]: # Allow the user to pass both if they are consistent. raise TypeError("location and orientation are mutually exclusive") return loc_settings @docstring.Substitution(_make_axes_param_doc, _make_axes_other_param_doc) def make_axes(parents, location=None, orientation=None, fraction=0.15, shrink=1.0, aspect=20, **kw): """ Create an `~.axes.Axes` suitable for a colorbar. The axes is placed in the figure of the *parents* axes, by resizing and repositioning *parents*. Parameters ---------- parents : `~.axes.Axes` or list of `~.axes.Axes` The Axes to use as parents for placing the colorbar. %s Returns ------- cax : `~.axes.Axes` The child axes. kw : dict The reduced keyword dictionary to be passed when creating the colorbar instance. Other Parameters ---------------- %s """ loc_settings = _normalize_location_orientation(location, orientation) # put appropriate values into the kw dict for passing back to # the Colorbar class kw['orientation'] = loc_settings['orientation'] location = kw['ticklocation'] = loc_settings['location'] anchor = kw.pop('anchor', loc_settings['anchor']) panchor = kw.pop('panchor', loc_settings['panchor']) aspect0 = aspect # turn parents into a list if it is not already. We do this w/ np # because `plt.subplots` can return an ndarray and is natural to # pass to `colorbar`. parents = np.atleast_1d(parents).ravel() fig = parents[0].get_figure() pad0 = 0.05 if fig.get_constrained_layout() else loc_settings['pad'] pad = kw.pop('pad', pad0) if not all(fig is ax.get_figure() for ax in parents): raise ValueError('Unable to create a colorbar axes as not all ' 'parents share the same figure.') # take a bounding box around all of the given axes parents_bbox = mtransforms.Bbox.union( [ax.get_position(original=True).frozen() for ax in parents]) pb = parents_bbox if location in ('left', 'right'): if location == 'left': pbcb, _, pb1 = pb.splitx(fraction, fraction + pad) else: pb1, _, pbcb = pb.splitx(1 - fraction - pad, 1 - fraction) pbcb = pbcb.shrunk(1.0, shrink).anchored(anchor, pbcb) else: if location == 'bottom': pbcb, _, pb1 = pb.splity(fraction, fraction + pad) else: pb1, _, pbcb = pb.splity(1 - fraction - pad, 1 - fraction) pbcb = pbcb.shrunk(shrink, 1.0).anchored(anchor, pbcb) # define the aspect ratio in terms of y's per x rather than x's per y aspect = 1.0 / aspect # define a transform which takes us from old axes coordinates to # new axes coordinates shrinking_trans = mtransforms.BboxTransform(parents_bbox, pb1) # transform each of the axes in parents using the new transform for ax in parents: new_posn = shrinking_trans.transform(ax.get_position(original=True)) new_posn = mtransforms.Bbox(new_posn) ax._set_position(new_posn) if panchor is not False: ax.set_anchor(panchor) cax = fig.add_axes(pbcb, label="") for a in parents: # tell the parent it has a colorbar a._colorbars += [cax] cax._colorbar_info = dict( location=location, parents=parents, shrink=shrink, anchor=anchor, panchor=panchor, fraction=fraction, aspect=aspect0, pad=pad) # and we need to set the aspect ratio by hand... cax.set_anchor(anchor) cax.set_box_aspect(aspect) cax.set_aspect('auto') return cax, kw @docstring.Substitution(_make_axes_param_doc, _make_axes_other_param_doc) def make_axes_gridspec(parent, *, location=None, orientation=None, fraction=0.15, shrink=1.0, aspect=20, **kw): """ Create a `.SubplotBase` suitable for a colorbar. The axes is placed in the figure of the *parent* axes, by resizing and repositioning *parent*. This function is similar to `.make_axes`. Primary differences are - `.make_axes_gridspec` should only be used with a `.SubplotBase` parent. - `.make_axes` creates an `~.axes.Axes`; `.make_axes_gridspec` creates a `.SubplotBase`. - `.make_axes` updates the position of the parent. `.make_axes_gridspec` replaces the ``grid_spec`` attribute of the parent with a new one. While this function is meant to be compatible with `.make_axes`, there could be some minor differences. Parameters ---------- parent : `~.axes.Axes` The Axes to use as parent for placing the colorbar. %s Returns ------- cax : `~.axes.SubplotBase` The child axes. kw : dict The reduced keyword dictionary to be passed when creating the colorbar instance. Other Parameters ---------------- %s """ loc_settings = _normalize_location_orientation(location, orientation) kw['orientation'] = loc_settings['orientation'] location = kw['ticklocation'] = loc_settings['location'] aspect0 = aspect anchor = kw.pop('anchor', loc_settings['anchor']) panchor = kw.pop('panchor', loc_settings['panchor']) pad = kw.pop('pad', loc_settings["pad"]) wh_space = 2 * pad / (1 - pad) if location in ('left', 'right'): # for shrinking height_ratios = [ (1-anchor[1])*(1-shrink), shrink, anchor[1]*(1-shrink)] if location == 'left': gs = parent.get_subplotspec().subgridspec( 1, 2, wspace=wh_space, width_ratios=[fraction, 1-fraction-pad]) ss_main = gs[1] ss_cb = gs[0].subgridspec( 3, 1, hspace=0, height_ratios=height_ratios)[1] else: gs = parent.get_subplotspec().subgridspec( 1, 2, wspace=wh_space, width_ratios=[1-fraction-pad, fraction]) ss_main = gs[0] ss_cb = gs[1].subgridspec( 3, 1, hspace=0, height_ratios=height_ratios)[1] else: # for shrinking width_ratios = [ anchor[0]*(1-shrink), shrink, (1-anchor[0])*(1-shrink)] if location == 'bottom': gs = parent.get_subplotspec().subgridspec( 2, 1, hspace=wh_space, height_ratios=[1-fraction-pad, fraction]) ss_main = gs[0] ss_cb = gs[1].subgridspec( 1, 3, wspace=0, width_ratios=width_ratios)[1] aspect = 1 / aspect else: gs = parent.get_subplotspec().subgridspec( 2, 1, hspace=wh_space, height_ratios=[fraction, 1-fraction-pad]) ss_main = gs[1] ss_cb = gs[0].subgridspec( 1, 3, wspace=0, width_ratios=width_ratios)[1] aspect = 1 / aspect parent.set_subplotspec(ss_main) parent.set_anchor(panchor) fig = parent.get_figure() cax = fig.add_subplot(ss_cb, label="") cax.set_anchor(anchor) cax.set_box_aspect(aspect) cax.set_aspect('auto') cax._colorbar_info = dict( location=location, parents=[parent], shrink=shrink, anchor=anchor, panchor=panchor, fraction=fraction, aspect=aspect0, pad=pad) return cax, kw @_api.deprecated("3.4", alternative="Colorbar") class ColorbarPatch(Colorbar): pass @_api.deprecated("3.4", alternative="Colorbar") def colorbar_factory(cax, mappable, **kwargs): """ Create a colorbar on the given axes for the given mappable. .. note:: This is a low-level function to turn an existing axes into a colorbar axes. Typically, you'll want to use `~.Figure.colorbar` instead, which automatically handles creation and placement of a suitable axes as well. Parameters ---------- cax : `~matplotlib.axes.Axes` The `~.axes.Axes` to turn into a colorbar. mappable : `~matplotlib.cm.ScalarMappable` The mappable to be described by the colorbar. **kwargs Keyword arguments are passed to the respective colorbar class. Returns ------- `.Colorbar` The created colorbar instance. """ return Colorbar(cax, mappable, **kwargs)