| | """ |
| | The :mod:`.axis_artist` module implements custom artists to draw axis elements |
| | (axis lines and labels, tick lines and labels, grid lines). |
| | |
| | Axis lines and labels and tick lines and labels are managed by the `AxisArtist` |
| | class; grid lines are managed by the `GridlinesCollection` class. |
| | |
| | There is one `AxisArtist` per Axis; it can be accessed through |
| | the ``axis`` dictionary of the parent Axes (which should be a |
| | `mpl_toolkits.axislines.Axes`), e.g. ``ax.axis["bottom"]``. |
| | |
| | Children of the AxisArtist are accessed as attributes: ``.line`` and ``.label`` |
| | for the axis line and label, ``.major_ticks``, ``.major_ticklabels``, |
| | ``.minor_ticks``, ``.minor_ticklabels`` for the tick lines and labels (e.g. |
| | ``ax.axis["bottom"].line``). |
| | |
| | Children properties (colors, fonts, line widths, etc.) can be set using |
| | setters, e.g. :: |
| | |
| | # Make the major ticks of the bottom axis red. |
| | ax.axis["bottom"].major_ticks.set_color("red") |
| | |
| | However, things like the locations of ticks, and their ticklabels need to be |
| | changed from the side of the grid_helper. |
| | |
| | axis_direction |
| | -------------- |
| | |
| | `AxisArtist`, `AxisLabel`, `TickLabels` have an *axis_direction* attribute, |
| | which adjusts the location, angle, etc. The *axis_direction* must be one of |
| | "left", "right", "bottom", "top", and follows the Matplotlib convention for |
| | rectangular axis. |
| | |
| | For example, for the *bottom* axis (the left and right is relative to the |
| | direction of the increasing coordinate), |
| | |
| | * ticklabels and axislabel are on the right |
| | * ticklabels and axislabel have text angle of 0 |
| | * ticklabels are baseline, center-aligned |
| | * axislabel is top, center-aligned |
| | |
| | The text angles are actually relative to (90 + angle of the direction to the |
| | ticklabel), which gives 0 for bottom axis. |
| | |
| | =================== ====== ======== ====== ======== |
| | Property left bottom right top |
| | =================== ====== ======== ====== ======== |
| | ticklabel location left right right left |
| | axislabel location left right right left |
| | ticklabel angle 90 0 -90 180 |
| | axislabel angle 180 0 0 180 |
| | ticklabel va center baseline center baseline |
| | axislabel va center top center bottom |
| | ticklabel ha right center right center |
| | axislabel ha right center right center |
| | =================== ====== ======== ====== ======== |
| | |
| | Ticks are by default direct opposite side of the ticklabels. To make ticks to |
| | the same side of the ticklabels, :: |
| | |
| | ax.axis["bottom"].major_ticks.set_tick_out(True) |
| | |
| | The following attributes can be customized (use the ``set_xxx`` methods): |
| | |
| | * `Ticks`: ticksize, tick_out |
| | * `TickLabels`: pad |
| | * `AxisLabel`: pad |
| | """ |
| |
|
| | |
| | |
| |
|
| |
|
| | from operator import methodcaller |
| |
|
| | 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.text as mtext |
| | from matplotlib.collections import LineCollection |
| | from matplotlib.lines import Line2D |
| | from matplotlib.patches import PathPatch |
| | from matplotlib.path import Path |
| | from matplotlib.transforms import ( |
| | Affine2D, Bbox, IdentityTransform, ScaledTranslation) |
| |
|
| | from .axisline_style import AxislineStyle |
| |
|
| |
|
| | class AttributeCopier: |
| | def get_ref_artist(self): |
| | """ |
| | Return the underlying artist that actually defines some properties |
| | (e.g., color) of this artist. |
| | """ |
| | raise RuntimeError("get_ref_artist must overridden") |
| |
|
| | def get_attribute_from_ref_artist(self, attr_name): |
| | getter = methodcaller("get_" + attr_name) |
| | prop = getter(super()) |
| | return getter(self.get_ref_artist()) if prop == "auto" else prop |
| |
|
| |
|
| | class Ticks(AttributeCopier, Line2D): |
| | """ |
| | Ticks are derived from `.Line2D`, and note that ticks themselves |
| | are markers. Thus, you should use set_mec, set_mew, etc. |
| | |
| | To change the tick size (length), you need to use |
| | `set_ticksize`. To change the direction of the ticks (ticks are |
| | in opposite direction of ticklabels by default), use |
| | ``set_tick_out(False)`` |
| | """ |
| |
|
| | def __init__(self, ticksize, tick_out=False, *, axis=None, **kwargs): |
| | self._ticksize = ticksize |
| | self.locs_angles_labels = [] |
| |
|
| | self.set_tick_out(tick_out) |
| |
|
| | self._axis = axis |
| | if self._axis is not None: |
| | if "color" not in kwargs: |
| | kwargs["color"] = "auto" |
| | if "mew" not in kwargs and "markeredgewidth" not in kwargs: |
| | kwargs["markeredgewidth"] = "auto" |
| |
|
| | Line2D.__init__(self, [0.], [0.], **kwargs) |
| | self.set_snap(True) |
| |
|
| | def get_ref_artist(self): |
| | |
| | return self._axis.majorTicks[0].tick1line |
| |
|
| | def set_color(self, color): |
| | |
| | |
| | if not cbook._str_equal(color, "auto"): |
| | mcolors._check_color_like(color=color) |
| | self._color = color |
| | self.stale = True |
| |
|
| | def get_color(self): |
| | return self.get_attribute_from_ref_artist("color") |
| |
|
| | def get_markeredgecolor(self): |
| | return self.get_attribute_from_ref_artist("markeredgecolor") |
| |
|
| | def get_markeredgewidth(self): |
| | return self.get_attribute_from_ref_artist("markeredgewidth") |
| |
|
| | def set_tick_out(self, b): |
| | """Set whether ticks are drawn inside or outside the axes.""" |
| | self._tick_out = b |
| |
|
| | def get_tick_out(self): |
| | """Return whether ticks are drawn inside or outside the axes.""" |
| | return self._tick_out |
| |
|
| | def set_ticksize(self, ticksize): |
| | """Set length of the ticks in points.""" |
| | self._ticksize = ticksize |
| |
|
| | def get_ticksize(self): |
| | """Return length of the ticks in points.""" |
| | return self._ticksize |
| |
|
| | def set_locs_angles(self, locs_angles): |
| | self.locs_angles = locs_angles |
| |
|
| | _tickvert_path = Path([[0., 0.], [1., 0.]]) |
| |
|
| | def draw(self, renderer): |
| | if not self.get_visible(): |
| | return |
| |
|
| | gc = renderer.new_gc() |
| | gc.set_foreground(self.get_markeredgecolor()) |
| | gc.set_linewidth(self.get_markeredgewidth()) |
| | gc.set_alpha(self._alpha) |
| |
|
| | path_trans = self.get_transform() |
| | marker_transform = (Affine2D() |
| | .scale(renderer.points_to_pixels(self._ticksize))) |
| | if self.get_tick_out(): |
| | marker_transform.rotate_deg(180) |
| |
|
| | for loc, angle in self.locs_angles: |
| | locs = path_trans.transform_non_affine(np.array([loc])) |
| | if self.axes and not self.axes.viewLim.contains(*locs[0]): |
| | continue |
| | renderer.draw_markers( |
| | gc, self._tickvert_path, |
| | marker_transform + Affine2D().rotate_deg(angle), |
| | Path(locs), path_trans.get_affine()) |
| |
|
| | gc.restore() |
| |
|
| |
|
| | class LabelBase(mtext.Text): |
| | """ |
| | A base class for `.AxisLabel` and `.TickLabels`. The position and |
| | angle of the text are calculated by the offset_ref_angle, |
| | text_ref_angle, and offset_radius attributes. |
| | """ |
| |
|
| | def __init__(self, *args, **kwargs): |
| | self.locs_angles_labels = [] |
| | self._ref_angle = 0 |
| | self._offset_radius = 0. |
| |
|
| | super().__init__(*args, **kwargs) |
| |
|
| | self.set_rotation_mode("anchor") |
| | self._text_follow_ref_angle = True |
| |
|
| | @property |
| | def _text_ref_angle(self): |
| | if self._text_follow_ref_angle: |
| | return self._ref_angle + 90 |
| | else: |
| | return 0 |
| |
|
| | @property |
| | def _offset_ref_angle(self): |
| | return self._ref_angle |
| |
|
| | _get_opposite_direction = {"left": "right", |
| | "right": "left", |
| | "top": "bottom", |
| | "bottom": "top"}.__getitem__ |
| |
|
| | def draw(self, renderer): |
| | if not self.get_visible(): |
| | return |
| |
|
| | |
| | tr = self.get_transform() |
| | angle_orig = self.get_rotation() |
| | theta = np.deg2rad(self._offset_ref_angle) |
| | dd = self._offset_radius |
| | dx, dy = dd * np.cos(theta), dd * np.sin(theta) |
| |
|
| | self.set_transform(tr + Affine2D().translate(dx, dy)) |
| | self.set_rotation(self._text_ref_angle + angle_orig) |
| | super().draw(renderer) |
| | |
| | self.set_transform(tr) |
| | self.set_rotation(angle_orig) |
| |
|
| | def get_window_extent(self, renderer=None): |
| | if renderer is None: |
| | renderer = self.figure._get_renderer() |
| |
|
| | |
| | tr = self.get_transform() |
| | angle_orig = self.get_rotation() |
| | theta = np.deg2rad(self._offset_ref_angle) |
| | dd = self._offset_radius |
| | dx, dy = dd * np.cos(theta), dd * np.sin(theta) |
| |
|
| | self.set_transform(tr + Affine2D().translate(dx, dy)) |
| | self.set_rotation(self._text_ref_angle + angle_orig) |
| | bbox = super().get_window_extent(renderer).frozen() |
| | |
| | self.set_transform(tr) |
| | self.set_rotation(angle_orig) |
| |
|
| | return bbox |
| |
|
| |
|
| | class AxisLabel(AttributeCopier, LabelBase): |
| | """ |
| | Axis label. Derived from `.Text`. The position of the text is updated |
| | in the fly, so changing text position has no effect. Otherwise, the |
| | properties can be changed as a normal `.Text`. |
| | |
| | To change the pad between tick labels and axis label, use `set_pad`. |
| | """ |
| |
|
| | def __init__(self, *args, axis_direction="bottom", axis=None, **kwargs): |
| | self._axis = axis |
| | self._pad = 5 |
| | self._external_pad = 0 |
| | LabelBase.__init__(self, *args, **kwargs) |
| | self.set_axis_direction(axis_direction) |
| |
|
| | def set_pad(self, pad): |
| | """ |
| | Set the internal pad in points. |
| | |
| | The actual pad will be the sum of the internal pad and the |
| | external pad (the latter is set automatically by the `.AxisArtist`). |
| | |
| | Parameters |
| | ---------- |
| | pad : float |
| | The internal pad in points. |
| | """ |
| | self._pad = pad |
| |
|
| | def get_pad(self): |
| | """ |
| | Return the internal pad in points. |
| | |
| | See `.set_pad` for more details. |
| | """ |
| | return self._pad |
| |
|
| | def get_ref_artist(self): |
| | |
| | return self._axis.get_label() |
| |
|
| | def get_text(self): |
| | |
| | t = super().get_text() |
| | if t == "__from_axes__": |
| | return self._axis.get_label().get_text() |
| | return self._text |
| |
|
| | _default_alignments = dict(left=("bottom", "center"), |
| | right=("top", "center"), |
| | bottom=("top", "center"), |
| | top=("bottom", "center")) |
| |
|
| | def set_default_alignment(self, d): |
| | """ |
| | Set the default alignment. See `set_axis_direction` for details. |
| | |
| | Parameters |
| | ---------- |
| | d : {"left", "bottom", "right", "top"} |
| | """ |
| | va, ha = _api.check_getitem(self._default_alignments, d=d) |
| | self.set_va(va) |
| | self.set_ha(ha) |
| |
|
| | _default_angles = dict(left=180, |
| | right=0, |
| | bottom=0, |
| | top=180) |
| |
|
| | def set_default_angle(self, d): |
| | """ |
| | Set the default angle. See `set_axis_direction` for details. |
| | |
| | Parameters |
| | ---------- |
| | d : {"left", "bottom", "right", "top"} |
| | """ |
| | self.set_rotation(_api.check_getitem(self._default_angles, d=d)) |
| |
|
| | def set_axis_direction(self, d): |
| | """ |
| | Adjust the text angle and text alignment of axis label |
| | according to the matplotlib convention. |
| | |
| | ===================== ========== ========= ========== ========== |
| | Property left bottom right top |
| | ===================== ========== ========= ========== ========== |
| | axislabel angle 180 0 0 180 |
| | axislabel va center top center bottom |
| | axislabel ha right center right center |
| | ===================== ========== ========= ========== ========== |
| | |
| | Note that the text angles are actually relative to (90 + angle |
| | of the direction to the ticklabel), which gives 0 for bottom |
| | axis. |
| | |
| | Parameters |
| | ---------- |
| | d : {"left", "bottom", "right", "top"} |
| | """ |
| | self.set_default_alignment(d) |
| | self.set_default_angle(d) |
| |
|
| | def get_color(self): |
| | return self.get_attribute_from_ref_artist("color") |
| |
|
| | def draw(self, renderer): |
| | if not self.get_visible(): |
| | return |
| |
|
| | self._offset_radius = \ |
| | self._external_pad + renderer.points_to_pixels(self.get_pad()) |
| |
|
| | super().draw(renderer) |
| |
|
| | def get_window_extent(self, renderer=None): |
| | if renderer is None: |
| | renderer = self.figure._get_renderer() |
| | if not self.get_visible(): |
| | return |
| |
|
| | r = self._external_pad + renderer.points_to_pixels(self.get_pad()) |
| | self._offset_radius = r |
| |
|
| | bb = super().get_window_extent(renderer) |
| |
|
| | return bb |
| |
|
| |
|
| | class TickLabels(AxisLabel): |
| | """ |
| | Tick labels. While derived from `.Text`, this single artist draws all |
| | ticklabels. As in `.AxisLabel`, the position of the text is updated |
| | in the fly, so changing text position has no effect. Otherwise, |
| | the properties can be changed as a normal `.Text`. Unlike the |
| | ticklabels of the mainline Matplotlib, properties of a single |
| | ticklabel alone cannot be modified. |
| | |
| | To change the pad between ticks and ticklabels, use `~.AxisLabel.set_pad`. |
| | """ |
| |
|
| | def __init__(self, *, axis_direction="bottom", **kwargs): |
| | super().__init__(**kwargs) |
| | self.set_axis_direction(axis_direction) |
| | self._axislabel_pad = 0 |
| |
|
| | def get_ref_artist(self): |
| | |
| | return self._axis.get_ticklabels()[0] |
| |
|
| | def set_axis_direction(self, label_direction): |
| | """ |
| | Adjust the text angle and text alignment of ticklabels |
| | according to the Matplotlib convention. |
| | |
| | The *label_direction* must be one of [left, right, bottom, top]. |
| | |
| | ===================== ========== ========= ========== ========== |
| | Property left bottom right top |
| | ===================== ========== ========= ========== ========== |
| | ticklabel angle 90 0 -90 180 |
| | ticklabel va center baseline center baseline |
| | ticklabel ha right center right center |
| | ===================== ========== ========= ========== ========== |
| | |
| | Note that the text angles are actually relative to (90 + angle |
| | of the direction to the ticklabel), which gives 0 for bottom |
| | axis. |
| | |
| | Parameters |
| | ---------- |
| | label_direction : {"left", "bottom", "right", "top"} |
| | |
| | """ |
| | self.set_default_alignment(label_direction) |
| | self.set_default_angle(label_direction) |
| | self._axis_direction = label_direction |
| |
|
| | def invert_axis_direction(self): |
| | label_direction = self._get_opposite_direction(self._axis_direction) |
| | self.set_axis_direction(label_direction) |
| |
|
| | def _get_ticklabels_offsets(self, renderer, label_direction): |
| | """ |
| | Calculate the ticklabel offsets from the tick and their total heights. |
| | |
| | The offset only takes account the offset due to the vertical alignment |
| | of the ticklabels: if axis direction is bottom and va is 'top', it will |
| | return 0; if va is 'baseline', it will return (height-descent). |
| | """ |
| | whd_list = self.get_texts_widths_heights_descents(renderer) |
| |
|
| | if not whd_list: |
| | return 0, 0 |
| |
|
| | r = 0 |
| | va, ha = self.get_va(), self.get_ha() |
| |
|
| | if label_direction == "left": |
| | pad = max(w for w, h, d in whd_list) |
| | if ha == "left": |
| | r = pad |
| | elif ha == "center": |
| | r = .5 * pad |
| | elif label_direction == "right": |
| | pad = max(w for w, h, d in whd_list) |
| | if ha == "right": |
| | r = pad |
| | elif ha == "center": |
| | r = .5 * pad |
| | elif label_direction == "bottom": |
| | pad = max(h for w, h, d in whd_list) |
| | if va == "bottom": |
| | r = pad |
| | elif va == "center": |
| | r = .5 * pad |
| | elif va == "baseline": |
| | max_ascent = max(h - d for w, h, d in whd_list) |
| | max_descent = max(d for w, h, d in whd_list) |
| | r = max_ascent |
| | pad = max_ascent + max_descent |
| | elif label_direction == "top": |
| | pad = max(h for w, h, d in whd_list) |
| | if va == "top": |
| | r = pad |
| | elif va == "center": |
| | r = .5 * pad |
| | elif va == "baseline": |
| | max_ascent = max(h - d for w, h, d in whd_list) |
| | max_descent = max(d for w, h, d in whd_list) |
| | r = max_descent |
| | pad = max_ascent + max_descent |
| |
|
| | |
| | |
| | |
| | return r, pad |
| |
|
| | _default_alignments = dict(left=("center", "right"), |
| | right=("center", "left"), |
| | bottom=("baseline", "center"), |
| | top=("baseline", "center")) |
| |
|
| | _default_angles = dict(left=90, |
| | right=-90, |
| | bottom=0, |
| | top=180) |
| |
|
| | def draw(self, renderer): |
| | if not self.get_visible(): |
| | self._axislabel_pad = self._external_pad |
| | return |
| |
|
| | r, total_width = self._get_ticklabels_offsets(renderer, |
| | self._axis_direction) |
| |
|
| | pad = self._external_pad + renderer.points_to_pixels(self.get_pad()) |
| | self._offset_radius = r + pad |
| |
|
| | for (x, y), a, l in self._locs_angles_labels: |
| | if not l.strip(): |
| | continue |
| | self._ref_angle = a |
| | self.set_x(x) |
| | self.set_y(y) |
| | self.set_text(l) |
| | LabelBase.draw(self, renderer) |
| |
|
| | |
| | self._axislabel_pad = total_width + pad |
| |
|
| | def set_locs_angles_labels(self, locs_angles_labels): |
| | self._locs_angles_labels = locs_angles_labels |
| |
|
| | def get_window_extents(self, renderer=None): |
| | if renderer is None: |
| | renderer = self.figure._get_renderer() |
| |
|
| | if not self.get_visible(): |
| | self._axislabel_pad = self._external_pad |
| | return [] |
| |
|
| | bboxes = [] |
| |
|
| | r, total_width = self._get_ticklabels_offsets(renderer, |
| | self._axis_direction) |
| |
|
| | pad = self._external_pad + renderer.points_to_pixels(self.get_pad()) |
| | self._offset_radius = r + pad |
| |
|
| | for (x, y), a, l in self._locs_angles_labels: |
| | self._ref_angle = a |
| | self.set_x(x) |
| | self.set_y(y) |
| | self.set_text(l) |
| | bb = LabelBase.get_window_extent(self, renderer) |
| | bboxes.append(bb) |
| |
|
| | |
| | self._axislabel_pad = total_width + pad |
| |
|
| | return bboxes |
| |
|
| | def get_texts_widths_heights_descents(self, renderer): |
| | """ |
| | Return a list of ``(width, height, descent)`` tuples for ticklabels. |
| | |
| | Empty labels are left out. |
| | """ |
| | whd_list = [] |
| | for _loc, _angle, label in self._locs_angles_labels: |
| | if not label.strip(): |
| | continue |
| | clean_line, ismath = self._preprocess_math(label) |
| | whd = renderer.get_text_width_height_descent( |
| | clean_line, self._fontproperties, ismath=ismath) |
| | whd_list.append(whd) |
| | return whd_list |
| |
|
| |
|
| | class GridlinesCollection(LineCollection): |
| | def __init__(self, *args, which="major", axis="both", **kwargs): |
| | """ |
| | Collection of grid lines. |
| | |
| | Parameters |
| | ---------- |
| | which : {"major", "minor"} |
| | Which grid to consider. |
| | axis : {"both", "x", "y"} |
| | Which axis to consider. |
| | *args, **kwargs : |
| | Passed to `.LineCollection`. |
| | """ |
| | self._which = which |
| | self._axis = axis |
| | super().__init__(*args, **kwargs) |
| | self.set_grid_helper(None) |
| |
|
| | def set_which(self, which): |
| | """ |
| | Select major or minor grid lines. |
| | |
| | Parameters |
| | ---------- |
| | which : {"major", "minor"} |
| | """ |
| | self._which = which |
| |
|
| | def set_axis(self, axis): |
| | """ |
| | Select axis. |
| | |
| | Parameters |
| | ---------- |
| | axis : {"both", "x", "y"} |
| | """ |
| | self._axis = axis |
| |
|
| | def set_grid_helper(self, grid_helper): |
| | """ |
| | Set grid helper. |
| | |
| | Parameters |
| | ---------- |
| | grid_helper : `.GridHelperBase` subclass |
| | """ |
| | self._grid_helper = grid_helper |
| |
|
| | def draw(self, renderer): |
| | if self._grid_helper is not None: |
| | self._grid_helper.update_lim(self.axes) |
| | gl = self._grid_helper.get_gridlines(self._which, self._axis) |
| | self.set_segments([np.transpose(l) for l in gl]) |
| | super().draw(renderer) |
| |
|
| |
|
| | class AxisArtist(martist.Artist): |
| | """ |
| | An artist which draws axis (a line along which the n-th axes coord |
| | is constant) line, ticks, tick labels, and axis label. |
| | """ |
| |
|
| | zorder = 2.5 |
| |
|
| | @property |
| | def LABELPAD(self): |
| | return self.label.get_pad() |
| |
|
| | @LABELPAD.setter |
| | def LABELPAD(self, v): |
| | self.label.set_pad(v) |
| |
|
| | def __init__(self, axes, |
| | helper, |
| | offset=None, |
| | axis_direction="bottom", |
| | **kwargs): |
| | """ |
| | Parameters |
| | ---------- |
| | axes : `mpl_toolkits.axisartist.axislines.Axes` |
| | helper : `~mpl_toolkits.axisartist.axislines.AxisArtistHelper` |
| | """ |
| | |
| |
|
| | super().__init__(**kwargs) |
| |
|
| | self.axes = axes |
| |
|
| | self._axis_artist_helper = helper |
| |
|
| | if offset is None: |
| | offset = (0, 0) |
| | self.offset_transform = ScaledTranslation( |
| | *offset, |
| | Affine2D().scale(1 / 72) |
| | + self.axes.figure.dpi_scale_trans) |
| |
|
| | if axis_direction in ["left", "right"]: |
| | self.axis = axes.yaxis |
| | else: |
| | self.axis = axes.xaxis |
| |
|
| | self._axisline_style = None |
| | self._axis_direction = axis_direction |
| |
|
| | self._init_line() |
| | self._init_ticks(**kwargs) |
| | self._init_offsetText(axis_direction) |
| | self._init_label() |
| |
|
| | |
| | self._ticklabel_add_angle = 0. |
| | self._axislabel_add_angle = 0. |
| | self.set_axis_direction(axis_direction) |
| |
|
| | |
| |
|
| | def set_axis_direction(self, axis_direction): |
| | """ |
| | Adjust the direction, text angle, and text alignment of tick labels |
| | and axis labels following the Matplotlib convention for the rectangle |
| | axes. |
| | |
| | The *axis_direction* must be one of [left, right, bottom, top]. |
| | |
| | ===================== ========== ========= ========== ========== |
| | Property left bottom right top |
| | ===================== ========== ========= ========== ========== |
| | ticklabel direction "-" "+" "+" "-" |
| | axislabel direction "-" "+" "+" "-" |
| | ticklabel angle 90 0 -90 180 |
| | ticklabel va center baseline center baseline |
| | ticklabel ha right center right center |
| | axislabel angle 180 0 0 180 |
| | axislabel va center top center bottom |
| | axislabel ha right center right center |
| | ===================== ========== ========= ========== ========== |
| | |
| | Note that the direction "+" and "-" are relative to the direction of |
| | the increasing coordinate. Also, the text angles are actually |
| | relative to (90 + angle of the direction to the ticklabel), |
| | which gives 0 for bottom axis. |
| | |
| | Parameters |
| | ---------- |
| | axis_direction : {"left", "bottom", "right", "top"} |
| | """ |
| | self.major_ticklabels.set_axis_direction(axis_direction) |
| | self.label.set_axis_direction(axis_direction) |
| | self._axis_direction = axis_direction |
| | if axis_direction in ["left", "top"]: |
| | self.set_ticklabel_direction("-") |
| | self.set_axislabel_direction("-") |
| | else: |
| | self.set_ticklabel_direction("+") |
| | self.set_axislabel_direction("+") |
| |
|
| | def set_ticklabel_direction(self, tick_direction): |
| | r""" |
| | Adjust the direction of the tick labels. |
| | |
| | Note that the *tick_direction*\s '+' and '-' are relative to the |
| | direction of the increasing coordinate. |
| | |
| | Parameters |
| | ---------- |
| | tick_direction : {"+", "-"} |
| | """ |
| | self._ticklabel_add_angle = _api.check_getitem( |
| | {"+": 0, "-": 180}, tick_direction=tick_direction) |
| |
|
| | def invert_ticklabel_direction(self): |
| | self._ticklabel_add_angle = (self._ticklabel_add_angle + 180) % 360 |
| | self.major_ticklabels.invert_axis_direction() |
| | self.minor_ticklabels.invert_axis_direction() |
| |
|
| | def set_axislabel_direction(self, label_direction): |
| | r""" |
| | Adjust the direction of the axis label. |
| | |
| | Note that the *label_direction*\s '+' and '-' are relative to the |
| | direction of the increasing coordinate. |
| | |
| | Parameters |
| | ---------- |
| | label_direction : {"+", "-"} |
| | """ |
| | self._axislabel_add_angle = _api.check_getitem( |
| | {"+": 0, "-": 180}, label_direction=label_direction) |
| |
|
| | def get_transform(self): |
| | return self.axes.transAxes + self.offset_transform |
| |
|
| | def get_helper(self): |
| | """ |
| | Return axis artist helper instance. |
| | """ |
| | return self._axis_artist_helper |
| |
|
| | def set_axisline_style(self, axisline_style=None, **kwargs): |
| | """ |
| | Set the axisline style. |
| | |
| | The new style is completely defined by the passed attributes. Existing |
| | style attributes are forgotten. |
| | |
| | Parameters |
| | ---------- |
| | axisline_style : str or None |
| | The line style, e.g. '->', optionally followed by a comma-separated |
| | list of attributes. Alternatively, the attributes can be provided |
| | as keywords. |
| | |
| | If *None* this returns a string containing the available styles. |
| | |
| | Examples |
| | -------- |
| | The following two commands are equal: |
| | |
| | >>> set_axisline_style("->,size=1.5") |
| | >>> set_axisline_style("->", size=1.5) |
| | """ |
| | if axisline_style is None: |
| | return AxislineStyle.pprint_styles() |
| |
|
| | if isinstance(axisline_style, AxislineStyle._Base): |
| | self._axisline_style = axisline_style |
| | else: |
| | self._axisline_style = AxislineStyle(axisline_style, **kwargs) |
| |
|
| | self._init_line() |
| |
|
| | def get_axisline_style(self): |
| | """Return the current axisline style.""" |
| | return self._axisline_style |
| |
|
| | def _init_line(self): |
| | """ |
| | Initialize the *line* artist that is responsible to draw the axis line. |
| | """ |
| | tran = (self._axis_artist_helper.get_line_transform(self.axes) |
| | + self.offset_transform) |
| |
|
| | axisline_style = self.get_axisline_style() |
| | if axisline_style is None: |
| | self.line = PathPatch( |
| | self._axis_artist_helper.get_line(self.axes), |
| | color=mpl.rcParams['axes.edgecolor'], |
| | fill=False, |
| | linewidth=mpl.rcParams['axes.linewidth'], |
| | capstyle=mpl.rcParams['lines.solid_capstyle'], |
| | joinstyle=mpl.rcParams['lines.solid_joinstyle'], |
| | transform=tran) |
| | else: |
| | self.line = axisline_style(self, transform=tran) |
| |
|
| | def _draw_line(self, renderer): |
| | self.line.set_path(self._axis_artist_helper.get_line(self.axes)) |
| | if self.get_axisline_style() is not None: |
| | self.line.set_line_mutation_scale(self.major_ticklabels.get_size()) |
| | self.line.draw(renderer) |
| |
|
| | def _init_ticks(self, **kwargs): |
| | axis_name = self.axis.axis_name |
| |
|
| | trans = (self._axis_artist_helper.get_tick_transform(self.axes) |
| | + self.offset_transform) |
| |
|
| | self.major_ticks = Ticks( |
| | kwargs.get( |
| | "major_tick_size", |
| | mpl.rcParams[f"{axis_name}tick.major.size"]), |
| | axis=self.axis, transform=trans) |
| | self.minor_ticks = Ticks( |
| | kwargs.get( |
| | "minor_tick_size", |
| | mpl.rcParams[f"{axis_name}tick.minor.size"]), |
| | axis=self.axis, transform=trans) |
| |
|
| | size = mpl.rcParams[f"{axis_name}tick.labelsize"] |
| | self.major_ticklabels = TickLabels( |
| | axis=self.axis, |
| | axis_direction=self._axis_direction, |
| | figure=self.axes.figure, |
| | transform=trans, |
| | fontsize=size, |
| | pad=kwargs.get( |
| | "major_tick_pad", mpl.rcParams[f"{axis_name}tick.major.pad"]), |
| | ) |
| | self.minor_ticklabels = TickLabels( |
| | axis=self.axis, |
| | axis_direction=self._axis_direction, |
| | figure=self.axes.figure, |
| | transform=trans, |
| | fontsize=size, |
| | pad=kwargs.get( |
| | "minor_tick_pad", mpl.rcParams[f"{axis_name}tick.minor.pad"]), |
| | ) |
| |
|
| | def _get_tick_info(self, tick_iter): |
| | """ |
| | Return a pair of: |
| | |
| | - list of locs and angles for ticks |
| | - list of locs, angles and labels for ticklabels. |
| | """ |
| | ticks_loc_angle = [] |
| | ticklabels_loc_angle_label = [] |
| |
|
| | ticklabel_add_angle = self._ticklabel_add_angle |
| |
|
| | for loc, angle_normal, angle_tangent, label in tick_iter: |
| | angle_label = angle_tangent - 90 + ticklabel_add_angle |
| | angle_tick = (angle_normal |
| | if 90 <= (angle_label - angle_normal) % 360 <= 270 |
| | else angle_normal + 180) |
| | ticks_loc_angle.append([loc, angle_tick]) |
| | ticklabels_loc_angle_label.append([loc, angle_label, label]) |
| |
|
| | return ticks_loc_angle, ticklabels_loc_angle_label |
| |
|
| | def _update_ticks(self, renderer=None): |
| | |
| | |
| |
|
| | if renderer is None: |
| | renderer = self.figure._get_renderer() |
| |
|
| | dpi_cor = renderer.points_to_pixels(1.) |
| | if self.major_ticks.get_visible() and self.major_ticks.get_tick_out(): |
| | ticklabel_pad = self.major_ticks._ticksize * dpi_cor |
| | self.major_ticklabels._external_pad = ticklabel_pad |
| | self.minor_ticklabels._external_pad = ticklabel_pad |
| | else: |
| | self.major_ticklabels._external_pad = 0 |
| | self.minor_ticklabels._external_pad = 0 |
| |
|
| | majortick_iter, minortick_iter = \ |
| | self._axis_artist_helper.get_tick_iterators(self.axes) |
| |
|
| | tick_loc_angle, ticklabel_loc_angle_label = \ |
| | self._get_tick_info(majortick_iter) |
| | self.major_ticks.set_locs_angles(tick_loc_angle) |
| | self.major_ticklabels.set_locs_angles_labels(ticklabel_loc_angle_label) |
| |
|
| | tick_loc_angle, ticklabel_loc_angle_label = \ |
| | self._get_tick_info(minortick_iter) |
| | self.minor_ticks.set_locs_angles(tick_loc_angle) |
| | self.minor_ticklabels.set_locs_angles_labels(ticklabel_loc_angle_label) |
| |
|
| | def _draw_ticks(self, renderer): |
| | self._update_ticks(renderer) |
| | self.major_ticks.draw(renderer) |
| | self.major_ticklabels.draw(renderer) |
| | self.minor_ticks.draw(renderer) |
| | self.minor_ticklabels.draw(renderer) |
| | if (self.major_ticklabels.get_visible() |
| | or self.minor_ticklabels.get_visible()): |
| | self._draw_offsetText(renderer) |
| |
|
| | _offsetText_pos = dict(left=(0, 1, "bottom", "right"), |
| | right=(1, 1, "bottom", "left"), |
| | bottom=(1, 0, "top", "right"), |
| | top=(1, 1, "bottom", "right")) |
| |
|
| | def _init_offsetText(self, direction): |
| | x, y, va, ha = self._offsetText_pos[direction] |
| | self.offsetText = mtext.Annotation( |
| | "", |
| | xy=(x, y), xycoords="axes fraction", |
| | xytext=(0, 0), textcoords="offset points", |
| | color=mpl.rcParams['xtick.color'], |
| | horizontalalignment=ha, verticalalignment=va, |
| | ) |
| | self.offsetText.set_transform(IdentityTransform()) |
| | self.axes._set_artist_props(self.offsetText) |
| |
|
| | def _update_offsetText(self): |
| | self.offsetText.set_text(self.axis.major.formatter.get_offset()) |
| | self.offsetText.set_size(self.major_ticklabels.get_size()) |
| | offset = (self.major_ticklabels.get_pad() |
| | + self.major_ticklabels.get_size() |
| | + 2) |
| | self.offsetText.xyann = (0, offset) |
| |
|
| | def _draw_offsetText(self, renderer): |
| | self._update_offsetText() |
| | self.offsetText.draw(renderer) |
| |
|
| | def _init_label(self, **kwargs): |
| | tr = (self._axis_artist_helper.get_axislabel_transform(self.axes) |
| | + self.offset_transform) |
| | self.label = AxisLabel( |
| | 0, 0, "__from_axes__", |
| | color="auto", |
| | fontsize=kwargs.get("labelsize", mpl.rcParams['axes.labelsize']), |
| | fontweight=mpl.rcParams['axes.labelweight'], |
| | axis=self.axis, |
| | transform=tr, |
| | axis_direction=self._axis_direction, |
| | ) |
| | self.label.set_figure(self.axes.figure) |
| | labelpad = kwargs.get("labelpad", 5) |
| | self.label.set_pad(labelpad) |
| |
|
| | def _update_label(self, renderer): |
| | if not self.label.get_visible(): |
| | return |
| |
|
| | if self._ticklabel_add_angle != self._axislabel_add_angle: |
| | if ((self.major_ticks.get_visible() |
| | and not self.major_ticks.get_tick_out()) |
| | or (self.minor_ticks.get_visible() |
| | and not self.major_ticks.get_tick_out())): |
| | axislabel_pad = self.major_ticks._ticksize |
| | else: |
| | axislabel_pad = 0 |
| | else: |
| | axislabel_pad = max(self.major_ticklabels._axislabel_pad, |
| | self.minor_ticklabels._axislabel_pad) |
| |
|
| | self.label._external_pad = axislabel_pad |
| |
|
| | xy, angle_tangent = \ |
| | self._axis_artist_helper.get_axislabel_pos_angle(self.axes) |
| | if xy is None: |
| | return |
| |
|
| | angle_label = angle_tangent - 90 |
| |
|
| | x, y = xy |
| | self.label._ref_angle = angle_label + self._axislabel_add_angle |
| | self.label.set(x=x, y=y) |
| |
|
| | def _draw_label(self, renderer): |
| | self._update_label(renderer) |
| | self.label.draw(renderer) |
| |
|
| | def set_label(self, s): |
| | |
| | self.label.set_text(s) |
| |
|
| | def get_tightbbox(self, renderer=None): |
| | if not self.get_visible(): |
| | return |
| | self._axis_artist_helper.update_lim(self.axes) |
| | self._update_ticks(renderer) |
| | self._update_label(renderer) |
| |
|
| | self.line.set_path(self._axis_artist_helper.get_line(self.axes)) |
| | if self.get_axisline_style() is not None: |
| | self.line.set_line_mutation_scale(self.major_ticklabels.get_size()) |
| |
|
| | bb = [ |
| | *self.major_ticklabels.get_window_extents(renderer), |
| | *self.minor_ticklabels.get_window_extents(renderer), |
| | self.label.get_window_extent(renderer), |
| | self.offsetText.get_window_extent(renderer), |
| | self.line.get_window_extent(renderer), |
| | ] |
| | bb = [b for b in bb if b and (b.width != 0 or b.height != 0)] |
| | if bb: |
| | _bbox = Bbox.union(bb) |
| | return _bbox |
| | else: |
| | return None |
| |
|
| | @martist.allow_rasterization |
| | def draw(self, renderer): |
| | |
| | if not self.get_visible(): |
| | return |
| | renderer.open_group(__name__, gid=self.get_gid()) |
| | self._axis_artist_helper.update_lim(self.axes) |
| | self._draw_ticks(renderer) |
| | self._draw_line(renderer) |
| | self._draw_label(renderer) |
| | renderer.close_group(__name__) |
| |
|
| | def toggle(self, all=None, ticks=None, ticklabels=None, label=None): |
| | """ |
| | Toggle visibility of ticks, ticklabels, and (axis) label. |
| | To turn all off, :: |
| | |
| | axis.toggle(all=False) |
| | |
| | To turn all off but ticks on :: |
| | |
| | axis.toggle(all=False, ticks=True) |
| | |
| | To turn all on but (axis) label off :: |
| | |
| | axis.toggle(all=True, label=False) |
| | |
| | """ |
| | if all: |
| | _ticks, _ticklabels, _label = True, True, True |
| | elif all is not None: |
| | _ticks, _ticklabels, _label = False, False, False |
| | else: |
| | _ticks, _ticklabels, _label = None, None, None |
| |
|
| | if ticks is not None: |
| | _ticks = ticks |
| | if ticklabels is not None: |
| | _ticklabels = ticklabels |
| | if label is not None: |
| | _label = label |
| |
|
| | if _ticks is not None: |
| | self.major_ticks.set_visible(_ticks) |
| | self.minor_ticks.set_visible(_ticks) |
| | if _ticklabels is not None: |
| | self.major_ticklabels.set_visible(_ticklabels) |
| | self.minor_ticklabels.set_visible(_ticklabels) |
| | if _label is not None: |
| | self.label.set_visible(_label) |
| |
|
