def __init__(self, base, nonpositive='clip'):
super().__init__()
if base <= 0 or base == 1:
raise ValueError('The log base cannot be <= 0 or == 1')
self.base = base
self._clip = _api.check_getitem(
{"clip": True, "mask": False}, nonpositive=nonpositive)
def _set_transform(self):
self.set_transform(_api.check_getitem({
"data": self.Q.axes.transData,
"axes": self.Q.axes.transAxes,
"figure": self.Q.axes.figure.transFigure,
"inches": self.Q.axes.figure.dpi_scale_trans,
}, coordinates=self.coord))
def _mpl_to_gtk_cursor(mpl_cursor):
return _api.check_getitem({
Cursors.MOVE: "move",
Cursors.HAND: "pointer",
Cursors.POINTER: "default",
Cursors.SELECT_REGION: "crosshair",
Cursors.WAIT: "wait",
Cursors.RESIZE_HORIZONTAL: "ew-resize",
Cursors.RESIZE_VERTICAL: "ns-resize",
}, cursor=mpl_cursor)
def _dots_per_unit(self, units):
"""Return a scale factor for converting from units to pixels."""
bb = self.axes.bbox
vl = self.axes.viewLim
return _api.check_getitem({
'x': bb.width / vl.width,
'y': bb.height / vl.height,
'xy': np.hypot(*bb.size) / np.hypot(*vl.size),
'width': bb.width,
'height': bb.height,
'dots': 1.,
'inches': self.axes.figure.dpi,
}, units=units)
def _mpl_to_gtk_cursor(mpl_cursor):
name = _api.check_getitem(
{
Cursors.MOVE: "move",
Cursors.HAND: "pointer",
Cursors.POINTER: "default",
Cursors.SELECT_REGION: "crosshair",
Cursors.WAIT: "wait",
Cursors.RESIZE_HORIZONTAL: "ew-resize",
Cursors.RESIZE_VERTICAL: "ns-resize",
},
cursor=mpl_cursor)
return Gdk.Cursor.new_from_name(Gdk.Display.get_default(), name)
def set_axislabel_direction(self, label_direction):
r"""
Adjust the direction of the axislabel.
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 set_cursor(self, cursor):
# docstring inherited
cursor = _api.check_getitem(
{
backend_tools.Cursors.HAND: 'pointer',
backend_tools.Cursors.POINTER: 'default',
backend_tools.Cursors.SELECT_REGION: 'crosshair',
backend_tools.Cursors.MOVE: 'move',
backend_tools.Cursors.WAIT: 'wait',
backend_tools.Cursors.RESIZE_HORIZONTAL: 'ew-resize',
backend_tools.Cursors.RESIZE_VERTICAL: 'ns-resize',
},
cursor=cursor)
self.send_event('cursor', cursor=cursor)
def set_cursor(self, cursor):
# docstring inherited
cursor = wx.Cursor(
_api.check_getitem(
{
cursors.MOVE: wx.CURSOR_HAND,
cursors.HAND: wx.CURSOR_HAND,
cursors.POINTER: wx.CURSOR_ARROW,
cursors.SELECT_REGION: wx.CURSOR_CROSS,
cursors.WAIT: wx.CURSOR_WAIT,
cursors.RESIZE_HORIZONTAL: wx.CURSOR_SIZEWE,
cursors.RESIZE_VERTICAL: wx.CURSOR_SIZENS,
},
cursor=cursor))
self.SetCursor(cursor)
self.Refresh()
def _print_ps(self,
fmt,
outfile,
*args,
dpi=None,
metadata=None,
papertype=None,
orientation='portrait',
**kwargs):
if dpi is None: # always use this branch after deprecation elapses.
dpi = self.figure.get_dpi()
self.figure.set_dpi(72) # Override the dpi kwarg
dsc_comments = {}
if isinstance(outfile, (str, os.PathLike)):
filename = pathlib.Path(outfile).name
dsc_comments["Title"] = \
filename.encode("ascii", "replace").decode("ascii")
dsc_comments["Creator"] = (metadata or {}).get(
"Creator",
f"Matplotlib v{mpl.__version__}, https://matplotlib.org/")
# See https://reproducible-builds.org/specs/source-date-epoch/
source_date_epoch = os.getenv("SOURCE_DATE_EPOCH")
dsc_comments["CreationDate"] = (datetime.datetime.utcfromtimestamp(
int(source_date_epoch)).strftime("%a %b %d %H:%M:%S %Y")
if source_date_epoch else time.ctime())
dsc_comments = "\n".join(f"%%{k}: {v}"
for k, v in dsc_comments.items())
if papertype is None:
papertype = mpl.rcParams['ps.papersize']
papertype = papertype.lower()
_api.check_in_list(['auto', *papersize], papertype=papertype)
orientation = _api.check_getitem(_Orientation,
orientation=orientation.lower())
printer = (self._print_figure_tex
if mpl.rcParams['text.usetex'] else self._print_figure)
printer(fmt,
outfile,
dpi=dpi,
dsc_comments=dsc_comments,
orientation=orientation,
papertype=papertype,
**kwargs)
def scale_factory(scale, axis, **kwargs):
"""
Return a scale class by name.
Parameters
----------
scale : {%(names)s}
axis : `matplotlib.axis.Axis`
"""
if scale != scale.lower():
_api.warn_deprecated(
"3.5",
message="Support for case-insensitive scales is deprecated "
"since %(since)s and support will be removed %(removal)s.")
scale = scale.lower()
scale_cls = _api.check_getitem(_scale_mapping, scale=scale)
return scale_cls(axis, **kwargs)
def _parse_cached(self, s, dpi, prop):
if prop is None:
prop = FontProperties()
fontset_class = _api.check_getitem(self._font_type_mapping,
fontset=prop.get_math_fontfamily())
backend = self._backend_mapping[self._output]()
font_output = fontset_class(prop, backend)
fontsize = prop.get_size_in_points()
# This is a class variable so we don't rebuild the parser
# with each request.
if self._parser is None:
self.__class__._parser = _mathtext.Parser()
box = self._parser.parse(s, font_output, fontsize, dpi)
backend.set_canvas_size(*np.ceil([box.width, box.height, box.depth]))
return backend.get_results(box)
def __init__(self, value, units):
"""
Create a new UnitDbl object.
Units are internally converted to km, rad, and sec. The only
valid inputs for units are [m, km, mile, rad, deg, sec, min, hour].
The field UnitDbl.value will contain the converted value. Use
the convert() method to get a specific type of units back.
= ERROR CONDITIONS
- If the input units are not in the allowed list, an error is thrown.
= INPUT VARIABLES
- value The numeric value of the UnitDbl.
- units The string name of the units the value is in.
"""
data = _api.check_getitem(self.allowed, units=units)
self._value = float(value * data[0])
self._units = data[1]
def convert(self, units):
"""
Convert the UnitDbl to a specific set of units.
= ERROR CONDITIONS
- If the input units are not in the allowed list, an error is thrown.
= INPUT VARIABLES
- units The string name of the units to convert to.
= RETURN VALUE
- Returns the value of the UnitDbl in the requested units as a floating
point number.
"""
if self._units == units:
return self._value
data = _api.check_getitem(self.allowed, units=units)
if self._units != data[1]:
raise ValueError(f"Error trying to convert to different units.\n"
f" Invalid conversion requested.\n"
f" UnitDbl: {self}\n"
f" Units: {units}\n")
return self._value / data[0]
def __init__(self, ax, direction):
self._get_size = _api.check_getitem(self._get_size_map,
direction=direction)
self._ax_list = [ax] if isinstance(ax, Axes) else ax
def set_default_angle(self, d):
self.set_rotation(_api.check_getitem(self._default_angles, d=d))
def set_default_alignment(self, d):
va, ha = _api.check_getitem(self._default_alignments, d=d)
self.set_va(va)
self.set_ha(ha)
def __init__(
self, parent, handles, labels,
loc=None,
numpoints=None, # number of points in the legend line
markerscale=None, # relative size of legend markers vs. original
markerfirst=True, # left/right ordering of legend marker and label
scatterpoints=None, # number of scatter points
scatteryoffsets=None,
prop=None, # properties for the legend texts
fontsize=None, # keyword to set font size directly
labelcolor=None, # keyword to set the text color
# spacing & pad defined as a fraction of the font-size
borderpad=None, # whitespace inside the legend border
labelspacing=None, # vertical space between the legend entries
handlelength=None, # length of the legend handles
handleheight=None, # height of the legend handles
handletextpad=None, # pad between the legend handle and text
borderaxespad=None, # pad between the axes and legend border
columnspacing=None, # spacing between columns
ncol=1, # number of columns
mode=None, # horizontal distribution of columns: None or "expand"
fancybox=None, # True: fancy box, False: rounded box, None: rcParam
shadow=None,
title=None, # legend title
title_fontsize=None, # legend title font size
framealpha=None, # set frame alpha
edgecolor=None, # frame patch edgecolor
facecolor=None, # frame patch facecolor
bbox_to_anchor=None, # bbox to which the legend will be anchored
bbox_transform=None, # transform for the bbox
frameon=None, # draw frame
handler_map=None,
title_fontproperties=None, # properties for the legend title
):
"""
Parameters
----------
parent : `~matplotlib.axes.Axes` or `.Figure`
The artist that contains the legend.
handles : list of `.Artist`
A list of Artists (lines, patches) to be added to the legend.
labels : list of str
A list of labels to show next to the artists. The length of handles
and labels should be the same. If they are not, they are truncated
to the smaller of both lengths.
Other Parameters
----------------
%(_legend_kw_doc)s
Notes
-----
Users can specify any arbitrary location for the legend using the
*bbox_to_anchor* keyword argument. *bbox_to_anchor* can be a
`.BboxBase` (or derived there from) or a tuple of 2 or 4 floats.
See `set_bbox_to_anchor` for more detail.
The legend location can be specified by setting *loc* with a tuple of
2 floats, which is interpreted as the lower-left corner of the legend
in the normalized axes coordinate.
"""
# local import only to avoid circularity
from matplotlib.axes import Axes
from matplotlib.figure import FigureBase
super().__init__()
if prop is None:
if fontsize is not None:
self.prop = FontProperties(size=fontsize)
else:
self.prop = FontProperties(
size=mpl.rcParams["legend.fontsize"])
else:
self.prop = FontProperties._from_any(prop)
if isinstance(prop, dict) and "size" not in prop:
self.prop.set_size(mpl.rcParams["legend.fontsize"])
self._fontsize = self.prop.get_size_in_points()
self.texts = []
self.legendHandles = []
self._legend_title_box = None
#: A dictionary with the extra handler mappings for this Legend
#: instance.
self._custom_handler_map = handler_map
def val_or_rc(val, rc_name):
return val if val is not None else mpl.rcParams[rc_name]
self.numpoints = val_or_rc(numpoints, 'legend.numpoints')
self.markerscale = val_or_rc(markerscale, 'legend.markerscale')
self.scatterpoints = val_or_rc(scatterpoints, 'legend.scatterpoints')
self.borderpad = val_or_rc(borderpad, 'legend.borderpad')
self.labelspacing = val_or_rc(labelspacing, 'legend.labelspacing')
self.handlelength = val_or_rc(handlelength, 'legend.handlelength')
self.handleheight = val_or_rc(handleheight, 'legend.handleheight')
self.handletextpad = val_or_rc(handletextpad, 'legend.handletextpad')
self.borderaxespad = val_or_rc(borderaxespad, 'legend.borderaxespad')
self.columnspacing = val_or_rc(columnspacing, 'legend.columnspacing')
self.shadow = val_or_rc(shadow, 'legend.shadow')
# trim handles and labels if illegal label...
_lab, _hand = [], []
for label, handle in zip(labels, handles):
if isinstance(label, str) and label.startswith('_'):
_api.warn_external('The handle {!r} has a label of {!r} '
'which cannot be automatically added to'
' the legend.'.format(handle, label))
else:
_lab.append(label)
_hand.append(handle)
labels, handles = _lab, _hand
handles = list(handles)
if len(handles) < 2:
ncol = 1
self._ncol = ncol
if self.numpoints <= 0:
raise ValueError("numpoints must be > 0; it was %d" % numpoints)
# introduce y-offset for handles of the scatter plot
if scatteryoffsets is None:
self._scatteryoffsets = np.array([3. / 8., 4. / 8., 2.5 / 8.])
else:
self._scatteryoffsets = np.asarray(scatteryoffsets)
reps = self.scatterpoints // len(self._scatteryoffsets) + 1
self._scatteryoffsets = np.tile(self._scatteryoffsets,
reps)[:self.scatterpoints]
# _legend_box is a VPacker instance that contains all
# legend items and will be initialized from _init_legend_box()
# method.
self._legend_box = None
if isinstance(parent, Axes):
self.isaxes = True
self.axes = parent
self.set_figure(parent.figure)
elif isinstance(parent, FigureBase):
self.isaxes = False
self.set_figure(parent)
else:
raise TypeError(
"Legend needs either Axes or FigureBase as parent"
)
self.parent = parent
self._loc_used_default = loc is None
if loc is None:
loc = mpl.rcParams["legend.loc"]
if not self.isaxes and loc in [0, 'best']:
loc = 'upper right'
if isinstance(loc, str):
loc = _api.check_getitem(self.codes, loc=loc)
if not self.isaxes and loc == 0:
raise ValueError(
"Automatic legend placement (loc='best') not implemented for "
"figure legend")
self._mode = mode
self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
# We use FancyBboxPatch to draw a legend frame. The location
# and size of the box will be updated during the drawing time.
if facecolor is None:
facecolor = mpl.rcParams["legend.facecolor"]
if facecolor == 'inherit':
facecolor = mpl.rcParams["axes.facecolor"]
if edgecolor is None:
edgecolor = mpl.rcParams["legend.edgecolor"]
if edgecolor == 'inherit':
edgecolor = mpl.rcParams["axes.edgecolor"]
if fancybox is None:
fancybox = mpl.rcParams["legend.fancybox"]
self.legendPatch = FancyBboxPatch(
xy=(0, 0), width=1, height=1,
facecolor=facecolor, edgecolor=edgecolor,
# If shadow is used, default to alpha=1 (#8943).
alpha=(framealpha if framealpha is not None
else 1 if shadow
else mpl.rcParams["legend.framealpha"]),
# The width and height of the legendPatch will be set (in draw())
# to the length that includes the padding. Thus we set pad=0 here.
boxstyle=("round,pad=0,rounding_size=0.2" if fancybox
else "square,pad=0"),
mutation_scale=self._fontsize,
snap=True,
visible=(frameon if frameon is not None
else mpl.rcParams["legend.frameon"])
)
self._set_artist_props(self.legendPatch)
# init with null renderer
self._init_legend_box(handles, labels, markerfirst)
tmp = self._loc_used_default
self._set_loc(loc)
self._loc_used_default = tmp # ignore changes done by _set_loc
# figure out title font properties:
if title_fontsize is not None and title_fontproperties is not None:
raise ValueError(
"title_fontsize and title_fontproperties can't be specified "
"at the same time. Only use one of them. ")
title_prop_fp = FontProperties._from_any(title_fontproperties)
if isinstance(title_fontproperties, dict):
if "size" not in title_fontproperties:
title_fontsize = mpl.rcParams["legend.title_fontsize"]
title_prop_fp.set_size(title_fontsize)
elif title_fontsize is not None:
title_prop_fp.set_size(title_fontsize)
elif not isinstance(title_fontproperties, FontProperties):
title_fontsize = mpl.rcParams["legend.title_fontsize"]
title_prop_fp.set_size(title_fontsize)
self.set_title(title, prop=title_prop_fp)
self._draggable = None
# set the text color
color_getters = { # getter function depends on line or patch
'linecolor': ['get_color', 'get_facecolor'],
'markerfacecolor': ['get_markerfacecolor', 'get_facecolor'],
'mfc': ['get_markerfacecolor', 'get_facecolor'],
'markeredgecolor': ['get_markeredgecolor', 'get_edgecolor'],
'mec': ['get_markeredgecolor', 'get_edgecolor'],
}
if labelcolor is None:
if mpl.rcParams['legend.labelcolor'] is not None:
labelcolor = mpl.rcParams['legend.labelcolor']
else:
labelcolor = mpl.rcParams['text.color']
if isinstance(labelcolor, str) and labelcolor in color_getters:
getter_names = color_getters[labelcolor]
for handle, text in zip(self.legendHandles, self.texts):
for getter_name in getter_names:
try:
color = getattr(handle, getter_name)()
text.set_color(color)
break
except AttributeError:
pass
elif isinstance(labelcolor, str) and labelcolor == 'none':
for text in self.texts:
text.set_color(labelcolor)
elif np.iterable(labelcolor):
for text, color in zip(self.texts,
itertools.cycle(
colors.to_rgba_array(labelcolor))):
text.set_color(color)
else:
raise ValueError("Invalid argument for labelcolor : %s" %
str(labelcolor))
def set_cursor(self, cursor):
# docstring inherited
self.setCursor(_api.check_getitem(cursord, cursor=cursor))
def set_cursor(self, cursor):
# docstring inherited
cursor = wx.Cursor(_api.check_getitem(cursord, cursor=cursor))
self.SetCursor(cursor)
self.Update()
