a a@stdZddlmZddlZddlZddlZddlZddlmZddl Z ddl Z ddl m Z mZmZmZddlmZddlmZddlmZddlmZddlmZddlm Z!ddl"m#Z$ddl%m&Z'ddl(m)Z*ddl+m,Z-ddlm.Z.m/Z/ddl0m1Z1m2Z2ddl+m3Z3dd l4m5Z5d d l6m7Z7d d l6m8Z8d d l6m9Z9ej:e;dgdgdgdGddde.Z Minor additions by Ben Axelrod Significant updates and revisions by Ben Root Module containing Axes3D, an object which can plot 3D objects on a 2D matplotlib figure. ) defaultdictN)Integral)_apicbook docstring_preprocess_data)AxesrcParams)_axis_method_wrapper_process_plot_format)Bbox) Triangulation)art3d)proj3d)axis3dxlimylimzlim)Zxlim3dZylim3dZzlim3dcsHeZdZdZdZdZeej d<ddddddd d fd d Z d dZ ddZ ddZ fddZddZddZeddZeddZejddd dedd Zejdd!d ded"d Zejddd ded#d Zdd$d%Zdd&d'Zdd(d)Zdfd+d, Zd-d.d/d0Zdd1d2Ze j!fd3d4Z"d5d6Z#d d7d8Z$d9d:Z%fd;d<Z&d=d>Z'fd?d@Z(dAdBZ)fdCdDZ*fdEdFZ+dGdHZ,dddd dIdJdKZ-d dMdNZ.d dOdPZ/d dQdRZ0dSdTZ1d dddUdVdWZ2ddddXdYdZZ3dddd[d\d]Z4d^d_Z5e6jj7je5_d`daZ8e6jj9je8_dbdcZ:dddeZ;dfdgZe?dlj@gd\e<_e=_e>_eddmZAeddnZBeddoZCeddpZDeddqZEeddrdsdtiduZFeddvZGeGjreGjeHIdw7_dxdyZJddzd{ZKd|d}ZLd~dZMddZNdddZOddZPddZQddZRfddZSddZTddZUddZVddZWddZXddZYddZZdddZ[ddZ\ddZ]ddZ^e_ddddddZ`dddZadfdd ZbddZcddZdddZedddZfdfdd ZgegZhejgZiddfdd ZjejZkejldddddddddddZmddZndddÄZoejlddddddńZpddddddƜddȄZqddd˄Zrddd̈́ZsdddτZtdddфZuevd*ddddҜfddԄ ZwewZxevd*ddddҜfddք Zydd؄Zzevdddٜfddۄ Z{e{Z|evdddٜfdd݄ Z}dfdd Z~evgdddfdd ZeZevdfdd Zevd ddZd!fdd Zevd-ddd*dddZeZddd ddddZevgddd"ddZd#d*dfdd ZevdddddddddZeZZS($Axes3Dz 3D axes object. 3dxyzrNiperspT)azimelevsharez proj_type box_aspectcomputed_zorderc s|durgd}||_||_||||_t|_t|_t|_t|_ | |j|j||_ |dur|j d ||d|_| dd} tj||g| Rd|d| t|d|_d|_||jjjj|jjd|j|jjd |j|jjd |jh| |j!"d |j#$%d d g} | d| d \|_&|_'|j(dd)d| rt*j+dddd|,|dS)at Parameters ---------- fig : Figure The parent figure. rect : (float, float, float, float) The ``(left, bottom, width, height)`` axes position. azim : float, default: -60 Azimuthal viewing angle. elev : float, default: 30 Elevation viewing angle. sharez : Axes3D, optional Other axes to share z-limits with. proj_type : {'persp', 'ortho'} The projection type, default 'persp'. computed_zorder : bool, default: True If True, the draw order is computed based on the average position of the `.Artist`\s along the view direction. Set to False if you want to manually control the order in which Artists are drawn on top of each other using their *zorder* attribute. This can be used for fine-tuning if the automatic order does not produce the desired result. Note however, that a manual zorder will only be correct for a limited view angle. If the figure is rotated by the user, it will look wrong from certain angles. auto_add_to_figure : bool, default: True Prior to Matplotlib 3.4 Axes3D would add themselves to their host Figure on init. Other Axes class do not do this. This behavior is deprecated in 3.4, the default will change to False in 3.5. The keyword will be undocumented and a non-False value will be an error in 3.6. **kwargs Other optional keyword arguments: %(Axes3D:kwdoc)s N)r#?r$rdatalimauto_add_to_figureT)frameonr!motion_notify_eventbutton_press_eventbutton_release_eventrrr)rrrF3.4z3.6aQAxes3D(fig) adding itself to the figure is deprecated since %(since)s. Pass the keyword argument auto_add_to_figure=False and use fig.add_axes(ax) to suppress this warning. The default value of auto_add_to_figure will change to False in mpl3.5 and True values will no longer work %(removal)s. This is consistent with other Axes classes.)removalmessage)- initial_azim initial_elev set_proj_typer"r unit xy_viewLim zz_viewLim xy_dataLim zz_dataLim view_init_sharez _shared_axesjoin _adjustablepopsuper__init__ set_axis_off set_axis_onM fmt_zdata mouse_initfigurecanvas callbacks _pickled_cidsupdate mpl_connect_on_move _button_press_button_release set_top_viewpatch set_linewidth transLimitsinverted transform _pseudo_w _pseudo_hspines set_visiblerwarn_deprecatedadd_axes) selffigrectrrrr r!r"argskwargsr&Z pseudo_bbox __class__k/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/mpl_toolkits/mplot3d/axes3d.pyr>8sf,          zAxes3D.__init__cCsd|_d|_dS)NFT _axis3donstalerYr`r`rar?szAxes3D.set_axis_offcCsd|_d|_dS)NTrbrer`r`rar@szAxes3D.set_axis_oncCs |j|S)zs For artists in an axes, if the zaxis has units support, convert *z* using zaxis unit type )zaxis convert_units)rYrr`r`raconvert_zunitsszAxes3D.convert_zunitscsTd|j}d|j}d|j}d|j}tj| |ddtj| |dddS)Ngffffff?g?auto)distr=set_xlimset_ylim)rYZxdwlZxdwZydwlZydwr^r`rarMs     zAxes3D.set_top_viewcCsptd|jj|jj||_td|jj|jj||_t d|j j|j j||_ |j|j|j fD] }| q^dS)z5Init 3D axes; overrides creation of regular X/Y axes.rrrN)rXAxisr3 intervalxr5xaxisYAxis intervalyyaxisZZAxisr4r6rfZinit3d)rYaxr`r`ra _init_axiss   zAxes3D._init_axiscCs|jS)z0Return the ``ZAxis`` (`~.axis3d.Axis`) instance.rfrer`r`ra get_zaxisszAxes3D.get_zaxisrf get_gridlines get_ticklines3.1rp) alternativependingcCs|jSN)rprer`r`razAxes3D.rscCs|jSr})rsrer`r`rar~rcCs|jSr}rvrer`r`rar~rc Cs\|p |\}}}}}}|||f|||f|||f|||f|||f|||f|||f|||fgSr}) get_w_lims)rYvalsminxmaxxminymaxyminzmaxzr`r`ra unit_cubeszAxes3D.unit_cubecCs(|dur|j}||}t||}|Sr})rArrZ proj_points)rYrrAZxyzsZtcuber`r`ra tunit_cubes   zAxes3D.tunit_cubecCs|||}|d|df|d|df|d|df|d|df|d|df|d|df|d|df|d|df|d|df|d|df|d|df|d|dfg }|S) Nrr)r)rYrrAtcedgesr`r`ra tunit_edgess zAxes3D.tunit_edgesFcs0|dkrtd|dtj||||ddS)ai Set the aspect ratios. Axes 3D does not current support any aspect but 'auto' which fills the axes with the data limits. To simulate having equal aspect in data space, set the ratio of your data limits to match the value of `.get_box_aspect`. To control box aspect ratios use `~.Axes3D.set_box_aspect`. Parameters ---------- aspect : {'auto'} Possible values: ========= ================================================== value description ========= ================================================== 'auto' automatic; fill the position rectangle with data. ========= ================================================== adjustable : None Currently ignored by Axes3D If not *None*, this defines which parameter will be adjusted to meet the required aspect. See `.set_adjustable` for further details. anchor : None or str or 2-tuple of float, optional If not *None*, this defines where the Axes will be drawn if there is extra space due to aspect constraints. The most common way to to specify the anchor are abbreviations of cardinal directions: ===== ===================== value description ===== ===================== 'C' centered 'SW' lower left corner 'S' middle of bottom edge 'SE' lower right corner etc. ===== ===================== See `~.Axes.set_anchor` for further details. share : bool, default: False If ``True``, apply the settings to all shared Axes. See Also -------- mpl_toolkits.mplot3d.axes3d.Axes3D.set_box_aspect rjzIAxes3D currently only supports the aspect argument 'auto'. You passed in .) adjustableanchorshareN)NotImplementedErrorr= set_aspect)rYaspectrrrr^r`rars5zAxes3D.set_aspectr)zoomcCsj|durtjdtd}n*|}tj|td}|jdkrBtd||d|tj|9}||_d|_dS)ao Set the axes box aspect. The box aspect is the ratio of height to width in display units for each face of the box when viewed perpendicular to that face. This is not to be confused with the data aspect (which for Axes3D is always 'auto'). The default ratios are 4:4:3 (x:y:z). To simulate having equal aspect in data space, set the box aspect to match your data range in each dimension. *zoom* controls the overall size of the Axes3D in the figure. Parameters ---------- aspect : 3-tuple of floats or None Changes the physical dimensions of the Axes3D, such that the ratio of the axis lengths in display units is x:y:z. If None, defaults to 4:4:3 zoom : float Control overall size of the Axes3D in the figure. N)rrrdtype)rz?You must pass a 3-tuple that can be cast to floats. You passed gIr|E?T) npasarrayfloatshape ValueErrorlinalgnorm _box_aspectrd)rYrrZ orig_aspectr`r`raset_box_aspect>s zAxes3D.set_box_aspectcCsx|dur|jdd}|j}tjdddd|}|j|j}d}| }| |||}| | | |ddS)NT)originalrractive) get_position get_figuretransSubfigure mtransformsr from_bounds transformedheightwidthfrozenshrunk_to_aspect _set_positionanchored get_anchor)rYpositiontransbb fig_aspectr!pbpb1r`r`ra apply_aspecths   zAxes3D.apply_aspectc sjd_}|r<|}|n_fdddD}tj t fi|fdd}ddj D}j r t d dDd }|}} t||d d D]:} t| tjr|| _|d 7}qt| tjr| | _| d 7} qn|D]} | qjr\D]} | q0D]} | qJtWdn1s~0YdS) NFcs:i|]2}|tjd|d|dtt|fddqS)r,z self.axes.)namer{cSs|Sr}r`)rY_valuer`r`rar~rz(Axes3D.draw...)r deprecatedpropertygetattr).0rrer`ra s   zAxes3D.draw..)rAvveceyeget_axis_positionc sTzt|j}|Wn.ttfyFtjddd|YS0|SdS)a7 Call `do_3d_projection` on an *artist*, and warn if passing *renderer*. Attempt to bind the empty signature first, so external Artists can avoid the deprecation warning if they support the new calling convention. r,zvThe 'renderer' parameter of do_3d_projection() was deprecated in Matplotlib %(since)s and will be removed %(removal)s.r.N)inspect signaturedo_3d_projectionbindr TypeErrorrrW)artistr)rendererr`rars   z%Axes3D.draw..do_3d_projectioncss$|]}t|tjtjfr|VqdSr}) isinstancemcoll CollectionmpatchesPatch)rrr`r`ra szAxes3D.draw..css|]}|VqdSr}) get_zorder)raxisr`r`rarsrT)keyreverse)_unstale_viewLimrNdraw_frameonget_axes_locatorrget_projrAr _setattr_cmtype _childrenr"max_get_axis_listsortedrrrzorderrrrrcZ draw_paner=) rYrlocatorposZprops3drZcollections_and_patchesZ zorder_offsetZcollection_zorderZ patch_zorderrrr^)rrYrarysT              z Axes3D.drawcCsh|}|||j}|dd|ddk}|dd|ddk}|dd|ddk}|||fS)Nrrrr)rrrA)rYrrZxhighZyhighZzhighr`r`rars zAxes3D.get_axis_positioncCsV|durtj|j|tdStj||d||j|dk|dk|dkddS)N)event) axis_namerrrscalexscaleyscalez) functoolspartial_unit_change_handlerobjectr check_in_list _get_axis_maprelim_request_autoscale_view)rYrrr`r`rars  zAxes3D._unit_change_handlercKsdSr}r`)rYxysr]r`r`raupdate_datalimszAxes3D.update_datalimcsto|Sr})r=get_autoscale_onget_autoscalez_onrer^r`rarszAxes3D.get_autoscale_oncCs|jS)z(Return whether the z-axis is autoscaled. _autoscaleZonrer`r`rarszAxes3D.get_autoscalez_oncst|||dSr})r=set_autoscale_onset_autoscalez_onrYbr^r`rars zAxes3D.set_autoscale_oncCs ||_dS)z Set whether the z-axis is autoscaled on the next draw or call to `.Axes.autoscale_view`. Parameters ---------- b : bool Nrrr`r`rars zAxes3D.set_autoscalez_oncs$|jd}t|||jd<dSNr)_stale_viewlimsr= set_xmarginrYmrr^r`rar s  zAxes3D.set_xmargincs$|jd}t|||jd<dSr)rr= set_ymarginrr^r`rars  zAxes3D.set_ymargincCs8|dks|dkrtd||_|jddddd|_dS)z Set padding of Z 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 rrzmargin must be in range 0 to 1FTrN)r_zmarginrrd)rYrr`r`ra set_zmargins zAxes3D.set_zmargin)rrrtightcGs|r&|dur&|dur&|dur&tdnBt|dkrD|d}}}n$t|dkr\|\}}}n |rhtd|dur|dur|dur|durtd|d |j|j|jfS|dur|||dur|||dur| ||j ||du|du|dud dS) a Convenience method to set or retrieve autoscaling margins. Call signatures:: margins() returns xmargin, ymargin, zmargin :: margins(margin) margins(xmargin, ymargin, zmargin) margins(x=xmargin, y=ymargin, z=zmargin) margins(..., tight=False) All forms above set the xmargin, ymargin and zmargin parameters. All keyword parameters are optional. A single positional argument specifies xmargin, ymargin and zmargin. Passing both positional and keyword arguments for xmargin, ymargin, and/or zmargin is invalid. 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. NzECannot pass both positional and keyword arguments for x, y, and/or z.rrrzYMust pass a single positional argument for all margins, or one for each margin (x, y, z).Tzignoring tight=z in get moderrrr) rlenr warn_external_xmargin_ymarginrrrrautoscale_view)rYrrrrmarginsr`r`rar *s,&       zAxes3D.marginsbothcCs|durd}d}d}nT|dvr.t||_}nd}|dvrJt||_}nd}|dvrft||_}nd}|j||||ddS)a9 Convenience method for simple axis view autoscaling. See :meth:`matplotlib.axes.Axes.autoscale` for full explanation. Note that this function behaves the same, but for all three axes. Therefore, 'z' can be passed for *axis*, and 'both' applies to all three axes. NTrrFrrrrr)bool _autoscaleXon _autoscaleYonrr)rYenablerrrrrr`r`ra autoscalels  zAxes3D.autoscalecCst|t|kr<|jtt|t|g| n |j|| |j|| |durt|j|| | dSr}) rrr5update_from_data_xy column_stackravelupdate_from_data_xupdate_from_data_yr6r )rYXYZhad_datar`r`raauto_scale_xyzszAxes3D.auto_scale_xyzcCs|durL|j}|sZ|jD]0}t|tjr.d}qt|tjtjfrd}qZqnt |}|_|r|j r|j d |j j\}}|j} | ||\}}|jdkr|||j} || 8}|| 7}|s| ||\}}||||rn|jrn|j d |j j\} } |j} | | | \} } |jdkrL| | |j} | | 8} | | 7} |sb| | | \} } || | |r|jr|j d |jj\}}|j}|||\}}|jdkr|||j} || 8}|| 7}|s|||\}}|||dS)a Autoscale the view limits using the data limits. See :meth:`matplotlib.axes.Axes.autoscale_view` for documentation. Note that this function applies to the 3D axes, and as such adds the *scalez* to the function arguments. NTFrrrr)_tightrrmimage AxesImagemlinesLine2Drrrrr9cleanr5rorpget_major_locator nonsingularr  view_limits set_xboundrrrrsr  set_yboundrr6rfr set_zbound)rYrrrrr!rx0x1Zxlocatordeltay0y1Zylocatorz0z1Zzlocatorr`r`rar s\               zAxes3D.autoscale_viewcCs4|\}}|\}}|\}}||||||fS)zGet 3D world limits.) get_xlim3d get_ylim3d get_zlim3d)rYrrrrrrr`r`rars   zAxes3D.get_w_lims)xminxmaxc Cs|durt|r|\}}|dur6|dur2td|}|durR|durNtd|}|jd||ffgdd|||j}|||j}|\}}|dur|}|dur|}||krtd|d||k} |j ||\}}|j ||\}}t ||gt| d \}}||f|j_|jd|D]} d| jd<q(|durNt||_|r|jd ||jd|D]>} | |urr| j|jjd|d | j|jkrr| jjqrd |_||fS) zm Set 3D x limits. See :meth:`matplotlib.axes.Axes.set_xlim` for full documentation. Nz"Cannot pass both `xmin` and `left`z#Cannot pass both `xmax` and `right`rFconvertz-Attempting to set identical left == right == > results in singular transformations; automatically expanding.r xlim_changedemitrjT)riterabler_process_unit_info_validate_converted_limitsconvert_xunitsget_xlimrr rpr'r(limit_range_for_scalerrr3ror9 get_siblingsrrrFprocessrlrDrE draw_idlerd) rYleftrightr?rjr7r8old_left old_rightrrtotherr`r`ra set_xlim3dsT       zAxes3D.set_xlim3d)yminymaxc Cs|durt|r|\}}|dur6|dur2td|}|durR|durNtd|}|jd||ffgdd|||j}|||j}|\}}|dur|}|dur|}||krtd|d||k} |j ||\}}|j ||\}}| r||}}||f|j _|jd|D]} d| jd<q |durFt||_|r|jd ||jd|D]>} | |urj| j|j jd|d | j|jkrj| jjqjd |_||fS) zm Set 3D y limits. See :meth:`matplotlib.axes.Axes.set_ylim` for full documentation. Nz$Cannot pass both `ymin` and `bottom`z!Cannot pass both `ymax` and `top`rFr9-Attempting to set identical bottom == top == r; ylim_changedr>T)rr@rrArBconvert_yunitsget_ylimrr rsr'r(rEr3rrr9rFrrrrFrGrmrDrErHrd) rYbottomtopr?rjrOrP old_bottomold_topswappedrtrMr`r`ra set_ylim3dsV        zAxes3D.set_ylim3d)zminzmaxc Cs|durt|r|\}}|dur6|dur2td|}|durR|durNtd|}|jd||ffgdd|||j}|||j}|\}}|dur|}|dur|}||krtd|d||k} |j ||\}}|j ||\}}| r||}}||f|j _|jd|D]} d| jd<q |durFt||_|r|jd ||jd|D]>} | |urj| j|j jd|d | j|jkrj| jjqjd |_||fS) zl Set 3D z limits. See :meth:`matplotlib.axes.Axes.set_ylim` for full documentation Nz$Cannot pass both `zmin` and `bottom`z!Cannot pass both `zmax` and `top`rFr9rQr;Z zlim_changedr>T)rr@rrArBrhget_zlimrr rfr'r(rEr4ror9rFrrrrFrGset_zlimrDrErHrd) rYrUrVr?rjr[r\rWrXrYrtrMr`r`ra set_zlim3dNsV        zAxes3D.set_zlim3dcCs t|jjSr})tupler3rorer`r`rar4szAxes3D.get_xlim3dcCs t|jjSr})r`r3rrrer`r`rar5szAxes3D.get_ylim3dcCs t|jjS)zGet 3D z limits.)r`r4rorer`r`rar6szAxes3D.get_zlim3dcCsddt|jS)Nz3 Return the zaxis scale string %s z, )r:mscaleget_scale_namesrf get_scalerer`r`ra get_zscales zAxes3D.get_zscalecKs4|jj|fi||jddd|d|_dS)NF)rrT)rp _set_scaler _update_transScalerdrYvaluer]r`r`ra set_xscaleszAxes3D.set_xscalecKs4|jj|fi||jddd|d|_dS)NF)rrT)rsrer rfrdrgr`r`ra set_yscaleszAxes3D.set_yscalecKs4|jj|fi||jddd|d|_dS)NF)rrT)rfrer rfrdrgr`r`ra set_zscaleszAxes3D.set_zscalea Set the {}-axis scale. Parameters ---------- value : {{"linear"}} The axis scale type to apply. 3D axes currently only support linear scales; other scales yield nonsensical results. **kwargs Keyword arguments are nominally forwarded to the scale class, but none of them is applicable for linear scales. get_ticklocs set_ticksget_majorticklabelsget_minorticklabelsget_ticklabels_set_ticklabelszAxis.set_tickszAxes3D.set_zticks)doc_sub axis_datez Notes ----- This function is merely provided for completeness, but 3D axes do not support dates for ticks, and so this may not work as expected. cOsdS)z:Currently not implemented for 3D axes, and returns *None*.Nr`)rYr\r]r`r`raclabelsz Axes3D.clabelcCsTd|_|dur|j|_n||_|dur0|j|_n||_tjtdddd|d|_dS)a Set the elevation and azimuth of the axes in degrees (not radians). This can be used to rotate the axes programmatically. Parameters ---------- elev : float, default: None The elevation angle in the vertical plane in degrees. If None then the initial value as specified in the `Axes3D` constructor is used. azim : float, default: None The azimuth angle in the horizontal plane in degrees. If None then the initial value as specified in the `Axes3D` constructor is used. vertical_axis : {"z", "x", "y"}, default: "z" The axis to align vertically. *azim* rotates about this axis. Nrrrr) vertical_axis) rkr0rr/rr check_getitemdict_vertical_axis)rYrrrvr`r`rar7s  zAxes3D.view_initcCstjtjtjd|d|_dS)zx Set the projection type. Parameters ---------- proj_type : {'persp', 'ortho'} )rortho)r N)rrwrZpersp_transformationortho_transformation _projection)rYr r`r`rar1s zAxes3D.set_proj_typecCst||jdS)z1Roll arrays to match the different vertical axis.r)rrollry)rYarrr`r`ra_roll_to_verticalszAxes3D._roll_to_verticalcCs2||j}tjg|||Rd|i}d|}t|j }t|j }t |t |}t |t |}t |}||||g} ||j | } | |_|| |_|jtj|j|_td} t|dtjkrdnd| |j<t| || } ||j |j } t| |}t| |}|S)z?Create the projection matrix from the current viewing position.Z pb_aspect?rr)rrrZworld_transformationr4r5r6rdeg2radrrcossinrkrrrrzerosabspiryZview_transformationr|dot)rYr!ZworldMRZelev_radZazim_radp0p1p2psrVZviewMZprojMM0rAr`r`rar s8         zAxes3D.get_projrcCs*d|_t||_t||_dS)aa Set the mouse buttons for 3D rotation and zooming. Parameters ---------- rotate_btn : int or list of int, default: 1 The mouse button or buttons to use for 3D rotation of the axes. zoom_btn : int or list of int, default: 3 The mouse button or buttons to use to zoom the 3D axes. N)button_pressedr atleast_1dtolist _rotate_btn _zoom_btn)rY rotate_btnzoom_btnr`r`rarCBs zAxes3D.mouse_initcCs|jggddS)z2Disable mouse buttons for 3D rotation and zooming.)rrN)rCrer`r`radisable_mouse_rotationTszAxes3D.disable_mouse_rotationcCsdS)z Return whether this axes supports the zoom box button functionality. 3D axes objects do not use the zoom box button. Fr`rer`r`racan_zoomXszAxes3D.can_zoomcCsdS)z Return whether this axes supports the pan/zoom button functionality. 3D axes objects do not use the pan/zoom button. Fr`rer`r`racan_pan`szAxes3D.can_pancst|j|jdurp|jjj|j_|jjj|j_|j\}}|j||ddd|j |jj n0|j dz|ddWnt yYn0d|_ |j tjurtd|_nd|_|td dS) NFr>linearrrTz axes.zmarginr#z axes3d.grid)r=clarfclearr8majorminorr]r^rercrrr|rr{r rgrid)rYr2r3r^r`rarhs$       z Axes3D.clacCsT|j|krP|j|_|j|j|_|_t|jj d}|rP| durP|jj j dSNtoolbar) inaxesbuttonrxdataydatasxsyrrDrE _nav_stackr push_currentrYrrr`r`rarKs  zAxes3D._button_presscCs*d|_t|jjd}|r&|jjjdSr)rrrDrErrrr`r`rarLszAxes3D._button_releasecCs||||j|jfSr})rDrTr]rrrer`r`ra _get_viewszAxes3D._get_viewcCs.|\}}}}}|j|||d||_||_dS)N)rrr)setrr)rYviewrrrrrr`r`ra _set_viewszAxes3D._set_viewc Cs@z ||WSttfy:|jj}||}|YS0dS)z Return *z* string formatted. This function will use the :attr:`fmt_zdata` attribute if it is callable, else will fall back on the zaxis major formatter N)rBAttributeErrorrrfget_major_formatterformat_data_short)rYrfuncvalr`r`ra format_zdatas   zAxes3D.format_zdatacs|jdurdS|j|jvr.)rzx=%s, y=%s, z=%s)rArrrrreplaceminrrhypotrZ inv_transform format_xdata format_ydatar)rYrrrrr-r0r2r.r1r3d0d1dtrrrxsyszsr`rra format_coords,         zAxes3D.format_coordcCs|js dS|jdurdS|j|j}}|dur2dS||j||j}}|j}|j}|||_|_|j|jvr|dkr|dkrdSt |j ||d|_ t |j ||d|_ | d|_|jjn|jdkr |dkr|dkrdS|\}} } } } } d|||}d|||}t|j t|j }}| ||t|t||t|}| | | t||t|t|}| | | t|}|||| ||| || ||| || || |jjn|j|jvr|\}} } } } } d|||}| ||}| | |}| | |}|||| ||| || ||| || || |jjdS)z Mouse moving. By default, button-1 rotates and button-3 zooms; these buttons can be modified via `mouse_init`. NrTrr)rrArrrrrSrTrrZ _norm_anglerrrrdrDrErHrrrrrrNrZr_r)rYrrrdxdywhrrrrrrrrdxxZdyyZdzzdfdzr`r`rarJsZ   .0   zAxes3D._on_movecKs&|dur||j_|jj||fi|S)zI Set zlabel. See doc for `.set_ylabel` for description. N)rflabelpadset_label_text)rYZzlabelfontdictrr]r`r`ra set_zlabelszAxes3D.set_zlabelcCs|j}|S)z. Get the z-label text string. )rf get_labelget_text)rYlabelr`r`ra get_zlabels zAxes3D.get_zlabelcCs|jS)z)Get whether the 3D axes panels are drawn.)rrer`r`ra get_frame_on&szAxes3D.get_frame_oncCst||_d|_dS)zs Set whether the 3D axes panels are drawn. Parameters ---------- b : bool TN)rrrdrr`r`ra set_frame_on*s zAxes3D.set_frame_onz3.5rvisiblecKst|r d}||_d|_dS)z Set / unset 3D grid. .. note:: Currently, this function does not behave the same as :meth:`matplotlib.axes.Axes.grid`, but it is intended to eventually support that behavior. TN)rZ _draw_gridrd)rYrr]r`r`rar5s z Axes3D.gridcKs||dv}|dv}|dv}|r2|jjfi||rL|jjfi||rf|jjfi||j||||ddS)a Convenience method for controlling tick locators. See :meth:`matplotlib.axes.Axes.locator_params` for full documentation. Note that this is for Axes3D objects, therefore, setting *axis* to 'both' will result in the parameters being set for all three axes. Also, *axis* can also take a value of 'z' to apply parameters to the z axis. rrrrN)rpr' set_paramsrsrfr)rYrrr]_x_y_zr`r`ralocator_paramsFs  zAxes3D.locator_paramsc stjgd|d|dvr.tj|fi||dvrt|}|dd|dd|dd|d d|jjfi|dS) a Convenience method for changing the appearance of ticks and tick labels. See :meth:`matplotlib.axes.Axes.tick_params` for more complete documentation. The only difference is that setting *axis* to 'both' will mean that the settings are applied to all three axes. Also, the *axis* parameter also accepts a value of 'z', which would mean to apply to only the z-axis. Also, because of how Axes3D objects are drawn very differently from regular 2D axes, some of these settings may have ambiguous meaning. For simplicity, the 'z' axis will accept settings as if it was like the 'y' axis. .. note:: Axes3D currently ignores some of these settings. )rrrrr)rrrrrVNrUlabeltop labelbottom)rrr= tick_paramsrxr<rfset_tick_params)rYrr]Zzkwr^r`rar]s    zAxes3D.tick_paramscCs |\}}|j||dddS)z$ Invert the z-axis. Nri)r]r^rYrUrVr`r`ra invert_zaxiss zAxes3D.invert_zaxiscCs|\}}||kS)z9 Returns True if the z-axis is inverted. r]rr`r`razaxis_inverteds zAxes3D.zaxis_invertedcCs(|\}}||kr||fS||fSdS)zP Return the lower and upper z-axis bounds, in increasing order. Nrrr`r`ra get_zbounds zAxes3D.get_zboundcCsd|durt|r|\}}|\}}|dur2|}|dur>|}|jt||ft|ddddS)z Set the lower and upper numerical bounds of the z-axis. This method will honor axes inversion regardless of parameter order. It will not change the autoscaling setting (`.get_autoscalez_on()`). Nr<ri)rr@rr^rrr)rYlowerupper old_lower old_upperr`r`rar,s   zAxes3D.set_zboundc s*tj|||fi|}t||||S)z Add text to the plot. kwargs will be passed on to Axes.text, except for the *zdir* keyword, which sets the direction to be used as the z direction. )r=textrZ text_2d_to_3d)rYrrrszdirr]rr^r`rarsz Axes3D.textrc s|}|r4t|dts4|^}}d|vr@tdn |dd}t|t|}tj ||g|Ri|}|D]} t j | ||dqrt ||||\}}}| |||||S)a0 Plot 2D or 3D data. Parameters ---------- xs : 1D array-like x coordinates of vertices. ys : 1D array-like y coordinates of vertices. zs : float or 1D array-like z coordinates of vertices; either one for all points or one for each point. zdir : {'x', 'y', 'z'}, default: 'z' When plotting 2D data, the direction to use as z ('x', 'y' or 'z'). **kwargs Other arguments are forwarded to `matplotlib.axes.Axes.plot`. rrz+plot() for multiple values for argument 'z'rr)has_datarstrrr<r broadcast_torr=plotr line_2d_to_3d juggle_axesr ) rYrrrr\r]rrlinesliner^r`rars  z Axes3D.plotr,r\r])r{)rvminvmax lightsourcec"s:|} |jdkrtdt|}t|||\}}}|j\} } d| vpPd| v} d| vp`d| v}| rr|rrtd| dd| dd| dd }| dd }t d r|}n| }|rt t t | |d t t t | |d d | vr| d }n4| d d}|dur|j }tt|}d}| dd}| d|du}|durftjdddg}| d dkr| d dkr|durtjfdd|||fDdd}nttd| d | d g}ttd| d | d g}g}t|dd|d dD]\t|dd|d dD]Z\fdd|||fD}t|j}|||dur:||q:qt|tjrt|r&g}g}t ||D]F\}}t|t|jd d}t!|r||||q|}|dur&|}t"j#|g|Ri| } |durx|rb|$||%||}| &|| '|n|rt|tjr|dj(dd}!ntdd|D}!| )|!|dus|dur| *|||dur| +|n*|r|$||%||}n|}| &||,| |-|||| | S)a. Create a surface plot. By default it will be colored in shades of a solid color, but it also supports colormapping by supplying the *cmap* argument. .. note:: The *rcount* and *ccount* kwargs, which both default to 50, determine the maximum number of samples used in each direction. If the input data is larger, it will be downsampled (by slicing) to these numbers of points. .. note:: To maximize rendering speed consider setting *rstride* and *cstride* to divisors of the number of rows minus 1 and columns minus 1 respectively. For example, given 51 rows rstride can be any of the divisors of 50. Similarly, a setting of *rstride* and *cstride* equal to 1 (or *rcount* and *ccount* equal the number of rows and columns) can use the optimized path. Parameters ---------- X, Y, Z : 2D arrays Data values. rcount, ccount : int Maximum number of samples used in each direction. If the input data is larger, it will be downsampled (by slicing) to these numbers of points. Defaults to 50. rstride, cstride : int Downsampling stride in each direction. These arguments are mutually exclusive with *rcount* and *ccount*. If only one of *rstride* or *cstride* is set, the other defaults to 10. 'classic' mode uses a default of ``rstride = cstride = 10`` instead of the new default of ``rcount = ccount = 50``. color : color-like Color of the surface patches. cmap : Colormap Colormap of the surface patches. facecolors : array-like of colors. Colors of each individual patch. norm : Normalize Normalization for the colormap. vmin, vmax : float Bounds for the normalization. shade : bool, default: True Whether to shade the facecolors. Shading is always disabled when *cmap* is specified. lightsource : `~matplotlib.colors.LightSource` The lightsource to use when *shade* is True. **kwargs Other arguments are forwarded to `.Poly3DCollection`. r!Argument Z must be 2-dimensional.rstridecstridercountccount.Cannot specify both stride and count argumentsru2_internal.classic_moder facecolorscolorNcmapshaderzzPassing shade=None to Axes3D.plot_surface() is deprecated since matplotlib 3.1 and will change its semantic or raise an error in matplotlib 3.3. Please use shade=False instead.rrcsg|]}t|qSr`)r_array_patch_perimetersra)rrr`ra dsz'Axes3D.plot_surface..rrc s.g|]&}t|ddfqS)r)r_array_perimeterr )cscs_nextrsrs_nextr`rar os).rcSs g|]}|dddfqSNr)mean)rrr`r`rar r).rndimrr_to_unmasked_float_arrayrbroadcast_arraysrr<r intrceil _get_linesget_next_colorarraymcolorsto_rgbagetrrWstacklistrangezipTappendrndarrayisnanany itertools zip_longestrrPoly3DCollection _shade_colors_generate_normalsset_facecolorsset_edgecolorsr set_arrayset_climset_normadd_collectionr )"rYrrrrrrrr\r]rrowscols has_stride has_countrrZcompute_stridesZfcolorsrrr colsetpolysZrow_indsZcol_indsrZ new_polysZ new_colsetpcolZnew_polypolycavg_zr`)rrrrrrra plot_surfacesG              ""                 zAxes3D.plot_surfacec Cs:t|tjr||jd}d|dd|d}}}|d|ddf|d|ddf}|d|ddf|d|ddf}ntt|df}tt|df}t|D]\}} t| }d|dd|d}}}| |ddf| |ddf||ddf<| |ddf| |ddf||ddf<qt||S)a Compute the normals of a list of polygons. Normals point towards the viewer for a face with its vertices in counterclockwise order, following the right hand rule. Uses three points equally spaced around the polygon. This normal of course might not make sense for polygons with more than three points not lying in a plane, but it's a plausible and fast approximation. Parameters ---------- polygons : list of (M_i, 3) array-like, or (..., M, 3) array-like A sequence of polygons to compute normals for, which can have varying numbers of vertices. If the polygons all have the same number of vertices and array is passed, then the operation will be vectorized. Returns ------- normals : (..., 3) array A normal vector estimated for the polygon. rrr.N)rrr&remptyr enumeratecross) rYpolygonsni1i2Zi3v1v2Zpoly_irr`r`rar-s  $&,.zAxes3D._generate_normalsc s|durtjddd}tjdd,|tjj|ddd |j}Wdn1sT0Yt|}|rt d dt d dj fd d }d||<t |}|dddf}||ddtj f|}||dddf<nt |}|S)z Shade *color* using normal vectors given by *normals*. *color* can also be an array of the same length as *normals*. Ng -x3@)azdegaltdegignore)invalidrT)rkeepdimsr333333?cs |Sr}r`)rZin_normZout_normr`rarsz"Axes3D._shade_colors..normrr)r LightSourcererrstaterr directionr'r( Normalizeinverse to_rgba_arraynewaxis asanyarraycopy) rYrnormalsrr maskralphacolorsr`rPrar,s$"    zAxes3D._shade_colorscs|}jdkrtdt\j\}}d|vpFd|v} d|vpVd|v} | rh| rhtd|dd} |dd} |dd } |dd }td r| r| rtt t || dnd } |rtt t ||dnd } nJ| s0| r tt t || dnd } |r,tt t ||dnd } t t t | rt t d || }|d kr|d |dkr||dg7}ng}| rt t d || }|d kr|d |dkr||dg7}ng}| d kr| d krtd jd krg}g}fdd|D}fdd|D}fdd|D}fdd|D}fdd|D}fdd|D}ddt|||Dddt|||D}tj|g|Ri|}|||||S)a Plot a 3D wireframe. .. note:: The *rcount* and *ccount* kwargs, which both default to 50, determine the maximum number of samples used in each direction. If the input data is larger, it will be downsampled (by slicing) to these numbers of points. Parameters ---------- X, Y, Z : 2D arrays Data values. rcount, ccount : int Maximum number of samples used in each direction. If the input data is larger, it will be downsampled (by slicing) to these numbers of points. Setting a count to zero causes the data to be not sampled in the corresponding direction, producing a 3D line plot rather than a wireframe plot. Defaults to 50. rstride, cstride : int Downsampling stride in each direction. These arguments are mutually exclusive with *rcount* and *ccount*. If only one of *rstride* or *cstride* is set, the other defaults to 1. Setting a stride to zero causes the data to be not sampled in the corresponding direction, producing a 3D line plot rather than a wireframe plot. 'classic' mode uses a default of ``rstride = cstride = 1`` instead of the new default of ``rcount = ccount = 50``. **kwargs Other arguments are forwarded to `.Line3DCollection`. rrrrrrrrrrrrz*Either rstride or cstride must be non zerocsg|] }|qSr`r`ri)rr`rar erz)Axes3D.plot_wireframe..csg|] }|qSr`r`r^)rr`rar frcsg|] }|qSr`r`r^)rr`rar grcsg|] }|qSr`r`r^)tXr`rar ircsg|] }|qSr`r`r^)tYr`rar jrcsg|] }|qSr`r`r^)tZr`rar krcSs"g|]\}}}tt|||qSr`r!r#rxlylzlr`r`rar mscSs"g|]\}}}tt|||qSr`rcrdr`r`rar os)rrrrrrr<r rrr transposer!r"sizer#rLine3DCollectionr3r )rYrrrr\r]rr4r5r6r7rrrrZriiZciixlinesZylinesZzlinesZtxlinesZtylinesZtzlinesrlinecr`)rrrr`rarbraplot_wireframesj'       """"    zAxes3D.plot_wireframe)rrrrrcOs|}|dur|j}tt|}|dd} |d| du} t j |i|\} }}z|d} Wnt y|^} }Yn0t | } | } | j| }| j| }| | }tj|||fdd}tj|g|Ri|}| rD|dddddfjdd}|||dus"|dur.||||durr||n.| rd||}||||}n|}|||||| j| j| ||S) aT Plot a triangulated surface. The (optional) triangulation can be specified in one of two ways; either:: plot_trisurf(triangulation, ...) where triangulation is a `~matplotlib.tri.Triangulation` object, or:: plot_trisurf(X, Y, ...) plot_trisurf(X, Y, triangles, ...) plot_trisurf(X, Y, triangles=triangles, ...) in which case a Triangulation object will be created. See `.Triangulation` for a explanation of these possibilities. The remaining arguments are:: plot_trisurf(..., Z) where *Z* is the array of values to contour, one per point in the triangulation. Parameters ---------- X, Y, Z : array-like Data values as 1D arrays. color Color of the surface patches. cmap A colormap for the surface patches. norm : Normalize An instance of Normalize to map values to colors. vmin, vmax : float, default: None Minimum and maximum value to map. shade : bool, default: True Whether to shade the facecolors. Shading is always disabled when *cmap* is specified. lightsource : `~matplotlib.colors.LightSource` The lightsource to use when *shade* is True. **kwargs All other arguments are passed on to :class:`~mpl_toolkits.mplot3d.art3d.Poly3DCollection` Examples -------- .. plot:: gallery/mplot3d/trisurf3d.py .. plot:: gallery/mplot3d/trisurf3d_2.py Nrr rrrrr)rrrrrrrrr<r get_from_args_and_kwargsKeyErrorrget_masked_trianglesrrr rr+rr0r1r2r-r,r.r3r )rYrrrrrr\r]rrr trir trianglesxtytZztvertsr<r=rZr8r`r`ra plot_trisurfxsD5             zAxes3D.plot_trisurfrc Cs|j}|j}|d|dd}t||D]V\}}|}|sBq*t|||} t|||} |d} g} g} tt| d|}|dkrt| ddkr*d}nq*t| dd|d}t t t|dD]Z}t t||}t t|d|}| | d|| d|| d|| d|gqt | } || } || | }|| | }tj| ||d}||||q*|D]}|qdS)z4 Extend a contour in 3D by creating rrrr edgecolorsN)levels collectionsr# get_pathsrZ_paths_to_3d_segments get_edgecolorroundrr"rr%rrr-r,r+ set_sort_zposadd_collection3dremove)rYcsetstriderycollsrrrlpathsZtopvertsZbotvertsrZ polyvertsrZZnstepsstepsizer_rErFr]Zcolors2Zpolycolr;r`r`ra_3d_extend_contoursL          zAxes3D._3d_extend_contourcCsRd|}|r|||n4t|j|jD]$\}}|dur<|}tj|||dq(dS)Nrr)rr#ryrzrline_collection_2d_to_3d)rYrextend3drroffsetrrlr`r`raadd_contour_setszAxes3D.add_contour_setcCs|j|||ddS)Nrr)_add_contourf_set)rYrrrr`r`raadd_contourf_setszAxes3D.add_contourf_setc Csd|}|jddt|jd}|jr\|jdt|jddd}t|d|}|jr|jdt|jddd}t||}t||jD].\}}|dur|}t j |||d| |q|S)z Returns ------- levels : numpy.ndarray Levels at which the filled contours are added. rNrrrr?r) ryrdiff _extend_mininsert _extend_maxr%r#rzrpoly_collection_2d_to_3dr~) rYrrrZ midpointsZ min_levelZ max_levelrrlr`r`rars""  zAxes3D._add_contourf_set)rrrrcsb|} t||||\} } } tj| | | g|Ri| }||||||||||| |S)aV Create a 3D contour plot. Parameters ---------- X, Y, Z : array-like, Input data. See `~matplotlib.axes.Axes.contour` for acceptable data shapes. extend3d : bool, default: False Whether to extend contour in 3D. stride : int Step size for extending contour. zdir : {'x', 'y', 'z'}, default: 'z' The direction to use. offset : float, optional If specified, plot a projection of the contour lines at this position in a plane normal to zdir. data : indexable object, optional DATA_PARAMETER_PLACEHOLDER *args, **kwargs Other arguments are forwarded to `matplotlib.axes.Axes.contour`. Returns ------- matplotlib.contour.QuadContourSet )rr rotate_axesr=contourrr )rYrrrrrrrr\r]rjXjYjZrr^r`rar7s zAxes3D.contourcs|}tj|i|\}}}|j} |j} d|vr>|d} n|^} }t| | | |\} } }t| | |j|j }t j ||g|Ri|}| |||||| | | | ||S)a Create a 3D contour plot. .. note:: This method currently produces incorrect output due to a longstanding bug in 3D PolyCollection rendering. Parameters ---------- X, Y, Z : array-like Input data. See `~matplotlib.axes.Axes.tricontour` for acceptable data shapes. extend3d : bool, default: False Whether to extend contour in 3D. stride : int Step size for extending contour. zdir : {'x', 'y', 'z'}, default: 'z' The direction to use. offset : float, optional If specified, plot a projection of the contour lines at this position in a plane normal to zdir. data : indexable object, optional DATA_PARAMETER_PLACEHOLDER *args, **kwargs Other arguments are forwarded to `matplotlib.axes.Axes.tricontour`. Returns ------- matplotlib.tri.tricontour.TriContourSet r)rr rnrrr<rrrrr[r= tricontourrr )rYrrrrr\r]rrqrrrrrrrr^r`rar`s"!  zAxes3D.tricontourcs>d|d|d|||ifdddD}|jg||RdS)Nrrrcs(g|] }t|t|fqSr`rnanminnanmax)rdimZdim_valsr`rar sz/Axes3D._auto_scale_contourf..r)r )rYrrrrryrlimitsr`rra_auto_scale_contourfs  zAxes3D._auto_scale_contourfrcsb|}t||||\} } } tj| | | g|Ri|} || ||} |||||| || S)a Create a 3D filled contour plot. Parameters ---------- X, Y, Z : array-like Input data. See `~matplotlib.axes.Axes.contourf` for acceptable data shapes. zdir : {'x', 'y', 'z'}, default: 'z' The direction to use. offset : float, optional If specified, plot a projection of the contour lines at this position in a plane normal to zdir. data : indexable object, optional DATA_PARAMETER_PLACEHOLDER *args, **kwargs Other arguments are forwarded to `matplotlib.axes.Axes.contourf`. Returns ------- matplotlib.contour.QuadContourSet )rrrr=contourfrr)rYrrrrrr\r]rrrrrryr^r`rars zAxes3D.contourfcs|}tj|i|\}}}|j}|j}d|vr>|d} n|^} }t||| |\} } } t| | |j|j }t j || g|Ri|} | | ||}| ||| |||| S)as Create a 3D filled contour plot. .. note:: This method currently produces incorrect output due to a longstanding bug in 3D PolyCollection rendering. Parameters ---------- X, Y, Z : array-like Input data. See `~matplotlib.axes.Axes.tricontourf` for acceptable data shapes. zdir : {'x', 'y', 'z'}, default: 'z' The direction to use. offset : float, optional If specified, plot a projection of the contour lines at this position in a plane normal to zdir. data : indexable object, optional DATA_PARAMETER_PLACEHOLDER *args, **kwargs Other arguments are forwarded to `matplotlib.axes.Axes.tricontourf`. Returns ------- matplotlib.tri.tricontour.TriContourSet r)rr rnrrr<rrrrr[r= tricontourfrr)rYrrr\r]rrqrrrrrrrryr^r`rars"  zAxes3D.tricontourfrcst|}|jrt|nd}t|tjurHtj|||d| |nRt|tj urrtj |||d| |n(t|tj urtj |||d| |t|}|S)a Add a 3D collection object to the plot. 2D collection types are converted to a 3D version by modifying the object and adding z coordinate information. Supported are: - PolyCollection - LineCollection - PatchCollection rr)rrrirrrPolyCollectionrrr~LineCollectionrPatchCollectionpatch_collection_2d_to_3dr=r3)rYr;rrZzvalsZzsortval collectionr^r`rars     zAxes3D.add_collection3d) rrrrrxc facecolorrr) replace_namesc s|} |} tjdd|||fD\}}}tj|}t|||||\}}}}}t| |rh|}t j ||g|R||d| } t j | |||d|j dkr|jdkr|d||||| | S)a Create a scatter plot. Parameters ---------- xs, ys : array-like The data positions. zs : float or array-like, default: 0 The z-positions. Either an array of the same length as *xs* and *ys* or a single value to place all points in the same plane. zdir : {'x', 'y', 'z', '-x', '-y', '-z'}, default: 'z' The axis direction for the *zs*. This is useful when plotting 2D data on a 3D Axes. The data must be passed as *xs*, *ys*. Setting *zdir* to 'y' then plots the data to the x-z-plane. See also :doc:`/gallery/mplot3d/2dcollections3d`. s : float or array-like, default: 20 The marker size in points**2. Either an array of the same length as *xs* and *ys* or a single value to make all markers the same size. c : color, sequence, or sequence of colors, optional The marker color. Possible values: - A single color format string. - A sequence of colors of length n. - A sequence of n numbers to be mapped to colors using *cmap* and *norm*. - A 2D array in which the rows are RGB or RGBA. For more details see the *c* argument of `~.axes.Axes.scatter`. depthshade : bool, default: True Whether to shade the scatter markers to give the appearance of depth. Each call to ``scatter()`` will perform its depthshading independently. data : indexable object, optional DATA_PARAMETER_PLACEHOLDER **kwargs All other arguments are passed on to `~.axes.Axes.scatter`. Returns ------- paths : `~matplotlib.collections.PathCollection` cSs"g|]}ttj|tjqSr`)rrmafillednan)rtr`r`rar L rz"Axes3D.scatter..)rr)rr depthshade皙?r)rrrrrrdelete_masked_pointsmay_share_memoryrYr=scatterrrrrirr ) rYrrrrrrrr\r]rZzs_origpatchesr^r`rar s"2   "  zAxes3D.scattercs|}tj||g|Ri|}t|t|}g} g} t||D]T\} } t| } | | 7} | | gt| 7} t | | |d|vrF| |dqFt| dkrt| \}}n gg}}t ||| |\}}} | ||| ||S)a Add 2D bar(s). Parameters ---------- left : 1D array-like The x coordinates of the left sides of the bars. height : 1D array-like The height of the bars. zs : float or 1D array-like Z coordinate of bars; if a single value is specified, it will be used for all bars. zdir : {'x', 'y', 'z'}, default: 'z' When plotting 2D data, the direction to use as z ('x', 'y' or 'z'). data : indexable object, optional DATA_PARAMETER_PLACEHOLDER **kwargs Other arguments are forwarded to `matplotlib.axes.Axes.bar`. Returns ------- mpl_toolkits.mplot3d.art3d.Patch3DCollection r\r)rr=barrrrr#rZ_get_patch_vertsrZpatch_2d_to_3d set_alpharr )rYrIrrrr\r]rrruZverts_zsr:rZvsrrr^r`rarb s$    z Axes3D.baraveragec Os|} tt||||||\}}}}}}t|}t||}t|}t||}t|}t||}tgd}t|j|j}d||fd||fd||ffD]J\}}}|dtj tj f}|dtj tj f}|||d|f|d|f<q| d|jdd}g}|dur0|j g}t t|}t|t|krn|D]}||gdqTn&|}t|t|kr|dt|9}| r||}|||| }n|}tj|g| R||d | }|||||f||f||f| |S) a Generate a 3D barplot. This method creates three dimensional barplot where the width, depth, height, and color of the bars can all be uniquely set. Parameters ---------- x, y, z : array-like The coordinates of the anchor point of the bars. dx, dy, dz : float or array-like The width, depth, and height of the bars, respectively. color : sequence of colors, optional The color of the bars can be specified globally or individually. This parameter can be: - A single color, to color all bars the same color. - An array of colors of length N bars, to color each bar independently. - An array of colors of length 6, to color the faces of the bars similarly. - An array of colors of length 6 * N bars, to color each face independently. When coloring the faces of the boxes specifically, this is the order of the coloring: 1. -Z (bottom of box) 2. +Z (top of box) 3. -Y 4. +Y 5. -X 6. +X zsort : str, optional The z-axis sorting scheme passed onto `~.art3d.Poly3DCollection` shade : bool, default: True When true, this shades the dark sides of the bars (relative to the plot's source of light). lightsource : `~matplotlib.colors.LightSource` The lightsource to use when *shade* is True. data : indexable object, optional DATA_PARAMETER_PLACEHOLDER **kwargs Any additional keyword arguments are passed onto `~.art3d.Poly3DCollection`. Returns ------- collection : `~.art3d.Poly3DCollection` A collection of three dimensional polygons representing the bars. ))rrrrrrrrrrrr)rrrrrrrrrrrr)rrrr)rrrr)rrrr)rrrrrrr.)rNr)zsortr)rrrrrrrr@rrWreshape_get_patches_for_fillrr!rrVrextendr-r,rr+r3r )rYrrrrrrrrr rr\r]rrrrrrrZcuboidr9r_r:dprrrZZ sfacecolorsr;r`r`rabar3d sT?   .&    z Axes3D.bar3dcenterc s<tj|f||d|}|j\}}|jd||S)N)rlocgq= ףp?)r= set_titletitlerset_y)rYrrrr]retrrr^r`rar> szAxes3D.set_titlerOtail)lengtharrow_length_ratiopivot normalizecsddd}|}d} t|| kr6td| t|f|d| } dd| D} tjg| | R} | d| } | | d} | rttj| fd d| D} nd d| D} td d | Drt j gg|| dRi|} | | | Stj d |gt d}||}tjgd|d|dkr0||8}n|dkrF||d8}t| dd}t| d| t }tjj|dd}|dk|}|r||d}n|}t|dkr6|tj||dd}||}|ddddftj||}|t|ddf}|dd}g||}ng}t j |g|| dRi|} | | ||dddf|dddf|dddf|| S)a ax.quiver(X, Y, Z, U, V, W, /, length=1, arrow_length_ratio=.3, pivot='tail', normalize=False, **kwargs) Plot a 3D field of arrows. The arguments could be array-like or scalars, so long as they they can be broadcast together. The arguments can also be masked arrays. If an element in any of argument is masked, then that corresponding quiver element will not be plotted. Parameters ---------- X, Y, Z : array-like The x, y and z coordinates of the arrow locations (default is tail of arrow; see *pivot* kwarg). U, V, W : array-like The x, y and z components of the arrow vectors. length : float, default: 1 The length of each quiver. arrow_length_ratio : float, default: 0.3 The ratio of the arrow head with respect to the quiver. pivot : {'tail', 'middle', 'tip'}, default: 'tail' The part of the arrow that is at the grid point; the arrow rotates about this point, hence the name *pivot*. normalize : bool, default: False Whether all arrows are normalized to have the same length, or keep the lengths defined by *u*, *v*, and *w*. data : indexable object, optional DATA_PARAMETER_PLACEHOLDER **kwargs Any additional keyword arguments are delegated to :class:`~matplotlib.collections.LineCollection` c Ssd|dddf}|dddf}tjj|ddddfdd}tj|||dkt|d}tj| ||dkt|d}t|}t|}t |} t ||dd|||d||| g||d|||dd|| | g| | || t ||gg} | } | gdgdfd9<t d | |} t d | |} tj| | gdd}|S) Nrrrr)whereout)rrrr)rrrrrzij...,...j->...i)rrrdivide zeros_like ones_likemathradiansrrr full_likerYeinsumr )UVWanglerrrZx_pZy_pZrarrZRposZRnegZ Rpos_vecsZ Rneg_vecs head_dirsr`r`ra calc_arrowss s(    (*z"Axes3D.quiver..calc_arrowsrz-Wrong number of arguments. Expected %d got %dNcSs g|]}t|tjjr|jqSr`)rrr MaskedArrayr[rkr`r`rar  sz!Axes3D.quiver..cs g|]}tjj|dqS)r[)rrr compressedrrr`rar  scSsg|]}t|qSr`)rrrr`r`rar  rcss|]}t|dkVqdS)rN)r)rvr`r`rar rz Axes3D.quiver..r#r)rmiddletip)rrrrrrrr)rrr)r)rrrrrrreduce logical_orr(rrjr3rrrrrastyperrrmultiplyouterswapaxesr )rYrrrrr\r]rrZargi input_argsmasksbcastrlZshaft_dtZarrow_dtZXYZrrZshaftsrheadsrr`rraquiverE sb.             "   4z Axes3D.quiver)rrxr rc2 st|dkrdd}ndd}||i|\}}jdkrDtdtjjtjd} t| d|dur|t\} } } nfd d |D\} } } fd d } |dur|j }| |d }| |d}| | | | tjgdgdgdgdgtjd}t t }dd}|dD]}|j| \}}}t|}t|}t|}||j}|ddd}|D]4}|D]&}|||dg}t|}|r||||t|dd|ddD]\}}||||g} ||||g}!t| }"t|!}#|"r&|#s&||"|!|n&|"sƈ|#r||#|!|q||||dg}$||||g}%t|$}&|&rr||&|%|qrqhqi}'|D]\}(})|dur|)}*ng}*|)D]}+|+dddf|+dddf|+dddff},t|+j}-| |,|-dddf<| |,|-dddf<| |,|-dddf<|*|-q||(}.||(}/|r||*}0||.|0|}.|/dur||/|0|}/tj|*f|.|/d|}1||1|1|'|(<q|'S)a ax.voxels([x, y, z,] /, filled, facecolors=None, edgecolors=None, **kwargs) Plot a set of filled voxels All voxels are plotted as 1x1x1 cubes on the axis, with ``filled[0, 0, 0]`` placed with its lower corner at the origin. Occluded faces are not plotted. Parameters ---------- filled : 3D np.array of bool A 3D array of values, with truthy values indicating which voxels to fill x, y, z : 3D np.array, optional The coordinates of the corners of the voxels. This should broadcast to a shape one larger in every dimension than the shape of *filled*. These can be used to plot non-cubic voxels. If not specified, defaults to increasing integers along each axis, like those returned by :func:`~numpy.indices`. As indicated by the ``/`` in the function signature, these arguments can only be passed positionally. facecolors, edgecolors : array-like, optional The color to draw the faces and edges of the voxels. Can only be passed as keyword arguments. These parameters can be: - A single color value, to color all voxels the same color. This can be either a string, or a 1D rgb/rgba array - ``None``, the default, to use a single color for the faces, and the style default for the edges. - A 3D ndarray of color names, with each item the color for the corresponding voxel. The size must match the voxels. - A 4D ndarray of rgb/rgba data, with the components along the last axis. shade : bool, default: True Whether to shade the facecolors. Shading is always disabled when *cmap* is specified. lightsource : `~matplotlib.colors.LightSource` The lightsource to use when *shade* is True. **kwargs Additional keyword arguments to pass onto `~mpl_toolkits.mplot3d.art3d.Poly3DCollection`. Returns ------- faces : dict A dictionary indexed by coordinate, where ``faces[i, j, k]`` is a `.Poly3DCollection` of the faces drawn for the voxel ``filled[i, j, k]``. If no faces were drawn for a given voxel, either because it was not asked to be drawn, or it is fully occluded, then ``(i, j, k) not in faces``. Examples -------- .. plot:: gallery/mplot3d/voxels.py .. plot:: gallery/mplot3d/voxels_rgb.py .. plot:: gallery/mplot3d/voxels_torus.py .. plot:: gallery/mplot3d/voxels_numpy_logo.py rc[s|||f||fSr}r`)Z _Axes3D__xZ _Axes3D__yZ _Axes3D__zrr]r`r`ravoxels( szAxes3D.voxels..voxelsc[s d||fSr}r`)rr]r`r`rar+ sz%Argument filled must be 3-dimensionalrrNc3s|]}t|VqdSr})rr)rr) coord_shaper`rar: rz Axes3D.voxels..cspt|dvr&t|jt|St|dvr^t|ddjkrZtd||Std|dS)N)rr)rrrz8When multidimensional, {} must match the shape of filledzInvalid {} argument)rrrrrformat)rr)rr`ra_broadcast_color_arg< sz+Axes3D.voxels.._broadcast_color_argrrxrrrrcss8tj|tjd}t|D]}|Vtj|ddd}qdS)z%Generate cyclic permutation matrices.rrrrN)rrintpr"r})rDmatr_r`r`rapermutation_matrices_ s z+Axes3D.voxels..permutation_matricesrrrrw)rrrrrrrr`indicesrrr rr!r$raranger%r#itemsr@r-r,rr+r)2rYrrxr rr\r]rZxyzrirrrrsquareZ voxel_facesrZpermutepcZqcrcZpindsZqindsZrindsZsquare_rot_posZsquare_rot_negr:qri0Zr1r2rrrErFZpkZpk2ZikrCcoordZ faces_indsZfacesZ face_indsindfacer edgecolorrZpolyr`)rrrar sH                "  .     z Axes3D.voxels)rrrxerryerrzerrrcC sV|}t|tj}dd|D}|dd|jd|fd|fd|fg|dd t |rd|n|g}t |rx|n|g}t |r|n|g}t |t |krt |ksnt d t | t rd | f} t | tr0t | dkrt | d t rt | d t rt| d d | d } nt d| dnt | tr>ntt | tst | rz || Wn<t tfyzt d| dWYd n d 00nt d| d|dd }d|d<|jj|dkr||fn|||f|dd\\}}tj||d|r||ddn||dd|dkrJ||nd }|dd|vrjd|d<| d ur||d} dD]}||d qi|d| i}| r| |d<nd|vr|d|d<dD]}||vr||||<qi|dd i}| d urtd!} | d kr$d"| |d#<| d ur6| |d$<| |d<tt |td| <d%d&}fd'd(ggg}}}g} d)d)d*d+}!d d dd,|d#td-d}"|"|jjd.9}"|j !"d/|"|"fg}"t#tj$|"d d0}"tj%|d d d1 tj&'|(}#Wd n1s0Yt)|#t*|"d d d gd }"|"d29}"i||"d d3}$|$d#d t+gd,|||g|||g|||g|||gD]\}%}&t,|%|%}'d urȐqt sgt |&t-t.t |&/tt.t |&/tfd4d5t0|||gD}(|(\\})}*\}+},\}-}.B}/|/1r| d kr||)|+|-g|/@}0||*|,|.g|/@}1tj2|0d|!|'d6|}2tj2|1d|!|'d6|}3||2||3|3|2|3|31r4||*|,|.g@\}4}5}6|j4|4|5|6gRi|$1rv||)|+|-g@\}7}8}9|j4|7|8|9g Ri|$tj5t*|(j6fi|}:|7|:|3|:| 3|(qt*| } fd7d8};|;| d\}<}=|;| d\}>}?|;| d\}@}A|8|<|=f|>|?f|@|Af|t9j:|t|t|f|d up2|d u|d u|d9}B|j;3|B|||fS):a Plot lines and/or markers with errorbars around them. *x*/*y*/*z* define the data locations, and *xerr*/*yerr*/*zerr* define the errorbar sizes. By default, this draws the data markers/lines as well the errorbars. Use fmt='none' to draw errorbars only. Parameters ---------- x, y, z : float or array-like The data positions. xerr, yerr, zerr : float or array-like, shape (N,) or (2, N), optional The errorbar sizes: - scalar: Symmetric +/- values for all data points. - shape(N,): Symmetric +/-values for each data point. - shape(2, N): Separate - and + values for each bar. First row contains the lower errors, the second row contains the upper errors. - *None*: No errorbar. Note that all error arrays should have *positive* values. fmt : str, default: '' The format for the data points / data lines. See `.plot` for details. Use 'none' (case insensitive) to plot errorbars without any data markers. ecolor : color, default: None The color of the errorbar lines. If None, use the color of the line connecting the markers. elinewidth : float, default: None The linewidth of the errorbar lines. If None, the linewidth of the current style is used. capsize : float, default: :rc:`errorbar.capsize` The length of the error bar caps in points. capthick : float, default: None An alias to the keyword argument *markeredgewidth* (a.k.a. *mew*). This setting is a more sensible name for the property that controls the thickness of the error bar cap in points. For backwards compatibility, if *mew* or *markeredgewidth* are given, then they will over-ride *capthick*. This may change in future releases. barsabove : bool, default: False If True, will plot the errorbars above the plot symbols. Default is below. xlolims, ylolims, zlolims : bool, default: False These arguments can be used to indicate that a value gives only lower limits. In that case a caret symbol is used to indicate this. *lims*-arguments may be scalars, or array-likes of the same length as the errors. To use limits with inverted axes, `~.Axes.set_xlim` or `~.Axes.set_ylim` must be called before :meth:`errorbar`. Note the tricky parameter names: setting e.g. *ylolims* to True means that the y-value is a *lower* limit of the True value, so, only an *upward*-pointing arrow will be drawn! xuplims, yuplims, zuplims : bool, default: False Same as above, but for controlling the upper limits. errorevery : int or (int, int), default: 1 draws error bars on a subset of the data. *errorevery* =N draws error bars on the points (x[::N], y[::N], z[::N]). *errorevery* =(start, N) draws error bars on the points (x[start::N], y[start::N], z[start::N]). e.g. errorevery=(6, 3) adds error bars to the data at (x[6], x[9], x[12], x[15], ...). Used to avoid overlapping error bars when two series share x-axis values. Returns ------- errlines : list List of `~mpl_toolkits.mplot3d.art3d.Line3DCollection` instances each containing an errorbar line. caplines : list List of `~mpl_toolkits.mplot3d.art3d.Line3D` instances each containing a capline object. limmarks : list List of `~mpl_toolkits.mplot3d.art3d.Line3D` instances each containing a marker with an upper or lower limit. Other Parameters ---------------- data : indexable object, optional DATA_PARAMETER_PLACEHOLDER **kwargs All other keyword arguments for styling errorbar lines are passed `~mpl_toolkits.mplot3d.art3d.Line3DCollection`. Examples -------- .. plot:: gallery/mplot3d/errorbar3d.py cSsi|]\}}|dur||qSr}r`)rrrr`r`rar% rz#Axes3D.errorbar..rrrrrFr9z)'x', 'y', and 'z' must have the same sizerrNz errorevery=z! is a not a tuple of two integerszL is iterable but not a valid NumPy fancy index to match 'xerr'/'yerr'/'zerr'z is not a recognized valuer _nolegend_rT) return_kwargs)rg?nonerC0) marker markersizemarkerfacecolormarkeredgewidthmarkeredgecolor markevery linestyle fillstyle drawstyle dash_capstyledash_joinstylesolid_capstylesolid_joinstyle linewidth)rRr\r rasterizedrNonezerrorbar.capsizeg@rrcsfdd|DS)Ncsg|]}gt|qSr`)r)compress)rrrr`rar  rz8Axes3D.errorbar.._apply_mask..r`)arraysr[r`rra _apply_mask sz$Axes3D.errorbar.._apply_maskcsZt|jdkr|\}}n ||}}t|B|||}t|B|||}||fSr)rrrr)errdataZlomaskZhimaskZlow_errZhigh_errZlowsZhighs) everymaskr`ra _extract_errs s   z&Axes3D.errorbar.._extract_errs|_)rrrrzlines.markersizeHr+r)rrgV&,t=?)rrcs&g|]\}}||qSr`r`)rr_r)r$ dir_vectorr!lolimsuplimsr`rar  sz#Axes3D.errorbar..)lsrc sLt|dd|ddddft|dd|ddddffSr}r)Zerr_arrZ coord_label)i_xyzr`ra_digout_minmax s$$z'Axes3D.errorbar.._digout_minmax)has_xerrhas_yerrr).rcs&g|]\}}}||f|||fgqSr`r`r`rcr`rar  scs&g|]\}}}||f|||fgqSr`r`r`rcr`rar  sNzlines.linestyler )rrr) linestylesr]r)r)matplotlib.containerr_rrrrrrr#r r rrrjr3 add_containerrr )rYrrrr[r\r]rUrr^r_rrrrbasexZbasexlimbaseyZbaseylimrr linemarker linecolorbaseline stemlines markerlinestem_containerZjxZjyZjzr`rcrastem- sVB                   (z Axes3D.stem)N)N)NN)NN)NNF)N)N)TrN)NN)NTTT)NNTF)NNTF)NNTF)NNr)rr)NN)T)rN)r)NN)N)N)r)FrrN)rN)rN)rr)rrrNT)rr)NrTN)Nr)NNNrFrNNNNFFFFFF)TN)__name__ __module__ __qualname____doc__r _axis_namesrGrouperrr9r>r?r@rhrMrurwr Zget_zgridlinesZget_zticklinesrrrZw_xaxisZw_yaxisZw_zaxisrrrrrrmartistallow_rasterizationrrrrrrrrrrrr rr r rrNrZr_r4maxesrDr5rTr6rdrirjrkmaprZ get_zticksZ set_zticksZget_zmajorticklabelsZget_zminorticklabelsZget_zticklabelsZset_zticklabelsZ zaxis_datetextwrapdedentrtr7r1rrrCrrrrrKrLrrrrrJrrrrrename_parameterrrrrrrr,rZtext3DZtext2DrZplot3Ddelete_parameterr>r-r,rmrvrrrrrrZ contour3DrrrZ contourf3DrrrZ scatter3DrrrrZquiver3DrrQrVroZstem3D __classcell__r`r`r^rar,sxq         =* a    B   > 9 : :           $ 6   $G    "  )O+ $ v e 4  &5  1! G5 & Y  btrrcCstdd|}}t||\}}t|d|d ddtj}t|ddd|ddd ddtjdd}||}|d}|d}|d}|||fS) z,Return a tuple X, Y, Z with a test data set.gg@rrg?rrui)rrmeshgridexpr)r/rrrrZZ1ZZ2rr`r`ra get_test_data s&*r)r)>rsrzrrrr)rnumbersrrznumpyr matplotlibrrrrmatplotlib.artistrrvmatplotlib.axesaxesrxmatplotlib.collectionsrmatplotlib.colorsr]rmatplotlib.imageimager"matplotlib.linesrr$matplotlib.patchesrrmatplotlib.scalescalerare containerr:matplotlib.transforms transformsrrr matplotlib.axes._baser r r Zmatplotlib.tri.triangulationr rrrrinterpd_define_aliasesrrr`r`r`rasv