```python
import os
```

```python
from pathlib import Path
```

```python
Path(os.curdir).resolve()
```

    WindowsPath('C:/Users/owner/OneDrive/Documents/GitHub/gcv-lab')

```python
from copy import deepcopy
from io import StringIO
from math import *
import numpy as np
from pathlib import Path
import pickle
from pprint import pformat as pf, pprint as pp
import re
from sympy import *
init_printing()
import sys
import warnings
```

```python
os.listdir()
```

    ['.git',
     '.gitignore',
     '.ipynb_checkpoints',
     'data',
     'gc',
     'gcv',
     'LICENSE',
     'ncv',
     'notes',
     'README.md',
     'Untitled.ipynb']

```python
exec((Path('ncv/ncv/startup.py').read_text()))
```

    hello world

```python
ls()
```

    data  gc  gcv  LICENSE  ncv  notes  README.md  Untitled.ipynb

```python
! dir
```

     Volume in drive C has no label.
     Volume Serial Number is 8A3F-F6F5

     Directory of C:\Users\owner\OneDrive\Documents\GitHub\gcv-lab

    08/09/2020  04:51 PM    <DIR>          .
    08/09/2020  04:51 PM    <DIR>          ..
    08/02/2020  06:40 AM             1,928 .gitignore
    08/09/2020  04:51 PM    <DIR>          .ipynb_checkpoints
    08/02/2020  06:42 AM    <DIR>          data
    08/05/2020  03:43 AM    <DIR>          gc
    08/09/2020  02:57 PM    <DIR>          gcv
    08/02/2020  06:40 AM             1,089 LICENSE
    08/02/2020  07:03 AM    <DIR>          ncv
    08/09/2020  02:53 PM    <DIR>          notes
    08/02/2020  06:40 AM               109 README.md
    08/05/2020  04:17 AM             2,719 Untitled.ipynb
                   4 File(s)          5,845 bytes
                   8 Dir(s)  892,644,352,000 bytes free

```python
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import numpy as np
```

```python
fig = plt.figure()
ax = fig.gca(projection='3d')
nphi, nz = 12,20
r=1
phi = np.linspace(0, 360, nphi)/180.0*np.pi
z = np.linspace(0,1.0,nz)
print(z)
facecolors = ['r','g','b','y']
cols = []
verts2 = []
for i in range(len(phi)-1):
    cp0 = r*np.cos(phi[i])
    cp1 = r*np.cos(phi[i+1])
    sp0 = r*np.sin(phi[i])
    sp1 = r*np.sin(phi[i+1])

    for j in range(len(z)-1):
        z0=z[j]
        z1=z[j+1]
        verts=[]
        verts.append((cp0, sp0, z0))
        verts.append((cp1, sp1, z0))
        verts.append((cp1, sp1, z1))
        verts.append((cp0, sp0, z1))
        verts2.append(verts)
        value=np.random.rand()
        print(value)
        col = plt.cm.bwr(value)
        print(col)
        cols.append(col)

poly3 = Poly3DCollection(verts2, facecolor=cols)
poly3.set_alpha(0.8)
ax.add_collection3d(poly3)
ax.set_xlabel('X')
ax.set_xlim3d(-1,1)
ax.set_ylabel('Y')
ax.set_ylim3d(-1,1)
ax.set_zlabel('Z')
ax.set_zlim3d(0,1)
plt.show()
```

```python
[s for s in dir(mp3d.art3d) if not s.startswith('_')]
```

    ['Line3D',
     'Line3DCollection',
     'LineCollection',
     'Normalize',
     'Patch',
     'Patch3D',
     'Patch3DCollection',
     'PatchCollection',
     'Path3DCollection',
     'PathCollection',
     'PathPatch3D',
     'Poly3DCollection',
     'PolyCollection',
     'Text3D',
     'artist',
     'get_dir_vector',
     'juggle_axes',
     'line_2d_to_3d',
     'line_collection_2d_to_3d',
     'lines',
     'math',
     'mcolors',
     'mpath',
     'mtext',
     'np',
     'patch_2d_to_3d',
     'patch_collection_2d_to_3d',
     'pathpatch_2d_to_3d',
     'poly_collection_2d_to_3d',
     'proj3d',
     'rotate_axes',
     'text_2d_to_3d']

```python
help(mp3d.art3d.patch_2d_to_3d)
```

    Help on function patch_2d_to_3d in module mpl_toolkits.mplot3d.art3d:

    patch_2d_to_3d(patch, z=0, zdir='z')
        Convert a Patch to a Patch3D object.

```python
[s for s in dir(mp3d.art3d.Patch3DCollection) if not s.startswith('_')]
```

    ['add_callback',
     'add_checker',
     'autoscale',
     'autoscale_None',
     'axes',
     'changed',
     'check_update',
     'contains',
     'convert_xunits',
     'convert_yunits',
     'do_3d_projection',
     'draw',
     'findobj',
     'format_cursor_data',
     'get_agg_filter',
     'get_alpha',
     'get_animated',
     'get_array',
     'get_capstyle',
     'get_children',
     'get_clim',
     'get_clip_box',
     'get_clip_on',
     'get_clip_path',
     'get_cmap',
     'get_contains',
     'get_cursor_data',
     'get_dashes',
     'get_datalim',
     'get_ec',
     'get_edgecolor',
     'get_edgecolors',
     'get_facecolor',
     'get_facecolors',
     'get_fc',
     'get_figure',
     'get_fill',
     'get_gid',
     'get_hatch',
     'get_in_layout',
     'get_joinstyle',
     'get_label',
     'get_linestyle',
     'get_linestyles',
     'get_linewidth',
     'get_linewidths',
     'get_ls',
     'get_lw',
     'get_offset_position',
     'get_offset_transform',
     'get_offsets',
     'get_path_effects',
     'get_paths',
     'get_picker',
     'get_pickradius',
     'get_rasterized',
     'get_sketch_params',
     'get_snap',
     'get_tightbbox',
     'get_transform',
     'get_transformed_clip_path_and_affine',
     'get_transforms',
     'get_url',
     'get_urls',
     'get_visible',
     'get_window_extent',
     'get_zorder',
     'have_units',
     'is_transform_set',
     'mouseover',
     'pchanged',
     'pick',
     'pickable',
     'properties',
     'remove',
     'remove_callback',
     'set',
     'set_3d_properties',
     'set_aa',
     'set_agg_filter',
     'set_alpha',
     'set_animated',
     'set_antialiased',
     'set_antialiaseds',
     'set_array',
     'set_capstyle',
     'set_clim',
     'set_clip_box',
     'set_clip_on',
     'set_clip_path',
     'set_cmap',
     'set_color',
     'set_contains',
     'set_dashes',
     'set_ec',
     'set_edgecolor',
     'set_edgecolors',
     'set_facecolor',
     'set_facecolors',
     'set_fc',
     'set_figure',
     'set_gid',
     'set_hatch',
     'set_in_layout',
     'set_joinstyle',
     'set_label',
     'set_linestyle',
     'set_linestyles',
     'set_linewidth',
     'set_linewidths',
     'set_ls',
     'set_lw',
     'set_norm',
     'set_offset_position',
     'set_offsets',
     'set_path_effects',
     'set_paths',
     'set_picker',
     'set_pickradius',
     'set_rasterized',
     'set_sketch_params',
     'set_snap',
     'set_sort_zpos',
     'set_transform',
     'set_url',
     'set_urls',
     'set_visible',
     'set_zorder',
     'stale',
     'sticky_edges',
     'to_rgba',
     'update',
     'update_dict',
     'update_from',
     'update_scalarmappable',
     'zorder']

```python
help(ax.add_patch)
```

    Help on method add_patch in module matplotlib.axes._base:

    add_patch(p) method of matplotlib.axes._subplots.Axes3DSubplot instance
        Add a `~.Patch` to the axes' patches; return the patch.

```python
help(mp3d.art3d.Patch3DCollection)
```

    Help on class Patch3DCollection in module mpl_toolkits.mplot3d.art3d:

    class Patch3DCollection(matplotlib.collections.PatchCollection)
     |  Patch3DCollection(*args, zs=0, zdir='z', depthshade=True, **kwargs)
     |
     |  A collection of 3D patches.
     |
     |  Method resolution order:
     |      Patch3DCollection
     |      matplotlib.collections.PatchCollection
     |      matplotlib.collections.Collection
     |      matplotlib.artist.Artist
     |      matplotlib.cm.ScalarMappable
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, zs=0, zdir='z', depthshade=True, **kwargs)
     |      Create a collection of flat 3D patches with its normal vector
     |      pointed in *zdir* direction, and located at *zs* on the *zdir*
     |      axis. 'zs' can be a scalar or an array-like of the same length as
     |      the number of patches in the collection.
     |
     |      Constructor arguments are the same as for
     |      :class:`~matplotlib.collections.PatchCollection`. In addition,
     |      keywords *zs=0* and *zdir='z'* are available.
     |
     |      Also, the keyword argument "depthshade" is available to
     |      indicate whether or not to shade the patches in order to
     |      give the appearance of depth (default is *True*).
     |      This is typically desired in scatter plots.
     |
     |  do_3d_projection(self, renderer)
     |
     |  set_3d_properties(self, zs, zdir)
     |
     |  set_sort_zpos(self, val)
     |      Set the position to use for z-sorting.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from matplotlib.collections.PatchCollection:
     |
     |  set_paths(self, patches)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from matplotlib.collections.Collection:
     |
     |  contains(self, mouseevent)
     |      Test whether the mouse event occurred in the collection.
     |
     |      Returns ``bool, dict(ind=itemlist)``, where every item in itemlist
     |      contains the event.
     |
     |  draw(self, renderer)
     |      Draw the Artist (and its children) using the given renderer.
     |
     |      This has no effect if the artist is not visible (`.Artist.get_visible`
     |      returns False).
     |
     |      Parameters
     |      ----------
     |      renderer : `.RendererBase` subclass.
     |
     |      Notes
     |      -----
     |      This method is overridden in the Artist subclasses.
     |
     |  get_capstyle(self)
     |
     |  get_dashes(self)
     |      Alias for `get_linestyle`.
     |
     |  get_datalim(self, transData)
     |
     |  get_ec(self)
     |      Alias for `get_edgecolor`.
     |
     |  get_edgecolor(self)
     |
     |  get_edgecolors(self)
     |      Alias for `get_edgecolor`.
     |
     |  get_facecolor(self)
     |
     |  get_facecolors(self)
     |      Alias for `get_facecolor`.
     |
     |  get_fc(self)
     |      Alias for `get_facecolor`.
     |
     |  get_fill(self)
     |      Return whether fill is set.
     |
     |  get_hatch(self)
     |      Return the current hatching pattern.
     |
     |  get_joinstyle(self)
     |
     |  get_linestyle(self)
     |
     |  get_linestyles(self)
     |      Alias for `get_linestyle`.
     |
     |  get_linewidth(self)
     |
     |  get_linewidths(self)
     |      Alias for `get_linewidth`.
     |
     |  get_ls(self)
     |      Alias for `get_linestyle`.
     |
     |  get_lw(self)
     |      Alias for `get_linewidth`.
     |
     |  get_offset_position(self)
     |      [*Deprecated*] Return how offsets are applied for the collection.  If
     |      *offset_position* is 'screen', the offset is applied after the
     |      master transform has been applied, that is, the offsets are in
     |      screen coordinates.  If offset_position is 'data', the offset
     |      is applied before the master transform, i.e., the offsets are
     |      in data coordinates.
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  get_offset_transform(self)
     |
     |  get_offsets(self)
     |      Return the offsets for the collection.
     |
     |  get_paths(self)
     |
     |  get_pickradius(self)
     |
     |  get_transforms(self)
     |
     |  get_urls(self)
     |      Return a list of URLs, one for each element of the collection.
     |
     |      The list contains *None* for elements without a URL. See
     |      :doc:`/gallery/misc/hyperlinks_sgskip` for an example.
     |
     |  get_window_extent(self, renderer)
     |      Get the axes bounding box in display space.
     |
     |      The bounding box' width and height are nonnegative.
     |
     |      Subclasses should override for inclusion in the bounding box
     |      "tight" calculation. Default is to return an empty bounding
     |      box at 0, 0.
     |
     |      Be careful when using this function, the results will not update
     |      if the artist window extent of the artist changes.  The extent
     |      can change due to any changes in the transform stack, such as
     |      changing the axes limits, the figure size, or the canvas used
     |      (as is done when saving a figure).  This can lead to unexpected
     |      behavior where interactive figures will look fine on the screen,
     |      but will save incorrectly.
     |
     |  set_aa(self, aa)
     |      Alias for `set_antialiased`.
     |
     |  set_alpha(self, alpha)
     |      Set the alpha value used for blending - not supported on all backends.
     |
     |      Parameters
     |      ----------
     |      alpha : float or None
     |
     |  set_antialiased(self, aa)
     |      Set the antialiasing state for rendering.
     |
     |      Parameters
     |      ----------
     |      aa : bool or list of bools
     |
     |  set_antialiaseds(self, aa)
     |      Alias for `set_antialiased`.
     |
     |  set_capstyle(self, cs)
     |      Set the capstyle for the collection (for all its elements).
     |
     |      Parameters
     |      ----------
     |      cs : {'butt', 'round', 'projecting'}
     |          The capstyle.
     |
     |  set_color(self, c)
     |      Set both the edgecolor and the facecolor.
     |
     |      Parameters
     |      ----------
     |      c : color or list of rgba tuples
     |
     |      See Also
     |      --------
     |      Collection.set_facecolor, Collection.set_edgecolor
     |          For setting the edge or face color individually.
     |
     |  set_dashes(self, ls)
     |      Alias for `set_linestyle`.
     |
     |  set_ec(self, c)
     |      Alias for `set_edgecolor`.
     |
     |  set_edgecolor(self, c)
     |      Set the edgecolor(s) of the collection.
     |
     |      Parameters
     |      ----------
     |      c : color or list of colors or 'face'
     |          The collection edgecolor(s).  If a sequence, the patches cycle
     |          through it.  If 'face', match the facecolor.
     |
     |  set_edgecolors(self, c)
     |      Alias for `set_edgecolor`.
     |
     |  set_facecolor(self, c)
     |      Set the facecolor(s) of the collection. *c* can be a color (all patches
     |      have same color), or a sequence of colors; if it is a sequence the
     |      patches will cycle through the sequence.
     |
     |      If *c* is 'none', the patch will not be filled.
     |
     |      Parameters
     |      ----------
     |      c : color or list of colors
     |
     |  set_facecolors(self, c)
     |      Alias for `set_facecolor`.
     |
     |  set_fc(self, c)
     |      Alias for `set_facecolor`.
     |
     |  set_hatch(self, hatch)
     |      Set the hatching pattern
     |
     |      *hatch* can be one of::
     |
     |        /   - diagonal hatching
     |        \   - back diagonal
     |        |   - vertical
     |        -   - horizontal
     |        +   - crossed
     |        x   - crossed diagonal
     |        o   - small circle
     |        O   - large circle
     |        .   - dots
     |        *   - stars
     |
     |      Letters can be combined, in which case all the specified
     |      hatchings are done.  If same letter repeats, it increases the
     |      density of hatching of that pattern.
     |
     |      Hatching is supported in the PostScript, PDF, SVG and Agg
     |      backends only.
     |
     |      Unlike other properties such as linewidth and colors, hatching
     |      can only be specified for the collection as a whole, not separately
     |      for each member.
     |
     |      Parameters
     |      ----------
     |      hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
     |
     |  set_joinstyle(self, js)
     |      Set the joinstyle for the collection (for all its elements).
     |
     |      Parameters
     |      ----------
     |      js : {'miter', 'round', 'bevel'}
     |          The joinstyle.
     |
     |  set_linestyle(self, ls)
     |      Set the linestyle(s) for the collection.
     |
     |      ===========================   =================
     |      linestyle                     description
     |      ===========================   =================
     |      ``'-'`` or ``'solid'``        solid line
     |      ``'--'`` or  ``'dashed'``     dashed line
     |      ``'-.'`` or  ``'dashdot'``    dash-dotted line
     |      ``':'`` or ``'dotted'``       dotted line
     |      ===========================   =================
     |
     |      Alternatively a dash tuple of the following form can be provided::
     |
     |          (offset, onoffseq),
     |
     |      where ``onoffseq`` is an even length tuple of on and off ink in points.
     |
     |      Parameters
     |      ----------
     |      ls : str or tuple or list thereof
     |          Valid values for individual linestyles include {'-', '--', '-.',
     |          ':', '', (offset, on-off-seq)}. See `.Line2D.set_linestyle` for a
     |          complete description.
     |
     |  set_linestyles(self, ls)
     |      Alias for `set_linestyle`.
     |
     |  set_linewidth(self, lw)
     |      Set the linewidth(s) for the collection.  *lw* can be a scalar
     |      or a sequence; if it is a sequence the patches will cycle
     |      through the sequence
     |
     |      Parameters
     |      ----------
     |      lw : float or list of floats
     |
     |  set_linewidths(self, lw)
     |      Alias for `set_linewidth`.
     |
     |  set_ls(self, ls)
     |      Alias for `set_linestyle`.
     |
     |  set_lw(self, lw)
     |      Alias for `set_linewidth`.
     |
     |  set_offset_position(self, offset_position)
     |      [*Deprecated*] Set how offsets are applied.  If *offset_position* is 'screen'
     |      (default) the offset is applied after the master transform has
     |      been applied, that is, the offsets are in screen coordinates.
     |      If offset_position is 'data', the offset is applied before the
     |      master transform, i.e., the offsets are in data coordinates.
     |
     |      Parameters
     |      ----------
     |      offset_position : {'screen', 'data'}
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  set_offsets(self, offsets)
     |      Set the offsets for the collection.
     |
     |      Parameters
     |      ----------
     |      offsets : array-like (N, 2) or (2,)
     |
     |  set_pickradius(self, pr)
     |      Set the pick radius used for containment tests.
     |
     |      Parameters
     |      ----------
     |      d : float
     |          Pick radius, in points.
     |
     |  set_urls(self, urls)
     |      Parameters
     |      ----------
     |      urls : list of str or None
     |
     |      Notes
     |      -----
     |      URLs are currently only implemented by the SVG backend. They are
     |      ignored by all other backends.
     |
     |  update_from(self, other)
     |      Copy properties from other to self.
     |
     |  update_scalarmappable(self)
     |      Update colors from the scalar mappable array, if it is not None.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from matplotlib.artist.Artist:
     |
     |  __getstate__(self)
     |
     |  add_callback(self, func)
     |      Add a callback function that will be called whenever one of the
     |      `.Artist`'s properties changes.
     |
     |      Parameters
     |      ----------
     |      func : callable
     |          The callback function. It must have the signature::
     |
     |              def func(artist: Artist) -> Any
     |
     |          where *artist* is the calling `.Artist`. Return values may exist
     |          but are ignored.
     |
     |      Returns
     |      -------
     |      int
     |          The observer id associated with the callback. This id can be
     |          used for removing the callback with `.remove_callback` later.
     |
     |      See Also
     |      --------
     |      remove_callback
     |
     |  convert_xunits(self, x)
     |      Convert *x* using the unit type of the xaxis.
     |
     |      If the artist is not in contained in an Axes or if the xaxis does not
     |      have units, *x* itself is returned.
     |
     |  convert_yunits(self, y)
     |      Convert *y* using the unit type of the yaxis.
     |
     |      If the artist is not in contained in an Axes or if the yaxis does not
     |      have units, *y* itself is returned.
     |
     |  findobj(self, match=None, include_self=True)
     |      Find artist objects.
     |
     |      Recursively find all `.Artist` instances contained in the artist.
     |
     |      Parameters
     |      ----------
     |      match
     |          A filter criterion for the matches. This can be
     |
     |          - *None*: Return all objects contained in artist.
     |          - A function with signature ``def match(artist: Artist) -> bool``.
     |            The result will only contain artists for which the function
     |            returns *True*.
     |          - A class instance: e.g., `.Line2D`. The result will only contain
     |            artists of this class or its subclasses (``isinstance`` check).
     |
     |      include_self : bool
     |          Include *self* in the list to be checked for a match.
     |
     |      Returns
     |      -------
     |      list of `.Artist`
     |
     |  format_cursor_data(self, data)
     |      Return a string representation of *data*.
     |
     |      .. note::
     |          This method is intended to be overridden by artist subclasses.
     |          As an end-user of Matplotlib you will most likely not call this
     |          method yourself.
     |
     |      The default implementation converts ints and floats and arrays of ints
     |      and floats into a comma-separated string enclosed in square brackets.
     |
     |      See Also
     |      --------
     |      get_cursor_data
     |
     |  get_agg_filter(self)
     |      Return filter function to be used for agg filter.
     |
     |  get_alpha(self)
     |      Return the alpha value used for blending - not supported on all
     |      backends.
     |
     |  get_animated(self)
     |      Return whether the artist is animated.
     |
     |  get_children(self)
     |      Return a list of the child `.Artist`\s of this `.Artist`.
     |
     |  get_clip_box(self)
     |      Return the clipbox.
     |
     |  get_clip_on(self)
     |      Return whether the artist uses clipping.
     |
     |  get_clip_path(self)
     |      Return the clip path.
     |
     |  get_contains(self)
     |      [*Deprecated*] Return the custom contains function of the artist if set, or *None*.
     |
     |      See Also
     |      --------
     |      set_contains
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  get_cursor_data(self, event)
     |      Return the cursor data for a given event.
     |
     |      .. note::
     |          This method is intended to be overridden by artist subclasses.
     |          As an end-user of Matplotlib you will most likely not call this
     |          method yourself.
     |
     |      Cursor data can be used by Artists to provide additional context
     |      information for a given event. The default implementation just returns
     |      *None*.
     |
     |      Subclasses can override the method and return arbitrary data. However,
     |      when doing so, they must ensure that `.format_cursor_data` can convert
     |      the data to a string representation.
     |
     |      The only current use case is displaying the z-value of an `.AxesImage`
     |      in the status bar of a plot window, while moving the mouse.
     |
     |      Parameters
     |      ----------
     |      event : `matplotlib.backend_bases.MouseEvent`
     |
     |      See Also
     |      --------
     |      format_cursor_data
     |
     |  get_figure(self)
     |      Return the `.Figure` instance the artist belongs to.
     |
     |  get_gid(self)
     |      Return the group id.
     |
     |  get_in_layout(self)
     |      Return boolean flag, ``True`` if artist is included in layout
     |      calculations.
     |
     |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,
     |      `.Figure.tight_layout()`, and
     |      ``fig.savefig(fname, bbox_inches='tight')``.
     |
     |  get_label(self)
     |      Return the label used for this artist in the legend.
     |
     |  get_path_effects(self)
     |
     |  get_picker(self)
     |      Return the picking behavior of the artist.
     |
     |      The possible values are described in `.set_picker`.
     |
     |      See Also
     |      --------
     |      set_picker, pickable, pick
     |
     |  get_rasterized(self)
     |      Return whether the artist is to be rasterized.
     |
     |  get_sketch_params(self)
     |      Return the sketch parameters for the artist.
     |
     |      Returns
     |      -------
     |      tuple or None
     |
     |          A 3-tuple with the following elements:
     |
     |          - *scale*: The amplitude of the wiggle perpendicular to the
     |            source line.
     |          - *length*: The length of the wiggle along the line.
     |          - *randomness*: The scale factor by which the length is
     |            shrunken or expanded.
     |
     |          Returns *None* if no sketch parameters were set.
     |
     |  get_snap(self)
     |      Return the snap setting.
     |
     |      See `.set_snap` for details.
     |
     |  get_tightbbox(self, renderer)
     |      Like `.Artist.get_window_extent`, but includes any clipping.
     |
     |      Parameters
     |      ----------
     |      renderer : `.RendererBase` subclass
     |          renderer that will be used to draw the figures (i.e.
     |          ``fig.canvas.get_renderer()``)
     |
     |      Returns
     |      -------
     |      `.Bbox`
     |          The enclosing bounding box (in figure pixel coordinates).
     |
     |  get_transform(self)
     |      Return the `.Transform` instance used by this artist.
     |
     |  get_transformed_clip_path_and_affine(self)
     |      Return the clip path with the non-affine part of its
     |      transformation applied, and the remaining affine part of its
     |      transformation.
     |
     |  get_url(self)
     |      Return the url.
     |
     |  get_visible(self)
     |      Return the visibility.
     |
     |  get_zorder(self)
     |      Return the artist's zorder.
     |
     |  have_units(self)
     |      Return *True* if units are set on any axis.
     |
     |  is_transform_set(self)
     |      Return whether the Artist has an explicitly set transform.
     |
     |      This is *True* after `.set_transform` has been called.
     |
     |  pchanged(self)
     |      Call all of the registered callbacks.
     |
     |      This function is triggered internally when a property is changed.
     |
     |      See Also
     |      --------
     |      add_callback
     |      remove_callback
     |
     |  pick(self, mouseevent)
     |      Process a pick event.
     |
     |      Each child artist will fire a pick event if *mouseevent* is over
     |      the artist and the artist has picker set.
     |
     |      See Also
     |      --------
     |      set_picker, get_picker, pickable
     |
     |  pickable(self)
     |      Return whether the artist is pickable.
     |
     |      See Also
     |      --------
     |      set_picker, get_picker, pick
     |
     |  properties(self)
     |      Return a dictionary of all the properties of the artist.
     |
     |  remove(self)
     |      Remove the artist from the figure if possible.
     |
     |      The effect will not be visible until the figure is redrawn, e.g.,
     |      with `.FigureCanvasBase.draw_idle`.  Call `~.axes.Axes.relim` to
     |      update the axes limits if desired.
     |
     |      Note: `~.axes.Axes.relim` will not see collections even if the
     |      collection was added to the axes with *autolim* = True.
     |
     |      Note: there is no support for removing the artist's legend entry.
     |
     |  remove_callback(self, oid)
     |      Remove a callback based on its observer id.
     |
     |      See Also
     |      --------
     |      add_callback
     |
     |  set(self, **kwargs)
     |      A property batch setter.  Pass *kwargs* to set properties.
     |
     |  set_agg_filter(self, filter_func)
     |      Set the agg filter.
     |
     |      Parameters
     |      ----------
     |      filter_func : callable
     |          A filter function, which takes a (m, n, 3) float array and a dpi
     |          value, and returns a (m, n, 3) array.
     |
     |          .. ACCEPTS: a filter function, which takes a (m, n, 3) float array
     |              and a dpi value, and returns a (m, n, 3) array
     |
     |  set_animated(self, b)
     |      Set the artist's animation state.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_clip_box(self, clipbox)
     |      Set the artist's clip `.Bbox`.
     |
     |      Parameters
     |      ----------
     |      clipbox : `.Bbox`
     |
     |  set_clip_on(self, b)
     |      Set whether the artist uses clipping.
     |
     |      When False artists will be visible outside of the axes which
     |      can lead to unexpected results.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_clip_path(self, path, transform=None)
     |      Set the artist's clip path.
     |
     |      Parameters
     |      ----------
     |      path : `.Patch` or `.Path` or `.TransformedPath` or None
     |          The clip path. If given a `.Path`, *transform* must be provided as
     |          well. If *None*, a previously set clip path is removed.
     |      transform : `~matplotlib.transforms.Transform`, optional
     |          Only used if *path* is a `.Path`, in which case the given `.Path`
     |          is converted to a `.TransformedPath` using *transform*.
     |
     |      Notes
     |      -----
     |      For efficiency, if *path* is a `.Rectangle` this method will set the
     |      clipping box to the corresponding rectangle and set the clipping path
     |      to ``None``.
     |
     |      For technical reasons (support of `~.Artist.set`), a tuple
     |      (*path*, *transform*) is also accepted as a single positional
     |      parameter.
     |
     |      .. ACCEPTS: Patch or (Path, Transform) or None
     |
     |  set_contains(self, picker)
     |      [*Deprecated*] Define a custom contains test for the artist.
     |
     |      The provided callable replaces the default `.contains` method
     |      of the artist.
     |
     |      Parameters
     |      ----------
     |      picker : callable
     |          A custom picker function to evaluate if an event is within the
     |          artist. The function must have the signature::
     |
     |              def contains(artist: Artist, event: MouseEvent) -> bool, dict
     |
     |          that returns:
     |
     |          - a bool indicating if the event is within the artist
     |          - a dict of additional information. The dict should at least
     |            return the same information as the default ``contains()``
     |            implementation of the respective artist, but may provide
     |            additional information.
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  set_figure(self, fig)
     |      Set the `.Figure` instance the artist belongs to.
     |
     |      Parameters
     |      ----------
     |      fig : `.Figure`
     |
     |  set_gid(self, gid)
     |      Set the (group) id for the artist.
     |
     |      Parameters
     |      ----------
     |      gid : str
     |
     |  set_in_layout(self, in_layout)
     |      Set if artist is to be included in layout calculations,
     |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,
     |      `.Figure.tight_layout()`, and
     |      ``fig.savefig(fname, bbox_inches='tight')``.
     |
     |      Parameters
     |      ----------
     |      in_layout : bool
     |
     |  set_label(self, s)
     |      Set a label that will be displayed in the legend.
     |
     |      Parameters
     |      ----------
     |      s : object
     |          *s* will be converted to a string by calling `str`.
     |
     |  set_path_effects(self, path_effects)
     |      Set the path effects.
     |
     |      Parameters
     |      ----------
     |      path_effects : `.AbstractPathEffect`
     |
     |  set_picker(self, picker)
     |      Define the picking behavior of the artist.
     |
     |      Parameters
     |      ----------
     |      picker : None or bool or callable
     |          This can be one of the following:
     |
     |          - *None*: Picking is disabled for this artist (default).
     |
     |          - A boolean: If *True* then picking will be enabled and the
     |            artist will fire a pick event if the mouse event is over
     |            the artist.
     |
     |          - A function: If picker is callable, it is a user supplied
     |            function which determines whether the artist is hit by the
     |            mouse event::
     |
     |              hit, props = picker(artist, mouseevent)
     |
     |            to determine the hit test.  if the mouse event is over the
     |            artist, return *hit=True* and props is a dictionary of
     |            properties you want added to the PickEvent attributes.
     |
     |          - *deprecated*: For `.Line2D` only, *picker* can also be a float
     |            that sets the tolerance for checking whether an event occurred
     |            "on" the line; this is deprecated.  Use `.Line2D.set_pickradius`
     |            instead.
     |
     |  set_rasterized(self, rasterized)
     |      Force rasterized (bitmap) drawing in vector backend output.
     |
     |      Defaults to None, which implies the backend's default behavior.
     |
     |      Parameters
     |      ----------
     |      rasterized : bool or None
     |
     |  set_sketch_params(self, scale=None, length=None, randomness=None)
     |      Sets the sketch parameters.
     |
     |      Parameters
     |      ----------
     |      scale : float, optional
     |          The amplitude of the wiggle perpendicular to the source
     |          line, in pixels.  If scale is `None`, or not provided, no
     |          sketch filter will be provided.
     |      length : float, optional
     |           The length of the wiggle along the line, in pixels
     |           (default 128.0)
     |      randomness : float, optional
     |          The scale factor by which the length is shrunken or
     |          expanded (default 16.0)
     |
     |          .. ACCEPTS: (scale: float, length: float, randomness: float)
     |
     |  set_snap(self, snap)
     |      Set the snapping behavior.
     |
     |      Snapping aligns positions with the pixel grid, which results in
     |      clearer images. For example, if a black line of 1px width was
     |      defined at a position in between two pixels, the resulting image
     |      would contain the interpolated value of that line in the pixel grid,
     |      which would be a grey value on both adjacent pixel positions. In
     |      contrast, snapping will move the line to the nearest integer pixel
     |      value, so that the resulting image will really contain a 1px wide
     |      black line.
     |
     |      Snapping is currently only supported by the Agg and MacOSX backends.
     |
     |      Parameters
     |      ----------
     |      snap : bool or None
     |          Possible values:
     |
     |          - *True*: Snap vertices to the nearest pixel center.
     |          - *False*: Do not modify vertex positions.
     |          - *None*: (auto) If the path contains only rectilinear line
     |            segments, round to the nearest pixel center.
     |
     |  set_transform(self, t)
     |      Set the artist transform.
     |
     |      Parameters
     |      ----------
     |      t : `.Transform`
     |
     |  set_url(self, url)
     |      Set the url for the artist.
     |
     |      Parameters
     |      ----------
     |      url : str
     |
     |  set_visible(self, b)
     |      Set the artist's visibility.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_zorder(self, level)
     |      Set the zorder for the artist.  Artists with lower zorder
     |      values are drawn first.
     |
     |      Parameters
     |      ----------
     |      level : float
     |
     |  update(self, props)
     |      Update this artist's properties from the dict *props*.
     |
     |      Parameters
     |      ----------
     |      props : dict
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from matplotlib.artist.Artist:
     |
     |  sticky_edges
     |      ``x`` and ``y`` sticky edge lists for autoscaling.
     |
     |      When performing autoscaling, if a data limit coincides with a value in
     |      the corresponding sticky_edges list, then no margin will be added--the
     |      view limit "sticks" to the edge. A typical use case is histograms,
     |      where one usually expects no margin on the bottom edge (0) of the
     |      histogram.
     |
     |      This attribute cannot be assigned to; however, the ``x`` and ``y``
     |      lists can be modified in place as needed.
     |
     |      Examples
     |      --------
     |      >>> artist.sticky_edges.x[:] = (xmin, xmax)
     |      >>> artist.sticky_edges.y[:] = (ymin, ymax)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from matplotlib.artist.Artist:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  axes
     |      The `~.axes.Axes` instance the artist resides in, or *None*.
     |
     |  mouseover
     |      If this property is set to *True*, the artist will be queried for
     |      custom context information when the mouse cursor moves over it.
     |
     |      See also :meth:`get_cursor_data`, :class:`.ToolCursorPosition` and
     |      :class:`.NavigationToolbar2`.
     |
     |  stale
     |      Whether the artist is 'stale' and needs to be re-drawn for the output
     |      to match the internal state of the artist.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from matplotlib.artist.Artist:
     |
     |  zorder = 0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from matplotlib.cm.ScalarMappable:
     |
     |  add_checker(self, checker)
     |      [*Deprecated*]
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |         \
     |
     |  autoscale(self)
     |      Autoscale the scalar limits on the norm instance using the
     |      current array
     |
     |  autoscale_None(self)
     |      Autoscale the scalar limits on the norm instance using the
     |      current array, changing only limits that are None
     |
     |  changed(self)
     |      Call this whenever the mappable is changed to notify all the
     |      callbackSM listeners to the 'changed' signal.
     |
     |  check_update(self, checker)
     |      [*Deprecated*]
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |         \
     |
     |  get_array(self)
     |      Return the data array.
     |
     |  get_clim(self)
     |      Return the values (min, max) that are mapped to the colormap limits.
     |
     |  get_cmap(self)
     |      Return the `.Colormap` instance.
     |
     |  set_array(self, A)
     |      Set the image array from numpy array *A*.
     |
     |      Parameters
     |      ----------
     |      A : ndarray
     |
     |  set_clim(self, vmin=None, vmax=None)
     |      Set the norm limits for image scaling.
     |
     |      Parameters
     |      ----------
     |      vmin, vmax : float
     |           The limits.
     |
     |           The limits may also be passed as a tuple (*vmin*, *vmax*) as a
     |           single positional argument.
     |
     |           .. ACCEPTS: (vmin: float, vmax: float)
     |
     |  set_cmap(self, cmap)
     |      Set the colormap for luminance data.
     |
     |      Parameters
     |      ----------
     |      cmap : `.Colormap` or str or None
     |
     |  set_norm(self, norm)
     |      Set the normalization instance.
     |
     |      Parameters
     |      ----------
     |      norm : `.Normalize` or None
     |
     |      Notes
     |      -----
     |      If there are any colorbars using the mappable for this norm, setting
     |      the norm of the mappable will reset the norm, locator, and formatters
     |      on the colorbar to default.
     |
     |  to_rgba(self, x, alpha=None, bytes=False, norm=True)
     |      Return a normalized rgba array corresponding to *x*.
     |
     |      In the normal case, *x* is a 1-D or 2-D sequence of scalars, and
     |      the corresponding ndarray of rgba values will be returned,
     |      based on the norm and colormap set for this ScalarMappable.
     |
     |      There is one special case, for handling images that are already
     |      rgb or rgba, such as might have been read from an image file.
     |      If *x* is an ndarray with 3 dimensions,
     |      and the last dimension is either 3 or 4, then it will be
     |      treated as an rgb or rgba array, and no mapping will be done.
     |      The array can be uint8, or it can be floating point with
     |      values in the 0-1 range; otherwise a ValueError will be raised.
     |      If it is a masked array, the mask will be ignored.
     |      If the last dimension is 3, the *alpha* kwarg (defaulting to 1)
     |      will be used to fill in the transparency.  If the last dimension
     |      is 4, the *alpha* kwarg is ignored; it does not
     |      replace the pre-existing alpha.  A ValueError will be raised
     |      if the third dimension is other than 3 or 4.
     |
     |      In either case, if *bytes* is *False* (default), the rgba
     |      array will be floats in the 0-1 range; if it is *True*,
     |      the returned rgba array will be uint8 in the 0 to 255 range.
     |
     |      If norm is False, no normalization of the input data is
     |      performed, and it is assumed to be in the range (0-1).
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from matplotlib.cm.ScalarMappable:
     |
     |  update_dict

```python
import matplotlib.collections as mplcol
import matplotlib.patches as patches
import matplotlib.path
import matplotlib.pyplot as plt
import mpl_toolkits.mplot3d
plt.ion()
```

```python
help(mplcol.PatchCollection)
```

    Help on class PatchCollection in module matplotlib.collections:

    class PatchCollection(Collection)
     |  PatchCollection(patches, match_original=False, **kwargs)
     |
     |  A generic collection of patches.
     |
     |  This makes it easier to assign a color map to a heterogeneous
     |  collection of patches.
     |
     |  This also may improve plotting speed, since PatchCollection will
     |  draw faster than a large number of patches.
     |
     |  Method resolution order:
     |      PatchCollection
     |      Collection
     |      matplotlib.artist.Artist
     |      matplotlib.cm.ScalarMappable
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, patches, match_original=False, **kwargs)
     |      *patches*
     |          a sequence of Patch objects.  This list may include
     |          a heterogeneous assortment of different patch types.
     |
     |      *match_original*
     |          If True, use the colors and linewidths of the original
     |          patches.  If False, new colors may be assigned by
     |          providing the standard collection arguments, facecolor,
     |          edgecolor, linewidths, norm or cmap.
     |
     |      If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds* are
     |      None, they default to their `.rcParams` patch setting, in sequence
     |      form.
     |
     |      The use of `~matplotlib.cm.ScalarMappable` functionality is optional.
     |      If the `~matplotlib.cm.ScalarMappable` matrix ``_A`` has been set (via
     |      a call to `~.ScalarMappable.set_array`), at draw time a call to scalar
     |      mappable will be made to set the face colors.
     |
     |  set_paths(self, patches)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Collection:
     |
     |  contains(self, mouseevent)
     |      Test whether the mouse event occurred in the collection.
     |
     |      Returns ``bool, dict(ind=itemlist)``, where every item in itemlist
     |      contains the event.
     |
     |  draw(self, renderer)
     |      Draw the Artist (and its children) using the given renderer.
     |
     |      This has no effect if the artist is not visible (`.Artist.get_visible`
     |      returns False).
     |
     |      Parameters
     |      ----------
     |      renderer : `.RendererBase` subclass.
     |
     |      Notes
     |      -----
     |      This method is overridden in the Artist subclasses.
     |
     |  get_capstyle(self)
     |
     |  get_dashes(self)
     |      Alias for `get_linestyle`.
     |
     |  get_datalim(self, transData)
     |
     |  get_ec(self)
     |      Alias for `get_edgecolor`.
     |
     |  get_edgecolor(self)
     |
     |  get_edgecolors(self)
     |      Alias for `get_edgecolor`.
     |
     |  get_facecolor(self)
     |
     |  get_facecolors(self)
     |      Alias for `get_facecolor`.
     |
     |  get_fc(self)
     |      Alias for `get_facecolor`.
     |
     |  get_fill(self)
     |      Return whether fill is set.
     |
     |  get_hatch(self)
     |      Return the current hatching pattern.
     |
     |  get_joinstyle(self)
     |
     |  get_linestyle(self)
     |
     |  get_linestyles(self)
     |      Alias for `get_linestyle`.
     |
     |  get_linewidth(self)
     |
     |  get_linewidths(self)
     |      Alias for `get_linewidth`.
     |
     |  get_ls(self)
     |      Alias for `get_linestyle`.
     |
     |  get_lw(self)
     |      Alias for `get_linewidth`.
     |
     |  get_offset_position(self)
     |      [*Deprecated*] Return how offsets are applied for the collection.  If
     |      *offset_position* is 'screen', the offset is applied after the
     |      master transform has been applied, that is, the offsets are in
     |      screen coordinates.  If offset_position is 'data', the offset
     |      is applied before the master transform, i.e., the offsets are
     |      in data coordinates.
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  get_offset_transform(self)
     |
     |  get_offsets(self)
     |      Return the offsets for the collection.
     |
     |  get_paths(self)
     |
     |  get_pickradius(self)
     |
     |  get_transforms(self)
     |
     |  get_urls(self)
     |      Return a list of URLs, one for each element of the collection.
     |
     |      The list contains *None* for elements without a URL. See
     |      :doc:`/gallery/misc/hyperlinks_sgskip` for an example.
     |
     |  get_window_extent(self, renderer)
     |      Get the axes bounding box in display space.
     |
     |      The bounding box' width and height are nonnegative.
     |
     |      Subclasses should override for inclusion in the bounding box
     |      "tight" calculation. Default is to return an empty bounding
     |      box at 0, 0.
     |
     |      Be careful when using this function, the results will not update
     |      if the artist window extent of the artist changes.  The extent
     |      can change due to any changes in the transform stack, such as
     |      changing the axes limits, the figure size, or the canvas used
     |      (as is done when saving a figure).  This can lead to unexpected
     |      behavior where interactive figures will look fine on the screen,
     |      but will save incorrectly.
     |
     |  set_aa(self, aa)
     |      Alias for `set_antialiased`.
     |
     |  set_alpha(self, alpha)
     |      Set the alpha value used for blending - not supported on all backends.
     |
     |      Parameters
     |      ----------
     |      alpha : float or None
     |
     |  set_antialiased(self, aa)
     |      Set the antialiasing state for rendering.
     |
     |      Parameters
     |      ----------
     |      aa : bool or list of bools
     |
     |  set_antialiaseds(self, aa)
     |      Alias for `set_antialiased`.
     |
     |  set_capstyle(self, cs)
     |      Set the capstyle for the collection (for all its elements).
     |
     |      Parameters
     |      ----------
     |      cs : {'butt', 'round', 'projecting'}
     |          The capstyle.
     |
     |  set_color(self, c)
     |      Set both the edgecolor and the facecolor.
     |
     |      Parameters
     |      ----------
     |      c : color or list of rgba tuples
     |
     |      See Also
     |      --------
     |      Collection.set_facecolor, Collection.set_edgecolor
     |          For setting the edge or face color individually.
     |
     |  set_dashes(self, ls)
     |      Alias for `set_linestyle`.
     |
     |  set_ec(self, c)
     |      Alias for `set_edgecolor`.
     |
     |  set_edgecolor(self, c)
     |      Set the edgecolor(s) of the collection.
     |
     |      Parameters
     |      ----------
     |      c : color or list of colors or 'face'
     |          The collection edgecolor(s).  If a sequence, the patches cycle
     |          through it.  If 'face', match the facecolor.
     |
     |  set_edgecolors(self, c)
     |      Alias for `set_edgecolor`.
     |
     |  set_facecolor(self, c)
     |      Set the facecolor(s) of the collection. *c* can be a color (all patches
     |      have same color), or a sequence of colors; if it is a sequence the
     |      patches will cycle through the sequence.
     |
     |      If *c* is 'none', the patch will not be filled.
     |
     |      Parameters
     |      ----------
     |      c : color or list of colors
     |
     |  set_facecolors(self, c)
     |      Alias for `set_facecolor`.
     |
     |  set_fc(self, c)
     |      Alias for `set_facecolor`.
     |
     |  set_hatch(self, hatch)
     |      Set the hatching pattern
     |
     |      *hatch* can be one of::
     |
     |        /   - diagonal hatching
     |        \   - back diagonal
     |        |   - vertical
     |        -   - horizontal
     |        +   - crossed
     |        x   - crossed diagonal
     |        o   - small circle
     |        O   - large circle
     |        .   - dots
     |        *   - stars
     |
     |      Letters can be combined, in which case all the specified
     |      hatchings are done.  If same letter repeats, it increases the
     |      density of hatching of that pattern.
     |
     |      Hatching is supported in the PostScript, PDF, SVG and Agg
     |      backends only.
     |
     |      Unlike other properties such as linewidth and colors, hatching
     |      can only be specified for the collection as a whole, not separately
     |      for each member.
     |
     |      Parameters
     |      ----------
     |      hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
     |
     |  set_joinstyle(self, js)
     |      Set the joinstyle for the collection (for all its elements).
     |
     |      Parameters
     |      ----------
     |      js : {'miter', 'round', 'bevel'}
     |          The joinstyle.
     |
     |  set_linestyle(self, ls)
     |      Set the linestyle(s) for the collection.
     |
     |      ===========================   =================
     |      linestyle                     description
     |      ===========================   =================
     |      ``'-'`` or ``'solid'``        solid line
     |      ``'--'`` or  ``'dashed'``     dashed line
     |      ``'-.'`` or  ``'dashdot'``    dash-dotted line
     |      ``':'`` or ``'dotted'``       dotted line
     |      ===========================   =================
     |
     |      Alternatively a dash tuple of the following form can be provided::
     |
     |          (offset, onoffseq),
     |
     |      where ``onoffseq`` is an even length tuple of on and off ink in points.
     |
     |      Parameters
     |      ----------
     |      ls : str or tuple or list thereof
     |          Valid values for individual linestyles include {'-', '--', '-.',
     |          ':', '', (offset, on-off-seq)}. See `.Line2D.set_linestyle` for a
     |          complete description.
     |
     |  set_linestyles(self, ls)
     |      Alias for `set_linestyle`.
     |
     |  set_linewidth(self, lw)
     |      Set the linewidth(s) for the collection.  *lw* can be a scalar
     |      or a sequence; if it is a sequence the patches will cycle
     |      through the sequence
     |
     |      Parameters
     |      ----------
     |      lw : float or list of floats
     |
     |  set_linewidths(self, lw)
     |      Alias for `set_linewidth`.
     |
     |  set_ls(self, ls)
     |      Alias for `set_linestyle`.
     |
     |  set_lw(self, lw)
     |      Alias for `set_linewidth`.
     |
     |  set_offset_position(self, offset_position)
     |      [*Deprecated*] Set how offsets are applied.  If *offset_position* is 'screen'
     |      (default) the offset is applied after the master transform has
     |      been applied, that is, the offsets are in screen coordinates.
     |      If offset_position is 'data', the offset is applied before the
     |      master transform, i.e., the offsets are in data coordinates.
     |
     |      Parameters
     |      ----------
     |      offset_position : {'screen', 'data'}
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  set_offsets(self, offsets)
     |      Set the offsets for the collection.
     |
     |      Parameters
     |      ----------
     |      offsets : array-like (N, 2) or (2,)
     |
     |  set_pickradius(self, pr)
     |      Set the pick radius used for containment tests.
     |
     |      Parameters
     |      ----------
     |      d : float
     |          Pick radius, in points.
     |
     |  set_urls(self, urls)
     |      Parameters
     |      ----------
     |      urls : list of str or None
     |
     |      Notes
     |      -----
     |      URLs are currently only implemented by the SVG backend. They are
     |      ignored by all other backends.
     |
     |  update_from(self, other)
     |      Copy properties from other to self.
     |
     |  update_scalarmappable(self)
     |      Update colors from the scalar mappable array, if it is not None.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from matplotlib.artist.Artist:
     |
     |  __getstate__(self)
     |
     |  add_callback(self, func)
     |      Add a callback function that will be called whenever one of the
     |      `.Artist`'s properties changes.
     |
     |      Parameters
     |      ----------
     |      func : callable
     |          The callback function. It must have the signature::
     |
     |              def func(artist: Artist) -> Any
     |
     |          where *artist* is the calling `.Artist`. Return values may exist
     |          but are ignored.
     |
     |      Returns
     |      -------
     |      int
     |          The observer id associated with the callback. This id can be
     |          used for removing the callback with `.remove_callback` later.
     |
     |      See Also
     |      --------
     |      remove_callback
     |
     |  convert_xunits(self, x)
     |      Convert *x* using the unit type of the xaxis.
     |
     |      If the artist is not in contained in an Axes or if the xaxis does not
     |      have units, *x* itself is returned.
     |
     |  convert_yunits(self, y)
     |      Convert *y* using the unit type of the yaxis.
     |
     |      If the artist is not in contained in an Axes or if the yaxis does not
     |      have units, *y* itself is returned.
     |
     |  findobj(self, match=None, include_self=True)
     |      Find artist objects.
     |
     |      Recursively find all `.Artist` instances contained in the artist.
     |
     |      Parameters
     |      ----------
     |      match
     |          A filter criterion for the matches. This can be
     |
     |          - *None*: Return all objects contained in artist.
     |          - A function with signature ``def match(artist: Artist) -> bool``.
     |            The result will only contain artists for which the function
     |            returns *True*.
     |          - A class instance: e.g., `.Line2D`. The result will only contain
     |            artists of this class or its subclasses (``isinstance`` check).
     |
     |      include_self : bool
     |          Include *self* in the list to be checked for a match.
     |
     |      Returns
     |      -------
     |      list of `.Artist`
     |
     |  format_cursor_data(self, data)
     |      Return a string representation of *data*.
     |
     |      .. note::
     |          This method is intended to be overridden by artist subclasses.
     |          As an end-user of Matplotlib you will most likely not call this
     |          method yourself.
     |
     |      The default implementation converts ints and floats and arrays of ints
     |      and floats into a comma-separated string enclosed in square brackets.
     |
     |      See Also
     |      --------
     |      get_cursor_data
     |
     |  get_agg_filter(self)
     |      Return filter function to be used for agg filter.
     |
     |  get_alpha(self)
     |      Return the alpha value used for blending - not supported on all
     |      backends.
     |
     |  get_animated(self)
     |      Return whether the artist is animated.
     |
     |  get_children(self)
     |      Return a list of the child `.Artist`\s of this `.Artist`.
     |
     |  get_clip_box(self)
     |      Return the clipbox.
     |
     |  get_clip_on(self)
     |      Return whether the artist uses clipping.
     |
     |  get_clip_path(self)
     |      Return the clip path.
     |
     |  get_contains(self)
     |      [*Deprecated*] Return the custom contains function of the artist if set, or *None*.
     |
     |      See Also
     |      --------
     |      set_contains
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  get_cursor_data(self, event)
     |      Return the cursor data for a given event.
     |
     |      .. note::
     |          This method is intended to be overridden by artist subclasses.
     |          As an end-user of Matplotlib you will most likely not call this
     |          method yourself.
     |
     |      Cursor data can be used by Artists to provide additional context
     |      information for a given event. The default implementation just returns
     |      *None*.
     |
     |      Subclasses can override the method and return arbitrary data. However,
     |      when doing so, they must ensure that `.format_cursor_data` can convert
     |      the data to a string representation.
     |
     |      The only current use case is displaying the z-value of an `.AxesImage`
     |      in the status bar of a plot window, while moving the mouse.
     |
     |      Parameters
     |      ----------
     |      event : `matplotlib.backend_bases.MouseEvent`
     |
     |      See Also
     |      --------
     |      format_cursor_data
     |
     |  get_figure(self)
     |      Return the `.Figure` instance the artist belongs to.
     |
     |  get_gid(self)
     |      Return the group id.
     |
     |  get_in_layout(self)
     |      Return boolean flag, ``True`` if artist is included in layout
     |      calculations.
     |
     |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,
     |      `.Figure.tight_layout()`, and
     |      ``fig.savefig(fname, bbox_inches='tight')``.
     |
     |  get_label(self)
     |      Return the label used for this artist in the legend.
     |
     |  get_path_effects(self)
     |
     |  get_picker(self)
     |      Return the picking behavior of the artist.
     |
     |      The possible values are described in `.set_picker`.
     |
     |      See Also
     |      --------
     |      set_picker, pickable, pick
     |
     |  get_rasterized(self)
     |      Return whether the artist is to be rasterized.
     |
     |  get_sketch_params(self)
     |      Return the sketch parameters for the artist.
     |
     |      Returns
     |      -------
     |      tuple or None
     |
     |          A 3-tuple with the following elements:
     |
     |          - *scale*: The amplitude of the wiggle perpendicular to the
     |            source line.
     |          - *length*: The length of the wiggle along the line.
     |          - *randomness*: The scale factor by which the length is
     |            shrunken or expanded.
     |
     |          Returns *None* if no sketch parameters were set.
     |
     |  get_snap(self)
     |      Return the snap setting.
     |
     |      See `.set_snap` for details.
     |
     |  get_tightbbox(self, renderer)
     |      Like `.Artist.get_window_extent`, but includes any clipping.
     |
     |      Parameters
     |      ----------
     |      renderer : `.RendererBase` subclass
     |          renderer that will be used to draw the figures (i.e.
     |          ``fig.canvas.get_renderer()``)
     |
     |      Returns
     |      -------
     |      `.Bbox`
     |          The enclosing bounding box (in figure pixel coordinates).
     |
     |  get_transform(self)
     |      Return the `.Transform` instance used by this artist.
     |
     |  get_transformed_clip_path_and_affine(self)
     |      Return the clip path with the non-affine part of its
     |      transformation applied, and the remaining affine part of its
     |      transformation.
     |
     |  get_url(self)
     |      Return the url.
     |
     |  get_visible(self)
     |      Return the visibility.
     |
     |  get_zorder(self)
     |      Return the artist's zorder.
     |
     |  have_units(self)
     |      Return *True* if units are set on any axis.
     |
     |  is_transform_set(self)
     |      Return whether the Artist has an explicitly set transform.
     |
     |      This is *True* after `.set_transform` has been called.
     |
     |  pchanged(self)
     |      Call all of the registered callbacks.
     |
     |      This function is triggered internally when a property is changed.
     |
     |      See Also
     |      --------
     |      add_callback
     |      remove_callback
     |
     |  pick(self, mouseevent)
     |      Process a pick event.
     |
     |      Each child artist will fire a pick event if *mouseevent* is over
     |      the artist and the artist has picker set.
     |
     |      See Also
     |      --------
     |      set_picker, get_picker, pickable
     |
     |  pickable(self)
     |      Return whether the artist is pickable.
     |
     |      See Also
     |      --------
     |      set_picker, get_picker, pick
     |
     |  properties(self)
     |      Return a dictionary of all the properties of the artist.
     |
     |  remove(self)
     |      Remove the artist from the figure if possible.
     |
     |      The effect will not be visible until the figure is redrawn, e.g.,
     |      with `.FigureCanvasBase.draw_idle`.  Call `~.axes.Axes.relim` to
     |      update the axes limits if desired.
     |
     |      Note: `~.axes.Axes.relim` will not see collections even if the
     |      collection was added to the axes with *autolim* = True.
     |
     |      Note: there is no support for removing the artist's legend entry.
     |
     |  remove_callback(self, oid)
     |      Remove a callback based on its observer id.
     |
     |      See Also
     |      --------
     |      add_callback
     |
     |  set(self, **kwargs)
     |      A property batch setter.  Pass *kwargs* to set properties.
     |
     |  set_agg_filter(self, filter_func)
     |      Set the agg filter.
     |
     |      Parameters
     |      ----------
     |      filter_func : callable
     |          A filter function, which takes a (m, n, 3) float array and a dpi
     |          value, and returns a (m, n, 3) array.
     |
     |          .. ACCEPTS: a filter function, which takes a (m, n, 3) float array
     |              and a dpi value, and returns a (m, n, 3) array
     |
     |  set_animated(self, b)
     |      Set the artist's animation state.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_clip_box(self, clipbox)
     |      Set the artist's clip `.Bbox`.
     |
     |      Parameters
     |      ----------
     |      clipbox : `.Bbox`
     |
     |  set_clip_on(self, b)
     |      Set whether the artist uses clipping.
     |
     |      When False artists will be visible outside of the axes which
     |      can lead to unexpected results.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_clip_path(self, path, transform=None)
     |      Set the artist's clip path.
     |
     |      Parameters
     |      ----------
     |      path : `.Patch` or `.Path` or `.TransformedPath` or None
     |          The clip path. If given a `.Path`, *transform* must be provided as
     |          well. If *None*, a previously set clip path is removed.
     |      transform : `~matplotlib.transforms.Transform`, optional
     |          Only used if *path* is a `.Path`, in which case the given `.Path`
     |          is converted to a `.TransformedPath` using *transform*.
     |
     |      Notes
     |      -----
     |      For efficiency, if *path* is a `.Rectangle` this method will set the
     |      clipping box to the corresponding rectangle and set the clipping path
     |      to ``None``.
     |
     |      For technical reasons (support of `~.Artist.set`), a tuple
     |      (*path*, *transform*) is also accepted as a single positional
     |      parameter.
     |
     |      .. ACCEPTS: Patch or (Path, Transform) or None
     |
     |  set_contains(self, picker)
     |      [*Deprecated*] Define a custom contains test for the artist.
     |
     |      The provided callable replaces the default `.contains` method
     |      of the artist.
     |
     |      Parameters
     |      ----------
     |      picker : callable
     |          A custom picker function to evaluate if an event is within the
     |          artist. The function must have the signature::
     |
     |              def contains(artist: Artist, event: MouseEvent) -> bool, dict
     |
     |          that returns:
     |
     |          - a bool indicating if the event is within the artist
     |          - a dict of additional information. The dict should at least
     |            return the same information as the default ``contains()``
     |            implementation of the respective artist, but may provide
     |            additional information.
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  set_figure(self, fig)
     |      Set the `.Figure` instance the artist belongs to.
     |
     |      Parameters
     |      ----------
     |      fig : `.Figure`
     |
     |  set_gid(self, gid)
     |      Set the (group) id for the artist.
     |
     |      Parameters
     |      ----------
     |      gid : str
     |
     |  set_in_layout(self, in_layout)
     |      Set if artist is to be included in layout calculations,
     |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,
     |      `.Figure.tight_layout()`, and
     |      ``fig.savefig(fname, bbox_inches='tight')``.
     |
     |      Parameters
     |      ----------
     |      in_layout : bool
     |
     |  set_label(self, s)
     |      Set a label that will be displayed in the legend.
     |
     |      Parameters
     |      ----------
     |      s : object
     |          *s* will be converted to a string by calling `str`.
     |
     |  set_path_effects(self, path_effects)
     |      Set the path effects.
     |
     |      Parameters
     |      ----------
     |      path_effects : `.AbstractPathEffect`
     |
     |  set_picker(self, picker)
     |      Define the picking behavior of the artist.
     |
     |      Parameters
     |      ----------
     |      picker : None or bool or callable
     |          This can be one of the following:
     |
     |          - *None*: Picking is disabled for this artist (default).
     |
     |          - A boolean: If *True* then picking will be enabled and the
     |            artist will fire a pick event if the mouse event is over
     |            the artist.
     |
     |          - A function: If picker is callable, it is a user supplied
     |            function which determines whether the artist is hit by the
     |            mouse event::
     |
     |              hit, props = picker(artist, mouseevent)
     |
     |            to determine the hit test.  if the mouse event is over the
     |            artist, return *hit=True* and props is a dictionary of
     |            properties you want added to the PickEvent attributes.
     |
     |          - *deprecated*: For `.Line2D` only, *picker* can also be a float
     |            that sets the tolerance for checking whether an event occurred
     |            "on" the line; this is deprecated.  Use `.Line2D.set_pickradius`
     |            instead.
     |
     |  set_rasterized(self, rasterized)
     |      Force rasterized (bitmap) drawing in vector backend output.
     |
     |      Defaults to None, which implies the backend's default behavior.
     |
     |      Parameters
     |      ----------
     |      rasterized : bool or None
     |
     |  set_sketch_params(self, scale=None, length=None, randomness=None)
     |      Sets the sketch parameters.
     |
     |      Parameters
     |      ----------
     |      scale : float, optional
     |          The amplitude of the wiggle perpendicular to the source
     |          line, in pixels.  If scale is `None`, or not provided, no
     |          sketch filter will be provided.
     |      length : float, optional
     |           The length of the wiggle along the line, in pixels
     |           (default 128.0)
     |      randomness : float, optional
     |          The scale factor by which the length is shrunken or
     |          expanded (default 16.0)
     |
     |          .. ACCEPTS: (scale: float, length: float, randomness: float)
     |
     |  set_snap(self, snap)
     |      Set the snapping behavior.
     |
     |      Snapping aligns positions with the pixel grid, which results in
     |      clearer images. For example, if a black line of 1px width was
     |      defined at a position in between two pixels, the resulting image
     |      would contain the interpolated value of that line in the pixel grid,
     |      which would be a grey value on both adjacent pixel positions. In
     |      contrast, snapping will move the line to the nearest integer pixel
     |      value, so that the resulting image will really contain a 1px wide
     |      black line.
     |
     |      Snapping is currently only supported by the Agg and MacOSX backends.
     |
     |      Parameters
     |      ----------
     |      snap : bool or None
     |          Possible values:
     |
     |          - *True*: Snap vertices to the nearest pixel center.
     |          - *False*: Do not modify vertex positions.
     |          - *None*: (auto) If the path contains only rectilinear line
     |            segments, round to the nearest pixel center.
     |
     |  set_transform(self, t)
     |      Set the artist transform.
     |
     |      Parameters
     |      ----------
     |      t : `.Transform`
     |
     |  set_url(self, url)
     |      Set the url for the artist.
     |
     |      Parameters
     |      ----------
     |      url : str
     |
     |  set_visible(self, b)
     |      Set the artist's visibility.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_zorder(self, level)
     |      Set the zorder for the artist.  Artists with lower zorder
     |      values are drawn first.
     |
     |      Parameters
     |      ----------
     |      level : float
     |
     |  update(self, props)
     |      Update this artist's properties from the dict *props*.
     |
     |      Parameters
     |      ----------
     |      props : dict
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from matplotlib.artist.Artist:
     |
     |  sticky_edges
     |      ``x`` and ``y`` sticky edge lists for autoscaling.
     |
     |      When performing autoscaling, if a data limit coincides with a value in
     |      the corresponding sticky_edges list, then no margin will be added--the
     |      view limit "sticks" to the edge. A typical use case is histograms,
     |      where one usually expects no margin on the bottom edge (0) of the
     |      histogram.
     |
     |      This attribute cannot be assigned to; however, the ``x`` and ``y``
     |      lists can be modified in place as needed.
     |
     |      Examples
     |      --------
     |      >>> artist.sticky_edges.x[:] = (xmin, xmax)
     |      >>> artist.sticky_edges.y[:] = (ymin, ymax)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from matplotlib.artist.Artist:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  axes
     |      The `~.axes.Axes` instance the artist resides in, or *None*.
     |
     |  mouseover
     |      If this property is set to *True*, the artist will be queried for
     |      custom context information when the mouse cursor moves over it.
     |
     |      See also :meth:`get_cursor_data`, :class:`.ToolCursorPosition` and
     |      :class:`.NavigationToolbar2`.
     |
     |  stale
     |      Whether the artist is 'stale' and needs to be re-drawn for the output
     |      to match the internal state of the artist.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from matplotlib.artist.Artist:
     |
     |  zorder = 0
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from matplotlib.cm.ScalarMappable:
     |
     |  add_checker(self, checker)
     |      [*Deprecated*]
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |         \
     |
     |  autoscale(self)
     |      Autoscale the scalar limits on the norm instance using the
     |      current array
     |
     |  autoscale_None(self)
     |      Autoscale the scalar limits on the norm instance using the
     |      current array, changing only limits that are None
     |
     |  changed(self)
     |      Call this whenever the mappable is changed to notify all the
     |      callbackSM listeners to the 'changed' signal.
     |
     |  check_update(self, checker)
     |      [*Deprecated*]
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |         \
     |
     |  get_array(self)
     |      Return the data array.
     |
     |  get_clim(self)
     |      Return the values (min, max) that are mapped to the colormap limits.
     |
     |  get_cmap(self)
     |      Return the `.Colormap` instance.
     |
     |  set_array(self, A)
     |      Set the image array from numpy array *A*.
     |
     |      Parameters
     |      ----------
     |      A : ndarray
     |
     |  set_clim(self, vmin=None, vmax=None)
     |      Set the norm limits for image scaling.
     |
     |      Parameters
     |      ----------
     |      vmin, vmax : float
     |           The limits.
     |
     |           The limits may also be passed as a tuple (*vmin*, *vmax*) as a
     |           single positional argument.
     |
     |           .. ACCEPTS: (vmin: float, vmax: float)
     |
     |  set_cmap(self, cmap)
     |      Set the colormap for luminance data.
     |
     |      Parameters
     |      ----------
     |      cmap : `.Colormap` or str or None
     |
     |  set_norm(self, norm)
     |      Set the normalization instance.
     |
     |      Parameters
     |      ----------
     |      norm : `.Normalize` or None
     |
     |      Notes
     |      -----
     |      If there are any colorbars using the mappable for this norm, setting
     |      the norm of the mappable will reset the norm, locator, and formatters
     |      on the colorbar to default.
     |
     |  to_rgba(self, x, alpha=None, bytes=False, norm=True)
     |      Return a normalized rgba array corresponding to *x*.
     |
     |      In the normal case, *x* is a 1-D or 2-D sequence of scalars, and
     |      the corresponding ndarray of rgba values will be returned,
     |      based on the norm and colormap set for this ScalarMappable.
     |
     |      There is one special case, for handling images that are already
     |      rgb or rgba, such as might have been read from an image file.
     |      If *x* is an ndarray with 3 dimensions,
     |      and the last dimension is either 3 or 4, then it will be
     |      treated as an rgb or rgba array, and no mapping will be done.
     |      The array can be uint8, or it can be floating point with
     |      values in the 0-1 range; otherwise a ValueError will be raised.
     |      If it is a masked array, the mask will be ignored.
     |      If the last dimension is 3, the *alpha* kwarg (defaulting to 1)
     |      will be used to fill in the transparency.  If the last dimension
     |      is 4, the *alpha* kwarg is ignored; it does not
     |      replace the pre-existing alpha.  A ValueError will be raised
     |      if the third dimension is other than 3 or 4.
     |
     |      In either case, if *bytes* is *False* (default), the rgba
     |      array will be floats in the 0-1 range; if it is *True*,
     |      the returned rgba array will be uint8 in the 0 to 255 range.
     |
     |      If norm is False, no normalization of the input data is
     |      performed, and it is assumed to be in the range (0-1).
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from matplotlib.cm.ScalarMappable:
     |
     |  update_dict

```python
[s for s in dir(patches) if not s.startswith('_')]
```

    ['Arc',
     'Arrow',
     'ArrowStyle',
     'BoxStyle',
     'Circle',
     'CirclePolygon',
     'ConnectionPatch',
     'ConnectionStyle',
     'Ellipse',
     'FancyArrow',
     'FancyArrowPatch',
     'FancyBboxPatch',
     'NonIntersectingPathException',
     'Number',
     'Patch',
     'Path',
     'PathPatch',
     'Polygon',
     'Rectangle',
     'RegularPolygon',
     'Shadow',
     'Wedge',
     'artist',
     'bbox_artist',
     'cbook',
     'colors',
     'contextlib',
     'docstring',
     'draw_bbox',
     'functools',
     'get_cos_sin',
     'get_intersection',
     'get_parallels',
     'inside_circle',
     'inspect',
     'k',
     'make_wedged_bezier2',
     'math',
     'mlines',
     'mpl',
     'np',
     'patchdoc',
     'split_bezier_intersecting_with_closedpath',
     'split_path_inout',
     'textwrap',
     'transforms']

```python
help(patches.Circle)
```

    Help on class Circle in module matplotlib.patches:

    class Circle(Ellipse)
     |  Circle(xy, radius=5, **kwargs)
     |
     |  A circle patch.
     |
     |  Method resolution order:
     |      Circle
     |      Ellipse
     |      Patch
     |      matplotlib.artist.Artist
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, xy, radius=5, **kwargs)
     |      Create a true circle at center *xy* = (*x*, *y*) with given *radius*.
     |
     |      Unlike `CirclePolygon` which is a polygonal approximation, this uses
     |      Bezier splines and is much closer to a scale-free circle.
     |
     |      Valid keyword arguments are:
     |
     |      Properties:
     |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
     |          alpha: float or None
     |          animated: bool
     |          antialiased or aa: unknown
     |          capstyle: {'butt', 'round', 'projecting'}
     |          clip_box: `.Bbox`
     |          clip_on: bool
     |          clip_path: Patch or (Path, Transform) or None
     |          color: color
     |          contains: unknown
     |          edgecolor or ec: color or None or 'auto'
     |          facecolor or fc: color or None
     |          figure: `.Figure`
     |          fill: bool
     |          gid: str
     |          hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
     |          in_layout: bool
     |          joinstyle: {'miter', 'round', 'bevel'}
     |          label: object
     |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
     |          linewidth or lw: float or None
     |          path_effects: `.AbstractPathEffect`
     |          picker: None or bool or callable
     |          rasterized: bool or None
     |          sketch_params: (scale: float, length: float, randomness: float)
     |          snap: bool or None
     |          transform: `.Transform`
     |          url: str
     |          visible: bool
     |          zorder: float
     |
     |  __str__(self)
     |      Return str(self).
     |
     |  get_radius(self)
     |      Return the radius of the circle.
     |
     |  set_radius(self, radius)
     |      Set the radius of the circle.
     |
     |      Parameters
     |      ----------
     |      radius : float
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  radius
     |      Return the radius of the circle.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Ellipse:
     |
     |  get_angle(self)
     |      Return the angle of the ellipse.
     |
     |  get_center(self)
     |      Return the center of the ellipse.
     |
     |  get_height(self)
     |      Return the height of the ellipse.
     |
     |  get_patch_transform(self)
     |      Return the `~.transforms.Transform` instance mapping patch coordinates
     |      to data coordinates.
     |
     |      For example, one may define a patch of a circle which represents a
     |      radius of 5 by providing coordinates for a unit circle, and a
     |      transform which scales the coordinates (the patch coordinate) by 5.
     |
     |  get_path(self)
     |      Return the path of the ellipse.
     |
     |  get_width(self)
     |      Return the width of the ellipse.
     |
     |  set_angle(self, angle)
     |      Set the angle of the ellipse.
     |
     |      Parameters
     |      ----------
     |      angle : float
     |
     |  set_center(self, xy)
     |      Set the center of the ellipse.
     |
     |      Parameters
     |      ----------
     |      xy : (float, float)
     |
     |  set_height(self, height)
     |      Set the height of the ellipse.
     |
     |      Parameters
     |      ----------
     |      height : float
     |
     |  set_width(self, width)
     |      Set the width of the ellipse.
     |
     |      Parameters
     |      ----------
     |      width : float
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Ellipse:
     |
     |  angle
     |      Return the angle of the ellipse.
     |
     |  center
     |      Return the center of the ellipse.
     |
     |  height
     |      Return the height of the ellipse.
     |
     |  width
     |      Return the width of the ellipse.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Patch:
     |
     |  contains(self, mouseevent, radius=None)
     |      Test whether the mouse event occurred in the patch.
     |
     |      Returns
     |      -------
     |      (bool, empty dict)
     |
     |  contains_point(self, point, radius=None)
     |      Return whether the given point is inside the patch.
     |
     |      Parameters
     |      ----------
     |      point : (float, float)
     |          The point (x, y) to check, in target coordinates of
     |          ``self.get_transform()``. These are display coordinates for patches
     |          that are added to a figure or axes.
     |      radius : float, optional
     |          Add an additional margin on the patch in target coordinates of
     |          ``self.get_transform()``. See `.Path.contains_point` for further
     |          details.
     |
     |      Returns
     |      -------
     |      bool
     |
     |      Notes
     |      -----
     |      The proper use of this method depends on the transform of the patch.
     |      Isolated patches do not have a transform. In this case, the patch
     |      creation coordinates and the point coordinates match. The following
     |      example checks that the center of a circle is within the circle
     |
     |      >>> center = 0, 0
     |      >>> c = Circle(center, radius=1)
     |      >>> c.contains_point(center)
     |      True
     |
     |      The convention of checking against the transformed patch stems from
     |      the fact that this method is predominantly used to check if display
     |      coordinates (e.g. from mouse events) are within the patch. If you want
     |      to do the above check with data coordinates, you have to properly
     |      transform them first:
     |
     |      >>> center = 0, 0
     |      >>> c = Circle(center, radius=1)
     |      >>> plt.gca().add_patch(c)
     |      >>> transformed_center = c.get_transform().transform(center)
     |      >>> c.contains_point(transformed_center)
     |      True
     |
     |  contains_points(self, points, radius=None)
     |      Return whether the given points are inside the patch.
     |
     |      Parameters
     |      ----------
     |      points : (N, 2) array
     |          The points to check, in target coordinates of
     |          ``self.get_transform()``. These are display coordinates for patches
     |          that are added to a figure or axes. Columns contain x and y values.
     |      radius : float, optional
     |          Add an additional margin on the patch in target coordinates of
     |          ``self.get_transform()``. See `.Path.contains_point` for further
     |          details.
     |
     |      Returns
     |      -------
     |      length-N bool array
     |
     |      Notes
     |      -----
     |      The proper use of this method depends on the transform of the patch.
     |      See the notes on `.Patch.contains_point`.
     |
     |  draw(self, renderer)
     |      Draw the Artist (and its children) using the given renderer.
     |
     |      This has no effect if the artist is not visible (`.Artist.get_visible`
     |      returns False).
     |
     |      Parameters
     |      ----------
     |      renderer : `.RendererBase` subclass.
     |
     |      Notes
     |      -----
     |      This method is overridden in the Artist subclasses.
     |
     |  get_aa(self)
     |      Alias for `get_antialiased`.
     |
     |  get_antialiased(self)
     |      Return whether antialiasing is used for drawing.
     |
     |  get_capstyle(self)
     |      Return the capstyle.
     |
     |  get_data_transform(self)
     |      Return the `~.transforms.Transform` mapping data coordinates to
     |      physical coordinates.
     |
     |  get_ec(self)
     |      Alias for `get_edgecolor`.
     |
     |  get_edgecolor(self)
     |      Return the edge color.
     |
     |  get_extents(self)
     |      Return the `Patch`'s axis-aligned extents as a `~.transforms.Bbox`.
     |
     |  get_facecolor(self)
     |      Return the face color.
     |
     |  get_fc(self)
     |      Alias for `get_facecolor`.
     |
     |  get_fill(self)
     |      Return whether the patch is filled.
     |
     |  get_hatch(self)
     |      Return the hatching pattern.
     |
     |  get_joinstyle(self)
     |      Return the joinstyle.
     |
     |  get_linestyle(self)
     |      Return the linestyle.
     |
     |  get_linewidth(self)
     |      Return the line width in points.
     |
     |  get_ls(self)
     |      Alias for `get_linestyle`.
     |
     |  get_lw(self)
     |      Alias for `get_linewidth`.
     |
     |  get_transform(self)
     |      Return the `~.transforms.Transform` applied to the `Patch`.
     |
     |  get_verts(self)
     |      Return a copy of the vertices used in this patch.
     |
     |      If the patch contains Bezier curves, the curves will be interpolated by
     |      line segments.  To access the curves as curves, use `get_path`.
     |
     |  get_window_extent(self, renderer=None)
     |      Get the axes bounding box in display space.
     |
     |      The bounding box' width and height are nonnegative.
     |
     |      Subclasses should override for inclusion in the bounding box
     |      "tight" calculation. Default is to return an empty bounding
     |      box at 0, 0.
     |
     |      Be careful when using this function, the results will not update
     |      if the artist window extent of the artist changes.  The extent
     |      can change due to any changes in the transform stack, such as
     |      changing the axes limits, the figure size, or the canvas used
     |      (as is done when saving a figure).  This can lead to unexpected
     |      behavior where interactive figures will look fine on the screen,
     |      but will save incorrectly.
     |
     |  set_aa(self, aa)
     |      Alias for `set_antialiased`.
     |
     |  set_alpha(self, alpha)
     |      Set the alpha value used for blending - not supported on all backends.
     |
     |      Parameters
     |      ----------
     |      alpha : float or None
     |
     |  set_antialiased(self, aa)
     |      Set whether to use antialiased rendering.
     |
     |      Parameters
     |      ----------
     |      b : bool or None
     |
     |  set_capstyle(self, s)
     |      Set the capstyle.
     |
     |      Parameters
     |      ----------
     |      s : {'butt', 'round', 'projecting'}
     |
     |  set_color(self, c)
     |      Set both the edgecolor and the facecolor.
     |
     |      Parameters
     |      ----------
     |      c : color
     |
     |      See Also
     |      --------
     |      Patch.set_facecolor, Patch.set_edgecolor
     |          For setting the edge or face color individually.
     |
     |  set_ec(self, color)
     |      Alias for `set_edgecolor`.
     |
     |  set_edgecolor(self, color)
     |      Set the patch edge color.
     |
     |      Parameters
     |      ----------
     |      color : color or None or 'auto'
     |
     |  set_facecolor(self, color)
     |      Set the patch face color.
     |
     |      Parameters
     |      ----------
     |      color : color or None
     |
     |  set_fc(self, color)
     |      Alias for `set_facecolor`.
     |
     |  set_fill(self, b)
     |      Set whether to fill the patch.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_hatch(self, hatch)
     |      Set the hatching pattern.
     |
     |      *hatch* can be one of::
     |
     |        /   - diagonal hatching
     |        \   - back diagonal
     |        |   - vertical
     |        -   - horizontal
     |        +   - crossed
     |        x   - crossed diagonal
     |        o   - small circle
     |        O   - large circle
     |        .   - dots
     |        *   - stars
     |
     |      Letters can be combined, in which case all the specified
     |      hatchings are done.  If same letter repeats, it increases the
     |      density of hatching of that pattern.
     |
     |      Hatching is supported in the PostScript, PDF, SVG and Agg
     |      backends only.
     |
     |      Parameters
     |      ----------
     |      hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
     |
     |  set_joinstyle(self, s)
     |      Set the joinstyle.
     |
     |      Parameters
     |      ----------
     |      s : {'miter', 'round', 'bevel'}
     |
     |  set_linestyle(self, ls)
     |      Set the patch linestyle.
     |
     |      ===========================   =================
     |      linestyle                     description
     |      ===========================   =================
     |      ``'-'`` or ``'solid'``        solid line
     |      ``'--'`` or  ``'dashed'``     dashed line
     |      ``'-.'`` or  ``'dashdot'``    dash-dotted line
     |      ``':'`` or ``'dotted'``       dotted line
     |      ===========================   =================
     |
     |      Alternatively a dash tuple of the following form can be provided::
     |
     |          (offset, onoffseq)
     |
     |      where ``onoffseq`` is an even length tuple of on and off ink in points.
     |
     |      Parameters
     |      ----------
     |      ls : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
     |          The line style.
     |
     |  set_linewidth(self, w)
     |      Set the patch linewidth in points.
     |
     |      Parameters
     |      ----------
     |      w : float or None
     |
     |  set_ls(self, ls)
     |      Alias for `set_linestyle`.
     |
     |  set_lw(self, w)
     |      Alias for `set_linewidth`.
     |
     |  update_from(self, other)
     |      Copy properties from *other* to *self*.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Patch:
     |
     |  fill
     |      Return whether the patch is filled.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Patch:
     |
     |  validCap = ('butt', 'round', 'projecting')
     |
     |  validJoin = ('miter', 'round', 'bevel')
     |
     |  zorder = 1
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from matplotlib.artist.Artist:
     |
     |  __getstate__(self)
     |
     |  add_callback(self, func)
     |      Add a callback function that will be called whenever one of the
     |      `.Artist`'s properties changes.
     |
     |      Parameters
     |      ----------
     |      func : callable
     |          The callback function. It must have the signature::
     |
     |              def func(artist: Artist) -> Any
     |
     |          where *artist* is the calling `.Artist`. Return values may exist
     |          but are ignored.
     |
     |      Returns
     |      -------
     |      int
     |          The observer id associated with the callback. This id can be
     |          used for removing the callback with `.remove_callback` later.
     |
     |      See Also
     |      --------
     |      remove_callback
     |
     |  convert_xunits(self, x)
     |      Convert *x* using the unit type of the xaxis.
     |
     |      If the artist is not in contained in an Axes or if the xaxis does not
     |      have units, *x* itself is returned.
     |
     |  convert_yunits(self, y)
     |      Convert *y* using the unit type of the yaxis.
     |
     |      If the artist is not in contained in an Axes or if the yaxis does not
     |      have units, *y* itself is returned.
     |
     |  findobj(self, match=None, include_self=True)
     |      Find artist objects.
     |
     |      Recursively find all `.Artist` instances contained in the artist.
     |
     |      Parameters
     |      ----------
     |      match
     |          A filter criterion for the matches. This can be
     |
     |          - *None*: Return all objects contained in artist.
     |          - A function with signature ``def match(artist: Artist) -> bool``.
     |            The result will only contain artists for which the function
     |            returns *True*.
     |          - A class instance: e.g., `.Line2D`. The result will only contain
     |            artists of this class or its subclasses (``isinstance`` check).
     |
     |      include_self : bool
     |          Include *self* in the list to be checked for a match.
     |
     |      Returns
     |      -------
     |      list of `.Artist`
     |
     |  format_cursor_data(self, data)
     |      Return a string representation of *data*.
     |
     |      .. note::
     |          This method is intended to be overridden by artist subclasses.
     |          As an end-user of Matplotlib you will most likely not call this
     |          method yourself.
     |
     |      The default implementation converts ints and floats and arrays of ints
     |      and floats into a comma-separated string enclosed in square brackets.
     |
     |      See Also
     |      --------
     |      get_cursor_data
     |
     |  get_agg_filter(self)
     |      Return filter function to be used for agg filter.
     |
     |  get_alpha(self)
     |      Return the alpha value used for blending - not supported on all
     |      backends.
     |
     |  get_animated(self)
     |      Return whether the artist is animated.
     |
     |  get_children(self)
     |      Return a list of the child `.Artist`\s of this `.Artist`.
     |
     |  get_clip_box(self)
     |      Return the clipbox.
     |
     |  get_clip_on(self)
     |      Return whether the artist uses clipping.
     |
     |  get_clip_path(self)
     |      Return the clip path.
     |
     |  get_contains(self)
     |      [*Deprecated*] Return the custom contains function of the artist if set, or *None*.
     |
     |      See Also
     |      --------
     |      set_contains
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  get_cursor_data(self, event)
     |      Return the cursor data for a given event.
     |
     |      .. note::
     |          This method is intended to be overridden by artist subclasses.
     |          As an end-user of Matplotlib you will most likely not call this
     |          method yourself.
     |
     |      Cursor data can be used by Artists to provide additional context
     |      information for a given event. The default implementation just returns
     |      *None*.
     |
     |      Subclasses can override the method and return arbitrary data. However,
     |      when doing so, they must ensure that `.format_cursor_data` can convert
     |      the data to a string representation.
     |
     |      The only current use case is displaying the z-value of an `.AxesImage`
     |      in the status bar of a plot window, while moving the mouse.
     |
     |      Parameters
     |      ----------
     |      event : `matplotlib.backend_bases.MouseEvent`
     |
     |      See Also
     |      --------
     |      format_cursor_data
     |
     |  get_figure(self)
     |      Return the `.Figure` instance the artist belongs to.
     |
     |  get_gid(self)
     |      Return the group id.
     |
     |  get_in_layout(self)
     |      Return boolean flag, ``True`` if artist is included in layout
     |      calculations.
     |
     |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,
     |      `.Figure.tight_layout()`, and
     |      ``fig.savefig(fname, bbox_inches='tight')``.
     |
     |  get_label(self)
     |      Return the label used for this artist in the legend.
     |
     |  get_path_effects(self)
     |
     |  get_picker(self)
     |      Return the picking behavior of the artist.
     |
     |      The possible values are described in `.set_picker`.
     |
     |      See Also
     |      --------
     |      set_picker, pickable, pick
     |
     |  get_rasterized(self)
     |      Return whether the artist is to be rasterized.
     |
     |  get_sketch_params(self)
     |      Return the sketch parameters for the artist.
     |
     |      Returns
     |      -------
     |      tuple or None
     |
     |          A 3-tuple with the following elements:
     |
     |          - *scale*: The amplitude of the wiggle perpendicular to the
     |            source line.
     |          - *length*: The length of the wiggle along the line.
     |          - *randomness*: The scale factor by which the length is
     |            shrunken or expanded.
     |
     |          Returns *None* if no sketch parameters were set.
     |
     |  get_snap(self)
     |      Return the snap setting.
     |
     |      See `.set_snap` for details.
     |
     |  get_tightbbox(self, renderer)
     |      Like `.Artist.get_window_extent`, but includes any clipping.
     |
     |      Parameters
     |      ----------
     |      renderer : `.RendererBase` subclass
     |          renderer that will be used to draw the figures (i.e.
     |          ``fig.canvas.get_renderer()``)
     |
     |      Returns
     |      -------
     |      `.Bbox`
     |          The enclosing bounding box (in figure pixel coordinates).
     |
     |  get_transformed_clip_path_and_affine(self)
     |      Return the clip path with the non-affine part of its
     |      transformation applied, and the remaining affine part of its
     |      transformation.
     |
     |  get_url(self)
     |      Return the url.
     |
     |  get_visible(self)
     |      Return the visibility.
     |
     |  get_zorder(self)
     |      Return the artist's zorder.
     |
     |  have_units(self)
     |      Return *True* if units are set on any axis.
     |
     |  is_transform_set(self)
     |      Return whether the Artist has an explicitly set transform.
     |
     |      This is *True* after `.set_transform` has been called.
     |
     |  pchanged(self)
     |      Call all of the registered callbacks.
     |
     |      This function is triggered internally when a property is changed.
     |
     |      See Also
     |      --------
     |      add_callback
     |      remove_callback
     |
     |  pick(self, mouseevent)
     |      Process a pick event.
     |
     |      Each child artist will fire a pick event if *mouseevent* is over
     |      the artist and the artist has picker set.
     |
     |      See Also
     |      --------
     |      set_picker, get_picker, pickable
     |
     |  pickable(self)
     |      Return whether the artist is pickable.
     |
     |      See Also
     |      --------
     |      set_picker, get_picker, pick
     |
     |  properties(self)
     |      Return a dictionary of all the properties of the artist.
     |
     |  remove(self)
     |      Remove the artist from the figure if possible.
     |
     |      The effect will not be visible until the figure is redrawn, e.g.,
     |      with `.FigureCanvasBase.draw_idle`.  Call `~.axes.Axes.relim` to
     |      update the axes limits if desired.
     |
     |      Note: `~.axes.Axes.relim` will not see collections even if the
     |      collection was added to the axes with *autolim* = True.
     |
     |      Note: there is no support for removing the artist's legend entry.
     |
     |  remove_callback(self, oid)
     |      Remove a callback based on its observer id.
     |
     |      See Also
     |      --------
     |      add_callback
     |
     |  set(self, **kwargs)
     |      A property batch setter.  Pass *kwargs* to set properties.
     |
     |  set_agg_filter(self, filter_func)
     |      Set the agg filter.
     |
     |      Parameters
     |      ----------
     |      filter_func : callable
     |          A filter function, which takes a (m, n, 3) float array and a dpi
     |          value, and returns a (m, n, 3) array.
     |
     |          .. ACCEPTS: a filter function, which takes a (m, n, 3) float array
     |              and a dpi value, and returns a (m, n, 3) array
     |
     |  set_animated(self, b)
     |      Set the artist's animation state.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_clip_box(self, clipbox)
     |      Set the artist's clip `.Bbox`.
     |
     |      Parameters
     |      ----------
     |      clipbox : `.Bbox`
     |
     |  set_clip_on(self, b)
     |      Set whether the artist uses clipping.
     |
     |      When False artists will be visible outside of the axes which
     |      can lead to unexpected results.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_clip_path(self, path, transform=None)
     |      Set the artist's clip path.
     |
     |      Parameters
     |      ----------
     |      path : `.Patch` or `.Path` or `.TransformedPath` or None
     |          The clip path. If given a `.Path`, *transform* must be provided as
     |          well. If *None*, a previously set clip path is removed.
     |      transform : `~matplotlib.transforms.Transform`, optional
     |          Only used if *path* is a `.Path`, in which case the given `.Path`
     |          is converted to a `.TransformedPath` using *transform*.
     |
     |      Notes
     |      -----
     |      For efficiency, if *path* is a `.Rectangle` this method will set the
     |      clipping box to the corresponding rectangle and set the clipping path
     |      to ``None``.
     |
     |      For technical reasons (support of `~.Artist.set`), a tuple
     |      (*path*, *transform*) is also accepted as a single positional
     |      parameter.
     |
     |      .. ACCEPTS: Patch or (Path, Transform) or None
     |
     |  set_contains(self, picker)
     |      [*Deprecated*] Define a custom contains test for the artist.
     |
     |      The provided callable replaces the default `.contains` method
     |      of the artist.
     |
     |      Parameters
     |      ----------
     |      picker : callable
     |          A custom picker function to evaluate if an event is within the
     |          artist. The function must have the signature::
     |
     |              def contains(artist: Artist, event: MouseEvent) -> bool, dict
     |
     |          that returns:
     |
     |          - a bool indicating if the event is within the artist
     |          - a dict of additional information. The dict should at least
     |            return the same information as the default ``contains()``
     |            implementation of the respective artist, but may provide
     |            additional information.
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  set_figure(self, fig)
     |      Set the `.Figure` instance the artist belongs to.
     |
     |      Parameters
     |      ----------
     |      fig : `.Figure`
     |
     |  set_gid(self, gid)
     |      Set the (group) id for the artist.
     |
     |      Parameters
     |      ----------
     |      gid : str
     |
     |  set_in_layout(self, in_layout)
     |      Set if artist is to be included in layout calculations,
     |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,
     |      `.Figure.tight_layout()`, and
     |      ``fig.savefig(fname, bbox_inches='tight')``.
     |
     |      Parameters
     |      ----------
     |      in_layout : bool
     |
     |  set_label(self, s)
     |      Set a label that will be displayed in the legend.
     |
     |      Parameters
     |      ----------
     |      s : object
     |          *s* will be converted to a string by calling `str`.
     |
     |  set_path_effects(self, path_effects)
     |      Set the path effects.
     |
     |      Parameters
     |      ----------
     |      path_effects : `.AbstractPathEffect`
     |
     |  set_picker(self, picker)
     |      Define the picking behavior of the artist.
     |
     |      Parameters
     |      ----------
     |      picker : None or bool or callable
     |          This can be one of the following:
     |
     |          - *None*: Picking is disabled for this artist (default).
     |
     |          - A boolean: If *True* then picking will be enabled and the
     |            artist will fire a pick event if the mouse event is over
     |            the artist.
     |
     |          - A function: If picker is callable, it is a user supplied
     |            function which determines whether the artist is hit by the
     |            mouse event::
     |
     |              hit, props = picker(artist, mouseevent)
     |
     |            to determine the hit test.  if the mouse event is over the
     |            artist, return *hit=True* and props is a dictionary of
     |            properties you want added to the PickEvent attributes.
     |
     |          - *deprecated*: For `.Line2D` only, *picker* can also be a float
     |            that sets the tolerance for checking whether an event occurred
     |            "on" the line; this is deprecated.  Use `.Line2D.set_pickradius`
     |            instead.
     |
     |  set_rasterized(self, rasterized)
     |      Force rasterized (bitmap) drawing in vector backend output.
     |
     |      Defaults to None, which implies the backend's default behavior.
     |
     |      Parameters
     |      ----------
     |      rasterized : bool or None
     |
     |  set_sketch_params(self, scale=None, length=None, randomness=None)
     |      Sets the sketch parameters.
     |
     |      Parameters
     |      ----------
     |      scale : float, optional
     |          The amplitude of the wiggle perpendicular to the source
     |          line, in pixels.  If scale is `None`, or not provided, no
     |          sketch filter will be provided.
     |      length : float, optional
     |           The length of the wiggle along the line, in pixels
     |           (default 128.0)
     |      randomness : float, optional
     |          The scale factor by which the length is shrunken or
     |          expanded (default 16.0)
     |
     |          .. ACCEPTS: (scale: float, length: float, randomness: float)
     |
     |  set_snap(self, snap)
     |      Set the snapping behavior.
     |
     |      Snapping aligns positions with the pixel grid, which results in
     |      clearer images. For example, if a black line of 1px width was
     |      defined at a position in between two pixels, the resulting image
     |      would contain the interpolated value of that line in the pixel grid,
     |      which would be a grey value on both adjacent pixel positions. In
     |      contrast, snapping will move the line to the nearest integer pixel
     |      value, so that the resulting image will really contain a 1px wide
     |      black line.
     |
     |      Snapping is currently only supported by the Agg and MacOSX backends.
     |
     |      Parameters
     |      ----------
     |      snap : bool or None
     |          Possible values:
     |
     |          - *True*: Snap vertices to the nearest pixel center.
     |          - *False*: Do not modify vertex positions.
     |          - *None*: (auto) If the path contains only rectilinear line
     |            segments, round to the nearest pixel center.
     |
     |  set_transform(self, t)
     |      Set the artist transform.
     |
     |      Parameters
     |      ----------
     |      t : `.Transform`
     |
     |  set_url(self, url)
     |      Set the url for the artist.
     |
     |      Parameters
     |      ----------
     |      url : str
     |
     |  set_visible(self, b)
     |      Set the artist's visibility.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_zorder(self, level)
     |      Set the zorder for the artist.  Artists with lower zorder
     |      values are drawn first.
     |
     |      Parameters
     |      ----------
     |      level : float
     |
     |  update(self, props)
     |      Update this artist's properties from the dict *props*.
     |
     |      Parameters
     |      ----------
     |      props : dict
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from matplotlib.artist.Artist:
     |
     |  sticky_edges
     |      ``x`` and ``y`` sticky edge lists for autoscaling.
     |
     |      When performing autoscaling, if a data limit coincides with a value in
     |      the corresponding sticky_edges list, then no margin will be added--the
     |      view limit "sticks" to the edge. A typical use case is histograms,
     |      where one usually expects no margin on the bottom edge (0) of the
     |      histogram.
     |
     |      This attribute cannot be assigned to; however, the ``x`` and ``y``
     |      lists can be modified in place as needed.
     |
     |      Examples
     |      --------
     |      >>> artist.sticky_edges.x[:] = (xmin, xmax)
     |      >>> artist.sticky_edges.y[:] = (ymin, ymax)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from matplotlib.artist.Artist:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  axes
     |      The `~.axes.Axes` instance the artist resides in, or *None*.
     |
     |  mouseover
     |      If this property is set to *True*, the artist will be queried for
     |      custom context information when the mouse cursor moves over it.
     |
     |      See also :meth:`get_cursor_data`, :class:`.ToolCursorPosition` and
     |      :class:`.NavigationToolbar2`.
     |
     |  stale
     |      Whether the artist is 'stale' and needs to be re-drawn for the output
     |      to match the internal state of the artist.

```python
fig, ax = mp3d.subplots(111, projection='3d', xlim=(0, 6), ylim=(0, 6))
# ax.plot([1.0,2.0,3.0],[4.0,5.0,6.0])
c = patches.Circle((2,3),1)
# mp3d.art3d.patch_2d_to_3d(c)
# col = mp3d.art3d.Patch3DCollection([c])
ax.add_artist(c)
plt.show()
```

```python
ax.plot(1.0,2.0,3.0)
```

    [<mpl_toolkits.mplot3d.art3d.Line3D at 0x56f0d48>]

```python
[s for s in dir(ax) if not s.startswith('_')]
```

    ['M',
     'acorr',
     'add_artist',
     'add_callback',
     'add_child_axes',
     'add_collection',
     'add_collection3d',
     'add_container',
     'add_contour_set',
     'add_contourf_set',
     'add_image',
     'add_line',
     'add_patch',
     'add_table',
     'angle_spectrum',
     'annotate',
     'apply_aspect',
     'arrow',
     'artists',
     'auto_scale_xyz',
     'autoscale',
     'autoscale_view',
     'axes',
     'axhline',
     'axhspan',
     'axis',
     'axison',
     'axline',
     'axvline',
     'axvspan',
     'azim',
     'bar',
     'bar3d',
     'barbs',
     'barh',
     'bbox',
     'boxplot',
     'broken_barh',
     'button_pressed',
     'bxp',
     'callbacks',
     'can_pan',
     'can_zoom',
     'change_geometry',
     'child_axes',
     'cla',
     'clabel',
     'clear',
     'clipbox',
     'cohere',
     'colNum',
     'collections',
     'containers',
     'contains',
     'contains_point',
     'contour',
     'contour3D',
     'contourf',
     'contourf3D',
     'convert_xunits',
     'convert_yunits',
     'convert_zunits',
     'csd',
     'dataLim',
     'disable_mouse_rotation',
     'dist',
     'drag_pan',
     'draw',
     'draw_artist',
     'elev',
     'end_pan',
     'errorbar',
     'eventplot',
     'eventson',
     'eye',
     'figbox',
     'figure',
     'fill',
     'fill_between',
     'fill_betweenx',
     'findobj',
     'fmt_xdata',
     'fmt_ydata',
     'fmt_zdata',
     'format_coord',
     'format_cursor_data',
     'format_xdata',
     'format_ydata',
     'format_zdata',
     'get_adjustable',
     'get_agg_filter',
     'get_alpha',
     'get_anchor',
     'get_animated',
     'get_aspect',
     'get_autoscale_on',
     'get_autoscalex_on',
     'get_autoscaley_on',
     'get_autoscalez_on',
     'get_axes_locator',
     'get_axis_position',
     'get_axisbelow',
     'get_box_aspect',
     'get_children',
     'get_clip_box',
     'get_clip_on',
     'get_clip_path',
     'get_contains',
     'get_cursor_data',
     'get_data_ratio',
     'get_data_ratio_log',
     'get_default_bbox_extra_artists',
     'get_facecolor',
     'get_fc',
     'get_figure',
     'get_frame_on',
     'get_geometry',
     'get_gid',
     'get_gridspec',
     'get_images',
     'get_in_layout',
     'get_label',
     'get_legend',
     'get_legend_handles_labels',
     'get_lines',
     'get_navigate',
     'get_navigate_mode',
     'get_path_effects',
     'get_picker',
     'get_position',
     'get_proj',
     'get_rasterization_zorder',
     'get_rasterized',
     'get_renderer_cache',
     'get_shared_x_axes',
     'get_shared_y_axes',
     'get_sketch_params',
     'get_snap',
     'get_subplotspec',
     'get_tightbbox',
     'get_title',
     'get_transform',
     'get_transformed_clip_path_and_affine',
     'get_url',
     'get_visible',
     'get_w_lims',
     'get_window_extent',
     'get_xaxis',
     'get_xaxis_text1_transform',
     'get_xaxis_text2_transform',
     'get_xaxis_transform',
     'get_xbound',
     'get_xgridlines',
     'get_xlabel',
     'get_xlim',
     'get_xlim3d',
     'get_xmajorticklabels',
     'get_xminorticklabels',
     'get_xscale',
     'get_xticklabels',
     'get_xticklines',
     'get_xticks',
     'get_yaxis',
     'get_yaxis_text1_transform',
     'get_yaxis_text2_transform',
     'get_yaxis_transform',
     'get_ybound',
     'get_ygridlines',
     'get_ylabel',
     'get_ylim',
     'get_ylim3d',
     'get_ymajorticklabels',
     'get_yminorticklabels',
     'get_yscale',
     'get_yticklabels',
     'get_yticklines',
     'get_yticks',
     'get_zaxis',
     'get_zbound',
     'get_zgridlines',
     'get_zlabel',
     'get_zlim',
     'get_zlim3d',
     'get_zmajorticklabels',
     'get_zminorticklabels',
     'get_zorder',
     'get_zscale',
     'get_zticklabels',
     'get_zticklines',
     'get_zticks',
     'grid',
     'has_data',
     'have_units',
     'hexbin',
     'hist',
     'hist2d',
     'hlines',
     'ignore_existing_data_limits',
     'images',
     'imshow',
     'in_axes',
     'indicate_inset',
     'indicate_inset_zoom',
     'initial_azim',
     'initial_elev',
     'inset_axes',
     'invert_xaxis',
     'invert_yaxis',
     'invert_zaxis',
     'is_first_col',
     'is_first_row',
     'is_last_col',
     'is_last_row',
     'is_transform_set',
     'label_outer',
     'legend',
     'legend_',
     'lines',
     'locator_params',
     'loglog',
     'magnitude_spectrum',
     'margins',
     'matshow',
     'minorticks_off',
     'minorticks_on',
     'mouse_init',
     'mouseover',
     'name',
     'numCols',
     'numRows',
     'patch',
     'patches',
     'pchanged',
     'pcolor',
     'pcolorfast',
     'pcolormesh',
     'phase_spectrum',
     'pick',
     'pickable',
     'pie',
     'plot',
     'plot3D',
     'plot_date',
     'plot_surface',
     'plot_trisurf',
     'plot_wireframe',
     'properties',
     'psd',
     'quiver',
     'quiver3D',
     'quiverkey',
     'redraw_in_frame',
     'relim',
     'remove',
     'remove_callback',
     'reset_position',
     'rowNum',
     'scatter',
     'scatter3D',
     'secondary_xaxis',
     'secondary_yaxis',
     'semilogx',
     'semilogy',
     'set',
     'set_adjustable',
     'set_agg_filter',
     'set_alpha',
     'set_anchor',
     'set_animated',
     'set_aspect',
     'set_autoscale_on',
     'set_autoscalex_on',
     'set_autoscaley_on',
     'set_autoscalez_on',
     'set_axes_locator',
     'set_axis_off',
     'set_axis_on',
     'set_axisbelow',
     'set_box_aspect',
     'set_clip_box',
     'set_clip_on',
     'set_clip_path',
     'set_contains',
     'set_facecolor',
     'set_fc',
     'set_figure',
     'set_frame_on',
     'set_gid',
     'set_in_layout',
     'set_label',
     'set_navigate',
     'set_navigate_mode',
     'set_path_effects',
     'set_picker',
     'set_position',
     'set_proj_type',
     'set_prop_cycle',
     'set_rasterization_zorder',
     'set_rasterized',
     'set_sketch_params',
     'set_snap',
     'set_subplotspec',
     'set_title',
     'set_top_view',
     'set_transform',
     'set_url',
     'set_visible',
     'set_xbound',
     'set_xlabel',
     'set_xlim',
     'set_xlim3d',
     'set_xmargin',
     'set_xscale',
     'set_xticklabels',
     'set_xticks',
     'set_ybound',
     'set_ylabel',
     'set_ylim',
     'set_ylim3d',
     'set_ymargin',
     'set_yscale',
     'set_yticklabels',
     'set_yticks',
     'set_zbound',
     'set_zlabel',
     'set_zlim',
     'set_zlim3d',
     'set_zmargin',
     'set_zorder',
     'set_zscale',
     'set_zticklabels',
     'set_zticks',
     'sharex',
     'sharey',
     'specgram',
     'spines',
     'spy',
     'stackplot',
     'stale',
     'stale_callback',
     'start_pan',
     'stem',
     'step',
     'sticky_edges',
     'streamplot',
     'table',
     'tables',
     'text',
     'text2D',
     'text3D',
     'texts',
     'tick_params',
     'ticklabel_format',
     'title',
     'titleOffsetTrans',
     'transAxes',
     'transData',
     'transLimits',
     'transScale',
     'tricontour',
     'tricontourf',
     'tripcolor',
     'triplot',
     'tunit_cube',
     'tunit_edges',
     'twinx',
     'twiny',
     'unit_cube',
     'update',
     'update_datalim',
     'update_datalim_bounds',
     'update_from',
     'update_params',
     'use_sticky_edges',
     'viewLim',
     'view_init',
     'violin',
     'violinplot',
     'vlines',
     'voxels',
     'vvec',
     'w_xaxis',
     'w_yaxis',
     'w_zaxis',
     'xaxis',
     'xaxis_date',
     'xaxis_inverted',
     'xcorr',
     'xy_dataLim',
     'xy_viewLim',
     'yaxis',
     'yaxis_date',
     'yaxis_inverted',
     'zaxis',
     'zaxis_date',
     'zaxis_inverted',
     'zorder',
     'zz_dataLim',
     'zz_viewLim']

```python
plt.show()
```

```python
help(ax.patch)
```

    Help on Rectangle in module matplotlib.patches object:

    class Rectangle(Patch)
     |  Rectangle(xy, width, height, angle=0.0, **kwargs)
     |
     |  A rectangle defined via an anchor point *xy* and its *width* and *height*.
     |
     |  The rectangle extends from ``xy[0]`` to ``xy[0] + width`` in x-direction
     |  and from ``xy[1]`` to ``xy[1] + height`` in y-direction. ::
     |
     |    :                +------------------+
     |    :                |                  |
     |    :              height               |
     |    :                |                  |
     |    :               (xy)---- width -----+
     |
     |  One may picture *xy* as the bottom left corner, but which corner *xy* is
     |  actually depends on the the direction of the axis and the sign of *width*
     |  and *height*; e.g. *xy* would be the bottom right corner if the x-axis
     |  was inverted or if *width* was negative.
     |
     |  Method resolution order:
     |      Rectangle
     |      Patch
     |      matplotlib.artist.Artist
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, xy, width, height, angle=0.0, **kwargs)
     |      Parameters
     |      ----------
     |      xy : (float, float)
     |          The anchor point.
     |      width : float
     |          Rectangle width.
     |      height : float
     |          Rectangle height.
     |      angle : float, default: 0
     |          Rotation in degrees anti-clockwise about *xy*.
     |
     |      Other Parameters
     |      ----------------
     |      **kwargs : `.Patch` properties
     |          Properties:
     |          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
     |          alpha: float or None
     |          animated: bool
     |          antialiased or aa: unknown
     |          capstyle: {'butt', 'round', 'projecting'}
     |          clip_box: `.Bbox`
     |          clip_on: bool
     |          clip_path: Patch or (Path, Transform) or None
     |          color: color
     |          contains: unknown
     |          edgecolor or ec: color or None or 'auto'
     |          facecolor or fc: color or None
     |          figure: `.Figure`
     |          fill: bool
     |          gid: str
     |          hatch: {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
     |          in_layout: bool
     |          joinstyle: {'miter', 'round', 'bevel'}
     |          label: object
     |          linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
     |          linewidth or lw: float or None
     |          path_effects: `.AbstractPathEffect`
     |          picker: None or bool or callable
     |          rasterized: bool or None
     |          sketch_params: (scale: float, length: float, randomness: float)
     |          snap: bool or None
     |          transform: `.Transform`
     |          url: str
     |          visible: bool
     |          zorder: float
     |
     |  __str__(self)
     |      Return str(self).
     |
     |  get_bbox(self)
     |      Return the `.Bbox`.
     |
     |  get_height(self)
     |      Return the height of the rectangle.
     |
     |  get_patch_transform(self)
     |      Return the `~.transforms.Transform` instance mapping patch coordinates
     |      to data coordinates.
     |
     |      For example, one may define a patch of a circle which represents a
     |      radius of 5 by providing coordinates for a unit circle, and a
     |      transform which scales the coordinates (the patch coordinate) by 5.
     |
     |  get_path(self)
     |      Return the vertices of the rectangle.
     |
     |  get_width(self)
     |      Return the width of the rectangle.
     |
     |  get_x(self)
     |      Return the left coordinate of the rectangle.
     |
     |  get_xy(self)
     |      Return the left and bottom coords of the rectangle as a tuple.
     |
     |  get_y(self)
     |      Return the bottom coordinate of the rectangle.
     |
     |  set_bounds(self, *args)
     |      Set the bounds of the rectangle as *left*, *bottom*, *width*, *height*.
     |
     |      The values may be passed as separate parameters or as a tuple::
     |
     |          set_bounds(left, bottom, width, height)
     |          set_bounds((left, bottom, width, height))
     |
     |      .. ACCEPTS: (left, bottom, width, height)
     |
     |  set_height(self, h)
     |      Set the height of the rectangle.
     |
     |  set_width(self, w)
     |      Set the width of the rectangle.
     |
     |  set_x(self, x)
     |      Set the left coordinate of the rectangle.
     |
     |  set_xy(self, xy)
     |      Set the left and bottom coordinates of the rectangle.
     |
     |      Parameters
     |      ----------
     |      xy : (float, float)
     |
     |  set_y(self, y)
     |      Set the bottom coordinate of the rectangle.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  xy
     |      Return the left and bottom coords of the rectangle as a tuple.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Patch:
     |
     |  contains(self, mouseevent, radius=None)
     |      Test whether the mouse event occurred in the patch.
     |
     |      Returns
     |      -------
     |      (bool, empty dict)
     |
     |  contains_point(self, point, radius=None)
     |      Return whether the given point is inside the patch.
     |
     |      Parameters
     |      ----------
     |      point : (float, float)
     |          The point (x, y) to check, in target coordinates of
     |          ``self.get_transform()``. These are display coordinates for patches
     |          that are added to a figure or axes.
     |      radius : float, optional
     |          Add an additional margin on the patch in target coordinates of
     |          ``self.get_transform()``. See `.Path.contains_point` for further
     |          details.
     |
     |      Returns
     |      -------
     |      bool
     |
     |      Notes
     |      -----
     |      The proper use of this method depends on the transform of the patch.
     |      Isolated patches do not have a transform. In this case, the patch
     |      creation coordinates and the point coordinates match. The following
     |      example checks that the center of a circle is within the circle
     |
     |      >>> center = 0, 0
     |      >>> c = Circle(center, radius=1)
     |      >>> c.contains_point(center)
     |      True
     |
     |      The convention of checking against the transformed patch stems from
     |      the fact that this method is predominantly used to check if display
     |      coordinates (e.g. from mouse events) are within the patch. If you want
     |      to do the above check with data coordinates, you have to properly
     |      transform them first:
     |
     |      >>> center = 0, 0
     |      >>> c = Circle(center, radius=1)
     |      >>> plt.gca().add_patch(c)
     |      >>> transformed_center = c.get_transform().transform(center)
     |      >>> c.contains_point(transformed_center)
     |      True
     |
     |  contains_points(self, points, radius=None)
     |      Return whether the given points are inside the patch.
     |
     |      Parameters
     |      ----------
     |      points : (N, 2) array
     |          The points to check, in target coordinates of
     |          ``self.get_transform()``. These are display coordinates for patches
     |          that are added to a figure or axes. Columns contain x and y values.
     |      radius : float, optional
     |          Add an additional margin on the patch in target coordinates of
     |          ``self.get_transform()``. See `.Path.contains_point` for further
     |          details.
     |
     |      Returns
     |      -------
     |      length-N bool array
     |
     |      Notes
     |      -----
     |      The proper use of this method depends on the transform of the patch.
     |      See the notes on `.Patch.contains_point`.
     |
     |  draw(self, renderer)
     |      Draw the Artist (and its children) using the given renderer.
     |
     |      This has no effect if the artist is not visible (`.Artist.get_visible`
     |      returns False).
     |
     |      Parameters
     |      ----------
     |      renderer : `.RendererBase` subclass.
     |
     |      Notes
     |      -----
     |      This method is overridden in the Artist subclasses.
     |
     |  get_aa(self)
     |      Alias for `get_antialiased`.
     |
     |  get_antialiased(self)
     |      Return whether antialiasing is used for drawing.
     |
     |  get_capstyle(self)
     |      Return the capstyle.
     |
     |  get_data_transform(self)
     |      Return the `~.transforms.Transform` mapping data coordinates to
     |      physical coordinates.
     |
     |  get_ec(self)
     |      Alias for `get_edgecolor`.
     |
     |  get_edgecolor(self)
     |      Return the edge color.
     |
     |  get_extents(self)
     |      Return the `Patch`'s axis-aligned extents as a `~.transforms.Bbox`.
     |
     |  get_facecolor(self)
     |      Return the face color.
     |
     |  get_fc(self)
     |      Alias for `get_facecolor`.
     |
     |  get_fill(self)
     |      Return whether the patch is filled.
     |
     |  get_hatch(self)
     |      Return the hatching pattern.
     |
     |  get_joinstyle(self)
     |      Return the joinstyle.
     |
     |  get_linestyle(self)
     |      Return the linestyle.
     |
     |  get_linewidth(self)
     |      Return the line width in points.
     |
     |  get_ls(self)
     |      Alias for `get_linestyle`.
     |
     |  get_lw(self)
     |      Alias for `get_linewidth`.
     |
     |  get_transform(self)
     |      Return the `~.transforms.Transform` applied to the `Patch`.
     |
     |  get_verts(self)
     |      Return a copy of the vertices used in this patch.
     |
     |      If the patch contains Bezier curves, the curves will be interpolated by
     |      line segments.  To access the curves as curves, use `get_path`.
     |
     |  get_window_extent(self, renderer=None)
     |      Get the axes bounding box in display space.
     |
     |      The bounding box' width and height are nonnegative.
     |
     |      Subclasses should override for inclusion in the bounding box
     |      "tight" calculation. Default is to return an empty bounding
     |      box at 0, 0.
     |
     |      Be careful when using this function, the results will not update
     |      if the artist window extent of the artist changes.  The extent
     |      can change due to any changes in the transform stack, such as
     |      changing the axes limits, the figure size, or the canvas used
     |      (as is done when saving a figure).  This can lead to unexpected
     |      behavior where interactive figures will look fine on the screen,
     |      but will save incorrectly.
     |
     |  set_aa(self, aa)
     |      Alias for `set_antialiased`.
     |
     |  set_alpha(self, alpha)
     |      Set the alpha value used for blending - not supported on all backends.
     |
     |      Parameters
     |      ----------
     |      alpha : float or None
     |
     |  set_antialiased(self, aa)
     |      Set whether to use antialiased rendering.
     |
     |      Parameters
     |      ----------
     |      b : bool or None
     |
     |  set_capstyle(self, s)
     |      Set the capstyle.
     |
     |      Parameters
     |      ----------
     |      s : {'butt', 'round', 'projecting'}
     |
     |  set_color(self, c)
     |      Set both the edgecolor and the facecolor.
     |
     |      Parameters
     |      ----------
     |      c : color
     |
     |      See Also
     |      --------
     |      Patch.set_facecolor, Patch.set_edgecolor
     |          For setting the edge or face color individually.
     |
     |  set_ec(self, color)
     |      Alias for `set_edgecolor`.
     |
     |  set_edgecolor(self, color)
     |      Set the patch edge color.
     |
     |      Parameters
     |      ----------
     |      color : color or None or 'auto'
     |
     |  set_facecolor(self, color)
     |      Set the patch face color.
     |
     |      Parameters
     |      ----------
     |      color : color or None
     |
     |  set_fc(self, color)
     |      Alias for `set_facecolor`.
     |
     |  set_fill(self, b)
     |      Set whether to fill the patch.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_hatch(self, hatch)
     |      Set the hatching pattern.
     |
     |      *hatch* can be one of::
     |
     |        /   - diagonal hatching
     |        \   - back diagonal
     |        |   - vertical
     |        -   - horizontal
     |        +   - crossed
     |        x   - crossed diagonal
     |        o   - small circle
     |        O   - large circle
     |        .   - dots
     |        *   - stars
     |
     |      Letters can be combined, in which case all the specified
     |      hatchings are done.  If same letter repeats, it increases the
     |      density of hatching of that pattern.
     |
     |      Hatching is supported in the PostScript, PDF, SVG and Agg
     |      backends only.
     |
     |      Parameters
     |      ----------
     |      hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
     |
     |  set_joinstyle(self, s)
     |      Set the joinstyle.
     |
     |      Parameters
     |      ----------
     |      s : {'miter', 'round', 'bevel'}
     |
     |  set_linestyle(self, ls)
     |      Set the patch linestyle.
     |
     |      ===========================   =================
     |      linestyle                     description
     |      ===========================   =================
     |      ``'-'`` or ``'solid'``        solid line
     |      ``'--'`` or  ``'dashed'``     dashed line
     |      ``'-.'`` or  ``'dashdot'``    dash-dotted line
     |      ``':'`` or ``'dotted'``       dotted line
     |      ===========================   =================
     |
     |      Alternatively a dash tuple of the following form can be provided::
     |
     |          (offset, onoffseq)
     |
     |      where ``onoffseq`` is an even length tuple of on and off ink in points.
     |
     |      Parameters
     |      ----------
     |      ls : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
     |          The line style.
     |
     |  set_linewidth(self, w)
     |      Set the patch linewidth in points.
     |
     |      Parameters
     |      ----------
     |      w : float or None
     |
     |  set_ls(self, ls)
     |      Alias for `set_linestyle`.
     |
     |  set_lw(self, w)
     |      Alias for `set_linewidth`.
     |
     |  update_from(self, other)
     |      Copy properties from *other* to *self*.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Patch:
     |
     |  fill
     |      Return whether the patch is filled.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Patch:
     |
     |  validCap = ('butt', 'round', 'projecting')
     |
     |  validJoin = ('miter', 'round', 'bevel')
     |
     |  zorder = 1
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from matplotlib.artist.Artist:
     |
     |  __getstate__(self)
     |
     |  add_callback(self, func)
     |      Add a callback function that will be called whenever one of the
     |      `.Artist`'s properties changes.
     |
     |      Parameters
     |      ----------
     |      func : callable
     |          The callback function. It must have the signature::
     |
     |              def func(artist: Artist) -> Any
     |
     |          where *artist* is the calling `.Artist`. Return values may exist
     |          but are ignored.
     |
     |      Returns
     |      -------
     |      int
     |          The observer id associated with the callback. This id can be
     |          used for removing the callback with `.remove_callback` later.
     |
     |      See Also
     |      --------
     |      remove_callback
     |
     |  convert_xunits(self, x)
     |      Convert *x* using the unit type of the xaxis.
     |
     |      If the artist is not in contained in an Axes or if the xaxis does not
     |      have units, *x* itself is returned.
     |
     |  convert_yunits(self, y)
     |      Convert *y* using the unit type of the yaxis.
     |
     |      If the artist is not in contained in an Axes or if the yaxis does not
     |      have units, *y* itself is returned.
     |
     |  findobj(self, match=None, include_self=True)
     |      Find artist objects.
     |
     |      Recursively find all `.Artist` instances contained in the artist.
     |
     |      Parameters
     |      ----------
     |      match
     |          A filter criterion for the matches. This can be
     |
     |          - *None*: Return all objects contained in artist.
     |          - A function with signature ``def match(artist: Artist) -> bool``.
     |            The result will only contain artists for which the function
     |            returns *True*.
     |          - A class instance: e.g., `.Line2D`. The result will only contain
     |            artists of this class or its subclasses (``isinstance`` check).
     |
     |      include_self : bool
     |          Include *self* in the list to be checked for a match.
     |
     |      Returns
     |      -------
     |      list of `.Artist`
     |
     |  format_cursor_data(self, data)
     |      Return a string representation of *data*.
     |
     |      .. note::
     |          This method is intended to be overridden by artist subclasses.
     |          As an end-user of Matplotlib you will most likely not call this
     |          method yourself.
     |
     |      The default implementation converts ints and floats and arrays of ints
     |      and floats into a comma-separated string enclosed in square brackets.
     |
     |      See Also
     |      --------
     |      get_cursor_data
     |
     |  get_agg_filter(self)
     |      Return filter function to be used for agg filter.
     |
     |  get_alpha(self)
     |      Return the alpha value used for blending - not supported on all
     |      backends.
     |
     |  get_animated(self)
     |      Return whether the artist is animated.
     |
     |  get_children(self)
     |      Return a list of the child `.Artist`\s of this `.Artist`.
     |
     |  get_clip_box(self)
     |      Return the clipbox.
     |
     |  get_clip_on(self)
     |      Return whether the artist uses clipping.
     |
     |  get_clip_path(self)
     |      Return the clip path.
     |
     |  get_contains(self)
     |      [*Deprecated*] Return the custom contains function of the artist if set, or *None*.
     |
     |      See Also
     |      --------
     |      set_contains
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  get_cursor_data(self, event)
     |      Return the cursor data for a given event.
     |
     |      .. note::
     |          This method is intended to be overridden by artist subclasses.
     |          As an end-user of Matplotlib you will most likely not call this
     |          method yourself.
     |
     |      Cursor data can be used by Artists to provide additional context
     |      information for a given event. The default implementation just returns
     |      *None*.
     |
     |      Subclasses can override the method and return arbitrary data. However,
     |      when doing so, they must ensure that `.format_cursor_data` can convert
     |      the data to a string representation.
     |
     |      The only current use case is displaying the z-value of an `.AxesImage`
     |      in the status bar of a plot window, while moving the mouse.
     |
     |      Parameters
     |      ----------
     |      event : `matplotlib.backend_bases.MouseEvent`
     |
     |      See Also
     |      --------
     |      format_cursor_data
     |
     |  get_figure(self)
     |      Return the `.Figure` instance the artist belongs to.
     |
     |  get_gid(self)
     |      Return the group id.
     |
     |  get_in_layout(self)
     |      Return boolean flag, ``True`` if artist is included in layout
     |      calculations.
     |
     |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,
     |      `.Figure.tight_layout()`, and
     |      ``fig.savefig(fname, bbox_inches='tight')``.
     |
     |  get_label(self)
     |      Return the label used for this artist in the legend.
     |
     |  get_path_effects(self)
     |
     |  get_picker(self)
     |      Return the picking behavior of the artist.
     |
     |      The possible values are described in `.set_picker`.
     |
     |      See Also
     |      --------
     |      set_picker, pickable, pick
     |
     |  get_rasterized(self)
     |      Return whether the artist is to be rasterized.
     |
     |  get_sketch_params(self)
     |      Return the sketch parameters for the artist.
     |
     |      Returns
     |      -------
     |      tuple or None
     |
     |          A 3-tuple with the following elements:
     |
     |          - *scale*: The amplitude of the wiggle perpendicular to the
     |            source line.
     |          - *length*: The length of the wiggle along the line.
     |          - *randomness*: The scale factor by which the length is
     |            shrunken or expanded.
     |
     |          Returns *None* if no sketch parameters were set.
     |
     |  get_snap(self)
     |      Return the snap setting.
     |
     |      See `.set_snap` for details.
     |
     |  get_tightbbox(self, renderer)
     |      Like `.Artist.get_window_extent`, but includes any clipping.
     |
     |      Parameters
     |      ----------
     |      renderer : `.RendererBase` subclass
     |          renderer that will be used to draw the figures (i.e.
     |          ``fig.canvas.get_renderer()``)
     |
     |      Returns
     |      -------
     |      `.Bbox`
     |          The enclosing bounding box (in figure pixel coordinates).
     |
     |  get_transformed_clip_path_and_affine(self)
     |      Return the clip path with the non-affine part of its
     |      transformation applied, and the remaining affine part of its
     |      transformation.
     |
     |  get_url(self)
     |      Return the url.
     |
     |  get_visible(self)
     |      Return the visibility.
     |
     |  get_zorder(self)
     |      Return the artist's zorder.
     |
     |  have_units(self)
     |      Return *True* if units are set on any axis.
     |
     |  is_transform_set(self)
     |      Return whether the Artist has an explicitly set transform.
     |
     |      This is *True* after `.set_transform` has been called.
     |
     |  pchanged(self)
     |      Call all of the registered callbacks.
     |
     |      This function is triggered internally when a property is changed.
     |
     |      See Also
     |      --------
     |      add_callback
     |      remove_callback
     |
     |  pick(self, mouseevent)
     |      Process a pick event.
     |
     |      Each child artist will fire a pick event if *mouseevent* is over
     |      the artist and the artist has picker set.
     |
     |      See Also
     |      --------
     |      set_picker, get_picker, pickable
     |
     |  pickable(self)
     |      Return whether the artist is pickable.
     |
     |      See Also
     |      --------
     |      set_picker, get_picker, pick
     |
     |  properties(self)
     |      Return a dictionary of all the properties of the artist.
     |
     |  remove(self)
     |      Remove the artist from the figure if possible.
     |
     |      The effect will not be visible until the figure is redrawn, e.g.,
     |      with `.FigureCanvasBase.draw_idle`.  Call `~.axes.Axes.relim` to
     |      update the axes limits if desired.
     |
     |      Note: `~.axes.Axes.relim` will not see collections even if the
     |      collection was added to the axes with *autolim* = True.
     |
     |      Note: there is no support for removing the artist's legend entry.
     |
     |  remove_callback(self, oid)
     |      Remove a callback based on its observer id.
     |
     |      See Also
     |      --------
     |      add_callback
     |
     |  set(self, **kwargs)
     |      A property batch setter.  Pass *kwargs* to set properties.
     |
     |  set_agg_filter(self, filter_func)
     |      Set the agg filter.
     |
     |      Parameters
     |      ----------
     |      filter_func : callable
     |          A filter function, which takes a (m, n, 3) float array and a dpi
     |          value, and returns a (m, n, 3) array.
     |
     |          .. ACCEPTS: a filter function, which takes a (m, n, 3) float array
     |              and a dpi value, and returns a (m, n, 3) array
     |
     |  set_animated(self, b)
     |      Set the artist's animation state.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_clip_box(self, clipbox)
     |      Set the artist's clip `.Bbox`.
     |
     |      Parameters
     |      ----------
     |      clipbox : `.Bbox`
     |
     |  set_clip_on(self, b)
     |      Set whether the artist uses clipping.
     |
     |      When False artists will be visible outside of the axes which
     |      can lead to unexpected results.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_clip_path(self, path, transform=None)
     |      Set the artist's clip path.
     |
     |      Parameters
     |      ----------
     |      path : `.Patch` or `.Path` or `.TransformedPath` or None
     |          The clip path. If given a `.Path`, *transform* must be provided as
     |          well. If *None*, a previously set clip path is removed.
     |      transform : `~matplotlib.transforms.Transform`, optional
     |          Only used if *path* is a `.Path`, in which case the given `.Path`
     |          is converted to a `.TransformedPath` using *transform*.
     |
     |      Notes
     |      -----
     |      For efficiency, if *path* is a `.Rectangle` this method will set the
     |      clipping box to the corresponding rectangle and set the clipping path
     |      to ``None``.
     |
     |      For technical reasons (support of `~.Artist.set`), a tuple
     |      (*path*, *transform*) is also accepted as a single positional
     |      parameter.
     |
     |      .. ACCEPTS: Patch or (Path, Transform) or None
     |
     |  set_contains(self, picker)
     |      [*Deprecated*] Define a custom contains test for the artist.
     |
     |      The provided callable replaces the default `.contains` method
     |      of the artist.
     |
     |      Parameters
     |      ----------
     |      picker : callable
     |          A custom picker function to evaluate if an event is within the
     |          artist. The function must have the signature::
     |
     |              def contains(artist: Artist, event: MouseEvent) -> bool, dict
     |
     |          that returns:
     |
     |          - a bool indicating if the event is within the artist
     |          - a dict of additional information. The dict should at least
     |            return the same information as the default ``contains()``
     |            implementation of the respective artist, but may provide
     |            additional information.
     |
     |      Notes
     |      -----
     |      .. deprecated:: 3.3
     |
     |  set_figure(self, fig)
     |      Set the `.Figure` instance the artist belongs to.
     |
     |      Parameters
     |      ----------
     |      fig : `.Figure`
     |
     |  set_gid(self, gid)
     |      Set the (group) id for the artist.
     |
     |      Parameters
     |      ----------
     |      gid : str
     |
     |  set_in_layout(self, in_layout)
     |      Set if artist is to be included in layout calculations,
     |      E.g. :doc:`/tutorials/intermediate/constrainedlayout_guide`,
     |      `.Figure.tight_layout()`, and
     |      ``fig.savefig(fname, bbox_inches='tight')``.
     |
     |      Parameters
     |      ----------
     |      in_layout : bool
     |
     |  set_label(self, s)
     |      Set a label that will be displayed in the legend.
     |
     |      Parameters
     |      ----------
     |      s : object
     |          *s* will be converted to a string by calling `str`.
     |
     |  set_path_effects(self, path_effects)
     |      Set the path effects.
     |
     |      Parameters
     |      ----------
     |      path_effects : `.AbstractPathEffect`
     |
     |  set_picker(self, picker)
     |      Define the picking behavior of the artist.
     |
     |      Parameters
     |      ----------
     |      picker : None or bool or callable
     |          This can be one of the following:
     |
     |          - *None*: Picking is disabled for this artist (default).
     |
     |          - A boolean: If *True* then picking will be enabled and the
     |            artist will fire a pick event if the mouse event is over
     |            the artist.
     |
     |          - A function: If picker is callable, it is a user supplied
     |            function which determines whether the artist is hit by the
     |            mouse event::
     |
     |              hit, props = picker(artist, mouseevent)
     |
     |            to determine the hit test.  if the mouse event is over the
     |            artist, return *hit=True* and props is a dictionary of
     |            properties you want added to the PickEvent attributes.
     |
     |          - *deprecated*: For `.Line2D` only, *picker* can also be a float
     |            that sets the tolerance for checking whether an event occurred
     |            "on" the line; this is deprecated.  Use `.Line2D.set_pickradius`
     |            instead.
     |
     |  set_rasterized(self, rasterized)
     |      Force rasterized (bitmap) drawing in vector backend output.
     |
     |      Defaults to None, which implies the backend's default behavior.
     |
     |      Parameters
     |      ----------
     |      rasterized : bool or None
     |
     |  set_sketch_params(self, scale=None, length=None, randomness=None)
     |      Sets the sketch parameters.
     |
     |      Parameters
     |      ----------
     |      scale : float, optional
     |          The amplitude of the wiggle perpendicular to the source
     |          line, in pixels.  If scale is `None`, or not provided, no
     |          sketch filter will be provided.
     |      length : float, optional
     |           The length of the wiggle along the line, in pixels
     |           (default 128.0)
     |      randomness : float, optional
     |          The scale factor by which the length is shrunken or
     |          expanded (default 16.0)
     |
     |          .. ACCEPTS: (scale: float, length: float, randomness: float)
     |
     |  set_snap(self, snap)
     |      Set the snapping behavior.
     |
     |      Snapping aligns positions with the pixel grid, which results in
     |      clearer images. For example, if a black line of 1px width was
     |      defined at a position in between two pixels, the resulting image
     |      would contain the interpolated value of that line in the pixel grid,
     |      which would be a grey value on both adjacent pixel positions. In
     |      contrast, snapping will move the line to the nearest integer pixel
     |      value, so that the resulting image will really contain a 1px wide
     |      black line.
     |
     |      Snapping is currently only supported by the Agg and MacOSX backends.
     |
     |      Parameters
     |      ----------
     |      snap : bool or None
     |          Possible values:
     |
     |          - *True*: Snap vertices to the nearest pixel center.
     |          - *False*: Do not modify vertex positions.
     |          - *None*: (auto) If the path contains only rectilinear line
     |            segments, round to the nearest pixel center.
     |
     |  set_transform(self, t)
     |      Set the artist transform.
     |
     |      Parameters
     |      ----------
     |      t : `.Transform`
     |
     |  set_url(self, url)
     |      Set the url for the artist.
     |
     |      Parameters
     |      ----------
     |      url : str
     |
     |  set_visible(self, b)
     |      Set the artist's visibility.
     |
     |      Parameters
     |      ----------
     |      b : bool
     |
     |  set_zorder(self, level)
     |      Set the zorder for the artist.  Artists with lower zorder
     |      values are drawn first.
     |
     |      Parameters
     |      ----------
     |      level : float
     |
     |  update(self, props)
     |      Update this artist's properties from the dict *props*.
     |
     |      Parameters
     |      ----------
     |      props : dict
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from matplotlib.artist.Artist:
     |
     |  sticky_edges
     |      ``x`` and ``y`` sticky edge lists for autoscaling.
     |
     |      When performing autoscaling, if a data limit coincides with a value in
     |      the corresponding sticky_edges list, then no margin will be added--the
     |      view limit "sticks" to the edge. A typical use case is histograms,
     |      where one usually expects no margin on the bottom edge (0) of the
     |      histogram.
     |
     |      This attribute cannot be assigned to; however, the ``x`` and ``y``
     |      lists can be modified in place as needed.
     |
     |      Examples
     |      --------
     |      >>> artist.sticky_edges.x[:] = (xmin, xmax)
     |      >>> artist.sticky_edges.y[:] = (ymin, ymax)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from matplotlib.artist.Artist:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  axes
     |      The `~.axes.Axes` instance the artist resides in, or *None*.
     |
     |  mouseover
     |      If this property is set to *True*, the artist will be queried for
     |      custom context information when the mouse cursor moves over it.
     |
     |      See also :meth:`get_cursor_data`, :class:`.ToolCursorPosition` and
     |      :class:`.NavigationToolbar2`.
     |
     |  stale
     |      Whether the artist is 'stale' and needs to be re-drawn for the output
     |      to match the internal state of the artist.

```python
np.random.seed(2016)
data = np.random.rand(12,20)
h, w = data.shape
theta, z = np.linspace(0, 2 * np.pi, w), np.linspace(0, 1, h)
THETA, Z = np.meshgrid(theta, z)
X = np.cos(THETA)
Y = np.sin(THETA)
fig = plt.figure()
ax = fig.add_subplot(1,1,1, projection='3d')
cmap = plt.get_cmap('bwr')
plot = ax.plot_surface(X,Y,Z, rstride=1, cstride=1,
#                        facecolors=cmap(data),
                       linewidth=0,
                       antialiased=False,
                       alpha=0.75)
plt.show()
```

```python
help(np.meshgrid)
```

    Help on function meshgrid in module numpy:

    meshgrid(*xi, **kwargs)
        Return coordinate matrices from coordinate vectors.

        Make N-D coordinate arrays for vectorized evaluations of
        N-D scalar/vector fields over N-D grids, given
        one-dimensional coordinate arrays x1, x2,..., xn.

        .. versionchanged:: 1.9
           1-D and 0-D cases are allowed.

        Parameters
        ----------
        x1, x2,..., xn : array_like
            1-D arrays representing the coordinates of a grid.
        indexing : {'xy', 'ij'}, optional
            Cartesian ('xy', default) or matrix ('ij') indexing of output.
            See Notes for more details.

            .. versionadded:: 1.7.0
        sparse : bool, optional
            If True a sparse grid is returned in order to conserve memory.
            Default is False.

            .. versionadded:: 1.7.0
        copy : bool, optional
            If False, a view into the original arrays are returned in order to
            conserve memory.  Default is True.  Please note that
            ``sparse=False, copy=False`` will likely return non-contiguous
            arrays.  Furthermore, more than one element of a broadcast array
            may refer to a single memory location.  If you need to write to the
            arrays, make copies first.

            .. versionadded:: 1.7.0

        Returns
        -------
        X1, X2,..., XN : ndarray
            For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
            return ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'
            or ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'
            with the elements of `xi` repeated to fill the matrix along
            the first dimension for `x1`, the second for `x2` and so on.

        Notes
        -----
        This function supports both indexing conventions through the indexing
        keyword argument.  Giving the string 'ij' returns a meshgrid with
        matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.
        In the 2-D case with inputs of length M and N, the outputs are of shape
        (N, M) for 'xy' indexing and (M, N) for 'ij' indexing.  In the 3-D case
        with inputs of length M, N and P, outputs are of shape (N, M, P) for
        'xy' indexing and (M, N, P) for 'ij' indexing.  The difference is
        illustrated by the following code snippet::

            xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')
            for i in range(nx):
                for j in range(ny):
                    # treat xv[i,j], yv[i,j]

            xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')
            for i in range(nx):
                for j in range(ny):
                    # treat xv[j,i], yv[j,i]

        In the 1-D and 0-D case, the indexing and sparse keywords have no effect.

        See Also
        --------
        index_tricks.mgrid : Construct a multi-dimensional "meshgrid"
                         using indexing notation.
        index_tricks.ogrid : Construct an open multi-dimensional "meshgrid"
                         using indexing notation.

        Examples
        --------
        >>> nx, ny = (3, 2)
        >>> x = np.linspace(0, 1, nx)
        >>> y = np.linspace(0, 1, ny)
        >>> xv, yv = np.meshgrid(x, y)
        >>> xv
        array([[0. , 0.5, 1. ],
               [0. , 0.5, 1. ]])
        >>> yv
        array([[0.,  0.,  0.],
               [1.,  1.,  1.]])
        >>> xv, yv = np.meshgrid(x, y, sparse=True)  # make sparse output arrays
        >>> xv
        array([[0. ,  0.5,  1. ]])
        >>> yv
        array([[0.],
               [1.]])

        `meshgrid` is very useful to evaluate functions on a grid.

        >>> import matplotlib.pyplot as plt
        >>> x = np.arange(-5, 5, 0.1)
        >>> y = np.arange(-5, 5, 0.1)
        >>> xx, yy = np.meshgrid(x, y, sparse=True)
        >>> z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
        >>> h = plt.contourf(x,y,z)
        >>> plt.show()

```python

```