CRc@ s ddlmZmZddlZddlZddlmZddlZddlZ ddlm Z ddl Z e j Z ddl jZddl mZddljZddljZddljZddljZddljZddlj Z!ddl m"Z"ddl#j$Z$ddl%j&Z'ddl(j)Z*ddl+j,Z-ddl.j/Z0ddl1j2Z2ddl3j4Z5ddl6j7Z8ddl9j:Z;ddl<j=Z>ddl?j@ZAddlBjCZDddlEjFZGddlHjIZJddlKjLZMddlNjOZPddlQjRZSddlTjUZVddlWmXZXmYZYmZZZej[Z[ej\Z\ej]Z]dZ^d Z_d e`fd YZad ejbfd YZcddldmeZemfZfdfdYZgiZheidZjejZkde`fdYZle"jmjnd ejoece"jmjndejoecdS(i(tdivisiontprint_functionN(t itemgetter(tma(tallow_rasterization(t docstring(t BarContainertErrorbarContainert StemContainercC s@t|s|S|dkr tS|dkr0tStddS(Ntontoffs,string argument must be either 'on' or 'off'(tis_string_liketTruetFalset ValueError(ts((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt_string_to_bool/s   cC s]d }d }d }yitjj|}ytt|}Wntk rZ|||fSX||krt|||fSd }Wntk rnX|jddkrd}|jdd}n|jddkrd}|jdd}n|jddkrd}|jdd}ng|D] }|^q&}x|D]}|t j kr||d k rstd|n|}q?|t j kr|d k rtd|n|}q?|tjj kr|d k rtd |n|}q?td |q?W|d kr&|d kr&t d }n|d kr;d}n|d krPd}n|||fS( s Process a MATLAB style color/line style format string. Return a (*linestyle*, *color*) tuple as a result of the processing. Default values are ('-', 'b'). Example format strings include: * 'ko': black circles * '.b': blue dots * 'r--': red dashed lines .. seealso:: :func:`~matplotlib.Line2D.lineStyles` and :func:`~matplotlib.pyplot.colors` for all possible styles and color format string. s--its-.t tNones1Illegal format string "%s"; two linestyle symbolss.Illegal format string "%s"; two marker symbolss-Illegal format string "%s"; two color symbolss*Unrecognized character %c in format stringslines.linestyleN(RtmcolorstcolorConvertertto_rgbtstrtintRtfindtreplacetmlinest lineStylest lineMarkerstcolorstrcParams(tfmtt linestyletmarkertcolortfmtinttctchars((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt_process_plot_format9sb                 t_process_plot_var_argscB seZdZddZdZdZddZdZdZ dZ d Z d Z d Z d Zd ZRS(s3 Process variable length arguments to the plot command, so that plot commands like the following are supported:: plot(t, s) plot(t1, s1, t2, s2) plot(t1, s1, 'ko', t2, s2) plot(t1, s1, 'ko', t2, s2, 'r--', t3, e3) an arbitrary number of *x*, *y*, *fmt* are allowed tplotcC s ||_||_|jdS(N(taxestcommandtset_color_cycle(tselfR*R+((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt__init__s  cC si|jd6|jd6S(NR*R+(R*R+(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt __getstate__scC s|j|_|jdS(N(tcopyt__dict__R,(R-tstate((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt __setstate__scC s/|dkrtd}ntj||_dS(Nsaxes.color_cycle(RRt itertoolstcyclet color_cycle(R-tclist((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR,s  cO s|jjdk r|jjdk r|jd|jjj}|jjdkrf|jd|}n|jd|jjj}|jjdkr|jd|}n||jjjkr|jjj|n||jjjkr|jjj|qn|j||}|S(Ntxunitstpolart thetaunitstyunitstrunits( R*txaxisRtyaxistpoptunitstnamet set_unitst_grab_next_args(R-targstkwargsR8R;tret((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt__call__s$cK s|jdkstdx_|jD]Q\}}d|}t||s`td|nt||}||q(WdS(NR)s$set_lineprops only works with "plot"sset_%ssThere is no line property "%s"(R+tAssertionErrortitemsthasattrt TypeErrortgetattr(R-tlineREtkeytvaltfuncNametfunc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_linepropss cK s|jdkstdx_|jD]Q\}}d|}t||s`td|nt||}||q(WdS(Ntfills%set_patchprops only works with "fill"sset_%ssThere is no patch property "%s"(R+RHRIRJRKRL(R-t fill_polyRERNRORPRQ((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytset_patchpropss cC sm|jjdk r|jjdk r|jjj|}|jjj|}|jdkr|rx|jj|}n|r|jj|}qqntj |}tj |}|j d|j dkrt dn|j dks|j dkr t dn|j dkr8|ddtj f}n|j dkrc|ddtj f}n||fS(NR)is&x and y must have same first dimensionis"x and y can be no greater than 2-Di(R*R=RR>t update_unitsR+tconvert_xunitstconvert_yunitstnpt atleast_1dtshapeRtndimtnewaxis(R-txtytbxtby((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt _xy_from_xys&$ cC sr|j}d|kr@d|jkr@|jj|dd;Z?d<Z@d=ZAd>ZBd?ZCd@ZDe e dAZEdBZFdCZGe e e dDZHdEZIdFZJdGZKdHZLdIZMdJZNdKZOdLZPdMZQdNZRdOZSdPZTe de dQZUe e e dRZVeWe edSZXdTZYdUZZdVZ[dWZ\dXZ]dYZ^dZZ_e`jae d[dd\Zbd]Zcde d^Zddd_Zed`ZfdaZgdbZhdcZiddZjdeZkdfZle e dgZmdhZne e e ediZodjZpdkdljqerjsep_e`jadmZtednZuedoZvdpZwdqZxedrZye`jae edsZzdtZ{duZ|dvZ}e e dwZ~dxZe e e edyZdzZd{dljqerjse_e`jad|Zed}Zed~ZdZdZedZe`jae edZe dZe dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZddZe`jae ddZdZe`jae e dZdZe`jae e dZe`jae edZe`jadZe`jaddddZe`jaddddZe`jadddZe`jadddZe`jddddZe`jaddddZe`jaddde e ddZe`jadZe`jade e edZe`jadZe`jadZe`jadZe`jadZe`jae eje ddZe dZe dZdZdZe`jade dZe`jade dZe`jadZdZe e e e dede e d Ze`jae e de e deeeeede d Zede de e ee e e d Ze`jaddde e e e e e e d Ze`jae de dde e e e e e e deje edZe`jadZdZejje_dZejje_dZejje_de e e e ddde d Zejje_e`jadZe`jadZe`jade edZe`jade dZe`jae e e e e e e e e e dde e e dZedZe`jadZe`jadZe`jadZdZejje_dZejje_dZejjje_e`jadZdZdZdZdZdZe`jade ee ee ddde ee e edZe`jade ee e e dZe`jadddejejde de d Ze`jadddejejde de d Ze`jadddejejde de d Ze`jadddejejde e e de d Zde e ddZdZdZe dZdZdZdZejje_dZejje_dZejje_dZejje_RS(sa The :class:`Axes` contains most of the figure elements: :class:`~matplotlib.axis.Axis`, :class:`~matplotlib.axis.Tick`, :class:`~matplotlib.lines.Line2D`, :class:`~matplotlib.text.Text`, :class:`~matplotlib.patches.Polygon`, etc., and sets the coordinate system. The :class:`Axes` instance supports callbacks through a callbacks attribute which is a :class:`~matplotlib.cbook.CallbackRegistry` instance. The events you can connect to are 'xlim_changed' and 'ylim_changed' and the callback will be called with func(*ax*) where *ax* is the :class:`Axes` instance. t rectilinearcC sdt|jjS(NsAxes(%g,%g;%gx%g)(ttuplet _positiontbounds(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt__str__^sRc K sdidjgtjD]} t| ^qd6tjj|t|tj re||_ ntj j ||_ |j j |_ |j||jdd|_|jd||_||_|dk r|jj|||jdkrd|_nd|_n|dk rZ|jj|||jdkrNd|_nd|_n|j||j||j| jdd|j|_|j|dkrtd }n||_||_ td |_!d|_"td |_#i|_$|j%d|_&d|_'|j(dd|_)|j*t+|j,d|r_|j-|n| ru|j.| nt/| rtj0|| n|j1dk r|j1j2j3d|j4|_5n|j6dk r|j6j2j3d|j4|_7ndS(Ns5 Build an :class:`Axes` instance in :class:`~matplotlib.figure.Figure` *fig* with *rect=[left, bottom, width, height]* in :class:`~matplotlib.figure.Figure` coordinates Optional keyword arguments: ================ ========================================= Keyword Description ================ ========================================= *adjustable* [ 'box' | 'datalim' | 'box-forced'] *alpha* float: the alpha transparency (can be None) *anchor* [ 'C', 'SW', 'S', 'SE', 'E', 'NE', 'N', 'NW', 'W' ] *aspect* [ 'auto' | 'equal' | aspect_ratio ] *autoscale_on* [ *True* | *False* ] whether or not to autoscale the *viewlim* *axis_bgcolor* any matplotlib color, see :func:`~matplotlib.pyplot.colors` *axisbelow* draw the grids and ticks below the other artists *cursor_props* a (*float*, *color*) tuple *figure* a :class:`~matplotlib.figure.Figure` instance *frame_on* a boolean - draw the axes frame *label* the axes label *navigate* [ *True* | *False* ] *navigate_mode* [ 'PAN' | 'ZOOM' | None ] the navigation toolbar button status *position* [left, bottom, width, height] in class:`~matplotlib.figure.Figure` coords *sharex* an class:`~matplotlib.axes.Axes` instance to share the x-axis with *sharey* an class:`~matplotlib.axes.Axes` instance to share the y-axis with *title* the title string *visible* [ *True* | *False* ] whether the axes is visible *xlabel* the xlabel *xlim* (*xmin*, *xmax*) view limits *xscale* [%(scale)s] *xticklabels* sequence of strings *xticks* sequence of floats *ylabel* the ylabel strings *ylim* (*ymin*, *ymax*) view limits *yscale* [%(scale)s] *yticklabels* sequence of strings *yticks* sequence of floats ================ ========================================= s | tscaletautotboxtCtdatalimt axes_locatorsaxes.facecolorsaxes.axisbelows axes.holdiRzsunits finalize(iRz(8tjointmscaletget_scale_namestreprtmartisttArtistR.t isinstancet mtransformstBboxRt from_boundstfrozent_originalPositiontset_axest set_aspectt _adjustablet set_anchort_sharext_shareyRt_shared_x_axest_shared_y_axest set_labelt set_figuretset_axes_locatorRut_gen_axes_spinestspinest _init_axisRt_axisbgt_frameont _axisbelowt_rasterization_zordert_holdt _connectedtclat fmt_xdatat fmt_ydatatset_cursor_propst_cachedRenderert set_navigateR tset_navigate_modet set_xscalet set_yscaleRqtsetpR=t callbackstconnecttrelimt_xcidR>t_ycid( R-tfigtrecttaxisbgtframeontsharextshareytlabeltxscaletyscaleRER^((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR.asn< +                                cC s\||_xLddddddgD]2}t||}x|D]}|j|_q>Wq"WdS(Ntlinest collectionsttablestpatchesttextstimages(R1RLtremovet_remove_method(R-R2tcontainer_namet containertartist((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR3s   cO s|jS(sc get the axes bounding box in display space; *args* and *kwargs* are empty (tbbox(R-RDRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_window_extentscC stj||_|jdj|j|jdj|jtj||_|jdj|j|jdj|j|jdS(sAmove this out of __init__ because non-separable axes don't use ittbottomttoptlefttrightN(tmaxistXAxisR=Rt register_axistYAxisR>t_update_transScale(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRscC sxtjj||tj|j|j|_tjj |_ tjj |_ tj tj|_|jdS(s| Set the class:`~matplotlib.axes.Axes` figure accepts a class:`~matplotlib.figure.Figure` instance N(RRRRtTransformedBboxRt transFigureRRtnulltdataLimtunittviewLimtTransformWrappertIdentityTransformt transScalet_set_lim_and_transforms(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs cC stj|j|_tjtj|_tjtj|j |j|_ |j|j |j|_ tj |j |j|_ tj |j|j |_dS(sB set the *dataLim* and *viewLim* :class:`~matplotlib.transforms.Bbox` attributes and the *transScale*, *transData*, *transLimits* and *transAxes* transformations. .. note:: This method is primarily used by rectilinear projections of the :class:`~matplotlib.axes.Axes` class, and is meant to be overridden by new kinds of projection axes that need different transformations and limits. (See :class:`~matplotlib.projections.polar.PolarAxes` for an example. N(RtBboxTransformToRt transAxesRRRtBboxTransformFromRRt transLimitst transDatatblended_transform_factoryt_xaxis_transformt_yaxis_transform(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRstgridcC s]|dkr|jS|dkr0|jdjS|dkrM|jdjStddS(s Get the transformation used for drawing x-axis labels, ticks and gridlines. The x-direction is in data coordinates and the y-direction is in axis coordinates. .. note:: This transformation is primarily used by the :class:`~matplotlib.axis.Axis` class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations. Rttick1Rttick2Rsunknown value for whichN(RRtget_spine_transformR(R-twhich((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_xaxis_transform<s   cC s:|jddtjdd|d|jjddfS(s Get the transformation used for drawing x-axis labels, which will add the given amount of padding (in points) between the axes and the label. The x-direction is in data coordinates and the y-direction is in axis coordinates. Returns a 3-tuple of the form:: (transform, valign, halign) where *valign* and *halign* are requested alignments for the text. .. note:: This transformation is primarily used by the :class:`~matplotlib.axis.Axis` class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations. RRiigR@Rtcenter(RRtScaledTranslationtfiguretdpi_scale_trans(R-t pad_points((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_xaxis_text1_transformUs cC s6|jddtjd|d|jjddfS(s Get the transformation used for drawing the secondary x-axis labels, which will add the given amount of padding (in points) between the axes and the label. The x-direction is in data coordinates and the y-direction is in axis coordinates. Returns a 3-tuple of the form:: (transform, valign, halign) where *valign* and *halign* are requested alignments for the text. .. note:: This transformation is primarily used by the :class:`~matplotlib.axis.Axis` class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations. RRigR@RR(RRRRR(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_xaxis_text2_transformos cC s]|dkr|jS|dkr0|jdjS|dkrM|jdjStddS(s Get the transformation used for drawing y-axis labels, ticks and gridlines. The x-direction is in axis coordinates and the y-direction is in data coordinates. .. note:: This transformation is primarily used by the :class:`~matplotlib.axis.Axis` class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations. RRRRRsunknown value for whichN(RRRR(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_yaxis_transforms   cC s:|jddtjd|dd|jjddfS(s Get the transformation used for drawing y-axis labels, which will add the given amount of padding (in points) between the axes and the label. The x-direction is in axis coordinates and the y-direction is in data coordinates. Returns a 3-tuple of the form:: (transform, valign, halign) where *valign* and *halign* are requested alignments for the text. .. note:: This transformation is primarily used by the :class:`~matplotlib.axis.Axis` class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations. RRigR@iRR(RRRRR(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_yaxis_text1_transforms cC s6|jddtj|dd|jjddfS(s Get the transformation used for drawing the secondary y-axis labels, which will add the given amount of padding (in points) between the axes and the label. The x-direction is in axis coordinates and the y-direction is in data coordinates. Returns a 3-tuple of the form:: (transform, valign, halign) where *valign* and *halign* are requested alignments for the text. .. note:: This transformation is primarily used by the :class:`~matplotlib.axis.Axis` class, and is meant to be overridden by new kinds of projections that may need to place axis elements in different locations. RRgR@iRR(RRRRR(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_yaxis_text2_transforms cC s}|jjtj|jj|jjt|dryx9|jD]+}y|j j WqGt k rqqGXqGWndS(NR( RtsetRRR=t get_transformR>RJRt_transformed_patht invalidatetAttributeError(R-RM((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs  cC s$|r|jjS|jjSdS(s1Return the a copy of the axes rectangle as a BboxN(RRR(R-toriginal((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_positions tbothcC sit|tjs'tjj|}n|dkrF|jj|n|dkre|jj|ndS(s Set the axes position with:: pos = [left, bottom, width, height] in relative 0,1 coords, or *pos* can be a :class:`~matplotlib.transforms.Bbox` There are two position variables: one which is ultimately used, but which may be modified by :meth:`apply_aspect`, and a second which is the starting point for :meth:`apply_aspect`. Optional keyword arguments: *which* ========== ==================== value description ========== ==================== 'active' to change the first 'original' to change the second 'both' to change both ========== ==================== RtactiveRN(RR (Rsoriginal(RRtBboxBaseRRRRR(R-tposR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_positions   cC s)|jdt}|j|dddS(s.Make the original position the active positionRRR N(RR R (R-R ((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytreset_position scC s ||_dS(s set axes_locator ACCEPT: a callable object which takes an axes instance and renderer and returns a bbox. N(t _axes_locator(R-tlocator((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRscC s|jS(s% return axes_locator (R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_axes_locatorscC s@|j|j|js/|j|jn|j|dS(s3set the boilerplate props for artists added to axesN(RRtis_transform_sett set_transformRR(R-ta((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt_set_artist_propss cC stjdddS(s] Returns the patch used to draw the background of the axes. It is also used as the clipping path for any data elements on the axes. In the standard axes, this is a rectangle, but in other projections it may not be. .. note:: Intended to be overridden by new projection types. gg?(gg(Rlt Rectangle(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt_gen_axes_patch%sgtinchescC s\itjj|dd6tjj|dd6tjj|dd6tjj|dd6S(si Returns a dict whose keys are spine names and values are Line2D or Patch instances. Each element is used to draw a spine of the axes. In the standard axes, this is a single line segment, but in other projections it may not be. .. note:: Intended to be overridden by new projection types. RRRR(tmspinestSpinet linear_spine(R-t locationstoffsetR@((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR5s c C sR|jj|jjx'|jjD]\}}|jq*Wt|_tj|_ |j dk rm|j jj |j_ |j jj |j_ |j j\}}|j||dtdd|j jj}|j jj}|j jj}|j jj}|jj|j jj|jj||jj||jj||jj|n|jjd|jdk r|jjj |j_ |jjj |j_ |jj\} } |j| | dtdd|jjj}|jjj}|jjj}|jjj}|jj|jjj|jj||jj||jj||jj|n|jjdt|_t|_t d|_!t d|_"t|_#|j$t%||_&t%|d|_'t d|_(g|_)g|_*g|_+g|_,g|_-g|_.d|_/d|_0g|_1g|_2|j3|j(t4j5dt d } t6j7d d|j8j9|_:t;j<d dddddd| dddd|_=t;j<d d ddddd| dddd|_>t;j<d dddddd| dddd|_?xQ|j=|j>|j?fD]7} | j@|jA|j:| jBd|jC| q[W|jD|_E|_F|jEjG|j8|jEjH|jI|jEjJd|jEjKd|jEj@|jAt|_L|jjM|jE|jjM|jE|jNjO|jPjOdS(sClear the current axes.temitRtlinears axes.xmargins axes.ymarginRSs axes.gridtsizesaxes.titlesizegg@gR@R^g?R_g?ttextRtfontpropertiestverticalalignmenttbaselinethorizontalalignmentRRRRiNgrqDZ?(QR=RR>Rt iteritemsR tignore_existing_data_limitstcbooktCallbackRegistryRRRtmajortminortget_xlimtset_xlimR tget_major_formattertget_minor_formattertget_major_locatortget_minor_locatort _set_scalet get_scaletset_major_formattertset_minor_formattertset_major_locatortset_minor_locatorRtget_ylimtset_ylimt _autoscaleXont _autoscaleYonRt_xmargint_ymargint_tightRR(t _get_linest_get_patches_for_fillt_gridOnRRRRtartistsRt_current_imagetlegend_Rt containersRt font_managertFontPropertiesRRRRttitleOffsetTranstmtexttTextttitlet _left_titlet _right_titleRRt set_clip_boxRRtpatcht axesPatchRt set_facecolorRt set_edgecolort set_linewidthtaxisont set_clip_pathRtcleanR( R-RAtspinetx0tx1tmajftminftmajltminlty0ty1tpropst_title((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRIs                             cC s|jdS(sclear the axesN(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytclearscC s$|jj||jj|dS(s Set the color cycle for any future plot commands on this Axes. *clist* is a list of mpl color specifiers. N(R>R,R?(R-R7((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR,scC s|jS(s"return the HOLD status of the axes(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytisholdscC s)|dkr|j |_n ||_dS(s. Call signature:: hold(b=None) Set the hold state. If *hold* is *None* (default), toggle the *hold* state. Else set the *hold* state to boolean value *b*. Examples:: # toggle hold hold() # turn hold on hold(True) # turn hold off hold(False) When hold is *True*, subsequent plot commands will be added to the current axes. When hold is *False*, the current axes and figure will be cleared on the next plot command N(RR(R-tb((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytholds cC s|jS(N(t_aspect(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_aspectscC s|dkr7tjdddddddd|_n'|d krO||_nt||_|d k rz|j|n|d k r|j|nd S( s\ *aspect* ======== ================================================ value description ======== ================================================ 'auto' automatic; fill position rectangle with data 'normal' same as 'auto'; deprecated 'equal' same scaling from data to plot units for x and y num a circle will be stretched such that the height is num times the width. aspect=1 is the same as aspect='equal'. ======== ================================================ *adjustable* ============ ===================================== value description ============ ===================================== 'box' change physical size of axes 'datalim' change xlim or ylim 'box-forced' same as 'box', but axes can be shared ============ ===================================== 'box' does not allow axes sharing, as this can cause unintended side effect. For cases when sharing axes is fine, use 'box-forced'. *anchor* ===== ===================== value description ===== ===================== 'C' centered 'SW' lower left corner 'S' middle of bottom edge 'SE' lower right corner etc. ===== ===================== .. deprecated:: 1.2 the option 'normal' for aspect is deprecated. Use 'auto' instead. tnormals1.2RAt alternativeRtobj_typetaspecttequalN(sequalsauto(R'twarn_deprecatedReRtRtset_adjustableR(R-Rjt adjustabletanchor((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs,      cC s|jS(N(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_adjustable6scC sd|dkrT||jks*||jkrH|dkrHtdqHn||_n tddS(s> ACCEPTS: [ 'box' | 'datalim' | 'box-forced'] RRs box-forceds,adjustable must be "datalim" for shared axess$argument must be "box", or "datalim"N(sboxsdatalims box-forced(RRRR(R-Rn((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRm9s   cC s|jS(N(t_anchor(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_anchorFscC s_|tjjjks*t|dkr6||_n%tddjtjjjdS(su *anchor* ===== ============ value description ===== ============ 'C' Center 'SW' bottom left 'S' bottom 'SE' bottom right 'E' right 'NE' top right 'N' top 'NW' top left 'W' left ===== ============ isargument must be among %ss, N(RRtcoefsRcRqRqRR(R-Ro((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRIs* cC sd|j\}}|j\}}ttj||d}ttj||d}||S(s Returns the aspect ratio of the raw data. This method is intended to be overridden by new projection types. gKH9(t get_xboundt get_yboundRwtmathtfabs(R-txmintxmaxtymintymaxtxsizetysize((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_data_ratiobs cC s|j\}}|j\}}ttjtj|tj|d}ttjtj|tj|d}||S(s Returns the aspect ratio of the raw data in log scale. Will be used when both axis scales are in log. gKH9(RtRuRwRvRwtlog10(R-RxRyRzR{R|R}((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_data_ratio_logqs ..c0C s|d kr!|jdt}n|j}|jdkr|j|j}}|dkrv|dkrvd}q|dkr|dkrd}q|dkr|dks|dkr|dkr|dk rtjd||fd}qqnd}|dkr"|j |ddd S|d kr7d }n|}||j ks[||j kr|j d krd |_ tjdqn|j j\}}||} |j dkr-|dkr||j} n||j} |j} | j| | | } |j | j|j| dd S|j |dd|j\} }|j\}}|dkrtj| tj|} }tj|tj|}}nttj|| d}ttj||d}|j\}}}}| ||} | |}|||d}t|dkr>d S|dkr|j}tj|jtj|j}tj|j tj|j!}d|}d|}n#|j}d|j"}d|j#}||}||}||} ||}!|!|}"| |}#d}$d}%||j ko4||j k}&||j koR||j k}'|&rr|'rrtjdd S|&rt$}(nc||$kr||%kr|#dkr|dkp|"dko|dk})n |dk})|'p|)}(|(rTd||}*|*| d}+|*| d},|dkr>|j%d|+d|,fq|j%|+|,fngd| |}-|-|!d}.|-|!d}/|dkr|j&d|.d|/fn|j&|.|/fd S(sp Use :meth:`_aspect` and :meth:`_adjustable` to modify the axes box or the view limits. RR9RtlogRs:aspect is not supported for Axes with xscale=%s, yscale=%sRR NRkiRRs7shared axes: "adjustable" is being changed to "datalim"s box-forcedgKH9g?g{Gzt?g?is9adjustable='datalim' cannot work with shared x and y axesg?g@g$@(sboxs box-forced('RRR RfRAt get_xscalet get_yscaletwarningstwarnR RRRt get_figuretget_size_inchesRR~Rtshrunk_to_aspecttanchoredRrRtRuRvRRwRwRtabsRRXRWR^R]twidththeightR t set_yboundt set_xbound(0R-tpositionRjRRtaspect_scale_modetAtfigWtfigHt fig_aspectt box_aspecttpbtpb1RxRyRzR{R|R}tlRctwtht data_ratiot y_expandertdLtdL_widtht dL_heighttxrtyrtxmargtymargtYsizetXsizetXmargtYmargtxmtymtchangextchangeytadjust_ytadjytycR]R^txcRWRX((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt apply_aspect~s              " "   ""                  c O st|dkrXt|dkrX|j\}}|j\}}||||fSt|dkrt|dr|dj}|dkr|jn*|dkr|jn|dkr|jt|j d |j dt |dkr|j dd d q|dkrI|j dd d dd|jt q|dkru|j dt|jt q|d kr|j dt|jt |j dd d ddqnt d||j\}}|j\}}||||fS|j dt}y |dWntk r|j dd}|j dd}t } |dkrz|dkrzd} n|j||d|d | \}}|j dd}|j dd}t } |dkr|dkrd} n|j||d|d | \}}||||fSX|d}t|dkrIt dn|j|d|dgd|d t |j|d|dgd|d t |S(s Convenience method for manipulating the x and y view limits and the aspect ratio of the plot. For details, see :func:`~matplotlib.pyplot.axis`. *kwargs* are passed on to :meth:`set_xlim` and :meth:`set_ylim` iiR R RkttighttscaledRgRtimageRnRRRoRs-Unrecognized string %s to axis; try on or offRRxRyRzR{is$v must contain [xmin xmax ymin ymax]ii(sequalstightRsnormalsautosimageN(RqR+R7R tlowert set_axis_ont set_axis_offtset_autoscale_onR Rtautoscale_viewR RRut IndexErrorRR,R8( R-R{RERxRyRzR{RRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytaxissl $"                $ $ ''cC s|jS(sT Return the legend.Legend instance, or None if no legend is defined (RC(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_legendXscC stjd|jS(s2return a list of Axes images contained by the Axest AxesImage(R't silent_listR(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_images^scC stjd|jS(s,Return a list of lines contained by the AxesRe(R'RR(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_linesbscC s|jS(sReturn the XAxis instance(R=(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_xaxisfscC stjd|jjS(s2Get the x grid lines as a list of Line2D instancessLine2D xgridline(R'RR=t get_gridlines(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_xgridlinesjs cC stjd|jjS(s1Get the xtick lines as a list of Line2D instancessText xtickline(R'RR=t get_ticklines(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_xticklinesos cC s|jS(sReturn the YAxis instance(R>(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_yaxistscC stjd|jjS(s2Get the y grid lines as a list of Line2D instancessLine2D ygridline(R'RR>R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_ygridlinesxs cC stjd|jjS(s1Get the ytick lines as a list of Line2D instancessLine2D ytickline(R'RR>R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_yticklines}s cC swt|tjjr=|jd|jkrjtdqjn-||jkrj||jkrjtdn||_dS(sZ helper for :func:`~matplotlib.pyplot.sci`; do not use elsewhere. is"ContourSet must be in current AxessAArgument must be an image, collection, or ContourSet in this AxesN(Rt matplotlibtcontourt ContourSetRRRRB(R-tim((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt_scis cC s|jS(sZ Helper for :func:`~matplotlib.pyplot.gci`; do not use elsewhere. (RB(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt_gciscC s:t|jt|jt|jt|jdkS(s Return *True* if any artists have been added to axes. This should not be used to determine whether the *dataLim* need to be updated, and may not actually be useful for anything. i(RqRRRR(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pythas_datas &c sP|jjj|j||jjfd|_|S(sf Add any :class:`~matplotlib.artist.Artist` to the axes. Returns the artist. c sjj|S(N(RAR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyts(RRARxRRTRNR(R-R((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt add_artists   c s|j}|s/|jdtjnjj|j||jdkrq|jj n|r|j dk rt|j rt|j rj |j jnfd|_|S(s Add a :class:`~matplotlib.collections.Collection` instance to the axes. Returns the collection. s _collection%dc sjj|S(N(RR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRsN(t get_labelRRqRRxRt get_clip_pathRRTRNt_pathst_offsetstupdate_datalimt get_datalimRR(R-t collectiontautolimR((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytadd_collections  c sj||jdkr2|jjnj||jsh|jdtj nj j |fd|_ |S(sv Add a :class:`~matplotlib.lines.Line2D` to the list of plot lines Returns the line. s_line%dc sjj|S(N(RR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRsN( RRRRTRNt_update_line_limitsRRRqRRxR(R-RM((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytadd_lines   c C s|j}|jjdkr"dS|j}||jkrF|}nyt|j|jr||j}|jjr|j}|j \}}|j |}q|j |}n|}|jjdkr|j|j\} } |j j ||jd| d| t|_ndS(sV Figures out the data limit of the given line, updating self.dataLim. iNtupdatextupdatey(tget_pathtverticesRRRtanytcontains_branch_seperatelyt is_affinet_get_transformed_pathtget_transformed_path_and_affinettransform_path_affinettransform_pathRtupdate_from_pathR&R ( R-RMtpatht line_transt data_patht trans_to_datatline_trans_pathtna_patht_RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs,        c sej||jdkr2|jjnj|jj|fd|_|S(s Add a :class:`~matplotlib.patches.Patch` *p* to the list of axes patches; the clipbox will be set to the Axes clipping box. If the transform is not set, it will be set to :attr:`transData`. Returns the patch. c sjj|S(N(RR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRsN( RRRRTRNt_update_patch_limitsRRxR(R-tp((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt add_patch s  cC st|tjr0|j s,|j r0dS|jj}|jdkr|jj |}|j |j kr|j |j }|j |}n|j j |j \}}|j|d|d|ndS(s$update the data limits for patch *p*NiRR(RRlRt get_widtht get_heightRRRtget_patch_transformt transformtget_data_transformRRRR(R-RNRtxyst patch_to_dataRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs   c sCj|jj||jjfd|_|S(s Add a :class:`~matplotlib.tables.Table` instance to the list of axes tables Returns the table. c sjj|S(N(RR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRAs(RRRxRTRNR(R-ttab((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt add_table7s  c sY|j}|s/|jdtjnjj||jfd|S(s Add a :class:`~matplotlib.container.Container` instance to the axes. Returns the collection. s _container%dc sjj|S(N(RDR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyROs(RRRqRDRxtset_remove_method(R-RR((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt add_containerDs  cC s~|jjt|jjtjjjt|_x|j D]}|j |qBWx|j D]}|j |qcWdS(s Recompute the data limits based on current artists. At present, :class:`~matplotlib.collections.Collection` instances are not supported. N( RtignoreR t set_pointsRRRt get_pointsR&RRRR(R-RMR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRRs  cC smt|rt| rdStj|s>tj|}n|jj||jd|d|t |_dS(sR Update the data lim bbox with seq of xy tups or equiv. 2-D array NRR( titerableRqRt isMaskedArrayRYtasarrayRtupdate_from_data_xyR&R (R-RRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRfs  cC sCt|rt| rdS|jj|||jt|_dS(s> Update the data lim bbox with seq of xy tups N(RRqRtupdate_from_dataR&R (R-R^R_((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytupdate_datalim_numerixwscC s)|jjtjj|j|gdS(so Update the datalim to include the given :class:`~matplotlib.transforms.Bbox` *bounds* N(RRRRtunion(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytupdate_datalim_boundsscC s|jdks|jdkr"dS|dk rS|jjsS|jj|qSn|dk r|jjs|jj|qn|dk r|jd|jj}|jdkr|jd|}n||jjkr|jj||dk r|jj|qn|jd|jj}|jdkrL|jd|}n||jjkr|jj||dk r|jj|qqndS(sALook for unit *kwargs* and update the axis instances as necessaryNR8R9R:R;R<( R=RR>t have_unitsRVR?R@RARB(R-txdatatydataRER8R;((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt_process_unit_infos.     cC s|jj|dS(sd Return *True* if the given *mouseevent* (in display coords) is in the Axes i(RNtcontains(R-t mouseevent((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytin_axesscC s|jo|jS(sS Get whether autoscaling is applied for both axes on plot commands (R9R:(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_autoscale_onscC s|jS(sT Get whether autoscaling for the x-axis is applied on plot commands (R9(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_autoscalex_onscC s|jS(sT Get whether autoscaling for the y-axis is applied on plot commands (R:(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_autoscaley_onscC s||_||_dS(sl Set whether autoscaling is applied on plot commands accepts: [ *True* | *False* ] N(R9R:(R-Rc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs cC s ||_dS(s{ Set whether autoscaling for the x-axis is applied on plot commands accepts: [ *True* | *False* ] N(R9(R-Rc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytset_autoscalex_onscC s ||_dS(s{ Set whether autoscaling for the y-axis is applied on plot commands accepts: [ *True* | *False* ] N(R:(R-Rc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytset_autoscaley_onscC s4|dks|dkr'tdn||_dS(s Set padding of X data limits prior to autoscaling. *m* times the data interval will be added to each end of that interval before it is used in autoscaling. accepts: float in range 0 to 1 iismargin must be in range 0 to 1N(RR;(R-tm((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_xmargins cC s4|dks|dkr'tdn||_dS(s Set padding of Y data limits prior to autoscaling. *m* times the data interval will be added to each end of that interval before it is used in autoscaling. accepts: float in range 0 to 1 iismargin must be in range 0 to 1N(RR<(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_ymargins cO s| r| r|j|jfS|jdt}|jdd }|jdd }t|dkrw|d}}n-t|dkr|\}}n td|d k r|j|n|d k r|j|n|d k }|d k }|j d|d|d |d S( s* Set or retrieve autoscaling margins. signatures:: margins() returns xmargin, ymargin :: margins(margin) margins(xmargin, ymargin) margins(x=xmargin, y=ymargin) margins(..., tight=False) All three forms above set the xmargin and ymargin parameters. All keyword parameters are optional. A single argument specifies both xmargin and ymargin. The *tight* parameter is passed to :meth:`autoscale_view`, which is executed after a margin is changed; the default here is *True*, on the assumption that when margins are specified, no additional padding to match tick marks is usually desired. Setting *tight* to *None* will preserve the previous setting. Specifying any margin changes only the autoscaling; for example, if *xmargin* is not None, then *xmargin* times the X data interval will be added to each end of that interval before it is used in autoscaling. RR^R_iiis%more than two arguments were suppliedtscalextscaleyN( R;R<R?R RRqRRRR(R-RDRfRtmxtmyRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytmarginss"#     cC s ||_dS(s Set zorder value below which artists will be rasterized. Set to `None` to disable rasterizing of artists below a particular zorder. N(R(R-tz((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytset_rasterization_zorder;scC s|jS(sI Get zorder value below which artists will be rasterized (R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_rasterization_zorderCscC s|dkrt}t}nZt}t}|dkrNt||_|j}n|d krut||_|j}n|jd|d|d|dS( s Autoscale the axis view to the data (toggle). Convenience method for simple axis view autoscaling. It turns autoscaling on or off, and then, if autoscaling for either axis is on, it performs the autoscaling on the specified axis or axes. *enable*: [True | False | None] True (default) turns autoscaling on, False turns it off. None leaves the autoscaling state unchanged. *axis*: ['x' | 'y' | 'both'] which axis to operate on; default is 'both' *tight*: [True | False | None] If True, set view limits to data limits; if False, let the locator and margins expand the view limits; if None, use tight scaling if the only artist is an image, otherwise treat *tight* as False. The *tight* setting is retained for future autoscaling until it is explicitly changed. Returns None. R^RR_RRRN(R^sboth(R_sboth(RR R tboolR9R:R(R-tenableRRRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt autoscaleIs      cC s|dkrW|jpQt|jdkoQt|jdkoQt|jdk}nt|}|_|r|jr|jj |}g|D]}|j ^q}t j j |}|j\} } |jj} y| j| | \} } Wn5tk r*t j| | dtdd\} } nX|jdkrb| | |j} | | 8} | | 7} n|s| j| | \} } n|j| | n|r|jr|jj |} g| D]}|j ^q}t j j |}|j\}}|jj}y|j||\}}Wn5tk rVt j||dtdd\}}nX|jdkr|||j} || 8}|| 7}n|s|j||\}}n|j||ndS(s Autoscale the view limits using the data limits. You can selectively autoscale only a single axis, eg, the xaxis by setting *scaley* to *False*. The autoscaling preserves any axis direction reversal that has already been done. The data limits are not updated automatically when artist data are changed after the artist has been added to an Axes instance. In that case, use :meth:`matplotlib.axes.Axes.relim` prior to calling autoscale_view. it increasingtexpanderg?N(RR=RqRRRRR9Rt get_siblingsRRR Rt intervalxR=R/t nonsingularRR R;t view_limitsRR:Rt intervalyR>R<R(R-RRRR=txsharedtaxtdltbbRWRXtxlocatortdeltatysharedR]R^tylocator((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRrsR       cC s|dkr|j}n|dkr3tdn|jsCdS|jd|j}|r|||}|j|n |jg}|j|j|j|j |j|j |j|j |j|j |j rY| rY|jr|jjd|jjdn |jjd|jjd|j|j|jgn|s|j|j|j|j|j|jn|j|j|jdk r|j|jn|j r|jr|j|jjn|jjjr&g|D]}|j|f^q}n.g|D]!}|js-|j|f^q-}t |j!dksu|j"r|jg|j!D]}|j|f^qt#} nt$} |j%dt&d|j'} | dk r`t |dkr`|dd| kr`|j(g|D]} | d| kr| ^q} g|D]} | d| kr;| ^q;}ng} |j r|jr|j)j*|n| r#g|j!D]!}|jr|j|f^q} | j%dd |j+}g| D]-\}}|j,|dd|j-f^q}|j.j/\} }}}|t0|dt0| d}|t0|dt0|d}t1j2|||}t#|_3|j.j4\} }}}|j5}|j6|j.|j7t8j9|j)j:|j)j;|j<|t0| t0|||j=n| rZx!| D]\}}|j*|q0W|j>nx!|D]\}}|j*|qaW|j?d||_dS( s*Draw everything (plot lines, axes, labels)sNo renderer definedNR*g?g@iRNicS s|dS(Ni((R^((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs(@RRt RuntimeErrort get_visiblet open_groupRRtextendRRRRRARSRR=t set_zorderR>RxRJRKRLRRCRRt itervaluesRtcanvast is_savingtzordert get_animatedRqRtoption_image_nocompositeR R tsortRRtstart_rasterizingRNtdrawtget_image_magnificationt make_imaget get_alphaRtextentstroundtmimaget from_imagest is_grayscaleRtnew_gctset_clip_rectangleRTRtTransformedPathRRt draw_imagetrestoretstop_rasterizingt close_group(R-trenderertinframeRR RARtdsuRt _do_compositetrasterization_zorderRtdsu_rasterizedt zorder_imagestmagRtimsRctrttRRRRtgcR9((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR>s        % !!,   & ),! :""      "   cC s)|jdk st|j|jdS(s This method can only be used after an initial draw which caches the renderer. It is used to efficiently update Axes data (axis ticks, labels, etc are not updated) N(RRRHR>(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt draw_artist+scC s/|jdk st|j|jdtdS(s This method can only be used after an initial draw which caches the renderer. It is used to efficiently update Axes data (axis ticks, labels, etc are not updated) RON(RRRHR>R (R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytredraw_in_frame4scC s|jS(N(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_renderer_cache=scC s|jS(s? Get whether the axes rectangle patch is drawn (R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_frame_onBscC s ||_dS(sf Set whether the axes rectangle patch is drawn ACCEPTS: [ *True* | *False* ] N(R(R-Rc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_frame_onHscC s|jS(s7 Get whether axis below is true or not (R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_axisbelowPscC s ||_dS(s Set whether the axis ticks and gridlines are above or below most artists ACCEPTS: [ *True* | *False* ] N(R(R-Rc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_axisbelowVsR)cK st|rt}nt|}|dks9|dkrU|jj|d||n|dksm|dkr|jj|d||ndS(s Turn the axes grids on or off. Call signature:: grid(self, b=None, which='major', axis='both', **kwargs) Set the axes grids on or off; *b* is a boolean. (For MATLAB compatibility, *b* may also be a string, 'on' or 'off'.) If *b* is *None* and ``len(kwargs)==0``, toggle the grid state. If *kwargs* are supplied, it is assumed that you want a grid and *b* is thus set to *True*. *which* can be 'major' (default), 'minor', or 'both' to control whether major tick grids, minor tick grids, or both are affected. *axis* can be 'both' (default), 'x', or 'y' to control which set of gridlines are drawn. *kwargs* are used to set the grid line properties, eg:: ax.grid(color='r', linestyle='-', linewidth=2) Valid :class:`~matplotlib.lines.Line2D` kwargs are %(Line2D)s R^RRR_N(RqR RR=RR>(R-RcRRRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR_s   c K s|jddj}|jdd}|jdd}|jdd}|jddj}|dk ry|\}}||dWqttfk rtd qXn|d d krt} n]|dkr t} |d krt} q-t} tdn!|dkr!d} n tdy| dk r|dksT|dkrm|jj j j | n|dks|dkr|j j j j | qn|dk r|dks|dkr|jj j j |n|dks|dkr|j j j j |qn|dk r|dks6|dkrO|jj j j|n|dksg|dkr|j j j j|qn|dk r|dks|dkr|jj j j|n|dks|dkr|j j j j|qnWntk rtdnXdS(s Change the `~matplotlib.ticker.ScalarFormatter` used by default for linear axes. Optional keyword arguments: ============ ========================================= Keyword Description ============ ========================================= *style* [ 'sci' (or 'scientific') | 'plain' ] plain turns off scientific notation *scilimits* (m, n), pair of integers; if *style* is 'sci', scientific notation will be used for numbers outside the range 10`m`:sup: to 10`n`:sup:. Use (0,0) to include all numbers. *useOffset* [True | False | offset]; if True, the offset will be calculated as needed; if False, no offset will be used; if a numeric offset is specified, it will be used. *axis* [ 'x' | 'y' | 'both' ] *useLocale* If True, format the number according to the current locale. This affects things such as the character used for the decimal separator. If False, use C-style (English) formatting. The default setting is controlled by the axes.formatter.use_locale rcparam. ============ ========================================= Only the major ticks are affected. If the method is called when the :class:`~matplotlib.ticker.ScalarFormatter` is not the :class:`~matplotlib.ticker.Formatter` being used, an :exc:`AttributeError` will be raised. tstyleRt scilimitst useOffsett useLocaleRRis*scilimits must be a sequence of 2 integersitscitplaintcommascomma style remains to be addeds%s is not a valid style valueR^R_s0This method only works with the ScalarFormatter.N(Rfscomma(R?RRRRKR R tNotImplementedErrorR=R)t formattertset_scientificR>tset_powerlimitst set_useOffsett set_useLocaleR( R-RERaRbRcRdRRtntsbtcb((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytticklabel_formats\'               cK sv|dk}|d k}|r7|jjj|n|rV|jjj|n|jd|d|d|dS( s Control behavior of tick locators. Keyword arguments: *axis* ['x' | 'y' | 'both'] Axis on which to operate; default is 'both'. *tight* [True | False | None] Parameter passed to :meth:`autoscale_view`. Default is None, for no change. Remaining keyword arguments are passed to directly to the :meth:`~matplotlib.ticker.MaxNLocator.set_params` method. Typically one might want to reduce the maximum number of ticks and use tight bounds when plotting small subplots, for example:: ax.locator_params(tight=True, nbins=4) Because the locator is involved in autoscaling, :meth:`autoscale_view` is called automatically after the parameters are changed. This presently works only for the :class:`~matplotlib.ticker.MaxNLocator` used by default on linear axes, but it may be generalized. R^RR_RRRN(R^sboth(R_sboth(R=R/t set_paramsR>R(R-RRREt_xt_y((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytlocator_paramss  cK s|d krkt|}|jdd |jdd |jdd |jdd |jj|n|dkrt|}|jdd |jd d |jd d |jd d |jj|nd S(s Change the appearance of ticks and tick labels. Keyword arguments: *axis* : ['x' | 'y' | 'both'] Axis on which to operate; default is 'both'. *reset* : [True | False] If *True*, set all parameters to defaults before processing other keyword arguments. Default is *False*. *which* : ['major' | 'minor' | 'both'] Default is 'major'; apply arguments to *which* ticks. *direction* : ['in' | 'out' | 'inout'] Puts ticks inside the axes, outside the axes, or both. *length* Tick length in points. *width* Tick width in points. *color* Tick color; accepts any mpl color spec. *pad* Distance in points between tick and label. *labelsize* Tick label font size in points or as a string (e.g., 'large'). *labelcolor* Tick label color; mpl color spec. *colors* Changes the tick color and the label color to the same value: mpl color spec. *zorder* Tick and label zorder. *bottom*, *top*, *left*, *right* : [bool | 'on' | 'off'] controls whether to draw the respective ticks. *labelbottom*, *labeltop*, *labelleft*, *labelright* Boolean or ['on' | 'off'], controls whether to draw the respective tick labels. Example:: ax.tick_params(direction='out', length=6, width=2, colors='r') This will make all major ticks be red, pointing out of the box, and with dimensions 6 points by 2 points. Tick labels will also be red. R^RRRt labelleftt labelrightR_RRtlabeltopt labelbottomN(R^sboth(R_sboth(tdictR?RR=tset_tick_paramsR>(R-RREtxkwtykw((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt tick_params s=    cC s t|_dS(sturn off the axisN(R RS(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRR scC s t|_dS(sturn on the axisN(R RS(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRV scC s|jS(s Return the axis background color(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_axis_bgcolorZ scC s||_|jj|dS(s set the axes background color ACCEPTS: any matplotlib color - see :func:`~matplotlib.pyplot.colors` N(RRNRP(R-R#((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytset_axis_bgcolor^ s cC s,|j\}}|j||dddS(sInvert the x-axis.RN(R+R,R(R-RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt invert_xaxisk scC s|j\}}||kS(s)Returns *True* if the x-axis is inverted.(R+(R-RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytxaxis_invertedp scC s6|j\}}||kr(||fS||fSdS(sa Returns the x-axis numerical bounds where:: lowerBound < upperBound N(R+(R-RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRtu s  cC s|dkr't|r'|\}}n|j\}}|dkrN|}n|dkrc|}n|jr||kr|j||ddq|j||ddn;||kr|j||ddn|j||dddS(s Set the lower and upper numerical bounds of the x-axis. This method will honor axes inversion regardless of parameter order. It will not change the _autoscaleXon attribute. RN(RRRtRR,(R-Rtuppert old_lowert old_upper((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR s       cC st|jjS(s8 Get the x-axis range [*left*, *right*] (RRR%(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR+ sc K sOd|kr|jd}nd|kr<|jd}n|r[td|jn|d krt|r|\}}n|jd||f|d k r|j|}n|d k r|j|}n|j\}}|d kr|}n|d kr|}n||kr>tj ddd||fnt j ||dt \}}|j j||\}}||f|j_|d k rt||_n|rE|jjd |x|jj|D]k}||k r|j|jjd t d ||j|jkr>|jjd k r>|jjjq>qqWn||fS( s Call signature:: set_xlim(self, *args, **kwargs): Set the data limits for the xaxis Examples:: set_xlim((left, right)) set_xlim(left, right) set_xlim(left=1) # right unchanged set_xlim(right=1) # left unchanged Keyword arguments: *left*: scalar The left xlim; *xmin*, the previous name, may still be used *right*: scalar The right xlim; *xmax*, the previous name, may still be used *emit*: [ *True* | *False* ] Notify observers of limit change *auto*: [ *True* | *False* | *None* ] Turn *x* autoscaling on (*True*), off (*False*; default), or leave unchanged (*None*) Note, the *left* (formerly *xmin*) value may be greater than the *right* (formerly *xmax*). For example, suppose *x* is years before present. Then one might use:: set_ylim(5000, 0) so 5000 years ago is on the left of the plot and the present is on the right. Returns the current xlimits as a length 2 tuple ACCEPTS: length 2 sequence of floats RxRysunrecognized kwargs: %sR s0Attempting to set identical left==right results s6in singular transformations; automatically expanding. sleft=%s, right=%sR"t xlim_changedRRN(R?RRcRRR RWR+RRRR&R R=tlimit_range_for_scaleRR%RR9RtprocessRR$R,RR7t draw_idle( R-RRRRRftold_leftt old_righttother((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR, sH,            cC s |jjS(N(R=R2(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR ss!Return the xaxis scale string: %ss, cK s1|jj|||jdt|jdS(s Call signature:: set_xscale(value) Set the scaling of the x-axis: %(scale)s ACCEPTS: [%(scale)s] Different kwargs are accepted, depending on the scale: %(scale_docs)s RN(R=R1RR R(R-tvalueRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR scC s|jjd|S(s)Return the x ticks as a list of locationsR*(R=t get_ticklocs(R-R*((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_xticks scC s|jj|d|S(s[ Set the x ticks with list of *ticks* ACCEPTS: sequence of floats R*(R=t set_ticks(R-tticksR*((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_xticks scC stjd|jjS(se Get the xtick labels as a list of :class:`~matplotlib.text.Text` instances. sText xticklabel(R'RR=tget_majorticklabels(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_xmajorticklabels s cC stjd|jjS(sk Get the x minor tick labels as a list of :class:`matplotlib.text.Text` instances. sText xticklabel(R'RR=tget_minorticklabels(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_xminorticklabels( s cC stjd|jjd|S(sf Get the x tick labels as a list of :class:`~matplotlib.text.Text` instances. sText xticklabelR*(R'RR=tget_ticklabels(R-R*((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_xticklabels0 s cK s|jj||d||S(so Call signature:: set_xticklabels(labels, fontdict=None, minor=False, **kwargs) Set the xtick labels with list of strings *labels*. Return a list of axis text instances. *kwargs* set the :class:`~matplotlib.text.Text` properties. Valid properties are %(Text)s ACCEPTS: sequence of strings R*(R=tset_ticklabels(R-tlabelstfontdictR*RE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytset_xticklabels8 scC s,|j\}}|j||dddS(s$ Invert the y-axis. RN(R7R8R(R-RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt invert_yaxisK scC s|j\}}||kS(s)Returns *True* if the y-axis is inverted.(R7(R-RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytyaxis_invertedR scC s6|j\}}||kr(||fS||fSdS(sc Return y-axis numerical bounds in the form of ``lowerBound < upperBound`` N(R7(R-RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRuW s  cC s|dkr't|r'|\}}n|j\}}|dkrN|}n|dkrc|}n|jr||kr|j||ddq|j||ddn;||kr|j||ddn|j||dddS(s Set the lower and upper numerical bounds of the y-axis. This method will honor axes inversion regardless of parameter order. It will not change the _autoscaleYon attribute. RN(RRRuRR8(R-RRRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRb s       cC st|jjS(s8 Get the y-axis range [*bottom*, *top*] (RRR((R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR7} sc K s9d|kr|jd}nd|kr<|jd}n|r[td|jn|d krt|r|\}}n|d k r|j|}n|d k r|j|}n|j\}}|d kr|}n|d kr|}n||kr(tjddd||fnt j ||dt \}}|j j ||\}}||f|j_|d k rt||_n|r/|jjd|x|jj|D]k}||k r|j|jjd t d ||j|jkr(|jjd k r(|jjjq(qqWn||fS( s Call signature:: set_ylim(self, *args, **kwargs): Set the data limits for the yaxis Examples:: set_ylim((bottom, top)) set_ylim(bottom, top) set_ylim(bottom=1) # top unchanged set_ylim(top=1) # bottom unchanged Keyword arguments: *bottom*: scalar The bottom ylim; the previous name, *ymin*, may still be used *top*: scalar The top ylim; the previous name, *ymax*, may still be used *emit*: [ *True* | *False* ] Notify observers of limit change *auto*: [ *True* | *False* | *None* ] Turn *y* autoscaling on (*True*), off (*False*; default), or leave unchanged (*None*) Note, the *bottom* (formerly *ymin*) value may be greater than the *top* (formerly *ymax*). For example, suppose *y* is depth in the ocean. Then one might use:: set_ylim(5000, 0) so 5000 m depth is at the bottom of the plot and the surface, 0 m, is at the top. Returns the current ylimits as a length 2 tuple ACCEPTS: length 2 sequence of floats RzR{sunrecognized kwargs: %ss0Attempting to set identical bottom==top results s6in singular transformations; automatically expanding. sbottom=%s, top=%sR"t ylim_changedRRN(R?RRcRRRXR7RRRR&R R>RRR(RR:RRRR$R8RR7R( R-RRRRRft old_bottomtold_topR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR8 sF,            cC s |jjS(N(R>R2(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR ss!Return the yaxis scale string: %scK s1|jj|||jdt|jdS(s Call signature:: set_yscale(value) Set the scaling of the y-axis: %(scale)s ACCEPTS: [%(scale)s] Different kwargs are accepted, depending on the scale: %(scale_docs)s RN(R>R1RR R(R-RRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR scC s|jjd|S(s)Return the y ticks as a list of locationsR*(R>R(R-R*((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_yticks scC s|jj|d|S(s Set the y ticks with list of *ticks* ACCEPTS: sequence of floats Keyword arguments: *minor*: [ *False* | *True* ] Sets the minor ticks if *True* R*(R>R(R-RR*((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_yticks s cC stjd|jjS(sl Get the major y tick labels as a list of :class:`~matplotlib.text.Text` instances. sText yticklabel(R'RR>R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_ymajorticklabels s cC stjd|jjS(sl Get the minor y tick labels as a list of :class:`~matplotlib.text.Text` instances. sText yticklabel(R'RR>R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_yminorticklabels s cC stjd|jjd|S(se Get the y tick labels as a list of :class:`~matplotlib.text.Text` instances sText yticklabelR*(R'RR>R(R-R*((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_yticklabels s cK s|jj||d||S(s Call signature:: set_yticklabels(labels, fontdict=None, minor=False, **kwargs) Set the y tick labels with list of strings *labels*. Return a list of :class:`~matplotlib.text.Text` instances. *kwargs* set :class:`~matplotlib.text.Text` properties for the labels. Valid properties are %(Text)s ACCEPTS: sequence of strings R*(R>R(R-RRR*RE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytset_yticklabels scC s|jj|dS(s Sets up x-axis ticks and labels that treat the x data as dates. *tz* is a timezone string or :class:`tzinfo` instance. Defaults to rc value. N(R=t axis_date(R-ttz((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt xaxis_date1 s cC s|jj|dS(s Sets up y-axis ticks and labels that treat the y data as dates. *tz* is a timezone string or :class:`tzinfo` instance. Defaults to rc value. N(R>R(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt yaxis_date< scC sHy|j|SWn0tk rC|jjj}||}|SXdS(s Return *x* string formatted. This function will use the attribute self.fmt_xdata if it is callable, else will fall back on the xaxis major formatter N(RRKR=R-tformat_data_short(R-R^RQRO((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt format_xdataE s   cC sHy|j|SWn0tk rC|jjj}||}|SXdS(s Return y string formatted. This function will use the :attr:`fmt_ydata` attribute if it is callable, else will fall back on the yaxis major formatter N(RRKR>R-R(R-R_RQRO((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt format_ydataR s   cC sV|dkrd}n|j|}|dkr9d}n|j|}d||fS(s4Return a format string formatting the *x*, *y* coords???s x=%s y=%sN(RRR(R-R^R_txstys((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt format_coord_ s    cC stS(sX Return *True* if this axes supports the zoom box button functionality. (R (R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytcan_zoomm scC stS(sX Return *True* if this axes supports any pan/zoom button functionality. (R (R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytcan_pans scC s|jS(sF Get whether the axes responds to navigation commands (t _navigate(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_navigatey scC s ||_dS(su Set whether the axes responds to navigation toolbar commands ACCEPTS: [ *True* | *False* ] N(R(R-Rc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR scC s|jS(sR Get the navigation toolbar button status: 'PAN', 'ZOOM', or None (t_navigate_mode(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_navigate_mode scC s ||_dS(s Set the navigation toolbar button status; .. warning:: this is not a user-API function. N(R(R-Rc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR sc C satjd|jjd|jjd|jjjd|jjd|d||_dS(s2 Called when a pan operation has started. *x*, *y* are the mouse coordinates in display coords. button is the mouse button number: * 1: LEFT * 2: MIDDLE * 3: RIGHT .. note:: Intended to be overridden by new projection types. tlimttranst trans_inverseRR^R_N(R'tBunchRRRtinvertedRt _pan_start(R-R^R_tbutton((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt start_pan s cC s |`dS(s Called when a pan operation completes (when the mouse button is up.) .. note:: Intended to be overridden by new projection types. N(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytend_pan s cC sd}|j}||j}||j}|dkrH|dkrHdS|dkr||||\}}|jj| | j|j} n|dkry| t|jj}| t|jj }||||\}}|j dkrd||}|}nt j d||f} t j |j|jg} |jj|j} | | | | } tj| j|j} Wqtk rtjd dSXn|j| j|j| jdS( s` Called when the mouse moves during a pan operation. *button* is the mouse button number: * 1: LEFT * 2: MIDDLE * 3: RIGHT *key* is a "shift" key *x*, *y* are the mouse coordinates in display coords. .. note:: Intended to be overridden by new projection types. cS s|dkr6t|t|kr-|}q|}n|dkrKd}n|dkr`d}n|dkrdt|t|krd}qdt|t|krd}qt|t|kr|t|t|}q|t|t|}n||fS(NtcontrolR^iR_tshifti(R(RNtdxtdy((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt format_deltas s"          iNiiRg?g$@sOverflow while panning(RR^R_Rt translatedt transformedRRtRRRfRYtpowertarrayRRRRt OverflowErrorRRR,R%R8R((R-RRNR^R_RRRRtresulttalphatstartt oldpointst newpoints((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytdrag_pan s:         cC s|jS(s Return the cursor propertiess as a (*linewidth*, *color*) tuple, where *linewidth* is a float and *color* is an RGBA tuple (t _cursorProps(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_cursor_props scG swt|dkr%|d\}}n-t|dkrF|\}}n tdtjj|}||f|_dS(s Set the cursor property as:: ax.set_cursor_props(linewidth, color) or:: ax.set_cursor_props((linewidth, color)) ACCEPTS: a (*float*, *color*) tuple iiis'args must be a (linewidth, color) tupleN(RqRRRtto_rgbaR(R-RDtlwR%((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR s  cC sg}|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j |j dk r|j|j n|j|j |j|j |j|j|j|j|j|j|j|jj|S(sreturn a list of child artistsN(RxR=R>R4RRRRRARRCRRRJRKRLRNRR6(R-tchildren((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_children s$cC s/t|jr|j||S|jj|S(si Test whether the mouse event occured in the axes. Returns *True* / *False*, {} (tcallablet _containsRNR (R-R ((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR 5 scC s|jj|ddS(s Returns *True* if the point (tuple of x,y) is inside the axes (the area defined by the its patch). A pixel coordinate is required. tradiusg?(RNtcontains_point(R-tpoint((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR@ scG stjj||ddS(s Call signature:: pick(mouseevent) each child artist will fire a pick event if mouseevent is over the artist and the artist has picker set iN(RRtpick(R-RD((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRI s RcC s`y2i|jd6|jd6|jd6|j}Wn!tk rUtd|nX|jS(sGet an axes title. Get one of the three available axes titles. The available titles are positioned above the axes in the center, flush with the left edge, and flush with the right edge. Parameters ---------- loc : {'center', 'left', 'right'}, str, optional Which title to get, defaults to 'center' Returns ------- title: str The title text string. RRRs'%s' is not a valid location(RKRJRLRRkRtget_text(R-tlocRJ((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_titleV s   cK sy2i|jd6|jd6|jd6|j}Wn!tk rUtd|nXitdd6dd6|jd 6}|j||j||d k r|j|n|j||S( s( Set a title for the axes. Set one of the three available axes titles. The available titles are positioned above the axes in the center, flush with the left edge, and flush with the right edge. Parameters ---------- label : str Text to use for the title fontdict : dict A dictionary controlling the appearance of the title text, the default `fontdict` is:: {'fontsize': rcParams['axes.titlesize'], 'verticalalignment': 'baseline', 'horizontalalignment': loc} loc : {'center', 'left', 'right'}, str, optional Which title to set, defaults to 'center' Returns ------- text : :class:`~matplotlib.text.Text` The matplotlib text instance representing the title Other parameters ---------------- Other keyword arguments are text properties, see :class:`~matplotlib.text.Text` for a list of valid text properties. RRRs'%s' is not a valid locationsaxes.titlesizetfontsizeR#R"R$N( RKRJRLRRkRRtset_texttupdateR(R-RRRRERJtdefault((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_titlep s $        cC s|jj}|jS(s- Get the xlabel text string. (R=RR(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_xlabel scK s1|dk r||j_n|jj|||S(s Set the label for the xaxis. Parameters ---------- xlabel : string x label labelpad : scalar, optional, default: None spacing in points between the label and the x-axis Other parameters ---------------- kwargs : `~matplotlib.text.Text` properties See also -------- text : for information on how override and the optional args work N(RR=tlabelpadtset_label_text(R-txlabelRRRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_xlabel s cC s|jj}|jS(s- Get the ylabel text string. (R>RR(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt get_ylabel scK s1|dk r||j_n|jj|||S(s Set the label for the yaxis Parameters ---------- ylabel : string y label labelpad : scalar, optional, default: None spacing in points between the label and the x-axis Other parameters ---------------- kwargs : `~matplotlib.text.Text` properties See also -------- text : for information on how override and the optional args work N(RR>RR(R-tylabelRRRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt set_ylabel s c  sidd6dd6jd6td6}|rLtjd|d|d |}ntjd|d|d |}j||j||d k r|j|n|j|jj |fd |_ |j j |S( s Add text to the axes. Add text in string *s* to axis at location *x*, *y*, data coordinates. Parameters ---------- s : string text x, y : scalars data coordinates fontdict : dictionary, optional, default: None A dictionary to override the default text properties. If fontdict is None, the defaults are determined by your rc parameters. withdash : boolean, optional, default: False Creates a `~matplotlib.text.TextWithDash` instance instead of a `~matplotlib.text.Text` instance. Other parameters ---------------- kwargs : `~matplotlib.text.Text` properties. Other miscellaneous text parameters. Examples -------- Individual keyword arguments can be used to override any given parameter:: >>> text(x, y, s, fontsize=12) The default transform specifies that text is in data coords, alternatively, you can specify text in axis coords (0,0 is lower-left and 1,1 is upper-right). The example below places text in the center of the axes:: >>> text(0.5, 0.5,'matplotlib', horizontalalignment='center', ... verticalalignment='center', ... transform=ax.transAxes) You can put a rectangular box around the text instance (e.g., to set a background color) by using the keyword *bbox*. *bbox* is a dictionary of `~matplotlib.patches.Rectangle` properties. For example:: >>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5)) R#R"RR$Rtclip_onR^R_R c sjj|S(N(RR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR6 sN( RR RHt TextWithDashRIRRRRRxRRTRN( R-R^R_RRtwithdashRERRX((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR  s&5        c sztj||}|jtjj||jdrT|jjnj j |fd|_ |S(se Create an annotation: a piece of text referring to a data point. Call signature:: annotate(s, xy, xytext=None, xycoords='data', textcoords='data', arrowprops=None, **kwargs) Keyword arguments: %(Annotation)s .. plot:: mpl_examples/pylab_examples/annotation_demo2.py Rc sjj|S(N(RR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRR s( RHt AnnotationRRRRthas_keyRTRNRRxR(R-RDRER((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytannotate; s iic K sd|krtddn|j\}}|jd|d||j|}||kpk||k}tj|j|j} tj ||g||gd| |} |j | |j dt d|| S(s\ Add a horizontal line across the axis. Call signature:: axhline(y=0, xmin=0, xmax=1, **kwargs) Draw a horizontal line at *y* from *xmin* to *xmax*. With the default values of *xmin* = 0 and *xmax* = 1, this line will always span the horizontal extent of the axes, regardless of the xlim settings, even if you change them, e.g., with the :meth:`set_xlim` command. That is, the horizontal extent is in axes coords: 0=left, 0.5=middle, 1.0=right but the *y* location is in data coordinates. Return value is the :class:`~matplotlib.lines.Line2D` instance. kwargs are the same as kwargs to plot, and can be used to control the line properties. e.g., * draw a thick red hline at *y* = 0 that spans the xrange:: >>> axhline(linewidth=4, color='r') * draw a default hline at *y* = 1 that spans the xrange:: >>> axhline(y=1) * draw a default hline at *y* = .5 that spans the the middle half of the xrange:: >>> axhline(y=.5, xmin=0.25, xmax=0.75) Valid kwargs are :class:`~matplotlib.lines.Line2D` properties, with the exception of 'transform': %(Line2D)s .. seealso:: :meth:`axhspan` for example plot and source code Rs&'transform' is not allowed as a kwarg;s$axhline generates its own transform.R RERR( RRuR RXRRRRRReRRR ( R-R_RxRyRERzR{tyyRRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytaxhlineW s-  ' c K sd|krtddn|j\}}|jd|d||j|}||kpk||k}tj|j|j} tj ||g||gd| |} |j | |j d|dt | S(sT Add a vertical line across the axes. Call signature:: axvline(x=0, ymin=0, ymax=1, **kwargs) Draw a vertical line at *x* from *ymin* to *ymax*. With the default values of *ymin* = 0 and *ymax* = 1, this line will always span the vertical extent of the axes, regardless of the ylim settings, even if you change them, e.g., with the :meth:`set_ylim` command. That is, the vertical extent is in axes coords: 0=bottom, 0.5=middle, 1.0=top but the *x* location is in data coordinates. Return value is the :class:`~matplotlib.lines.Line2D` instance. kwargs are the same as kwargs to plot, and can be used to control the line properties. e.g., * draw a thick red vline at *x* = 0 that spans the yrange:: >>> axvline(linewidth=4, color='r') * draw a default vline at *x* = 1 that spans the yrange:: >>> axvline(x=1) * draw a default vline at *x* = .5 that spans the the middle half of the yrange:: >>> axvline(x=.5, ymin=0.25, ymax=0.75) Valid kwargs are :class:`~matplotlib.lines.Line2D` properties, with the exception of 'transform': %(Line2D)s .. seealso:: :meth:`axhspan` for example plot and source code Rs&'transform' is not allowed as a kwarg;s$axvline generates its own transform.R RERR( RRtR RWRRRRRReRRR ( R-R^RzR{RERxRytxxRRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytaxvline s-  ' c K stj|j|j}|j||g||gd||j||g\}}|j||g\}}||f||f||f||ff}tj||}|j ||j ||j dt |S(sg Add a horizontal span (rectangle) across the axis. Call signature:: axhspan(ymin, ymax, xmin=0, xmax=1, **kwargs) *y* coords are in data units and *x* coords are in axes (relative 0-1) units. Draw a horizontal span (rectangle) from *ymin* to *ymax*. With the default values of *xmin* = 0 and *xmax* = 1, this always spans the xrange, regardless of the xlim settings, even if you change them, e.g., with the :meth:`set_xlim` command. That is, the horizontal extent is in axes coords: 0=left, 0.5=middle, 1.0=right but the *y* location is in data coordinates. Return value is a :class:`matplotlib.patches.Polygon` instance. Examples: * draw a gray rectangle from *y* = 0.25-0.75 that spans the horizontal extent of the axes:: >>> axhspan(0.25, 0.75, facecolor='0.5', alpha=0.5) Valid kwargs are :class:`~matplotlib.patches.Polygon` properties: %(Polygon)s **Example:** .. plot:: mpl_examples/pylab_examples/axhspan_demo.py RER( RRRRR RWRXRlRmRRRR ( R-RzR{RxRyRERtvertsR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytaxhspan s'"*  c K stj|j|j}|j||g||gd||j||g\}}|j||g\}}||f||f||f||fg}tj||}|j ||j ||j dt |S(s{ Add a vertical span (rectangle) across the axes. Call signature:: axvspan(xmin, xmax, ymin=0, ymax=1, **kwargs) *x* coords are in data units and *y* coords are in axes (relative 0-1) units. Draw a vertical span (rectangle) from *xmin* to *xmax*. With the default values of *ymin* = 0 and *ymax* = 1, this always spans the yrange, regardless of the ylim settings, even if you change them, e.g., with the :meth:`set_ylim` command. That is, the vertical extent is in axes coords: 0=bottom, 0.5=middle, 1.0=top but the *y* location is in data coordinates. Return value is the :class:`matplotlib.patches.Polygon` instance. Examples: * draw a vertical green translucent rectangle from x=1.25 to 1.55 that spans the yrange of the axes:: >>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5) Valid kwargs are :class:`~matplotlib.patches.Polygon` properties: %(Polygon)s .. seealso:: :meth:`axhspan` for example plot and source code RER( RRRRR RWRXRlRmRRRR ( R-RxRyRzR{RERRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytaxvspans'"*  RztsolidcK sq|j||g|d||j|}|j|}|j|}t|sa|g}nt|sy|g}nt|s|g}ntj|}tj|}tj|}t|dkrtj||j}nt|dkrtj||j}nt|t|kr9t dnt|t|kr`t dngt |||D]'\}} } || f| | ff^qs} t j | d|d|d|} |j | | j|t|dkrmt|j|j} t|j|j}|j}|j}| |f||ff}|j||jn| S( s Plot horizontal lines. Plot horizontal lines at each `y` from `xmin` to `xmax`. Parameters ---------- y : scalar or 1D array_like y-indexes where to plot the lines. xmin, xmax : scalar or 1D array_like Respective beginning and end of each line. If scalars are provided, all lines will have same length. colors : array_like of colors, optional, default: 'k' linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional label : string, optional, default: '' Returns ------- lines : `~matplotlib.collections.LineCollection` Other parameters ---------------- kwargs : `~matplotlib.collections.LineCollection` properties. See also -------- vlines : vertical lines Examples -------- .. plot:: mpl_examples/pylab_examples/vline_hline_demo.py REis&xmin and y are unequal sized sequencess&xmax and y are unequal sized sequencesRt linestylesRi(R RXRWRRYRRqtresizeR[RRrtmcolltLineCollectionRRtminRwRR(R-R_RxRyRRRREtthisxmintthisxmaxtthisyRtcolltminxtmaxxtminytmaxytcorners((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pythlinesGsH+      =      cK s|jd|d||gd||j|}|j|}|j|}t|sg|g}nt|s|g}nt|s|g}ntj|}tj|}tj|}t|dkrtj||j}nt|dkrtj||j}nt|t|kr?t dnt|t|krft dntj ||gj }gt ||D]*\} \} } | | f| | ff^q} t j| d|d|d |} |j| | j|t|d krt|}t|}tt|t|}tt|t|}||f||ff}|j||jn| S( s Plot vertical lines. Plot vertical lines at each `x` from `ymin` to `ymax`. Parameters ---------- x : scalar or 1D array_like x-indexes where to plot the lines. xmin, xmax : scalar or 1D array_like Respective beginning and end of each line. If scalars are provided, all lines will have same length. colors : array_like of colors, optional, default: 'k' linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional label : string, optional, default: '' Returns ------- lines : `~matplotlib.collections.LineCollection` Other parameters ---------------- kwargs : `~matplotlib.collections.LineCollection` properties. See also -------- hlines : horizontal lines Examples --------- .. plot:: mpl_examples/pylab_examples/vline_hline_demo.py R R REis&ymin and x are unequal sized sequencess&ymax and x are unequal sized sequencesRRRi(R RWRXRRYRRqRR[RRtTRrRRRRRRwRR(R-R^RzR{RRRREtYtthisxtthisymintthisymaxRRRRRRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytvlinessJ)"      =      t horizontalcK sN|jd|d||gd||j|}|j|}|j|}t|sg|g}nMtd|Drg|D]} tj| ^q}ntj|g}t|dkrgSt|s|g}nt|s|g}nt|s|g}nt|s*|g}nt|dsFt| rR|g}ntj |}tj |}tj |}t|dkrdg}nt|dkrdg}nt|dkrdg}nt|dkrdg}nt|dkrdg}nt|dkrmt|dkrmtj |t|}d|dEsiRis5lineoffsets and positions are unequal sized sequencess5linelengths and positions are unequal sized sequencess4linewidths and positions are unequal sized sequencess0colors and positions are unequal sized sequencess4linestyles and positions are unequal sized sequencest orientationt lineoffsett linelengtht linewidthR#R!cs s|]}|jVqdS(N(R(RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pys scs s|]}|jVqdS(N(Rw(RR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pys sN(R RWRXRRRYt asanyarrayRqRJRRttiletcumsumRR4tizipRtEventCollectionRRRxRRwt is_horizontalRR(R-t positionsRt lineoffsetst linelengthst linewidthsRRRERtcollsRRRR#R!RtminpostmaxpostminlinetmaxlineR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt eventplots?   %              $ !"      cO s|jdt}|jdt}|js:|jng}x4|j||D] }|j||j|qSW|jd|d||S(s Plot lines and/or markers to the :class:`~matplotlib.axes.Axes`. *args* is a variable length argument, allowing for multiple *x*, *y* pairs with an optional format string. For example, each of the following is legal:: plot(x, y) # plot x and y using default line style and color plot(x, y, 'bo') # plot x and y using blue circle markers plot(y) # plot y using x as index array 0..N-1 plot(y, 'r+') # ditto, but with red plusses If *x* and/or *y* is 2-dimensional, then the corresponding columns will be plotted. An arbitrary number of *x*, *y*, *fmt* groups can be specified, as in:: a.plot(x1, y1, 'g^', x2, y2, 'g-') Return value is a list of lines that were added. By default, each line is assigned a different color specified by a 'color cycle'. To change this behavior, you can edit the axes.color_cycle rcParam. Alternatively, you can use :meth:`~matplotlib.axes.Axes.set_default_color_cycle`. The following format string characters are accepted to control the line style or marker: ================ =============================== character description ================ =============================== ``'-'`` solid line style ``'--'`` dashed line style ``'-.'`` dash-dot line style ``':'`` dotted line style ``'.'`` point marker ``','`` pixel marker ``'o'`` circle marker ``'v'`` triangle_down marker ``'^'`` triangle_up marker ``'<'`` triangle_left marker ``'>'`` triangle_right marker ``'1'`` tri_down marker ``'2'`` tri_up marker ``'3'`` tri_left marker ``'4'`` tri_right marker ``'s'`` square marker ``'p'`` pentagon marker ``'*'`` star marker ``'h'`` hexagon1 marker ``'H'`` hexagon2 marker ``'+'`` plus marker ``'x'`` x marker ``'D'`` diamond marker ``'d'`` thin_diamond marker ``'|'`` vline marker ``'_'`` hline marker ================ =============================== The following color abbreviations are supported: ========== ======== character color ========== ======== 'b' blue 'g' green 'r' red 'c' cyan 'm' magenta 'y' yellow 'k' black 'w' white ========== ======== In addition, you can specify colors in many weird and wonderful ways, including full names (``'green'``), hex strings (``'#008000'``), RGB or RGBA tuples (``(0,1,0,1)``) or grayscale intensities as a string (``'0.8'``). Of these, the string specifications can be used in place of a ``fmt`` group, but the tuple forms can be used only as ``kwargs``. Line styles and colors are combined in a single format string, as in ``'bo'`` for blue circles. The *kwargs* can be used to set line properties (any property that has a ``set_*`` method). You can use this to set a line label (for auto legends), linewidth, anitialising, marker face color, etc. Here is an example:: plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2) plot([1,2,3], [1,4,9], 'rs', label='line 2') axis([0, 4, 0, 10]) legend() If you make multiple lines with one plot command, the kwargs apply to all those lines, e.g.:: plot(x1, y1, x2, y2, antialised=False) Neither line will be antialiased. You do not need to use format strings, which are just abbreviations. All of the line properties can be controlled by keyword arguments. For example, you can set the color, marker, linestyle, and markercolor with:: plot(x, y, color='green', linestyle='dashed', marker='o', markerfacecolor='blue', markersize=12). See :class:`~matplotlib.lines.Line2D` for details. The kwargs are :class:`~matplotlib.lines.Line2D` properties: %(Line2D)s kwargs *scalex* and *scaley*, if defined, are passed on to :meth:`~matplotlib.axes.Axes.autoscale_view` to determine whether the *x* and *y* axes are autoscaled; the default is *True*. RR(R?R RRR>RRxR(R-RDRERRRRM((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR)s}   tboc K sh|js|jn|j||||}|rD|j|n|rZ|j|n|j|S(s} Plot with data with dates. Call signature:: plot_date(x, y, fmt='bo', tz=None, xdate=True, ydate=False, **kwargs) Similar to the :func:`~matplotlib.pyplot.plot` command, except the *x* or *y* (or both) data is considered to be dates, and the axis is labeled accordingly. *x* and/or *y* can be a sequence of dates represented as float days since 0001-01-01 UTC. Keyword arguments: *fmt*: string The plot format string. *tz*: [ *None* | timezone string | :class:`tzinfo` instance] The time zone to use in labeling dates. If *None*, defaults to rc value. *xdate*: [ *True* | *False* ] If *True*, the *x*-axis will be labeled with dates. *ydate*: [ *False* | *True* ] If *True*, the *y*-axis will be labeled with dates. Note if you are using custom date tickers and formatters, it may be necessary to set the formatters/locators after the call to :meth:`plot_date` since :meth:`plot_date` will set the default tick locator to :class:`matplotlib.dates.AutoDateLocator` (if the tick locator is not already set to a :class:`matplotlib.dates.DateLocator` instance) and the default tick formatter to :class:`matplotlib.dates.AutoDateFormatter` (if the tick formatter is not already set to a :class:`matplotlib.dates.DateFormatter` instance). Valid kwargs are :class:`~matplotlib.lines.Line2D` properties: %(Line2D)s .. seealso:: :mod:`~matplotlib.dates` for helper functions :func:`~matplotlib.dates.date2num`, :func:`~matplotlib.dates.num2date` and :func:`~matplotlib.dates.drange` for help on creating the required floating point dates. (RRR)RRR( R-R^R_R RtxdatetydateRERF((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt plot_date0s;   cO s|js|jni|jddd6|jdd d6|jddd6}i|jddd6|jdd d6|jddd6}|jd ||jd ||j}t|_|j||}||_|S( s Make a plot with log scaling on both the *x* and *y* axis. Call signature:: loglog(*args, **kwargs) :func:`~matplotlib.pyplot.loglog` supports all the keyword arguments of :func:`~matplotlib.pyplot.plot` and :meth:`matplotlib.axes.Axes.set_xscale` / :meth:`matplotlib.axes.Axes.set_yscale`. Notable keyword arguments: *basex*/*basey*: scalar > 1 Base of the *x*/*y* logarithm *subsx*/*subsy*: [ *None* | sequence ] The location of the minor *x*/*y* ticks; *None* defaults to autosubs, which depend on the number of decades in the plot; see :meth:`matplotlib.axes.Axes.set_xscale` / :meth:`matplotlib.axes.Axes.set_yscale` for details *nonposx*/*nonposy*: ['mask' | 'clip' ] Non-positive values in *x* or *y* can be masked as invalid, or clipped to a very small positive number The remaining valid kwargs are :class:`~matplotlib.lines.Line2D` properties: %(Line2D)s **Example:** .. plot:: mpl_examples/pylab_examples/log_demo.py tbasexi tsubsxtnonposxtmasktbaseytsubsytnonposyRN(RRR?RRRR R)(R-RDRERRRcR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytloglogys'     cO s|js|jni|jddd6|jddd6|jddd6}|jd||j}t|_|j||}||_|S(s Make a plot with log scaling on the *x* axis. Call signature:: semilogx(*args, **kwargs) :func:`semilogx` supports all the keyword arguments of :func:`~matplotlib.pyplot.plot` and :meth:`matplotlib.axes.Axes.set_xscale`. Notable keyword arguments: *basex*: scalar > 1 Base of the *x* logarithm *subsx*: [ *None* | sequence ] The location of the minor xticks; *None* defaults to autosubs, which depend on the number of decades in the plot; see :meth:`~matplotlib.axes.Axes.set_xscale` for details. *nonposx*: [ 'mask' | 'clip' ] Non-positive values in *x* can be masked as invalid, or clipped to a very small positive number The remaining valid kwargs are :class:`~matplotlib.lines.Line2D` properties: %(Line2D)s .. seealso:: :meth:`loglog` For example code and figure R*i R+R,R-RN(RRR?RRR R)(R-RDREtdRcR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytsemilogxs&     cO s|js|jni|jddd6|jddd6|jddd6}|jd||j}t|_|j||}||_|S(s Make a plot with log scaling on the *y* axis. call signature:: semilogy(*args, **kwargs) :func:`semilogy` supports all the keyword arguments of :func:`~matplotlib.pylab.plot` and :meth:`matplotlib.axes.Axes.set_yscale`. Notable keyword arguments: *basey*: scalar > 1 Base of the *y* logarithm *subsy*: [ *None* | sequence ] The location of the minor yticks; *None* defaults to autosubs, which depend on the number of decades in the plot; see :meth:`~matplotlib.axes.Axes.set_yscale` for details. *nonposy*: [ 'mask' | 'clip' ] Non-positive values in *y* can be masked as invalid, or clipped to a very small positive number The remaining valid kwargs are :class:`~matplotlib.lines.Line2D` properties: %(Line2D)s .. seealso:: :meth:`loglog` For example code and figure R.i R/R0R-RN(RRR?RRR R)(R-RDRER2RcR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytsemilogys&     cK s|j|||S(s Plot the autocorrelation of *x*. Call signature:: acorr(x, normed=True, detrend=mlab.detrend_none, usevlines=True, maxlags=10, **kwargs) If *normed* = *True*, normalize the data by the autocorrelation at 0-th lag. *x* is detrended by the *detrend* callable (default no normalization). Data are plotted as ``plot(lags, c, **kwargs)`` Return value is a tuple (*lags*, *c*, *line*) where: - *lags* are a length 2*maxlags+1 lag vector - *c* is the 2*maxlags+1 auto correlation vector - *line* is a :class:`~matplotlib.lines.Line2D` instance returned by :meth:`plot` The default *linestyle* is None and the default *marker* is ``'o'``, though these can be overridden with keyword args. The cross correlation is performed with :func:`numpy.correlate` with *mode* = 2. If *usevlines* is *True*, :meth:`~matplotlib.axes.Axes.vlines` rather than :meth:`~matplotlib.axes.Axes.plot` is used to draw vertical lines from the origin to the acorr. Otherwise, the plot style is determined by the kwargs, which are :class:`~matplotlib.lines.Line2D` properties. *maxlags* is a positive integer detailing the number of lags to show. The default value of *None* will return all ``(2*len(x)-1)`` lags. The return value is a tuple (*lags*, *c*, *linecol*, *b*) where - *linecol* is the :class:`~matplotlib.collections.LineCollection` - *b* is the *x*-axis. .. seealso:: :meth:`~matplotlib.axes.Axes.plot` or :meth:`~matplotlib.axes.Axes.vlines` For documentation on valid kwargs. **Example:** :func:`~matplotlib.pyplot.xcorr` is top graph, and :func:`~matplotlib.pyplot.acorr` is bottom graph. .. plot:: mpl_examples/pylab_examples/xcorr_demo.py (txcorr(R-R^RE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytacorrs=i c K st|}|t|kr-tdn|tj|}|tj|}tj||dd} |r| tjtj||tj||} n|d kr|d}n||ks|dkrtd|ntj| |d} | |d|||!} |rN|j | dg| |} |j |} n>|j dd|j d d |j | | |\} d } | | | | fS( s Plot the cross correlation between *x* and *y*. Call signature:: xcorr(self, x, y, normed=True, detrend=mlab.detrend_none, usevlines=True, maxlags=10, **kwargs) If *normed* = *True*, normalize the data by the cross correlation at 0-th lag. *x* and y are detrended by the *detrend* callable (default no normalization). *x* and *y* must be equal length. Data are plotted as ``plot(lags, c, **kwargs)`` Return value is a tuple (*lags*, *c*, *line*) where: - *lags* are a length ``2*maxlags+1`` lag vector - *c* is the ``2*maxlags+1`` auto correlation vector - *line* is a :class:`~matplotlib.lines.Line2D` instance returned by :func:`~matplotlib.pyplot.plot`. The default *linestyle* is *None* and the default *marker* is 'o', though these can be overridden with keyword args. The cross correlation is performed with :func:`numpy.correlate` with *mode* = 2. If *usevlines* is *True*: :func:`~matplotlib.pyplot.vlines` rather than :func:`~matplotlib.pyplot.plot` is used to draw vertical lines from the origin to the xcorr. Otherwise the plotstyle is determined by the kwargs, which are :class:`~matplotlib.lines.Line2D` properties. The return value is a tuple (*lags*, *c*, *linecol*, *b*) where *linecol* is the :class:`matplotlib.collections.LineCollection` instance and *b* is the *x*-axis. *maxlags* is a positive integer detailing the number of lags to show. The default value of *None* will return all ``(2*len(x)-1)`` lags. **Example:** :func:`~matplotlib.pyplot.xcorr` is top graph, and :func:`~matplotlib.pyplot.acorr` is bottom graph. .. plot:: mpl_examples/pylab_examples/xcorr_demo.py sx and y must be equal lengthtmodeiis.maglags must be None or strictly positive < %diR"toR!RN( RqRRYRt correlatetsqrttdotRRsRRt setdefaultR)( R-R^R_tnormedtdetrendt usevlinestmaxlagsREtNxR%tlagsRRc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR5]s.8 2   cC s|j|j|j|j}tjj}|dk rU|j}|j |ng}xK|D]C}|j dkrqbntjj ||rb|j |qbqbW|S(s6return artists that will be used as handles for legendt _nolegend_N( RRRRDtmlegendtLegendtget_default_handler_mapRR0RRtget_legend_handlerRx(R-tlegend_handler_mapthandles_originalt handler_mapthandlesR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt_get_legend_handless   cC sog}g}xV|j|D]E}|j}|r|jd r|j||j|qqW||fS(s Return handles and labels for legend ``ax.legend()`` is equivalent to :: h, l = ax.get_legend_handles_labels() ax.legend(h, l) R(RLRt startswithRx(R-RHRKRthandleR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_legend_handles_labelss   cO s~t|dkrJ|j\}}t|dkr\tjddSnt|dkr|d}gt|j|D]\}}|^q|}nt|dkr"t|dst|dt r|\}}gt|j|D]\}}|^q}||dRXRvRrRRlRRRt_interpolation_stepsRRxRdterrorbarRR%RYtamintamaxRwR(RRR(,R-RRRRRER#RWRRXRYRZR[R\R]RRRR`t_leftt_bottomt adjust_ylimt adjust_xlimtnbarsRtiRDRRcRRR%teRRWt holdstateR^R_RfRxRyRzR{t bar_container((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytbars*S                                  8 8"           0/ ,3    . .   c K s1|jd|d|d|d|dd|}|S(s Make a horizontal bar plot. Call signature:: barh(bottom, width, height=0.8, left=0, **kwargs) Make a horizontal bar plot with rectangles bounded by: *left*, *left* + *width*, *bottom*, *bottom* + *height* (left, right, bottom and top edges) *bottom*, *width*, *height*, and *left* can be either scalars or sequences Return value is a list of :class:`matplotlib.patches.Rectangle` instances. Required arguments: ======== ====================================================== Argument Description ======== ====================================================== *bottom* the vertical positions of the bottom edges of the bars *width* the lengths of the bars ======== ====================================================== Optional keyword arguments: =============== ========================================== Keyword Description =============== ========================================== *height* the heights (thicknesses) of the bars *left* the x coordinates of the left edges of the bars *color* the colors of the bars *edgecolor* the colors of the bar edges *linewidth* width of bar edges; None means use default linewidth; 0 means don't draw edges. *xerr* if not None, will be used to generate errorbars on the bar chart *yerr* if not None, will be used to generate errorbars on the bar chart *ecolor* specifies the color of any errorbar *capsize* (default 3) determines the length in points of the error bar caps *align* 'edge' (default) | 'center' *log* [False|True] False (default) leaves the horizontal axis as-is; True sets it to log scale =============== ========================================== Setting *align* = 'edge' aligns bars by their bottom edges in bottom, while *align* = 'center' interprets these values as the *y* coordinates of the bar centers. The optional arguments *color*, *edgecolor*, *linewidth*, *xerr*, and *yerr* can be either scalars or sequences of length equal to the number of bars. This enables you to use barh as the basis for stacked bar charts, or candlestick plots. other optional kwargs: %(Rectangle)s RRRRRR(Rr(R-RRRRRER((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytbarhsEcK s6tj|||}|j|dt|j|S(s Plot horizontal bars. Call signature:: broken_barh(self, xranges, yrange, **kwargs) A collection of horizontal bars spanning *yrange* with a sequence of *xranges*. Required arguments: ========= ============================== Argument Description ========= ============================== *xranges* sequence of (*xmin*, *xwidth*) *yrange* sequence of (*ymin*, *ywidth*) ========= ============================== kwargs are :class:`matplotlib.collections.BrokenBarHCollection` properties: %(BrokenBarHCollection)s these can either be a single argument, ie:: facecolors = 'black' or a sequence of arguments for the various bars, ie:: facecolors = ('black', 'red', 'green') **Example:** .. plot:: mpl_examples/pylab_examples/broken_barh.py R(RtBrokenBarHCollectionRR R(R-txrangestyrangeREtcol((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt broken_barh8s' cO s|j}|js|jn|jttj|ddtj}|d}y7tj|ddtj}||}}|d}Wn2ttfk rtj t |}|}nXy|j d|d}Wn#tk r|j dd}nXy|j d|d}Wn#tk r=|j dd}nXy|j d|d } Wn#tk r}|j dd } nX|j d d} |j d d} |j |||d d \} | dkrd} ng} xTt||D]C\}}|j ||g| |g|d d \}| j|qW|j tj|tj|g| | g| d d \}|j|t| | |fd | }|j||S(s) Create a stem plot. Call signatures:: stem(y, linefmt='b-', markerfmt='bo', basefmt='r-') stem(x, y, linefmt='b-', markerfmt='bo', basefmt='r-') A stem plot plots vertical lines (using *linefmt*) at each *x* location from the baseline to *y*, and places a marker there using *markerfmt*. A horizontal line at 0 is is plotted using *basefmt*. If no *x* values are provided, the default is (0, 1, ..., len(y) - 1) Return value is a tuple (*markerline*, *stemlines*, *baseline*). .. seealso:: This `document `_ for details. **Example:** .. plot:: mpl_examples/pylab_examples/stem_plot.py iRpitlinefmtsb-t markerfmtR&tbasefmtisr-RRRCN(RRRdR RYRRtRRRsRqR?RR)RrRxRgRhRR(R-RDREt remember_holdR_tsecondR^RyRzR{RRt markerlinet stemlinesR RRR#tstem_container((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytstemesT             *   g333333?g?c  C s$|jttj|jtj}t|j} | dkr[tj|| }n|dkr}dgt |}n|dkrdgt |}nt |t |kst t |t |kst |dkrd}nd } | dkr d} n| dkr d} n | d } g}g}g}d}xt j |||D]m\}}}| \}}| |}d tjd| |}||tj|7}||tj|7}tj||f| d | d |d||t |}|j||j||j||rttj|dd}|jd|j|jd|j|n||| tj|}||| tj|}|dkrdpd}|j|||dtdd|dd}|j||dk r||| tj|}||| tj|}t|rY|d|}n+t|rx|d|}n td|j|||dddd}|j|n|} |d7}qXW|jd!|j d"|j!g|j"g|dkr||fS|||fSdS(#s Plot a pie chart. Call signature:: pie(x, explode=None, labels=None, colors=('b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'), autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=None, radius=None) Make a pie chart of array *x*. The fractional area of each wedge is given by x/sum(x). If sum(x) <= 1, then the values of x give the fractional area directly and the array will not be normalized. The wedges are plotted counterclockwise, by default starting from the x-axis. Keyword arguments: *explode*: [ *None* | len(x) sequence ] If not *None*, is a ``len(x)`` array which specifies the fraction of the radius with which to offset each wedge. *colors*: [ *None* | color sequence ] A sequence of matplotlib color args through which the pie chart will cycle. *labels*: [ *None* | len(x) sequence of strings ] A sequence of strings providing the labels for each wedge *autopct*: [ *None* | format string | format function ] If not *None*, is a string or function used to label the wedges with their numeric value. The label will be placed inside the wedge. If it is a format string, the label will be ``fmt%pct``. If it is a function, it will be called. *pctdistance*: scalar The ratio between the center of each pie slice and the start of the text generated by *autopct*. Ignored if *autopct* is *None*; default is 0.6. *labeldistance*: scalar The radial distance at which the pie labels are drawn *shadow*: [ *False* | *True* ] Draw a shadow beneath the pie. *startangle*: [ *None* | Offset angle ] If not *None*, rotates the start of the pie chart by *angle* degrees counterclockwise from the x-axis. *radius*: [ *None* | scalar ] The radius of the pie, if *radius* is *None* it will be set to 1. The pie chart will probably look best if the figure and axes are square, or the Axes aspect is equal. e.g.:: figure(figsize=(8,8)) ax = axes([0.1, 0.1, 0.8, 0.8]) or:: axes(aspect=1) Return value: If *autopct* is *None*, return the tuple (*patches*, *texts*): - *patches* is a sequence of :class:`matplotlib.patches.Wedge` instances - *texts* is a list of the label :class:`matplotlib.text.Text` instances. If *autopct* is not *None*, return the tuple (*patches*, *texts*, *autotexts*), where *patches* and *texts* are as above, and *autotexts* is a list of :class:`~matplotlib.text.Text` instances for the numeric labels. iRiRctgRWR%RR_RzRgv@ig?Rig{Gzg?RCRRRsxtick.labelsizeR$R"RgY@s+autopct must be callable or a format stringgg?N(RcRRWR%RR_RzR(ii(gg?(gg?(#R^R RYRtastypetfloat32RttsumtdivideRRqRHR'tsafezipRvtpitcostsinRltWedgeRxRRtShadowR5t get_zorderR RR RRKR,R8RR(R-R^texplodeRRtautopctt pctdistancetshadowt labeldistancet startangleRtsxRttheta1Rtslicest autotextsRntfracRtexplR_ttheta2tthetamRtshadtxttyttlabel_alignmentRXR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytpiesQ           %  #                  t-ic1 K s$ |dkrtdn|jd|d|d||jsM|jn|j}t|_|jdd}t|s|g}nt|s|g}n|dk rt|s|gt|}qn|dk rt|s|gt|}qnd}| r?|dk r?|j |||dd|\}ng}g}idd6}|rk||dR6Rdt get_colort set_colorRRRRD(1R-R^R_RYRXR R[t elinewidthR\t barsabovetlolimstuplimstxlolimstxuplimst erroreverytcapthickRERpRtl0tbarcolstcaplinestlines_kwt everymaskRtplot_kwR tthiserrRRtyoRtlotrotleftlotylotrightuptyupRRRtxotuotxlotlowerlotxuptupperupRterrorbar_container((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRfms8i              $        " " " "            03,,  " "%  03,,  " "%         sb+g?c =  s ddfd} js1jnj} gggggf\}}}}}t|drKt|jdkrt|ddrt|}qH|g}qKt|jdkr<|j\}}|dkr|g}qH|dkr |jg}qHgt|D]}|dd|f^q}qKtd nt|dd sj|g}nt|}d }d }| dk r t| drt| jdkrt|q| jd|krt|qq t| |kr t|q nd }d}d}| dk rt| drt| jdkr[t|q| jd|kr}t|q| jddkrt|qqt| |krt|nx>| D]3}|dk rt|dkrt|qqWn|dkr&t d|d}n|dkrgt |t |}t dt |dd}nt |tst |trtj|ft|}njtxt|D]\}}tj||}t|}|dkrqntj|dddg\}} }!| dk rH| |dk rH| |} qHn|!|}"|!||"}#tj||#k|}$t|$dkstj |$|!kr|!}$n t |$}$|||"}%tj||%k|}&t|&dkstj |&|kr |}&n t |&}&g}'g}(g})g}*t|dkrtj||$k|}'tj||&k|}(tj|'jd|})tj|(jd|}*n|||d}+|||d},tjd|}-|||d}.|||d}/|.|/g}0| | g}1|r| dk re| |dk retj | |}2tj | |}3n| || |"| \}3}2|+|,|,|/|,|,|+|+|.|+|+g }4|||3| |2|!|!|2| |3|g }5|.|/g}6| | g}1n6|+|,|,|+|+g}4|||!|!|g}5|+|,g}6dfd|rafd}7fd}8nfd}7fd}8|rd}9nd}9|j|7|-||&gd|-|!|$gd|j|7|0|$|$gd |0|&|&gd |r|j|8|4|5n|j|7|4|5d!|j|7|6|1|9d"|j|7|)|'||*|(|qW|rjj}:};njj}:};t |dt |df}<|;|<|:|j| td#|d$|d%|d&|d'|S((s Make a box and whisker plot. Call signature:: boxplot(x, notch=False, sym='+', vert=True, whis=1.5, positions=None, widths=None, patch_artist=False, bootstrap=None, usermedians=None, conf_intervals=None) Make a box and whisker plot for each column of *x* or each vector in sequence *x*. The box extends from the lower to upper quartile values of the data, with a line at the median. The whiskers extend from the box to show the range of the data. Flier points are those past the end of the whiskers. Function Arguments: *x* : Array or a sequence of vectors. *notch* : [ False (default) | True ] If False (default), produces a rectangular box plot. If True, will produce a notched box plot *sym* : [ default 'b+' ] The default symbol for flier points. Enter an empty string ('') if you don't want to show fliers. *vert* : [ False | True (default) ] If True (default), makes the boxes vertical. If False, makes horizontal boxes. *whis* : [ default 1.5 ] Defines the length of the whiskers as a function of the inner quartile range. They extend to the most extreme data point within ( ``whis*(75%-25%)`` ) data range. *bootstrap* : [ *None* (default) | integer ] Specifies whether to bootstrap the confidence intervals around the median for notched boxplots. If bootstrap==None, no bootstrapping is performed, and notches are calculated using a Gaussian-based asymptotic approximation (see McGill, R., Tukey, J.W., and Larsen, W.A., 1978, and Kendall and Stuart, 1967). Otherwise, bootstrap specifies the number of times to bootstrap the median to determine it's 95% confidence intervals. Values between 1000 and 10000 are recommended. *usermedians* : [ default None ] An array or sequence whose first dimension (or length) is compatible with *x*. This overrides the medians computed by matplotlib for each element of *usermedians* that is not None. When an element of *usermedians* == None, the median will be computed directly as normal. *conf_intervals* : [ default None ] Array or sequence whose first dimension (or length) is compatible with *x* and whose second dimension is 2. When the current element of *conf_intervals* is not None, the notch locations computed by matplotlib are overridden (assuming notch is True). When an element of *conf_intervals* is None, boxplot compute notches the method specified by the other kwargs (e.g., *bootstrap*). *positions* : [ default 1,2,...,n ] Sets the horizontal positions of the boxes. The ticks and limits are automatically set to match the positions. *widths* : [ default 0.5 ] Either a scalar or a vector and sets the width of each box. The default is 0.5, or ``0.15*(distance between extreme positions)`` if that is smaller. *patch_artist* : [ False (default) | True ] If False produces boxes with the Line2D artist If True produces boxes with the Patch artist Returns a dictionary mapping each component of the boxplot to a list of the :class:`matplotlib.lines.Line2D` instances created. That dictionary has the following keys (assuming vertical boxplots): - boxes: the main body of the boxplot showing the quartiles and the median's confidence intervals if enabled. - medians: horizonal lines at the median of each box. - whiskers: the vertical lines extending to the most extreme, n-outlier data points. - caps: the horizontal lines at the ends of the whiskers. - fliers: points representing data that extend beyone the whiskers (outliers). **Example:** .. plot:: pyplots/boxplot_demo.py ic S st|}ddg}tj|}xPt|D]B}tjjd|d|}||}tj|d|||8|j?dt@|jA|5|s |5S|dkr t jBt|}nfd}9t jC|||}:|9|||:};t j|;}<gg}=}>xtD|;D]\}.}?|:|.}@|.t|:d krP|:|.d }An|@t jE|:d }A|<|.swqn|=j |@df|@d!f|Ad!f|Adfg|>j |?qWt j |>}>t)jF|jG|jH}Bt'j(|=d"|Bddj7|>j8| j9| j:| j;||jAt jC|||}:|9|||:}Ct j|C}<gg}=}>xtD|CD]\}.}?|:|.}@|.t|:d kr|:|.d }An|@t jE|:d }A|<|.sqn|=j d|@fd|Afd!|Afd!|@fg|>j |?qWt j |>}>t)jF|jH|jG}Bt'j(|=d"|Bddj7|>j8| j9| j:| j;||jA|5_I|5_Jfd#}D|5jKjLd$|D|5S(&sv Make a hexagonal binning plot. Call signature:: hexbin(x, y, C = None, gridsize = 100, bins = None, xscale = 'linear', yscale = 'linear', cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='none' reduce_C_function = np.mean, mincnt=None, marginals=True **kwargs) Make a hexagonal binning plot of *x* versus *y*, where *x*, *y* are 1-D sequences of the same length, *N*. If *C* is *None* (the default), this is a histogram of the number of occurences of the observations at (x[i],y[i]). If *C* is specified, it specifies values at the coordinate (x[i],y[i]). These values are accumulated for each hexagonal bin and then reduced according to *reduce_C_function*, which defaults to numpy's mean function (np.mean). (If *C* is specified, it must also be a 1-D sequence of the same length as *x* and *y*.) *x*, *y* and/or *C* may be masked arrays, in which case only unmasked points will be plotted. Optional keyword arguments: *gridsize*: [ 100 | integer ] The number of hexagons in the *x*-direction, default is 100. The corresponding number of hexagons in the *y*-direction is chosen such that the hexagons are approximately regular. Alternatively, gridsize can be a tuple with two elements specifying the number of hexagons in the *x*-direction and the *y*-direction. *bins*: [ *None* | 'log' | integer | sequence ] If *None*, no binning is applied; the color of each hexagon directly corresponds to its count value. If 'log', use a logarithmic scale for the color map. Internally, :math:`log_{10}(i+1)` is used to determine the hexagon color. If an integer, divide the counts in the specified number of bins, and color the hexagons accordingly. If a sequence of values, the values of the lower bound of the bins to be used. *xscale*: [ 'linear' | 'log' ] Use a linear or log10 scale on the horizontal axis. *scale*: [ 'linear' | 'log' ] Use a linear or log10 scale on the vertical axis. *mincnt*: [ *None* | a positive integer ] If not *None*, only display cells with more than *mincnt* number of points in the cell *marginals*: [ *True* | *False* ] if marginals is *True*, plot the marginal density as colormapped rectagles along the bottom of the x-axis and left of the y-axis *extent*: [ *None* | scalars (left, right, bottom, top) ] The limits of the bins. The default assigns the limits based on gridsize, x, y, xscale and yscale. Other keyword arguments controlling color mapping and normalization arguments: *cmap*: [ *None* | Colormap ] a :class:`matplotlib.colors.Colormap` instance. If *None*, defaults to rc ``image.cmap``. *norm*: [ *None* | Normalize ] :class:`matplotlib.colors.Normalize` instance is used to scale luminance data to 0,1. *vmin* / *vmax*: scalar *vmin* and *vmax* are used in conjunction with *norm* to normalize luminance data. If either are *None*, the min and max of the color array *C* is used. Note if you pass a norm instance, your settings for *vmin* and *vmax* will be ignored. *alpha*: scalar between 0 and 1, or *None* the alpha value for the patches *linewidths*: [ *None* | scalar ] If *None*, defaults to rc lines.linewidth. Note that this is a tuple, and if you set the linewidths argument you must set it as a sequence of floats, as required by :class:`~matplotlib.collections.RegularPolyCollection`. Other keyword arguments controlling the Collection properties: *edgecolors*: [ *None* | ``'none'`` | mpl color | color sequence ] If ``'none'``, draws the edges in the same color as the fill color. This is the default, as it avoids unsightly unpainted pixels between the hexagons. If *None*, draws the outlines in the default color. If a matplotlib color arg or sequence of rgba tuples, draws the outlines in the specified color. Here are the standard descriptions of all the :class:`~matplotlib.collections.Collection` kwargs: %(Collection)s The return value is a :class:`~matplotlib.collections.PolyCollection` instance; use :meth:`~matplotlib.collections.PolyCollection.get_array` on this :class:`~matplotlib.collections.PolyCollection` to get the counts in each hexagon. If *marginals* is *True*, horizontal bar and vertical bar (both PolyCollections) will be attached to the return collection as attributes *hbar* and *vbar*. **Example:** .. plot:: mpl_examples/pylab_examples/hexbin_demo.py R R REiRgs8x contains non-positive values, so can not be log-scaleds8y contains non-positive values, so can not be log-scaledg& .>iig@g?iRpNigg?gR'R(g$@R%RR*R+toffset_positionRRc s{|j|jdt|d}tjt|}x:tt|D]&}|||k}|||g?cC sk|js|jntj|||||d|d|d|d|d| d| d| d| d |  }|S( NtdensityRR#R9R:t arrowsizet arrowstylet minlengthR(RRtmstreamt streamplot(R-R^R_tuR{RRR#R9R:RRRRtstream_container((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs   cO sY|js|jntj|||}|j||j|j|j|S(sq %(barbs_doc)s **Example:** .. plot:: mpl_examples/pylab_examples/barb_demo.py (RRRtBarbsRRt get_offsetsR(R-RDRfRc((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytbarbss    cO sa|js|jng}x4|j||D] }|j||j|q/W|j|S(s Plot filled polygons. Call signature:: fill(*args, **kwargs) *args* is a variable length argument, allowing for multiple *x*, *y* pairs with an optional color format string; see :func:`~matplotlib.pyplot.plot` for details on the argument parsing. For example, to plot a polygon with vertices at *x*, *y* in blue.:: ax.fill(x,y, 'b' ) An arbitrary number of *x*, *y*, *color* groups can be specified:: ax.fill(x1, y1, 'g', x2, y2, 'r') Return value is a list of :class:`~matplotlib.patches.Patch` instances that were added. The same color strings that :func:`~matplotlib.pyplot.plot` supports are supported by the fill format string. If you would like to fill below a curve, e.g., shade a region between 0 and *y* along *x*, use :meth:`fill_between` The *closed* kwarg will close the polygon when *True* (default). kwargs control the :class:`~matplotlib.patches.Polygon` properties: %(Polygon)s **Example:** .. plot:: mpl_examples/lines_bars_and_markers/fill_demo.py (RRR?RRxR(R-RDRERtpoly((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRSs)    c s|jddd||jdtj|jtj|jtj|jjdkrtjnjdkrtjn|d krtj t tj }ntj |tj }j j ko+j ko+|j kns?tdnttjgfD]}tj|^qX}|tjk r||M}ng} xtj|D]y\} } | | !} | | !} | | !}t | sqnt | }tjd|ddftj}|rSfd}|| }|| }n(| d|df}| d|df}||d<|||d <| |d |d df<| |d |d d f<| d d d||dd df<|d d d||dd d f<| j|qWtj| |}tj||gj}tj||gj}|jj||jd td t|jj||jd t d t|j!||j"|S( s Make filled polygons between two curves. Call signature:: fill_between(x, y1, y2=0, where=None, **kwargs) Create a :class:`~matplotlib.collections.PolyCollection` filling the regions between *y1* and *y2* where ``where==True`` *x* : An N-length array of the x data *y1* : An N-length array (or scalar) of the y data *y2* : An N-length array (or scalar) of the y data *where* : If *None*, default to fill between everywhere. If not *None*, it is an N-length numpy boolean array and the fill will only happen over the regions where ``where==True``. *interpolate* : If *True*, interpolate between the two lines to find the precise point of intersection. Otherwise, the start and end points of the filled region will only occur on explicit values in the *x* array. *kwargs* : Keyword args passed on to the :class:`~matplotlib.collections.PolyCollection`. kwargs control the :class:`~matplotlib.patches.Polygon` properties: %(PolyCollection)s .. plot:: mpl_examples/pylab_examples/fill_between_demo.py .. seealso:: :meth:`fill_betweenx` for filling between two sets of x-values R R REis$Argument dimensions are incompatibleic st|dd}||d!}||d!||d!}||d!}t|dkrtjj|dr||fStjj|dr||fSn|j}tjd||||}tj|||}||fS(Niii(RwRqRYRt is_maskedtargsorttinterp(RDtim1tx_valuest diff_valuest y1_valuest diff_ordert diff_root_xt diff_root_y(R^R^ty2(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_interp_pointns  iiNRR(#R Rtmasked_invalidRWRXR\RYt ones_likeRRRqRRR[Rtreducetmask_ortgetmasktnomaskRtcontiguous_regionsRRtRxRRVRR RRR&R R RR(R-R^R^RRQt interpolateRERR-tpolystind0tind1txslicety1slicety2sliceRtXRRtendRtXY1tXY2((R^R^RsI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt fill_betweensb3 37     #  ''      cK s|jd|d|d||jd|tj|j|}tj|j|}tj|j|}|jdkrtj||}n|jdkrtj||}n|d krtj t |tj }ntj |tj }|j |j ko+|j ko+|j kns?tdnttjg|||fD]}tj|^qX}|tjk r||M}ng}xHtj|D]7\} } || | !} || | !} || | !} t | sqnt | }tjd|ddftj}| d| df|d<| d| df||d<| |d|ddf<| |d|ddf<| d d d||dd df<| d d d||dd df<|j|qWtj||}tj||||gj}tj||||gj}|jj||jd td t|jj||jd t d t|j!||j"|S( s Make filled polygons between two horizontal curves. Call signature:: fill_betweenx(y, x1, x2=0, where=None, **kwargs) Create a :class:`~matplotlib.collections.PolyCollection` filling the regions between *x1* and *x2* where ``where==True`` *y* : An N-length array of the y data *x1* : An N-length array (or scalar) of the x data *x2* : An N-length array (or scalar) of the x data *where* : If *None*, default to fill between everywhere. If not *None*, it is a N length numpy boolean array and the fill will only happen over the regions where ``where==True`` *kwargs* : keyword args passed on to the :class:`~matplotlib.collections.PolyCollection` kwargs control the :class:`~matplotlib.patches.Polygon` properties: %(PolyCollection)s .. plot:: mpl_examples/pylab_examples/fill_betweenx_demo.py .. seealso:: :meth:`fill_between` for filling between two sets of y-values R R REis$Argument dimensions are incompatibleiiiNRR(#R RRRXRWR\RYRRRRqRRR[RRRRRRRRRtRxRRVRR RRR&R R RR(R-R_RXtx2RQRERR-RRRtyslicetx1slicetx2sliceRR RtX1YtX2Y((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt fill_betweenxsV, 37     #''      g@c s]jsjn|dk r=t|tjs=tn|dkrVtd}nj|t j |||| | d| d| d||}|j ||j |j ||jdkr|jjn|dk s|dk r |j||n |j|j||j|jjj|fd|_|S(s Display an image on the axes. Parameters ----------- X : array_like, shape (n, m) or (n, m, 3) or (n, m, 4) Display the image in `X` to current axes. `X` may be a float array, a uint8 array or a PIL image. If `X` is an array, it can have the following shapes: - MxN -- luminance (grayscale, float array only) - MxNx3 -- RGB (float or uint8 array) - MxNx4 -- RGBA (float or uint8 array) The value for each component of MxNx3 and MxNx4 float arrays should be in the range 0.0 to 1.0; MxN float arrays may be normalised. cmap : `~matplotlib.colors.Colormap`, optional, default: None If None, default to rc `image.cmap` value. `cmap` is ignored when `X` has RGB(A) information aspect : ['auto' | 'equal' | scalar], optional, default: None If 'auto', changes the image aspect ratio to match that of the axes. If 'equal', and `extent` is None, changes the axes aspect ratio to match that of the image. If `extent` is not `None`, the axes aspect ratio is changed to match that of the extent. If None, default to rc ``image.aspect`` value. interpolation : string, optional, default: None Acceptable values are 'none', 'nearest', 'bilinear', 'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos' If `interpolation` is None, default to rc `image.interpolation`. See also the `filternorm` and `filterrad` parameters. If `interpolation` is 'none', then no interpolation is performed on the Agg, ps and pdf backends. Other backends will fall back to 'nearest'. norm : `~matplotlib.colors.Normalize`, optional, default: None A `~matplotlib.colors.Normalize` instance is used to scale luminance data to 0, 1. If `None`, use the default func:`normalize`. `norm` is only used if `X` is an array of floats. vmin, vmax : scalar, optional, default: None `vmin` and `vmax` are used in conjunction with norm to normalize luminance data. Note if you pass a `norm` instance, your settings for `vmin` and `vmax` will be ignored. alpha : scalar, optional, default: None The alpha blending value, between 0 (transparent) and 1 (opaque) origin : ['upper' | 'lower'], optional, default: None Place the [0,0] index of the array in the upper left or lower left corner of the axes. If None, default to rc `image.origin`. extent : scalars (left, right, bottom, top), optional, default: None Data limits for the axes. The default assigns zero-based row, column indices to the `x`, `y` centers of the pixels. shape : scalars (columns, rows), optional, default: None For raw buffer images filternorm : scalar, optional, default: 1 A parameter for the antigrain image resize filter. From the antigrain documentation, if `filternorm` = 1, the filter normalizes integer values and corrects the rounding errors. It doesn't do anything with the source floating point values, it corrects only integers according to the rule of 1.0 which means that any sum of pixel weights must be equal to 1.0. So, the filter function must produce a graph of the proper shape. filterrad : scalar, optional, default: 4.0 The filter radius for filters that have a radius parameter, i.e. when interpolation is one of: 'sinc', 'lanczos' or 'blackman' Returns -------- image : `~matplotlib.image.AxesImage` Other parameters ---------------- kwargs : `~matplotlib.artist.Artist` properties. See also -------- matshow : Plot a matrix or an array as an image. Examples -------- .. plot:: mpl_examples/pylab_examples/image_demo.py s image.aspectt filternormt filterradtresamplec sjj|S(N(RR(R(R-(sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRsN(RRRRRR3RHRRRDRtset_dataR2RRRTRNR7R8tset_urlt set_extentt get_extentRRxR(R-RR9R:Rjt interpolationRR;R<toriginR]R[RRtimlimRturlRER((R-sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytimshows.j           c O s|jdt}t|dkr|d}|j\}}|rptjtj|tj|\}}n2tjtj|dtj|d\}}|||fSt|dkr|\}}}|j\}}ntd||f|jd} |jd} t|jdks:|jddkrd|jd| } | j | dd}nt|jdks|jddkr|j| d} | j | dd}n|j|jkrtd ||fn|r$| |ko| |kstd |j| | |fqnr|| | dfkoM|| | dfksrtd |j| | |fn|d| dd| df}|||fS( Ntallmatchiiis%Illegal arguments to %s; see help(%s)iiRs,Incompatible X, Y inputs to %s; see help(%s)sKDimensions of C %s are incompatible with X (%d) and/or Y (%d); see help(%s)( R?R RqR[RYtmeshgridRsRKtreshapeRT( tfuncnameRDRfRRtnumRowstnumColsRR RAtNyR^R_((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt _pcolorargssF -   ((,$c- O sZ|js|jn|jdd}|jdd}|jdd}|jdd}|jdd}d|krtjdddd d d d n|jdd }|jddt|\} } } | j\} } t j | } t j | } t j | } t j | t j | }|ddddf|ddddf|ddddf|ddddf}t j | |}t j }t j}|dkj}||t j| ddddfj}||t j| ddddfj}||t j| ddddfj}||t j| ddddfj}||t j| ddddfj}||t j| ddddfj}||t j| ddddfj}||t j| ddddfj}t|}t j|dd|f|dd|f|dd|f|dd|f|dd|f|dd|f|dd|f|dd|f|dd|f|dd|ff dd}|j|ddf}||t j| d| dd| dfj} d"}d|kr|jd|d` section below. If either or both of *X* and *Y* are 1-D arrays or column vectors, they will be expanded as needed into the appropriate 2-D arrays, making a rectangular grid. *X*, *Y* and *C* may be masked arrays. If either C[i, j], or one of the vertices surrounding C[i,j] (*X* or *Y* at [i, j], [i+1, j], [i, j+1],[i+1, j+1]) is masked, nothing is plotted. Keyword arguments: *cmap*: [ *None* | Colormap ] A :class:`matplotlib.colors.Colormap` instance. If *None*, use rc settings. *norm*: [ *None* | Normalize ] An :class:`matplotlib.colors.Normalize` instance is used to scale luminance data to 0,1. If *None*, defaults to :func:`normalize`. *vmin*/*vmax*: [ *None* | scalar ] *vmin* and *vmax* are used in conjunction with *norm* to normalize luminance data. If either is *None*, it is autoscaled to the respective min or max of the color array *C*. If not *None*, *vmin* or *vmax* passed in here override any pre-existing values supplied in the *norm* instance. *shading*: [ 'flat' | 'faceted' ] If 'faceted', a black grid is drawn around each rectangle; if 'flat', edges are not drawn. Default is 'flat', contrary to MATLAB. This kwarg is deprecated; please use 'edgecolors' instead: * shading='flat' -- edgecolors='none' * shading='faceted -- edgecolors='k' *edgecolors*: [ *None* | ``'none'`` | color | color sequence] If *None*, the rc setting is used by default. If ``'none'``, edges will not be visible. An mpl color or sequence of colors will set the edge color *alpha*: ``0 <= scalar <= 1`` or *None* the alpha blending value Return value is a :class:`matplotlib.collections.Collection` instance. .. _axes-pcolor-grid-orientation: The grid orientation follows the MATLAB convention: an array *C* with shape (*nrows*, *ncolumns*) is plotted with the column number as *X* and the row number as *Y*, increasing up; hence it is plotted the way the array would be printed, except that the *Y* axis is reversed. That is, *C* is taken as *C*(*y*, *x*). Similarly for :func:`meshgrid`:: x = np.arange(5) y = np.arange(3) X, Y = np.meshgrid(x, y) is equivalent to:: X = array([[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]) Y = array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2]]) so if you have:: C = rand(len(x), len(y)) then you need to transpose C:: pcolor(X, Y, C.T) or:: pcolor(C.T) MATLAB :func:`pcolor` always discards the last row and column of *C*, but matplotlib displays the last row and column if *X* and *Y* are not specified, or if *X* and *Y* have one more row and column than *C*. kwargs can be used to control the :class:`~matplotlib.collections.PolyCollection` properties: %(PolyCollection)s .. note:: The default *antialiaseds* is False if the default *edgecolors*="none" is used. This eliminates artificial lines at patch boundaries, and works regardless of the value of alpha. If *edgecolors* is not "none", then the default *antialiaseds* is taken from rcParams['patch.antialiased'], which defaults to *True*. Stroking the edges may be preferred if *alpha* is 1, but will cause artifacts otherwise. .. seealso:: :func:`~matplotlib.pyplot.pcolormesh` For an explanation of the differences between pcolor and pcolormesh. RR:R9R;R<tshadings1.2RARhR%RiR&tflattpcolorRiiiNRiig?RRR$RzR'RWt antialiasedt antialiasedst_as_mpl_transform.(g?(Rz(.i(.i(8RRR?RR'RlRR R[RRt getmaskarrayRYR]RRtfilledRqt concatenateRR<R RRRVR2R4RRR3RHR5R6R7R8Rt compressedt _transformRt TransformRJRR*RRRtvstackR RRtRRgRhRRR(-R-RDRERR:R9R;R<RRR RRRAR-txymaskR]Rt ravelmasktX1tY1tX2tY2tX3tY3tX4tY4tnpolyRbRRR%tecRR^R_RXRtptsttransformed_ptsRRRRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs    !j  44444444 ,&&&, <                 $     c O s4|js|jn|jdd}|jdd}|jdd}|jdd}|jdd}|jddj}|jdt} |jd d |d k} |jd d | |\} } } | j\}}| j } | j } | j } t j ||dfdt }| |dddf<| |dddft tick_righttset_label_positiontset_offset_positiont tick_leftR=t set_visible(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyttwinxXs  cC sV|jd|dt}|jj|jjd|jj|jjt|S(s Call signature:: ax = twiny() create a twin of Axes for generating a plot with a shared y-axis but independent x axis. The x-axis of self will have ticks on bottom and the returned axes will have ticks on the top. .. note:: For those who are 'picking' artists while using twiny, pick events are only called for the artists in the top-most axes. RRR(RR R=ttick_topRt tick_bottomR>R (R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyttwinyps   cC s|jS(s:Return a copy of the shared axes Grouper object for x axes(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_shared_x_axesscC s|jS(s:Return a copy of the shared axes Grouper object for y axes(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_shared_y_axessRrRTR_c=K s|js|jn|}td}|d4krEtd|n| d5krdtd | n| d6krtd | n|dkr| rt}nt|tjst|d rdtj |}|j dkr|j }n7|j dkr|j d|j d}n td|j d|j dkrtjd|j dddqn"g|D]}tj |^qk}t|}| dkrgt|D]}|jjj^q} n3tjj| } t| |krtdn|dk rt|tjs.t|d rtj|}|j dkrX|j }q|j dkrd|j df|_ qtdn"g|D]}tj |^q}t||krtdnxSt|D]5}t||t||krtdqqWn dg|}|jj}tj|pL|dk }|stj}tj }x8|D]0}t||j}t||j}qoW||f}nt d|}g}|}xt|D]}tj!|||d|||\}}|j"t#}|dkrFtj$t|d|j%}n|r| rtj&|}|j"t#||j'}n|r||7}||(n|j(|qW|r|rtj&|}x3|D](}|j"t#||dj'|(qWn|rt)d} tj*|r@|dkr@t)ddd} n|r}g|D]'}|tj&|| j+| ^qM}qg|D]}|| j+| ^q}ng}!|j,dr%|j-}"|j.}#|j/t0|j1t0tj&|}$| dk r$tdtd| }%n!t|dkr?d}%nd}%|dkr| r|%|$|}&|&}'|dkrd|%|$dd|}(nd}(t0}n+|dks|r|%|$}&d7\}(}'n| dks| dkr|(d|$7}(n| d kr|(|$7}(n| d kr/|j2})d}*n|j3})d}*xt4|| D]\}}+|dkrtj$t|tj#}n|r||},n|},|)|d |(|,|&d d!d"| d#|+i||*6}-|!j(|-|r||(n|(|'7}(qNW|j/|"|j1|#|j5n|j,dr& tj$d$t|d%tj#}tj$d$t|d%tj#}.||d |ddt|dd<|ddt|dd<|ddt|d!ddd|dt|d)| r | d kr2 |j6d"d&d'|j7j8j9}/n"|j:d"d(d'|j;j8j9}/|r tj|}0tj|0|0dk|/}1n d|/}1|1|1|.d<|.d||.d)td*|+qG Wnoxlt=t4|3|4| D]R\}}.}+dt|}5|!j(|j>||5 |.|5 d)t0d+|+d,t0q W|!j?| d kr t|dd-|1}6|jj@d}x'|D]}tjA||dk}q5 Wt|d-|1}t|6|}||f|j_@q& | d kr& t|dd-|1}7|jjBd}8x'|D]}tjA||dk}9q Wt|9d-|1}9t|7|9}9|9|8f|j_Bq& n|dkr> dg}:n?tC|rV |g}:n'tD|rq tE|}:n td.t|:|kr |:dg|t|:7}:nxt4|!|:D]\}-};|-r |-d}<|<jF||;dk r|<jG|;n|<jHt0x/|-dD] }<|<jF||<jGd/qWq q W|r| d kr|jI|ddf|ddfgd0t0q|jId|dfd|dfgd1t0n|dkr|d|tjJd2|!dfS||tjJd3|!fSdS(8s Plot a histogram. Compute and draw the histogram of *x*. The return value is a tuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*, [*patches0*, *patches1*,...]) if the input contains multiple data. Multiple data can be provided via *x* as a list of datasets of potentially different length ([*x0*, *x1*, ...]), or as a 2-D ndarray in which each column is a dataset. Note that the ndarray form is transposed relative to the list form. Masked arrays are not supported at present. Parameters ---------- x : array_like, shape (n, ) Input values. bins : integer or array_like, optional, default: 10 If an integer is given, `bins + 1` bin edges are returned, consistently with :func:`numpy.histogram` for numpy version >= 1.3. Unequally spaced bins are supported if `bins` is a sequence. range : tuple, optional, default: None The lower and upper range of the bins. Lower and upper outliers are ignored. If not provided, `range` is (x.min(), x.max()). Range has no effect if `bins` is a sequence. If `bins` is a sequence or `range` is specified, autoscaling is based on the specified bin range instead of the range of x. normed : boolean, optional, default: False If `True`, the first element of the return tuple will be the counts normalized to form a probability density, i.e., ``n/(len(x)`dbin)``, ie the integral of the histogram will sum to 1. If *stacked* is also *True*, the sum of the histograms is normalized to 1. weights : array_like, shape (n, ), optional, default: None An array of weights, of the same shape as `x`. Each value in `x` only contributes its associated weight towards the bin count (instead of 1). If `normed` is True, the weights are normalized, so that the integral of the density over the range remains 1. cumulative : boolean, optional, default : True If `True`, then a histogram is computed where each bin gives the counts in that bin plus all bins for smaller values. The last bin gives the total number of datapoints. If `normed` is also `True` then the histogram is normalized such that the last bin equals 1. If `cumulative` evaluates to less than 0 (e.g., -1), the direction of accumulation is reversed. In this case, if `normed` is also `True`, then the histogram is normalized such that the first bin equals 1. histtype : ['bar' | 'barstacked' | 'step' | 'stepfilled'], optional The type of histogram to draw. - 'bar' is a traditional bar-type histogram. If multiple data are given the bars are aranged side by side. - 'barstacked' is a bar-type histogram where multiple data are stacked on top of each other. - 'step' generates a lineplot that is by default unfilled. - 'stepfilled' generates a lineplot that is by default filled. align : ['left' | 'mid' | 'right'], optional, default: 'mid' Controls how the histogram is plotted. - 'left': bars are centered on the left bin edges. - 'mid': bars are centered between the bin edges. - 'right': bars are centered on the right bin edges. orientation : ['horizontal' | 'vertical'], optional If 'horizontal', `~matplotlib.pyplot.barh` will be used for bar-type histograms and the *bottom* kwarg will be the left edges. rwidth : scalar, optional, default: None The relative width of the bars as a fraction of the bin width. If `None`, automatically compute the width. Ignored if `histtype` = 'step' or 'stepfilled'. log : boolean, optional, default : False If `True`, the histogram axis will be set to a log scale. If `log` is `True` and `x` is a 1D array, empty bins will be filtered out and only the non-empty (`n`, `bins`, `patches`) will be returned. color : color or array_like of colors, optional, default: None Color spec or sequence of color specs, one per dataset. Default (`None`) uses the standard line color sequence. label : string, optional, default: '' String, or sequence of strings to match multiple datasets. Bar charts yield multiple patches per dataset, but only the first gets the label, so that the legend command will work as expected. stacked : boolean, optional, default : False If `True`, multiple data are stacked on top of each other If `False` multiple data are aranged side by side if histtype is 'bar' or on top of each other if histtype is 'step' Returns ------- tuple : (n, bins, patches) or ([n0, n1, ...], bins, [patches0, patches1,...]) Other Parameters ---------------- kwargs : `~matplotlib.patches.Patch` properties See also -------- hist2d : 2D histograms Notes ----- Until numpy release 1.5, the underlying numpy histogram function was incorrect with `normed`=`True` if bin sizes were unequal. MPL inherited that error. It is now corrected within MPL when using earlier numpy versions. Examples -------- .. plot:: mpl_examples/statistics/histogram_demo_features.py RRrt barstackedRVt stepfilledshisttype %s is not recognizedRRTRs align kwarg %s is not recognizedRR_s&orientation kwarg %s is not recognizediiisx must be 1D or 2DsX2D hist input should be nsamples x nvariables; this looks transposed (shape is %d x %d)Nis+color kwarg must have one color per datasetsweights must be 1D or 2Ds'weights should have the same shape as xtweightsg?gg?gR^g?RR]RRR#iiR,RaR0RjRiRWRSg?s4invalid label: must be string or sequence of stringsRCRRtPatchsLists of Patches(sbarRsstepR(sleftsmidsright(s horizontalsvertical(gg(KRRt __builtins__RR RRYtndarrayRRR\R RR[RRRqRRvR>R6RdRRRdRRRR'tinfRRwRzt histogramRRtRRpRYRRxtslicet is_numlikeRRMRRRR RRsRrRrRRR=t_scaletbaseRR>R0treversedRStreverseR%RgR(R R,RcRRtset_snapRR(=R-R^R\RR=Rt cumulativeRthisttypeR]RtrwidthRR#RtstackedREt bin_rangeRR`RnRtwit _saved_boundst binsgivenRxRyt hist_kwargsRntmlastRtdbtslcRt_saved_autoscalext_saved_autoscaleyttotwidthtdrRtdwtboffsett_barfunct bottom_kwargR%RRNR_tlogbasetndataRxRStxvalstyvalstsplittxmin0tymin0R{RzRtlblR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pythists       #  "  + # "      ) "      ) 7*                       ##G:       :C (  (                   ** !c  K s|} td}tj||d|d| d|d|\} } } |dk rbd| | |ktwindowtnoverlaptpad_totsidest scale_by_freqREtpxxtfreqst psd_unitsR;R<tintvtlogiRVR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRG!s,4           + c  K s)|js|jntj|||||||| | | \} }t|f| _||7}|j|dtjtj | | |j d|j d|j t |jj\}}||}dttj|}tjtj|tj|d|}|j|| |fS(s Plot cross-spectral density. Call signature:: csd(x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none, window=mlab.window_hanning, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, **kwargs) The cross spectral density :math:`P_{xy}` by Welch's average periodogram method. The vectors *x* and *y* are divided into *NFFT* length segments. Each segment is detrended by function *detrend* and windowed by function *window*. The product of the direct FFTs of *x* and *y* are averaged over each segment to compute :math:`P_{xy}`, with a scaling to correct for power loss due to windowing. Returns the tuple (*Pxy*, *freqs*). *P* is the cross spectrum (complex valued), and :math:`10\log_{10}|P_{xy}|` is plotted. %(PSD)s *noverlap*: integer The number of points of overlap between blocks. The default value is 0 (no overlap). *Fc*: integer The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. References: Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John Wiley & Sons (1986) kwargs control the Line2D properties: %(Line2D)s **Example:** .. plot:: mpl_examples/pylab_examples/csd_demo.py .. seealso: :meth:`psd` For a description of the optional parameters. i RFsCross Spectrum Magnitude (dB)i(RRRtcsdRqR[R)RYRtabsoluteRRRR RR(RRsRvRORHR(R-R^R_RIRJRKR>RLRMRNRORPREtpxyRRR;R<RTRVR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRV"s 6   )    + c  K s|js|jntj|||||||| \} }||7}|j|| | |jd|jd|jt| |fS(s} Plot the coherence between *x* and *y*. Call signature:: cohere(x, y, NFFT=256, Fs=2, Fc=0, detrend = mlab.detrend_none, window = mlab.window_hanning, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, **kwargs) Plot the coherence between *x* and *y*. Coherence is the normalized cross spectral density: .. math:: C_{xy} = \frac{|P_{xy}|^2}{P_{xx}P_{yy}} %(PSD)s *noverlap*: integer The number of points of overlap between blocks. The default value is 0 (no overlap). *Fc*: integer The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. The return value is a tuple (*Cxy*, *f*), where *f* are the frequencies of the coherence vector. kwargs are applied to the lines. References: * Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John Wiley & Sons (1986) kwargs control the :class:`~matplotlib.lines.Line2D` properties of the coherence plot: %(Line2D)s **Example:** .. plot:: mpl_examples/pylab_examples/cohere_demo.py RFt Coherence( RRRtcohereR)RRRR (R-R^R_RIRJRKR>RLRMRNRORPREtcxyRR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRZ]"s3      ic  K s|js|jntj||||||| | | \}}}dtj|}tj|}| dkrdtj|f} n| \}}||7}|||d|df}|j ||d|| }|j d||||fS(sE Plot a spectrogram. Call signature:: specgram(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none, window=mlab.window_hanning, noverlap=128, cmap=None, xextent=None, pad_to=None, sides='default', scale_by_freq=None, **kwargs) Compute and plot a spectrogram of data in *x*. Data are split into *NFFT* length segments and the PSD of each section is computed. The windowing function *window* is applied to each segment, and the amount of overlap of each segment is specified with *noverlap*. The spectrogram is plotted in decibels as a colormap (using imshow). %(PSD)s *noverlap*: integer The number of points of overlap between blocks. The default value is 128. *Fc*: integer The center frequency of *x* (defaults to 0), which offsets the y extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. *cmap*: A :class:`matplotlib.colors.Colormap` instance; if *None*, use default determined by rc *xextent*: The image extent along the x-axis. xextent = (xmin,xmax) The default is (0,max(bins)), where bins is the return value from :func:`~matplotlib.mlab.specgram` *kwargs*: Additional kwargs are passed on to imshow which makes the specgram image Return value is (*Pxx*, *freqs*, *bins*, *im*): - *bins* are the time points the spectrogram is calculated over - *freqs* is an array of frequencies - *Pxx* is an array of shape `(len(times), len(freqs))` of power - *im* is a :class:`~matplotlib.image.AxesImage` instance .. note:: If *x* is real (i.e. non-complex), only the positive spectrum is shown. If *x* is complex, both positive and negative parts of the spectrum are shown. This can be overridden using the *sides* keyword argument. Also note that while the plot is in dB, the *Pxx* array returned is linear in power. **Example:** .. plot:: mpl_examples/pylab_examples/specgram_demo.py g$@iiR]RN( RRRtspecgramRYRtflipudRRhRR(R-R^RIRJRKR>RLRMR9txextentRNRORPREtPxxRRR\tZRxRyR]R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR\"sE      Rkc K s|d#kr0|d#kr0t|dr0d}n|d#kr|d#krtj|}tj||k}d|krtjddgdd|d precision` will be plotted. For :class:`scipy.sparse.spmatrix` instances, there is a special case: if *precision* is 'present', any value present in the array will be plotted, even if it is identically zero. The array will be plotted as it would be printed, with the first index (row) increasing down and the second index (column) increasing to the right. By default aspect is 'equal', so that each array element occupies a square space; set the aspect kwarg to 'auto' to allow the plot to fill the plot box, or to any scalar number to specify the aspect ratio of an array element directly. Two plotting styles are available: image or marker. Both are available for full arrays, but only the marker style works for :class:`scipy.sparse.spmatrix` instances. If *marker* and *markersize* are *None*, an image will be returned and any remaining kwargs are passed to :func:`~matplotlib.pyplot.imshow`; else, a :class:`~matplotlib.lines.Line2D` object will be returned with the value of marker determining the marker type, and any remaining kwargs passed to the :meth:`~matplotlib.axes.Axes.plot` method. If *marker* and *markersize* are *None*, useful kwargs include: * *cmap* * *alpha* .. seealso:: :func:`~matplotlib.pyplot.imshow` For image options. For controlling colors, e.g., cyan background and red marks, use:: cmap = mcolors.ListedColormap(['c','r']) If *marker* or *markersize* is not *None*, useful kwargs include: * *marker* * *markersize* * *color* Useful values for *marker* include: * 's' square (default) * 'o' circle * '.' point * ',' pixel .. seealso:: :func:`~matplotlib.pyplot.plot` For plotting options ttocooRR9RRzRAtbinarygg?RRRjR]RRtpresenti R!RR"t markersizeRxRyRzR{g?Rtnbinsi tstepsiiitintegerN(RRJRYRRWRtListedColormapR[RRaR RwRtnonzeroRReRR,R8RRJtset_yR=R tset_ticks_positionR5tmtickert MaxNLocatorR R>(R-R`t precisionR"RdRjRER-RRR]RFR%R_R^Ritmarks((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytspy"sZJ'                c K stj|}|j\}}idd6dd6dd6}|j||j||}|jjd|jj|jj d|jj t j d d d d d ddgdt |jj t j d d d d d ddgdt |S(s Plot a matrix or array as an image. The matrix will be shown the way it would be printed, with the first row at the top. Row and column numbering is zero-based. Parameters ---------- Z : array_like shape (n, m) The matrix to be displayed. Returns ------- image : `~matplotlib.image.AxesImage` Other parameters ---------------- kwargs : `~matplotlib.axes.Axes.imshow` arguments Sets `origin` to 'upper', 'interpolation' to 'nearest' and 'aspect' to equal. See also -------- imshow : plot an image Examples -------- .. plot:: mpl_examples/pylab_examples/matshow.py RRRRRkRjg?RRei Rfiiii Rg(RYRR[RRRJRjR=R RkR5RlRmR R>(R-R`RERRRfR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytmatshowq#s"      cC s)g|jD]}|jr |^q S(N(RR2(R-R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytget_default_bbox_extra_artists#sc C sg}|jsdS|j}|rM|rM|||}|j|n |j|j|j||jjr|j|jj|n|jjr|j|jj|n|jjr|j|jj|n|j j |}|r|j|n|j j |}|r>|j|nt j jg|D]*}|jdksr|jdkrN|^qN} | S(s Return the tight bounding box of the axes. The dimension of the Bbox in canvas coordinate. If *call_axes_locator* is *False*, it does not call the _axes_locator attribute, which is necessary to get the correct bounding box. ``call_axes_locator==False`` can be used if the caller is only intereted in the relative size of the tightbbox compared to the axes bbox. iN(R2RRRRxRRJRKRLR=t get_tightbboxR>RRRRR( R-RNtcall_axes_locatorR,RR tbb_xaxistbb_yaxisRct_bbox((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRs#s0      :cC sqxj|j|jfD]V}|jdkrV|j}|jtj|j|jq|jtj qWdS(s(Add autoscaling minor ticks to the axes.RN( R=R>R2RR6Rlt LogLocatorRtsubstAutoMinorLocator(R-R*R((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt minorticks_on#s  "cC s0|jjtj|jjtjdS(s!Remove minor ticks from the axes.N(R=R6Rlt NullLocatorR>(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytminorticks_off#scO stj|||S(N(tmtrit tricontour(R-RDRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR#scO stj|||S(N(R~t tricontourf(R-RDRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR#scO stj|||S(N(R~t tripcolor(R-RDRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR#scO stj|||dS(N(R~ttriplot(R-RDRE((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR#s(RRRRAR'tGrouperRRRRR R.R3RRRRRRRRRRRR RR R RRRRRRRaR,RbRdRfRRpRmRrRR~RRRRRRRRRRRRRRRRRRRRRRRRRRRR RRRRRRRRRRRRR!RRR>RZR[R\R]R^R_R`Rtdedent_interpdRRqRuR~RRRRRRRtRR+R,RRRRRRRRRRRRRRuRR7R8RRRRRRRRRRRRRRRRRRRRRRRRRR RRRRRRRRR RRRRRtdedentR RR%R)R)R1R3R4R6Rt detrend_noneR5RLRORPRVRrRsRxRRRfR#R@RYRRRRRRt quiverkey_docRRt quiver_docRRRRRRSRRRt staticmethodRRRRRRRt contour_docRRRRRR RRRR=RDtwindow_hanningRGRVRZR\RpRqRrRsR{R}RR~t TriContourSetttricontour_docRRR(((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRKst       (        !        ;     I               -     +       9  )>z     ' X' L       Z          [             G    5  R??77WY H=44? W   "H- W    J  _     $     3m   :             Y M I =  T  { 1  .     (tGridSpect SubplotSpect SubplotBasecB seZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZRS(s Base class for subplots, which are :class:`Axes` instances with additional methods to facilitate generating and manipulating a set of :class:`Axes` within a figure. c O s||_t|dkrt|dtr>|d|_qy2tt|d}tt|\}}}Wntk rtdnXt |||d|_nt|dkrq|\}}}t|}t|}t|t rNt|dkrNg|D]}t|^q}t |||dd|d!|_qt ||t|d|_ntd|f|j |j j |||j|dS(s *fig* is a :class:`matplotlib.figure.Figure` instance. *args* is the tuple (*numRows*, *numCols*, *plotNum*), where the array of subplots in the figure has dimensions *numRows*, *numCols*, and where *plotNum* is the number of the subplot being created. *plotNum* starts at 1 in the upper left corner and increases to the right. If *numRows* <= *numCols* <= *plotNum* < 10, *args* can be the decimal integer *numRows* * 100 + *numCols* * 10 + *plotNum*. iis4Single argument to subplot must be a 3-digit integeriis"Illegal argument(s) to subplot: %sN(RRqRRt _subplotspecRRtmapRRRt update_paramst _axes_classR.tfigbox( R-RRDRERtrowstcolstnumRn((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR.#s,     !(# cC s`d}g|jjD]}||r|^qd}t|f|jg}t|S(NcS st|tot|t S(N(t issubclassRR(R%((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR/$si(t __class__tmrot!_PicklableSubplotClassConstructorR/R(R-tnot_subplotbaseR%t axes_classRW((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt __reduce__-$s  2cC s/|jj\}}}}|||dfS(s"get the subplot geometry, eg 2,2,3i(tget_subplotspect get_geometry(R-RRtnum1tnum2((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR7$scC s8t|||d|_|j|j|jdS(s2change subplot geometry, e.g., from 1,1,1 to 2,2,3iN(RRRR R(R-tnumrowstnumcolsR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytchange_geometry=$s cC s|jS(s8get the SubplotSpec instance associated with the subplot(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRC$scC s ||_dS(s8set the SubplotSpec instance associated with the subplotN(R(R-t subplotspec((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pytset_subplotspecG$scC s@|jj|jdt\|_|_|_|_|_dS(s0update the subplot position from fig.subplotparst return_allN( RRRR RtrowNumtcolNumRR(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRK$scC s |jdkS(Ni(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt is_first_colR$scC s |jdkS(Ni(R(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt is_first_rowU$scC s|j|jdkS(Ni(RR(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt is_last_rowX$scC s|j|jdkS(Ni(RR(R-((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt is_last_col[$scC sd|j}|j}x!|jD]}|j|q%Wx!|jD]}|j|qIWdS(s set the visible property on ticklabels so xticklabels are visible only if the subplot is in the last row and yticklabels are visible only if the subplot is in the first column N(RRRR R(R-tlastrowtfirstcolR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyt label_outer_$s   cO spddlm}|jf|}||j||\}}}t||j||}|jj||S(sN make a twinx axes of self. This is used for twinx and twiny. i(tprocess_projection_requirements(tmatplotlib.projectionsRRRtsubplot_class_factoryt add_subplot(R-RRERtprojection_classRNR((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyRm$s (RRRR.RRRRRRRRRRRR(((sI/opt/xtal/ccp4-6.5-linux32/lib/python2.7/site-packages/matplotlib/axes.pyR#s 0          cC sg|dkrt}ntj|}|dkrctd|jt|fi|d6}|t|s          T