| from matplotlib import cbook |
| from matplotlib.artist import Artist |
|
|
|
|
| class Container(tuple): |
| """ |
| Base class for containers. |
| |
| Containers are classes that collect semantically related Artists such as |
| the bars of a bar plot. |
| """ |
|
|
| def __repr__(self): |
| return f"<{type(self).__name__} object of {len(self)} artists>" |
|
|
| def __new__(cls, *args, **kwargs): |
| return tuple.__new__(cls, args[0]) |
|
|
| def __init__(self, kl, label=None): |
| self._callbacks = cbook.CallbackRegistry(signals=["pchanged"]) |
| self._remove_method = None |
| self._label = str(label) if label is not None else None |
|
|
| def remove(self): |
| for c in cbook.flatten( |
| self, scalarp=lambda x: isinstance(x, Artist)): |
| if c is not None: |
| c.remove() |
| if self._remove_method: |
| self._remove_method(self) |
|
|
| def get_children(self): |
| return [child for child in cbook.flatten(self) if child is not None] |
|
|
| get_label = Artist.get_label |
| set_label = Artist.set_label |
| add_callback = Artist.add_callback |
| remove_callback = Artist.remove_callback |
| pchanged = Artist.pchanged |
|
|
|
|
| class BarContainer(Container): |
| """ |
| Container for the artists of bar plots (e.g. created by `.Axes.bar`). |
| |
| The container can be treated as a tuple of the *patches* themselves. |
| Additionally, you can access these and further parameters by the |
| attributes. |
| |
| Attributes |
| ---------- |
| patches : list of :class:`~matplotlib.patches.Rectangle` |
| The artists of the bars. |
| |
| errorbar : None or :class:`~matplotlib.container.ErrorbarContainer` |
| A container for the error bar artists if error bars are present. |
| *None* otherwise. |
| |
| datavalues : None or array-like |
| The underlying data values corresponding to the bars. |
| |
| orientation : {'vertical', 'horizontal'}, default: None |
| If 'vertical', the bars are assumed to be vertical. |
| If 'horizontal', the bars are assumed to be horizontal. |
| |
| """ |
|
|
| def __init__(self, patches, errorbar=None, *, datavalues=None, |
| orientation=None, **kwargs): |
| self.patches = patches |
| self.errorbar = errorbar |
| self.datavalues = datavalues |
| self.orientation = orientation |
| super().__init__(patches, **kwargs) |
|
|
|
|
| class ErrorbarContainer(Container): |
| """ |
| Container for the artists of error bars (e.g. created by `.Axes.errorbar`). |
| |
| The container can be treated as the *lines* tuple itself. |
| Additionally, you can access these and further parameters by the |
| attributes. |
| |
| Attributes |
| ---------- |
| lines : tuple |
| Tuple of ``(data_line, caplines, barlinecols)``. |
| |
| - data_line : A `~matplotlib.lines.Line2D` instance of x, y plot markers |
| and/or line. |
| - caplines : A tuple of `~matplotlib.lines.Line2D` instances of the error |
| bar caps. |
| - barlinecols : A tuple of `~matplotlib.collections.LineCollection` with the |
| horizontal and vertical error ranges. |
| |
| has_xerr, has_yerr : bool |
| ``True`` if the errorbar has x/y errors. |
| |
| """ |
|
|
| def __init__(self, lines, has_xerr=False, has_yerr=False, **kwargs): |
| self.lines = lines |
| self.has_xerr = has_xerr |
| self.has_yerr = has_yerr |
| super().__init__(lines, **kwargs) |
|
|
|
|
| class StemContainer(Container): |
| """ |
| Container for the artists created in a :meth:`.Axes.stem` plot. |
| |
| The container can be treated like a namedtuple ``(markerline, stemlines, |
| baseline)``. |
| |
| Attributes |
| ---------- |
| markerline : `~matplotlib.lines.Line2D` |
| The artist of the markers at the stem heads. |
| |
| stemlines : `~matplotlib.collections.LineCollection` |
| The artists of the vertical lines for all stems. |
| |
| baseline : `~matplotlib.lines.Line2D` |
| The artist of the horizontal baseline. |
| """ |
| def __init__(self, markerline_stemlines_baseline, **kwargs): |
| """ |
| Parameters |
| ---------- |
| markerline_stemlines_baseline : tuple |
| Tuple of ``(markerline, stemlines, baseline)``. |
| ``markerline`` contains the `.Line2D` of the markers, |
| ``stemlines`` is a `.LineCollection` of the main lines, |
| ``baseline`` is the `.Line2D` of the baseline. |
| """ |
| markerline, stemlines, baseline = markerline_stemlines_baseline |
| self.markerline = markerline |
| self.stemlines = stemlines |
| self.baseline = baseline |
| super().__init__(markerline_stemlines_baseline, **kwargs) |
|
|
