#!/usr/bin/env python3
"""
The standard x-y axes used for most ProPlot figures.
"""
import matplotlib.dates as mdates
import matplotlib.ticker as mticker
import numpy as np
from .. import constructor
from .. import scale as pscale
from .. import ticker as pticker
from ..config import rc
from ..internals import ic # noqa: F401
from ..internals import _not_none, docstring, rcsetup, warnings
from ..utils import units
from . import base
__all__ = ['CartesianAxes']
_alt_doc = """
Return an axes in the same location as this one but whose {x} axis is on
the {x2}. This is an alias and more intuitive name for
`~CartesianAxes.twin{y}`, which generates two *{x}* axes with
a shared ("twin") *{y}* axes.
Also enforces the following settings:
* Places the old *{x}* axis on the {x1} and the new *{x}* axis
on the {x2}.
* Makes the old {x2} spine invisible and the new {x1}, {y1},
and {y2} spines invisible.
* Adjusts the *{x}* axis tick, tick label, and axis label positions
according to the visible spine positions.
* Locks the old and new *{y}* axis limits and scales, and makes the new
{y} axis labels invisible.
Parameters
----------
{xargs} : optional
Passed to `Axes.format`.
{args} : optional
Prepended with ``'{x}'`` and passed to `Axes.format`.
"""
_alt_kwargs = ( # TODO: More systematic approach?
'lim', 'reverse', 'scale', 'label',
'tickdir', 'grid', 'gridminor',
'tickminor', 'ticklabeldir', 'tickrange', 'wraprange',
'rotation', 'formatter', 'ticklabels',
'ticks', 'locator', 'minorticks', 'minorlocator',
'bounds', 'margin', 'color',
'ticklen', 'linewidth', 'gridcolor',
'label_kw', 'scale_kw', 'locator_kw', 'formatter_kw', 'minorlocator_kw',
)
docstring.snippets['axes.altx'] = _alt_doc.format(
x='x',
x1='bottom',
x2='top',
y='y',
y1='left',
y2='right',
args=', '.join(_alt_kwargs),
xargs=', '.join('x' + key for key in _alt_kwargs),
)
docstring.snippets['axes.alty'] = _alt_doc.format(
x='y',
x1='left',
x2='right',
y='x',
y1='bottom',
y2='top',
args=', '.join(_alt_kwargs),
xargs=', '.join('y' + key for key in _alt_kwargs),
)
_dual_doc = """
Return a secondary *{x}* axis for denoting equivalent *{x}*
coordinates in *alternate units*.
Parameters
----------
funcscale : function, (function, function), or scale-spec
Used to transform units from the parent axis to the secondary axis.
This can be a `~proplot.scale.FuncScale` itself or a function,
(function, function) tuple, or an axis scale specification interpreted
by the `~proplot.constructor.Scale` constructor function, any of which will
be used to build a `~proplot.scale.FuncScale` and applied to the dual axis
(see `~proplot.scale.FuncScale` for details).
{args} : optional
Prepended with ``'{x}'`` and passed to `Axes.format`.
"""
docstring.snippets['axes.dualx'] = _dual_doc.format(
x='x',
args=', '.join(_alt_kwargs),
xargs=', '.join('x' + key for key in _alt_kwargs),
)
docstring.snippets['axes.dualy'] = _dual_doc.format(
x='y',
args=', '.join(_alt_kwargs),
xargs=', '.join('y' + key for key in _alt_kwargs),
)
_twin_doc = """
Mimics the builtin `~matplotlib.axes.Axes.twin{y}` method.
Also enforces the following settings:
* Places the old *{x}* axis on the {x1} and the new *{x}* axis
on the {x2}.
* Makes the old {x2} spine invisible and the new {x1}, {y1},
and {y2} spines invisible.
* Adjusts the *{x}* axis tick, tick label, and axis label positions
according to the visible spine positions.
* Locks the old and new *{y}* axis limits and scales, and makes the new
{y} axis labels invisible.
Parameters
----------
{xargs} : optional
Passed to `Axes.format`.
{args} : optional
Prepended with ``'{x}'`` and passed to `Axes.format`.
"""
docstring.snippets['axes.twinx'] = _twin_doc.format(
x='y', x1='left', x2='right',
y='x', y1='bottom', y2='top',
args=', '.join(_alt_kwargs),
xargs=', '.join('y' + key for key in _alt_kwargs),
)
docstring.snippets['axes.twiny'] = _twin_doc.format(
x='x', x1='bottom', x2='top',
y='y', y1='left', y2='right',
args=', '.join(_alt_kwargs),
xargs=', '.join('x' + key for key in _alt_kwargs),
)
def _parse_alt(x, kwargs):
"""
Interpret keyword args passed to all "twin axis" methods so they
can be passed to Axes.format.
"""
kw_bad, kw_out = {}, {}
for key, value in kwargs.items():
if key in _alt_kwargs:
kw_out[x + key] = value
elif key[0] == x and key[1:] in _alt_kwargs:
# NOTE: We permit both e.g. 'locator' and 'xlocator' because
# while is more elegant and consistent with e.g. colorbar() syntax
# but latter is more consistent and easier to use when refactoring.
kw_out[key] = value
elif key in rcsetup._rc_nodots:
kw_out[key] = value
else:
kw_bad[key] = value
if kw_bad:
raise TypeError(f'Unexpected keyword argument(s): {kw_bad!r}')
return kw_out
def _parse_rcloc(x, string): # figures out string location
"""
Convert the *boolean* "left", "right", "top", and "bottom" rc settings
to a location string. Returns ``None`` if settings are unchanged.
"""
if x == 'x':
top = rc.get(f'{string}.top', context=True)
bottom = rc.get(f'{string}.bottom', context=True)
if top is None and bottom is None:
return None
elif top and bottom:
return 'both'
elif top:
return 'top'
elif bottom:
return 'bottom'
else:
return 'neither'
else:
left = rc.get(f'{string}.left', context=True)
right = rc.get(f'{string}.right', context=True)
if left is None and right is None:
return None
elif left and right:
return 'both'
elif left:
return 'left'
elif right:
return 'right'
else:
return 'neither'
[docs]class CartesianAxes(base.Axes):
"""
Axes subclass for plotting in ordinary Cartesian coordinates.
Adds the `~CartesianAxes.format` method and overrides several existing
methods.
"""
#: The registered projection name.
name = 'proplot_cartesian'
def __init__(self, *args, **kwargs):
"""
See also
--------
proplot.ui.subplots
"""
# Impose default formatter
super().__init__(*args, **kwargs)
formatter = pticker.AutoFormatter()
self.xaxis.set_major_formatter(formatter)
self.yaxis.set_major_formatter(formatter)
self.xaxis.isDefault_majfmt = True
self.yaxis.isDefault_majfmt = True
self._altx_parent = None
self._alty_parent = None
self._datex_rotated = False # whether manual rotation has been applied
self._dualx_funcscale = None # for scaling units on dual axes
self._dualx_prevstate = None # prevent excess _dualy_scale calls
self._dualy_funcscale = None
self._dualy_prevstate = None
def _apply_axis_sharing(self):
"""
Enforce the "shared" axis labels and axis tick labels. If this is not called
at drawtime, "shared" labels can be inadvertantly turned off.
"""
# X axis
# NOTE: The "panel sharing group" refers to axes and panels *above* the
# bottommost or to the *right* of the leftmost panel. But the edge panel
# sharing level is the *figure* sharing level.
axis = self.xaxis
if self._sharex is not None:
level = 3 if self._panel_sharex_group else self.figure._sharex
if level > 0:
axis.label.set_visible(False)
if level > 2:
# WARNING: Cannot set NullFormatter because shared axes share the
# same axis.Ticker classes. Instead use the approach copied from
# matplotlib subplots().
axis.set_tick_params(which='both', labelbottom=False, labeltop=False)
# Y axis
axis = self.yaxis
if self._sharey is not None:
level = 3 if self._panel_sharey_group else self.figure._sharey
if level > 0:
axis.label.set_visible(False)
if level > 2:
axis.set_tick_params(which='both', labelleft=False, labelright=False)
axis.set_minor_formatter(mticker.NullFormatter())
def _datex_rotate(self):
"""
Apply default rotation to datetime axis coordinates.
"""
# NOTE: Rotation is done *before* horizontal/vertical alignment,
# cannot change alignment with set_tick_params. Must apply to text
# objects. fig.autofmt_date calls subplots_adjust, so cannot use it.
if (
not isinstance(self.xaxis.converter, mdates.DateConverter)
or self._datex_rotated
):
return
rotation = rc['formatter.timerotation']
kw = {'rotation': rotation}
if rotation not in (0, 90, -90):
kw['ha'] = ('right' if rotation > 0 else 'left')
for label in self.xaxis.get_ticklabels():
label.update(kw)
self._datex_rotated = True # do not need to apply more than once
def _dualx_scale(self):
"""
Lock the child "dual" *x* axis limits to the parent.
"""
# NOTE: We bypass autoscale_view because we set limits manually, and bypass
# child.stale = True because that is done in call to set_xlim() below.
# NOTE: We set the scale using private API to bypass application of
# set_default_locators_and_formatters: only_if_default=True is critical
# to prevent overriding user settings!
# NOTE: Dual axis only needs to be constrained if the parent axis scale
# and limits have changed, and limits are always applied before we reach
# the child.draw() because always called after parent.draw()
funcscale, parent, child = self._dualx_funcscale, self._altx_parent, self
if funcscale is None or parent is None:
return
olim = parent.get_xlim()
scale = parent.xaxis._scale
if (scale, *olim) == child._dualx_prevstate:
return
funcscale = pscale.FuncScale(funcscale, invert=True, parent_scale=scale)
child.xaxis._scale = funcscale
child._update_transScale()
funcscale.set_default_locators_and_formatters(child.xaxis, only_if_default=True)
nlim = list(map(funcscale.functions[1], np.array(olim)))
if np.sign(np.diff(olim)) != np.sign(np.diff(nlim)):
nlim = nlim[::-1] # if function flips limits, so will set_xlim!
child.set_xlim(nlim, emit=False)
child._dualx_prevstate = (scale, *olim)
def _dualy_scale(self):
"""
Lock the child "dual" *y* axis limits to the parent.
"""
# See _dualx_scale() comments
funcscale, parent, child = self._dualy_funcscale, self._alty_parent, self
if funcscale is None or parent is None:
return
olim = parent.get_ylim()
scale = parent.yaxis._scale
if (scale, *olim) == child._dualy_prevstate:
return
funcscale = pscale.FuncScale(funcscale, invert=True, parent_scale=scale)
child.yaxis._scale = funcscale
child._update_transScale()
funcscale.set_default_locators_and_formatters(child.yaxis, only_if_default=True)
nlim = list(map(funcscale.functions[1], np.array(olim)))
if np.sign(np.diff(olim)) != np.sign(np.diff(nlim)):
nlim = nlim[::-1]
child.set_ylim(nlim, emit=False)
child._dualy_prevstate = (scale, *olim)
def _sharex_setup(self, sharex):
"""
Configure shared axes accounting for panels. The input is the
'parent' axes, from which this one will draw its properties.
"""
# Share *panels* across different subplots
super()._sharex_setup(sharex)
# Get sharing level
level = (
3 if self._panel_sharex_group and self._is_panel_group_member(sharex)
else self.figure._sharex
)
if level not in range(4):
raise ValueError(
'Invalid sharing level sharex={value!r}. '
'Axis sharing level can be 0 (share nothing), '
'1 (hide axis labels), '
'2 (share limits and hide axis labels), or '
'3 (share limits and hide axis and tick labels).'
)
if sharex in (None, self) or not isinstance(sharex, CartesianAxes):
return
# Share future changes to axis labels
# Proplot internally uses _sharex and _sharey for label sharing. Matplotlib
# only uses these in __init__() and cla() to share tickers -- all other builtin
# matplotlib axis sharing features derive from _shared_x_axes() group.
if level > 0:
self._sharex = sharex
if not sharex.xaxis.label.get_text():
sharex.xaxis.label.set_text(self.xaxis.label.get_text())
# Share future axis tickers, limits, and scales
# NOTE: Only difference between levels 2 and 3 is level 3 hides
# tick labels. But this is done after the fact -- tickers are still shared.
if level > 1:
# Initial limits and scales should be shared both ways
for (ax1, ax2) in ((self, sharex), (sharex, self)):
if ax1.get_xscale() == 'linear' and ax2.get_xscale() != 'linear':
ax1.set_xscale(ax2.get_xscale())
if ax1.get_autoscalex_on() and not ax2.get_autoscalex_on():
ax1.set_xlim(ax2.get_xlim())
# Locators and formatters only need to be shared from children
# to parent, because this is done automatically when we assign
# parent sharex tickers to child.
self._shared_x_axes.join(self, sharex) # share limit/scale changes
if sharex.xaxis.isDefault_majloc and not self.xaxis.isDefault_majloc:
sharex.xaxis.set_major_locator(self.xaxis.get_major_locator())
if sharex.xaxis.isDefault_minloc and not self.xaxis.isDefault_minloc:
sharex.xaxis.set_minor_locator(self.xaxis.get_minor_locator())
if sharex.xaxis.isDefault_majfmt and not self.xaxis.isDefault_majfmt:
sharex.xaxis.set_major_formatter(self.xaxis.get_major_formatter())
if sharex.xaxis.isDefault_minfmt and not self.xaxis.isDefault_minfmt:
sharex.xaxis.set_minor_formatter(self.xaxis.get_minor_formatter())
self.xaxis.major = sharex.xaxis.major
self.xaxis.minor = sharex.xaxis.minor
def _sharey_setup(self, sharey):
"""
Configure shared axes accounting for panels. The input is the
'parent' axes, from which this one will draw its properties.
"""
# Share *panels* across different subplots
super()._sharey_setup(sharey)
# Get sharing level
level = (
3 if self._panel_sharey_group and self._is_panel_group_member(sharey)
else self.figure._sharey
)
if level not in range(4):
raise ValueError(
'Invalid sharing level sharey={value!r}. '
'Axis sharing level can be 0 (share nothing), '
'1 (hide axis labels), '
'2 (share limits and hide axis labels), or '
'3 (share limits and hide axis and tick labels).'
)
if sharey in (None, self) or not isinstance(sharey, CartesianAxes):
return
# Share future changes to axis labels
if level > 0:
self._sharey = sharey
if not sharey.yaxis.label.get_text():
sharey.yaxis.label.set_text(self.yaxis.label.get_text())
# Share future axis tickers, limits, and scales
if level > 1:
# Initial limits and scales should be shared both ways
for (ax1, ax2) in ((self, sharey), (sharey, self)):
if ax1.get_yscale() == 'linear' and ax2.get_yscale() != 'linear':
ax1.set_yscale(ax2.get_yscale())
if ax1.get_autoscaley_on() and not ax2.get_autoscaley_on():
ax1.set_ylim(ax2.get_ylim())
# Locators and formatters only need to be shared from children
# to parent, because this is done automatically when we assign
# parent sharey tickers to child.
self._shared_y_axes.join(self, sharey) # share limit/scale changes
if sharey.yaxis.isDefault_majloc and not self.yaxis.isDefault_majloc:
sharey.yaxis.set_major_locator(self.yaxis.get_major_locator())
if sharey.yaxis.isDefault_minloc and not self.yaxis.isDefault_minloc:
sharey.yaxis.set_minor_locator(self.yaxis.get_minor_locator())
if sharey.yaxis.isDefault_majfmt and not self.yaxis.isDefault_majfmt:
sharey.yaxis.set_major_formatter(self.yaxis.get_major_formatter())
if sharey.yaxis.isDefault_minfmt and not self.yaxis.isDefault_minfmt:
sharey.yaxis.set_minor_formatter(self.yaxis.get_minor_formatter())
self.yaxis.major = sharey.yaxis.major
self.yaxis.minor = sharey.yaxis.minor
def _update_bounds(self, x, fixticks=False):
"""
Ensure there are no out-of-bounds labels. Mostly a brute-force version of
`~matplotlib.axis.Axis.set_smart_bounds` (which I couldn't get to work).
"""
# NOTE: Previously triggered this every time FixedFormatter was found
# on axis but 1) that seems heavy-handed + strange and 2) internal
# application of FixedFormatter by boxplot resulted in subsequent format()
# successfully calling this and messing up the ticks for some reason.
# So avoid using this when possible, and try to make behavior consistent
# by cacheing the locators before we use them for ticks.
axis = getattr(self, x + 'axis')
sides = ('bottom', 'top') if x == 'x' else ('left', 'right')
bounds = tuple(tuple(self.spines[side].get_bounds() or ()) for side in sides)
if fixticks or any(bounds) or axis.get_scale() == 'cutoff':
# Major locator
lim = bounds[0] or bounds[1] or getattr(self, 'get_' + x + 'lim')()
locator = getattr(axis, '_major_locator_cached', None)
if locator is None:
locator = axis._major_locator_cached = axis.get_major_locator()
locator = constructor.Locator([x for x in locator() if lim[0] <= x <= lim[1]]) # noqa: E501
axis.set_major_locator(locator)
# Minor locator
locator = getattr(axis, '_minor_locator_cached', None)
if locator is None:
locator = axis._minor_locator_cached = axis.get_minor_locator()
locator = constructor.Locator([x for x in locator() if lim[0] <= x <= lim[1]]) # noqa: E501
axis.set_minor_locator(locator)
def _update_formatter(
self, x, formatter=None, *, formatter_kw=None,
tickrange=None, wraprange=None,
):
"""
Update the axis formatter. Passes `formatter` through `Formatter` with kwargs.
"""
# Is this a date axis?
# NOTE: Make sure to get this *after* lims set!
# See: https://matplotlib.org/api/units_api.html
# And: https://matplotlib.org/api/dates_api.html
# Also see: https://github.com/matplotlib/matplotlib/blob/master/lib/matplotlib/axis.py # noqa
# The axis_date() method just applies DateConverter
axis = getattr(self, x + 'axis')
date = isinstance(axis.converter, mdates.DateConverter)
# Major formatter
# NOTE: The only reliable way to disable ticks labels and then
# restore them is by messing with the *formatter*, rather than
# setting labelleft=False, labelright=False, etc.
formatter_kw = formatter_kw or {}
formatter_kw = formatter_kw.copy()
if formatter is not None or tickrange is not None or wraprange is not None:
# Tick range
if tickrange is not None or wraprange is not None:
if formatter not in (None, 'auto'):
warnings._warn_proplot(
'The tickrange and autorange features require '
'proplot.AutoFormatter formatter. Overriding the input.'
)
formatter = 'auto'
if tickrange is not None:
formatter_kw.setdefault('tickrange', tickrange)
if wraprange is not None:
formatter_kw.setdefault('wraprange', wraprange)
# Set the formatter
# Note some formatters require 'locator' as keyword arg
if formatter in ('date', 'concise'):
locator = axis.get_major_locator()
formatter_kw.setdefault('locator', locator)
formatter = constructor.Formatter(formatter, date=date, **formatter_kw)
axis.set_major_formatter(formatter)
def _update_labels(self, x, *, label=None, color=None, **kwargs):
"""
Apply axis labels to the relevant shared axis. If spanning labels are toggled
this keeps the labels synced for all subplots in the same row or column. Label
positions will be adjusted at draw-time with figure._align_axislabels.
"""
# First get settings
kw = rc.fill(
{
'color': 'axes.labelcolor',
'weight': 'axes.labelweight',
'fontsize': 'axes.labelsize',
'fontfamily': 'font.family',
},
context=True,
)
if label is not None:
kw['text'] = label
if color:
kw['color'] = color
kw.update(kwargs)
if not kw:
return
# Get axes in 3 step process
# 1. Walk to parent if it is a main axes
# 2. Get spanning main axes in this row or column (ignore short panel edges)
# 3. Walk to parent if it exists (may be a panel long edge)
# NOTE: Initially we keep spanning labels off
# NOTE: Axis sharing between "main" axes is only ever one level deep.
# NOTE: Critical to apply labels to *shared* axes attributes rather
# than testing extents or we end up sharing labels with twin axes.
ax = self
if getattr(self.figure, '_share' + x) > 0:
share = getattr(ax, '_share' + x) or ax
if not share._panel_parent:
ax = share
# Get spanning axes
axs = [ax]
if getattr(ax.figure, '_span' + x):
side = getattr(self, x + 'axis').get_label_position()
if side in ('left', 'bottom'):
axs = ax._get_side_axes(side, panels=False)
# Update axes with label
for ax in axs:
ax = getattr(ax, '_share' + x) or ax # defer to panel
axis = getattr(ax, x + 'axis')
axis.label.update(kw)
def _update_locators(
self, x, locator=None, minorlocator=None, *,
tickminor=None, locator_kw=None, minorlocator_kw=None,
):
"""
Update the locators. Requires `Locator` instances.
"""
# Major locator
# NOTE: Parts of API (dualxy) rely on minor tick toggling preserving the
# isDefault_minloc setting. In future should override mpl minorticks_on()
# NOTE: Unlike matplotlib when "turning on" minor ticks we *always* use the
# scale default, thanks to scale classes refactoring with _ScaleBase.
axis = getattr(self, x + 'axis')
locator_kw = locator_kw or {}
if locator is not None:
locator = constructor.Locator(locator, **locator_kw)
if locator is not None:
axis.set_major_locator(locator)
if isinstance(locator, mticker.IndexLocator):
tickminor = False # 'index' minor ticks make no sense
# Minor locator
minorlocator_kw = minorlocator_kw or {}
if minorlocator is not None:
minorlocator = constructor.Locator(minorlocator, **minorlocator_kw)
if tickminor or minorlocator:
isdefault = minorlocator is None
if isdefault:
minorlocator = getattr(axis._scale, '_default_minor_locator', None)
if not minorlocator:
minorlocator = constructor.Locator('minor')
axis.set_minor_locator(minorlocator)
axis.isDefault_minloc = isdefault
elif tickminor is not None and not tickminor:
# NOTE: Generally if you *enable* minor ticks on a dual axis, want to
# allow FuncScale updates to change the minor tick locators. If you
# *disable* minor ticks, do not want FuncScale applications to turn them
# on. So we allow below to set isDefault_minloc to False.
axis.set_minor_locator(constructor.Locator('null'))
def _update_limits(self, x, *, min_=None, max_=None, lim=None, reverse=None):
"""
Update the axis limits.
"""
# Set limits for just one side or both at once
axis = getattr(self, x + 'axis')
if min_ is not None or max_ is not None:
if lim is not None:
warnings._warn_proplot(
f'Overriding {x}lim={lim!r} '
f'with {x}min={min_!r} and {x}max={max_!r}.'
)
lim = (min_, max_)
if lim is not None:
getattr(self, 'set_' + x + 'lim')(lim)
# Reverse direction
# NOTE: 3.1+ has axis.set_inverted(), below is from source code
if reverse is not None:
lo, hi = axis.get_view_interval()
if reverse:
lim = (max(lo, hi), min(lo, hi))
else:
lim = (min(lo, hi), max(lo, hi))
axis.set_view_interval(*lim, ignore=True)
def _update_spines(self, x, *, loc='both', bounds=None, color=None, linewidth=None):
"""
Update the spine settings.
"""
# Get rc properties
kw = rc.fill(
{
'color': 'axes.edgecolor',
'linewidth': 'axes.linewidth',
},
context=True,
)
if color is not None:
kw['color'] = color
if linewidth is not None:
kw['linewidth'] = linewidth
# Iterate over spines associated with this axis
sides = ('bottom', 'top') if x == 'x' else ('left', 'right')
for side in sides:
# Line properties. Override if we're settings spine bounds
# In this case just have spines on edges by default
spine = self.spines[side]
if bounds is not None and loc not in sides:
loc = sides[0]
# Eliminate sides
if loc == 'neither':
spine.set_visible(False)
elif loc == 'both':
spine.set_visible(True)
elif loc in sides: # make relevant spine visible
spine.set_visible(side == loc)
# Special spine location, usually 'zero', 'center', or tuple with
# (units, location) where 'units' can be 'axes', 'data', or 'outward'
elif loc is not None:
if side == sides[1]:
spine.set_visible(False)
else:
spine.set_visible(True)
try:
spine.set_position(loc)
except ValueError:
raise ValueError(
f'Invalid {x} spine location {loc!r}. '
'Options are: '
+ ', '.join(map(
repr, (*sides, 'both', 'neither')
)) + '.'
)
# Apply spine bounds
if bounds is not None and spine.get_visible():
spine.set_bounds(*bounds)
spine.update(kw)
def _update_ticks(
self, x, *, grid=None, gridminor=None,
color=None, gridcolor=None, ticklen=None,
tickloc=None, ticklabelloc=None, labelloc=None,
tickdir=None, ticklabeldir=None, rotation=None,
):
"""
Update the ticks and gridlines.
"""
# Initial stuff
axis = getattr(self, x + 'axis')
sides = ('bottom', 'top') if x == 'x' else ('left', 'right')
sides_active = tuple(side for side in sides if self.spines[side].get_visible())
# Tick and grid settings for major and minor ticks separately
# Override is just a "new default", but user can override this
for which, igrid in zip(('major', 'minor'), (grid, gridminor)):
# Tick properties
# NOTE: This loads xtick.major.size, xtick.major.width,
# xtick.major.pad, xtick.major.bottom, and xtick.major.top
# For all the x/y major/minor tick types
kwticks = rc.category(x + 'tick.' + which, context=True)
if kwticks is None:
kwticks = {}
else:
kwticks.pop('visible', None) # invalid setting
if ticklen is not None:
kwticks['size'] = units(ticklen, 'pt')
if which == 'minor':
kwticks['size'] *= rc['tick.lenratio']
# Grid style and toggling
name = 'grid' if which == 'major' else 'gridminor'
if igrid is not None:
axis.grid(igrid, which=which)
kwgrid = rc.fill(
{
'grid_color': name + '.color',
'grid_alpha': name + '.alpha',
'grid_linewidth': name + '.linewidth',
'grid_linestyle': name + '.linestyle',
},
context=True,
)
if gridcolor is not None: # override for specific x/y axes
kwgrid['grid_color'] = gridcolor
axis.set_tick_params(which=which, **kwgrid, **kwticks)
# Tick and ticklabel properties that apply equally for major/minor lines
# Weird issue causes set_tick_params to reset/forget grid is turned on if
# you access tick.gridOn directly, instead of passing through tick_params.
# Since gridOn is undocumented feature, don't use it. So calling _format_axes
# a second time will remove the lines. First determine tick sides, avoiding
# situation where we draw ticks on top of invisible spine.
kw = {}
loc2sides = {
None: None,
'both': sides,
'none': (),
'neither': (),
}
if tickloc not in sides and any(self.spines[_].get_bounds() is not None for _ in sides): # noqa: E501
tickloc = sides[0] # override to just one side
ticklocs = loc2sides.get(tickloc, (tickloc,))
if ticklocs is not None:
kw.update({side: side in ticklocs for side in sides})
kw.update({side: False for side in sides if side not in sides_active})
# Tick label sides
# Will override to make sure only appear where ticks are
ticklabellocs = loc2sides.get(ticklabelloc, (ticklabelloc,))
if ticklabellocs is not None:
kw.update({'label' + side: (side in ticklabellocs) for side in sides})
kw.update(
{
'label' + side: False for side in sides
if side not in sides_active
or (ticklocs is not None and side not in ticklocs)
}
)
# The axis label side
if labelloc is None:
if ticklocs is not None:
options = tuple(
side for side in sides if side in ticklocs and side in sides_active
)
if len(options) == 1:
labelloc = options[0]
elif labelloc not in sides:
raise ValueError(
f'Got labelloc {labelloc!r}, valid options are '
+ ', '.join(map(repr, sides)) + '.'
)
# Apply
axis.set_tick_params(which='both', **kw)
if labelloc is not None:
axis.set_label_position(labelloc)
# Tick label settings
kw = rc.fill(
{
'labelcolor': 'tick.labelcolor', # new props
'labelsize': 'tick.labelsize',
'color': x + 'tick.color',
},
context=True,
)
if color:
kw['color'] = color
kw['labelcolor'] = color
# Tick label direction and rotation
if tickdir == 'in': # ticklabels should be much closer
kw['pad'] = 1.0
if ticklabeldir == 'in': # put tick labels inside the plot
tickdir = 'in'
kw['pad'] = -rc[f'{x}tick.major.size'] - rc[f'{x}tick.major.pad']
kw['pad'] -= rc._scale_font(rc[f'{x}tick.labelsize'])
if tickdir is not None:
kw['direction'] = tickdir
axis.set_tick_params(which='both', **kw)
# Settings that can't be controlled by set_tick_params
# Also set rotation and alignment here
kw = rc.fill(
{
'fontfamily': 'font.family',
'weight': 'tick.labelweight'
},
context=True,
)
if rotation is not None:
kw = {'rotation': rotation}
if x == 'x':
self._datex_rotated = True
if rotation not in (0, 90, -90):
kw['ha'] = ('right' if rotation > 0 else 'left')
for t in axis.get_ticklabels():
t.update(kw)
[docs] @docstring.add_snippets
def altx(self, **kwargs):
"""
%(axes.altx)s
"""
# NOTE: Cannot *wrap* twiny() because we want to use CartesianAxes, not
# matplotlib Axes. Instead use hidden method SubplotBase._make_twin_axes.
# WARNING: This repairs a matplotlib bug where twins fail to inherit the minor
# locator due to application of `AutoMinorLocator` when `ytick.minor.visible`
# is ``True`` in `Axes.cla` and due to the fact that passing ``sharey=self``
# to the alternate axes means that they share the same major and minor Tickers.
# >>> import matplotlib.pyplot as plt
# ... fig, ax = plt.subplots()
# ... ax.set_yscale('log')
# ... ax.twiny()
# WARNING: We add axes as children for tight layout algorithm convenience and
# to support eventual paradigm of arbitrarily many duplicates with spines
# arranged in an edge stack. However this means all artists drawn there take
# on zorder of their axes when drawn inside the "parent" (see Axes.draw()).
# To restore matplotlib behavior, which draws "child" artists on top simply
# because the axes was created after the "parent" one, use the inset_axes
# zorder of 4 and make the background transparent.
minorlocator = self.yaxis.get_minor_locator()
with self.figure._context_authorize_add_subplot():
ax = self._make_twin_axes(sharey=self, projection='proplot_cartesian')
# Child defaults
ax._altx_parent = self
ax.yaxis.set_minor_locator(minorlocator)
ax.yaxis.isDefault_minloc = True
for side, spine in ax.spines.items():
spine.set_visible(side == 'top')
ax.xaxis.tick_top()
ax.xaxis.set_label_position('top')
ax.yaxis.set_visible(False)
ax.patch.set_visible(False)
ax.grid(False)
ax.set_zorder(4)
ax.set_autoscaley_on(self.get_autoscaley_on())
# Parent defaults
self.spines['top'].set_visible(False)
self.spines['bottom'].set_visible(True)
self.xaxis.tick_bottom()
self.xaxis.set_label_position('bottom')
# Add axes
self.add_child_axes(ax) # to facilitate tight layout
self.figure._axstack.remove(ax) # or gets drawn twice!
ax.format(**_parse_alt('x', kwargs))
return ax
[docs] @docstring.add_snippets
def alty(self, **kwargs):
"""
%(axes.alty)s
"""
# See altx() comments
minorlocator = self.xaxis.get_minor_locator()
with self.figure._context_authorize_add_subplot():
ax = self._make_twin_axes(sharex=self, projection='proplot_cartesian')
# Child defaults
ax._alty_parent = self
ax.xaxis.set_minor_locator(minorlocator)
ax.xaxis.isDefault_minloc = True
for side, spine in ax.spines.items():
spine.set_visible(side == 'right')
ax.yaxis.tick_right()
ax.yaxis.set_label_position('right')
ax.xaxis.set_visible(False)
ax.patch.set_visible(False)
ax.grid(False)
ax.set_zorder(4)
ax.set_autoscalex_on(self.get_autoscalex_on())
# Parent defaults
self.spines['right'].set_visible(False)
self.spines['left'].set_visible(True)
self.yaxis.tick_left()
self.yaxis.set_label_position('left')
# Add axes
self.add_child_axes(ax) # to facilitate tight layout
self.figure._axstack.remove(ax) # or gets drawn twice!
ax.format(**_parse_alt('y', kwargs))
return ax
[docs] @docstring.add_snippets
def dualx(self, funcscale, **kwargs):
"""
%(axes.dualx)s
"""
# NOTE: Matplotlib 3.1 has a 'secondary axis' feature. For the time
# being, our version is more robust (see FuncScale) and simpler, since
# we do not create an entirely separate _SecondaryAxis class.
ax = self.altx(**kwargs)
ax._dualx_funcscale = funcscale
ax._dualx_scale()
return ax
[docs] @docstring.add_snippets
def dualy(self, funcscale, **kwargs):
"""
%(axes.dualy)s
"""
ax = self.alty(**kwargs)
ax._dualy_funcscale = funcscale
ax._dualy_scale()
return ax
def draw(self, renderer=None, *args, **kwargs):
# Perform extra post-processing steps
# NOTE: This mimics matplotlib API, which calls identical
# post-processing steps in both draw() and get_tightbbox()
self._dualx_scale()
self._dualy_scale()
self._datex_rotate()
self._apply_axis_sharing()
if self._inset_parent is not None and self._inset_zoom:
self.indicate_inset_zoom()
super().draw(renderer, *args, **kwargs)
def get_tightbbox(self, renderer, *args, **kwargs):
# Perform extra post-processing steps
self._dualx_scale()
self._dualy_scale()
self._datex_rotate()
self._apply_axis_sharing()
if self._inset_parent is not None and self._inset_zoom:
self.indicate_inset_zoom()
return super().get_tightbbox(renderer, *args, **kwargs)
[docs] @docstring.add_snippets
def twinx(self):
"""
%(axes.twinx)s
"""
return self.alty()
[docs] @docstring.add_snippets
def twiny(self):
"""
%(axes.twiny)s
"""
return self.altx()