403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.156
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /usr/lib/python3/dist-packages/mpl_toolkits/mplot3d/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /usr/lib/python3/dist-packages/mpl_toolkits/mplot3d/__pycache__/axes3d.cpython-310.pyc
o

�:�a��@stdZddlmZddlZddlZddlZddlZddlmZddl	Z	ddl
Zddlm
Z
mZmZmZddlmZddlmZddlmZddlmZddlmZddlm Z!ddl"m#Z$ddl%m&Z'ddl(m)Z*ddl+m,Z-ddlm.Z.m/Z/ddl0m1Z1m2Z2ddl+m3Z3dd	l4m5Z5d
dl6m7Z7d
dl6m8Z8d
d
l6m9Z9ej:e�;dgdgdgd��Gdd�de.���Z<ddd�Z=dS)aR
axes3d.py, original mplot3d version by John Porter
Created: 23 Sep 2005

Parts fixed by Reinier Heeres <reinier@heeres.eu>
Minor additions by Ben Axelrod <baxelrod@coroware.com>
Significant updates and revisions by Ben Root <ben.v.root@gmail.com>

Module containing Axes3D, an object which can plot 3D objects on a
2D matplotlib figure.
�)�defaultdictN)�Integral)�_api�cbook�	docstring�_preprocess_data)�Axes�rcParams)�_axis_method_wrapper�_process_plot_format)�Bbox)�
Triangulation�)�art3d)�proj3d)�axis3d�xlim�ylim�zlim)�xlim3d�ylim3d�zlim3dcs`eZdZdZdZdZe��ej	d<	�ddddddd	d
��fdd�Z
d
d�Zdd�Zdd�Z
�fdd�Zdd�Zdd�Zedd�Zedd�Zejddd	d�edd ���Zejdd!d	d�ed"d ���Zejddd	d�ed#d ���Z�dd$d%�Z�dd&d'�Z�dd(d)�Z�d�fd+d,�	Zd-d.�d/d0�Z�dd1d2�Ze j!�fd3d4��Z"d5d6�Z#�dd7d8�Z$d9d:�Z%�fd;d<�Z&d=d>�Z'�fd?d@�Z(dAdB�Z)�fdCdD�Z*�fdEdF�Z+dGdH�Z,dddd	dI�dJdK�Z-�ddMdN�Z.�ddOdP�Z/				�ddQdR�Z0dSdT�Z1�ddddU�dVdW�Z2�ddddX�dYdZ�Z3�dddd[�d\d]�Z4d^d_�Z5e6jj7je5_d`da�Z8e6jj9je8_dbdc�Z:ddde�Z;dfdg�Z<dhdi�Z=djdk�Z>e?dlj@gd��\e<_e=_e>_eddm�ZAeddn�ZBeddo�ZCeddp�ZDeddq�ZEeddrdsdtidu�ZFeddv�ZGeGj�r}eGjeH�Idw�7_dxdy�ZJ�d	dzd{�ZKd|d}�ZLd~d�ZMd�d��ZN�d
d�d��ZOd�d��ZPd�d��ZQd�d��ZR�fd�d��ZSd�d��ZTd�d��ZUd�d��ZVd�d��ZWd�d��ZXd�d��ZYd�d��ZZ�dd�d��Z[d�d��Z\d�d��Z]d�d��Z^e�_d�d�d���dd�d���Z`�dd�d��Za�d
�fd�d��	Zbd�d��Zcd�d��Zdd�d��Ze�dd�d��Zf�d�fd�d��	ZgegZhejgZidd���fd�d��
ZjejZkejld�d�d�d��ddddd��d�d���Zmd�d��Zn�dd�dÄZoejld�d�d�d��d�dń�ZpddddddƜd�dȄZq�dd�d˄Zr	�dd�d̈́Zs�dd�dτZt�dd�dфZuev�d*d�dddҜ�fd�dԄ
�ZwewZxev�d*d�dddҜ�fd�dք
�Zyd�d؄Zzev�dddٜ�fd�dۄ
�Z{e{Z|ev�dddٜ�fd�d݄
�Z}�d�fd�d�	Z~evgd�d��d�fd�d�	�ZeZ�ev��d�fd�d�	�Z�ev�		�dd�d��Z��d�fd�d�	Z�ev�d-d�d�d*d�d�d��Z�e�Z�ddd	dd�d�d��Z�evgd��d�	�		*	*�dd�d���Z�			�dd*d���fd�d��Z�ev�d�d�d�d�dd�d��d�d��Z�e�Z��Z�S(�Axes3Dz
    3D axes object.
    �3d��x�y�zrNi�����perspT)�azim�elev�sharez�	proj_type�
box_aspect�computed_zorderc
s�|durgd�}||_||_|�|�||_t��|_t��|_t��|_t��|_	|�
|j|j�||_|durE|jd�
||�d|_|
�dd�}t�j||g|	�Rd|d�|
��t���|��d|_d|_|��|jjjj�|jj�d|j�|jj�d	|j�|jj�d
|j�h�|� �|j!�"d�|j#�$��%dd
g�}|d|d\|_&|_'|j(dd��)d�|r�t*j+dddd�|�,|�dSdS)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'r�datalim�auto_add_to_figureT)�frameonr$�motion_notify_event�button_press_event�button_release_eventr�rr)rrrF�3.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.)�removal�message)-�initial_azim�initial_elev�
set_proj_typer%r�unit�
xy_viewLim�
zz_viewLim�
xy_dataLim�
zz_dataLim�	view_init�_sharez�_shared_axes�join�_adjustable�pop�super�__init__�set_axis_off�set_axis_on�M�	fmt_zdata�
mouse_init�figure�canvas�	callbacks�
_pickled_cids�update�mpl_connect�_on_move�
_button_press�_button_release�set_top_view�patch�
set_linewidth�transLimits�inverted�	transform�	_pseudo_w�	_pseudo_h�spines�set_visibler�warn_deprecated�add_axes)
�self�fig�rectr r!r"r#r$r%�args�kwargsr)�pseudo_bbox��	__class__��=/usr/lib/python3/dist-packages/mpl_toolkits/mplot3d/axes3d.pyrA8sh,




����
�����	�zAxes3D.__init__cCsd|_d|_dS)NFT��	_axis3don�stale�r\rdrdrerB��
zAxes3D.set_axis_offcCsd|_d|_dS)NTrfrirdrdrerC�rjzAxes3D.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)r\rrdrdre�convert_zunits�szAxes3D.convert_zunitscsTd|j}d|j}d|j}d|j}t�j||dd�t�j||dd�dS)Ngffffff�?g�������?��auto)�distr@�set_xlim�set_ylim)r\�xdwl�xdw�ydwl�ydwrbrdrerP�s



zAxes3D.set_top_viewcCspt�d|jj|jj|�|_t�d|jj|jj|�|_t�	d|j
j|jj|�|_|j|j|jfD]}|�
�q/dS)z5Init 3D axes; overrides creation of regular X/Y axes.rrrN)r�XAxisr6�	intervalxr8�xaxis�YAxis�	intervaly�yaxis�ZAxisr7r9rk�init3d)r\�axrdrdre�
_init_axis�s���
�zAxes3D._init_axiscC�|jS)z0Return the ``ZAxis`` (`~.axis3d.Axis`) instance.�rkrirdrdre�	get_zaxis��zAxes3D.get_zaxisrk�
get_gridlines�
get_ticklines�3.1ry)�alternative�pendingcCr��N)ryrirdrdre�<lambda>��zAxes3D.<lambda>r|cCr�r�)r|rirdrdrer��r�cCr�r�r�rirdrdrer��r�c
Cs\|p|��\}}}}}}|||f|||f|||f|||f|||f|||f|||f|||fgSr�)�
get_w_lims)r\�vals�minx�maxx�miny�maxy�minz�maxzrdrdre�	unit_cube�s�zAxes3D.unit_cubecCs(|dur|j}|�|�}t�||�}|Sr�)rDr�r�proj_points)r\r�rD�xyzs�tcuberdrdre�
tunit_cube�s

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�)r\r�rD�tc�edgesrdrdre�tunit_edges�s�zAxes3D.tunit_edgesFcs0|dkrtd|�d���t�j||||d�dS)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
        rozIAxes3D currently only supports the aspect argument 'auto'. You passed in �.)�
adjustable�anchor�shareN)�NotImplementedErrorr@�
set_aspect)r\�aspectr�r�r�rbrdrer�s5��
�zAxes3D.set_aspectr)�zoomcCsj|durtjdtd�}n|}tj|td�}|jdkr!td|����|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)r�r�r���dtype)r�z?You must pass a 3-tuple that can be cast to floats. You passed g�Ir|E�?T)	�np�asarray�float�shape�
ValueError�linalg�norm�_box_aspectrh)r\r�r��orig_aspectrdrdre�set_box_aspect>s
��
zAxes3D.set_box_aspectcCsx|dur
|jdd�}|��j}tj�dddd��|�}|j|j}d}|�	�}|�
|||�}|�|�|�
�|�d�dS)NT)�originalrr�active)�get_position�
get_figure�transSubfigure�mtransformsr�from_bounds�transformed�height�width�frozen�shrunk_to_aspect�
_set_position�anchored�
get_anchor)r\�position�trans�bb�
fig_aspectr$�pb�pb1rdrdre�apply_aspecths
zAxes3D.apply_aspectcs�����j���d�_���}|r|���}��|�n�������_�fdd�dD�}tj	t
��fi|���{�fdd�}dd��jD�}�jr�t
d	d����D��d
}|}}	t||dd�D]}
t|
tj�ru||
_|d
7}qet|
tj�r�|	|
_|	d
7}	qen	|D]}
|
��q��jr����D]}|���q����D]}|���q�t����Wd�dS1s�wYdS)
NFcs:i|]}|tjd|d|��d�tt�|�fdd����qS)r/z
self.axes.)�namer�cSs|Sr�rd)r\�_valuerdrdrer��sz(Axes3D.draw.<locals>.<dictcomp>.<lambda>)r�
deprecated�property�getattr)�.0r�rirdre�
<dictcomp>�s
����zAxes3D.draw.<locals>.<dictcomp>)rD�vvec�eye�get_axis_positionc	sNzt�|j�}|��W|��Sttfy&tjddd�|���YSw)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.�r1)�inspect�	signature�do_3d_projection�bindr��	TypeErrorrrZ)�artistr�)�rendererrdrer��s	

���z%Axes3D.draw.<locals>.do_3d_projectioncss&�|]}t|tjtjf�r|VqdSr�)�
isinstance�mcoll�
Collection�mpatches�Patch)r�r�rdrdre�	<genexpr>�s��
�zAxes3D.draw.<locals>.<genexpr>css�|]}|��VqdSr�)�
get_zorder)r��axisrdrdrer��s��rT)�key�reverse)�_unstale_viewLimrQ�draw�_frameon�get_axes_locatorr��get_projrDr�_setattr_cm�type�	_childrenr%�max�_get_axis_list�sortedr�r�r��zorderr�r�r�rg�	draw_paner@)r\r��locator�pos�props3dr��collections_and_patches�
zorder_offset�collection_zorder�patch_zorderr�r�rb)r�r\rer�ysZ



����
�
��

"�zAxes3D.drawcCsh|��}|�||j�}|dd|ddk}|dd|ddk}|dd|ddk}|||fS)Nrr�r�r)r�r�rD)r\r�r��xhigh�yhigh�zhighrdrdrer��s
zAxes3D.get_axis_positioncCsV|durtj|j|t�d�Stj|��|d�|��|j|dk|dk|dkd�dS)N)�event)�	axis_namerrr��scalex�scaley�scalez)	�	functools�partial�_unit_change_handler�objectr�
check_in_list�
_get_axis_map�relim�_request_autoscale_view)r\rrrdrdrer�s
�

�zAxes3D._unit_change_handlercKsdSr�rd)r\�xysr`rdrdre�update_datalim�szAxes3D.update_datalimcst���o|��Sr�)r@�get_autoscale_on�get_autoscalez_onrirbrdrer��zAxes3D.get_autoscale_oncCr�)z(Return whether the z-axis is autoscaled.��
_autoscaleZonrirdrdrer�r�zAxes3D.get_autoscalez_oncst��|�|�|�dSr�)r@�set_autoscale_on�set_autoscalez_on�r\�brbrdrer�s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
        Nrrrdrdrer�s
	zAxes3D.set_autoscalez_onc�$|jd}t��|�||jd<dS�Nr)�_stale_viewlimsr@�set_xmargin�r\�mrrbrdrer	�
zAxes3D.set_xmargincrr)rr@�set_ymarginrrbrdrer rzAxes3D.set_ymargincCs8|dks|dkrtd��||_|jdddd�d|_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��_zmarginr
rh)r\rrdrdre�set_zmargins
	
zAxes3D.set_zmargin)rrr�tightcGs|r|dur|dur|durtd��t|�dkr!|d}}}nt|�dkr-|\}}}n|r3td��|durT|durT|durT|durLt�d|�d	��|j|j|jfS|dur]|�|�|durf|�|�|duro|�	|�|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.rrr�zYMust pass a single positional argument for all margins, or one for each margin (x, y, z).Tzignoring tight=z in get mode�r#rrr)r��lenr�
warn_external�_xmargin�_ymarginr!rr r"�autoscale_view)r\rrrr#�marginsrdrdrer**s,&



�zAxes3D.margins�bothcCs�|durd}d}d}n*|dvrt|�|_}nd}|dvr%t|�|_}nd}|dvr3t|�|_}nd}|j||||d�dS)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.
        NT�rr+F�rr+�rr+r$)�bool�
_autoscaleXon�
_autoscaleYonrr
)r\�enabler�r#rrrrdrdre�	autoscalels 

�zAxes3D.autoscalecCs�t�|�t�|�kr|j�t�t�|�t�|�g�|�n|j�||�|j�||�|dur:|j�||�|�	�dSr�)
r�r�r8�update_from_data_xy�column_stack�ravel�update_from_data_x�update_from_data_yr9r))r\�X�Y�Z�had_datardrdre�auto_scale_xyz�s�zAxes3D.auto_scale_xyzcCs�|dur&|j}|s%|jD]}t|tj�rd}qt|tjtjf�r$d}nqnt	|�}|_|rp|j
rp|jd��|j
j\}}|j��}	|	�||�\}}|jdkr`|||j}
||
8}||
7}|sj|	�||�\}}|�||�|r�|jr�|jd��|j
j\}}|j��}
|
�||�\}}|jdkr�|||j}
||
8}||
7}|s�|
�||�\}}|�||�|r�|jr�|jd��|jj\}}|j��}|�||�\}}|jdkr�|||j}
||
8}||
7}|s�|�||�\}}|�||�dSdSdS)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)�_tightr�r��mimage�	AxesImage�mlines�Line2Dr�r�r/r0r<�cleanr8rxry�get_major_locator�nonsingularr'�view_limits�
set_xboundr1r{r|r(�
set_yboundrr9rkr!�
set_zbound)r\r#rrrr>r��x0�x1�xlocator�delta�y0�y1�ylocator�z0�z1�zlocatorrdrdrer)�sb

��








�zAxes3D.autoscale_viewcCs4|��\}}|��\}}|��\}}||||||fS)zGet 3D world limits.)�
get_xlim3d�
get_ylim3d�
get_zlim3d)r\r�r�r�r�r�r�rdrdrer��szAxes3D.get_w_lims)�xmin�xmaxcCs�|dur
t�|�r
|\}}|dur|durtd��|}|dur)|dur'td��|}|jd||ffgdd�|�||j�}|�||j�}|��\}}|durO|}|durU|}||krbt�d|�d��||k}	|j	�
��||�\}}|j	�||�\}}t
||gt|	�d	�\}}||f|j_|jd�|�D]}
d|
jd<q�|dur�t|�|_|r�|j�d
|�|jd�|�D]}||ur�|j|jjd|d�|j|jkr�|jj��q�d|_||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`rF��convertz-Attempting to set identical left == right == �> results in singular transformations; automatically expanding.�r��xlim_changed��emitroT)r��iterabler��_process_unit_info�_validate_converted_limits�convert_xunits�get_xlimrr&ryrDrE�limit_range_for_scaler�r/r6rxr<�get_siblingsrr0rI�processrqrGrH�	draw_idlerh)r\�left�rightr_rorWrX�old_left�	old_rightr�r�otherrdrdre�
set_xlim3d�sV
�

��zAxes3D.set_xlim3d)�ymin�ymaxcC�|dur
t�|�r
|\}}|dur|durtd��|}|dur)|dur'td��|}|jd||ffgdd�|�||j�}|�||j�}|��\}}|durO|}|durU|}||krbt�d|�d��||k}	|j	�
��||�\}}|j	�||�\}}|	r�||}}||f|j
_|jd�|�D]}
d|
jd<q�|dur�t|�|_|r�|j�d	|�|jd�|�D]}||ur�|j|j
jd|d
�|j|jkr�|jj��q�d|_||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`rFrY�-Attempting to set identical bottom == top == r[�ylim_changedr^T)r�r`r�rarb�convert_yunits�get_ylimrr&r|rDrErer6r{r<rfrr/r1rIrgrrrGrHrhrh)r\�bottom�topr_rororp�
old_bottom�old_top�swappedrrmrdrdre�
set_ylim3d�X
�


��zAxes3D.set_ylim3d)�zmin�zmaxcCrq)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`rFrYrrr[�zlim_changedr^T)r�r`r�rarbrm�get_zlimrr&rkrDrErer7rxr<rfrr/rrIrg�set_zlimrGrHrhrh)r\rvrwr_ror}r~rxryrzrrmrdrdre�
set_zlim3dNr|zAxes3D.set_zlim3dcC�t|jj�Sr�)�tupler6rxrirdrdrerT��zAxes3D.get_xlim3dcCr�r�)r�r6r{rirdrdrerU�r�zAxes3D.get_ylim3dcCr�)zGet 3D z limits.)r�r7rxrirdrdrerV�szAxes3D.get_zlim3dcCsdd�t���|j��S)Nz3
        Return the zaxis scale string %s

        z, )r=�mscale�get_scale_namesrk�	get_scalerirdrdre�
get_zscale�s�
zAxes3D.get_zscalecK�4|jj|fi|��|jddd�|��d|_dS)NF)rrT)ry�
_set_scaler)�_update_transScalerh�r\�valuer`rdrdre�
set_xscale��
zAxes3D.set_xscalecKr�)NF)rrT)r|r�r)r�rhr�rdrdre�
set_yscale�r�zAxes3D.set_yscalecKr�)NF)rrT)rkr�r)r�rhr�rdrdre�
set_zscale�r�zAxes3D.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_ticks�get_majorticklabels�get_minorticklabels�get_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.
        cO�dS)z:Currently not implemented for 3D axes, and returns *None*.Nrd)r\r_r`rdrdre�clabel�sz
Axes3D.clabelcCsTd|_|dur|j|_n||_|dur|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.
        �
Nrrr�r)�
vertical_axis)	rpr3r!r2r r�
check_getitem�dict�_vertical_axis)r\r!r r�rdrdrer:�s

�zAxes3D.view_initcCstjtjtjd�|d�|_dS)zx
        Set the projection type.

        Parameters
        ----------
        proj_type : {'persp', 'ortho'}
        )r�ortho)r#N)rr�r�persp_transformation�ortho_transformation�_projection)r\r#rdrdrer4�s��zAxes3D.set_proj_typecCst�||jd�S)z1Roll arrays to match the different vertical axis.r�)r��rollr�)r\�arrrdrdre�_roll_to_verticalrzAxes3D._roll_to_verticalcCs2|�|j�}tjg|���|���|���Rd|i�}d|}t�|j	�}t�|j
�}t�|�t�|�}t�|�t�|�}t�|�}|�|||g�}	||j
|	}
|
|_||
|_|jtj�|j�|_t�d�}t|�dtjkrvdnd||j<t�|
||�}|�|j
|j
�}
t�||�}t�|
|�}|S)z?Create the projection matrix from the current viewing position.�	pb_aspect��?r����r)r�r�r�world_transformationrTrUrVr��deg2radr!r �cos�sinrpr�r�r�r��zeros�abs�pir��view_transformationr��dot)r\r$�worldM�R�elev_rad�azim_rad�p0�p1�p2�psr��V�viewM�projM�M0rDrdrdrer�s8����


 zAxes3D.get_projr�cCs*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_1d�tolist�_rotate_btn�	_zoom_btn)r\�
rotate_btn�zoom_btnrdrdrerFBszAxes3D.mouse_initcCs|jggd�dS)z2Disable mouse buttons for 3D rotation and zooming.)r�r�N)rFrirdrdre�disable_mouse_rotationTrzAxes3D.disable_mouse_rotationcCr�)z�
        Return whether this axes supports the zoom box button functionality.

        3D axes objects do not use the zoom box button.
        Frdrirdrdre�can_zoomX�zAxes3D.can_zoomcCr�)z�
        Return whether this axes supports the pan/zoom button functionality.

        3D axes objects do not use the pan/zoom button.
        Frdrirdrdre�can_pan`r�zAxes3D.can_pancs�t���|j��|jdur8|jjj|j_|jjj|j_|j��\}}|j||ddd�|j�	|jj�
��n|j�	d�z|�dd�Wn	tyOYnwd|_|j
tjur_td|_nd|_|�td	�dS)
NFr^�linearrrTzaxes.zmarginr&zaxes3d.grid)r@�clark�clearr;�major�minorr�r�r�r�r�rr�rr�r	r!�grid)r\rQrRrbrdrer�hs&


�z
Axes3D.clacCs`|j|kr*|j|_|j|j|_|_t|jj	d�}|r,|�
�dur.|jj	j��dSdSdSdS�N�toolbar)
�inaxes�buttonr��xdata�ydata�sx�syr�rGrH�
_nav_stackr��push_current�r\rr�rdrdrerN�s
�zAxes3D._button_presscCs.d|_t|jjd�}|r|jjj��dSdSr�)r�r�rGrHr�r�r�rdrdrerO�s
�zAxes3D._button_releasecCs|��|��|��|j|jfSr�)rdrur�r!r rirdrdre�	_get_view�s�zAxes3D._get_viewcCs.|\}}}}}|j|||d�||_||_dS)N)rrr)�setr!r )r\�viewrrrr!r rdrdre�	_set_view�s
zAxes3D._set_viewc	Cs<z|�|�WSttfy|j��j}||�}|YSw)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
        )rE�AttributeErrorr�rk�get_major_formatter�format_data_short)r\r�func�valrdrdre�format_zdata�s�zAxes3D.format_zdatacs�|jdurdS|j|jvrd|jd�d|jd�d��dd�St|����fd	d
�d�\}}|\}}}|\}}	}
t�	|�|��}t�	|�|	��}||}
||
|||
|
}t
���||j�\}}}|�|�}|�
|�}|�|�}d|||fS)
z�
        Given the 2D view coordinates attempt to guess a 3D coordinate.
        Looks for the nearest edge to the point and then assumes that
        the point is at the same z location as the nearest point on the edge.
        N�zazimuth=z.0fu°, elevation=�°�-u−cst�|d|d��f�S)Nrr)r�_line2d_seg_dist)�edge��xd�ydrdrer��s�z%Axes3D.format_coord.<locals>.<lambda>)r�zx=%s, y=%s, z=%s)rDr�r�r r!�replace�minr�r��hypotr�
inv_transform�format_xdata�format_ydatar�)r\r�r�r�r�rJrNrQrKrOrR�d0�d1�dtrrr�xs�ys�zsrdr�re�format_coord�s,
��
�




zAxes3D.format_coordcCs�|jsdS|jdurdS|j|j}}|durdS||j||j}}|j}|j}|||_|_|j|jvrj|dkrA|dkrAdSt	�
|j||d�|_t	�
|j||d�|_|�
�d|_|jj��dS|jdk�r|dkrz|dkrzdS|��\}}	}
}}}
d|||}d|||}t�|j�t�|j�}}|	||t�|�t�|�|t�|�}||
|t�|�|t�|�t�|�}|
||t�|�}|�|||	|�|�|
|||�|�|||
|�|�
�|jj��dS|j|jv�r[|��\}}	}
}}}
d|||}|	||}||
|}|
||}|�|||	|�|�|
|||�|�|||
|�|�
�|jj��dSdS)z�
        Mouse moving.

        By default, button-1 rotates and button-3 zooms; these buttons can be
        modified via `mouse_init`.
        Nr�Tr�r)r�rDr�r�r�r�rVrWr�r�_norm_angler!r r�rhrGrHrhr�r�r�r�r�rnr{r�r�)r\rrr�dx�dy�w�hr�r�r�r�r�r�r!r �dxx�dyy�dzz�df�dzrdrdrerM�s\
.0�zAxes3D._on_movecKs&|dur||j_|jj||fi|��S)zI
        Set zlabel.  See doc for `.set_ylabel` for description.
        N)rk�labelpad�set_label_text)r\�zlabel�fontdictrr`rdrdre�
set_zlabelszAxes3D.set_zlabelcCs|j��}|��S)z.
        Get the z-label text string.
        )rk�	get_label�get_text)r\�labelrdrdre�
get_zlabels
zAxes3D.get_zlabelcCr�)z)Get whether the 3D axes panels are drawn.)r�rirdrdre�get_frame_on&r�zAxes3D.get_frame_oncCst|�|_d|_dS)zs
        Set whether the 3D axes panels are drawn.

        Parameters
        ----------
        b : bool
        TN)r/r�rhrrdrdre�set_frame_on*s

zAxes3D.set_frame_onz3.5r�visiblecKst|�rd}||_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)r%�
_draw_gridrh)r\rr`rdrdrer�5s
zAxes3D.gridcKs||dv}|dv}|dv}|r|j��jdi|��|r&|j��jdi|��|r3|j��jdi|��|j||||d�dS)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.
        r,r-r.r$Nrd)ryrD�
set_paramsr|rkr
)r\r�r#r`�_x�_y�_zrdrdre�locator_paramsFs

�zAxes3D.locator_paramscs�tjgd�|d�|dvrt�j|fi|��|dvrBt|�}|�dd�|�dd�|�dd�|�d	d�|jjd
i|��dSdS)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.
        )rrrr+�r�)rrr+r.rwNrv�labeltop�labelbottomrd)rr
r@�tick_paramsr�r?rk�set_tick_params)r\r�r`�zkwrbrdrer]s�zAxes3D.tick_paramscCs |��\}}|j||dd�dS)z$
        Invert the z-axis.
        Nrn)r�r��r\rvrwrdrdre�invert_zaxisszAxes3D.invert_zaxiscCs|��\}}||kS)z9
        Returns True if the z-axis is inverted.
        �r�rrdrdre�zaxis_inverted�szAxes3D.zaxis_invertedcCs$|��\}}||kr||fS||fS)zP
        Return the lower and upper z-axis bounds, in increasing order.
        r!rrdrdre�
get_zbound�szAxes3D.get_zboundcCsd|dur
t�|�r
|\}}|��\}}|dur|}|dur|}|jt||ft|���d�dd�dS)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\rn)r�r`r#r�r�r/r")r\�lower�upper�	old_lower�	old_upperrdrdrerI�s
�
�zAxes3D.set_zboundcs*t�j|||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@�textr�
text_2d_to_3d)r\rrr�s�zdirr`r(rbrdrer(�szAxes3D.text�r+c
s�|��}|rt|dt�s|^}}d|vrtd��n|�dd�}t�|t�|��}t�j	||g|�Ri|��}|D]
}	t
j|	||d�q9t
�||||�\}}}|�
||||�|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`.
        rr�z+plot() for multiple values for argument 'z'�r�r+)�has_datar��strr�r?r��broadcast_tor�r@�plotr�
line_2d_to_3d�juggle_axesr=)
r\r�r�r+r_r`r<r��lines�linerbrdrer1�s�zAxes3D.plotr/r_r`)r�)r��vmin�vmax�lightsourcec"s0|��}
|jdkr
td��t�|�}t�|||�\}}}|j\}}d|	vp(d|	v}
d|	vp0d|	v}|
r9|r9td��|	�dd��|	�dd��|	�dd	�}|	�dd	�}t	d
rX|}n|
}|rut
tt�||�d���t
tt�||�d���d|	vr|	�d�}n|	�d
d�}|dur�|j
��}t�t�|��}d}|	�dd�}|	�d|du�}|dur�tjddd�g}|d�dkr�|d�dkr�|dur�tj��fdd�|||fD�dd�}nnttd|d���|dg}ttd|d���|dg}g}t|dd�|dd��D]@\��t|dd�|dd��D]-\������fdd�|||fD�}t�|�j}|�|�|du�rD|�|����q�qt|tj��rWt�|����r�g}g}t� ||�D]#\}}t�|�t�|�jdd�}t!|��r�|�|�|�|��qa|}|du�r�|}t"j#|g|�Ri|	��} |du�r�|�r�|�$||�%|�|�}| �&|�| �'|�nR|�r�t|tj��r�|dj(dd�}!n
t�dd�|D��}!| �)|!�|du�s�|du�r�| �*||�|du�r�| �+|�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.�rstride�cstride�rcount�ccount�.Cannot specify both stride and count argumentsr��2�_internal.classic_moder�
facecolors�colorN�cmap�shader�z�Passing 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.r�rcsg|]	}t�|����qSrd)r�_array_patch_perimeters�r��a)r;r:rdre�
<listcomp>ds�z'Axes3D.plot_surface.<locals>.<listcomp>r�rc	s.g|]}t�|��d���d�f��qS)r)r�_array_perimeterrF)�cs�cs_next�rs�rs_nextrdrerHos ��).r�cSs g|]}|dd�df���qS�Nr�)�mean)r�r�rdrdrerH�s ).r.�ndimr�r�_to_unmasked_float_arrayr��broadcast_arraysr�r?r	�intr��ceil�
_get_lines�get_next_color�array�mcolors�to_rgba�getrrZ�stack�list�range�zip�T�appendr��ndarray�isnan�any�	itertools�zip_longestr%r�Poly3DCollection�
_shade_colors�_generate_normals�set_facecolors�set_edgecolorsrO�	set_array�set_clim�set_norm�add_collectionr=)"r\r9r:r;r�r6r7r8r_r`r<�rows�cols�
has_stride�	has_countr<r=�compute_strides�fcolorsrBrCrD�colset�polys�row_inds�col_indsr��	new_polys�
new_colset�p�col�new_poly�polyc�avg_zrd)rJrKr;rLrMr:re�plot_surface�s�G



���""�

��


�

�



��

zAxes3D.plot_surfacec
Cs:t|tj�r>|jd}d|dd|d}}}|d|dd�f|d|dd�f}|d|dd�f|d|dd�f}nYt�t|�df�}t�t|�df�}t|�D]B\}}	t|	�}d|dd|d}}}|	|dd�f|	|dd�f||dd�f<|	|dd�f|	|dd�f||dd�f<qTt�||�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.
        ���rr�r�.N)r�r�rar��emptyr%�	enumerate�cross)
r\�polygons�n�i1�i2�i3�v1�v2�poly_ir�rdrdrerh�s
$&,.zAxes3D._generate_normalsc	s�|durtjddd�}tjdd��|tjj|ddd	�|j}Wd�n1s*wYt�|�}|��rvt�	d
d��t�	dd�j
���fdd
�}d||<t�|�}|dd�df}||�dd�tjf|}||dd�df<|St�
|���}|S)z�
        Shade *color* using normal vectors given by *normals*.
        *color* can also be an array of the same length as *normals*.
        N��g
�-��x3@)�azdeg�altdeg�ignore)�invalidrT)r��keepdimsr��333333�?cs��|��Sr�rd)r��in_norm�out_normrdrer��r�z"Axes3D._shade_colors.<locals>.normrr�)rX�LightSourcer��errstater�r��	directionrbrc�	Normalize�inverse�
to_rgba_array�newaxis�
asanyarray�copy)	r\rB�normalsr8rD�maskr��alpha�colorsrdr�rerg�s(��

�zAxes3D._shade_colorscs�|��}�jdkr
td��t�����\����j\}}d|vp#d|v}	d|vp+d|v}
|	r4|
r4td��|�dd�}|�dd�}|�dd	�}
|�dd	�}td
rs|
rr|
r`tt	t�
||
�d��nd}|rptt	t�
||�d��nd}n"|	s�|
r�tt	t�
||
�d��nd}|r�tt	t�
||�d��nd}t���t���t������|r�tt
d||��}|dkr�|d|dkr�||dg7}ng}|r�tt
d||��}|dkr�|d|dkr�||dg7}ng}|dkr�|dkr�td
���jdkr�g}g}�fdd�|D�}�fdd�|D�}�fdd�|D�}�fdd�|D�}�fdd�|D�}�fdd�|D�}dd�t|||�D�dd�t|||�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`.
        r�r9r:r;r<r=r>rr?r@rr�z*Either rstride or cstride must be non zeroc�g|]}�|�qSrdrd�r��i)r9rdrerHe�z)Axes3D.plot_wireframe.<locals>.<listcomp>cr�rdrdr�)r:rdrerHfr�cr�rdrdr�)r;rdrerHgr�cr�rdrdr�)�tXrdrerHir�cr�rdrdr�)�tYrdrerHjr�cr�rdrdr�)�tZrdrerHkr�cS�"g|]
\}}}tt|||���qSrd�r\r^�r��xl�yl�zlrdrdrerHm��cSr�rdr�r�rdrdrerHor�)r.rPr�r�rRr�r?r	rSr�rT�	transposer\r]�sizer^r�Line3DCollectionrnr=)r\r9r:r;r_r`r<rorprqrrr:r;r<r=�rii�cii�xlines�ylines�zlines�txlines�tylines�tzlinesr4�linecrd)r9r:r;r�r�r�re�plot_wireframesp'

  �  "��

�
��
zAxes3D.plot_wireframe)rBr�r6r7r8cOs�|��}|dur
|j��}t�t�|��}|�dd�}	|�d|	du�}
t	j
|i|��\}}}z|�d�}Wn
tyB|^}}Ynwt�|�}|�
�}
|j|
}|j|
}||
}tj|||fdd�}tj|g|�Ri|��}|	r�|dd�dd�dfjdd�}|�|�|dus�|dur�|�||�|dur�|�|�n|
r�|�|�}|�|||�}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
        NrCrDr;r�rr�r)r.rUrVr�rWrXrYrZr?r
�get_from_args_and_kwargs�KeyErrorr��get_masked_trianglesrrr[rrfrOrkrlrmrhrgrirnr=)r\rBr�r6r7r8r_r`r<rCrD�trir�	triangles�xt�yt�zt�vertsr~rr�rurdrdre�plot_trisurfxsH5
��




�


zAxes3D.plot_trisurfr�c	Cs�|j}|j}|d|dd}t||�D]�\}}|��}|s qt�|||�}	t�|||�}
|��d}g}g}
tt|	d�|�}|dkrTt|	d�dkrSd}nqt|	d�d|d}t	t
t|��d�D]-}t
t||��}t
t|d|��}|�|	d||	d||
d||
d|g�qjt�
|�}|�|�}
|�||
�}|�||
�}tj|||d�}|�|�|�|�q|D]}|��q�dS)z4
        Extend a contour in 3D by creating
        rrr��rA�
edgecolorsN)�levels�collectionsr^�	get_pathsr�_paths_to_3d_segments�
get_edgecolor�roundr%r]rSr`r�rWrhrgrf�
set_sort_zpos�add_collection3d�remove)r\�cset�strider��collsrrr��paths�topverts�botvertsrB�	polyvertsr��nsteps�stepsizer�r�r�r��colors2�polycolr|rdrdre�_3d_extend_contour�sN


�

�

�zAxes3D._3d_extend_contourcCsTd|}|r|�||�dSt|j|j�D]\}}|dur|}tj|||d�qdS)Nr�r,)r�r^r�r�r�line_collection_2d_to_3d)r\r��extend3dr�r+�offsetrr�rdrdre�add_contour_sets�zAxes3D.add_contour_setcCs|j|||d�dS)N�r+r�)�_add_contourf_set)r\r�r+r�rdrdre�add_contourf_setszAxes3D.add_contourf_setc	Cs�d|}|jdd�t�|j�d}|jr.|jdt�|jdd��d}t�|d|�}|jrH|jdt�|jdd��d}t�||�}t||j�D]\}}|durX|}t	j
|||d�|�|�qN|S)z�
        Returns
        -------
        levels : numpy.ndarray
            Levels at which the filled contours are added.
        r�Nr�r�rr�r,)r�r��diff�_extend_min�insert�_extend_maxr`r^r�r�poly_collection_2d_to_3dr�)	r\r�r+r��	midpoints�	min_level�	max_levelrr�rdrdrer�s""zAxes3D._add_contourf_set)r�r�r+r�csb|��}
t�||||�\}}}
t�j|||
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
        )r.r�rotate_axesr@�contourr�r=)r\r9r:r;r�r�r+r�r_r`r<�jX�jY�jZr�rbrdrer�7s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;)r.r
r�rrr?rr�r�r�r@�
tricontourr�r=)r\r�r�r+r�r_r`r<r�r9r:r;r�r�r�r�rbrdrer�`s"!��zAxes3D.tricontourcs>d|d|d|||i��fdd�dD�}|jg|�|�R�dS)Nrrrcs(g|]}t��|�t��|�f�qSrd�r��nanmin�nanmax)r��dim��dim_valsrdrerH�s �z/Axes3D._auto_scale_contourf.<locals>.<listcomp>r)r=)r\r9r:r;r+r�r<�limitsrdr�re�_auto_scale_contourf�s

�zAxes3D._auto_scale_contourfr�csb|��}t�||||�\}	}
}t�j|	|
|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
        )r.rr�r@�contourfr�r�)r\r9r:r;r+r�r_r`r<r�r�r�r�r�rbrdrer��s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;)r.r
r�rrr?rr�r�r�r@�tricontourfr�r�)r\r+r�r_r`r<r�r9r:r;r�r�r�r�r�rbrdrer��s"��zAxes3D.tricontourfrcs�t�|�}|jr
t�|�nd}t|�tjur$tj|||d�|�	|�n)t|�tj
ur9tj|||d�|�	|�nt|�tjurMtj
|||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-)r�r�r�r�r�r��PolyCollectionrr�r��LineCollectionr��PatchCollection�patch_collection_2d_to_3dr@rn)r\r|r�r+�zvals�zsortval�
collectionrbrdrer��s

�
zAxes3D.add_collection3d)	r�r�r�r*r��c�	facecolorrArB)�
replace_names�c
s�|��}
|}tjdd�|||fD��\}}}tj�|�}t�|||||�\}}}}}t�||�r4|��}t	�j
||g|�R||d�|	��}tj||||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|]
}t�tj�|tj���qSrd)r�r6�ma�filled�nan)r��trdrdrerHL	s"z"Axes3D.scatter.<locals>.<listcomp>)r*r)r�r+�
depthshade皙�����?r)r.r�rRr
r6r�delete_masked_points�may_share_memoryr�r@�scatterrrr!r�r"r=)
r\r�r�r�r+r*rrr_r`r<�zs_orig�patchesrbrdrer	s"2
�"
�
zAxes3D.scattercs�|��}t�j||g|�Ri|��}t�|t|��}g}	g}
t||�D]*\}}t�|�}
|	|
�	�7}	|
|gt|
�7}
t�
|||�d|vrM|�|d�q#t|	�dkr[t|	�\}}ngg}}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)r.r@�barr�r0r%r^r�_get_patch_vertsr��patch_2d_to_3d�	set_alphar3r=)r\rir�r�r+r_r`r<rr��verts_zsr{r�vsr�r�rbrdrerb	s&
�
z
Axes3D.bar�averagecOs�|��}
t�t�|�|||||�\}}}}}}t�|�}t�||�}t�|�}t�||�}t�|�}t�||�}t�gd��}t�|j|j�}d||fd||fd||ffD]%\}}}|dtj	tj	f}|dtj	tj	f}|||d|f|d|f<qY|�
d|jdd��}g}|dur�|j��g}t
t�|��}t|�t|�kr�|D]
}|�|gd�q�n|}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.
        ))�rrr�rrr�rrr�rrr)�rrr�rrr�rrr�rrr)rrr!r )rr#r"r)rr r#r)rrr"r!rrr�.)r�Nr�)�zsortr)r.r�rRr�r�r�rWr�r�r��reshape�_get_patches_for_fillrVr\rXr�r%�extendrhrgrrfrnr=)r\rrrr�r�rrBr$rDr8r_r`r<r�r�r�r�r�r��cuboidrvr�r{�dprArr��sfacecolorsr|rdrdre�bar3d�	sV?�


.&�
���
zAxes3D.bar3d�centercs<t�j|f||d�|��}|j��\}}|j�d|�|S)N)r
�locgq=
ףp�?)r@�	set_title�titler��set_y)r\rr
r-r`�retrrrbrdrer.>
szAxes3D.set_titler��tail)�length�arrow_length_ratio�pivot�	normalizecs�ddd�}|��}d}	t|�|	krtd|	t|�f��|d|	�}
dd�|
D�}tjg|
�|�R�}|d|	�}
||	d�}|rQt�tj|���fd	d�|
D�}
nd
d�|
D�}
tdd�|
D��rxt	j
gg||	d��Ri|��}
|�|
�|
Stjd
|gt
d�}||}tjgd�|d�|dkr�||8}n
|dkr�||d8}t�|
dd��}t�|
d|	���t
�}tjj|dd�}|dk�|�}|r�|�|��d�}n|�}t|�dk�r|tj�||��dd�}||�}|dd�dd�ftj�||�}|�t|�ddf�}|�dd�}g|�|�}ng}t	j
|g||	d��Ri|��}
|�|
�|�|dd�df|dd�df|dd�df|�|
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|dd�df}|dd�df}tjj|dd�dd�fdd�}tj|||dkt�|�d�}tj|||dkt�|�d�}t�|�}t�|�}t�	|�}	t�
||dd|||d|||	g||d|||dd|||	g||	||	t�||�gg�}
|
��}|gd�gd�fd9<t�
d	|
|�}t�
d	||�}
tj||
gdd�}|S)
Nrrr�r)�where�out)rrr�r�)r�r�rrr�zij...,...j->...i)r�r�r��divide�
zeros_like�	ones_like�math�radiansr�r�rW�	full_liker��einsumr[)�UVW�anglerrr��x_p�y_p�rarr*�Rpos�Rneg�	Rpos_vecs�	Rneg_vecs�	head_dirsrdrdre�calc_arrowss
s( 


(*��z"Axes3D.quiver.<locals>.calc_arrowsr�z-Wrong number of arguments. Expected %d got %dNcSs g|]}t|tjj�r|j�qSrd)r�r�r
�MaskedArrayr��r��krdrdrerH�
s�z!Axes3D.quiver.<locals>.<listcomp>cs g|]}tjj|�d����qS)�r�)r�r
rW�
compressedrMrOrdrerH�
s�cSsg|]}t�|��qSrd)r�r6rMrdrdrerH�
scss�|]	}t|�dkVqdS)rN)r%)r��vrdrdrer��
��z Axes3D.quiver.<locals>.<genexpr>r&r�)r2�middle�tip)r5r2rSr�r�rrr)r�rr�)r7)r.r%r�r�rRr�reduce�
logical_orrcrr�rnrWr�rr
r5�astyper�r�r%�multiply�outer�swapaxesr=)r\r3r4r5r6r_r`rKr<�argi�
input_args�masks�bcastr��shaft_dt�arrow_dt�XYZrAr��shaftsrJ�headsr4rdrOre�quiverE
sb
.
�
� 

" 
4z
Axes3D.quiver)rAr�rDr8c2	s�t|�dkrdd�}ndd�}||i|��\}�}�jdkr"td��tj�jtjd�}	t|	d��|dur>t���\}
}}n�fd	d
�|D�\}
}}�fdd�}
|durY|j	�
�}|
|d
�}|
|d�}|�|
||�tjgd�gd�gd�gd�gtjd�}tt
�}dd�}|d�D]�}|j�|	�\}}}t�|�}t�|�}t�|�}|�|j�}|ddd�}|D]�}|D]�}|�||dg�}t|�}�|r�||�||�t|dd�|dd��D]C\}}|�|||g�} |�|||g�}!t| �}"t|!�}#�|"�r�|#�s||"�|!|�q߈|"�s"�|#�r"||#�|!|�q�|�|||dg�}$|�|||g�}%t|$�}&�|&�rG||&�|%|�q�q�q�i}'|��D]�\}(})|du�r\|)}*nHg}*|)D]C}+|+dd�df|+dd�df|+dd�dff},t�|+j�}-|
|,|-dd�df<||,|-dd�df<||,|-dd�df<|*�|-��q`||(}.||(}/|�r�|�|*�}0|�|.|0|�}.|/du�r�|�|/|0|�}/tj|*f|.|/d�|��}1|�|1�|1|'|(<�qP|'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
        r�c[s|||f||fSr�rd)�
_Axes3D__x�
_Axes3D__y�
_Axes3D__zrr`rdrdre�voxels(szAxes3D.voxels.<locals>.voxelsc[s
d||fSr�rd)rr`rdrdrerh+s
z%Argument filled must be 3-dimensionalr�rNc3s�|]	}t�|��VqdSr�)r�r0)r�r)�coord_shaperdrer�:rRz Axes3D.voxels.<locals>.<genexpr>cslt�|�dvrt�|�jt�|��St�|�dvr/t�|�dd��jkr-td�|���|Std�|���)N)rr)r�r�r�z8When multidimensional, {} must match the shape of filledzInvalid {} argument)r�rPr0r�r��format)rBr�)rrdre�_broadcast_color_arg<s�z+Axes3D.voxels.<locals>._broadcast_color_argrAr�rrrrcss:�tj|tjd�}t|�D]
}|Vtj|ddd�}q
dS)z%Generate cyclic permutation matrices.r�rrrN)r�r��intpr]r�)r��matr�rdrdre�permutation_matrices_s��z+Axes3D.voxels.<locals>.permutation_matricesr�rr�r�)r%rPr�r�rWr�rlr��indicesr&rVr=rr\r_r��aranger`r^�itemsr�rhrgrrfr�)2r\rAr�rDr8r_r`rh�xyzr�rrrrk�square�voxel_facesrn�permute�pc�qc�rc�pinds�qinds�rinds�square_rot_pos�square_rot_negr{�qr��i0�r1�r2r�r�r�r��pk�pk2�ikr��coord�
faces_inds�faces�	face_inds�ind�facer�	edgecolorr��polyrd)rirrerh�
s�H




��	


"�
���"
.

����
z
Axes3D.voxels)rrr�xerr�yerr�zerrr�cC
s:|��}t�|tj�}dd�|��D�}|�dd�|jd|fd|fd|fg|dd	�t�	|�r2|n|g}t�	|�r<|n|g}t�	|�rF|n|g}t
|�t
|�kr\t
|�ksatd
��td
��t|	t
�rjd|	f}	t|	t�r�t
|	�dkr�t|	dt
�r�t|	dt
�r�t|	dd
|	d�}	n>td|	�d���t|	t�r�n0t|	t�s�t�	|	�r�z||	Wnttfy��z	td|	�d����d
��wwtd|	�d���|�dd
�}d|d<|jj|dkr�||fn|||f|dd�\\}}tj||d�|�r|�|dd�n	|�|dd�|��dk�r|�|�nd
}|�d�d|v�r'd|d<|
d
u�r0|d}
dD]	}|�|d
��q2i|�d|
i�}|�rL||d<nd|v�rW|d|d<dD]}||v�rf||||<�qYi|�dd i�}|d
u�rytd!}|dk�r�d"||d#<|
d
u�r�|
|d$<|
|d<t�t
|�t��d�|	<d%d&�}�fd'd(��ggg}}}g} d)d)d*d+�}!dddd,��|�d#td-�d}"|"|jjd.9}"|j �!��"d/|"|"fg�}"t�#tj$|"dd0��}"tj%|ddd1��tj&�'|�(��}#Wd
�n	1�swYt�)|#t�*|"dddg��d}"|"d29}"i|�|"dd3��}$|$�d#d
�t+gd,�|||g|||g|||g|||g�D�]\}%}&���t�,|%���|%}'�d
u�rV�q>t�	���sc�gt
|&��t�-���t�.�t
|&���/t��t�.�t
|&���/t�������fd4d5�t0|||g�D�}(|(\\})}*\}+},\}-}.��B}/|/�1��r�|dk�r�||)|+|-g|/�@�}0||*|,|.g|/�@�}1tj2|0d|!|'d6�|��}2tj2|1d|!|'d6�|��}3|�|2�|�|3�|�3|2�|�3|3���1��r||*|,|.g��@�\}4}5}6|j4|4|5|6g��Ri|$����1��r-||)|+|-g��@�\}7}8}9|j4|7|8|9g��Ri|$��tj5t�*|(�j6fi|��}:|�7|:�|�3|:�| �3|(��q>t�*| �} �fd7d8�};|;| d�\}<}=|;| d�\}>}?|;| d�\}@}A|�8|<|=f|>|?f|@|Af|�t9j:|t|�t|�f|d
u�p�|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�rd)r�rNrQrdrdrer�%sz#Axes3D.errorbar.<locals>.<dictcomp>r�r�rrrFrYz)'x', 'y', and 'z' must have the same sizerrNzerrorevery=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_r�T)�
return_kwargs)r�g�������?�nonerB�C0)
�marker�
markersize�markerfacecolor�markeredgewidth�markeredgecolor�	markevery�	linestyle�	fillstyle�	drawstyle�
dash_capstyle�dash_joinstyle�solid_capstyle�solid_joinstyle�	linewidth)rUr�r��
rasterizedr��Nonezerrorbar.capsizeg@r�r�cs�fdd�|D�S)Ncsg|]
}gt�|����qSrd)rd�compress)r�rWrOrdrerH�sz8Axes3D.errorbar.<locals>._apply_mask.<locals>.<listcomp>rd)�arraysr�rdrOre�_apply_mask�sz$Axes3D.errorbar.<locals>._apply_maskcsZt|j�dkr|\}}n||}}t�|�B|||�}t�|�B|||�}||fSrN)r%r�r�r8)�err�data�lomask�himask�low_err�high_err�lows�highs)�	everymaskrdre�
_extract_errs�s

z&Axes3D.errorbar.<locals>._extract_errs�|�_)rrr�rzlines.markersize�Hr.r)r r!gV&,t=�?)r3r4cs&g|]\}}���||����qSrdrd)r�r�r�)r��
dir_vectorr��lolims�uplimsrdrerH�s��z#Axes3D.errorbar.<locals>.<listcomp>)�lsr�c	sLt�|dd��|dd�dd�f�t�|dd��|dd�dd�f�fSr�r�)�err_arr�coord_label)�i_xyzrdre�_digout_minmax
s$$�z'Axes3D.errorbar.<locals>._digout_minmax)�has_xerr�has_yerrr)<r.r�normalize_kwargsrArBrq�
setdefaultrar�r`r%r�r�rr��slicer/�
IndexErrorr?rU�
_plot_argsrr2�
set_zorderr$�add_liner	r�r/rZrG�dpi�	transAxesrTrUrOr�r�r��invr�r�rWr^�get_dir_vectorr�r0rWr�rc�Line3Dr`rdr�r_rnr=�
mcontainer�ErrorbarContainer�
containers)Cr\rrrr�r�r��fmt�	barsabove�
errorevery�ecolor�
elinewidth�capsize�capthick�xlolims�xuplims�ylolims�yuplims�zlolims�zuplimsr`r<r�	data_line�
base_styler��eb_lines_style�eb_cap_styler��errlines�caplines�limmarks�	coorderrs�	capmarker�
quiversize�invM�eb_quiver_styler+r��i_zdir�coorderrr��xhr��yhr��zh�nolims�lo_caps_xyz�hi_caps_xyz�cap_lo�cap_hi�xh0�yh0�zh0�xl0�yl0�zl0�errliner�r�r�r�r�r�r��errorbar_containerrd)r�r�r�r�r�r�r�re�errorbar�sLk��

��
�

����
��





�



��
����


�
����





�


�
zAxes3D.errorbar��for_layout_onlyc		s�t�j||||d�}|g}|jr:|��D]%}|��r2z	|j||d�}Wnty1|�|�}Ynw|r9|�|�qtj�	|�S)N)�call_axes_locator�bbox_extra_artistsr�r�)
r@�
get_tightbboxrgr��get_visibler�r`r�r�union)	r\r�r�r�r�r1�batchr��axis_bbrbrdrer�
s*�
��
�zAxes3D.get_tightbboxzC0-�C0ozC3-)�linefmt�	markerfmt�basefmtrvr�orientationcs�ddlm}
|��}tjgd�|	d�t�|�t�|�f}t�|�t�|�f}
t�|�t�|�f}|	dkrM||
}}||}}�fdd�t|||�D�}n3|	dkri||}}||}}�fd	d�t|||�D�}n||}}||
}}�fd
d�t|||�D�}t	|�\}}}|dur�t
d}|j|||�|	d
d�\}tj
|||d
d�}|�|�|j||||d
d�\}|
|||f|d�}|�|�t�||��g|	�\}}}|�g|�|�g|�|
�g|�|�|�|S)a�
        Create a 3D stem plot.

        A stem plot draws lines perpendicular to a baseline, and places markers
        at the heads. By default, the baseline is defined by *x* and *y*, and
        stems are drawn vertically from *bottom* to *z*.

        Parameters
        ----------
        x, y, z : array-like
            The positions of the heads of the stems. The stems are drawn along
            the *orientation*-direction from the baseline at *bottom* (in the
            *orientation*-coordinate) to the heads. By default, the *x* and *y*
            positions are used for the baseline and *z* for the head position,
            but this can be changed by *orientation*.

        linefmt : str, default: 'C0-'
            A string defining the properties of the vertical lines. Usually,
            this will be a color or a color and a linestyle:

            =========  =============
            Character  Line Style
            =========  =============
            ``'-'``    solid line
            ``'--'``   dashed line
            ``'-.'``   dash-dot line
            ``':'``    dotted line
            =========  =============

            Note: While it is technically possible to specify valid formats
            other than color or color and linestyle (e.g. 'rx' or '-.'), this
            is beyond the intention of the method and will most likely not
            result in a reasonable plot.

        markerfmt : str, default: 'C0o'
            A string defining the properties of the markers at the stem heads.

        basefmt : str, default: 'C3-'
            A format string defining the properties of the baseline.

        bottom : float, default: 0
            The position of the baseline, in *orientation*-coordinates.

        label : str, default: None
            The label to use for the stems in legends.

        orientation : {'x', 'y', 'z'}, default: 'z'
            The direction along which stems are drawn.

        data : indexable object, optional
            DATA_PARAMETER_PLACEHOLDER

        Returns
        -------
        `.StemContainer`
            The container may be treated like a tuple
            (*markerline*, *stemlines*, *baseline*)

        Examples
        --------
        .. plot:: gallery/mplot3d/stem3d_demo.py
        r)�
StemContainerr)rrcs&g|]\}}}�||f|||fg�qSrdrd�r��thisx�thisy�thisz�rvrdrerH~
��zAxes3D.stem.<locals>.<listcomp>rcs&g|]\}}}|�|f|||fg�qSrdrdrrrdrerH�
r
cs&g|]\}}}||�f|||fg�qSrdrdrrrdrerH�
r
Nzlines.linestyler�)r�r+r)�
linestylesr�r)r)�matplotlib.containerrr.rr
r�r�r�r^rr	r1rr�rn�
add_containerr3r=)r\rrrrrrrvrrrr<rrr�basex�basexlim�basey�baseylimr4r��
linemarker�	linecolor�baseline�	stemlines�
markerline�stem_container�jx�jy�jzrdrre�stem-
sVB



�



�



���

�

�(zAxes3D.stemr�)NN)NNF)Tr+N)NTTT)NNTF)NNr)rr�)T)r+N)r+)r�)Fr�rN)rN)rr)rrr	NT)NrTN)Nr,)NNNr�FrNNNNFFFFFF)TN)��__name__�
__module__�__qualname__�__doc__r��_axis_namesr�Grouperrr<rArBrCrmrPr�r�r
�get_zgridlines�get_zticklinesrr�r��w_xaxis�w_yaxis�w_zaxisr�r�r�r�r�r��martist�allow_rasterizationr�r�rrrrrrrr r"r*r3r=r)r�rnr{r�rT�maxesrdrUrurVr�r�r�r��maprj�
get_zticks�
set_zticks�get_zmajorticklabels�get_zminorticklabels�get_zticklabels�set_zticklabels�
zaxis_date�textwrap�dedentr�r:r4r�r�rFr�r�r�r�rNrOr�r�r�r�rMrrrr�rename_parameterr�rrr r"r#rIr(�text3D�text2Dr1�plot3D�delete_parameterr�rhrgr�r�r�r�r�r�rr��	contour3Dr�r�r��
contourf3Dr�r�r�	scatter3Drr+r.rd�quiver3Drhr�r�r�stem3D�
__classcell__rdrdrbrer,s|��q


�
�
�=*a		B�>�9�:�:
�




�
$
6
$G	"

)�O+$
v�e4��&�5
 1!G5�&��Y�b���trrcCs�t�dd|�}}t�||�\}}t�|d|dd�dtj}t�|ddd|dddd�dtjdd}||}|d}|d}|d}|||fS)	z,Return a tuple X, Y, Z with a test data set.g�g@r�rg�?r�r�i�)r�rp�meshgrid�expr�)rMrrr9r:�Z1�Z2r;rdrdre�
get_test_data�
s&*�
rF)r)>r"r�rrr�rdr=�numbersrr5�numpyr��
matplotlibrrrr�matplotlib.artistr�r*�matplotlib.axes�axesr,�matplotlib.collectionsr��matplotlib.colorsr�rX�matplotlib.image�imager?�matplotlib.linesr4rA�matplotlib.patchesrr��matplotlib.scale�scaler�r�	containerr��matplotlib.transforms�
transformsr�rr	�matplotlib.axes._baser
rr�matplotlib.tri.triangulationr
r�rrr�interpd�_define_aliasesrrFrdrdrdre�<module>sx�

Youez - 2016 - github.com/yon3zu
LinuXploit