U
    ÂmœdÁu  ã                   @   sF  d Z ddlmZ ddlZddlmZmZ ddlm	Z	 ddl
mZ ddlmZ dd„ ZG d	d
„ d
ƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd „ d eƒZG d!d"„ d"eƒZG d#d$„ d$eƒZG d%d&„ d&eƒZdS )'a  
Default legend handlers.

.. important::

    This is a low-level legend API, which most end users do not need.

    We recommend that you are familiar with the :doc:`legend guide
    </tutorials/intermediate/legend_guide>` before reading this documentation.

Legend handlers are expected to be a callable object with a following
signature::

    legend_handler(legend, orig_handle, fontsize, handlebox)

Where *legend* is the legend itself, *orig_handle* is the original
plot, *fontsize* is the fontsize in pixels, and *handlebox* is an
`.OffsetBox` instance. Within the call, you should create relevant
artists (using relevant properties from the *legend* and/or
*orig_handle*) and add them into the *handlebox*. The artists need to
be scaled according to the *fontsize* (note that the size is in pixels,
i.e., this is dpi-scaled value).

This module includes definition of several legend handler classes
derived from the base class (HandlerBase) with the following method::

    def legend_artist(self, legend, orig_handle, fontsize, handlebox)
é    )ÚcycleN)Ú_apiÚcbook©ÚLine2D)Ú	Rectanglec                 C   s(   t t| ¡ ƒd ƒ}|d k	r$|  |¡ d S ©N)ÚnextÚiterZget_childrenÚupdate_from)ZtgtÚsrcZfirst_child© r   úR/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/matplotlib/legend_handler.pyÚupdate_from_first_child(   s    r   c                   @   sJ   e Zd ZdZddd„Zdd„ Zdd	„ Zd
d„ Zdd„ Zdd„ Z	dd„ Z
dS )ÚHandlerBasea  
    A base class for default legend handlers.

    The derived classes are meant to override *create_artists* method, which
    has the following signature::

      def create_artists(self, legend, orig_handle,
                         xdescent, ydescent, width, height, fontsize,
                         trans):

    The overridden method needs to create artists of the given
    transform that fits in the given dimension (xdescent, ydescent,
    width, height) that are scaled by fontsize if necessary.

    ç        Nc                 C   s   || | _ | _|| _dS )al  
        Parameters
        ----------

        xpad : float, optional
            Padding in x-direction.
        ypad : float, optional
            Padding in y-direction.
        update_func : callable, optional
            Function for updating the legend handler properties from another
            legend handler, used by `~HandlerBase.update_prop`.
        N)Ú_xpadÚ_ypadÚ_update_prop_func)ÚselfZxpadZypadZupdate_funcr   r   r   Ú__init__>   s    zHandlerBase.__init__c                 C   s(   | j d kr|  ||¡ n|   ||¡ d S r   )r   Ú_default_update_prop©r   Úlegend_handleÚorig_handler   r   r   Ú_update_propN   s    
zHandlerBase._update_propc                 C   s   |  |¡ d S r   )r   r   r   r   r   r   T   s    z HandlerBase._default_update_propc                 C   s.   |   ||¡ | |¡ | d ¡ | d ¡ d S r   )r   Z_set_artist_propsÚset_clip_boxÚset_clip_path©r   r   r   Úlegendr   r   r   Úupdate_propW   s    

zHandlerBase.update_propc                 C   sD   || j |  }|| j|  }|| j |  }|| j|  }||||fS r   )r   r   )r   r   r   ÚxdescentÚydescentÚwidthÚheightÚfontsizer   r   r   Úadjust_drawing_area_   s
    zHandlerBase.adjust_drawing_areac                 C   s^   |   |||j|j|j|j|¡\}}}}|  |||||||| ¡ ¡}	|	D ]}
| |
¡ qF|	d S )a-  
        Return the artist that this HandlerBase generates for the given
        original artist/handle.

        Parameters
        ----------
        legend : `~matplotlib.legend.Legend`
            The legend for which these legend artists are being created.
        orig_handle : :class:`matplotlib.artist.Artist` or similar
            The object for which these legend artists are being created.
        fontsize : int
            The fontsize in pixels. The artists being created should
            be scaled according to the given fontsize.
        handlebox : `matplotlib.offsetbox.OffsetBox`
            The box which has been created to hold this legend entry's
            artists. Artists created in the `legend_artist` method must
            be added to this handlebox inside this method.

        r   )r&   r!   r"   r#   r$   Úcreate_artistsZget_transformZ
add_artist)r   r   r   r%   Z	handleboxr!   r"   r#   r$   ÚartistsÚar   r   r   Úlegend_artisth   s(       ü    þzHandlerBase.legend_artistc	           	      C   s   t dƒ‚dS )a“  
        Return the legend artists generated.

        Parameters
        ----------
        legend : `~matplotlib.legend.Legend`
            The legend for which these legend artists are being created.
        orig_handle : `~matplotlib.artist.Artist` or similar
            The object for which these legend artists are being created.
        xdescent, ydescent, width, height : int
            The rectangle (*xdescent*, *ydescent*, *width*, *height*) that the
            legend artists being created should fit within.
        fontsize : int
            The fontsize in pixels. The legend artists being created should
            be scaled according to the given fontsize.
        trans :  `~matplotlib.transforms.Transform`
            The transform that is applied to the legend artists being created.
            Typically from unit coordinates in the handler box to screen
            coordinates.
        zDerived must overrideN)ÚNotImplementedError)	r   r   r   r!   r"   r#   r$   r%   Útransr   r   r   r'   �   s    zHandlerBase.create_artists)r   r   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r   r   r    r&   r*   r'   r   r   r   r   r   .   s   
	%r   c                       s2   e Zd ZdZd
‡ fdd„	Zdd„ Zdd	„ Z‡  ZS )ÚHandlerNpointszM
    A legend handler that shows *numpoints* points in the legend entry.
    ç333333Ó?Nc                    s   t ƒ jf |Ž || _|| _dS )a  
        Parameters
        ----------
        marker_pad : float
            Padding between points in legend entry.
        numpoints : int
            Number of points to show in legend entry.
        **kwargs
            Keyword arguments forwarded to `.HandlerBase`.
        N)Úsuperr   Ú
_numpointsÚ_marker_pad)r   Ú
marker_padÚ	numpointsÚkwargs©Ú	__class__r   r   r   ¬   s    zHandlerNpoints.__init__c                 C   s   | j d kr|jS | j S d S r   )r4   r7   ©r   r   r   r   r   Úget_numpoints¼   s    
zHandlerNpoints.get_numpointsc                 C   sh   |   |¡}|dkr@| j| }t | | | | | |¡}	|	}
n | | | g}	| d|  g}
|	|
fS )Né   ç      à?)r<   r5   ÚnpÚlinspace)r   r   r!   r"   r#   r$   r%   r7   ÚpadÚxdataÚxdata_markerr   r   r   Ú	get_xdataÂ   s    

þzHandlerNpoints.get_xdata)r2   N)r-   r.   r/   r0   r   r<   rD   Ú__classcell__r   r   r9   r   r1   §   s   r1   c                       s*   e Zd ZdZd‡ fdd„	Zdd„ Z‡  ZS )ÚHandlerNpointsYoffsetsz‚
    A legend handler that shows *numpoints* in the legend, and allows them to
    be individually offset in the y-direction.
    Nc                    s    t ƒ jf d|i|—Ž || _dS )aL  
        Parameters
        ----------
        numpoints : int
            Number of points to show in legend entry.
        yoffsets : array of floats
            Length *numpoints* list of y offsets for each point in
            legend entry.
        **kwargs
            Keyword arguments forwarded to `.HandlerNpoints`.
        r7   N)r3   r   Ú	_yoffsets)r   r7   Úyoffsetsr8   r9   r   r   r   ×   s    zHandlerNpointsYoffsets.__init__c                 C   s*   | j d kr||j }n|t | j ¡ }|S r   ©rG   Z_scatteryoffsetsr?   Úasarray©r   r   r!   r"   r#   r$   r%   Úydatar   r   r   Ú	get_ydataæ   s    
z HandlerNpointsYoffsets.get_ydata)NN)r-   r.   r/   r0   r   rM   rE   r   r   r9   r   rF   Ñ   s   rF   c                   @   s   e Zd ZdZdd„ ZdS )ÚHandlerLine2DCompoundz™
    Original handler for `.Line2D` instances, that relies on combining
    a line-only with a marker-only artist.  May be deprecated in the future.
    c	                 C   sÊ   |   ||||||¡\}	}
t |	|| d ¡}t|	|ƒ}|  |||¡ | d¡ | d¡ t|
|d t|
ƒ… ƒ}|  |||¡ | d¡ |j	dkr¨| 
¡ |j	 }| |¡ ||_| |¡ | |¡ ||gS )Né   ÚdefaultÚ ÚNoner=   )rD   r?   Ú	full_liker   r    Úset_drawstyleÚ
set_markerÚlenÚset_linestyleÚmarkerscaleÚget_markersizeÚset_markersizeZ
_legmarkerÚset_transform)r   r   r   r!   r"   r#   r$   r%   r,   rB   rC   rL   ÚleglineÚlegline_markerÚnewszr   r   r   r'   õ   s(    
  ÿ







z$HandlerLine2DCompound.create_artistsN©r-   r.   r/   r0   r'   r   r   r   r   rN   ï   s   rN   c                   @   s   e Zd ZdZdd„ ZdS )ÚHandlerLine2Dzâ
    Handler for `.Line2D` instances.

    See Also
    --------
    HandlerLine2DCompound : An earlier handler implementation, which used one
                            artist for the line and another for the marker(s).
    c	                 C   s¨   |   ||||||¡\}	}
d }|  |¡dkrFt |	d |	d d¡}	dg}t |	|| d ¡}t|	||d�}|  |||¡ |jdkr˜| ¡ |j }| 	|¡ | 
|¡ |gS )Nr=   r   éÿÿÿÿé   rO   )Ú	markevery)rD   r<   r?   r@   rS   r   r    rX   rY   rZ   r[   )r   r   r   r!   r"   r#   r$   r%   r,   rB   rC   rc   rL   r\   r^   r   r   r   r'     s"    
  ÿ


zHandlerLine2D.create_artistsNr_   r   r   r   r   r`     s   	r`   c                       s2   e Zd ZdZd	‡ fdd„	Zdd„ Zdd„ Z‡  ZS )
ÚHandlerPatchz)
    Handler for `.Patch` instances.
    Nc                    s   t ƒ jf |Ž || _dS )a†  
        Parameters
        ----------
        patch_func : callable, optional
            The function that creates the legend key artist.
            *patch_func* should have the signature::

                def patch_func(legend=legend, orig_handle=orig_handle,
                               xdescent=xdescent, ydescent=ydescent,
                               width=width, height=height, fontsize=fontsize)

            Subsequently, the created artist will have its ``update_prop``
            method called and the appropriate transform will be applied.

        **kwargs
            Keyword arguments forwarded to `.HandlerBase`.
        N)r3   r   Ú_patch_func)r   Z
patch_funcr8   r9   r   r   r   @  s    zHandlerPatch.__init__c           	   	   C   s>   | j d kr"t| | f||d�}n| j |||||||d�}|S )N©Úxyr#   r$   )r   r   r!   r"   r#   r$   r%   )re   r   )	r   r   r   r!   r"   r#   r$   r%   Úpr   r   r   Ú_create_patchU  s    
 ÿ   þzHandlerPatch._create_patchc	           
   	   C   s4   |   |||||||¡}	|  |	||¡ |	 |¡ |	gS r   )ri   r    r[   ©
r   r   r   r!   r"   r#   r$   r%   r,   rh   r   r   r   r'   `  s        ÿ
zHandlerPatch.create_artists)N)r-   r.   r/   r0   r   ri   r'   rE   r   r   r9   r   rd   ;  s   rd   c                   @   s0   e Zd ZdZedd„ ƒZedd„ ƒZdd„ ZdS )	ÚHandlerStepPatchzA
    Handler for `~.matplotlib.patches.StepPatch` instances.
    c                 C   s   t | | f|||  ¡ d�S )N)rg   r#   r$   Úcolor)r   Úget_facecolor)r   r!   r"   r#   r$   r   r   r   ri   o  s     ÿzHandlerStepPatch._create_patchc                 C   sF   t d|g|d |d g|  ¡ |  ¡ |  ¡ d�}| d¡ | d¡ |S )Nr   rO   )rl   Z	linestyleZ	linewidthrP   rQ   )r   Úget_edgecolorÚget_linestyleZget_linewidthrT   rU   )r   r#   r$   r\   r   r   r   Ú_create_linet  s    ý

zHandlerStepPatch._create_linec	           
      C   sT   |  ¡ s| ¡ d k	r6|  |||||¡}	|  |	||¡ n|  |||¡}	|	 |¡ |	gS r   )Úget_fillÚ	get_hatchri   r    rp   r[   rj   r   r   r   r'   ‚  s    ÿ
zHandlerStepPatch.create_artistsN)r-   r.   r/   r0   Ústaticmethodri   rp   r'   r   r   r   r   rk   j  s   

rk   c                   @   s(   e Zd ZdZdd„ Zdd„ Zdd„ ZdS )	ÚHandlerLineCollectionz2
    Handler for `.LineCollection` instances.
    c                 C   s   | j d kr|jS | j S d S r   ©r4   Zscatterpointsr;   r   r   r   r<   “  s    
z#HandlerLineCollection.get_numpointsc                 C   sD   |  ¡ d }|jd }| ¡ d }| |¡ | |¡ | |¡ d S ©Nr   )Úget_linewidthsZ_us_linestylesZ
get_colorsÚ	set_colorrW   Úset_linewidth)r   r   r   ZlwÚdashesrl   r   r   r   r   ™  s    


z*HandlerLineCollection._default_update_propc	                 C   sT   |   ||||||¡\}	}
t |	|| d ¡}t|	|ƒ}|  |||¡ | |¡ |gS )NrO   )rD   r?   rS   r   r    r[   )r   r   r   r!   r"   r#   r$   r%   r,   rB   rC   rL   r\   r   r   r   r'   ¡  s    
  ÿ

z$HandlerLineCollection.create_artistsN)r-   r.   r/   r0   r<   r   r'   r   r   r   r   rt   �  s   rt   c                       sX   e Zd ZdZd‡ fdd„	Zdd„ Zdd„ Zd	d
„ Ze 	ddd¡dd„ ƒZ
dd„ Z‡  ZS )ÚHandlerRegularPolyCollectionz'Handler for `.RegularPolyCollection`\s.Nc                    s    t ƒ jf d|i|—Ž || _d S )NrH   )r3   r   Ú_sizes)r   rH   Úsizesr8   r9   r   r   r   ²  s    z%HandlerRegularPolyCollection.__init__c                 C   s   | j d kr|jS | j S d S r   ru   r;   r   r   r   r<   ·  s    
z*HandlerRegularPolyCollection.get_numpointsc                 C   sœ   | j d kr’| ¡ }t|ƒs dg}t|ƒ|jd  }	t|ƒ|jd  }
|  |¡}|dk rrd|	|
  |	|
gd |… }q˜|	|
 }|t dd|¡ |
 }n| j }|S )Nr=   rO   é   r>   r   )	r|   Ú	get_sizesrV   ÚmaxrX   Úminr<   r?   r@   )r   r   r   r!   r"   r#   r$   r%   Zhandle_sizesZsize_maxZsize_minr7   r}   Úrngr   r   r   r   ½  s"    

ÿÿz&HandlerRegularPolyCollection.get_sizesc                 C   s0   |   ||¡ | |j¡ | d ¡ | d ¡ d S r   )r   Ú
set_figureZfigurer   r   r   r   r   r   r    Ò  s    
z(HandlerRegularPolyCollection.update_propú3.6ÚtransOffsetÚoffset_transformc                 C   s   t |ƒ| ¡ | ¡ |||d�S )N)Zrotationr}   Úoffsetsr†   )ÚtypeZget_numsidesZget_rotation©r   r   r}   r‡   r†   r   r   r   Úcreate_collectionÛ  s      ýz.HandlerRegularPolyCollection.create_collectionc	              	   C   s|   |   ||||||¡\}	}
|  ||||||¡}|  |||||||¡}| j||tt|
|ƒƒ|d�}|  |||¡ | |¡ |gS ©N)r‡   r†   )rD   rM   r   rŠ   ÚlistÚzipr    Zset_offset_transform)r   r   r   r!   r"   r#   r$   r%   r,   rB   rC   rL   r}   rh   r   r   r   r'   ã  s0    
  ÿ
  ÿ  ÿ  þ
z+HandlerRegularPolyCollection.create_artists)NN)r-   r.   r/   r0   r   r<   r   r    r   Úrename_parameterrŠ   r'   rE   r   r   r9   r   r{   ¯  s   	
r{   c                   @   s&   e Zd ZdZe ddd¡dd„ ƒZdS )ÚHandlerPathCollectionzDHandler for `.PathCollection`\s, which are used by `~.Axes.scatter`.r„   r…   r†   c                 C   s   t |ƒ| ¡ d g|||d�S )Nr   )r}   r‡   r†   )rˆ   Ú	get_pathsr‰   r   r   r   rŠ   ü  s      þz'HandlerPathCollection.create_collectionN©r-   r.   r/   r0   r   rŽ   rŠ   r   r   r   r   r�   ù  s   r�   c                   @   s&   e Zd ZdZe ddd¡dd„ ƒZdS )ÚHandlerCircleCollectionz"Handler for `.CircleCollection`\s.r„   r…   r†   c                 C   s   t |ƒ|||d�S r‹   )rˆ   r‰   r   r   r   rŠ     s
      ÿz)HandlerCircleCollection.create_collectionNr‘   r   r   r   r   r’     s   r’   c                       s2   e Zd ZdZd‡ fdd„	Zdd„ Zd	d
„ Z‡  ZS )ÚHandlerErrorbarzHandler for Errorbars.r>   Nr2   c                    s(   || _ || _tƒ jf ||dœ|—Ž d S )N)r6   r7   )Ú
_xerr_sizeÚ
_yerr_sizer3   r   )r   Ú	xerr_sizeÚ	yerr_sizer6   r7   r8   r9   r   r   r     s    zHandlerErrorbar.__init__c           	      C   s,   | j | }| jd kr|}n
| j| }||fS r   )r”   r•   )	r   r   r!   r"   r#   r$   r%   r–   r—   r   r   r   Úget_err_size  s
    


zHandlerErrorbar.get_err_sizec	                    s”  |\}	}
}|   ||||||¡\}}t ||| d ¡}t||ƒ}t |¡}t |d t|ƒ… ¡}|  ||||||¡\‰ ‰t||ƒ}|	d kr | d¡ | d¡ n\|  ||	|¡ | 	d¡ | 
d¡ |  ||	|¡ | d¡ |jdkrü| ¡ |j }| |¡ g }g }|j�r¸‡ fdd„t||ƒD ƒ}t |¡}|  ||d	 |¡ | |¡ |
�r¸t|ˆ  |ƒ}t|ˆ  |ƒ}|  ||
d	 |¡ |  ||
d	 |¡ | 
d
¡ | 
d
¡ | |¡ | |¡ |j�rl‡fdd„t||ƒD ƒ}t |¡}|  ||d	 |¡ | |¡ |
�rlt||ˆ ƒ}t||ˆ ƒ}|  ||
d	 |¡ |  ||
d	 |¡ | 
d¡ | 
d¡ | |¡ | |¡ ||||f•}|D ]}| |¡ �q~|S )NrO   FrP   ÚnonerR   r=   c                    s(   g | ] \}}|ˆ  |f|ˆ  |ff‘qS r   r   ©Ú.0ÚxÚy)r–   r   r   Ú
<listcomp>M  s   ÿz2HandlerErrorbar.create_artists.<locals>.<listcomp>r   ú|c                    s(   g | ] \}}||ˆ  f||ˆ  ff‘qS r   r   rš   )r—   r   r   rž   _  s   ÿÚ_)rD   r?   rS   r   rJ   rV   r˜   Zset_visibler    rT   rU   rW   rX   rY   rZ   Zhas_xerrr�   ÚmcollÚLineCollectionÚappendZhas_yerrr[   )r   r   r   r!   r"   r#   r$   r%   r,   Z	plotlinesZcaplinesZbarlinecolsrB   rC   rL   r\   Zydata_markerr]   r^   Zhandle_barlinecolsZhandle_caplinesZvertsZcollZcapline_leftZcapline_rightr(   Úartistr   )r–   r—   r   r'   #  sŠ    

  ÿ


  ÿ







ÿ






ÿ





   ÿzHandlerErrorbar.create_artists)r>   Nr2   N)r-   r.   r/   r0   r   r˜   r'   rE   r   r   r9   r   r“     s       ÿr“   c                       s:   e Zd ZdZd‡ fdd„	Zdd„ Zdd	„ Zd
d„ Z‡  ZS )ÚHandlerStemz6
    Handler for plots produced by `~.Axes.stem`.
    r2   Nc                    s$   t ƒ jf |||dœ|—Ž || _dS )aç  
        Parameters
        ----------
        marker_pad : float, default: 0.3
            Padding between points in legend entry.
        numpoints : int, optional
            Number of points to show in legend entry.
        bottom : float, optional

        yoffsets : array of floats, optional
            Length *numpoints* list of y offsets for each point in
            legend entry.
        **kwargs
            Keyword arguments forwarded to `.HandlerNpointsYoffsets`.
        )r6   r7   rH   N)r3   r   Ú_bottom)r   r6   r7   ÚbottomrH   r8   r9   r   r   r   }  s    ÿÿzHandlerStem.__init__c                 C   s2   | j d kr|d|j d  }n|t | j ¡ }|S )Nr>   rI   rK   r   r   r   rM   ’  s    
zHandlerStem.get_ydatac	              	      sB  |\}	}
}t |
tjƒ}|  ||||||¡\}}|  ||||||¡}| jd krRd‰ n| j‰ t||d t|ƒ… ƒ}|  ||	|¡ ‡ fdd„t	||ƒD ƒ}|rÎt
j| | jd�� |D ]}|  ||
|¡ q®W 5 Q R X n"t	||
ƒD ]\}}|  |||¡ qØtt |¡t |¡gˆ ˆ gƒ}|  |||¡ |||f•}|D ]}| |¡ �q,|S )Nr   c                    s"   g | ]\}}t ||gˆ |gƒ‘qS r   r   rš   ©r§   r   r   rž   ²  s   ÿz.HandlerStem.create_artists.<locals>.<listcomp>)r   )Ú
isinstancer¡   r¢   rD   rM   r¦   r   rV   r    r�   r   Z_setattr_cmÚ_copy_collection_propsr?   r�   r€   r[   )r   r   r   r!   r"   r#   r$   r%   r,   Z
markerlineZ	stemlinesZbaselineZusing_linecollrB   rC   rL   Zleg_markerlineZleg_stemlinesÚlineZlmÚmZleg_baseliner(   r¤   r   r¨   r   r'   š  sJ    

  ÿ
  ÿ

ÿ ÿÿzHandlerStem.create_artistsc                 C   s(   |  | ¡ d ¡ | | ¡ d ¡ dS )zt
        Copy properties from the `.LineCollection` *orig_handle* to the
        `.Line2D` *legend_handle*.
        r   N)rx   Ú	get_colorrW   ro   r   r   r   r   rª   Ê  s    z"HandlerStem._copy_collection_props)r2   NNN)	r-   r.   r/   r0   r   rM   r'   rª   rE   r   r   r9   r   r¥   x  s       ÿ0r¥   c                       s*   e Zd ZdZd‡ fdd„	Zdd„ Z‡  ZS )	ÚHandlerTuplez
    Handler for Tuple.
    r=   Nc                    s   || _ || _tƒ jf |Ž dS )a…  
        Parameters
        ----------
        ndivide : int, default: 1
            The number of sections to divide the legend area into.  If None,
            use the length of the input tuple.
        pad : float, default: :rc:`legend.borderpad`
            Padding in units of fraction of font size.
        **kwargs
            Keyword arguments forwarded to `.HandlerBase`.
        N)Ú_ndivideÚ_padr3   r   )r   ÚndividerA   r8   r9   r   r   r   Ø  s    zHandlerTuple.__init__c	                 C   s¼   |  ¡ }	| jd krt|ƒ}
n| j}
| jd kr8|j| }n
| j| }|
dkr^|||
d   |
 }t||| t |
¡  ƒ}g }|D ]6}| |	|¡}| 	||t
|ƒ|||||¡}| |¡ q€|S )Nr=   )Zget_legend_handler_mapr¯   rV   r°   Z	borderpadr   r?   ZarangeZget_legend_handlerr'   r	   Úextend)r   r   r   r!   r"   r#   r$   r%   r,   Zhandler_mapr±   rA   Z	xds_cycleÚa_listZhandle1ÚhandlerZ_a_listr   r   r   r'   è  s2    



      þzHandlerTuple.create_artists)r=   N)r-   r.   r/   r0   r   r'   rE   r   r   r9   r   r®   Ó  s   r®   c                   @   s    e Zd ZdZdd„ Zdd„ ZdS )ÚHandlerPolyCollectionza
    Handler for `.PolyCollection` used in `~.Axes.fill_between` and
    `~.Axes.stackplot`.
    c                 C   s    dd„ }dd„ }||  ¡ ƒ|_|| ¡ ƒ|_|j|_|j|_| ¡ |_| ¡ |_	|j
|_
| || ¡ ƒ¡ | || ¡ ƒ¡ | || ¡ ƒ¡ | | ¡ ¡ d S )Nc                 S   s   | j dkrdS t| d ƒS )Nr   )r   r   r   r   )ÚsizeÚtuple)Úcolorsr   r   r   Úfirst_color  s    
z7HandlerPolyCollection._update_prop.<locals>.first_colorc                 S   s   t | ƒr| d S d S d S rv   )rV   )Z
prop_arrayr   r   r   Ú	get_first  s    z5HandlerPolyCollection._update_prop.<locals>.get_first)rm   Z
_facecolorrn   Z
_edgecolorZ_original_facecolorZ_original_edgecolorrq   Z_fillrr   Z_hatchZ_hatch_colorry   rw   rW   Zget_linestylesr[   Zget_transformsrƒ   Z
get_figure)r   r   r   r¹   rº   r   r   r   r     s    

z"HandlerPolyCollection._update_propc	           
      C   s4   t | | f||d�}	|  |	||¡ |	 |¡ |	gS )Nrf   )r   r    r[   rj   r   r   r   r'   *  s     ÿ
z$HandlerPolyCollection.create_artistsN)r-   r.   r/   r0   r   r'   r   r   r   r   rµ     s   rµ   )r0   Ú	itertoolsr   Únumpyr?   Z
matplotlibr   r   Zmatplotlib.linesr   Zmatplotlib.patchesr   Zmatplotlib.collectionsÚcollectionsr¡   r   r   r1   rF   rN   r`   rd   rk   rt   r{   r�   r’   r“   r¥   r®   rµ   r   r   r   r   Ú<module>   s,   y*%'/% J	k[5