""" Classes for the ticks and x- and y-axis. """ import datetime import functools import logging from numbers import Real import warnings import numpy as np import matplotlib as mpl from matplotlib import _api, cbook import matplotlib.artist as martist import matplotlib.colors as mcolors import matplotlib.lines as mlines import matplotlib.scale as mscale import matplotlib.text as mtext import matplotlib.ticker as mticker import matplotlib.transforms as mtransforms import matplotlib.units as munits _log = logging.getLogger(__name__) GRIDLINE_INTERPOLATION_STEPS = 180 # This list is being used for compatibility with Axes.grid, which # allows all Line2D kwargs. _line_inspector = martist.ArtistInspector(mlines.Line2D) _line_param_names = _line_inspector.get_setters() _line_param_aliases = [next(iter(d)) for d in _line_inspector.aliasd.values()] _gridline_param_names = ['grid_' + name for name in _line_param_names + _line_param_aliases] class Tick(martist.Artist): """ Abstract base class for the axis ticks, grid lines and labels. Ticks mark a position on an Axis. They contain two lines as markers and two labels; one each for the bottom and top positions (in case of an `.XAxis`) or for the left and right positions (in case of a `.YAxis`). Attributes ---------- tick1line : `~matplotlib.lines.Line2D` The left/bottom tick marker. tick2line : `~matplotlib.lines.Line2D` The right/top tick marker. gridline : `~matplotlib.lines.Line2D` The grid line associated with the label position. label1 : `~matplotlib.text.Text` The left/bottom tick label. label2 : `~matplotlib.text.Text` The right/top tick label. """ def __init__( self, axes, loc, *, size=None, # points width=None, color=None, tickdir=None, pad=None, labelsize=None, labelcolor=None, labelfontfamily=None, zorder=None, gridOn=None, # defaults to axes.grid depending on axes.grid.which tick1On=True, tick2On=True, label1On=True, label2On=False, major=True, labelrotation=0, grid_color=None, grid_linestyle=None, grid_linewidth=None, grid_alpha=None, **kwargs, # Other Line2D kwargs applied to gridlines. ): """ bbox is the Bound2D bounding box in display coords of the Axes loc is the tick location in data coords size is the tick size in points """ super().__init__() if gridOn is None: which = mpl.rcParams['axes.grid.which'] if major and (which in ('both', 'major')): gridOn = mpl.rcParams['axes.grid'] elif (not major) and (which in ('both', 'minor')): gridOn = mpl.rcParams['axes.grid'] else: gridOn = False self.set_figure(axes.get_figure(root=False)) self.axes = axes self._loc = loc self._major = major name = self.__name__ major_minor = "major" if major else "minor" if size is None: size = mpl.rcParams[f"{name}.{major_minor}.size"] self._size = size if width is None: width = mpl.rcParams[f"{name}.{major_minor}.width"] self._width = width if color is None: color = mpl.rcParams[f"{name}.color"] if pad is None: pad = mpl.rcParams[f"{name}.{major_minor}.pad"] self._base_pad = pad if labelcolor is None: labelcolor = mpl.rcParams[f"{name}.labelcolor"] if cbook._str_equal(labelcolor, 'inherit'): # inherit from tick color labelcolor = mpl.rcParams[f"{name}.color"] if labelsize is None: labelsize = mpl.rcParams[f"{name}.labelsize"] self._set_labelrotation(labelrotation) if zorder is None: if major: zorder = mlines.Line2D.zorder + 0.01 else: zorder = mlines.Line2D.zorder self._zorder = zorder grid_color = mpl._val_or_rc(grid_color, "grid.color") grid_linestyle = mpl._val_or_rc(grid_linestyle, "grid.linestyle") grid_linewidth = mpl._val_or_rc(grid_linewidth, "grid.linewidth") if grid_alpha is None and not mcolors._has_alpha_channel(grid_color): # alpha precedence: kwarg > color alpha > rcParams['grid.alpha'] # Note: only resolve to rcParams if the color does not have alpha # otherwise `grid(color=(1, 1, 1, 0.5))` would work like # grid(color=(1, 1, 1, 0.5), alpha=rcParams['grid.alpha']) # so the that the rcParams default would override color alpha. grid_alpha = mpl.rcParams["grid.alpha"] grid_kw = {k[5:]: v for k, v in kwargs.items()} self.tick1line = mlines.Line2D( [], [], color=color, linestyle="none", zorder=zorder, visible=tick1On, markeredgecolor=color, markersize=size, markeredgewidth=width, ) self.tick2line = mlines.Line2D( [], [], color=color, linestyle="none", zorder=zorder, visible=tick2On, markeredgecolor=color, markersize=size, markeredgewidth=width, ) self.gridline = mlines.Line2D( [], [], color=grid_color, alpha=grid_alpha, visible=gridOn, linestyle=grid_linestyle, linewidth=grid_linewidth, marker="", **grid_kw, ) self.gridline.get_path()._interpolation_steps = \ GRIDLINE_INTERPOLATION_STEPS self.label1 = mtext.Text( np.nan, np.nan, fontsize=labelsize, color=labelcolor, visible=label1On, fontfamily=labelfontfamily, rotation=self._labelrotation[1]) self.label2 = mtext.Text( np.nan, np.nan, fontsize=labelsize, color=labelcolor, visible=label2On, fontfamily=labelfontfamily, rotation=self._labelrotation[1]) self._apply_tickdir(tickdir) for artist in [self.tick1line, self.tick2line, self.gridline, self.label1, self.label2]: self._set_artist_props(artist) self.update_position(loc) def _set_labelrotation(self, labelrotation): if isinstance(labelrotation, str): mode = labelrotation angle = 0 elif isinstance(labelrotation, (tuple, list)): mode, angle = labelrotation else: mode = 'default' angle = labelrotation _api.check_in_list(['auto', 'default'], labelrotation=mode) self._labelrotation = (mode, angle) @property def _pad(self): return self._base_pad + self.get_tick_padding() def _apply_tickdir(self, tickdir): """Set tick direction. Valid values are 'out', 'in', 'inout'.""" # This method is responsible for verifying input and, in subclasses, for setting # the tick{1,2}line markers. From the user perspective this should always be # called through _apply_params, which further updates ticklabel positions using # the new pads. if tickdir is None: tickdir = mpl.rcParams[f'{self.__name__}.direction'] else: _api.check_in_list(['in', 'out', 'inout'], tickdir=tickdir) self._tickdir = tickdir def get_tickdir(self): return self._tickdir def get_tick_padding(self): """Get the length of the tick outside of the Axes.""" padding = { 'in': 0.0, 'inout': 0.5, 'out': 1.0 } return self._size * padding[self._tickdir] def get_children(self): children = [self.tick1line, self.tick2line, self.gridline, self.label1, self.label2] return children def set_clip_path(self, path, transform=None): # docstring inherited super().set_clip_path(path, transform) self.gridline.set_clip_path(path, transform) self.stale = True def contains(self, mouseevent): """ Test whether the mouse event occurred in the Tick marks. This function always returns false. It is more useful to test if the axis as a whole contains the mouse rather than the set of tick marks. """ return False, {} def set_pad(self, val): """ Set the tick label pad in points Parameters ---------- val : float """ self._apply_params(pad=val) self.stale = True def get_pad(self): """Get the value of the tick label pad in points.""" return self._base_pad def get_loc(self): """Return the tick location (data coords) as a scalar.""" return self._loc @martist.allow_rasterization def draw(self, renderer): if not self.get_visible(): self.stale = False return renderer.open_group(self.__name__, gid=self.get_gid()) for artist in [self.gridline, self.tick1line, self.tick2line, self.label1, self.label2]: artist.draw(renderer) renderer.close_group(self.__name__) self.stale = False def set_url(self, url): """ Set the url of label1 and label2. Parameters ---------- url : str """ super().set_url(url) self.label1.set_url(url) self.label2.set_url(url) self.stale = True def _set_artist_props(self, a): a.set_figure(self.get_figure(root=False)) def get_view_interval(self): """ Return the view limits ``(min, max)`` of the axis the tick belongs to. """ raise NotImplementedError('Derived must override') def _apply_params(self, **kwargs): for name, target in [("gridOn", self.gridline), ("tick1On", self.tick1line), ("tick2On", self.tick2line), ("label1On", self.label1), ("label2On", self.label2)]: if name in kwargs: target.set_visible(kwargs.pop(name)) if any(k in kwargs for k in ['size', 'width', 'pad', 'tickdir']): self._size = kwargs.pop('size', self._size) # Width could be handled outside this block, but it is # convenient to leave it here. self._width = kwargs.pop('width', self._width) self._base_pad = kwargs.pop('pad', self._base_pad) # _apply_tickdir uses _size and _base_pad to make _pad, and also # sets the ticklines markers. self._apply_tickdir(kwargs.pop('tickdir', self._tickdir)) for line in (self.tick1line, self.tick2line): line.set_markersize(self._size) line.set_markeredgewidth(self._width) # _get_text1_transform uses _pad from _apply_tickdir. trans = self._get_text1_transform()[0] self.label1.set_transform(trans) trans = self._get_text2_transform()[0] self.label2.set_transform(trans) tick_kw = {k: v for k, v in kwargs.items() if k in ['color', 'zorder']} if 'color' in kwargs: tick_kw['markeredgecolor'] = kwargs['color'] self.tick1line.set(**tick_kw) self.tick2line.set(**tick_kw) for k, v in tick_kw.items(): setattr(self, '_' + k, v) if 'labelrotation' in kwargs: self._set_labelrotation(kwargs.pop('labelrotation')) self.label1.set(rotation=self._labelrotation[1]) self.label2.set(rotation=self._labelrotation[1]) label_kw = {k[5:]: v for k, v in kwargs.items() if k in ['labelsize', 'labelcolor', 'labelfontfamily']} self.label1.set(**label_kw) self.label2.set(**label_kw) grid_kw = {k[5:]: v for k, v in kwargs.items() if k in _gridline_param_names} self.gridline.set(**grid_kw) def update_position(self, loc): """Set the location of tick in data coords with scalar *loc*.""" raise NotImplementedError('Derived must override') def _get_text1_transform(self): raise NotImplementedError('Derived must override') def _get_text2_transform(self): raise NotImplementedError('Derived must override') class XTick(Tick): """ Contains all the Artists needed to make an x tick - the tick line, the label text and the grid line """ __name__ = 'xtick' def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # x in data coords, y in axes coords ax = self.axes self.tick1line.set( data=([0], [0]), transform=ax.get_xaxis_transform("tick1")) self.tick2line.set( data=([0], [1]), transform=ax.get_xaxis_transform("tick2")) self.gridline.set( data=([0, 0], [0, 1]), transform=ax.get_xaxis_transform("grid")) # the y loc is 3 points below the min of y axis trans, va, ha = self._get_text1_transform() self.label1.set( x=0, y=0, verticalalignment=va, horizontalalignment=ha, transform=trans, ) trans, va, ha = self._get_text2_transform() self.label2.set( x=0, y=1, verticalalignment=va, horizontalalignment=ha, transform=trans, ) def _get_text1_transform(self): return self.axes.get_xaxis_text1_transform(self._pad) def _get_text2_transform(self): return self.axes.get_xaxis_text2_transform(self._pad) def _apply_tickdir(self, tickdir): # docstring inherited super()._apply_tickdir(tickdir) mark1, mark2 = { 'out': (mlines.TICKDOWN, mlines.TICKUP), 'in': (mlines.TICKUP, mlines.TICKDOWN), 'inout': ('|', '|'), }[self._tickdir] self.tick1line.set_marker(mark1) self.tick2line.set_marker(mark2) def update_position(self, loc): """Set the location of tick in data coords with scalar *loc*.""" self.tick1line.set_xdata((loc,)) self.tick2line.set_xdata((loc,)) self.gridline.set_xdata((loc,)) self.label1.set_x(loc) self.label2.set_x(loc) self._loc = loc self.stale = True def get_view_interval(self): # docstring inherited return self.axes.viewLim.intervalx class YTick(Tick): """ Contains all the Artists needed to make a Y tick - the tick line, the label text and the grid line """ __name__ = 'ytick' def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # x in axes coords, y in data coords ax = self.axes self.tick1line.set( data=([0], [0]), transform=ax.get_yaxis_transform("tick1")) self.tick2line.set( data=([1], [0]), transform=ax.get_yaxis_transform("tick2")) self.gridline.set( data=([0, 1], [0, 0]), transform=ax.get_yaxis_transform("grid")) # the y loc is 3 points below the min of y axis trans, va, ha = self._get_text1_transform() self.label1.set( x=0, y=0, verticalalignment=va, horizontalalignment=ha, transform=trans, ) trans, va, ha = self._get_text2_transform() self.label2.set( x=1, y=0, verticalalignment=va, horizontalalignment=ha, transform=trans, ) def _get_text1_transform(self): return self.axes.get_yaxis_text1_transform(self._pad) def _get_text2_transform(self): return self.axes.get_yaxis_text2_transform(self._pad) def _apply_tickdir(self, tickdir): # docstring inherited super()._apply_tickdir(tickdir) mark1, mark2 = { 'out': (mlines.TICKLEFT, mlines.TICKRIGHT), 'in': (mlines.TICKRIGHT, mlines.TICKLEFT), 'inout': ('_', '_'), }[self._tickdir] self.tick1line.set_marker(mark1) self.tick2line.set_marker(mark2) def update_position(self, loc): """Set the location of tick in data coords with scalar *loc*.""" self.tick1line.set_ydata((loc,)) self.tick2line.set_ydata((loc,)) self.gridline.set_ydata((loc,)) self.label1.set_y(loc) self.label2.set_y(loc) self._loc = loc self.stale = True def get_view_interval(self): # docstring inherited return self.axes.viewLim.intervaly class Ticker: """ A container for the objects defining tick position and format. Attributes ---------- locator : `~matplotlib.ticker.Locator` subclass Determines the positions of the ticks. formatter : `~matplotlib.ticker.Formatter` subclass Determines the format of the tick labels. """ def __init__(self): self._locator = None self._formatter = None self._locator_is_default = True self._formatter_is_default = True @property def locator(self): return self._locator @locator.setter def locator(self, locator): if not isinstance(locator, mticker.Locator): raise TypeError('locator must be a subclass of ' 'matplotlib.ticker.Locator') self._locator = locator @property def formatter(self): return self._formatter @formatter.setter def formatter(self, formatter): if not isinstance(formatter, mticker.Formatter): raise TypeError('formatter must be a subclass of ' 'matplotlib.ticker.Formatter') self._formatter = formatter class _LazyTickList: """ A descriptor for lazy instantiation of tick lists. See comment above definition of the ``majorTicks`` and ``minorTicks`` attributes. """ def __init__(self, major): self._major = major def __get__(self, instance, owner): if instance is None: return self else: # instance._get_tick() can itself try to access the majorTicks # attribute (e.g. in certain projection classes which override # e.g. get_xaxis_text1_transform). In order to avoid infinite # recursion, first set the majorTicks on the instance temporarily # to an empty lis. Then create the tick; note that _get_tick() # may call reset_ticks(). Therefore, the final tick list is # created and assigned afterwards. if self._major: instance.majorTicks = [] tick = instance._get_tick(major=True) instance.majorTicks = [tick] return instance.majorTicks else: instance.minorTicks = [] tick = instance._get_tick(major=False) instance.minorTicks = [tick] return instance.minorTicks class Axis(martist.Artist): """ Base class for `.XAxis` and `.YAxis`. Attributes ---------- isDefault_label : bool axes : `~matplotlib.axes.Axes` The `~.axes.Axes` to which the Axis belongs. major : `~matplotlib.axis.Ticker` Determines the major tick positions and their label format. minor : `~matplotlib.axis.Ticker` Determines the minor tick positions and their label format. callbacks : `~matplotlib.cbook.CallbackRegistry` label : `~matplotlib.text.Text` The axis label. labelpad : float The distance between the axis label and the tick labels. Defaults to :rc:`axes.labelpad`. offsetText : `~matplotlib.text.Text` A `.Text` object containing the data offset of the ticks (if any). pickradius : float The acceptance radius for containment tests. See also `.Axis.contains`. majorTicks : list of `.Tick` The major ticks. .. warning:: Ticks are not guaranteed to be persistent. Various operations can create, delete and modify the Tick instances. There is an imminent risk that changes to individual ticks will not survive if you work on the figure further (including also panning/zooming on a displayed figure). Working on the individual ticks is a method of last resort. Use `.set_tick_params` instead if possible. minorTicks : list of `.Tick` The minor ticks. """ OFFSETTEXTPAD = 3 # The class used in _get_tick() to create tick instances. Must either be # overwritten in subclasses, or subclasses must reimplement _get_tick(). _tick_class = None converter = _api.deprecate_privatize_attribute( "3.10", alternative="get_converter and set_converter methods" ) def __str__(self): return "{}({},{})".format( type(self).__name__, *self.axes.transAxes.transform((0, 0))) def __init__(self, axes, *, pickradius=15, clear=True): """ Parameters ---------- axes : `~matplotlib.axes.Axes` The `~.axes.Axes` to which the created Axis belongs. pickradius : float The acceptance radius for containment tests. See also `.Axis.contains`. clear : bool, default: True Whether to clear the Axis on creation. This is not required, e.g., when creating an Axis as part of an Axes, as ``Axes.clear`` will call ``Axis.clear``. .. versionadded:: 3.8 """ super().__init__() self._remove_overlapping_locs = True self.set_figure(axes.get_figure(root=False)) self.isDefault_label = True self.axes = axes self.major = Ticker() self.minor = Ticker() self.callbacks = cbook.CallbackRegistry(signals=["units"]) self._autolabelpos = True self.label = mtext.Text( np.nan, np.nan, fontsize=mpl.rcParams['axes.labelsize'], fontweight=mpl.rcParams['axes.labelweight'], color=mpl.rcParams['axes.labelcolor'], ) #: The `.Text` object of the axis label. self._set_artist_props(self.label) self.offsetText = mtext.Text(np.nan, np.nan) self._set_artist_props(self.offsetText) self.labelpad = mpl.rcParams['axes.labelpad'] self.pickradius = pickradius # Initialize here for testing; later add API self._major_tick_kw = dict() self._minor_tick_kw = dict() if clear: self.clear() else: self._converter = None self._converter_is_explicit = False self.units = None self._autoscale_on = True @property def isDefault_majloc(self): return self.major._locator_is_default @isDefault_majloc.setter def isDefault_majloc(self, value): self.major._locator_is_default = value @property def isDefault_majfmt(self): return self.major._formatter_is_default @isDefault_majfmt.setter def isDefault_majfmt(self, value): self.major._formatter_is_default = value @property def isDefault_minloc(self): return self.minor._locator_is_default @isDefault_minloc.setter def isDefault_minloc(self, value): self.minor._locator_is_default = value @property def isDefault_minfmt(self): return self.minor._formatter_is_default @isDefault_minfmt.setter def isDefault_minfmt(self, value): self.minor._formatter_is_default = value def _get_shared_axes(self): """Return Grouper of shared Axes for current axis.""" return self.axes._shared_axes[ self._get_axis_name()].get_siblings(self.axes) def _get_shared_axis(self): """Return list of shared axis for current axis.""" name = self._get_axis_name() return [ax._axis_map[name] for ax in self._get_shared_axes()] def _get_axis_name(self): """Return the axis name.""" return next(name for name, axis in self.axes._axis_map.items() if axis is self) # During initialization, Axis objects often create ticks that are later # unused; this turns out to be a very slow step. Instead, use a custom # descriptor to make the tick lists lazy and instantiate them as needed. majorTicks = _LazyTickList(major=True) minorTicks = _LazyTickList(major=False) def get_remove_overlapping_locs(self): return self._remove_overlapping_locs def set_remove_overlapping_locs(self, val): self._remove_overlapping_locs = bool(val) remove_overlapping_locs = property( get_remove_overlapping_locs, set_remove_overlapping_locs, doc=('If minor ticker locations that overlap with major ' 'ticker locations should be trimmed.')) def set_label_coords(self, x, y, transform=None): """ Set the coordinates of the label. By default, the x coordinate of the y label and the y coordinate of the x label are determined by the tick label bounding boxes, but this can lead to poor alignment of multiple labels if there are multiple Axes. You can also specify the coordinate system of the label with the transform. If None, the default coordinate system will be the axes coordinate system: (0, 0) is bottom left, (0.5, 0.5) is center, etc. """ self._autolabelpos = False if transform is None: transform = self.axes.transAxes self.label.set_transform(transform) self.label.set_position((x, y)) self.stale = True def get_transform(self): """Return the transform used in the Axis' scale""" return self._scale.get_transform() def get_scale(self): """Return this Axis' scale (as a str).""" return self._scale.name def _set_scale(self, value, **kwargs): if not isinstance(value, mscale.ScaleBase): self._scale = mscale.scale_factory(value, self, **kwargs) else: self._scale = value self._scale.set_default_locators_and_formatters(self) self.isDefault_majloc = True self.isDefault_minloc = True self.isDefault_majfmt = True self.isDefault_minfmt = True # This method is directly wrapped by Axes.set_{x,y}scale. def _set_axes_scale(self, value, **kwargs): """ Set this Axis' scale. Parameters ---------- value : str or `.ScaleBase` The axis scale type to apply. Valid string values are the names of scale classes ("linear", "log", "function",...). These may be the names of any of the :ref:`built-in scales` or of any custom scales registered using `matplotlib.scale.register_scale`. **kwargs If *value* is a string, keywords are passed to the instantiation method of the respective class. """ name = self._get_axis_name() old_default_lims = (self.get_major_locator() .nonsingular(-np.inf, np.inf)) for ax in self._get_shared_axes(): ax._axis_map[name]._set_scale(value, **kwargs) ax._update_transScale() ax.stale = True new_default_lims = (self.get_major_locator() .nonsingular(-np.inf, np.inf)) if old_default_lims != new_default_lims: # Force autoscaling now, to take advantage of the scale locator's # nonsingular() before it possibly gets swapped out by the user. self.axes.autoscale_view( **{f"scale{k}": k == name for k in self.axes._axis_names}) def limit_range_for_scale(self, vmin, vmax): """ Return the range *vmin*, *vmax*, restricted to the domain supported by the current scale. """ return self._scale.limit_range_for_scale(vmin, vmax, self.get_minpos()) def _get_autoscale_on(self): """Return whether this Axis is autoscaled.""" return self._autoscale_on def _set_autoscale_on(self, b): """ Set whether this Axis is autoscaled when drawing or by `.Axes.autoscale_view`. If b is None, then the value is not changed. Parameters ---------- b : bool """ if b is not None: self._autoscale_on = b def get_children(self): return [self.label, self.offsetText, *self.get_major_ticks(), *self.get_minor_ticks()] def _reset_major_tick_kw(self): self._major_tick_kw.clear() self._major_tick_kw['gridOn'] = ( mpl.rcParams['axes.grid'] and mpl.rcParams['axes.grid.which'] in ('both', 'major')) def _reset_minor_tick_kw(self): self._minor_tick_kw.clear() self._minor_tick_kw['gridOn'] = ( mpl.rcParams['axes.grid'] and mpl.rcParams['axes.grid.which'] in ('both', 'minor')) def clear(self): """ Clear the axis. This resets axis properties to their default values: - the label - the scale - locators, formatters and ticks - major and minor grid - units - registered callbacks """ self.label._reset_visual_defaults() # The above resets the label formatting using text rcParams, # so we then update the formatting using axes rcParams self.label.set_color(mpl.rcParams['axes.labelcolor']) self.label.set_fontsize(mpl.rcParams['axes.labelsize']) self.label.set_fontweight(mpl.rcParams['axes.labelweight']) self.offsetText._reset_visual_defaults() self.labelpad = mpl.rcParams['axes.labelpad'] self._init() self._set_scale('linear') # Clear the callback registry for this axis, or it may "leak" self.callbacks = cbook.CallbackRegistry(signals=["units"]) # whether the grids are on self._major_tick_kw['gridOn'] = ( mpl.rcParams['axes.grid'] and mpl.rcParams['axes.grid.which'] in ('both', 'major')) self._minor_tick_kw['gridOn'] = ( mpl.rcParams['axes.grid'] and mpl.rcParams['axes.grid.which'] in ('both', 'minor')) self.reset_ticks() self._converter = None self._converter_is_explicit = False self.units = None self.stale = True def reset_ticks(self): """ Re-initialize the major and minor Tick lists. Each list starts with a single fresh Tick. """ # Restore the lazy tick lists. try: del self.majorTicks except AttributeError: pass try: del self.minorTicks except AttributeError: pass try: self.set_clip_path(self.axes.patch) except AttributeError: pass def minorticks_on(self): """ Display default minor ticks on the Axis, depending on the scale (`~.axis.Axis.get_scale`). Scales use specific minor locators: - log: `~.LogLocator` - symlog: `~.SymmetricalLogLocator` - asinh: `~.AsinhLocator` - logit: `~.LogitLocator` - default: `~.AutoMinorLocator` Displaying minor ticks may reduce performance; you may turn them off using `minorticks_off()` if drawing speed is a problem. """ scale = self.get_scale() if scale == 'log': s = self._scale self.set_minor_locator(mticker.LogLocator(s.base, s.subs)) elif scale == 'symlog': s = self._scale self.set_minor_locator( mticker.SymmetricalLogLocator(s._transform, s.subs)) elif scale == 'asinh': s = self._scale self.set_minor_locator( mticker.AsinhLocator(s.linear_width, base=s._base, subs=s._subs)) elif scale == 'logit': self.set_minor_locator(mticker.LogitLocator(minor=True)) else: self.set_minor_locator(mticker.AutoMinorLocator()) def minorticks_off(self): """Remove minor ticks from the Axis.""" self.set_minor_locator(mticker.NullLocator()) def set_tick_params(self, which='major', reset=False, **kwargs): """ Set appearance parameters for ticks, ticklabels, and gridlines. For documentation of keyword arguments, see :meth:`matplotlib.axes.Axes.tick_params`. See Also -------- .Axis.get_tick_params View the current style settings for ticks, ticklabels, and gridlines. """ _api.check_in_list(['major', 'minor', 'both'], which=which) kwtrans = self._translate_tick_params(kwargs) # the kwargs are stored in self._major/minor_tick_kw so that any # future new ticks will automatically get them if reset: if which in ['major', 'both']: self._reset_major_tick_kw() self._major_tick_kw.update(kwtrans) if which in ['minor', 'both']: self._reset_minor_tick_kw() self._minor_tick_kw.update(kwtrans) self.reset_ticks() else: if which in ['major', 'both']: self._major_tick_kw.update(kwtrans) for tick in self.majorTicks: tick._apply_params(**kwtrans) if which in ['minor', 'both']: self._minor_tick_kw.update(kwtrans) for tick in self.minorTicks: tick._apply_params(**kwtrans) # labelOn and labelcolor also apply to the offset text. if 'label1On' in kwtrans or 'label2On' in kwtrans: self.offsetText.set_visible( self._major_tick_kw.get('label1On', False) or self._major_tick_kw.get('label2On', False)) if 'labelcolor' in kwtrans: self.offsetText.set_color(kwtrans['labelcolor']) self.stale = True def get_tick_params(self, which='major'): """ Get appearance parameters for ticks, ticklabels, and gridlines. .. versionadded:: 3.7 Parameters ---------- which : {'major', 'minor'}, default: 'major' The group of ticks for which the parameters are retrieved. Returns ------- dict Properties for styling tick elements added to the axis. Notes ----- This method returns the appearance parameters for styling *new* elements added to this axis and may be different from the values on current elements if they were modified directly by the user (e.g., via ``set_*`` methods on individual tick objects). Examples -------- :: >>> ax.yaxis.set_tick_params(labelsize=30, labelcolor='red', ... direction='out', which='major') >>> ax.yaxis.get_tick_params(which='major') {'direction': 'out', 'left': True, 'right': False, 'labelleft': True, 'labelright': False, 'gridOn': False, 'labelsize': 30, 'labelcolor': 'red'} >>> ax.yaxis.get_tick_params(which='minor') {'left': True, 'right': False, 'labelleft': True, 'labelright': False, 'gridOn': False} """ _api.check_in_list(['major', 'minor'], which=which) if which == 'major': return self._translate_tick_params( self._major_tick_kw, reverse=True ) return self._translate_tick_params(self._minor_tick_kw, reverse=True) @classmethod def _translate_tick_params(cls, kw, reverse=False): """ Translate the kwargs supported by `.Axis.set_tick_params` to kwargs supported by `.Tick._apply_params`. In particular, this maps axis specific names like 'top', 'left' to the generic tick1, tick2 logic of the axis. Additionally, there are some other name translations. Returns a new dict of translated kwargs. Note: Use reverse=True to translate from those supported by `.Tick._apply_params` back to those supported by `.Axis.set_tick_params`. """ kw_ = {**kw} # The following lists may be moved to a more accessible location. allowed_keys = [ 'size', 'width', 'color', 'tickdir', 'pad', 'labelsize', 'labelcolor', 'labelfontfamily', 'zorder', 'gridOn', 'tick1On', 'tick2On', 'label1On', 'label2On', 'length', 'direction', 'left', 'bottom', 'right', 'top', 'labelleft', 'labelbottom', 'labelright', 'labeltop', 'labelrotation', *_gridline_param_names] keymap = { # tick_params key -> axis key 'length': 'size', 'direction': 'tickdir', 'rotation': 'labelrotation', 'left': 'tick1On', 'bottom': 'tick1On', 'right': 'tick2On', 'top': 'tick2On', 'labelleft': 'label1On', 'labelbottom': 'label1On', 'labelright': 'label2On', 'labeltop': 'label2On', } if reverse: kwtrans = {} is_x_axis = cls.axis_name == 'x' y_axis_keys = ['left', 'right', 'labelleft', 'labelright'] for oldkey, newkey in keymap.items(): if newkey in kw_: if is_x_axis and oldkey in y_axis_keys: continue else: kwtrans[oldkey] = kw_.pop(newkey) else: kwtrans = { newkey: kw_.pop(oldkey) for oldkey, newkey in keymap.items() if oldkey in kw_ } if 'colors' in kw_: c = kw_.pop('colors') kwtrans['color'] = c kwtrans['labelcolor'] = c # Maybe move the checking up to the caller of this method. for key in kw_: if key not in allowed_keys: raise ValueError( "keyword %s is not recognized; valid keywords are %s" % (key, allowed_keys)) kwtrans.update(kw_) return kwtrans def set_clip_path(self, path, transform=None): super().set_clip_path(path, transform) for child in self.majorTicks + self.minorTicks: child.set_clip_path(path, transform) self.stale = True def get_view_interval(self): """Return the ``(min, max)`` view limits of this axis.""" raise NotImplementedError('Derived must override') def set_view_interval(self, vmin, vmax, ignore=False): """ Set the axis view limits. This method is for internal use; Matplotlib users should typically use e.g. `~.Axes.set_xlim` or `~.Axes.set_ylim`. If *ignore* is False (the default), this method will never reduce the preexisting view limits, only expand them if *vmin* or *vmax* are not within them. Moreover, the order of *vmin* and *vmax* does not matter; the orientation of the axis will not change. If *ignore* is True, the view limits will be set exactly to ``(vmin, vmax)`` in that order. """ raise NotImplementedError('Derived must override') def get_data_interval(self): """Return the ``(min, max)`` data limits of this axis.""" raise NotImplementedError('Derived must override') def set_data_interval(self, vmin, vmax, ignore=False): """ Set the axis data limits. This method is for internal use. If *ignore* is False (the default), this method will never reduce the preexisting data limits, only expand them if *vmin* or *vmax* are not within them. Moreover, the order of *vmin* and *vmax* does not matter; the orientation of the axis will not change. If *ignore* is True, the data limits will be set exactly to ``(vmin, vmax)`` in that order. """ raise NotImplementedError('Derived must override') def get_inverted(self): """ Return whether this Axis is oriented in the "inverse" direction. The "normal" direction is increasing to the right for the x-axis and to the top for the y-axis; the "inverse" direction is increasing to the left for the x-axis and to the bottom for the y-axis. """ low, high = self.get_view_interval() return high < low def set_inverted(self, inverted): """ Set whether this Axis is oriented in the "inverse" direction. The "normal" direction is increasing to the right for the x-axis and to the top for the y-axis; the "inverse" direction is increasing to the left for the x-axis and to the bottom for the y-axis. """ a, b = self.get_view_interval() # cast to bool to avoid bad interaction between python 3.8 and np.bool_ self._set_lim(*sorted((a, b), reverse=bool(inverted)), auto=None) def set_default_intervals(self): """ Set the default limits for the axis data and view interval if they have not been not mutated yet. """ # this is mainly in support of custom object plotting. For # example, if someone passes in a datetime object, we do not # know automagically how to set the default min/max of the # data and view limits. The unit conversion AxisInfo # interface provides a hook for custom types to register # default limits through the AxisInfo.default_limits # attribute, and the derived code below will check for that # and use it if it's available (else just use 0..1) def _set_lim(self, v0, v1, *, emit=True, auto): """ Set view limits. This method is a helper for the Axes ``set_xlim``, ``set_ylim``, and ``set_zlim`` methods. Parameters ---------- v0, v1 : float The view limits. (Passing *v0* as a (low, high) pair is not supported; normalization must occur in the Axes setters.) emit : bool, default: True Whether to notify observers of limit change. auto : bool or None, default: False Whether to turn on autoscaling of the x-axis. True turns on, False turns off, None leaves unchanged. """ name = self._get_axis_name() self.axes._process_unit_info([(name, (v0, v1))], convert=False) v0 = self.axes._validate_converted_limits(v0, self.convert_units) v1 = self.axes._validate_converted_limits(v1, self.convert_units) if v0 is None or v1 is None: # Axes init calls set_xlim(0, 1) before get_xlim() can be called, # so only grab the limits if we really need them. old0, old1 = self.get_view_interval() if v0 is None: v0 = old0 if v1 is None: v1 = old1 if self.get_scale() == 'log' and (v0 <= 0 or v1 <= 0): # Axes init calls set_xlim(0, 1) before get_xlim() can be called, # so only grab the limits if we really need them. old0, old1 = self.get_view_interval() if v0 <= 0: _api.warn_external(f"Attempt to set non-positive {name}lim on " f"a log-scaled axis will be ignored.") v0 = old0 if v1 <= 0: _api.warn_external(f"Attempt to set non-positive {name}lim on " f"a log-scaled axis will be ignored.") v1 = old1 if v0 == v1: _api.warn_external( f"Attempting to set identical low and high {name}lims " f"makes transformation singular; automatically expanding.") reverse = bool(v0 > v1) # explicit cast needed for python3.8+np.bool_. v0, v1 = self.get_major_locator().nonsingular(v0, v1) v0, v1 = self.limit_range_for_scale(v0, v1) v0, v1 = sorted([v0, v1], reverse=bool(reverse)) self.set_view_interval(v0, v1, ignore=True) # Mark viewlims as no longer stale without triggering an autoscale. for ax in self._get_shared_axes(): ax._stale_viewlims[name] = False self._set_autoscale_on(auto) if emit: self.axes.callbacks.process(f"{name}lim_changed", self.axes) # Call all of the other Axes that are shared with this one for other in self._get_shared_axes(): if other is self.axes: continue other._axis_map[name]._set_lim(v0, v1, emit=False, auto=auto) if emit: other.callbacks.process(f"{name}lim_changed", other) if ((other_fig := other.get_figure(root=False)) != self.get_figure(root=False)): other_fig.canvas.draw_idle() self.stale = True return v0, v1 def _set_artist_props(self, a): if a is None: return a.set_figure(self.get_figure(root=False)) def _update_ticks(self): """ Update ticks (position and labels) using the current data interval of the axes. Return the list of ticks that will be drawn. """ major_locs = self.get_majorticklocs() major_labels = self.major.formatter.format_ticks(major_locs) major_ticks = self.get_major_ticks(len(major_locs)) for tick, loc, label in zip(major_ticks, major_locs, major_labels): tick.update_position(loc) tick.label1.set_text(label) tick.label2.set_text(label) minor_locs = self.get_minorticklocs() minor_labels = self.minor.formatter.format_ticks(minor_locs) minor_ticks = self.get_minor_ticks(len(minor_locs)) for tick, loc, label in zip(minor_ticks, minor_locs, minor_labels): tick.update_position(loc) tick.label1.set_text(label) tick.label2.set_text(label) ticks = [*major_ticks, *minor_ticks] view_low, view_high = self.get_view_interval() if view_low > view_high: view_low, view_high = view_high, view_low if (hasattr(self, "axes") and self.axes.name == '3d' and mpl.rcParams['axes3d.automargin']): # In mpl3.8, the margin was 1/48. Due to the change in automargin # behavior in mpl3.9, we need to adjust this to compensate for a # zoom factor of 2/48, giving us a 23/24 modifier. So the new # margin is 0.019965277777777776 = 1/48*23/24. margin = 0.019965277777777776 delta = view_high - view_low view_high = view_high - delta * margin view_low = view_low + delta * margin interval_t = self.get_transform().transform([view_low, view_high]) ticks_to_draw = [] for tick in ticks: try: loc_t = self.get_transform().transform(tick.get_loc()) except AssertionError: # transforms.transform doesn't allow masked values but # some scales might make them, so we need this try/except. pass else: if mtransforms._interval_contains_close(interval_t, loc_t): ticks_to_draw.append(tick) return ticks_to_draw def _get_ticklabel_bboxes(self, ticks, renderer=None): """Return lists of bboxes for ticks' label1's and label2's.""" if renderer is None: renderer = self.get_figure(root=True)._get_renderer() return ([tick.label1.get_window_extent(renderer) for tick in ticks if tick.label1.get_visible()], [tick.label2.get_window_extent(renderer) for tick in ticks if tick.label2.get_visible()]) def get_tightbbox(self, renderer=None, *, for_layout_only=False): """ Return a bounding box that encloses the axis. It only accounts tick labels, axis label, and offsetText. If *for_layout_only* is True, then the width of the label (if this is an x-axis) or the height of the label (if this is a y-axis) is collapsed to near zero. This allows tight/constrained_layout to ignore too-long labels when doing their layout. """ if not self.get_visible() or for_layout_only and not self.get_in_layout(): return if renderer is None: renderer = self.get_figure(root=True)._get_renderer() ticks_to_draw = self._update_ticks() self._update_label_position(renderer) # go back to just this axis's tick labels tlb1, tlb2 = self._get_ticklabel_bboxes(ticks_to_draw, renderer) self._update_offset_text_position(tlb1, tlb2) self.offsetText.set_text(self.major.formatter.get_offset()) bboxes = [ *(a.get_window_extent(renderer) for a in [self.offsetText] if a.get_visible()), *tlb1, *tlb2, ] # take care of label if self.label.get_visible(): bb = self.label.get_window_extent(renderer) # for constrained/tight_layout, we want to ignore the label's # width/height because the adjustments they make can't be improved. # this code collapses the relevant direction if for_layout_only: if self.axis_name == "x" and bb.width > 0: bb.x0 = (bb.x0 + bb.x1) / 2 - 0.5 bb.x1 = bb.x0 + 1.0 if self.axis_name == "y" and bb.height > 0: bb.y0 = (bb.y0 + bb.y1) / 2 - 0.5 bb.y1 = bb.y0 + 1.0 bboxes.append(bb) bboxes = [b for b in bboxes if 0 < b.width < np.inf and 0 < b.height < np.inf] if bboxes: return mtransforms.Bbox.union(bboxes) else: return None def get_tick_padding(self): values = [] if len(self.majorTicks): values.append(self.majorTicks[0].get_tick_padding()) if len(self.minorTicks): values.append(self.minorTicks[0].get_tick_padding()) return max(values, default=0) @martist.allow_rasterization def draw(self, renderer): # docstring inherited if not self.get_visible(): return renderer.open_group(__name__, gid=self.get_gid()) ticks_to_draw = self._update_ticks() tlb1, tlb2 = self._get_ticklabel_bboxes(ticks_to_draw, renderer) for tick in ticks_to_draw: tick.draw(renderer) # Shift label away from axes to avoid overlapping ticklabels. self._update_label_position(renderer) self.label.draw(renderer) self._update_offset_text_position(tlb1, tlb2) self.offsetText.set_text(self.major.formatter.get_offset()) self.offsetText.draw(renderer) renderer.close_group(__name__) self.stale = False def get_gridlines(self): r"""Return this Axis' grid lines as a list of `.Line2D`\s.""" ticks = self.get_major_ticks() return cbook.silent_list('Line2D gridline', [tick.gridline for tick in ticks]) def set_label(self, s): """Assigning legend labels is not supported. Raises RuntimeError.""" raise RuntimeError( "A legend label cannot be assigned to an Axis. Did you mean to " "set the axis label via set_label_text()?") def get_label(self): """ Return the axis label as a Text instance. .. admonition:: Discouraged This overrides `.Artist.get_label`, which is for legend labels, with a new semantic. It is recommended to use the attribute ``Axis.label`` instead. """ return self.label def get_offset_text(self): """Return the axis offsetText as a Text instance.""" return self.offsetText def get_pickradius(self): """Return the depth of the axis used by the picker.""" return self._pickradius def get_majorticklabels(self): """Return this Axis' major tick labels, as a list of `~.text.Text`.""" self._update_ticks() ticks = self.get_major_ticks() labels1 = [tick.label1 for tick in ticks if tick.label1.get_visible()] labels2 = [tick.label2 for tick in ticks if tick.label2.get_visible()] return labels1 + labels2 def get_minorticklabels(self): """Return this Axis' minor tick labels, as a list of `~.text.Text`.""" self._update_ticks() ticks = self.get_minor_ticks() labels1 = [tick.label1 for tick in ticks if tick.label1.get_visible()] labels2 = [tick.label2 for tick in ticks if tick.label2.get_visible()] return labels1 + labels2 def get_ticklabels(self, minor=False, which=None): """ Get this Axis' tick labels. Parameters ---------- minor : bool Whether to return the minor or the major ticklabels. which : None, ('minor', 'major', 'both') Overrides *minor*. Selects which ticklabels to return Returns ------- list of `~matplotlib.text.Text` """ if which is not None: if which == 'minor': return self.get_minorticklabels() elif which == 'major': return self.get_majorticklabels() elif which == 'both': return self.get_majorticklabels() + self.get_minorticklabels() else: _api.check_in_list(['major', 'minor', 'both'], which=which) if minor: return self.get_minorticklabels() return self.get_majorticklabels() def get_majorticklines(self): r"""Return this Axis' major tick lines as a list of `.Line2D`\s.""" lines = [] ticks = self.get_major_ticks() for tick in ticks: lines.append(tick.tick1line) lines.append(tick.tick2line) return cbook.silent_list('Line2D ticklines', lines) def get_minorticklines(self): r"""Return this Axis' minor tick lines as a list of `.Line2D`\s.""" lines = [] ticks = self.get_minor_ticks() for tick in ticks: lines.append(tick.tick1line) lines.append(tick.tick2line) return cbook.silent_list('Line2D ticklines', lines) def get_ticklines(self, minor=False): r"""Return this Axis' tick lines as a list of `.Line2D`\s.""" if minor: return self.get_minorticklines() return self.get_majorticklines() def get_majorticklocs(self): """Return this Axis' major tick locations in data coordinates.""" return self.major.locator() def get_minorticklocs(self): """Return this Axis' minor tick locations in data coordinates.""" # Remove minor ticks duplicating major ticks. minor_locs = np.asarray(self.minor.locator()) if self.remove_overlapping_locs: major_locs = self.major.locator() transform = self._scale.get_transform() tr_minor_locs = transform.transform(minor_locs) tr_major_locs = transform.transform(major_locs) lo, hi = sorted(transform.transform(self.get_view_interval())) # Use the transformed view limits as scale. 1e-5 is the default # rtol for np.isclose. tol = (hi - lo) * 1e-5 mask = np.isclose(tr_minor_locs[:, None], tr_major_locs[None, :], atol=tol, rtol=0).any(axis=1) minor_locs = minor_locs[~mask] return minor_locs def get_ticklocs(self, *, minor=False): """ Return this Axis' tick locations in data coordinates. The locations are not clipped to the current axis limits and hence may contain locations that are not visible in the output. Parameters ---------- minor : bool, default: False True to return the minor tick directions, False to return the major tick directions. Returns ------- array of tick locations """ return self.get_minorticklocs() if minor else self.get_majorticklocs() def get_ticks_direction(self, minor=False): """ Return an array of this Axis' tick directions. Parameters ---------- minor : bool, default: False True to return the minor tick directions, False to return the major tick directions. Returns ------- array of tick directions """ if minor: return np.array( [tick._tickdir for tick in self.get_minor_ticks()]) else: return np.array( [tick._tickdir for tick in self.get_major_ticks()]) def _get_tick(self, major): """Return the default tick instance.""" if self._tick_class is None: raise NotImplementedError( f"The Axis subclass {self.__class__.__name__} must define " "_tick_class or reimplement _get_tick()") tick_kw = self._major_tick_kw if major else self._minor_tick_kw return self._tick_class(self.axes, 0, major=major, **tick_kw) def _get_tick_label_size(self, axis_name): """ Return the text size of tick labels for this Axis. This is a convenience function to avoid having to create a `Tick` in `.get_tick_space`, since it is expensive. """ tick_kw = self._major_tick_kw size = tick_kw.get('labelsize', mpl.rcParams[f'{axis_name}tick.labelsize']) return mtext.FontProperties(size=size).get_size_in_points() def _copy_tick_props(self, src, dest): """Copy the properties from *src* tick to *dest* tick.""" if src is None or dest is None: return dest.label1.update_from(src.label1) dest.label2.update_from(src.label2) dest.tick1line.update_from(src.tick1line) dest.tick2line.update_from(src.tick2line) dest.gridline.update_from(src.gridline) dest.update_from(src) dest._loc = src._loc dest._size = src._size dest._width = src._width dest._base_pad = src._base_pad dest._labelrotation = src._labelrotation dest._zorder = src._zorder dest._tickdir = src._tickdir def get_label_text(self): """Get the text of the label.""" return self.label.get_text() def get_major_locator(self): """Get the locator of the major ticker.""" return self.major.locator def get_minor_locator(self): """Get the locator of the minor ticker.""" return self.minor.locator def get_major_formatter(self): """Get the formatter of the major ticker.""" return self.major.formatter def get_minor_formatter(self): """Get the formatter of the minor ticker.""" return self.minor.formatter def get_major_ticks(self, numticks=None): r""" Return the list of major `.Tick`\s. .. warning:: Ticks are not guaranteed to be persistent. Various operations can create, delete and modify the Tick instances. There is an imminent risk that changes to individual ticks will not survive if you work on the figure further (including also panning/zooming on a displayed figure). Working on the individual ticks is a method of last resort. Use `.set_tick_params` instead if possible. """ if numticks is None: numticks = len(self.get_majorticklocs()) while len(self.majorTicks) < numticks: # Update the new tick label properties from the old. tick = self._get_tick(major=True) self.majorTicks.append(tick) self._copy_tick_props(self.majorTicks[0], tick) return self.majorTicks[:numticks] def get_minor_ticks(self, numticks=None): r""" Return the list of minor `.Tick`\s. .. warning:: Ticks are not guaranteed to be persistent. Various operations can create, delete and modify the Tick instances. There is an imminent risk that changes to individual ticks will not survive if you work on the figure further (including also panning/zooming on a displayed figure). Working on the individual ticks is a method of last resort. Use `.set_tick_params` instead if possible. """ if numticks is None: numticks = len(self.get_minorticklocs()) while len(self.minorTicks) < numticks: # Update the new tick label properties from the old. tick = self._get_tick(major=False) self.minorTicks.append(tick) self._copy_tick_props(self.minorTicks[0], tick) return self.minorTicks[:numticks] def grid(self, visible=None, which='major', **kwargs): """ Configure the grid lines. Parameters ---------- visible : bool or None Whether to show the grid lines. If any *kwargs* are supplied, it is assumed you want the grid on and *visible* will be set to True. If *visible* is *None* and there are no *kwargs*, this toggles the visibility of the lines. which : {'major', 'minor', 'both'} The grid lines to apply the changes on. **kwargs : `~matplotlib.lines.Line2D` properties Define the line properties of the grid, e.g.:: grid(color='r', linestyle='-', linewidth=2) """ if kwargs: if visible is None: visible = True elif not visible: # something false-like but not None _api.warn_external('First parameter to grid() is false, ' 'but line properties are supplied. The ' 'grid will be enabled.') visible = True which = which.lower() _api.check_in_list(['major', 'minor', 'both'], which=which) gridkw = {f'grid_{name}': value for name, value in kwargs.items()} if which in ['minor', 'both']: gridkw['gridOn'] = (not self._minor_tick_kw['gridOn'] if visible is None else visible) self.set_tick_params(which='minor', **gridkw) if which in ['major', 'both']: gridkw['gridOn'] = (not self._major_tick_kw['gridOn'] if visible is None else visible) self.set_tick_params(which='major', **gridkw) self.stale = True def update_units(self, data): """ Introspect *data* for units converter and update the ``axis.get_converter`` instance if necessary. Return *True* if *data* is registered for unit conversion. """ if not self._converter_is_explicit: converter = munits.registry.get_converter(data) else: converter = self._converter if converter is None: return False neednew = self._converter != converter self._set_converter(converter) default = self._converter.default_units(data, self) if default is not None and self.units is None: self.set_units(default) elif neednew: self._update_axisinfo() self.stale = True return True def _update_axisinfo(self): """ Check the axis converter for the stored units to see if the axis info needs to be updated. """ if self._converter is None: return info = self._converter.axisinfo(self.units, self) if info is None: return if info.majloc is not None and \ self.major.locator != info.majloc and self.isDefault_majloc: self.set_major_locator(info.majloc) self.isDefault_majloc = True if info.minloc is not None and \ self.minor.locator != info.minloc and self.isDefault_minloc: self.set_minor_locator(info.minloc) self.isDefault_minloc = True if info.majfmt is not None and \ self.major.formatter != info.majfmt and self.isDefault_majfmt: self.set_major_formatter(info.majfmt) self.isDefault_majfmt = True if info.minfmt is not None and \ self.minor.formatter != info.minfmt and self.isDefault_minfmt: self.set_minor_formatter(info.minfmt) self.isDefault_minfmt = True if info.label is not None and self.isDefault_label: self.set_label_text(info.label) self.isDefault_label = True self.set_default_intervals() def have_units(self): return self._converter is not None or self.units is not None def convert_units(self, x): # If x is natively supported by Matplotlib, doesn't need converting if munits._is_natively_supported(x): return x if self._converter is None: self._set_converter(munits.registry.get_converter(x)) if self._converter is None: return x try: ret = self._converter.convert(x, self.units, self) except Exception as e: raise munits.ConversionError('Failed to convert value(s) to axis ' f'units: {x!r}') from e return ret def get_converter(self): """ Get the unit converter for axis. Returns ------- `~matplotlib.units.ConversionInterface` or None """ return self._converter def set_converter(self, converter): """ Set the unit converter for axis. Parameters ---------- converter : `~matplotlib.units.ConversionInterface` """ self._set_converter(converter) self._converter_is_explicit = True def _set_converter(self, converter): if self._converter is converter or self._converter == converter: return if self._converter_is_explicit: raise RuntimeError("Axis already has an explicit converter set") elif ( self._converter is not None and not isinstance(converter, type(self._converter)) and not isinstance(self._converter, type(converter)) ): _api.warn_external( "This axis already has a converter set and " "is updating to a potentially incompatible converter" ) self._converter = converter def set_units(self, u): """ Set the units for axis. Parameters ---------- u : units tag Notes ----- The units of any shared axis will also be updated. """ if u == self.units: return for axis in self._get_shared_axis(): axis.units = u axis._update_axisinfo() axis.callbacks.process('units') axis.stale = True def get_units(self): """Return the units for axis.""" return self.units def set_label_text(self, label, fontdict=None, **kwargs): """ Set the text value of the axis label. Parameters ---------- label : str Text string. fontdict : dict Text properties. .. admonition:: Discouraged The use of *fontdict* is discouraged. Parameters should be passed as individual keyword arguments or using dictionary-unpacking ``set_label_text(..., **fontdict)``. **kwargs Merged into fontdict. """ self.isDefault_label = False self.label.set_text(label) if fontdict is not None: self.label.update(fontdict) self.label.update(kwargs) self.stale = True return self.label def set_major_formatter(self, formatter): """ Set the formatter of the major ticker. In addition to a `~matplotlib.ticker.Formatter` instance, this also accepts a ``str`` or function. For a ``str`` a `~matplotlib.ticker.StrMethodFormatter` is used. The field used for the value must be labeled ``'x'`` and the field used for the position must be labeled ``'pos'``. See the `~matplotlib.ticker.StrMethodFormatter` documentation for more information. For a function, a `~matplotlib.ticker.FuncFormatter` is used. The function must take two inputs (a tick value ``x`` and a position ``pos``), and return a string containing the corresponding tick label. See the `~matplotlib.ticker.FuncFormatter` documentation for more information. Parameters ---------- formatter : `~matplotlib.ticker.Formatter`, ``str``, or function """ self._set_formatter(formatter, self.major) def set_minor_formatter(self, formatter): """ Set the formatter of the minor ticker. In addition to a `~matplotlib.ticker.Formatter` instance, this also accepts a ``str`` or function. See `.Axis.set_major_formatter` for more information. Parameters ---------- formatter : `~matplotlib.ticker.Formatter`, ``str``, or function """ self._set_formatter(formatter, self.minor) def _set_formatter(self, formatter, level): if isinstance(formatter, str): formatter = mticker.StrMethodFormatter(formatter) # Don't allow any other TickHelper to avoid easy-to-make errors, # like using a Locator instead of a Formatter. elif (callable(formatter) and not isinstance(formatter, mticker.TickHelper)): formatter = mticker.FuncFormatter(formatter) else: _api.check_isinstance(mticker.Formatter, formatter=formatter) if (isinstance(formatter, mticker.FixedFormatter) and len(formatter.seq) > 0 and not isinstance(level.locator, mticker.FixedLocator)): _api.warn_external('FixedFormatter should only be used together ' 'with FixedLocator') if level == self.major: self.isDefault_majfmt = False else: self.isDefault_minfmt = False level.formatter = formatter formatter.set_axis(self) self.stale = True def set_major_locator(self, locator): """ Set the locator of the major ticker. Parameters ---------- locator : `~matplotlib.ticker.Locator` """ _api.check_isinstance(mticker.Locator, locator=locator) self.isDefault_majloc = False self.major.locator = locator if self.major.formatter: self.major.formatter._set_locator(locator) locator.set_axis(self) self.stale = True def set_minor_locator(self, locator): """ Set the locator of the minor ticker. Parameters ---------- locator : `~matplotlib.ticker.Locator` """ _api.check_isinstance(mticker.Locator, locator=locator) self.isDefault_minloc = False self.minor.locator = locator if self.minor.formatter: self.minor.formatter._set_locator(locator) locator.set_axis(self) self.stale = True def set_pickradius(self, pickradius): """ Set the depth of the axis used by the picker. Parameters ---------- pickradius : float The acceptance radius for containment tests. See also `.Axis.contains`. """ if not isinstance(pickradius, Real) or pickradius < 0: raise ValueError("pick radius should be a distance") self._pickradius = pickradius pickradius = property( get_pickradius, set_pickradius, doc="The acceptance radius for " "containment tests. See also `.Axis.contains`.") # Helper for set_ticklabels. Defining it here makes it picklable. @staticmethod def _format_with_dict(tickd, x, pos): return tickd.get(x, "") def set_ticklabels(self, labels, *, minor=False, fontdict=None, **kwargs): r""" [*Discouraged*] Set this Axis' tick labels with list of string 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 ``Axes.set_[x/y/z]ticks(positions, labels)`` or ``Axis.set_ticks`` instead. If you are using this method, you should always fix the tick positions before, e.g. by using `.Axis.set_ticks` or by explicitly setting a `~.ticker.FixedLocator`. Otherwise, ticks are free to move and the labels may end up in unexpected positions. Parameters ---------- labels : sequence of str or of `.Text`\s Texts for labeling each tick location in the sequence set by `.Axis.set_ticks`; the number of labels must match the number of locations. The labels are used as is, via a `.FixedFormatter` (without further formatting). minor : bool If True, set minor ticks instead of major ticks. fontdict : dict, optional .. admonition:: Discouraged The use of *fontdict* is discouraged. Parameters should be passed as individual keyword arguments or using dictionary-unpacking ``set_ticklabels(..., **fontdict)``. A dictionary controlling the appearance of the ticklabels. The default *fontdict* is:: {'fontsize': rcParams['axes.titlesize'], 'fontweight': rcParams['axes.titleweight'], 'verticalalignment': 'baseline', 'horizontalalignment': loc} **kwargs Text properties. .. warning:: This only sets the properties of the current ticks, which is only sufficient for static plots. Ticks are not guaranteed to be persistent. Various operations can create, delete and modify the Tick instances. There is an imminent risk that these settings can get lost if you work on the figure further (including also panning/zooming on a displayed figure). Use `.set_tick_params` instead if possible. Returns ------- list of `.Text`\s For each tick, includes ``tick.label1`` if it is visible, then ``tick.label2`` if it is visible, in that order. """ try: labels = [t.get_text() if hasattr(t, 'get_text') else t for t in labels] except TypeError: raise TypeError(f"{labels:=} must be a sequence") from None locator = (self.get_minor_locator() if minor else self.get_major_locator()) if not labels: # eg labels=[]: formatter = mticker.NullFormatter() elif isinstance(locator, mticker.FixedLocator): # Passing [] as a list of labels is often used as a way to # remove all tick labels, so only error for > 0 labels if len(locator.locs) != len(labels) and len(labels) != 0: raise ValueError( "The number of FixedLocator locations" f" ({len(locator.locs)}), usually from a call to" " set_ticks, does not match" f" the number of labels ({len(labels)}).") tickd = {loc: lab for loc, lab in zip(locator.locs, labels)} func = functools.partial(self._format_with_dict, tickd) formatter = mticker.FuncFormatter(func) else: _api.warn_external( "set_ticklabels() should only be used with a fixed number of " "ticks, i.e. after set_ticks() or using a FixedLocator.") formatter = mticker.FixedFormatter(labels) with warnings.catch_warnings(): warnings.filterwarnings( "ignore", message="FixedFormatter should only be used together with FixedLocator") if minor: self.set_minor_formatter(formatter) locs = self.get_minorticklocs() ticks = self.get_minor_ticks(len(locs)) else: self.set_major_formatter(formatter) locs = self.get_majorticklocs() ticks = self.get_major_ticks(len(locs)) ret = [] if fontdict is not None: kwargs.update(fontdict) for pos, (loc, tick) in enumerate(zip(locs, ticks)): tick.update_position(loc) tick_label = formatter(loc, pos) # deal with label1 tick.label1.set_text(tick_label) tick.label1._internal_update(kwargs) # deal with label2 tick.label2.set_text(tick_label) tick.label2._internal_update(kwargs) # only return visible tick labels if tick.label1.get_visible(): ret.append(tick.label1) if tick.label2.get_visible(): ret.append(tick.label2) self.stale = True return ret def _set_tick_locations(self, ticks, *, minor=False): # see docstring of set_ticks # XXX if the user changes units, the information will be lost here ticks = self.convert_units(ticks) locator = mticker.FixedLocator(ticks) # validate ticks early. if len(ticks): for axis in self._get_shared_axis(): # set_view_interval maintains any preexisting inversion. axis.set_view_interval(min(ticks), max(ticks)) self.axes.stale = True if minor: self.set_minor_locator(locator) return self.get_minor_ticks(len(ticks)) else: self.set_major_locator(locator) return self.get_major_ticks(len(ticks)) def set_ticks(self, ticks, labels=None, *, minor=False, **kwargs): """ Set this Axis' tick locations and optionally tick labels. If necessary, the view limits of the Axis are expanded so that all given ticks are visible. Parameters ---------- ticks : 1D array-like Array of tick locations (either floats or in axis units). The axis `.Locator` is replaced by a `~.ticker.FixedLocator`. Pass an empty list (``set_ticks([])``) to remove all ticks. Some tick formatters will not label arbitrary tick positions; e.g. log formatters only label decade ticks by default. In such a case you can set a formatter explicitly on the axis using `.Axis.set_major_formatter` or provide formatted *labels* yourself. labels : list of str, optional Tick labels for each location in *ticks*; must have the same length as *ticks*. If set, the labels are used as is, via a `.FixedFormatter`. If not set, the labels are generated using the axis tick `.Formatter`. minor : bool, default: False If ``False``, set only the major ticks; if ``True``, only the minor ticks. **kwargs `.Text` properties for the labels. Using these is only allowed if you pass *labels*. In other cases, please use `~.Axes.tick_params`. Notes ----- The mandatory expansion of the view limits is an intentional design choice to prevent the surprise of a non-visible tick. If you need other limits, you should set the limits explicitly after setting the ticks. """ if labels is None and kwargs: first_key = next(iter(kwargs)) raise ValueError( f"Incorrect use of keyword argument {first_key!r}. Keyword arguments " "other than 'minor' modify the text labels and can only be used if " "'labels' are passed as well.") result = self._set_tick_locations(ticks, minor=minor) if labels is not None: self.set_ticklabels(labels, minor=minor, **kwargs) return result def _get_tick_boxes_siblings(self, renderer): """ Get the bounding boxes for this `.axis` and its siblings as set by `.Figure.align_xlabels` or `.Figure.align_ylabels`. By default, it just gets bboxes for *self*. """ # Get the Grouper keeping track of x or y label groups for this figure. name = self._get_axis_name() if name not in self.get_figure(root=False)._align_label_groups: return [], [] grouper = self.get_figure(root=False)._align_label_groups[name] bboxes = [] bboxes2 = [] # If we want to align labels from other Axes: for ax in grouper.get_siblings(self.axes): axis = ax._axis_map[name] ticks_to_draw = axis._update_ticks() tlb, tlb2 = axis._get_ticklabel_bboxes(ticks_to_draw, renderer) bboxes.extend(tlb) bboxes2.extend(tlb2) return bboxes, bboxes2 def _update_label_position(self, renderer): """ Update the label position based on the bounding box enclosing all the ticklabels and axis spine. """ raise NotImplementedError('Derived must override') def _update_offset_text_position(self, bboxes, bboxes2): """ Update the offset text position based on the sequence of bounding boxes of all the ticklabels. """ raise NotImplementedError('Derived must override') def axis_date(self, tz=None): """ Set up axis ticks and labels to treat data along this Axis as dates. Parameters ---------- tz : str or `datetime.tzinfo`, default: :rc:`timezone` The timezone used to create date labels. """ # By providing a sample datetime instance with the desired timezone, # the registered converter can be selected, and the "units" attribute, # which is the timezone, can be set. if isinstance(tz, str): import dateutil.tz tz = dateutil.tz.gettz(tz) self.update_units(datetime.datetime(2009, 1, 1, 0, 0, 0, 0, tz)) def get_tick_space(self): """Return the estimated number of ticks that can fit on the axis.""" # Must be overridden in the subclass raise NotImplementedError() def _get_ticks_position(self): """ Helper for `XAxis.get_ticks_position` and `YAxis.get_ticks_position`. Check the visibility of tick1line, label1, tick2line, and label2 on the first major and the first minor ticks, and return - 1 if only tick1line and label1 are visible (which corresponds to "bottom" for the x-axis and "left" for the y-axis); - 2 if only tick2line and label2 are visible (which corresponds to "top" for the x-axis and "right" for the y-axis); - "default" if only tick1line, tick2line and label1 are visible; - "unknown" otherwise. """ major = self.majorTicks[0] minor = self.minorTicks[0] if all(tick.tick1line.get_visible() and not tick.tick2line.get_visible() and tick.label1.get_visible() and not tick.label2.get_visible() for tick in [major, minor]): return 1 elif all(tick.tick2line.get_visible() and not tick.tick1line.get_visible() and tick.label2.get_visible() and not tick.label1.get_visible() for tick in [major, minor]): return 2 elif all(tick.tick1line.get_visible() and tick.tick2line.get_visible() and tick.label1.get_visible() and not tick.label2.get_visible() for tick in [major, minor]): return "default" else: return "unknown" def get_label_position(self): """ Return the label position (top or bottom) """ return self.label_position def set_label_position(self, position): """ Set the label position (top or bottom) Parameters ---------- position : {'top', 'bottom'} """ raise NotImplementedError() def get_minpos(self): raise NotImplementedError() def _make_getset_interval(method_name, lim_name, attr_name): """ Helper to generate ``get_{data,view}_interval`` and ``set_{data,view}_interval`` implementations. """ def getter(self): # docstring inherited. return getattr(getattr(self.axes, lim_name), attr_name) def setter(self, vmin, vmax, ignore=False): # docstring inherited. if ignore: setattr(getattr(self.axes, lim_name), attr_name, (vmin, vmax)) else: oldmin, oldmax = getter(self) if oldmin < oldmax: setter(self, min(vmin, vmax, oldmin), max(vmin, vmax, oldmax), ignore=True) else: setter(self, max(vmin, vmax, oldmin), min(vmin, vmax, oldmax), ignore=True) self.stale = True getter.__name__ = f"get_{method_name}_interval" setter.__name__ = f"set_{method_name}_interval" return getter, setter class XAxis(Axis): __name__ = 'xaxis' axis_name = 'x' #: Read-only name identifying the axis. _tick_class = XTick def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._init() def _init(self): """ Initialize the label and offsetText instance values and `label_position` / `offset_text_position`. """ # x in axes coords, y in display coords (to be updated at draw time by # _update_label_positions and _update_offset_text_position). self.label.set( x=0.5, y=0, verticalalignment='top', horizontalalignment='center', transform=mtransforms.blended_transform_factory( self.axes.transAxes, mtransforms.IdentityTransform()), ) self.label_position = 'bottom' if mpl.rcParams['xtick.labelcolor'] == 'inherit': tick_color = mpl.rcParams['xtick.color'] else: tick_color = mpl.rcParams['xtick.labelcolor'] self.offsetText.set( x=1, y=0, verticalalignment='top', horizontalalignment='right', transform=mtransforms.blended_transform_factory( self.axes.transAxes, mtransforms.IdentityTransform()), fontsize=mpl.rcParams['xtick.labelsize'], color=tick_color ) self.offset_text_position = 'bottom' def contains(self, mouseevent): """Test whether the mouse event occurred in the x-axis.""" if self._different_canvas(mouseevent): return False, {} x, y = mouseevent.x, mouseevent.y try: trans = self.axes.transAxes.inverted() xaxes, yaxes = trans.transform((x, y)) except ValueError: return False, {} (l, b), (r, t) = self.axes.transAxes.transform([(0, 0), (1, 1)]) inaxis = 0 <= xaxes <= 1 and ( b - self._pickradius < y < b or t < y < t + self._pickradius) return inaxis, {} def set_label_position(self, position): """ Set the label position (top or bottom) Parameters ---------- position : {'top', 'bottom'} """ self.label.set_verticalalignment(_api.check_getitem({ 'top': 'baseline', 'bottom': 'top', }, position=position)) self.label_position = position self.stale = True def _update_label_position(self, renderer): """ Update the label position based on the bounding box enclosing all the ticklabels and axis spine """ if not self._autolabelpos: return # get bounding boxes for this axis and any siblings # that have been set by `fig.align_xlabels()` bboxes, bboxes2 = self._get_tick_boxes_siblings(renderer=renderer) x, y = self.label.get_position() if self.label_position == 'bottom': # Union with extents of the bottom spine if present, of the axes otherwise. bbox = mtransforms.Bbox.union([ *bboxes, self.axes.spines.get("bottom", self.axes).get_window_extent()]) self.label.set_position( (x, bbox.y0 - self.labelpad * self.get_figure(root=True).dpi / 72)) else: # Union with extents of the top spine if present, of the axes otherwise. bbox = mtransforms.Bbox.union([ *bboxes2, self.axes.spines.get("top", self.axes).get_window_extent()]) self.label.set_position( (x, bbox.y1 + self.labelpad * self.get_figure(root=True).dpi / 72)) def _update_offset_text_position(self, bboxes, bboxes2): """ Update the offset_text position based on the sequence of bounding boxes of all the ticklabels """ x, y = self.offsetText.get_position() if not hasattr(self, '_tick_position'): self._tick_position = 'bottom' if self._tick_position == 'bottom': if not len(bboxes): bottom = self.axes.bbox.ymin else: bbox = mtransforms.Bbox.union(bboxes) bottom = bbox.y0 y = bottom - self.OFFSETTEXTPAD * self.get_figure(root=True).dpi / 72 else: if not len(bboxes2): top = self.axes.bbox.ymax else: bbox = mtransforms.Bbox.union(bboxes2) top = bbox.y1 y = top + self.OFFSETTEXTPAD * self.get_figure(root=True).dpi / 72 self.offsetText.set_position((x, y)) def set_ticks_position(self, position): """ Set the ticks position. Parameters ---------- position : {'top', 'bottom', 'both', 'default', 'none'} 'both' sets the ticks to appear on both positions, but does not change the tick labels. 'default' resets the tick positions to the default: ticks on both positions, labels at bottom. 'none' can be used if you don't want any ticks. 'none' and 'both' affect only the ticks, not the labels. """ if position == 'top': self.set_tick_params(which='both', top=True, labeltop=True, bottom=False, labelbottom=False) self._tick_position = 'top' self.offsetText.set_verticalalignment('bottom') elif position == 'bottom': self.set_tick_params(which='both', top=False, labeltop=False, bottom=True, labelbottom=True) self._tick_position = 'bottom' self.offsetText.set_verticalalignment('top') elif position == 'both': self.set_tick_params(which='both', top=True, bottom=True) elif position == 'none': self.set_tick_params(which='both', top=False, bottom=False) elif position == 'default': self.set_tick_params(which='both', top=True, labeltop=False, bottom=True, labelbottom=True) self._tick_position = 'bottom' self.offsetText.set_verticalalignment('top') else: _api.check_in_list(['top', 'bottom', 'both', 'default', 'none'], position=position) self.stale = True def tick_top(self): """ Move ticks and ticklabels (if present) to the top of the Axes. """ label = True if 'label1On' in self._major_tick_kw: label = (self._major_tick_kw['label1On'] or self._major_tick_kw['label2On']) self.set_ticks_position('top') # If labels were turned off before this was called, leave them off. self.set_tick_params(which='both', labeltop=label) def tick_bottom(self): """ Move ticks and ticklabels (if present) to the bottom of the Axes. """ label = True if 'label1On' in self._major_tick_kw: label = (self._major_tick_kw['label1On'] or self._major_tick_kw['label2On']) self.set_ticks_position('bottom') # If labels were turned off before this was called, leave them off. self.set_tick_params(which='both', labelbottom=label) def get_ticks_position(self): """ Return the ticks position ("top", "bottom", "default", or "unknown"). """ return {1: "bottom", 2: "top", "default": "default", "unknown": "unknown"}[ self._get_ticks_position()] get_view_interval, set_view_interval = _make_getset_interval( "view", "viewLim", "intervalx") get_data_interval, set_data_interval = _make_getset_interval( "data", "dataLim", "intervalx") def get_minpos(self): return self.axes.dataLim.minposx def set_default_intervals(self): # docstring inherited # only change view if dataLim has not changed and user has # not changed the view: if (not self.axes.dataLim.mutatedx() and not self.axes.viewLim.mutatedx()): if self._converter is not None: info = self._converter.axisinfo(self.units, self) if info.default_limits is not None: xmin, xmax = self.convert_units(info.default_limits) self.axes.viewLim.intervalx = xmin, xmax self.stale = True def get_tick_space(self): ends = mtransforms.Bbox.unit().transformed( self.axes.transAxes - self.get_figure(root=False).dpi_scale_trans) length = ends.width * 72 # There is a heuristic here that the aspect ratio of tick text # is no more than 3:1 size = self._get_tick_label_size('x') * 3 if size > 0: return int(np.floor(length / size)) else: return 2**31 - 1 class YAxis(Axis): __name__ = 'yaxis' axis_name = 'y' #: Read-only name identifying the axis. _tick_class = YTick def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._init() def _init(self): """ Initialize the label and offsetText instance values and `label_position` / `offset_text_position`. """ # x in display coords, y in axes coords (to be updated at draw time by # _update_label_positions and _update_offset_text_position). self.label.set( x=0, y=0.5, verticalalignment='bottom', horizontalalignment='center', rotation='vertical', rotation_mode='anchor', transform=mtransforms.blended_transform_factory( mtransforms.IdentityTransform(), self.axes.transAxes), ) self.label_position = 'left' if mpl.rcParams['ytick.labelcolor'] == 'inherit': tick_color = mpl.rcParams['ytick.color'] else: tick_color = mpl.rcParams['ytick.labelcolor'] # x in axes coords, y in display coords(!). self.offsetText.set( x=0, y=0.5, verticalalignment='baseline', horizontalalignment='left', transform=mtransforms.blended_transform_factory( self.axes.transAxes, mtransforms.IdentityTransform()), fontsize=mpl.rcParams['ytick.labelsize'], color=tick_color ) self.offset_text_position = 'left' def contains(self, mouseevent): # docstring inherited if self._different_canvas(mouseevent): return False, {} x, y = mouseevent.x, mouseevent.y try: trans = self.axes.transAxes.inverted() xaxes, yaxes = trans.transform((x, y)) except ValueError: return False, {} (l, b), (r, t) = self.axes.transAxes.transform([(0, 0), (1, 1)]) inaxis = 0 <= yaxes <= 1 and ( l - self._pickradius < x < l or r < x < r + self._pickradius) return inaxis, {} def set_label_position(self, position): """ Set the label position (left or right) Parameters ---------- position : {'left', 'right'} """ self.label.set_rotation_mode('anchor') self.label.set_verticalalignment(_api.check_getitem({ 'left': 'bottom', 'right': 'top', }, position=position)) self.label_position = position self.stale = True def _update_label_position(self, renderer): """ Update the label position based on the bounding box enclosing all the ticklabels and axis spine """ if not self._autolabelpos: return # get bounding boxes for this axis and any siblings # that have been set by `fig.align_ylabels()` bboxes, bboxes2 = self._get_tick_boxes_siblings(renderer=renderer) x, y = self.label.get_position() if self.label_position == 'left': # Union with extents of the left spine if present, of the axes otherwise. bbox = mtransforms.Bbox.union([ *bboxes, self.axes.spines.get("left", self.axes).get_window_extent()]) self.label.set_position( (bbox.x0 - self.labelpad * self.get_figure(root=True).dpi / 72, y)) else: # Union with extents of the right spine if present, of the axes otherwise. bbox = mtransforms.Bbox.union([ *bboxes2, self.axes.spines.get("right", self.axes).get_window_extent()]) self.label.set_position( (bbox.x1 + self.labelpad * self.get_figure(root=True).dpi / 72, y)) def _update_offset_text_position(self, bboxes, bboxes2): """ Update the offset_text position based on the sequence of bounding boxes of all the ticklabels """ x, _ = self.offsetText.get_position() if 'outline' in self.axes.spines: # Special case for colorbars: bbox = self.axes.spines['outline'].get_window_extent() else: bbox = self.axes.bbox top = bbox.ymax self.offsetText.set_position( (x, top + self.OFFSETTEXTPAD * self.get_figure(root=True).dpi / 72) ) def set_offset_position(self, position): """ Parameters ---------- position : {'left', 'right'} """ x, y = self.offsetText.get_position() x = _api.check_getitem({'left': 0, 'right': 1}, position=position) self.offsetText.set_ha(position) self.offsetText.set_position((x, y)) self.stale = True def set_ticks_position(self, position): """ Set the ticks position. Parameters ---------- position : {'left', 'right', 'both', 'default', 'none'} 'both' sets the ticks to appear on both positions, but does not change the tick labels. 'default' resets the tick positions to the default: ticks on both positions, labels at left. 'none' can be used if you don't want any ticks. 'none' and 'both' affect only the ticks, not the labels. """ if position == 'right': self.set_tick_params(which='both', right=True, labelright=True, left=False, labelleft=False) self.set_offset_position(position) elif position == 'left': self.set_tick_params(which='both', right=False, labelright=False, left=True, labelleft=True) self.set_offset_position(position) elif position == 'both': self.set_tick_params(which='both', right=True, left=True) elif position == 'none': self.set_tick_params(which='both', right=False, left=False) elif position == 'default': self.set_tick_params(which='both', right=True, labelright=False, left=True, labelleft=True) else: _api.check_in_list(['left', 'right', 'both', 'default', 'none'], position=position) self.stale = True def tick_right(self): """ Move ticks and ticklabels (if present) to the right of the Axes. """ label = True if 'label1On' in self._major_tick_kw: label = (self._major_tick_kw['label1On'] or self._major_tick_kw['label2On']) self.set_ticks_position('right') # if labels were turned off before this was called # leave them off self.set_tick_params(which='both', labelright=label) def tick_left(self): """ Move ticks and ticklabels (if present) to the left of the Axes. """ label = True if 'label1On' in self._major_tick_kw: label = (self._major_tick_kw['label1On'] or self._major_tick_kw['label2On']) self.set_ticks_position('left') # if labels were turned off before this was called # leave them off self.set_tick_params(which='both', labelleft=label) def get_ticks_position(self): """ Return the ticks position ("left", "right", "default", or "unknown"). """ return {1: "left", 2: "right", "default": "default", "unknown": "unknown"}[ self._get_ticks_position()] get_view_interval, set_view_interval = _make_getset_interval( "view", "viewLim", "intervaly") get_data_interval, set_data_interval = _make_getset_interval( "data", "dataLim", "intervaly") def get_minpos(self): return self.axes.dataLim.minposy def set_default_intervals(self): # docstring inherited # only change view if dataLim has not changed and user has # not changed the view: if (not self.axes.dataLim.mutatedy() and not self.axes.viewLim.mutatedy()): if self._converter is not None: info = self._converter.axisinfo(self.units, self) if info.default_limits is not None: ymin, ymax = self.convert_units(info.default_limits) self.axes.viewLim.intervaly = ymin, ymax self.stale = True def get_tick_space(self): ends = mtransforms.Bbox.unit().transformed( self.axes.transAxes - self.get_figure(root=False).dpi_scale_trans) length = ends.height * 72 # Having a spacing of at least 2 just looks good. size = self._get_tick_label_size('y') * 2 if size > 0: return int(np.floor(length / size)) else: return 2**31 - 1