2684 lines
96 KiB
Python
2684 lines
96 KiB
Python
"""
|
|
Classes for the ticks and x and y axis.
|
|
"""
|
|
|
|
import datetime
|
|
import functools
|
|
import logging
|
|
from numbers import Number
|
|
|
|
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 = [list(d)[0] 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 : `.Line2D`
|
|
The left/bottom tick marker.
|
|
tick2line : `.Line2D`
|
|
The right/top tick marker.
|
|
gridline : `.Line2D`
|
|
The grid line associated with the label position.
|
|
label1 : `.Text`
|
|
The left/bottom tick label.
|
|
label2 : `.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,
|
|
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:
|
|
if major and (mpl.rcParams['axes.grid.which']
|
|
in ('both', 'major')):
|
|
gridOn = mpl.rcParams['axes.grid']
|
|
elif (not major) and (mpl.rcParams['axes.grid.which']
|
|
in ('both', 'minor')):
|
|
gridOn = mpl.rcParams['axes.grid']
|
|
else:
|
|
gridOn = False
|
|
|
|
self.set_figure(axes.figure)
|
|
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 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
|
|
|
|
if grid_color is None:
|
|
grid_color = mpl.rcParams["grid.color"]
|
|
if grid_linestyle is None:
|
|
grid_linestyle = mpl.rcParams["grid.linestyle"]
|
|
if grid_linewidth is None:
|
|
grid_linewidth = mpl.rcParams["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,
|
|
rotation=self._labelrotation[1])
|
|
self.label2 = mtext.Text(
|
|
np.nan, np.nan,
|
|
fontsize=labelsize, color=labelcolor, visible=label2On,
|
|
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)
|
|
|
|
@property
|
|
@_api.deprecated("3.1", alternative="Tick.label1", removal="3.8")
|
|
def label(self):
|
|
return self.label1
|
|
|
|
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)
|
|
|
|
def _apply_tickdir(self, tickdir):
|
|
"""Set tick direction. Valid values are 'out', 'in', 'inout'."""
|
|
# This method is responsible for updating `_pad`, and, in subclasses,
|
|
# for setting the tick{1,2}line markers as well. From the user
|
|
# perspective this should always be called though _apply_params, which
|
|
# further updates ticklabel positions using the new pads.
|
|
if tickdir is None:
|
|
tickdir = mpl.rcParams[f'{self.__name__}.direction']
|
|
_api.check_in_list(['in', 'out', 'inout'], tickdir=tickdir)
|
|
self._tickdir = tickdir
|
|
self._pad = self._base_pad + self.get_tick_padding()
|
|
|
|
@_api.deprecated("3.5", alternative="`.Axis.set_tick_params`")
|
|
def apply_tickdir(self, tickdir):
|
|
self._apply_tickdir(tickdir)
|
|
self.stale = True
|
|
|
|
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, clippath, transform=None):
|
|
# docstring inherited
|
|
super().set_clip_path(clippath, transform)
|
|
self.gridline.set_clip_path(clippath, transform)
|
|
self.stale = True
|
|
|
|
@_api.deprecated("3.6")
|
|
def get_pad_pixels(self):
|
|
return self.figure.dpi * self._base_pad / 72
|
|
|
|
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.
|
|
"""
|
|
inside, info = self._default_contains(mouseevent)
|
|
if inside is not None:
|
|
return inside, info
|
|
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_text1(self):
|
|
"""Get the default Text 1 instance."""
|
|
|
|
def _get_text2(self):
|
|
"""Get the default Text 2 instance."""
|
|
|
|
def _get_tick1line(self):
|
|
"""Get the default line2D instance for tick1."""
|
|
|
|
def _get_tick2line(self):
|
|
"""Get the default line2D instance for tick2."""
|
|
|
|
def _get_gridline(self):
|
|
"""Get the default grid Line2d instance for this tick."""
|
|
|
|
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_label1(self, s):
|
|
"""
|
|
Set the label1 text.
|
|
|
|
Parameters
|
|
----------
|
|
s : str
|
|
"""
|
|
self.label1.set_text(s)
|
|
self.stale = True
|
|
|
|
set_label = set_label1
|
|
|
|
def set_label2(self, s):
|
|
"""
|
|
Set the label2 text.
|
|
|
|
Parameters
|
|
----------
|
|
s : str
|
|
"""
|
|
self.label2.set_text(s)
|
|
self.stale = True
|
|
|
|
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.figure)
|
|
|
|
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']}
|
|
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, cls):
|
|
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 to an empty
|
|
# list, then create the tick and append it.
|
|
if self._major:
|
|
instance.majorTicks = []
|
|
tick = instance._get_tick(major=True)
|
|
instance.majorTicks.append(tick)
|
|
return instance.majorTicks
|
|
else:
|
|
instance.minorTicks = []
|
|
tick = instance._get_tick(major=False)
|
|
instance.minorTicks.append(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 : `.Text`
|
|
The axis label.
|
|
labelpad : float
|
|
The distance between the axis label and the tick labels.
|
|
Defaults to :rc:`axes.labelpad` = 4.
|
|
offsetText : `.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.
|
|
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
|
|
|
|
def __str__(self):
|
|
return "{}({},{})".format(
|
|
type(self).__name__, *self.axes.transAxes.transform((0, 0)))
|
|
|
|
@_api.make_keyword_only("3.6", name="pickradius")
|
|
def __init__(self, axes, pickradius=15):
|
|
"""
|
|
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`.
|
|
"""
|
|
super().__init__()
|
|
self._remove_overlapping_locs = True
|
|
|
|
self.set_figure(axes.figure)
|
|
|
|
self.isDefault_label = True
|
|
|
|
self.axes = axes
|
|
self.major = Ticker()
|
|
self.minor = Ticker()
|
|
self.callbacks = cbook.CallbackRegistry(
|
|
signals=["units", "units finalize"])
|
|
|
|
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'],
|
|
)
|
|
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()
|
|
|
|
self.clear()
|
|
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
|
|
|
|
# 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 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 : {"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.
|
|
"""
|
|
name, = [name for name, axis in self.axes._axis_map.items()
|
|
if axis is self] # The axis name.
|
|
old_default_lims = (self.get_major_locator()
|
|
.nonsingular(-np.inf, np.inf))
|
|
g = self.axes._shared_axes[name]
|
|
for ax in g.get_siblings(self.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 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`.
|
|
|
|
Parameters
|
|
----------
|
|
b : bool
|
|
"""
|
|
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.set_text('') # self.set_label_text would change isDefault_
|
|
|
|
self._set_scale('linear')
|
|
|
|
# Clear the callback registry for this axis, or it may "leak"
|
|
self.callbacks = cbook.CallbackRegistry(
|
|
signals=["units", "units finalize"])
|
|
|
|
# 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.units = None
|
|
self.set_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 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`.
|
|
"""
|
|
_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
|
|
|
|
@staticmethod
|
|
def _translate_tick_params(kw):
|
|
"""
|
|
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: The input *kwargs* are currently modified, but that's ok for
|
|
the only caller.
|
|
"""
|
|
# The following lists may be moved to a more accessible location.
|
|
allowed_keys = [
|
|
'size', 'width', 'color', 'tickdir', 'pad',
|
|
'labelsize', 'labelcolor', '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',
|
|
}
|
|
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, clippath, transform=None):
|
|
super().set_clip_path(clippath, transform)
|
|
for child in self.majorTicks + self.minorTicks:
|
|
child.set_clip_path(clippath, 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, = [name for name, axis in self.axes._axis_map.items()
|
|
if axis is self] # The 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.axes._shared_axes[name].get_siblings(self.axes):
|
|
ax._stale_viewlims[name] = False
|
|
if auto is not None:
|
|
self._set_autoscale_on(bool(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.axes._shared_axes[name].get_siblings(self.axes):
|
|
if other is not self.axes:
|
|
other._axis_map[name]._set_lim(
|
|
v0, v1, emit=False, auto=auto)
|
|
if other.figure != self.figure:
|
|
other.figure.canvas.draw_idle()
|
|
|
|
self.stale = True
|
|
return v0, v1
|
|
|
|
def _set_artist_props(self, a):
|
|
if a is None:
|
|
return
|
|
a.set_figure(self.figure)
|
|
|
|
@_api.deprecated("3.6")
|
|
def get_ticklabel_extents(self, renderer):
|
|
"""Get the extents of the tick labels on either side of the axes."""
|
|
ticks_to_draw = self._update_ticks()
|
|
tlb1, tlb2 = self._get_ticklabel_bboxes(ticks_to_draw, renderer)
|
|
if len(tlb1):
|
|
bbox1 = mtransforms.Bbox.union(tlb1)
|
|
else:
|
|
bbox1 = mtransforms.Bbox.from_extents(0, 0, 0, 0)
|
|
if len(tlb2):
|
|
bbox2 = mtransforms.Bbox.union(tlb2)
|
|
else:
|
|
bbox2 = mtransforms.Bbox.from_extents(0, 0, 0, 0)
|
|
return bbox1, bbox2
|
|
|
|
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))
|
|
self.major.formatter.set_locs(major_locs)
|
|
for tick, loc, label in zip(major_ticks, major_locs, major_labels):
|
|
tick.update_position(loc)
|
|
tick.set_label1(label)
|
|
tick.set_label2(label)
|
|
minor_locs = self.get_minorticklocs()
|
|
minor_labels = self.minor.formatter.format_ticks(minor_locs)
|
|
minor_ticks = self.get_minor_ticks(len(minor_locs))
|
|
self.minor.formatter.set_locs(minor_locs)
|
|
for tick, loc, label in zip(minor_ticks, minor_locs, minor_labels):
|
|
tick.update_position(loc)
|
|
tick.set_label1(label)
|
|
tick.set_label2(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
|
|
|
|
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.figure._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():
|
|
return
|
|
if renderer is None:
|
|
renderer = self.figure._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, *args, **kwargs):
|
|
# 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)
|
|
|
|
# Scale up the axis label box to also find the neighbors, not just the
|
|
# tick labels that actually overlap. We need a *copy* of the axis
|
|
# label box because we don't want to scale the actual bbox.
|
|
|
|
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 get_label(self):
|
|
"""Return the axis label as a Text instance."""
|
|
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
|
|
-------
|
|
numpy array of tick locations
|
|
"""
|
|
return self.get_minorticklocs() if minor else self.get_majorticklocs()
|
|
|
|
def get_ticks_direction(self, minor=False):
|
|
"""
|
|
Get the tick directions as a numpy array
|
|
|
|
Parameters
|
|
----------
|
|
minor : bool, default: False
|
|
True to return the minor tick directions,
|
|
False to return the major tick directions.
|
|
|
|
Returns
|
|
-------
|
|
numpy 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)
|
|
|
|
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."""
|
|
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."""
|
|
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]
|
|
|
|
@_api.rename_parameter("3.5", "b", "visible")
|
|
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 : `.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.converter instance if necessary. Return *True*
|
|
if *data* is registered for unit conversion.
|
|
"""
|
|
converter = munits.registry.get_converter(data)
|
|
if converter is None:
|
|
return False
|
|
|
|
neednew = self.converter != converter
|
|
self.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.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 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 name, axis in self.axes._axis_map.items():
|
|
if self is axis:
|
|
shared = [
|
|
getattr(ax, f"{name}axis")
|
|
for ax
|
|
in self.axes._shared_axes[name].get_siblings(self.axes)]
|
|
break
|
|
else:
|
|
shared = [self]
|
|
for axis in shared:
|
|
axis.units = u
|
|
axis._update_axisinfo()
|
|
axis.callbacks.process('units')
|
|
axis.callbacks.process('units finalize')
|
|
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.
|
|
**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, Number) 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, ticklabels, *, minor=False, **kwargs):
|
|
r"""
|
|
[*Discouraged*] Set the text values of the 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_[x/y]ticks(positions, labels)`` 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
|
|
----------
|
|
ticklabels : 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.
|
|
minor : bool
|
|
If True, set minor ticks instead of major ticks.
|
|
**kwargs
|
|
Text properties.
|
|
|
|
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:
|
|
ticklabels = [t.get_text() if hasattr(t, 'get_text') else t
|
|
for t in ticklabels]
|
|
except TypeError:
|
|
raise TypeError(f"{ticklabels:=} must be a sequence") from None
|
|
locator = (self.get_minor_locator() if minor
|
|
else self.get_major_locator())
|
|
if isinstance(locator, mticker.FixedLocator):
|
|
# Passing [] as a list of ticklabels is often used as a way to
|
|
# remove all tick labels, so only error for > 0 ticklabels
|
|
if len(locator.locs) != len(ticklabels) and len(ticklabels) != 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 ticklabels ({len(ticklabels)}).")
|
|
tickd = {loc: lab for loc, lab in zip(locator.locs, ticklabels)}
|
|
func = functools.partial(self._format_with_dict, tickd)
|
|
formatter = mticker.FuncFormatter(func)
|
|
else:
|
|
formatter = mticker.FixedFormatter(ticklabels)
|
|
|
|
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 = []
|
|
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
|
|
|
|
# Wrapper around set_ticklabels used to generate Axes.set_x/ytickabels; can
|
|
# go away once the API of Axes.set_x/yticklabels becomes consistent.
|
|
def _set_ticklabels(self, labels, *, fontdict=None, minor=False, **kwargs):
|
|
"""
|
|
Set this Axis' labels with list of string labels.
|
|
|
|
.. warning::
|
|
This method should only be used after fixing the tick positions
|
|
using `.Axis.set_ticks`. Otherwise, the labels may end up in
|
|
unexpected positions.
|
|
|
|
Parameters
|
|
----------
|
|
labels : list of str
|
|
The label texts.
|
|
|
|
fontdict : dict, optional
|
|
A dictionary controlling the appearance of the ticklabels.
|
|
The default *fontdict* is::
|
|
|
|
{'fontsize': rcParams['axes.titlesize'],
|
|
'fontweight': rcParams['axes.titleweight'],
|
|
'verticalalignment': 'baseline',
|
|
'horizontalalignment': loc}
|
|
|
|
minor : bool, default: False
|
|
Whether to set the minor ticklabels rather than the major ones.
|
|
|
|
Returns
|
|
-------
|
|
list of `.Text`
|
|
The labels.
|
|
|
|
Other Parameters
|
|
----------------
|
|
**kwargs : `~.text.Text` properties.
|
|
"""
|
|
if fontdict is not None:
|
|
kwargs.update(fontdict)
|
|
return self.set_ticklabels(labels, minor=minor, **kwargs)
|
|
|
|
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)
|
|
for name, axis in self.axes._axis_map.items():
|
|
if self is axis:
|
|
shared = [
|
|
getattr(ax, f"{name}axis")
|
|
for ax
|
|
in self.axes._shared_axes[name].get_siblings(self.axes)]
|
|
break
|
|
else:
|
|
shared = [self]
|
|
if len(ticks):
|
|
for axis in shared:
|
|
# 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(mticker.FixedLocator(ticks))
|
|
return self.get_minor_ticks(len(ticks))
|
|
else:
|
|
self.set_major_locator(mticker.FixedLocator(ticks))
|
|
return self.get_major_ticks(len(ticks))
|
|
|
|
def set_ticks(self, ticks, labels=None, *, minor=False, **kwargs):
|
|
"""
|
|
Set this Axis' tick locations and optionally labels.
|
|
|
|
If necessary, the view limits of the Axis are expanded so that all
|
|
given ticks are visible.
|
|
|
|
Parameters
|
|
----------
|
|
ticks : list of floats
|
|
List of tick locations. The axis `.Locator` is replaced by a
|
|
`~.ticker.FixedLocator`.
|
|
|
|
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
|
|
List of tick labels. If not set, the labels are generated with
|
|
the axis tick `.Formatter`.
|
|
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`.
|
|
|
|
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.
|
|
"""
|
|
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.
|
|
axis_names = [
|
|
name for name, axis in self.axes._axis_map.items()
|
|
if name in self.figure._align_label_groups and axis is self]
|
|
if len(axis_names) != 1:
|
|
return [], []
|
|
axis_name, = axis_names
|
|
grouper = self.figure._align_label_groups[axis_name]
|
|
bboxes = []
|
|
bboxes2 = []
|
|
# If we want to align labels from other Axes:
|
|
for ax in grouper.get_siblings(self.axes):
|
|
axis = getattr(ax, f"{axis_name}axis")
|
|
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)
|
|
# 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'
|
|
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=mpl.rcParams['xtick.color'],
|
|
)
|
|
self.offset_text_position = 'bottom'
|
|
|
|
def contains(self, mouseevent):
|
|
"""Test whether the mouse event occurred in the x axis."""
|
|
inside, info = self._default_contains(mouseevent)
|
|
if inside is not None:
|
|
return inside, info
|
|
|
|
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':
|
|
try:
|
|
spine = self.axes.spines['bottom']
|
|
spinebbox = spine.get_window_extent()
|
|
except KeyError:
|
|
# use Axes if spine doesn't exist
|
|
spinebbox = self.axes.bbox
|
|
bbox = mtransforms.Bbox.union(bboxes + [spinebbox])
|
|
bottom = bbox.y0
|
|
|
|
self.label.set_position(
|
|
(x, bottom - self.labelpad * self.figure.dpi / 72)
|
|
)
|
|
else:
|
|
try:
|
|
spine = self.axes.spines['top']
|
|
spinebbox = spine.get_window_extent()
|
|
except KeyError:
|
|
# use Axes if spine doesn't exist
|
|
spinebbox = self.axes.bbox
|
|
bbox = mtransforms.Bbox.union(bboxes2 + [spinebbox])
|
|
top = bbox.y1
|
|
|
|
self.label.set_position(
|
|
(x, top + self.labelpad * self.figure.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.figure.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.figure.dpi / 72
|
|
self.offsetText.set_position((x, y))
|
|
|
|
@_api.deprecated("3.6")
|
|
def get_text_heights(self, renderer):
|
|
"""
|
|
Return how much space should be reserved for text above and below the
|
|
Axes, as a pair of floats.
|
|
"""
|
|
bbox, bbox2 = self.get_ticklabel_extents(renderer)
|
|
# MGDTODO: Need a better way to get the pad
|
|
pad_pixels = self.majorTicks[0].get_pad_pixels()
|
|
|
|
above = 0.0
|
|
if bbox2.height:
|
|
above += bbox2.height + pad_pixels
|
|
below = 0.0
|
|
if bbox.height:
|
|
below += bbox.height + pad_pixels
|
|
|
|
if self.get_label_position() == 'top':
|
|
above += self.label.get_window_extent(renderer).height + pad_pixels
|
|
else:
|
|
below += self.label.get_window_extent(renderer).height + pad_pixels
|
|
return above, below
|
|
|
|
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.
|
|
"""
|
|
_api.check_in_list(['top', 'bottom', 'both', 'default', 'none'],
|
|
position=position)
|
|
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:
|
|
assert False, "unhandled parameter not caught by _check_in_list"
|
|
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.figure.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)
|
|
# 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'
|
|
# 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=mpl.rcParams['ytick.color'],
|
|
)
|
|
self.offset_text_position = 'left'
|
|
|
|
def contains(self, mouseevent):
|
|
# docstring inherited
|
|
inside, info = self._default_contains(mouseevent)
|
|
if inside is not None:
|
|
return inside, info
|
|
|
|
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':
|
|
try:
|
|
spine = self.axes.spines['left']
|
|
spinebbox = spine.get_window_extent()
|
|
except KeyError:
|
|
# use Axes if spine doesn't exist
|
|
spinebbox = self.axes.bbox
|
|
bbox = mtransforms.Bbox.union(bboxes + [spinebbox])
|
|
left = bbox.x0
|
|
self.label.set_position(
|
|
(left - self.labelpad * self.figure.dpi / 72, y)
|
|
)
|
|
|
|
else:
|
|
try:
|
|
spine = self.axes.spines['right']
|
|
spinebbox = spine.get_window_extent()
|
|
except KeyError:
|
|
# use Axes if spine doesn't exist
|
|
spinebbox = self.axes.bbox
|
|
|
|
bbox = mtransforms.Bbox.union(bboxes2 + [spinebbox])
|
|
right = bbox.x1
|
|
self.label.set_position(
|
|
(right + self.labelpad * self.figure.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.figure.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
|
|
|
|
@_api.deprecated("3.6")
|
|
def get_text_widths(self, renderer):
|
|
bbox, bbox2 = self.get_ticklabel_extents(renderer)
|
|
# MGDTODO: Need a better way to get the pad
|
|
pad_pixels = self.majorTicks[0].get_pad_pixels()
|
|
|
|
left = 0.0
|
|
if bbox.width:
|
|
left += bbox.width + pad_pixels
|
|
right = 0.0
|
|
if bbox2.width:
|
|
right += bbox2.width + pad_pixels
|
|
|
|
if self.get_label_position() == 'left':
|
|
left += self.label.get_window_extent(renderer).width + pad_pixels
|
|
else:
|
|
right += self.label.get_window_extent(renderer).width + pad_pixels
|
|
return left, right
|
|
|
|
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.
|
|
"""
|
|
_api.check_in_list(['left', 'right', 'both', 'default', 'none'],
|
|
position=position)
|
|
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:
|
|
assert False, "unhandled parameter not caught by _check_in_list"
|
|
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.figure.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
|