m[c@`shdZddlmZmZmZmZddlZddlZddlZddl Z ddl m Z ddl m Z ddl mZddljZddlmZmZddljZddlmZmZdd l mZdd lmZddljZdd l m!Z!m"Z"m#Z#dd l$m%Z%m&Z&dd l'm(Z(ddl)j*Z+ddl,m-Z-ddl.m/Z/m0Z0ddl1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8ddl9j:Z;ddl<m=Z=ej>e?Z@e jAjBde/dZCdefdYZDdeEfdYZFdefdYZGdZHe jAjBdejIeGdS(u5 The figure module provides the top-level :class:`~matplotlib.artist.Artist`, the :class:`Figure`, which contains all the plot elements. The following classes are defined :class:`SubplotParams` control the default spacing of the subplots :class:`Figure` Top level container for all plot elements. i(tabsolute_importtdivisiontprint_functiontunicode_literalsN(trcParams(t docstring(t __version__(tArtisttallow_rasterization(tStacktiterable(timage(t FigureImage(tAxest SubplotBasetsubplot_class_factory(tBlockingMouseInputtBlockingKeyMouseInput(tGridSpec(t Rectangle(tget_projection_namestprocess_projection_requirements(tTextt_process_text_args(tAffine2DtBboxtBboxTransformTotTransformedBbox(tNonGuiExceptiontprojection_namescC`s|jr||j_ndS(N(tfiguretstale(tselftval((s0lib/python2.7/site-packages/matplotlib/figure.pyt_stale_figure_callback:s t AxesStackcB`sheZdZdZdZdZdZdZdZdZ dZ d Z d Z RS( u Specialization of the `.Stack` to handle all tracking of `~matplotlib.axes.Axes` in a `.Figure`. This stack stores ``key, (ind, axes)`` pairs, where: * **key** should be a hash of the args and kwargs used in generating the Axes. * **ind** is a serial number for tracking the order in which axes were added. The AxesStack is a callable, where ``ax_stack()`` returns the current axes. Alternatively the :meth:`current_key_axes` will return the current key and associated axes. cC`stj|d|_dS(Ni(R t__init__t_ind(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyR$Os cC`sIg|jD]\}}|^q }|jg|D]\}}|^q3S(uX Return a list of the Axes instances that have been added to the figure (t _elementstsort(R tktatia_listti((s0lib/python2.7/site-packages/matplotlib/figure.pytas_listSs" cC`s@t|jj|}|dkr(dStjdd|dS(up Return the Axes instance that was added with *key*. If it is not present, return None. u2.1u)Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.iN(tdictR&tgettNonetcbooktwarn_deprecated(R tkeytitem((s0lib/python2.7/site-packages/matplotlib/figure.pyR.[s cC`s-d|jD|\}}|||ffS(NcS`s+i|]!\}\}}||f|qS(((t.0R(tindR)((s0lib/python2.7/site-packages/matplotlib/figure.pys ms (R&(R teR5R(((s0lib/python2.7/site-packages/matplotlib/figure.pyt_entry_from_axeslscC`stj||j|dS(uRemove the axes from the stack.N(R tremoveR7(R R)((s0lib/python2.7/site-packages/matplotlib/figure.pyR8pscC`stj||j|S(ua Move the given axes, which must already exist in the stack, to the top. (R tbubbleR7(R R)((s0lib/python2.7/site-packages/matplotlib/figure.pyR9tscC`st|ts'tdj|nyt|Wntk rQt}nX|j|}|dk rt j |||ft j dj|n||krdS|j d7_ t j|||j |ffS(u Add Axes *a*, with key *key*, to the stack, and return the stack. If *key* is unhashable, replace it by a unique, arbitrary object. If *a* is already on the stack, don't add it again, but return *None*. u%second argument, {!r}, is not an Axesu0key {!r} already existed; Axes is being replacediN(t isinstanceR t ValueErrortformatthasht TypeErrortobjectR.R/R R8twarningstwarnR%tpush(R R2R)t a_existing((s0lib/python2.7/site-packages/matplotlib/figure.pytadd{s     cC`sIt|js|j|jfS|j|j\}\}}||fSdS(u Return a tuple of ``(key, axes)`` for the active axes. If no axes exists on the stack, then returns ``(None, None)``. N(tlenR&t_defaultt_pos(R R2tindextaxes((s0lib/python2.7/site-packages/matplotlib/figure.pytcurrent_key_axesscC`s|jdS(Ni(RJ(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt__call__scC`s||jkS(N(R,(R R)((s0lib/python2.7/site-packages/matplotlib/figure.pyt __contains__s( t__name__t __module__t__doc__R$R,R.R7R8R9RDRJRKRL(((s0lib/python2.7/site-packages/matplotlib/figure.pyR#?s        t SubplotParamscB`sMeZdZdddddddZdddddddZdZRS(u7 A class to hold the parameters for a subplot. cC`s)t|_|j||||||dS(u All dimensions are fractions of the figure width or height. Defaults are given by :rc:`figure.subplot.[name]`. Parameters ---------- left : float The left side of the subplots of the figure. right : float The right side of the subplots of the figure. bottom : float The bottom of the subplots of the figure. top : float The top of the subplots of the figure. wspace : float The amount of width reserved for space between subplots, expressed as a fraction of the average axis width. hspace : float The amount of height reserved for space between subplots, expressed as a fraction of the average axis height. N(tTruetvalidatetupdate(R tlefttbottomtrightttoptwspacethspace((s0lib/python2.7/site-packages/matplotlib/figure.pyR$s c`sMtdd tdd tdd tdd tdd tdd jd|jd|jd|jd|jd|jd|fd}jrIjjkr|tdnjjkrI|td qInd S( uY Update the dimensions of the passed parameters. *None* means unchanged. ulefturightutopubottomuwspaceuhspacec`s:______dS(N(RTRVRWRURXRY((R t thisbottomt thishspacetthisleftt thisrighttthistopt thiswspace(s0lib/python2.7/site-packages/matplotlib/figure.pytresets      uleft cannot be >= rightubottom cannot be >= topN( tgetattrR/t _update_thisRRRTRVR;RURW(R RTRURVRWRXRYR`((R RZR[R\R]R^R_s0lib/python2.7/site-packages/matplotlib/figure.pyRSs(! cC`sX|dkrDt||d}|dkrDd|}t|}qDnt|||dS(Nufigure.subplot.(R/RaRtsetattr(R tsR!R2((s0lib/python2.7/site-packages/matplotlib/figure.pyRbs    N(RMRNROR/R$RSRb(((s0lib/python2.7/site-packages/matplotlib/figure.pyRPs   #tFigurec B`seZdZdZdZdYdYdYdYddYdYdYdYd Zeej ddddZ d Z e d Z d Zed ed dZdZe dZeeed dZdZdZdZdZdZedZddddYdZdZdZdZdZd Zej d!dYd"Z d#d#dYdYdYdYdYdYed$ Z!dYe d%Z"d&Z#d'Z$d(Z%d)Z&d*Z'd+Z(d,Z)d-Z*d.Z+d/Z,e d0Z-e d1Z.d2Z/d3Z0d4Z1d5Z2d6Z3d7d7eee dYdYd8Z4d9Z5ed:Z6ed;Z7e8d<Z9d=Z:d>Z;e<j=d?Z>e<j=d@Z?dAZ@e<j=dBZAdCZBdDZCdEZDdFZEdGZFdHZGe<j=dYdYe dIZHdJZId7de d7dKdLdMZJdNdOZKdPZLdQZMdRZNdYdSZOdYdTdYdYdYdUZPdYdVZQdYdWZRdYdXZSRS(Zu The top level container for all the plot elements. The Figure instance supports callbacks through a *callbacks* attribute which is a `.CallbackRegistry` instance. The events you can connect to are 'dpi_changed', and the callback will be called with ``func(fig)`` where fig is the `Figure` instance. Attributes ---------- patch The `.Rectangle` instance representing the figure patch. suppressComposite For multiple figure images, the figure will make composite images depending on the renderer option_image_nocomposite function. If *suppressComposite* is a boolean, this will override the renderer. cC`sdt|jjS(Nu Figure(%gx%g)(ttupletbboxtsize(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt__str__sc C`sEdjd|jjd|jjdd|jjddt|jS(Nu.<{clsname} size {h:g}x{w:g} with {naxes} Axes>tclsnamethitwitnaxes(R<t __class__RMRgRhRERI(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt__repr__s   gc C`sGtj||`tj|_|dkr;td}n|dkrTtd}n|dkrmtd}n|dkrtd}n|dkrtd}ntj |j st dj |nt jdd||_tj|||_||_t|j|j|_||_t|j|_tddd d d d d |d |d||_|j|j|jjttd|_|jdkrt|_nd|_ d|_!|dkrt"}n||_#d|_$|j%| |j&|t'|_(|j)d|_*tj+|_,tj+|_-dS(u Parameters ---------- figsize : 2-tuple of floats, default: :rc:`figure.figsize` Figure dimension ``(width, height)`` in inches. dpi : float, default: :rc:`figure.dpi` Dots per inch. facecolor : default: :rc:`figure.facecolor` The figure patch facecolor. edgecolor : default: :rc:`figure.edgecolor` The figure patch edge color. linewidth : float The linewidth of the frame (i.e. the edge linewidth of the figure patch). frameon : bool, default: :rc:`figure.frameon` If ``False``, suppress drawing the figure frame. subplotpars : :class:`SubplotParams` Subplot parameters. If not given, the default subplot parameters :rc:`figure.subplot.*` are used. tight_layout : bool or dict, default: :rc:`figure.autolayout` If ``False`` use *subplotpars*. If ``True`` adjust subplot parameters using `.tight_layout` with default padding. When providing a dict containing the keys ``pad``, ``w_pad``, ``h_pad``, and ``rect``, the default `.tight_layout` paddings will be overridden. constrained_layout : bool If ``True`` use constrained layout to adjust positioning of plot elements. Like ``tight_layout``, but designed to be more flexible. See :doc:`/tutorials/intermediate/constrainedlayout_guide` for examples. (Note: does not work with :meth:`.subplot` or :meth:`.subplot2grid`.) Defaults to :rc:`figure.constrained_layout.use`. ufigure.figsizeu figure.dpiufigure.facecolorufigure.edgecolorufigure.frameonu!figure size must be finite not {}itxytwidthitheightt facecolort edgecolort linewidthu axes.holdN(ii(.RR$t_axesR0tCallbackRegistryt callbacksR/RtnptisfinitetallR;R<Rt from_boundst bbox_inchesRtscaletdpi_scale_transt_dpiRRgtframeonRt transFigureRtpatcht_set_artist_propstset_aatFalset_holdRQtcanvast _suptitleRPt subplotparst _layoutboxtset_constrained_layouttset_tight_layoutR#t_axstacktclft_cachedRenderertGroupert_align_xlabel_grpt_align_ylabel_grp( R tfigsizetdpiRsRtRuRRt tight_layouttconstrained_layout((s0lib/python2.7/site-packages/matplotlib/figure.pyR$sV6                           u2.1t alternativeu`.Figure.patch`cC`s|jS(N(R(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt figurePatchscC`sE|jdk rAd|jjjkrAddlm}|j|SdS(NuWebAggi(tbackend_webagg(RR/RnRMtmatplotlib.backendsRtipython_inline_display(R R((s0lib/python2.7/site-packages/matplotlib/figure.pyt _repr_html_scC`syt|jd}Wn#tk r;}td|nX|dk rqy|jdSWqqtk rmqqXn|rddl}|jdndS(u@ If using a GUI backend with pyplot, display the figure window. If the figure was not created using :func:`~matplotlib.pyplot.figure`, it will lack a :class:`~matplotlib.backend_bases.FigureManagerBase`, and will raise an AttributeError. Parameters ---------- warm : bool If ``True``, issue warning when called on a non-GUI backend Notes ----- For non-GUI backends, this does nothing, in which case a warning will be issued if *warn* is ``True`` (default). umanageru]%s Figure.show works only for figures managed by pyplot, normally created by pyplot.figure().NiuJmatplotlib is currently using a non-GUI backend, so cannot show the figure(RaRtAttributeErrorR/tshowRR@RA(R RAtmanagerterrR@((s0lib/python2.7/site-packages/matplotlib/figure.pyRs    cC`s |jjS(N(RR,(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt _get_axesstfgettdocuList of axes in the Figure. You can access the axes in the Figure through this list. Do not modify the list itself. Instead, use `~Figure.add_axes`, `~.Figure.subplot` or `~.Figure.delaxes` to add or remove an axes.cC`s|jS(N(R(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt_get_dpiscC`sa||_|jjj|||j\}}|j||d||jjd|dS(u Parameters ---------- dpi : float forward : bool Passed on to `~.Figure.set_size_inches` tforwardu dpi_changedN(RRtclearR~tget_size_inchestset_size_inchesRxtprocess(R RRRlRk((s0lib/python2.7/site-packages/matplotlib/figure.pyt_set_dpis u The resolution in dots per inch.cC`s|jS(u6Return whether `.tight_layout` is called when drawing.(t_tight(R ((s0lib/python2.7/site-packages/matplotlib/figure.pytget_tight_layoutscC`sS|dkrtd}nt||_t|tr=|ni|_t|_dS(u[ Set whether and how `.tight_layout` is called when drawing. Parameters ---------- tight : bool or dict with keys "pad", "w_pad", "h_pad", "rect" or None If a bool, sets whether to call `.tight_layout` upon drawing. If ``None``, use the ``figure.autolayout`` rcparam instead. If a dict, pass it as kwargs to `.tight_layout`, overriding the default paddings. .. ACCEPTS: [ bool | dict with keys "pad", "w_pad", "h_pad", "rect" | None ] ufigure.autolayoutN( R/RtboolRR:R-t_tight_parametersRQR(R ttight((s0lib/python2.7/site-packages/matplotlib/figure.pyRs   cC`s|jS(u Return a boolean: True means constrained layout is being used. See :doc:`/tutorials/intermediate/constrainedlayout_guide`. (t _constrained(R ((s0lib/python2.7/site-packages/matplotlib/figure.pytget_constrained_layoutscC`st|_d|jdsiitwhichuRUN(R{RIREtget_xticklabelstset_hat set_rotationtget_axest is_last_rowt set_visibleRt set_xlabeltsubplots_adjustRQR(R RUtrotationthaRt allsubplotstlabelR((s0lib/python2.7/site-packages/matplotlib/figure.pyt autofmt_xdatejs"    cC`s|jg}|j|j|j|j|j|j|j|j|j|j|j|j|j|j|S(u.Get a list of artists contained in the figure.( RtextendtartistsRItlinestpatchesttextstimagestlegends(R tchildren((s0lib/python2.7/site-packages/matplotlib/figure.pyt get_childrens cC`sDt|jr|j||S|jj|j|j}|ifS(u| Test whether the mouse event occurred on the figure. Returns ------- bool, {} (tcallablet _containsRgtcontainstxty(R t mouseeventtinside((s0lib/python2.7/site-packages/matplotlib/figure.pyRscO`s|jS(uY Return the figure bounding box in display space. Arguments are ignored. (Rg(R targsR((s0lib/python2.7/site-packages/matplotlib/figure.pytget_window_extentsc K`s6d|kpd|k}|jdd}|jdd}d|krad|krad|dpsN(RRtget_dpitshapeRRQR R"tstale_callbackt set_arrayt set_alphaR/tset_climRtappendt_remove_methodR(R tXtxotyotalphatnormtcmaptvmintvmaxtorigintresizeRRRRtim((R s0lib/python2.7/site-packages/matplotlib/figure.pytfigimages F   1     c C`s|dkr|\}}ntd||fDsRtdj||n||f|j_|rt|d}|dk rt|jdd}|j|}||}||}t|jdd} | dk r| j t |t |qqnt |_ dS(uSet the figure size in inches (1in == 2.54cm) Usage :: fig.set_size_inches(w, h) # OR fig.set_size_inches((w, h)) optional kwarg *forward=True* will cause the canvas size to be automatically updated; e.g., you can resize the figure window from the shell ACCEPTS: a w, h tuple with w, h in inches See Also -------- matplotlib.Figure.get_size_inches cs`s|]}tj|VqdS(N(RyRz(R4t_((s0lib/python2.7/site-packages/matplotlib/figure.pys su'figure size must be finite not ({}, {})ucanvasu _dpi_ratioiumanagerN( R/R{R;R<R}tp1RaRRR tintRQR( R RlRkRRtratiotdpivaltcanvaswtcanvashR((s0lib/python2.7/site-packages/matplotlib/figure.pyRts"       %cC`stj|jjS(u Returns the current size of the figure in inches. Returns ------- size : ndarray The size (width, height) of the figure in inches. See Also -------- matplotlib.Figure.set_size_inches (RytarrayR}R (R ((s0lib/python2.7/site-packages/matplotlib/figure.pyRs cC`s |jjS(u+Get the edge color of the Figure rectangle.(Rt get_edgecolor(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyRscC`s |jjS(u+Get the face color of the Figure rectangle.(Rt get_facecolor(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyRscC`s |jjS(u#Return the figure width as a float.(R}Rq(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt get_figwidthscC`s |jjS(u$Return the figure height as a float.(R}Rr(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt get_figheightscC`s|jS(u2Return the resolution in dots per inch as a float.(R(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyRscC`s|jS(u.Return whether the figure frame will be drawn.(R(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyt get_frameonscC`s|jj|dS(uw Set the edge color of the Figure rectangle. ACCEPTS: any matplotlib color - see help(colors) N(Rt set_edgecolor(R tcolor((s0lib/python2.7/site-packages/matplotlib/figure.pyRscC`s|jj|dS(uw Set the face color of the Figure rectangle. ACCEPTS: any matplotlib color - see help(colors) N(Rt set_facecolor(R R((s0lib/python2.7/site-packages/matplotlib/figure.pyRscC`s||_t|_dS(uN Set the dots-per-inch of the figure. ACCEPTS: float N(RRQR(R R!((s0lib/python2.7/site-packages/matplotlib/figure.pytset_dpis cC`s |j||jd|dS(uP Set the width of the figure in inches. ACCEPTS: float RN(RR(R R!R((s0lib/python2.7/site-packages/matplotlib/figure.pyt set_figwidthscC`s |j|j|d|dS(uQ Set the height of the figure in inches. ACCEPTS: float RN(RR(R R!R((s0lib/python2.7/site-packages/matplotlib/figure.pyt set_figheightscC`s||_t|_dS(uo Set whether the figure frame (background) is displayed or invisible ACCEPTS: boolean N(RRQR(R R((s0lib/python2.7/site-packages/matplotlib/figure.pyt set_frameons cC`s;|jj|x|jD]}||qWt|_dS(un Remove the `~matplotlib.axes.Axes` *ax* from the figure and update the current axes. N(RR8t _axobserversRQR(R Rtfunc((s0lib/python2.7/site-packages/matplotlib/figure.pytdelaxesscO`s7d}d}|||tj|f}|S(u+Make a hashable key out of args and kwargs.cS`s^g}xK|D]C\}}yt|}Wntk r<nX|j||fq Wt|S(N(Rft ExceptionR(titemstretR(tv((s0lib/python2.7/site-packages/matplotlib/figure.pytfixitemss cS`sIg}x6|D].}t|r.t|}n|j|q Wt|S(N(R RfR(RR%R)((s0lib/python2.7/site-packages/matplotlib/figure.pytfixlists   (tsixt iteritems(R RRR'R(R2((s0lib/python2.7/site-packages/matplotlib/figure.pyt _make_keys  !cO`sjt|sdS|j||}|jj|}|dk rQ|j||St|dtr|d}|j|k r(t dq(n|d}t j |j st dj |nt|||\}}}|jj|}t||r|j||S||||}|jj|||j||j|_t|_t|_|S(u Add an axes to the figure. Call signature:: add_axes(rect, projection=None, polar=False, **kwargs) Parameters ---------- rect : sequence of float The dimensions [left, bottom, width, height] of the new axes. All quantities are in fractions of figure width and height. projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', 'polar', rectilinear'}, optional The projection type of the axes. polar : boolean, optional If True, equivalent to projection='polar'. **kwargs This method also takes the keyword arguments for :class:`~matplotlib.axes.Axes`. Returns ------- axes : Axes The added axes. Examples -------- Some simple examples:: rect = l, b, w, h fig.add_axes(rect) fig.add_axes(rect, frameon=False, facecolor='g') fig.add_axes(rect, polar=True) fig.add_axes(rect, projection='polar') fig.add_axes(ax) If the figure already has an axes with the same parameters, then it will simply make that axes current and return it. This behavior has been deprecated as of Matplotlib 2.1. Meanwhile, if you do not want this behavior (i.e., you want to force the creation of a new Axes), you must use a unique set of args and kwargs. The axes :attr:`~matplotlib.axes.Axes.label` attribute has been exposed for this purpose: if you want two axes that are otherwise identical to be added to the figure, make sure you give them unique labels:: fig.add_axes(rect, label='axes1') fig.add_axes(rect, label='axes2') In rare circumstances, add_axes may be called with a single argument, an Axes instance already created in the present figure but not in the figure's list of axes. For example, if an axes has been removed with :meth:`delaxes`, it can be restored with:: fig.add_axes(ax) In all cases, the :class:`~matplotlib.axes.Axes` instance will be returned. Niu5The Axes must have been created in the present figureu)all entries in rect must be finite not {}(RER+RR.R/tscaR:R t get_figureR;RyRzR{R<RRDt_Figure__remove_axRRQRR"R(R RRR2RR)trecttprojection_class((s0lib/python2.7/site-packages/matplotlib/figure.pytadd_axess:@           cO`st|sdSt|dkrt|dtrd|dkoPdknsqtdj|dntttt|d}nt|dtr|d}|j |k rtdn|j ||}nt |||\}}}|j j |}|dk rRt||r?|j||S|j j|nt||||}|j j|||j||j|_t|_t|_|S(ur Add a subplot. Call signatures:: add_subplot(nrows, ncols, index, **kwargs) add_subplot(pos, **kwargs) Parameters ---------- *args Either a 3-digit integer or three separate integers describing the position of the subplot. If the three integers are R, C, and P in order, the subplot will take the Pth position on a grid with R rows and C columns. projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', 'polar', rectilinear'}, optional The projection type of the axes. polar : boolean, optional If True, equivalent to projection='polar'. **kwargs This method also takes the keyword arguments for :class:`~matplotlib.axes.Axes`. Returns ------- axes : Axes The axes of the subplot. Notes ----- If the figure already has a subplot with key (*args*, *kwargs*) then it will simply make that subplot current and return it. This behavior is deprecated. Examples -------- :: fig.add_subplot(111) # equivalent but more general fig.add_subplot(1, 1, 1) # add subplot with red background fig.add_subplot(212, facecolor='r') # add a polar subplot fig.add_subplot(111, projection='polar') # add Subplot instance sub fig.add_subplot(sub) See Also -------- matplotlib.pyplot.subplot : for an explanation of the args. NiiidiuBInteger subplot specification must be a three-digit number, not {}u8The Subplot must have been created in the present figure(RER:RR;R<RftmaptstrRR-R+RRR.R/R,R8RRDR.RRQRR"R(R RRR)R2R0R((s0lib/python2.7/site-packages/matplotlib/figure.pyt add_subplots8= %  "        icC`st|tr$|rdnd}nt|trH|r?dnd}nddddg}||krt|trtjdntd||fn||krtd||fn|d kri}n|d kri}n|jrt||d||} nt||dd |} t j ||fd t } xt |D]} xt |D]} id d6| dd6| | d fd6| d | fd6} | ||d <| ||d <|j | | | f|| | | f1 and M>1 are returned as a 2D array. - If False, no squeezing at all is done: the returned Axes object is always a 2D array containing Axes instances, even if it ends up being 1x1. subplot_kw : dict, default: {} Dict with keywords passed to the :meth:`~matplotlib.figure.Figure.add_subplot` call used to create each subplots. gridspec_kw : dict, default: {} Dict with keywords passed to the :class:`~matplotlib.gridspec.GridSpec` constructor used to create the grid the subplots are placed on. Returns ------- ax : single Axes object or array of Axes objects The added axes. The dimensions of the resulting array can be controlled with the squeeze keyword, see above. See Also -------- pyplot.subplots : pyplot API; docstring includes examples. uallunoneurowucolu\sharex argument to subplots() was an integer. Did you intend to use subplot() (without 's')?usharex [%s] must be one of %susharey [%s] must be one of %sRtdtypeiusharexushareyNiRubotht labelbottomtlabeltopit labelleftt labelright(ii(ucoluall(urowuall(R:RRR@RAR;R/RRRytemptyR?trangeR4tflattxaxistset_tick_paramsRt offsetTextRtyaxisRhR3tsqueeze(R tnrowstncolstsharextshareyRAt subplot_kwt gridspec_kwt share_valuestgstaxarrtrowtcolt shared_withR((s0lib/python2.7/site-packages/matplotlib/figure.pytsubplotssT@        %. &  & #cC`sd}d}|j||||j}|dk rM||jn|||j}|dk r{||jndS(NcS`sP|j|j|j|j|j|j|j|jdS(N(tset_major_formattertget_major_formattertset_major_locatortget_major_locatortset_minor_formattertget_minor_formattertset_minor_locatortget_minor_locator(taxis((s0lib/python2.7/site-packages/matplotlib/figure.pyt_reset_loc_formrscS`sY|j|}t|dkrU|j|x$|D]}||krMq5n|SWndS(Ni(t get_siblingsRER8R/(Rtgroupertsiblingstlast_ax((s0lib/python2.7/site-packages/matplotlib/figure.pyt_break_share_linkxs   (R"t_shared_y_axesR/R@t_shared_x_axesR=(R RRXR]R\((s0lib/python2.7/site-packages/matplotlib/figure.pyt __remove_axqs    cC`sd|_tj|_x.t|jD]}|j|j|q(Wt |j dd}|dk rw|j n|j j g|_g|_g|_g|_g|_g|_|sg|_nd|_|jrtj|jnt|_dS(u Clear the figure. Set *keep_observers* to True if, for example, a gui widget is tracking the axes in the figure. utoolbarN(R/tsuppressCompositeR0RwRxRfRItclaR"RaRRSRRRRRRRRR RRRtnonetreeRRQR(R tkeep_observersRttoolbar((s0lib/python2.7/site-packages/matplotlib/figure.pyRs*              cC`s|jd|dS(u> Clear the figure -- synonym for :meth:`clf`. RdN(R(R Rd((s0lib/python2.7/site-packages/matplotlib/figure.pyRscC`sJ|jsdStd|j|j|j|j|j|j|jDdd}z|j d|j r|jrt r|j |qn|j r|jry|j||jWqtk rqXn|jr|jj|ntj||||j|jdWdt|_X||_|jj|dS(uu Render the figure using :class:`matplotlib.backend_bases.RendererBase` instance *renderer*. Ncs`s!|]}|js|VqdS(N(t get_animated(R4R((s0lib/python2.7/site-packages/matplotlib/figure.pys sR2cS`s |jS(N(t get_zorder(R((s0lib/python2.7/site-packages/matplotlib/figure.pyRsufigure(t get_visibletsortedRRRRRIRRt open_groupRRQtexecute_constrained_layoutRRRR;RRtdrawtmimaget_draw_list_compositing_imagesRat close_groupRRRRt draw_event(R trendererR((s0lib/python2.7/site-packages/matplotlib/figure.pyRls4 7       cC`s2|jdkrtdn|j|jdS(u Draw :class:`matplotlib.artist.Artist` instance *a* only. This is available only after the figure is drawn. uLdraw_artist can only be used after an initial draw which caches the rendererN(RR/RRl(R R)((s0lib/python2.7/site-packages/matplotlib/figure.pyt draw_artistscC`s|jS(uY Return a list of axes in the Figure. You can access and modify the axes in the Figure through this list. Do not modify the list itself. Instead, use `~Figure.add_axes`, `~.Figure.subplot` or `~.Figure.delaxes` to add or remove an axes. Note: This is equivalent to the property `~.Figure.axes`. (RI(R ((s0lib/python2.7/site-packages/matplotlib/figure.pyRs c`s}tjj||\}}}}t|r3ntj||||}jj|fd|_t_ |S(ub" Place a legend on the figure. To make a legend from existing artists on every axes:: legend() To make a legend for a list of lines and labels:: legend( (line1, line2, line3), ('label1', 'label2', 'label3'), loc='upper right') These can also be specified by keyword:: legend(handles=(line1, line2, line3), labels=('label1', 'label2', 'label3'), loc='upper right') Parameters ---------- handles : sequence of `.Artist`, optional A list of Artists (lines, patches) to be added to the legend. Use this together with *labels*, if you need full control on what is shown in the legend and the automatic mechanism described above is not sufficient. The length of handles and labels should be the same in this case. If they are not, they are truncated to the smaller length. labels : sequence of strings, optional A list of labels to show next to the artists. Use this together with *handles*, if you need full control on what is shown in the legend and the automatic mechanism described above is not sufficient. Other Parameters ---------------- loc : int or string or pair of floats, default: 'upper right' The location of the legend. Possible codes are: =============== ============= Location String Location Code =============== ============= 'best' 0 'upper right' 1 'upper left' 2 'lower left' 3 'lower right' 4 'right' 5 'center left' 6 'center right' 7 'lower center' 8 'upper center' 9 'center' 10 =============== ============= Alternatively can be a 2-tuple giving ``x, y`` of the lower-left corner of the legend in axes coordinates (in which case ``bbox_to_anchor`` will be ignored). bbox_to_anchor : `.BboxBase` or pair of floats Specify any arbitrary location for the legend in `bbox_transform` coordinates (default Axes coordinates). For example, to put the legend's upper right hand corner in the center of the axes the following keywords can be used:: loc='upper right', bbox_to_anchor=(0.5, 0.5) ncol : integer The number of columns that the legend has. Default is 1. prop : None or :class:`matplotlib.font_manager.FontProperties` or dict The font properties of the legend. If None (default), the current :data:`matplotlib.rcParams` will be used. fontsize : int or float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'} Controls the font size of the legend. If the value is numeric the size will be the absolute font size in points. String values are relative to the current default font size. This argument is only used if `prop` is not specified. numpoints : None or int The number of marker points in the legend when creating a legend entry for a `.Line2D` (line). Default is ``None``, which will take the value from :rc:`legend.numpoints`. scatterpoints : None or int The number of marker points in the legend when creating a legend entry for a `.PathCollection` (scatter plot). Default is ``None``, which will take the value from :rc:`legend.scatterpoints`. scatteryoffsets : iterable of floats The vertical offset (relative to the font size) for the markers created for a scatter plot legend entry. 0.0 is at the base the legend text, and 1.0 is at the top. To draw all markers at the same height, set to ``[0.5]``. Default is ``[0.375, 0.5, 0.3125]``. markerscale : None or int or float The relative size of legend markers compared with the originally drawn ones. Default is ``None``, which will take the value from :rc:`legend.markerscale`. markerfirst : bool If *True*, legend marker is placed to the left of the legend label. If *False*, legend marker is placed to the right of the legend label. Default is *True*. frameon : None or bool Control whether the legend should be drawn on a patch (frame). Default is ``None``, which will take the value from :rc:`legend.frameon`. fancybox : None or bool Control whether round edges should be enabled around the :class:`~matplotlib.patches.FancyBboxPatch` which makes up the legend's background. Default is ``None``, which will take the value from :rc:`legend.fancybox`. shadow : None or bool Control whether to draw a shadow behind the legend. Default is ``None``, which will take the value from :rc:`legend.shadow`. framealpha : None or float Control the alpha transparency of the legend's background. Default is ``None``, which will take the value from :rc:`legend.framealpha`. If shadow is activated and *framealpha* is ``None``, the default value is ignored. facecolor : None or "inherit" or a color spec Control the legend's background color. Default is ``None``, which will take the value from :rc:`legend.facecolor`. If ``"inherit"``, it will take :rc:`axes.facecolor`. edgecolor : None or "inherit" or a color spec Control the legend's background patch edge color. Default is ``None``, which will take the value from :rc:`legend.edgecolor` If ``"inherit"``, it will take :rc:`axes.edgecolor`. mode : {"expand", None} If `mode` is set to ``"expand"`` the legend will be horizontally expanded to fill the axes area (or `bbox_to_anchor` if defines the legend's size). bbox_transform : None or :class:`matplotlib.transforms.Transform` The transform for the bounding box (`bbox_to_anchor`). For a value of ``None`` (default) the Axes' :data:`~matplotlib.axes.Axes.transAxes` transform will be used. title : str or None The legend's title. Default is no title (``None``). borderpad : float or None The fractional whitespace inside the legend border. Measured in font-size units. Default is ``None``, which will take the value from :rc:`legend.borderpad`. labelspacing : float or None The vertical space between the legend entries. Measured in font-size units. Default is ``None``, which will take the value from :rc:`legend.labelspacing`. handlelength : float or None The length of the legend handles. Measured in font-size units. Default is ``None``, which will take the value from :rc:`legend.handlelength`. handletextpad : float or None The pad between the legend handle and text. Measured in font-size units. Default is ``None``, which will take the value from :rc:`legend.handletextpad`. borderaxespad : float or None The pad between the axes and legend border. Measured in font-size units. Default is ``None``, which will take the value from :rc:`legend.borderaxespad`. columnspacing : float or None The spacing between columns. Measured in font-size units. Default is ``None``, which will take the value from :rc:`legend.columnspacing`. handler_map : dict or None The custom dictionary mapping instances or types to a legend handler. This `handler_map` updates the default handler map found at :func:`matplotlib.legend.Legend.get_legend_handler_map`. Returns ------- :class:`matplotlib.legend.Legend` instance Notes ----- Not all kinds of artist are supported by the legend command. See :doc:`/tutorials/intermediate/legend_guide` for details. c`sjj|S(N(RR8(Rk(R (s0lib/python2.7/site-packages/matplotlib/figure.pyRs( tmlegendt_parse_legend_argsRIREtLegendRRRRQR(R RRthandlestlabelst extra_argstl((R s0lib/python2.7/site-packages/matplotlib/figure.pytlegends  c`svti||}td|d|d|}|j|j|jj|fd|_t_|S(un Add text to figure. Call signature:: text(x, y, s, fontdict=None, **kwargs) Add text to figure at location *x*, *y* (relative 0-1 coords). See :func:`~matplotlib.pyplot.text` for the meaning of the other arguments. kwargs control the :class:`~matplotlib.text.Text` properties: %(Text)s RRRc`sjj|S(N(RR8(Rk(R (s0lib/python2.7/site-packages/matplotlib/figure.pyRs( RRRSRRRRRQR(R RRRdRRtoverrideR((R s0lib/python2.7/site-packages/matplotlib/figure.pyRs   cC`s9||kr|j|nt|_|j|jdS(N(t set_figureR"Rt set_transformR(R R)((s0lib/python2.7/site-packages/matplotlib/figure.pyRs  cK`s|jj\}}|dk r|s+|S|j}t||\}}}|d}|d}||krt||r|Stjdddn|jddd|S(u Get the current axes, creating one if necessary. The following kwargs are supported for ensuring the returned axes adheres to the given projection etc., and for axes creation if the active axes does not exist: %(Axes)s iulRequested projection is different from current axis projection, creating new axis with requested projection.t stackleveliN( RRJR/tcopyRR:R@RAR4(R Rtckeytcaxt kwargs_copyR0R R2((s0lib/python2.7/site-packages/matplotlib/figure.pytgcas       cC`s2|jj|x|jD]}||qW|S(u*Set the current axes to be a and return a.(RR9R (R R)R!((s0lib/python2.7/site-packages/matplotlib/figure.pyR,6scC`sy|jjd}|dkr#dS|j}|dk r?|Sx3t|jD]"}|j}|dk rO|SqOWdS(uR Helper for :func:`~matplotlib.pyplot.gci`. Do not use elsewhere. iN(RRJR/t_gcitreversedRI(R RR R((s0lib/python2.7/site-packages/matplotlib/figure.pyR=s     cC`stt|j}xd D]}|j|dqWt|dWhenever the axes state change, ``func(self)`` will be called.N(R R(R R!((s0lib/python2.7/site-packages/matplotlib/figure.pytadd_axobserversc K`s|jdtd|jdtd}|jdtd}|r|jdd|jd dg}x~|jD]H}|j}|j|j|jf|jd|j dqvWn(|jdtd |jd td |r|j }|j |n|j j |||r8|j |n|rxKt|j|D]4\}} |jj| d |jj | d qQWndS(u9 Save the current figure. Call signature:: savefig(fname, dpi=None, facecolor='w', edgecolor='w', orientation='portrait', papertype=None, format=None, transparent=False, bbox_inches=None, pad_inches=0.1, frameon=None) The output formats available depend on the backend being used. Parameters ---------- fname : str or file-like object A string containing a path to a filename, or a Python file-like object, or possibly some backend-dependent object such as :class:`~matplotlib.backends.backend_pdf.PdfPages`. If *format* is *None* and *fname* is a string, the output format is deduced from the extension of the filename. If the filename has no extension, the value of the rc parameter ``savefig.format`` is used. If *fname* is not a string, remember to specify *format* to ensure that the correct backend is used. Other Parameters ---------------- dpi : [ *None* | scalar > 0 | 'figure'] The resolution in dots per inch. If *None* it will default to the value ``savefig.dpi`` in the matplotlibrc file. If 'figure' it will set the dpi to be the value of the figure. facecolor : color spec or None, optional the facecolor of the figure; if None, defaults to savefig.facecolor edgecolor : color spec or None, optional the edgecolor of the figure; if None, defaults to savefig.edgecolor orientation : {'landscape', 'portrait'} not supported on all backends; currently only on postscript output papertype : str One of 'letter', 'legal', 'executive', 'ledger', 'a0' through 'a10', 'b0' through 'b10'. Only supported for postscript output. format : str One of the file extensions supported by the active backend. Most backends support png, pdf, ps, eps and svg. transparent : bool If *True*, the axes patches will all be transparent; the figure patch will also be transparent unless facecolor and/or edgecolor are specified via kwargs. This is useful, for example, for displaying a plot on top of a colored background on a web page. The transparency of these patches will be restored to their original values upon exit of this function. frameon : bool If *True*, the figure patch will be colored, if *False*, the figure background will be transparent. If not provided, the rcParam 'savefig.frameon' will be used. bbox_inches : str or `~matplotlib.transforms.Bbox`, optional Bbox in inches. Only the given portion of the figure is saved. If 'tight', try to figure out the tight bbox of the figure. If None, use savefig.bbox pad_inches : scalar, optional Amount of padding around the figure when bbox_inches is 'tight'. If None, use savefig.pad_inches bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional A list of extra artists that will be considered when the tight bbox is calculated. udpiu savefig.dpiuframeonusavefig.frameonu transparentusavefig.transparentu facecolorunoneu edgecolorusavefig.facecolorusavefig.edgecoloriiN(t setdefaultRRRIRRRRRRRRRt print_figuretzip( R tfnameRRt transparenttoriginal_axes_colorsRRtoriginal_frameontcc((s0lib/python2.7/site-packages/matplotlib/figure.pytsavefigs4S     c  `s|dkr|j}n|j}|dkr|rpt|trp|j rptj||\}}qtj||\}}nt|_ ddddddgfd|j D}tj |||}|j |t|_ |S( u Create a colorbar for a ScalarMappable instance, *mappable*. Documentation for the pylab thin wrapper: %(colorbar_doc)s ufractionupadushrinkuaspectuanchorupanchorc`s+i|]!\}}|kr||qS(((R4R(R&(tNON_COLORBAR_KEYS(s0lib/python2.7/site-packages/matplotlib/figure.pys 1s N(R/RR:RRtcbartmake_axes_gridspect make_axesRQRR$tcolorbar_factoryR,R( R tmappableRRt use_gridspectkwt current_axtcb_kwtcb((Rs0lib/python2.7/site-packages/matplotlib/figure.pytcolorbars         cO`s|jr)|jttjdn|jj||x|jD]}t|t st|j t r|j j |j |j j qt|jt r|jj |j |jj qqF|j |j |j qFWt|_dS(u& Call signature:: subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) Update the :class:`SubplotParams` with *kwargs* (defaulting to rc when *None*) and update the subplot locations. uThis figure was using constrained_layout==True, but that is incompatible with subplots_adjust and or tight_layout: setting constrained_layout==False. N(RRRR@RARRSRIR:Rt_sharext update_paramsRtfigboxt_shareyRQR(R RRR((s0lib/python2.7/site-packages/matplotlib/figure.pyR8s     iicC`s7t|d|d|d|}|d|d|d|S(u5 Blocking call to interact with a figure. Wait until the user clicks *n* times on the figure, and return the coordinates of each click in a list. The buttons used for the various actions (adding points, removing points, terminating the inputs) can be overridden via the arguments *mouse_add*, *mouse_pop* and *mouse_stop*, that give the associated mouse button: 1 for left, 2 for middle, 3 for right. Parameters ---------- n : int, optional, default: 1 Number of mouse clicks to accumulate. If negative, accumulate clicks until the input is terminated manually. timeout : scalar, optional, default: 30 Number of seconds to wait before timing out. If zero or negative will never timeout. show_clicks : bool, optional, default: False If True, show a red cross at the location of each click. mouse_add : int, one of (1, 2, 3), optional, default: 1 (left click) Mouse button used to add points. mouse_pop : int, one of (1, 2, 3), optional, default: 3 (right click) Mouse button used to remove the most recently added point. mouse_stop : int, one of (1, 2, 3), optional, default: 2 (middle click) Mouse button used to stop input. Returns ------- points : list of tuples A list of the clicked (x, y) coordinates. Notes ----- The keyboard can also be used to select points in case your mouse does not have one or more of the buttons. The delete and backspace keys act like right clicking (i.e., remove last point), the enter key terminates input and any other key (not already used by the window manager) selects a point. t mouse_addt mouse_popt mouse_stoptnttimeoutt show_clicks(R(R RRRRRRtblocking_mouse_input((s0lib/python2.7/site-packages/matplotlib/figure.pytginputYs -  icC`st|}|d|S(u Blocking call to interact with the figure. This will return True is a key was pressed, False if a mouse button was pressed and None if *timeout* was reached without either being pressed. If *timeout* is negative, does not timeout. R(R(R Rtblocking_input((s0lib/python2.7/site-packages/matplotlib/figure.pytwaitforbuttonpresss cC`sug|jD]}|jr |^q }x3|jD](}|jr5|j|jq5q5W|j|j|S(N(RRhRIRtget_default_bbox_extra_artistsR8R(R Rt bbox_artistsR((s0lib/python2.7/site-packages/matplotlib/figure.pyRs cC`sg}x6|jD]+}|jr|j|j|qqWt|dkrX|jStjg|D]*}|jdks|j dkre|^qe}t |t j d|j }|S(u Return a (tight) bounding box of the figure in inches. It only accounts axes title, axis labels, and axis ticklabels. Needs improvement. ig?(RIRhRt get_tightbboxRER}RtunionRqRrRRR~R(R RqtbbRRt_bboxR}((s0lib/python2.7/site-packages/matplotlib/figure.pyRs @cC`sP|jdkrLtjddddd||_|jjddddndS(u7Initialize the layoutbox for use in constrained_layout.RRufiglbRgg?N(RR/RRtconstrain_geometry(R ((s0lib/python2.7/site-packages/matplotlib/figure.pytinit_layoutboxs  c C`sddlm}tjd|jdkr=tjddS|j\}}}}|}|j \}} ||}|| }|dkrt j |}n|||||||dS(u} Use ``layoutbox`` to determine pos positions within axes. See also `.set_constrained_layout_pads`. i(tdo_constrained_layoutuExecuting constrainedlayoutuCalling figure.constrained_layout, but figure not setup to do constrained layout. You either called GridSpec without the fig keyword, you are using plt.subplot, or you need to call figure or subplotswith the constrained_layout=True kwarg.N( tmatplotlib._constrained_layoutRt_logtdebugRR/R@RARRRR( R RqRRRRXRYtfigRqRr((s0lib/python2.7/site-packages/matplotlib/figure.pyRks     gHzG?c C`sddlm}m}m}||j} d| krGtjdn|dkrb||}n|||j| |d|d|d|d|} |j| dS( u Adjust subplot parameters to give specified padding. Parameters ---------- pad : float padding between the figure edge and the edges of subplots, as a fraction of the font-size. h_pad, w_pad : float, optional padding (height/width) between edges of adjacent subplots. Defaults to `pad_inches`. rect : tuple (left, bottom, right, top), optional a rectangle (left, bottom, right, top) in the normalized figure coordinate that the whole subplots area (including labels) will fit into. Default is (0, 0, 1, 1). i(Rtget_subplotspec_listtget_tight_layout_figureucThis figure includes Axes that are not compatible with tight_layout, so results might be incorrect.tpadRRR/N( RRRRRIR/R@RAR( R RqRRRR/RRRtsubplotspec_listR((s0lib/python2.7/site-packages/matplotlib/figure.pyRs  cC`s*|dkr|j}ntj|j}x|D]}tjd|j|j}|j \}}}}}} |j j } x|D]} | j j | kr| j}|j \}}} } }} | dkr| |ks| dkr| |kr|j j || qqqWq4WdS(ut Align the ylabels of subplots in the same subplot column if label alignment is being done automatically (i.e. the label position is not manually set). Alignment persists for draw events after this is called. If a label is on the bottom, it is aligned with labels on axes that also have their label on the bottom and that have the same bottom-most subplot row. If the label is on the top, it is aligned with labels on axes with the same top-most row. Parameters ---------- axs : list of `~matplotlib.axes.Axes` Optional list of (or ndarray) `~matplotlib.axes.Axes` to align the xlabels. Default is to align all axes on the figure. See Also -------- matplotlib.figure.Figure.align_ylabels matplotlib.figure.Figure.align_labels Notes ----- This assumes that ``axs`` are from the same `.GridSpec`, so that their `.SubplotSpec` positions correspond to figure positions. Examples -------- Example with rotated xtick labels:: fig, axs = plt.subplots(1, 2) for tick in axs[0].get_xticklabels(): tick.set_rotation(55) axs[0].set_xlabel('XLabel 0') axs[1].set_xlabel('XLabel 1') fig.align_xlabels() u Working on: %subottomutopN(R/RIRytasarraytravelRRt get_xlabeltget_subplotspectget_rows_columnsR=tget_label_positionRtjoin(R taxsRtssRBRCtrow0trow1tcol0tcol1tlabpotaxctrowc0trowc1tcolc((s0lib/python2.7/site-packages/matplotlib/figure.pyt align_xlabels s,      cC`sB|dkr|j}ntj|j}x|D]}tjd|j|j}|j \}}}}}} |g} |j j } x|D]} | |kr| j j | kr6| j}|j \}}}}} }| dkr| |ks| dkr3|| kr3|j j || q3q6qqWq4WdS(uO Align the ylabels of subplots in the same subplot column if label alignment is being done automatically (i.e. the label position is not manually set). Alignment persists for draw events after this is called. If a label is on the left, it is aligned with labels on axes that also have their label on the left and that have the same left-most subplot column. If the label is on the right, it is aligned with labels on axes with the same right-most column. Parameters ---------- axs : list of `~matplotlib.axes.Axes` Optional list (or ndarray) of `~matplotlib.axes.Axes` to align the ylabels. Default is to align all axes on the figure. See Also -------- matplotlib.figure.Figure.align_xlabels matplotlib.figure.Figure.align_labels Notes ----- This assumes that ``axs`` are from the same `.GridSpec`, so that their `.SubplotSpec` positions correspond to figure positions. Examples -------- Example with large yticks labels:: fig, axs = plt.subplots(2, 1) axs[0].plot(np.arange(0, 1000, 50)) axs[0].set_ylabel('YLabel 0') axs[1].set_ylabel('YLabel 1') fig.align_ylabels() u Working on: %sulefturightN(R/RIRyRRRRt get_ylabelRRR@RRR(R RRRRBRCRRRRtsameRRtcolc0tcolc1((s0lib/python2.7/site-packages/matplotlib/figure.pyt align_ylabelsK s"+        cC`s$|jd||jd|dS(u Align the xlabels and ylabels of subplots with the same subplots row or column (respectively) if label alignment is being done automatically (i.e. the label position is not manually set). Alignment persists for draw events after this is called. Parameters ---------- axs : list of `~matplotlib.axes.Axes` Optional list (or ndarray) of `~matplotlib.axes.Axes` to align the labels. Default is to align all axes on the figure. See Also -------- matplotlib.figure.Figure.align_xlabels matplotlib.figure.Figure.align_ylabels RN(RR(R R((s0lib/python2.7/site-packages/matplotlib/figure.pyt align_labels sN(TRMRNRORiRoR/R$tpropertyR0t deprecatedRRRQRRRIRRRRRRRRRRRRRRRRRR RRRRRRRRRRRRRRR"R+R1R4RNR.RRRRlRrRRtdedent_interpdRzRRRR,RRRRRRRRRRRRRkRRRR(((s0lib/python2.7/site-packages/matplotlib/figure.pyRes   p!  '          $ -  I  Y(             i k    .  0   " ,  t ! 3      $ E Ec C`st|dotj| }tjd }tjd }|rc|jd \}}||}n|}tdd}tj|||f}|td||}|td||}tj|||}|S( u> Create a figure with specified aspect ratio. If *arg* is a number, use that aspect ratio. If *arg* is an array, figaspect will determine the width and height for a figure that would fit array preserving aspect ratio. The figure width, height in inches are returned. Be sure to create an axes with equal with and height, e.g., Example usage:: # make a figure twice as tall as it is wide w, h = figaspect(2.) fig = Figure(figsize=(w,h)) ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) ax.imshow(A, **kwargs) # make a figure with the proper aspect for an array A = rand(5,3) w, h = figaspect(A) fig = Figure(figsize=(w,h)) ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) ax.imshow(A, **kwargs) Thanks to Fernando Perez for this function ushapeg@g@g0@iufigure.figsizeig?(g@g@(g0@g0@( RRytisscalarRRRtminRtclip( targtisarrayt figsize_mint figsize_maxtnrtnct arr_ratiot fig_heighttnewsize((s0lib/python2.7/site-packages/matplotlib/figure.pyt figaspect s (JROt __future__RRRRR)tloggingR@tnumpyRyRRRRRtmatplotlib.artistRtmartistRRtmatplotlib.cbookR0R R R Rmtmatplotlib.imageR tmatplotlib.colorbarRRtmatplotlib.axesR RRtmatplotlib.blocking_inputRRtmatplotlib.gridspecRtmatplotlib.legendRzRstmatplotlib.patchesRtmatplotlib.projectionsRRtmatplotlib.textRRtmatplotlib.transformsRRRRtmatplotlib._layoutboxRRtmatplotlib.backend_basesRt getLoggerRMRtinterpdRSR"R#R?RPReRtkwdoc(((s0lib/python2.7/site-packages/matplotlib/figure.pyt sR"    " mQ ;